Something went wrong. Try again.
sloproxy
Something went wrong. Try again.
30 kB · 716 lines
Go
at commit 291cfb87
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717package executor
import ( "bytes" "context" "io" "net/http" "net/http/httptest" "strings" "testing" "time"
"github.com/router-for-me/CLIProxyAPI/v7/internal/config" _ "github.com/router-for-me/CLIProxyAPI/v7/internal/translator" cliproxyauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/auth" cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/executor" sdktranslator "github.com/router-for-me/CLIProxyAPI/v7/sdk/translator" "github.com/tidwall/gjson")
func TestCodexExecutorExecute_NonEmptyCompletionOutputHydratesMissingItemID(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte(`data: {"type":"response.output_item.done","item":{"id":"fc_123","type":"function_call","call_id":"call_123","name":"weather","arguments":"{}"},"output_index":0}` + "\n\n")) _, _ = w.Write([]byte(`data: {"type":"response.output_item.done","item":{"id":"fc_done_existing","type":"function_call","call_id":"call_existing","name":"other","arguments":"{}"},"output_index":1}` + "\n\n")) _, _ = w.Write([]byte(`data: {"type":"response.completed","response":{"id":"resp_1","object":"response","status":"completed","output":[{"id":null,"type":"function_call","call_id":"call_123","name":"weather-terminal","arguments":"{}"},{"id":"fc_existing","type":"function_call","call_id":"call_existing","name":"preserved","arguments":"{}"}]}}` + "\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
resp, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.4", Payload: []byte(`{"model":"gpt-5.4","input":"What is the weather?"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: false, }) if err != nil { t.Fatalf("Execute error: %v", err) }
if got := gjson.GetBytes(resp.Payload, "output.0.id").String(); got != "fc_123" { t.Fatalf("output[0].id = %q, want %q; payload=%s", got, "fc_123", resp.Payload) } if got := gjson.GetBytes(resp.Payload, "output.0.name").String(); got != "weather-terminal" { t.Fatalf("output[0].name = %q, want terminal value; payload=%s", got, resp.Payload) } if got := gjson.GetBytes(resp.Payload, "output.1.id").String(); got != "fc_existing" { t.Fatalf("output[1].id = %q, want existing value; payload=%s", got, resp.Payload) }}
func TestCodexExecutorExecute_EmptyStreamCompletionOutputUsesOutputItemDone(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"ok\"}]},\"output_index\":0}\n")) _, _ = w.Write([]byte("data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"object\":\"response\",\"created_at\":1775555723,\"status\":\"completed\",\"model\":\"gpt-5.4-mini-2026-03-17\",\"output\":[],\"usage\":{\"input_tokens\":8,\"output_tokens\":28,\"total_tokens\":36}}}\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
resp, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.4-mini", Payload: []byte(`{"model":"gpt-5.4-mini","messages":[{"role":"user","content":"Say ok"}]}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai"), Stream: false, }) if err != nil { t.Fatalf("Execute error: %v", err) }
gotContent := gjson.GetBytes(resp.Payload, "choices.0.message.content").String() if gotContent != "ok" { t.Fatalf("choices.0.message.content = %q, want %q; payload=%s", gotContent, "ok", string(resp.Payload)) }}
func TestCodexExecutorExecuteSurfacesTerminalStreamError(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("event: response.created\n")) _, _ = w.Write([]byte(`data: {"type":"response.created","response":{"id":"resp_1","model":"gpt-5.5"}}` + "\n\n")) _, _ = w.Write([]byte("event: error\n")) _, _ = w.Write([]byte(`data: {"type":"error","error":{"type":"invalid_request_error","code":"context_length_exceeded","message":"Your input exceeds the context window of this model. Please adjust your input and try again.","param":"input"},"sequence_number":2}` + "\n\n")) _, _ = w.Write([]byte("event: response.failed\n")) _, _ = w.Write([]byte(`data: {"type":"response.failed","response":{"id":"resp_1","status":"failed","error":{"code":"context_length_exceeded","message":"Your input exceeds the context window of this model. Please adjust your input and try again."}}}` + "\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: false, }) if err == nil { t.Fatal("expected terminal stream error, got nil") } if got := statusCodeFromTestError(t, err); got != http.StatusBadRequest { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusBadRequest, err) } assertCodexErrorCode(t, err.Error(), "invalid_request_error", "context_too_large") if !strings.Contains(err.Error(), "Your input exceeds the context window") { t.Fatalf("error message missing upstream context text: %v", err) }}
func TestCodexExecutorExecuteIncompleteResponseIsSuccessful(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte(`data: {"type":"response.incomplete","response":{"id":"resp_1","model":"gpt-5.5","status":"incomplete","incomplete_details":{"reason":"max_output_tokens"},"output":[],"usage":{"input_tokens":10,"output_tokens":5,"total_tokens":15}}}` + "\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
resp, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","messages":[{"role":"user","content":"hello"}]}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), Stream: false, }) if err != nil { t.Fatalf("Execute error: %v", err) } if got := gjson.GetBytes(resp.Payload, "stop_reason").String(); got != "max_tokens" { t.Fatalf("stop_reason = %q, want %q; payload=%s", got, "max_tokens", resp.Payload) }}
func TestCodexExecutorExecuteExplicitTerminalFailureIsNotRequestScoped(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte(`data: {"type":"error","error":{"type":"invalid_request_error","code":"invalid_value","message":"Invalid input."}}` + "\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: false, }) if err == nil { t.Fatal("expected explicit terminal failure, got nil") } if got := statusCodeFromTestError(t, err); got != http.StatusBadRequest { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusBadRequest, err) } assertNotRequestScopedTestError(t, err)}
func TestCodexExecutorExecuteMissingCompletionIsRequestScoped(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_1\",\"model\":\"gpt-5.5\"}}\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: false, }) if err == nil { t.Fatal("expected missing-completion error, got nil") } if got := statusCodeFromTestError(t, err); got != http.StatusRequestTimeout { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusRequestTimeout, err) } assertRequestScopedTestError(t, err)}
func TestCodexExecutorExecuteStreamMissingCompletionIsRequestScoped(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_1\",\"model\":\"gpt-5.5\"}}\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: true, }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) }
var streamErr error for chunk := range result.Chunks { if chunk.Err != nil { streamErr = chunk.Err } } if streamErr == nil { t.Fatal("expected missing-completion stream error, got nil") } if got := statusCodeFromTestError(t, streamErr); got != http.StatusRequestTimeout { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusRequestTimeout, streamErr) } assertRequestScopedTestError(t, streamErr)}
func TestCodexExecutorExecuteStreamExplicitTerminalFailureIsNotSuccessful(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_1\",\"model\":\"gpt-5.5\"}}\n\n")) _, _ = w.Write([]byte(`data: {"type":"error","error":{"type":"invalid_request_error","code":"invalid_value","message":"Invalid input."}}` + "\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: true, }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) }
var streamErr error for chunk := range result.Chunks { if chunk.Err != nil { streamErr = chunk.Err } } if streamErr == nil { t.Fatal("expected explicit terminal stream error, got nil") } if got := statusCodeFromTestError(t, streamErr); got != http.StatusBadRequest { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusBadRequest, streamErr) } assertNotRequestScopedTestError(t, streamErr)}
func TestCodexAutoExecutorHTTPFallbackForwardsSequentialCutoffReasoningSummaryDelivery(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, errRead := io.ReadAll(r.Body) if errRead != nil { t.Errorf("read request body: %v", errRead) return } if gjson.GetBytes(body, "stream_options.include_usage").Exists() { t.Errorf("unsupported stream option was forwarded: %s", body) }
w.Header().Set("Content-Type", "text/event-stream") if delivery := gjson.GetBytes(body, "stream_options.reasoning_summary_delivery").String(); delivery == "sequential_cutoff" { _, _ = w.Write([]byte(`data: {"type":"response.reasoning_summary_text.done","item_id":"rs_1","summary_index":0,"text":"Checking"}` + "\n\n")) } else { _, _ = w.Write([]byte(`data: {"type":"response.reasoning_summary_text.delta","item_id":"rs_1","summary_index":0,"delta":"Checking"}` + "\n\n")) } _, _ = w.Write([]byte(`data: {"type":"response.completed","response":{"id":"resp_1","output":[],"usage":{"input_tokens":1,"output_tokens":1,"total_tokens":2}}}` + "\n\n")) })) defer server.Close()
executor := NewCodexAutoExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }} result, err := executor.ExecuteStream(cliproxyexecutor.WithDownstreamWebsocket(context.Background()), auth, cliproxyexecutor.Request{ Model: "gpt-5.6-sol", Payload: []byte(`{"model":"gpt-5.6-sol","input":"hello","reasoning":{"summary":"detailed"},"stream_options":{"reasoning_summary_delivery":"sequential_cutoff","include_usage":true}}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), ResponseFormat: sdktranslator.FromString("openai-response"), Stream: true, }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) }
var output bytes.Buffer for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("stream error: %v", chunk.Err) } output.Write(chunk.Payload) } if !strings.Contains(output.String(), `"type":"response.reasoning_summary_text.done"`) { t.Fatalf("missing sequential-cutoff summary event; output=%s", output.String()) }}
func TestCodexExecutorTransportFailureBeforeTerminalIsRequestScoped(t *testing.T) { tests := []struct { name string stream bool }{ {name: "non-streaming"}, {name: "streaming", stream: true}, }
for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { created := []byte("data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_1\",\"model\":\"gpt-5.5\"}}\n\n") ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", roundTripperFunc(func(req *http.Request) (*http.Response, error) { return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": {"text/event-stream"}}, Body: io.NopCloser(io.MultiReader(bytes.NewReader(created), unexpectedEOFReader{})), Request: req, }, nil }))
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": "http://codex.test", "api_key": "test", }} req := cliproxyexecutor.Request{Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`)} opts := cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("openai-response"), Stream: tc.stream}
var terminalErr error if tc.stream { result, errStream := executor.ExecuteStream(ctx, auth, req, opts) if errStream != nil { t.Fatalf("ExecuteStream error: %v", errStream) } for chunk := range result.Chunks { if chunk.Err != nil { terminalErr = chunk.Err } } } else { _, terminalErr = executor.Execute(ctx, auth, req, opts) } if terminalErr == nil { t.Fatal("expected transport failure before terminal event") } if got := statusCodeFromTestError(t, terminalErr); got != http.StatusRequestTimeout { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusRequestTimeout, terminalErr) } assertRequestScopedTestError(t, terminalErr) }) }}
func TestCodexExecutorExecuteIgnoresTransportErrorAfterCompletion(t *testing.T) { completed := []byte("data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"model\":\"gpt-5.5\",\"status\":\"completed\",\"output\":[],\"usage\":{\"input_tokens\":1,\"output_tokens\":1,\"total_tokens\":2}}}\n\n") ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", roundTripperFunc(func(req *http.Request) (*http.Response, error) { return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": {"text/event-stream"}}, Body: io.NopCloser(io.MultiReader(bytes.NewReader(completed), unexpectedEOFReader{})), Request: req, }, nil }))
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": "http://codex.test", "api_key": "test", }}
resp, err := executor.Execute(ctx, auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: false, }) if err != nil { t.Fatalf("unexpected error after response.completed: %v", err) } if got := gjson.GetBytes(resp.Payload, "id").String(); got != "resp_1" { t.Fatalf("response id = %q, want resp_1; payload=%s", got, resp.Payload) }}
func TestCodexExecutorExecuteStreamIgnoresTransportErrorAfterCompletion(t *testing.T) { completed := []byte("data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"model\":\"gpt-5.5\",\"output\":[],\"usage\":{\"input_tokens\":1,\"output_tokens\":1,\"total_tokens\":2}}}\n\n") ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", roundTripperFunc(func(req *http.Request) (*http.Response, error) { return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": {"text/event-stream"}}, Body: io.NopCloser(io.MultiReader(bytes.NewReader(completed), unexpectedEOFReader{})), Request: req, }, nil }))
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": "http://codex.test", "api_key": "test", }}
result, err := executor.ExecuteStream(ctx, auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: true, }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) }
var streamErr error for chunk := range result.Chunks { if chunk.Err != nil { streamErr = chunk.Err } } if streamErr != nil { t.Fatalf("unexpected error after response.completed: %v", streamErr) }}
func TestCodexExecutorExecuteStreamSurfacesTerminalStreamError(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("event: response.created\n")) _, _ = w.Write([]byte(`data: {"type":"response.created","response":{"id":"resp_1","model":"gpt-5.5"}}` + "\n\n")) _, _ = w.Write([]byte("event: error\n")) _, _ = w.Write([]byte(`data: {"type":"error","error":{"type":"invalid_request_error","code":"context_length_exceeded","message":"Your input exceeds the context window of this model. Please adjust your input and try again.","param":"input"},"sequence_number":2}` + "\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.5", Payload: []byte(`{"model":"gpt-5.5","input":"hello"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: true, }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) }
var streamErr error for chunk := range result.Chunks { if chunk.Err != nil { streamErr = chunk.Err break } } if streamErr == nil { t.Fatal("missing stream terminal error") } if got := statusCodeFromTestError(t, streamErr); got != http.StatusBadRequest { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusBadRequest, streamErr) } assertCodexErrorCode(t, streamErr.Error(), "invalid_request_error", "context_too_large")}
func TestCodexTerminalStreamContextLengthErrFromResponseFailed(t *testing.T) { err, ok := codexTerminalStreamContextLengthErr([]byte(`{"type":"response.failed","response":{"id":"resp_1","status":"failed","error":{"code":"context_length_exceeded","message":"Your input exceeds the context window of this model. Please adjust your input and try again."}}}`)) if !ok { t.Fatal("expected context length terminal error") } if got := statusCodeFromTestError(t, err); got != http.StatusBadRequest { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusBadRequest, err) } assertCodexErrorCode(t, err.Error(), "invalid_request_error", "context_too_large")}
func TestCodexTerminalStreamContextLengthErrFromTopLevelError(t *testing.T) { err, ok := codexTerminalStreamContextLengthErr([]byte(`{"type":"error","code":"context_length_exceeded","message":"Your input exceeds the context window of this model. Please adjust your input and try again.","sequence_number":2}`)) if !ok { t.Fatal("expected top-level context length terminal error") } if got := statusCodeFromTestError(t, err); got != http.StatusBadRequest { t.Fatalf("status code = %d, want %d; err=%v", got, http.StatusBadRequest, err) } assertCodexErrorCode(t, err.Error(), "invalid_request_error", "context_too_large") if !strings.Contains(err.Error(), "Your input exceeds the context window") { t.Fatalf("error message missing upstream context text: %v", err) }}
func TestCodexTerminalStreamContextLengthErrIgnoresOtherTerminalErrors(t *testing.T) { _, ok := codexTerminalStreamContextLengthErr([]byte(`{"type":"error","error":{"type":"rate_limit_error","code":"rate_limit_exceeded","message":"Rate limit reached."}}`)) if ok { t.Fatal("rate limit terminal error should not be handled by context length fix") }}
func TestCodexTerminalStreamErrIgnoresRateLimitTerminalErrors(t *testing.T) { _, _, ok := codexTerminalStreamErr([]byte(`{"type":"error","error":{"type":"rate_limit_error","code":"rate_limit_exceeded","message":"Rate limit reached."}}`)) if ok { t.Fatal("rate limit terminal error should not be handled by replay terminal error path") }}
func TestCodexTerminalFailureErrClassifiesStatus(t *testing.T) { tests := []struct { name string event string wantStatus int }{ { name: "invalid request", event: `{"type":"error","error":{"type":"invalid_request_error","code":"invalid_value","message":"Invalid input."}}`, wantStatus: http.StatusBadRequest, }, { name: "cyber policy", event: `{"type":"error","error":{"type":"invalid_request","code":"cyber_policy","message":"This content was flagged for possible cybersecurity risk."}}`, wantStatus: http.StatusBadRequest, }, { name: "authentication", event: `{"type":"response.failed","response":{"error":{"type":"authentication_error","code":"invalid_api_key","message":"Invalid token."}}}`, wantStatus: http.StatusUnauthorized, }, { name: "rate limit", event: `{"type":"error","error":{"type":"rate_limit_error","code":"rate_limit_exceeded","message":"Rate limit reached."}}`, wantStatus: http.StatusTooManyRequests, }, { name: "unknown upstream failure", event: `{"type":"response.failed","response":{"error":{"type":"upstream_error","code":"unknown","message":"Upstream failed."}}}`, wantStatus: http.StatusBadGateway, }, // Overload rejections keep falling through to 502 here. The 503 restoration is scoped to // the opt-in bootstrap buffering path so this shared mapping stays unchanged. { name: "overload stays a bad gateway without buffering", event: `{"type":"error","error":{"type":"service_unavailable_error","code":"server_is_overloaded","message":"Our servers are currently overloaded. Please try again later."}}`, wantStatus: http.StatusBadGateway, }, }
for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { streamErr, _, ok := codexTerminalFailureErr([]byte(tc.event)) if !ok { t.Fatal("expected terminal failure to be handled") } if got := streamErr.StatusCode(); got != tc.wantStatus { t.Fatalf("status code = %d, want %d; err=%v", got, tc.wantStatus, streamErr) } }) }}
func TestCodexTerminalStreamErrHandlesUsageLimitErrorEvent(t *testing.T) { streamErr, _, ok := codexTerminalStreamErr([]byte(`{"type":"error","error":{"type":"usage_limit_reached","message":"You've hit your usage limit.","resets_in_seconds":300}}`)) if !ok { t.Fatal("expected usage_limit_reached terminal error to be handled") } if got := statusCodeFromTestError(t, streamErr); got != http.StatusTooManyRequests { t.Fatalf("status code = %d, want %d", got, http.StatusTooManyRequests) } retryAfter := streamErr.RetryAfter() if retryAfter == nil { t.Fatal("expected retryAfter from usage_limit_reached terminal error") } if *retryAfter != 300*time.Second { t.Fatalf("retryAfter = %v, want %v", *retryAfter, 300*time.Second) }}
func TestCodexTerminalStreamErrHandlesUsageLimitResponseFailed(t *testing.T) { streamErr, _, ok := codexTerminalStreamErr([]byte(`{"type":"response.failed","response":{"error":{"type":"usage_limit_reached","message":"usage limit reached","resets_in_seconds":60}}}`)) if !ok { t.Fatal("expected usage_limit_reached response.failed terminal error to be handled") } if got := statusCodeFromTestError(t, streamErr); got != http.StatusTooManyRequests { t.Fatalf("status code = %d, want %d", got, http.StatusTooManyRequests) } if streamErr.RetryAfter() == nil { t.Fatal("expected retryAfter from usage_limit_reached response.failed terminal error") }}
func statusCodeFromTestError(t *testing.T, err error) int { t.Helper()
statusErr, ok := err.(interface{ StatusCode() int }) if !ok { t.Fatalf("error %T does not expose StatusCode(): %v", err, err) } return statusErr.StatusCode()}
func assertRequestScopedTestError(t *testing.T, err error) { t.Helper()
requestErr, ok := err.(interface{ IsRequestScoped() bool }) if !ok { t.Fatalf("error %T does not expose IsRequestScoped(): %v", err, err) } if !requestErr.IsRequestScoped() { t.Fatalf("error %T is not request-scoped: %v", err, err) }}
func assertNotRequestScopedTestError(t *testing.T, err error) { t.Helper()
requestErr, ok := err.(interface{ IsRequestScoped() bool }) if ok && requestErr.IsRequestScoped() { t.Fatalf("error %T is unexpectedly request-scoped: %v", err, err) }}
type unexpectedEOFReader struct{}
func (unexpectedEOFReader) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF}
func TestCodexExecutorExecuteStream_EmptyStreamCompletionOutputUsesOutputItemDone(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"ok\"}]},\"output_index\":0}\n")) _, _ = w.Write([]byte("data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"object\":\"response\",\"created_at\":1775555723,\"status\":\"completed\",\"model\":\"gpt-5.4-mini-2026-03-17\",\"output\":[],\"usage\":{\"input_tokens\":8,\"output_tokens\":28,\"total_tokens\":36}}}\n\n")) })) defer server.Close()
executor := NewCodexExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "base_url": server.URL, "api_key": "test", }}
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "gpt-5.4-mini", Payload: []byte(`{"model":"gpt-5.4-mini","input":"Say ok"}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai-response"), Stream: true, }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) }
var completed []byte for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("stream chunk error: %v", chunk.Err) } payload := bytes.TrimSpace(chunk.Payload) if !bytes.HasPrefix(payload, []byte("data:")) { continue } data := bytes.TrimSpace(payload[5:]) if gjson.GetBytes(data, "type").String() == "response.completed" { completed = append([]byte(nil), data...) } }
if len(completed) == 0 { t.Fatal("missing response.completed chunk") }
gotContent := gjson.GetBytes(completed, "response.output.0.content.0.text").String() if gotContent != "ok" { t.Fatalf("response.output[0].content[0].text = %q, want %q; completed=%s", gotContent, "ok", string(completed)) }}