修复 AI 网关流式断流:错误透传、自动降级,max_tokens 可缺省

internal/service/airesponses.go

@@ -104,3 +104,25 @@ func RespStreamCompletedUsage(data []byte) *aiwire.Usage {
 	}
 	return RespPassthroughUsage(ev.Response)
 }
+
+// RespStreamErrorMsg 从一行 SSE data JSON 中提取 error / response.failed 事件的
+// 错误消息;非错误事件返回空串。流式直通据此把上游错误写入调用日志。
+func RespStreamErrorMsg(data []byte) string {
+	var ev respStreamEvent
+	if json.Unmarshal(data, &ev) != nil {
+		return ""
+	}
+	switch ev.Type {
+	case "error":
+		if ev.Message != "" {
+			return ev.Message
+		}
+		return "上游返回错误事件 error"
+	case "response.failed":
+		if m := respErrorMsg(ev.Response); m != "" {
+			return m
+		}
+		return "上游返回错误事件 response.failed"
+	}
+	return ""
+}

internal/service/anthresponses.go

@@ -258,7 +258,7 @@ type AnthEvent struct {
 
 // AnthRespBridge 把直通 SSE 事件流桥接为 Anthropic 事件序列:
 // message_start → content_block_start/delta/stop(text 与 tool_use 分块)→ message_delta → message_stop。
-// reasoning 系列事件丢弃。
+// reasoning 系列事件丢弃;上游 error / response.failed 转 Anthropic error 事件透传。
 type AnthRespBridge struct {
 	id, model   string
 	started     bool
@@ -267,6 +267,11 @@ type AnthRespBridge struct {
 	blockIndex  int
 	stopReason  string
 	usage       aiwire.AnthUsage
+	// sawTerminal 标记收到过终态事件(completed/incomplete/failed);
+	// 上游流提前 EOF 时据此发 error 事件而非伪装正常结束
+	sawTerminal bool
+	// errMsg 记录上游错误消息,非空即本流已失败(供调用日志)
+	errMsg string
 }
 
 // NewAnthRespBridge 构造桥;id 为响应消息 ID。
@@ -278,6 +283,7 @@ func NewAnthRespBridge(id, model string) *AnthRespBridge {
 type respStreamEvent struct {
 	Type     string          `json:"type"`
 	Delta    string          `json:"delta"`
+	Message  string          `json:"message"`
 	Item     *respOutputItem `json:"item"`
 	Response *respPayload    `json:"response"`
 }
@@ -288,27 +294,130 @@ func (st *AnthRespBridge) Feed(data []byte) []AnthEvent {
 	if json.Unmarshal(data, &ev) != nil {
 		return nil
 	}
-	var events []AnthEvent
-	if !st.started {
-		st.started = true
-		events = append(events, st.startEvent())
+	if ev.Type == "error" || ev.Type == "response.failed" {
+		return st.failWith(ev)
 	}
+	// message_start 延迟到首个可见输出事件:created / reasoning 阶段不向客户端
+	// 写任何字节,上游此段断流时 handler 才有降级非流式重做的无感窗口
+	var events []AnthEvent
 	switch ev.Type {
 	case "response.output_item.added":
 		if ev.Item != nil && ev.Item.Type == "function_call" {
+			events = append(events, st.ensureStarted()...)
 			events = append(events, st.openBlock(true, ev.Item.CallID, ev.Item.Name)...)
 			st.stopReason = "tool_use"
 		}
 	case "response.output_text.delta":
+		events = append(events, st.ensureStarted()...)
 		events = append(events, st.textDelta(ev.Delta)...)
 	case "response.function_call_arguments.delta":
 		events = append(events, st.argsDelta(ev.Delta)...)
-	case "response.completed", "response.incomplete", "response.failed":
+	case "response.completed", "response.incomplete":
+		st.sawTerminal = true
 		st.finishFrom(ev.Response)
 	}
 	return events
 }
 
+// ensureStarted 在首个可见输出事件前补发 message_start(仅一次)。
+func (st *AnthRespBridge) ensureStarted() []AnthEvent {
+	if st.started {
+		return nil
+	}
+	st.started = true
+	return []AnthEvent{st.startEvent()}
+}
+
+// failWith 记录上游错误并产出 Anthropic error 事件(每流至多一次)。
+func (st *AnthRespBridge) failWith(ev respStreamEvent) []AnthEvent {
+	if st.errMsg != "" {
+		return nil
+	}
+	st.sawTerminal = true
+	msg := ev.Message
+	if ev.Type == "response.failed" {
+		st.finishFrom(ev.Response)
+		if m := respErrorMsg(ev.Response); m != "" {
+			msg = m
+		}
+	}
+	if msg == "" {
+		msg = "上游返回错误事件 " + ev.Type
+	}
+	st.errMsg = msg
+	return []AnthEvent{st.errorEvent()}
+}
+
+// respErrorMsg 提取 response.failed 载荷中的错误消息。
+func respErrorMsg(resp *respPayload) string {
+	if resp == nil || resp.Error == nil {
+		return ""
+	}
+	return (*resp.Error)["message"]
+}
+
+// errorEvent 按 Anthropic 流式协议产出 error 事件。
+func (st *AnthRespBridge) errorEvent() AnthEvent {
+	return AnthEvent{Event: "error", Data: map[string]any{
+		"type":  "error",
+		"error": map[string]string{"type": "api_error", "message": st.errMsg},
+	}}
+}
+
+// Err 返回上游错误消息;空串表示流正常(供调用日志)。
+func (st *AnthRespBridge) Err() string { return st.errMsg }
+
+// SawTerminal 报告是否收到过终态事件;false 即上游流提前终止。
+func (st *AnthRespBridge) SawTerminal() bool { return st.sawTerminal }
+
+// AnthMessageEvents 把完整 Messages 响应展开为标准事件序列,
+// 供流式上游断流后的非流式降级结果推送(客户端协议不变)。
+func AnthMessageEvents(m *aiwire.MessagesResponse) []AnthEvent {
+	events := []AnthEvent{{Event: "message_start", Data: map[string]any{
+		"type": "message_start",
+		"message": map[string]any{
+			"id": m.ID, "type": "message", "role": m.Role, "model": m.Model,
+			"content": []any{}, "stop_reason": nil,
+			"usage": map[string]int{"input_tokens": 0, "output_tokens": 0},
+		},
+	}}}
+	for i, b := range m.Content {
+		events = append(events, anthBlockEvents(i, b)...)
+	}
+	usage := map[string]int{"input_tokens": m.Usage.InputTokens, "output_tokens": m.Usage.OutputTokens}
+	if m.Usage.CacheReadInputTokens > 0 {
+		usage["cache_read_input_tokens"] = m.Usage.CacheReadInputTokens
+	}
+	events = append(events,
+		AnthEvent{Event: "message_delta", Data: map[string]any{
+			"type":  "message_delta",
+			"delta": map[string]any{"stop_reason": m.StopReason, "stop_sequence": nil},
+			"usage": usage,
+		}},
+		AnthEvent{Event: "message_stop", Data: map[string]any{"type": "message_stop"}})
+	return events
+}
+
+// anthBlockEvents 把一个内容块展开为 start / delta / stop 三事件。
+func anthBlockEvents(index int, b aiwire.AnthBlock) []AnthEvent {
+	var start, delta map[string]any
+	if b.Type == "tool_use" {
+		start = map[string]any{"type": "tool_use", "id": b.ID, "name": b.Name, "input": map[string]any{}}
+		delta = map[string]any{"type": "input_json_delta", "partial_json": string(b.Input)}
+	} else {
+		start = map[string]any{"type": "text", "text": ""}
+		delta = map[string]any{"type": "text_delta", "text": b.Text}
+	}
+	return []AnthEvent{
+		{Event: "content_block_start", Data: map[string]any{
+			"type": "content_block_start", "index": index, "content_block": start}},
+		{Event: "content_block_delta", Data: map[string]any{
+			"type": "content_block_delta", "index": index, "delta": delta}},
+		{Event: "content_block_stop", Data: map[string]any{
+			"type": "content_block_stop", "index": index}},
+	}
+}
+
 func (st *AnthRespBridge) textDelta(delta string) []AnthEvent {
 	var events []AnthEvent
 	if !st.blockOpen || st.blockIsTool {
@@ -378,7 +487,16 @@ func (st *AnthRespBridge) closeBlockEvent() AnthEvent {
 }
 
 // Finish 在上游流结束后收尾:关块 → message_delta(stop_reason+usage)→ message_stop。
+// 已发过 error 事件的流不再补终态;未见终态事件即 EOF 视为上游提前终止,
+// 发 error 事件而非伪装正常结束(否则客户端拿到"成功的空消息")。
 func (st *AnthRespBridge) Finish() []AnthEvent {
+	if st.errMsg != "" {
+		return nil
+	}
+	if !st.sawTerminal {
+		st.errMsg = "上游流提前终止,未返回终态事件"
+		return []AnthEvent{st.errorEvent()}
+	}
 	var events []AnthEvent
 	if !st.started {
 		st.started = true

internal/service/anthresponses_test.go

@@ -164,10 +164,105 @@ func TestAnthRespBridge(t *testing.T) {
 	}
 }
 
-// TestAnthRespBridgeEmpty 断言空流也产出完整事件骨架。
-func TestAnthRespBridgeEmpty(t *testing.T) {
-	st := NewAnthRespBridge("msg_1", "m1")
-	if got := bridgeEventTypes(st.Finish()); got != "message_start,message_delta,message_stop" {
-		t.Errorf("空流事件序列 = %s", got)
+// TestAnthRespBridgeFailure 断言异常流的错误透传:上游 error / response.failed
+// 事件转 Anthropic error 事件,提前 EOF(未见终态)不再伪装正常结束。
+func TestAnthRespBridgeFailure(t *testing.T) {
+	cases := []struct {
+		name      string
+		lines     []string
+		wantKinds string
+		wantErr   string
+	}{
+		{
+			name:      "上游 error 事件透传",
+			lines:     []string{`{"type":"error","message":"model overloaded"}`},
+			wantKinds: "error",
+			wantErr:   "model overloaded",
+		},
+		{
+			name: "response.failed 提取错误消息",
+			lines: []string{
+				`{"type":"response.output_text.delta","delta":"你"}`,
+				`{"type":"response.failed","response":{"status":"failed","error":{"message":"content filtered"}}}`,
+			},
+			wantKinds: "message_start,content_block_start,content_block_delta,error",
+			wantErr:   "content filtered",
+		},
+		{
+			name:      "空流提前终止",
+			lines:     nil,
+			wantKinds: "error",
+			wantErr:   "上游流提前终止,未返回终态事件",
+		},
+		{
+			name: "输出中途 EOF 无终态",
+			lines: []string{
+				`{"type":"response.output_text.delta","delta":"你"}`,
+			},
+			wantKinds: "message_start,content_block_start,content_block_delta,error",
+			wantErr:   "上游流提前终止,未返回终态事件",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			st := NewAnthRespBridge("msg_1", "m1")
+			var events []AnthEvent
+			for _, l := range tc.lines {
+				events = append(events, st.Feed([]byte(l))...)
+			}
+			events = append(events, st.Finish()...)
+			if got := bridgeEventTypes(events); got != tc.wantKinds {
+				t.Fatalf("事件序列 = %s, want %s", got, tc.wantKinds)
+			}
+			if st.Err() != tc.wantErr {
+				t.Fatalf("Err() = %q, want %q", st.Err(), tc.wantErr)
+			}
+		})
+	}
+}
+
+// TestRespStreamErrorMsg 断言直通流错误事件消息提取。
+func TestRespStreamErrorMsg(t *testing.T) {
+	cases := []struct {
+		name string
+		data string
+		want string
+	}{
+		{name: "error 事件", data: `{"type":"error","message":"boom"}`, want: "boom"},
+		{name: "error 无消息用占位", data: `{"type":"error"}`, want: "上游返回错误事件 error"},
+		{name: "failed 事件", data: `{"type":"response.failed","response":{"error":{"message":"bad"}}}`, want: "bad"},
+		{name: "正常事件返回空", data: `{"type":"response.completed","response":{}}`, want: ""},
+		{name: "非 JSON 返回空", data: `<html>`, want: ""},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := RespStreamErrorMsg([]byte(tc.data)); got != tc.want {
+				t.Fatalf("RespStreamErrorMsg = %q, want %q", got, tc.want)
+			}
+		})
+	}
+}
+
+// TestAnthMessageEvents 断言非流式降级结果展开的事件序列与 usage。
+func TestAnthMessageEvents(t *testing.T) {
+	msg := &aiwire.MessagesResponse{
+		ID: "msg_1", Type: "message", Role: "assistant", Model: "m1",
+		Content: []aiwire.AnthBlock{
+			{Type: "text", Text: "好"},
+			{Type: "tool_use", ID: "c1", Name: "f", Input: json.RawMessage(`{"a":1}`)},
+		},
+		StopReason: "tool_use",
+		Usage:      aiwire.AnthUsage{InputTokens: 9, OutputTokens: 3, CacheReadInputTokens: 5},
+	}
+	events := AnthMessageEvents(msg)
+	want := "message_start,content_block_start,content_block_delta,content_block_stop," +
+		"content_block_start,content_block_delta,content_block_stop,message_delta,message_stop"
+	if got := bridgeEventTypes(events); got != want {
+		t.Fatalf("事件序列:\n got %s\nwant %s", got, want)
+	}
+	delta := events[len(events)-2].Data.(map[string]any)
+	usage := delta["usage"].(map[string]int)
+	if usage["input_tokens"] != 9 || usage["output_tokens"] != 3 || usage["cache_read_input_tokens"] != 5 {
+		t.Fatalf("usage = %+v", usage)
 	}
 }

internal/service/chatresponses.go

@@ -358,3 +358,32 @@ func (b *ChatRespBridge) Finish() []aiwire.ChatChunk {
 
 // Usage 返回聚合到的用量(供调用日志),上游未报告时为 nil。
 func (b *ChatRespBridge) Usage() *aiwire.Usage { return b.usage }
+
+// ChatResponseChunks 把完整 Chat 响应展开为 chunk 序列(内容与工具调用 →
+// 终块 → 可选 usage 块),供流式上游断流后的非流式降级结果推送。
+func ChatResponseChunks(resp *aiwire.ChatResponse, includeUsage bool) []aiwire.ChatChunk {
+	if len(resp.Choices) == 0 {
+		return nil
+	}
+	choice := resp.Choices[0]
+	mk := func(delta aiwire.Delta, finish *string) aiwire.ChatChunk {
+		return aiwire.ChatChunk{ID: resp.ID, Object: "chat.completion.chunk", Created: resp.Created,
+			Model: resp.Model, Choices: []aiwire.ChunkChoice{{Index: 0, Delta: delta, FinishReason: finish}}}
+	}
+	delta := aiwire.Delta{Role: "assistant", Content: choice.Message.Content.Text}
+	for i, tc := range choice.Message.ToolCalls {
+		delta.ToolCalls = append(delta.ToolCalls, aiwire.ToolCallDelta{Index: i, ID: tc.ID,
+			Type: "function", Function: aiwire.FunctionCallDelta{Name: tc.Function.Name, Arguments: tc.Function.Arguments}})
+	}
+	finish := choice.FinishReason
+	chunks := []aiwire.ChatChunk{mk(delta, nil), mk(aiwire.Delta{}, &finish)}
+	if includeUsage {
+		usage := resp.Usage
+		if usage == nil {
+			usage = &aiwire.Usage{}
+		}
+		chunks = append(chunks, aiwire.ChatChunk{ID: resp.ID, Object: "chat.completion.chunk",
+			Created: resp.Created, Model: resp.Model, Choices: []aiwire.ChunkChoice{}, Usage: usage})
+	}
+	return chunks
+}