mirror of
https://github.com/Wei-Shaw/sub2api.git
synced 2026-10-14 12:02:27 +08:00
cikenerdandCursor
087987070b
网关合成/重编的 Responses SSE 因 omitempty 或缺字段丢掉 sequence_number， grok-build 会整轮反序列化失败。合成失败帧、compact 桥接和转换 wire JSON 一律写出该字段，0 也保留。 Fixes #7128 Co-authored-by: Cursor <cursoragent@cursor.com>
378 lines
17 KiB
Go
378 lines
17 KiB
Go
package handler
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"net/http"
|
||
"net/http/httptest"
|
||
"strings"
|
||
"testing"
|
||
|
||
"github.com/Wei-Shaw/sub2api/internal/pkg/ctxkey"
|
||
"github.com/gin-gonic/gin"
|
||
"github.com/stretchr/testify/assert"
|
||
"github.com/stretchr/testify/require"
|
||
"github.com/tidwall/gjson"
|
||
)
|
||
|
||
// Regression for the production incident on 2026-05-24 around 9:13 CST:
|
||
// user 16 sent /v1/responses with stream:true via Codex CLI; the user-concurrency
|
||
// slot wait sent SSE ping comments (flushing HTTP 200 + headers), then the 30s
|
||
// timeout fired and the handler emitted `event: error\ndata: {...}`. Codex CLI
|
||
// does not recognize that as a Responses terminal event and reports
|
||
// "stream closed before response.completed". The fix is to emit a synthetic
|
||
// response.failed event when the inbound endpoint is /v1/responses.
|
||
|
||
func newGinContextForEndpoint(t *testing.T, endpoint string) (*gin.Context, *httptest.ResponseRecorder) {
|
||
t.Helper()
|
||
gin.SetMode(gin.TestMode)
|
||
w := httptest.NewRecorder()
|
||
c, _ := gin.CreateTestContext(w)
|
||
c.Request = httptest.NewRequest(http.MethodPost, endpoint, nil)
|
||
return c, w
|
||
}
|
||
|
||
// parseResponsesFailedSSE 抽出 SSE 中 data 行的 JSON，返回 (response 对象, error 对象)。
|
||
func parseResponsesFailedSSE(t *testing.T, body string) (map[string]any, map[string]any) {
|
||
t.Helper()
|
||
require.True(t, strings.HasPrefix(body, "event: response.failed\n"),
|
||
"expect event: response.failed prefix, got: %q", body)
|
||
require.True(t, strings.HasSuffix(body, "\n\n"))
|
||
|
||
lines := strings.SplitN(strings.TrimSuffix(body, "\n\n"), "\n", 2)
|
||
require.Len(t, lines, 2)
|
||
require.True(t, strings.HasPrefix(lines[1], "data: "))
|
||
jsonStr := strings.TrimPrefix(lines[1], "data: ")
|
||
|
||
var parsed map[string]any
|
||
require.NoError(t, json.Unmarshal([]byte(jsonStr), &parsed), "data must be valid JSON: %s", jsonStr)
|
||
|
||
assert.Equal(t, "response.failed", parsed["type"])
|
||
// grok-build 把 sequence_number 当必填；合成终止事件未知上一帧时写 0。
|
||
rawSeq, hasSeq := parsed["sequence_number"]
|
||
assert.True(t, hasSeq, "synthetic event must emit sequence_number")
|
||
seq, ok := rawSeq.(float64)
|
||
assert.True(t, ok, "sequence_number must be a number, got %T", rawSeq)
|
||
assert.GreaterOrEqual(t, seq, float64(0))
|
||
|
||
resp, ok := parsed["response"].(map[string]any)
|
||
require.True(t, ok, "response object missing")
|
||
assert.Equal(t, "response", resp["object"])
|
||
assert.Equal(t, "failed", resp["status"])
|
||
|
||
errObj, ok := resp["error"].(map[string]any)
|
||
require.True(t, ok, "error object missing")
|
||
|
||
return resp, errObj
|
||
}
|
||
|
||
// OpenAI handler: /v1/responses streaming, after stream started, must emit response.failed.
|
||
func TestOpenAIHandleStreamingAwareError_ResponsesStreamingEmitsResponseFailed(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
"Concurrency limit exceeded for user, please retry later", true)
|
||
|
||
resp, errObj := parseResponsesFailedSSE(t, w.Body.String())
|
||
|
||
id, _ := resp["id"].(string)
|
||
assert.True(t, strings.HasPrefix(id, "resp_"), "id should start with resp_, got %q", id)
|
||
assert.Equal(t, "rate_limit_exceeded", errObj["code"])
|
||
assert.Equal(t, "Concurrency limit exceeded for user, please retry later", errObj["message"])
|
||
}
|
||
|
||
func TestOpenAIAdmissionError_SynchronousNonResponsesIncludesGatewayCode(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointChatCompletions)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareErrorWithCode(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
gatewayQueueFullCode, "Too many pending requests, please retry later", false, false)
|
||
|
||
assert.Equal(t, http.StatusTooManyRequests, w.Code)
|
||
assert.Equal(t, "rate_limit_error", gjson.GetBytes(w.Body.Bytes(), "error.type").String())
|
||
assert.Equal(t, gatewayQueueFullCode, gjson.GetBytes(w.Body.Bytes(), "error.code").String())
|
||
}
|
||
|
||
func TestOpenAIAdmissionError_SynchronousResponsesIncludesGatewayCode(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareErrorWithCode(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
gatewayConcurrencyLimitCode, "Concurrency limit exceeded for account, please retry later", false, false)
|
||
|
||
assert.Equal(t, http.StatusTooManyRequests, w.Code)
|
||
assert.Equal(t, "rate_limit_error", gjson.GetBytes(w.Body.Bytes(), "error.type").String())
|
||
assert.Equal(t, gatewayConcurrencyLimitCode, gjson.GetBytes(w.Body.Bytes(), "error.code").String())
|
||
}
|
||
|
||
func TestOpenAIAdmissionError_ResponsesFailedIncludesGatewayCode(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareErrorWithCode(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
gatewayConcurrencyLimitCode, "Concurrency limit exceeded for account, please retry later", true, false)
|
||
|
||
_, errObj := parseResponsesFailedSSE(t, w.Body.String())
|
||
assert.Equal(t, gatewayConcurrencyLimitCode, errObj["code"])
|
||
}
|
||
|
||
func TestOpenAIAdmissionError_StreamingNonResponsesIncludesGatewayCode(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointChatCompletions)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareErrorWithCode(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
gatewayQueueFullCode, "Too many pending requests, please retry later", true, false)
|
||
|
||
body := w.Body.String()
|
||
assert.True(t, strings.HasPrefix(body, "event: error\n"))
|
||
payload := body[strings.Index(body, "{"):]
|
||
assert.Equal(t, "rate_limit_error", gjson.Get(payload, "error.type").String())
|
||
assert.Equal(t, gatewayQueueFullCode, gjson.Get(payload, "error.code").String())
|
||
}
|
||
|
||
func TestOpenAIUpstreamRateLimitWithoutLocalCodeRemainsUnchanged(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointChatCompletions)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusTooManyRequests, "rate_limit_error", "upstream limited", false)
|
||
|
||
assert.Equal(t, "rate_limit_error", gjson.GetBytes(w.Body.Bytes(), "error.type").String())
|
||
assert.False(t, gjson.GetBytes(w.Body.Bytes(), "error.code").Exists())
|
||
}
|
||
|
||
// 当 setOpsRequestContext 写过 model，合成事件应回填该字段（与 codebase 已有 makeResponsesCompletedEvent 对齐）。
|
||
func TestOpenAIHandleStreamingAwareError_ResponsesStreamingIncludesModel(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
setOpsRequestContext(c, "gpt-5.5", true)
|
||
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusBadGateway, "upstream_error", "boom", true)
|
||
|
||
resp, _ := parseResponsesFailedSSE(t, w.Body.String())
|
||
assert.Equal(t, "gpt-5.5", resp["model"])
|
||
}
|
||
|
||
// 没有 model 时 model 字段不应出现（避免发空字符串污染下游解析）。
|
||
func TestOpenAIHandleStreamingAwareError_ResponsesStreamingOmitsEmptyModel(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusBadGateway, "upstream_error", "boom", true)
|
||
|
||
resp, _ := parseResponsesFailedSSE(t, w.Body.String())
|
||
_, hasModel := resp["model"]
|
||
assert.False(t, hasModel, "model field must be omitted when unknown")
|
||
}
|
||
|
||
// 当 request.Context 携带 ctxkey.RequestID 时，合成 id 应与之关联，便于和 server log 串起来。
|
||
func TestOpenAIHandleStreamingAwareError_ResponsesStreamingReusesRequestID(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
c.Request = c.Request.WithContext(
|
||
context.WithValue(c.Request.Context(), ctxkey.RequestID, "fd277bc5-ff7e-45d1-8aa9-f54e1df318f1"),
|
||
)
|
||
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusTooManyRequests, "rate_limit_error", "x", true)
|
||
|
||
resp, _ := parseResponsesFailedSSE(t, w.Body.String())
|
||
assert.Equal(t, "resp_fd277bc5ff7e45d18aa9f54e1df318f1", resp["id"])
|
||
}
|
||
|
||
// 与旧分支的 TestOpenAIHandleStreamingAwareError_JSONEscaping 对齐：
|
||
// 新的 response.failed payload 也必须正确转义 message 里的特殊字符，
|
||
// 否则下游 SDK 解析 JSON 时会失败。
|
||
func TestOpenAIHandleStreamingAwareError_ResponsesStreamingJSONEscaping(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
errType string
|
||
message string
|
||
}{
|
||
{"双引号", "server_error", `upstream returned "invalid" response`},
|
||
{"反斜杠", "server_error", `path C:\Users\test\file.txt not found`},
|
||
{"双引号+反斜杠", "upstream_error", `error parsing "key\value": unexpected token`},
|
||
{"换行与制表", "server_error", "line1\nline2\ttab"},
|
||
{"普通", "upstream_error", "Upstream service temporarily unavailable"},
|
||
}
|
||
|
||
for _, tc := range cases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusBadGateway, tc.errType, tc.message, true)
|
||
|
||
_, errObj := parseResponsesFailedSSE(t, w.Body.String())
|
||
assert.Equal(t, tc.message, errObj["message"], "message 必须被原样还原")
|
||
})
|
||
}
|
||
}
|
||
|
||
// OpenAI handler: /v1/chat/completions streaming keeps the legacy event: error format
|
||
// (out of scope for this fix; covered to prevent regression of unrelated paths).
|
||
func TestOpenAIHandleStreamingAwareError_ChatCompletionsStreamingKeepsLegacy(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointChatCompletions)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusBadGateway, "upstream_error", "boom", true)
|
||
|
||
body := w.Body.String()
|
||
assert.True(t, strings.HasPrefix(body, "event: error\n"), "got: %q", body)
|
||
}
|
||
|
||
// Gateway (Anthropic-backed) handler: /v1/responses path also must emit response.failed.
|
||
func TestGatewayHandleStreamingAwareError_ResponsesStreamingEmitsResponseFailed(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
h := &GatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusBadGateway, "upstream_error", "upstream gone", true)
|
||
|
||
_, errObj := parseResponsesFailedSSE(t, w.Body.String())
|
||
assert.Equal(t, "upstream_error", errObj["code"])
|
||
assert.Equal(t, "upstream gone", errObj["message"])
|
||
}
|
||
|
||
func TestGatewayAdmissionError_SynchronousIncludesGatewayCode(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointMessages)
|
||
h := &GatewayHandler{}
|
||
h.handleStreamingAwareErrorWithCode(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
gatewayQueueFullCode, "Too many pending requests, please retry later", false)
|
||
|
||
assert.Equal(t, http.StatusTooManyRequests, w.Code)
|
||
assert.Equal(t, "error", gjson.GetBytes(w.Body.Bytes(), "type").String())
|
||
assert.Equal(t, "rate_limit_error", gjson.GetBytes(w.Body.Bytes(), "error.type").String())
|
||
assert.Equal(t, gatewayQueueFullCode, gjson.GetBytes(w.Body.Bytes(), "error.code").String())
|
||
}
|
||
|
||
func TestGatewayAdmissionError_MessagesStreamingIncludesGatewayCode(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointMessages)
|
||
h := &GatewayHandler{}
|
||
h.handleStreamingAwareErrorWithCode(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
gatewayConcurrencyLimitCode, "Concurrency limit exceeded for account, please retry later", true)
|
||
|
||
body := w.Body.String()
|
||
assert.True(t, strings.HasPrefix(body, `data: {"type":"error"`))
|
||
payload := body[strings.Index(body, "{"):]
|
||
assert.Equal(t, "rate_limit_error", gjson.Get(payload, "error.type").String())
|
||
assert.Equal(t, gatewayConcurrencyLimitCode, gjson.Get(payload, "error.code").String())
|
||
}
|
||
|
||
func TestGatewayAdmissionError_BareResponsesFailedIncludesGatewayCode(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, "/responses")
|
||
h := &GatewayHandler{}
|
||
h.handleStreamingAwareErrorWithCode(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
gatewayQueueFullCode, "Too many pending requests, please retry later", true)
|
||
|
||
_, errObj := parseResponsesFailedSSE(t, w.Body.String())
|
||
assert.Equal(t, gatewayQueueFullCode, errObj["code"])
|
||
}
|
||
|
||
// Gateway handler: /v1/messages preserves the legacy data:{type:error,...} format
|
||
// (Anthropic spec accepts a type:"error" stream event).
|
||
func TestGatewayHandleStreamingAwareError_MessagesStreamingKeepsLegacy(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointMessages)
|
||
h := &GatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusBadGateway, "upstream_error", "boom", true)
|
||
|
||
body := w.Body.String()
|
||
assert.True(t, strings.HasPrefix(body, `data: {"type":"error"`), "got: %q", body)
|
||
}
|
||
|
||
// 项目里 /responses 注册在多组路由：/v1/responses（gateway）、裸 /responses（top-level）、
|
||
// /backend-api/codex/responses（codex direct）。我们 fix 必须覆盖全部，
|
||
// 否则一些客户端走的路径就不会发 response.failed，照样报 stream closed。
|
||
// 这是生产 2026-05-24 ~11:05 UTC user 16 实际命中的 bug。
|
||
func TestInboundIsResponses_CoversAllRoutes(t *testing.T) {
|
||
cases := []struct {
|
||
route string
|
||
want bool
|
||
}{
|
||
{"/v1/responses", true},
|
||
{"/v1/responses/compact", true},
|
||
{"/responses", true}, // <-- 用户 16 实际走这条
|
||
{"/responses/compact", true},
|
||
{"/backend-api/codex/responses", true},
|
||
{"/backend-api/codex/responses/compact", true},
|
||
{"/v1/chat/completions", false},
|
||
{"/v1/messages", false},
|
||
{"/", false},
|
||
{"/responses-fake", false},
|
||
}
|
||
for _, tc := range cases {
|
||
t.Run(tc.route, func(t *testing.T) {
|
||
c, _ := newGinContextForEndpoint(t, tc.route)
|
||
assert.Equal(t, tc.want, inboundIsResponses(c), "route=%q", tc.route)
|
||
})
|
||
}
|
||
}
|
||
|
||
// 用 c.Request.URL.Path 作为 fallback（当 c.FullPath() 为空时，例如某些测试 fixture）。
|
||
func TestInboundIsResponses_FallsBackToURLPath(t *testing.T) {
|
||
gin.SetMode(gin.TestMode)
|
||
w := httptest.NewRecorder()
|
||
c, _ := gin.CreateTestContext(w)
|
||
c.Request = httptest.NewRequest(http.MethodPost, "/responses", nil)
|
||
// 这种情况下 c.FullPath() 是 ""，必须 fallback 到 URL.Path
|
||
assert.True(t, inboundIsResponses(c), "URL.Path fallback must work when FullPath is empty")
|
||
}
|
||
|
||
// 回归生产事故：用户 16 走 /responses 路径，必须发 response.failed。
|
||
func TestOpenAIHandleStreamingAwareError_BareResponsesRouteEmitsResponseFailed(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, "/responses")
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusTooManyRequests, "rate_limit_error",
|
||
"Concurrency limit exceeded for user, please retry later", true)
|
||
|
||
resp, errObj := parseResponsesFailedSSE(t, w.Body.String())
|
||
id, _ := resp["id"].(string)
|
||
assert.True(t, strings.HasPrefix(id, "resp_"))
|
||
assert.Equal(t, "rate_limit_exceeded", errObj["code"])
|
||
}
|
||
|
||
// issue #7128：grok-build 把顶层 sequence_number 当必填，合成的 response.failed
|
||
// 必须写出该字段，否则整轮反序列化失败。
|
||
func TestOpenAIHandleStreamingAwareError_ResponsesStreamingCarriesSequenceNumber(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusBadGateway, "upstream_error", "boom", true)
|
||
|
||
require.True(t, strings.HasPrefix(w.Body.String(), "event: response.failed\n"))
|
||
_, payload, found := strings.Cut(w.Body.String(), "data: ")
|
||
require.True(t, found)
|
||
require.True(t, gjson.Get(payload, "sequence_number").Exists(), "response.failed 必须带 sequence_number")
|
||
require.GreaterOrEqual(t, gjson.Get(payload, "sequence_number").Int(), int64(0))
|
||
}
|
||
|
||
// issue #5601：严格的 Responses 客户端把 created_at 当必填字段，缺失即
|
||
// `missing field 'created_at'`。合成的终止事件若解析不了，本文件存在的意义
|
||
// （给客户端一个可识别的终止事件而不是盲重连）就落空了。
|
||
func TestOpenAIHandleStreamingAwareError_ResponsesStreamingCarriesCreatedAt(t *testing.T) {
|
||
c, w := newGinContextForEndpoint(t, EndpointResponses)
|
||
h := &OpenAIGatewayHandler{}
|
||
h.handleStreamingAwareError(c, http.StatusBadGateway, "upstream_error", "boom", true)
|
||
|
||
resp, _ := parseResponsesFailedSSE(t, w.Body.String())
|
||
raw, ok := resp["created_at"]
|
||
assert.True(t, ok, "response.failed 必须带 created_at")
|
||
createdAt, ok := raw.(float64)
|
||
assert.True(t, ok, "created_at 必须是数字，得到 %T", raw)
|
||
assert.Greater(t, int64(createdAt), int64(0), "created_at 必须是有效的 unix 时间戳")
|
||
}
|
||
|
||
// Synthesized response.failed id falls back to uuid when no request_id is present.
|
||
func TestSynthesizeResponseID_FallbackUUID(t *testing.T) {
|
||
c, _ := newGinContextForEndpoint(t, EndpointResponses)
|
||
id := synthesizeResponseID(c)
|
||
assert.True(t, strings.HasPrefix(id, "resp_"))
|
||
// uuid 去掉短横线后 32 hex 字符；前缀 "resp_" 共 37。
|
||
assert.Len(t, id, 37)
|
||
}
|
||
|
||
func TestMapResponsesErrorCode(t *testing.T) {
|
||
cases := []struct{ in, out string }{
|
||
{"rate_limit_error", "rate_limit_exceeded"},
|
||
{"invalid_request_error", "invalid_request"},
|
||
{"permission_error", "permission_denied"},
|
||
{"authentication_error", "authentication_failed"},
|
||
{"upstream_error", "upstream_error"},
|
||
{"server_error", "server_error"},
|
||
{"api_error", "server_error"},
|
||
{"", "server_error"},
|
||
{"custom_thing", "custom_thing"},
|
||
}
|
||
for _, tc := range cases {
|
||
assert.Equal(t, tc.out, mapResponsesErrorCode(tc.in, ""), "in=%q", tc.in)
|
||
}
|
||
assert.Equal(t, gatewayQueueFullCode, mapResponsesErrorCode("rate_limit_error", gatewayQueueFullCode))
|
||
}
|