Files
CLIProxyAPI/internal/runtime/executor/codex_websockets_duplex_test.go
sususu98 61f1ad5e3e fix(codex): support local compaction for compatible Responses endpoints
Handle compaction triggers and capsule replay locally for is-compat models while preserving native Codex behavior. Harden duplex cancellation, event ordering, response ownership, settings inheritance, model aliases, and credential failure classification.

Add HTTP, streaming, duplex, handler, usage, and deterministic concurrency regression coverage.

Fixes #7406
2026-11-10 19:22:38 +08:00

658 lines
28 KiB
Go

package executor
import (
"bytes"
"context"
"fmt"
"net/http"
"net/http/httptest"
"sync/atomic"
"testing"
"time"
"github.com/MoeForge/moego/ojson"
"github.com/gorilla/websocket"
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
core "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
coreusage "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/usage"
sdktranslator "github.com/router-for-me/CLIProxyAPI/v8/sdk/translator"
)
// The upstream deliberately cannot finish the initial response until it reads
// steering. A serial request/response proxy deadlocks this test.
func TestCodexDuplexSteeringLifecycle(t *testing.T) {
for _, boundary := range []string{"response.incomplete", "response.completed"} {
t.Run(boundary, func(t *testing.T) {
var connections atomic.Int32
serverErrors := make(chan error, 1)
serverDone := make(chan struct{})
steer := []byte(`{"type":"response.steer","previous_response_id":"r1","input":[{"role":"user","content":[{"type":"input_text","text":"STEER_OK"}]}]}`)
accepted := []byte(`{"type":"response.steer.accepted","sequence_number":2,"steer":{"id":"s1","previous_response_id":"r1"}}`)
pending := []byte(`{"type":"response.steer.pending","sequence_number":8,"steer":{"id":"s2","previous_response_id":"r2"},"reason":"waiting_for_required_input","required_input":[{"type":"function_call_output","call_id":"c1","name":"lookup"}]}`)
failed := []byte(`{"type":"response.steer.failed","sequence_number":14,"steer":{"id":"s3","previous_response_id":"missing","input":"recover me"},"error":{"code":"response_not_found","message":"missing response"}}`)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer close(serverDone)
connections.Add(1)
conn, err := (&websocket.Upgrader{}).Upgrade(w, r, nil)
if err != nil {
serverErrors <- err
return
}
defer func() { _ = conn.Close() }()
// Timeouts are test failure bounds only; no production network deadline is added.
_ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
read := func() []byte {
_, b, err := conn.ReadMessage()
if err != nil {
t.Errorf("upstream read: %v", err)
}
return b
}
write := func(b []byte) {
if err := conn.WriteMessage(websocket.TextMessage, b); err != nil {
t.Errorf("upstream write: %v", err)
}
}
first := read()
if ojson.GetBytes(first, "type").String() != "response.create" {
t.Errorf("initial create: %s", first)
}
write([]byte(`{"type":"response.created","response":{"id":"r1","output":[]}}`))
if got := read(); !bytes.Equal(got, steer) {
t.Errorf("steer transformed: %s", got)
}
write(accepted)
write([]byte(fmt.Sprintf(`{"type":%q,"response":{"id":"r1","output":[],"incomplete_details":{"reason":"steered"}}}`, boundary)))
write([]byte(`{"type":"response.created","response":{"id":"r2","output":[]}}`))
got := read()
if ojson.GetBytes(got, "type").String() != "response.steer" {
t.Errorf("second control: %s", got)
}
write([]byte(`{"type":"response.steer.accepted","steer":{"id":"s2","previous_response_id":"r2"}}`))
write([]byte(`{"type":"response.completed","response":{"id":"r2","output":[{"type":"function_call","call_id":"c1","name":"lookup","arguments":"{}"}]}}`))
write(pending)
got = read()
if ojson.GetBytes(got, "type").String() != "response.create" || ojson.GetBytes(got, "previous_response_id").String() != "r2" || ojson.GetBytes(got, "input.0.call_id").String() != "c1" {
t.Errorf("tool continuation: %s", got)
}
if ojson.GetBytes(got, "instructions").String() != "New settings" {
t.Errorf("explicit settings not applied: %s", got)
}
write([]byte(`{"type":"response.created","response":{"id":"r3","output":[]}}`))
write([]byte(`{"type":"response.output_item.done","output_index":0,"item":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"STEER_OK"}]}}`))
write([]byte(`{"type":"response.completed","response":{"id":"r3","output":[]}}`))
// Idle steering must also reach the same live upstream connection.
got = read()
if ojson.GetBytes(got, "previous_response_id").String() != "missing" {
t.Errorf("idle control missing: %s", got)
}
write(failed)
// Keep the socket alive until the client closes it; no automatic replay.
_, _, _ = conn.ReadMessage()
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
defer cancel()
input := make(chan core.WebsocketInput, 8)
ctx = core.WithWebsocketInput(core.WithDownstreamWebsocket(ctx), input)
ctx = coreusage.WithRequestedModelAlias(ctx, t.Name())
ctx = coreusage.WithHomeSelection(ctx, coreusage.HomeSelection{Model: "home-route"})
capture := &codexResponseModelUsageCapture{alias: t.Name(), records: make(chan coreusage.Record, 8)}
coreusage.RegisterNamedPlugin(t.Name(), capture)
t.Cleanup(func() { coreusage.RegisterNamedPlugin(t.Name(), codexResponseModelNoopUsagePlugin{}) })
exec := NewCodexWebsocketsExecutor(&config.Config{Codex: config.CodexConfig{ResponseSteering: true}})
exec.store = &codexWebsocketSessionStore{sessions: make(map[string]*codexWebsocketSession)}
auth := &cliproxyauth.Auth{ID: "A", Provider: "codex", Attributes: map[string]string{"api_key": "test-key", "base_url": server.URL, "websockets": "true"}}
req := core.Request{Model: "gpt-6-astra", Payload: []byte(`{"model":"gpt-6-astra","input":[],"instructions":"Initial settings"}`)}
opts := core.Options{SourceFormat: sdktranslator.FromString("codex"), Metadata: map[string]any{core.ExecutionSessionMetadataKey: "duplex-test"}}
result, err := exec.ExecuteStream(ctx, auth, req, opts)
if err != nil {
t.Fatal(err)
}
seen := map[string]bool{}
for !seen["failed"] {
select {
case chunk, ok := <-result.Chunks:
if !ok {
t.Fatal("stream ended before all responses")
}
if chunk.Err != nil {
t.Fatal(chunk.Err)
}
event := ojson.GetBytes(chunk.Payload, "type").String()
id := ojson.GetBytes(chunk.Payload, "response.id").String()
switch {
case event == "response.created" && id == "r1":
input <- core.WebsocketInput{Payload: steer}
case event == "response.steer.accepted" && ojson.GetBytes(chunk.Payload, "steer.id").String() == "s1":
if !bytes.Equal(chunk.Payload, accepted) {
t.Fatal("accepted event changed")
}
seen["accepted"] = true
case event == boundary && id == "r1":
seen["boundary"] = true
case event == "response.created" && id == "r2":
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.steer","previous_response_id":"r2","input":"Use tool result"}`)}
case event == "response.steer.pending":
if !bytes.Equal(chunk.Payload, pending) {
t.Fatal("pending event changed")
}
seen["pending"] = true
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.create","previous_response_id":"r2","instructions":"New settings","input":[{"type":"function_call_output","call_id":"c1","output":"ok"}]}`)}
case event == "response.completed" && id == "r3":
if ojson.GetBytes(chunk.Payload, "response.output.0.content.0.text").String() != "STEER_OK" {
t.Fatal("successor output missing or contaminated by preceding response")
}
seen["successor"] = true
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.steer","previous_response_id":"missing","input":"recover me"}`)}
case event == "response.steer.failed":
if !bytes.Equal(chunk.Payload, failed) {
t.Fatal("failed input changed")
}
seen["failed"] = true
}
case <-ctx.Done():
t.Fatal(ctx.Err())
}
}
cancel()
select {
case <-serverDone:
case <-time.After(3 * time.Second):
t.Fatal("upstream did not close")
}
for range result.Chunks {
}
if connections.Load() != 1 {
t.Fatalf("connections=%d", connections.Load())
}
ids := make(map[string]bool)
for turn := range 3 {
record := capture.await(t)
if record.HomeSelection == nil || record.HomeSelection.Reused != (turn > 0) || record.HomeSelection.Model != "home-route" {
t.Fatalf("turn %d accounting=%+v", turn, record.HomeSelection)
}
if ids[record.RequestID] {
t.Fatal("duplex responses share an execution ID")
}
ids[record.RequestID] = true
}
for _, key := range []string{"accepted", "boundary", "pending", "successor", "failed"} {
if !seen[key] {
t.Fatalf("missing %s", key)
}
}
select {
case err := <-serverErrors:
t.Fatal(err)
default:
}
})
}
}
func TestCodexDuplexSIWCSteerStripsConfigurationUpdates(t *testing.T) {
captured := make(chan []byte, 1)
serverDone := make(chan struct{})
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer close(serverDone)
conn, errUpgrade := (&websocket.Upgrader{}).Upgrade(w, r, nil)
if errUpgrade != nil {
t.Errorf("upgrade websocket: %v", errUpgrade)
return
}
defer func() { _ = conn.Close() }()
// This deadline bounds test failures only.
_ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
_, first, errRead := conn.ReadMessage()
if errRead != nil {
t.Errorf("read initial create: %v", errRead)
return
}
if ojson.GetBytes(first, "type").String() != "response.create" {
t.Errorf("initial create: %s", first)
}
if errWrite := conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"r1","output":[]}}`)); errWrite != nil {
t.Errorf("write response.created: %v", errWrite)
return
}
_, steer, errSteer := conn.ReadMessage()
if errSteer != nil {
t.Errorf("read steer: %v", errSteer)
return
}
captured <- steer
for _, event := range []string{
`{"type":"response.steer.accepted","steer":{"id":"s1","previous_response_id":"r1"}}`,
`{"type":"response.completed","response":{"id":"r1","output":[]}}`,
} {
if errWrite := conn.WriteMessage(websocket.TextMessage, []byte(event)); errWrite != nil {
t.Errorf("write event: %v", errWrite)
return
}
}
_, _, _ = conn.ReadMessage()
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
defer cancel()
input := make(chan core.WebsocketInput, 1)
ctx = core.WithWebsocketInput(core.WithDownstreamWebsocket(ctx), input)
exec := NewCodexWebsocketsExecutor(&config.Config{Codex: config.CodexConfig{ResponseSteering: true}})
exec.store = &codexWebsocketSessionStore{sessions: make(map[string]*codexWebsocketSession)}
req := core.Request{
Model: "gpt-6-astra",
Payload: []byte(`{"model":"gpt-6-astra","input":[{"type":"message","role":"user","content":[{"type":"input_text","text":"hi"}]}],"instructions":"Initial settings"}`),
}
opts := core.Options{SourceFormat: sdktranslator.FromString("codex"), Metadata: map[string]any{core.ExecutionSessionMetadataKey: "duplex-siwc-steer"}}
result, err := exec.ExecuteStream(ctx, codexSIWCAuthForUpdateTest(server.URL), req, opts)
if err != nil {
t.Fatal(err)
}
completed := false
for !completed {
select {
case chunk, ok := <-result.Chunks:
if !ok {
t.Fatal("stream ended before response.completed")
}
if chunk.Err != nil {
t.Fatal(chunk.Err)
}
event := ojson.GetBytes(chunk.Payload, "type").String()
id := ojson.GetBytes(chunk.Payload, "response.id").String()
if event == "response.created" && id == "r1" {
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.steer","previous_response_id":"r1","input":[{"type":"configuration_update","reasoning":{"effort":"high"}},{"role":"user","content":[{"type":"input_text","text":"STEER_OK"}]}]}`)}
}
completed = event == "response.completed" && id == "r1"
case <-ctx.Done():
t.Fatal(ctx.Err())
}
}
cancel()
for range result.Chunks {
}
select {
case <-serverDone:
case <-time.After(3 * time.Second):
t.Fatal("upstream did not close")
}
select {
case got := <-captured:
if ojson.GetBytes(got, "type").String() != "response.steer" || ojson.GetBytes(got, "previous_response_id").String() != "r1" {
t.Fatalf("steer routing changed: %s", got)
}
items := ojson.GetBytes(got, "input").Array()
if len(items) != 1 || items[0].Get("role").String() != "user" || items[0].Get("content.0.text").String() != "STEER_OK" {
t.Fatalf("steer input must contain only the user message: %s", got)
}
if ojson.GetBytes(got, "reasoning").Exists() {
t.Fatalf("steer must not promote reasoning: %s", got)
}
if ojson.GetBytes(got, "store").Exists() || ojson.GetBytes(got, "stream").Exists() {
t.Fatalf("steer must not inherit response.create defaults: %s", got)
}
default:
t.Fatal("upstream steer was not captured")
}
}
func TestCodexDuplexAppendInheritsContextAndInstructions(t *testing.T) {
serverDone := make(chan struct{})
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer close(serverDone)
conn, err := (&websocket.Upgrader{}).Upgrade(w, r, nil)
if err != nil {
t.Error(err)
return
}
defer func() { _ = conn.Close() }()
_ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
// 1. Read initial create
_, first, err := conn.ReadMessage()
if err != nil {
t.Errorf("read first create: %v", err)
return
}
if ojson.GetBytes(first, "instructions").String() != "Initial system instructions" {
t.Errorf("first instructions = %q", ojson.GetBytes(first, "instructions").String())
}
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"resp-1","output":[]}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.completed","response":{"id":"resp-1","output":[]}}`))
// 2. Read subsequent append (which client sent omitting previous_response_id, model, and instructions)
_, second, err := conn.ReadMessage()
if err != nil {
t.Errorf("read second create (from append): %v", err)
return
}
if got := ojson.GetBytes(second, "type").String(); got != "response.create" {
t.Errorf("second type = %q, want response.create", got)
}
if got := ojson.GetBytes(second, "previous_response_id").String(); got != "resp-1" {
t.Errorf("second previous_response_id = %q, want resp-1", got)
}
if got := ojson.GetBytes(second, "model").String(); got != "gpt-6-astra" {
t.Errorf("second model = %q, want gpt-6-astra", got)
}
if got := ojson.GetBytes(second, "instructions").String(); got != "Initial system instructions" {
t.Errorf("second instructions = %q, want 'Initial system instructions'", got)
}
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"resp-2","output":[]}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.completed","response":{"id":"resp-2","output":[]}}`))
_, _, _ = conn.ReadMessage()
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
input := make(chan core.WebsocketInput, 4)
ctx = core.WithWebsocketInput(core.WithDownstreamWebsocket(ctx), input)
exec := NewCodexWebsocketsExecutor(&config.Config{Codex: config.CodexConfig{ResponseSteering: true}})
exec.store = &codexWebsocketSessionStore{sessions: make(map[string]*codexWebsocketSession)}
auth := &cliproxyauth.Auth{ID: "append-test-auth", Provider: "codex", Attributes: map[string]string{"api_key": "test-key", "base_url": server.URL, "websockets": "true"}}
req := core.Request{
Model: "gpt-6-astra",
Payload: []byte(`{"model":"gpt-6-astra","input":[{"role":"user","content":"turn 1"}],"instructions":"Initial system instructions"}`),
}
opts := core.Options{SourceFormat: sdktranslator.FromString("codex"), Metadata: map[string]any{core.ExecutionSessionMetadataKey: "append-test"}}
result, err := exec.ExecuteStream(ctx, auth, req, opts)
if err != nil {
t.Fatal(err)
}
for chunk := range result.Chunks {
if chunk.Err != nil {
t.Fatal(chunk.Err)
}
eventType := ojson.GetBytes(chunk.Payload, "type").String()
eventID := ojson.GetBytes(chunk.Payload, "response.id").String()
if eventType == "response.completed" && eventID == "resp-1" {
// Client sends response.append omitting previous_response_id, model, instructions
appendPayload := []byte(`{"type":"response.append","input":[{"role":"user","content":"turn 2"}]}`)
input <- core.WebsocketInput{Payload: appendPayload}
}
if eventType == "response.completed" && eventID == "resp-2" {
cancel()
break
}
}
select {
case <-serverDone:
case <-time.After(3 * time.Second):
t.Fatal("server did not finish")
}
}
func TestCodexDuplexStandaloneCreateDoesNotInheritParentID(t *testing.T) {
serverDone := make(chan struct{})
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer close(serverDone)
conn, err := (&websocket.Upgrader{}).Upgrade(w, r, nil)
if err != nil {
t.Error(err)
return
}
defer func() { _ = conn.Close() }()
_ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
// 1. Read first create
_, _, err = conn.ReadMessage()
if err != nil {
t.Errorf("read first create: %v", err)
return
}
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"resp-1","output":[]}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.completed","response":{"id":"resp-1","output":[]}}`))
// 2. Read second create (standalone / full history replacement without previous_response_id)
_, second, err := conn.ReadMessage()
if err != nil {
t.Errorf("read second create: %v", err)
return
}
if got := ojson.GetBytes(second, "type").String(); got != "response.create" {
t.Errorf("second type = %q, want response.create", got)
}
if ojson.GetBytes(second, "previous_response_id").Exists() {
t.Errorf("standalone create must not gain previous_response_id: %s", second)
}
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"resp-2","output":[]}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.completed","response":{"id":"resp-2","output":[]}}`))
_, _, _ = conn.ReadMessage()
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
input := make(chan core.WebsocketInput, 4)
ctx = core.WithWebsocketInput(core.WithDownstreamWebsocket(ctx), input)
exec := NewCodexWebsocketsExecutor(&config.Config{Codex: config.CodexConfig{ResponseSteering: true}})
exec.store = &codexWebsocketSessionStore{sessions: make(map[string]*codexWebsocketSession)}
auth := &cliproxyauth.Auth{ID: "standalone-create-test", Provider: "codex", Attributes: map[string]string{"api_key": "test-key", "base_url": server.URL, "websockets": "true"}}
req := core.Request{
Model: "gpt-6-astra",
Payload: []byte(`{"model":"gpt-6-astra","input":[{"role":"user","content":"turn 1"}]}`),
}
opts := core.Options{SourceFormat: sdktranslator.FromString("codex"), Metadata: map[string]any{core.ExecutionSessionMetadataKey: "standalone-test"}}
result, err := exec.ExecuteStream(ctx, auth, req, opts)
if err != nil {
t.Fatal(err)
}
for chunk := range result.Chunks {
if chunk.Err != nil {
t.Fatal(chunk.Err)
}
eventType := ojson.GetBytes(chunk.Payload, "type").String()
eventID := ojson.GetBytes(chunk.Payload, "response.id").String()
if eventType == "response.completed" && eventID == "resp-1" {
// Client sends standalone response.create without previous_response_id
standalonePayload := []byte(`{"type":"response.create","model":"gpt-6-astra","input":[{"role":"user","content":"turn 2 standalone"}]}`)
input <- core.WebsocketInput{Payload: standalonePayload}
}
if eventType == "response.completed" && eventID == "resp-2" {
cancel()
break
}
}
select {
case <-serverDone:
case <-time.After(3 * time.Second):
t.Fatal("server did not finish")
}
}
func TestCodexDuplexQueuedCreateDoesNotBlockSubsequentSteer(t *testing.T) {
serverDone := make(chan struct{})
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer close(serverDone)
conn, err := (&websocket.Upgrader{}).Upgrade(w, r, nil)
if err != nil {
t.Error(err)
return
}
defer func() { _ = conn.Close() }()
_ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
// 1. Read first create
_, first, err := conn.ReadMessage()
if err != nil {
t.Errorf("read first create: %v", err)
return
}
if ojson.GetBytes(first, "type").String() != "response.create" {
t.Errorf("expected response.create: %s", first)
}
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"r1","output":[]}}`))
// Read first steer for r1
_, steer1, err := conn.ReadMessage()
if err != nil {
t.Errorf("read steer1: %v", err)
return
}
if ojson.GetBytes(steer1, "type").String() != "response.steer" {
t.Errorf("expected response.steer: %s", steer1)
}
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.steer.accepted","steer":{"id":"s1","previous_response_id":"r1"}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.incomplete","response":{"id":"r1","output":[],"incomplete_details":{"reason":"steered"}}}`))
// Emit automatic successor (sets automaticActive = true)
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"auto-1","previous_response_id":"r1","output":[]}}`))
// Client will send next create (blocked by automaticActive) followed by steer for auto-1.
// Upstream expects steering to arrive NEXT, proving create did not block the steer!
_, steerFrame, err := conn.ReadMessage()
if err != nil {
t.Errorf("read steer: %v", err)
return
}
if got := ojson.GetBytes(steerFrame, "type").String(); got != "response.steer" {
t.Errorf("expected response.steer to arrive before blocked create, got: %s", steerFrame)
return
}
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.steer.accepted","steer":{"id":"s2","previous_response_id":"auto-1"}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.completed","response":{"id":"auto-1","output":[]}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"auto-2","previous_response_id":"auto-1","output":[]}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.completed","response":{"id":"auto-2","output":[]}}`))
// Now that automatic successor is completed, the queued create is delivered to upstream
_, nextCreate, err := conn.ReadMessage()
if err != nil {
t.Errorf("read queued create: %v", err)
return
}
if got := ojson.GetBytes(nextCreate, "type").String(); got != "response.create" {
t.Errorf("queued create type = %q, want response.create", got)
}
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.created","response":{"id":"r2","output":[]}}`))
_ = conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.completed","response":{"id":"r2","output":[]}}`))
_, _, _ = conn.ReadMessage()
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
input := make(chan core.WebsocketInput, 8)
ctx = core.WithWebsocketInput(core.WithDownstreamWebsocket(ctx), input)
exec := NewCodexWebsocketsExecutor(&config.Config{Codex: config.CodexConfig{ResponseSteering: true}})
exec.store = &codexWebsocketSessionStore{sessions: make(map[string]*codexWebsocketSession)}
auth := &cliproxyauth.Auth{ID: "steer-blocking-test", Provider: "codex", Attributes: map[string]string{"api_key": "test-key", "base_url": server.URL, "websockets": "true"}}
req := core.Request{
Model: "gpt-6-astra",
Payload: []byte(`{"model":"gpt-6-astra","input":[{"role":"user","content":"start"}]}`),
}
opts := core.Options{SourceFormat: sdktranslator.FromString("codex"), Metadata: map[string]any{core.ExecutionSessionMetadataKey: "steer-block-test"}}
result, err := exec.ExecuteStream(ctx, auth, req, opts)
if err != nil {
t.Fatal(err)
}
for chunk := range result.Chunks {
if chunk.Err != nil {
t.Fatal(chunk.Err)
}
eventType := ojson.GetBytes(chunk.Payload, "type").String()
eventID := ojson.GetBytes(chunk.Payload, "response.id").String()
if eventType == "response.created" && eventID == "r1" {
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.steer","previous_response_id":"r1","input":"steer 1"}`)}
}
if eventType == "response.created" && eventID == "auto-1" {
// During automatic successor generation, send a create first, followed by steer:
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.create","model":"gpt-6-astra","previous_response_id":"auto-1","input":[{"role":"user","content":"queued next"}]}`)}
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.steer","previous_response_id":"auto-1","input":"steer 2 in flight"}`)}
}
if eventType == "response.completed" && eventID == "r2" {
cancel()
break
}
}
select {
case <-serverDone:
case <-time.After(3 * time.Second):
t.Fatal("server did not finish")
}
}
func TestCodexDuplexNativeAliasContinuationUsesRealModel(t *testing.T) {
frames := make(chan []byte, 3)
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
c, errUpgrade := (&websocket.Upgrader{}).Upgrade(w, r, nil)
if errUpgrade != nil {
t.Error(errUpgrade)
return
}
defer func() {
if errClose := c.Close(); errClose != nil {
t.Errorf("close upstream websocket: %v", errClose)
}
}()
for i := 0; i < 3; i++ {
_, frame, errRead := c.ReadMessage()
if errRead != nil {
return
}
frames <- frame
for _, payload := range []string{`{"type":"response.created","response":{"id":"r1"}}`, `{"type":"response.completed","response":{"id":"r1","output":[]}}`} {
if errWrite := c.WriteMessage(websocket.TextMessage, []byte(payload)); errWrite != nil {
t.Error(errWrite)
return
}
}
}
_, _, _ = c.ReadMessage()
}))
defer upstream.Close()
cfg := &config.Config{CodexKey: []config.CodexKey{{APIKey: "test-key", BaseURL: upstream.URL, Models: []config.CodexModel{{Name: "real-model", IsCompat: false}}}}}
cfg.Codex.ResponseSteering = true
cfg.CodexResponseSteering = true
exec := NewCodexWebsocketsExecutor(cfg)
defer exec.CloseExecutionSession("native-alias-session")
ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
defer cancel()
input := make(chan core.WebsocketInput, 1)
ctx = core.WithWebsocketInput(core.WithDownstreamWebsocket(ctx), input)
stream, errStream := exec.ExecuteStream(ctx, &cliproxyauth.Auth{ID: "native-alias-account", Provider: "codex", Attributes: map[string]string{"api_key": "test-key", "base_url": upstream.URL, "websockets": "true"}}, core.Request{Model: "real-model", Payload: []byte(`{"model":"client-alias","input":[]}`)}, core.Options{SourceFormat: sdktranslator.FromString("codex"), Metadata: map[string]any{core.ExecutionSessionMetadataKey: "native-alias-session"}})
if errStream != nil {
t.Fatal(errStream)
}
for turn := 0; turn < 3; turn++ {
for {
chunk, ok := <-stream.Chunks
if !ok || chunk.Err != nil {
t.Fatalf("turn %d stream closed or failed: %v", turn, chunk.Err)
}
if ojson.GetBytes(chunk.Payload, "type").String() == "response.completed" {
break
}
}
frame := <-frames
if got := ojson.GetBytes(frame, "model").String(); got != "real-model" {
t.Fatalf("turn %d model = %q, want real-model; frame=%s", turn, got, frame)
}
if turn == 0 {
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.create","model":"client-alias","previous_response_id":"r1","input":"follow up"}`)}
} else if turn == 1 {
input <- core.WebsocketInput{Payload: []byte(`{"type":"response.create","previous_response_id":"r1","input":"follow up again"}`)}
}
}
}