mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-18 15:48:39 +08:00
287 lines
13 KiB
Go
287 lines
13 KiB
Go
package executor
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/MoeForge/moego/ojson"
|
|
"github.com/gorilla/websocket"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/clienterror"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
|
|
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
|
|
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
|
|
sdktranslator "github.com/router-for-me/CLIProxyAPI/v8/sdk/translator"
|
|
)
|
|
|
|
func TestCodexPolicyErrorEnvelopesAcrossTransports(t *testing.T) {
|
|
for _, tc := range []struct{ name, payload string }{
|
|
{"typeless", `{"error":{"code":"bio_policy","message":"blocked"},"sequence_number":7}`},
|
|
{"body", `{"type":"error","body":{"error":{"code":"bio_policy","message":" "}},"sequence_number":7}`},
|
|
{"typeless_body", `{"body":{"error":{"code":"bio_policy"}},"sequence_number":7}`},
|
|
{"typeless_status", `{"status":400,"body":{"error":{"code":"bio_policy"}},"sequence_number":7}`},
|
|
{"null_error", `{"type":"error","error":null,"body":{"error":{"code":"bio_policy"}},"sequence_number":7}`},
|
|
{"failed_body", `{"type":"response.failed","body":{"error":{"code":"bio_policy"}},"sequence_number":7}`},
|
|
{"typeless_response", `{"response":{"error":{"code":"bio_policy"}},"sequence_number":7}`},
|
|
{"typeless_top_level", `{"code":"bio_policy","message":"blocked","sequence_number":7}`},
|
|
{"typeless_top_level_status", `{"status":400,"code":"bio_policy","message":"blocked","sequence_number":7}`},
|
|
} {
|
|
for _, transport := range []string{"sse", "websocket"} {
|
|
for _, mode := range []string{"execute", "stream", "buffered_stream"} {
|
|
for _, format := range []string{"openai-response", "claude"} {
|
|
t.Run(fmt.Sprintf("%s/%s/%s/%s", tc.name, transport, mode, format), func(t *testing.T) {
|
|
created := `{"type":"response.created","response":{"id":"policy-test","model":"gpt-5.5"}}`
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if transport == "sse" {
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
_, _ = fmt.Fprintf(w, "data: %s\n\nevent: error\ndata: %s\n\n", created, tc.payload)
|
|
return
|
|
}
|
|
conn, errUpgrade := (&websocket.Upgrader{}).Upgrade(w, r, nil)
|
|
if errUpgrade != nil {
|
|
t.Error(errUpgrade)
|
|
return
|
|
}
|
|
defer func() {
|
|
if errClose := conn.Close(); errClose != nil {
|
|
t.Error(errClose)
|
|
}
|
|
}()
|
|
if _, _, errRead := conn.ReadMessage(); errRead != nil {
|
|
t.Error(errRead)
|
|
return
|
|
}
|
|
for _, payload := range []string{created, tc.payload} {
|
|
if errWrite := conn.WriteMessage(websocket.TextMessage, []byte(payload)); errWrite != nil {
|
|
t.Error(errWrite)
|
|
return
|
|
}
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
cfg := &config.Config{}
|
|
cfg.Codex.StreamBootstrapBuffering = mode == "buffered_stream"
|
|
var executor cliproxyauth.ProviderExecutor = NewCodexExecutor(cfg)
|
|
if transport == "websocket" {
|
|
executor = NewCodexWebsocketsExecutor(cfg)
|
|
}
|
|
auth := &cliproxyauth.Auth{Attributes: map[string]string{"base_url": server.URL, "api_key": "test"}}
|
|
payload := []byte(`{"model":"gpt-5.5","input":"hello"}`)
|
|
if format == "claude" {
|
|
payload = []byte(`{"model":"gpt-5.5","messages":[{"role":"user","content":"hello"}]}`)
|
|
}
|
|
req := cliproxyexecutor.Request{Model: "gpt-5.5", Payload: payload}
|
|
opts := cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString(format), Stream: mode != "execute"}
|
|
var executionErr error
|
|
if mode == "execute" {
|
|
_, executionErr = executor.Execute(context.Background(), auth, req, opts)
|
|
} else {
|
|
result, errStream := executor.ExecuteStream(context.Background(), auth, req, opts)
|
|
executionErr = errStream
|
|
if result != nil {
|
|
for chunk := range result.Chunks {
|
|
if chunk.Err != nil {
|
|
executionErr = chunk.Err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if executionErr == nil {
|
|
t.Fatal("missing policy error")
|
|
}
|
|
if got := statusCodeFromTestError(t, executionErr); got != http.StatusBadRequest {
|
|
t.Fatalf("status = %d: %v", got, executionErr)
|
|
}
|
|
if got := ojson.Get(executionErr.Error(), "error.code").String(); got != "bio_policy" {
|
|
t.Fatalf("lost policy code: %v", executionErr)
|
|
}
|
|
if got := ojson.Get(executionErr.Error(), "error.message").String(); got == "" || got == " " {
|
|
t.Fatalf("missing fallback message: %v", executionErr)
|
|
}
|
|
if got := ojson.Get(executionErr.Error(), "sequence_number").Int(); got != 7 {
|
|
t.Fatalf("sequence = %d, want 7: %v", got, executionErr)
|
|
}
|
|
if !clienterror.IsRequestFault(400, executionErr) {
|
|
t.Fatalf("policy error is not request scoped: %v", executionErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCodexWebsocketStringErrorsPreserveMessage(t *testing.T) {
|
|
for _, wrapped := range []bool{false, true} {
|
|
for _, message := range []string{"This content was flagged for possible biological risk.", "Invalid signature in thinking block"} {
|
|
t.Run(fmt.Sprintf("wrapped=%t/%s", wrapped, message), func(t *testing.T) {
|
|
payload := ojson.NewDocString(`{"type":"error","status":400,"headers":{"x-request-id":"req-test"}}`)
|
|
path := "error"
|
|
if wrapped {
|
|
path = "body.error"
|
|
}
|
|
_ = payload.Set(path, message)
|
|
err, ok := parseCodexWebsocketError(payload.Bytes())
|
|
if !ok || err == nil {
|
|
t.Fatal("missing websocket error")
|
|
}
|
|
if got := ojson.Get(err.Error(), "error.message").String(); got != message {
|
|
t.Fatalf("message = %q, want %q", got, message)
|
|
}
|
|
if got := err.(interface{ Headers() http.Header }).Headers().Get("X-Request-Id"); got != "req-test" {
|
|
t.Fatalf("request id = %q", got)
|
|
}
|
|
if wrapped && ojson.Get(err.Error(), "body.error").String() != message {
|
|
t.Fatalf("original body lost: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCodexTypelessErrorsPreserveCredentialStatus(t *testing.T) {
|
|
for _, status := range []int{401, 402, 429} {
|
|
payload := fmt.Sprintf(`{"status":%d,"error":{"type":"authentication_error","code":"invalid_request_error","message":"rejected"},"headers":{"retry-after":"7"}}`, status)
|
|
err, ok := parseCodexWebsocketError([]byte(payload))
|
|
if !ok || statusCodeFromTestError(t, err) != status {
|
|
t.Fatalf("websocket status %d: %v", status, err)
|
|
}
|
|
if clienterror.IsRequestFault(status, err) {
|
|
t.Fatalf("websocket credential status %d became a request fault", status)
|
|
}
|
|
if status == 429 {
|
|
retry := err.(interface{ RetryAfter() *time.Duration }).RetryAfter()
|
|
if retry == nil || *retry != 7*time.Second {
|
|
t.Fatalf("retry-after = %v", retry)
|
|
}
|
|
}
|
|
|
|
sseErr, _, okSSE := codexTerminalFailureErr([]byte(payload))
|
|
if !okSSE || statusCodeFromTestError(t, sseErr) != status {
|
|
t.Fatalf("sse status %d: %v", status, sseErr)
|
|
}
|
|
if clienterror.IsRequestFault(statusCodeFromTestError(t, sseErr), sseErr) {
|
|
t.Fatalf("sse credential status %d became a request fault", status)
|
|
}
|
|
}
|
|
|
|
untypedRateLimit := []byte(`{"status":429,"error":{"message":"Too many concurrent requests"}}`)
|
|
sseRateLimitErr, _, ok := codexTerminalFailureErr(untypedRateLimit)
|
|
if !ok || statusCodeFromTestError(t, sseRateLimitErr) != http.StatusTooManyRequests {
|
|
t.Fatalf("untyped 429 sse status = %v (ok=%v)", sseRateLimitErr, ok)
|
|
}
|
|
|
|
blankScalarWS, okWS := parseCodexWebsocketError([]byte(`{"type":"error","status":503,"error":" "}`))
|
|
if !okWS || blankScalarWS == nil {
|
|
t.Fatal("missing blank scalar websocket error")
|
|
}
|
|
if got := ojson.Get(blankScalarWS.Error(), "error.message").String(); got != http.StatusText(http.StatusServiceUnavailable) {
|
|
t.Fatalf("blank scalar fallback message = %q, want %q", got, http.StatusText(http.StatusServiceUnavailable))
|
|
}
|
|
|
|
for _, nestedPayload := range []string{
|
|
`{"body":{"status":429,"error":{"message":"Too many concurrent requests"}},"headers":{"retry-after":"9","x-request-id":"req-body-429"}}`,
|
|
`{"error":{"status_code":429,"message":"Too many concurrent requests"},"headers":{"retry-after":"9","x-request-id":"req-err-429"}}`,
|
|
} {
|
|
nestedErr, okNested := parseCodexWebsocketError([]byte(nestedPayload))
|
|
if !okNested || statusCodeFromTestError(t, nestedErr) != http.StatusTooManyRequests {
|
|
t.Fatalf("nested websocket 429 = %v (ok=%v)", nestedErr, okNested)
|
|
}
|
|
retry := nestedErr.(interface{ RetryAfter() *time.Duration }).RetryAfter()
|
|
if retry == nil || *retry != 9*time.Second {
|
|
t.Fatalf("nested websocket retry-after = %v, want 9s", retry)
|
|
}
|
|
if gotReqID := nestedErr.(interface{ Headers() http.Header }).Headers().Get("X-Request-Id"); gotReqID == "" {
|
|
t.Fatalf("nested websocket headers lost: %#v", nestedErr)
|
|
}
|
|
}
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
payload string
|
|
wantRetry time.Duration
|
|
wantReqID string
|
|
wantTrans bool
|
|
}{
|
|
{
|
|
name: "typeless rate_limit_error without numeric status",
|
|
payload: `{"error":{"type":"rate_limit_error","message":"Too many requests"},"headers":{"retry-after":"11","x-request-id":"req-inferred-type"}}`,
|
|
wantRetry: 11 * time.Second,
|
|
wantReqID: "req-inferred-type",
|
|
},
|
|
{
|
|
name: "typeless rate_limit_exceeded code without numeric status",
|
|
payload: `{"error":{"code":"rate_limit_exceeded","message":"Rate limit exceeded"},"headers":{"retry-after":"13","x-request-id":"req-inferred-code"}}`,
|
|
wantRetry: 13 * time.Second,
|
|
wantReqID: "req-inferred-code",
|
|
},
|
|
{
|
|
name: "typeless nested body turn_rate_limit_exceeded without numeric status",
|
|
payload: `{"body":{"error":{"type":"rate_limit_error","code":"turn_rate_limit_exceeded","message":"Codex is at capacity"},"headers":{"retry-after":"17","x-request-id":"req-inferred-turn"}}}`,
|
|
wantRetry: 17 * time.Second,
|
|
wantReqID: "req-inferred-turn",
|
|
wantTrans: true,
|
|
},
|
|
{
|
|
name: "top-level rate_limit_exceeded without numeric status",
|
|
payload: `{"code":"rate_limit_exceeded","message":"Rate limit exceeded","headers":{"retry-after":"19","x-request-id":"req-inferred-top"}}`,
|
|
wantRetry: 19 * time.Second,
|
|
wantReqID: "req-inferred-top",
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
inferredErr, okInferred := parseCodexWebsocketError([]byte(tc.payload))
|
|
if !okInferred || statusCodeFromTestError(t, inferredErr) != http.StatusTooManyRequests {
|
|
t.Fatalf("inferred websocket 429 = %v (ok=%v)", inferredErr, okInferred)
|
|
}
|
|
if clienterror.IsRequestFault(http.StatusTooManyRequests, inferredErr) {
|
|
t.Fatalf("inferred 429 became a request fault: %v", inferredErr)
|
|
}
|
|
retry := inferredErr.(interface{ RetryAfter() *time.Duration }).RetryAfter()
|
|
if retry == nil || *retry != tc.wantRetry {
|
|
t.Fatalf("inferred retry-after = %v, want %v", retry, tc.wantRetry)
|
|
}
|
|
if gotReqID := inferredErr.(interface{ Headers() http.Header }).Headers().Get("X-Request-Id"); gotReqID != tc.wantReqID {
|
|
t.Fatalf("request id = %q, want %q", gotReqID, tc.wantReqID)
|
|
}
|
|
if transient, okTrans := inferredErr.(interface{ IsTransientRateLimit() bool }); !okTrans || transient.IsTransientRateLimit() != tc.wantTrans {
|
|
t.Fatalf("transient = %v (ok=%v), want %v", transient, okTrans, tc.wantTrans)
|
|
}
|
|
|
|
server := codexWebsocketServer(t, tc.payload)
|
|
defer server.Close()
|
|
req, opts := codexWebsocketRequest()
|
|
_, streamErr := NewCodexWebsocketsExecutor(codexBufferingConfig(true)).ExecuteStream(context.Background(), codexTestAuth(server.URL), req, opts)
|
|
if statusCodeFromTestError(t, streamErr) != http.StatusTooManyRequests {
|
|
t.Fatalf("stream status = %v, want 429", streamErr)
|
|
}
|
|
streamRetry := streamErr.(interface{ RetryAfter() *time.Duration }).RetryAfter()
|
|
if streamRetry == nil || *streamRetry != tc.wantRetry {
|
|
t.Fatalf("stream retry-after = %v, want %v", streamRetry, tc.wantRetry)
|
|
}
|
|
})
|
|
}
|
|
|
|
responseFailedPayload := `{"type":"response.failed","headers":{"retry-after":"23"},"response":{"error":{"type":"rate_limit_error","code":"rate_limit_exceeded","message":"Rate limit exceeded"}}}`
|
|
failedErr, _, okFailed := codexTerminalFailureErr([]byte(responseFailedPayload))
|
|
if !okFailed || statusCodeFromTestError(t, failedErr) != http.StatusTooManyRequests {
|
|
t.Fatalf("response.failed 429 = %v (ok=%v)", failedErr, okFailed)
|
|
}
|
|
if failedRetry := failedErr.RetryAfter(); failedRetry == nil || *failedRetry != 23*time.Second {
|
|
t.Fatalf("response.failed retry-after = %v, want 23s", failedRetry)
|
|
}
|
|
failedServer := codexWebsocketServer(t, codexCreatedEvent, responseFailedPayload)
|
|
defer failedServer.Close()
|
|
req, opts := codexWebsocketRequest()
|
|
_, failedStreamErr := NewCodexWebsocketsExecutor(codexBufferingConfig(true)).ExecuteStream(context.Background(), codexTestAuth(failedServer.URL), req, opts)
|
|
if statusCodeFromTestError(t, failedStreamErr) != http.StatusTooManyRequests {
|
|
t.Fatalf("response.failed bootstrap status = %v, want 429", failedStreamErr)
|
|
}
|
|
if failedBootstrapRetry := failedStreamErr.(interface{ RetryAfter() *time.Duration }).RetryAfter(); failedBootstrapRetry == nil || *failedBootstrapRetry != 23*time.Second {
|
|
t.Fatalf("response.failed bootstrap retry-after = %v, want 23s", failedBootstrapRetry)
|
|
}
|
|
}
|