feat: 配置 golangci-lint 静态分析并修复存量违规

- 新增 backend/.golangci.yml 配置 12 个 linter（forbidigo、errorlint、errcheck、staticcheck、revive、gocritic、gosec、bodyclose、noctx、nilerr、goimports、gocyclo）
- 新增 lefthook.yml 配置 pre-commit hook 自动运行 lint
- 修复存量代码违规：errors.Is/As 替换、zap.Error 替换、import 排序、errcheck 修复
- 更新 README 补充编码规范说明
- 归档 backend-code-lint 变更

backend/internal/conversion/anthropic/adapter.go

@@ -141,7 +141,10 @@ func (a *Adapter) EncodeError(err *conversion.ConversionError) ([]byte, int) {
 			Message: err.Message,
 		},
 	}
-	body, _ := json.Marshal(errMsg)
+	body, marshalErr := json.Marshal(errMsg)
+	if marshalErr != nil {
+		return []byte(`{"type":"error","error":{"type":"internal_error","message":"internal error"}}`), statusCode
+	}
 	return body, statusCode
 }
 
@@ -235,7 +238,11 @@ func locateModelFieldInRequest(body []byte, ifaceType conversion.InterfaceType)
 			return "", nil, err
 		}
 		rewriteFunc := func(newModel string) ([]byte, error) {
-			m["model"], _ = json.Marshal(newModel)
+			encodedModel, err := json.Marshal(newModel)
+			if err != nil {
+				return nil, err
+			}
+			m["model"] = encodedModel
 			return json.Marshal(m)
 		}
 		return current, rewriteFunc, nil
@@ -269,7 +276,11 @@ func (a *Adapter) RewriteResponseModelName(body []byte, newModel string, ifaceTy
 	switch ifaceType {
 	case conversion.InterfaceTypeChat:
 		// Chat 响应必须有 model 字段，存在则改写，不存在则添加
-		m["model"], _ = json.Marshal(newModel)
+		encodedModel, err := json.Marshal(newModel)
+		if err != nil {
+			return nil, err
+		}
+		m["model"] = encodedModel
 		return json.Marshal(m)
 	default:
 		return body, nil

backend/internal/conversion/anthropic/adapter_test.go

@@ -2,6 +2,7 @@ package anthropic
 
 import (
 	"encoding/json"
+	"errors"
 	"testing"
 
 	"nex/backend/internal/conversion"
@@ -52,10 +53,10 @@ func TestAdapter_BuildUrl(t *testing.T) {
 	a := NewAdapter()
 
 	tests := []struct {
-		name         string
-		nativePath   string
+		name          string
+		nativePath    string
 		interfaceType conversion.InterfaceType
-		expected     string
+		expected      string
 	}{
 		{"聊天", "/v1/messages", conversion.InterfaceTypeChat, "/v1/messages"},
 		{"模型", "/v1/models", conversion.InterfaceTypeModels, "/v1/models"},
@@ -102,9 +103,9 @@ func TestAdapter_SupportsInterface(t *testing.T) {
 	a := NewAdapter()
 
 	tests := []struct {
-		name         string
+		name          string
 		interfaceType conversion.InterfaceType
-		expected     bool
+		expected      bool
 	}{
 		{"聊天", conversion.InterfaceTypeChat, true},
 		{"模型", conversion.InterfaceTypeModels, true},
@@ -141,8 +142,8 @@ func TestAdapter_UnsupportedEmbedding(t *testing.T) {
 	t.Run("解码嵌入请求", func(t *testing.T) {
 		_, err := a.DecodeEmbeddingRequest([]byte(`{}`))
 		require.Error(t, err)
-		convErr, ok := err.(*conversion.ConversionError)
-		require.True(t, ok)
+		var convErr *conversion.ConversionError
+		require.ErrorAs(t, err, &convErr)
 		assert.Equal(t, conversion.ErrorCodeInterfaceNotSupported, convErr.Code)
 	})
 
@@ -150,24 +151,24 @@ func TestAdapter_UnsupportedEmbedding(t *testing.T) {
 		provider := conversion.NewTargetProvider("https://api.anthropic.com", "key", "claude-3")
 		_, err := a.EncodeEmbeddingRequest(&canonical.CanonicalEmbeddingRequest{}, provider)
 		require.Error(t, err)
-		convErr, ok := err.(*conversion.ConversionError)
-		require.True(t, ok)
+		var convErr *conversion.ConversionError
+		require.True(t, errors.As(err, &convErr))
 		assert.Equal(t, conversion.ErrorCodeInterfaceNotSupported, convErr.Code)
 	})
 
 	t.Run("解码嵌入响应", func(t *testing.T) {
 		_, err := a.DecodeEmbeddingResponse([]byte(`{}`))
 		require.Error(t, err)
-		convErr, ok := err.(*conversion.ConversionError)
-		require.True(t, ok)
+		var convErr *conversion.ConversionError
+		require.ErrorAs(t, err, &convErr)
 		assert.Equal(t, conversion.ErrorCodeInterfaceNotSupported, convErr.Code)
 	})
 
 	t.Run("编码嵌入响应", func(t *testing.T) {
 		_, err := a.EncodeEmbeddingResponse(&canonical.CanonicalEmbeddingResponse{})
 		require.Error(t, err)
-		convErr, ok := err.(*conversion.ConversionError)
-		require.True(t, ok)
+		var convErr *conversion.ConversionError
+		require.ErrorAs(t, err, &convErr)
 		assert.Equal(t, conversion.ErrorCodeInterfaceNotSupported, convErr.Code)
 	})
 }
@@ -178,8 +179,8 @@ func TestAdapter_UnsupportedRerank(t *testing.T) {
 	t.Run("解码重排序请求", func(t *testing.T) {
 		_, err := a.DecodeRerankRequest([]byte(`{}`))
 		require.Error(t, err)
-		convErr, ok := err.(*conversion.ConversionError)
-		require.True(t, ok)
+		var convErr *conversion.ConversionError
+		require.ErrorAs(t, err, &convErr)
 		assert.Equal(t, conversion.ErrorCodeInterfaceNotSupported, convErr.Code)
 	})
 
@@ -187,24 +188,24 @@ func TestAdapter_UnsupportedRerank(t *testing.T) {
 		provider := conversion.NewTargetProvider("https://api.anthropic.com", "key", "claude-3")
 		_, err := a.EncodeRerankRequest(&canonical.CanonicalRerankRequest{}, provider)
 		require.Error(t, err)
-		convErr, ok := err.(*conversion.ConversionError)
-		require.True(t, ok)
+		var convErr *conversion.ConversionError
+		require.ErrorAs(t, err, &convErr)
 		assert.Equal(t, conversion.ErrorCodeInterfaceNotSupported, convErr.Code)
 	})
 
 	t.Run("解码重排序响应", func(t *testing.T) {
 		_, err := a.DecodeRerankResponse([]byte(`{}`))
 		require.Error(t, err)
-		convErr, ok := err.(*conversion.ConversionError)
-		require.True(t, ok)
+		var convErr *conversion.ConversionError
+		require.ErrorAs(t, err, &convErr)
 		assert.Equal(t, conversion.ErrorCodeInterfaceNotSupported, convErr.Code)
 	})
 
 	t.Run("编码重排序响应", func(t *testing.T) {
 		_, err := a.EncodeRerankResponse(&canonical.CanonicalRerankResponse{})
 		require.Error(t, err)
-		convErr, ok := err.(*conversion.ConversionError)
-		require.True(t, ok)
+		var convErr *conversion.ConversionError
+		require.ErrorAs(t, err, &convErr)
 		assert.Equal(t, conversion.ErrorCodeInterfaceNotSupported, convErr.Code)
 	})
 }

backend/internal/conversion/anthropic/decoder.go

@@ -28,7 +28,10 @@ func decodeRequest(body []byte) (*canonical.CanonicalRequest, error) {
 
 	var canonicalMsgs []canonical.CanonicalMessage
 	for _, msg := range req.Messages {
-		decoded := decodeMessage(msg)
+		decoded, err := decodeMessage(msg)
+		if err != nil {
+			return nil, conversion.NewConversionError(conversion.ErrorCodeJSONParseError, "解析消息内容失败").WithCause(err)
+		}
 		canonicalMsgs = append(canonicalMsgs, decoded...)
 	}
 
@@ -94,10 +97,13 @@ func decodeSystem(system any) any {
 }
 
 // decodeMessage 解码 Anthropic 消息
-func decodeMessage(msg Message) []canonical.CanonicalMessage {
+func decodeMessage(msg Message) ([]canonical.CanonicalMessage, error) {
 	switch msg.Role {
 	case "user":
-		blocks := decodeContentBlocks(msg.Content)
+		blocks, err := decodeContentBlocks(msg.Content)
+		if err != nil {
+			return nil, err
+		}
 		var toolResults []canonical.ContentBlock
 		var others []canonical.ContentBlock
 		for _, b := range blocks {
@@ -117,58 +123,83 @@ func decodeMessage(msg Message) []canonical.CanonicalMessage {
 		if len(result) == 0 {
 			result = append(result, canonical.CanonicalMessage{Role: canonical.RoleUser, Content: []canonical.ContentBlock{canonical.NewTextBlock("")}})
 		}
-		return result
+		return result, nil
 
 	case "assistant":
-		blocks := decodeContentBlocks(msg.Content)
+		blocks, err := decodeContentBlocks(msg.Content)
+		if err != nil {
+			return nil, err
+		}
 		if len(blocks) == 0 {
 			blocks = append(blocks, canonical.NewTextBlock(""))
 		}
-		return []canonical.CanonicalMessage{{Role: canonical.RoleAssistant, Content: blocks}}
+		return []canonical.CanonicalMessage{{Role: canonical.RoleAssistant, Content: blocks}}, nil
 	}
-	return nil
+	return nil, nil
 }
 
 // decodeContentBlocks 解码内容块列表
-func decodeContentBlocks(content any) []canonical.ContentBlock {
+func decodeContentBlocks(content any) ([]canonical.ContentBlock, error) {
 	switch v := content.(type) {
 	case string:
-		return []canonical.ContentBlock{canonical.NewTextBlock(v)}
+		return []canonical.ContentBlock{canonical.NewTextBlock(v)}, nil
 	case []any:
 		var blocks []canonical.ContentBlock
 		for _, item := range v {
 			if m, ok := item.(map[string]any); ok {
-				block := decodeSingleContentBlock(m)
+				block, err := decodeSingleContentBlock(m)
+				if err != nil {
+					return nil, err
+				}
 				if block != nil {
 					blocks = append(blocks, *block)
 				}
 			}
 		}
 		if len(blocks) > 0 {
-			return blocks
+			return blocks, nil
 		}
-		return []canonical.ContentBlock{canonical.NewTextBlock("")}
+		return []canonical.ContentBlock{canonical.NewTextBlock("")}, nil
 	case nil:
-		return []canonical.ContentBlock{canonical.NewTextBlock("")}
+		return []canonical.ContentBlock{canonical.NewTextBlock("")}, nil
 	default:
-		return []canonical.ContentBlock{canonical.NewTextBlock(fmt.Sprintf("%v", v))}
+		return []canonical.ContentBlock{canonical.NewTextBlock(fmt.Sprintf("%v", v))}, nil
 	}
 }
 
 // decodeSingleContentBlock 解码单个内容块
-func decodeSingleContentBlock(m map[string]any) *canonical.ContentBlock {
-	t, _ := m["type"].(string)
+func decodeSingleContentBlock(m map[string]any) (*canonical.ContentBlock, error) {
+	t, ok := m["type"].(string)
+	if !ok {
+		return nil, nil
+	}
+
 	switch t {
 	case "text":
-		text, _ := m["text"].(string)
-		return &canonical.ContentBlock{Type: "text", Text: text}
+		text, ok := m["text"].(string)
+		if !ok {
+			text = ""
+		}
+		return &canonical.ContentBlock{Type: "text", Text: text}, nil
 	case "tool_use":
-		id, _ := m["id"].(string)
-		name, _ := m["name"].(string)
-		input, _ := json.Marshal(m["input"])
-		return &canonical.ContentBlock{Type: "tool_use", ID: id, Name: name, Input: input}
+		id, ok := m["id"].(string)
+		if !ok {
+			id = ""
+		}
+		name, ok := m["name"].(string)
+		if !ok {
+			name = ""
+		}
+		input, err := json.Marshal(m["input"])
+		if err != nil {
+			return nil, err
+		}
+		return &canonical.ContentBlock{Type: "tool_use", ID: id, Name: name, Input: input}, nil
 	case "tool_result":
-		toolUseID, _ := m["tool_use_id"].(string)
+		toolUseID, ok := m["tool_use_id"].(string)
+		if !ok {
+			toolUseID = ""
+		}
 		isErr := false
 		if ie, ok := m["is_error"].(bool); ok {
 			isErr = ie
@@ -179,7 +210,11 @@ func decodeSingleContentBlock(m map[string]any) *canonical.ContentBlock {
 			case string:
 				content = json.RawMessage(fmt.Sprintf("%q", cv))
 			default:
-				content, _ = json.Marshal(cv)
+				encoded, err := json.Marshal(cv)
+				if err != nil {
+					return nil, err
+				}
+				content = encoded
 			}
 		} else {
 			content = json.RawMessage(`""`)
@@ -189,15 +224,18 @@ func decodeSingleContentBlock(m map[string]any) *canonical.ContentBlock {
 			ToolUseID: toolUseID,
 			Content:   content,
 			IsError:   &isErr,
-		}
+		}, nil
 	case "thinking":
-		thinking, _ := m["thinking"].(string)
-		return &canonical.ContentBlock{Type: "thinking", Thinking: thinking}
+		thinking, ok := m["thinking"].(string)
+		if !ok {
+			thinking = ""
+		}
+		return &canonical.ContentBlock{Type: "thinking", Thinking: thinking}, nil
 	case "redacted_thinking":
 		// 丢弃
-		return nil
+		return nil, nil
 	}
-	return nil
+	return nil, nil
 }
 
 // decodeTools 解码工具定义
@@ -232,7 +270,10 @@ func decodeToolChoice(toolChoice any) *canonical.ToolChoice {
 			return canonical.NewToolChoiceAny()
 		}
 	case map[string]any:
-		t, _ := v["type"].(string)
+		t, ok := v["type"].(string)
+		if !ok {
+			return nil
+		}
 		switch t {
 		case "auto":
 			return canonical.NewToolChoiceAuto()
@@ -241,7 +282,10 @@ func decodeToolChoice(toolChoice any) *canonical.ToolChoice {
 		case "any":
 			return canonical.NewToolChoiceAny()
 		case "tool":
-			name, _ := v["name"].(string)
+			name, ok := v["name"].(string)
+			if !ok {
+				name = ""
+			}
 			return canonical.NewToolChoiceNamed(name)
 		}
 	}

backend/internal/conversion/anthropic/encoder.go

@@ -182,7 +182,7 @@ func encodeContentBlocks(blocks []canonical.ContentBlock) []map[string]any {
 			result = append(result, m)
 		case "tool_result":
 			m := map[string]any{
-				"type":       "tool_result",
+				"type":        "tool_result",
 				"tool_use_id": b.ToolUseID,
 			}
 			if b.Content != nil {
@@ -335,11 +335,11 @@ func encodeResponse(resp *canonical.CanonicalResponse) ([]byte, error) {
 	}
 
 	result := map[string]any{
-		"id":      resp.ID,
-		"type":    "message",
-		"role":    "assistant",
-		"model":   resp.Model,
-		"content": blocks,
+		"id":            resp.ID,
+		"type":          "message",
+		"role":          "assistant",
+		"model":         resp.Model,
+		"content":       blocks,
 		"stop_reason":   sr,
 		"stop_sequence": nil,
 		"usage":         usage,

backend/internal/conversion/anthropic/encoder_test.go

@@ -33,7 +33,8 @@ func TestEncodeRequest_Basic(t *testing.T) {
 	assert.Equal(t, true, result["stream"])
 	assert.Equal(t, float64(1024), result["max_tokens"])
 
-	msgs := result["messages"].([]any)
+	msgs, ok := result["messages"].([]any)
+	require.True(t, ok)
 	assert.Len(t, msgs, 1)
 }
 
@@ -55,17 +56,20 @@ func TestEncodeRequest_ToolMergeIntoUser(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	msgs := result["messages"].([]any)
+	msgs, ok := result["messages"].([]any)
+	require.True(t, ok)
 
 	// tool 消息应被合并到相邻 user 消息
 	foundToolResult := false
 	for _, m := range msgs {
-		msgMap := m.(map[string]any)
+		msgMap, ok := m.(map[string]any)
+		require.True(t, ok)
 		if msgMap["role"] == "user" {
 			content, ok := msgMap["content"].([]any)
 			if ok {
 				for _, c := range content {
-					block := c.(map[string]any)
+					block, ok := c.(map[string]any)
+					require.True(t, ok)
 					if block["type"] == "tool_result" {
 						foundToolResult = true
 					}
@@ -93,8 +97,10 @@ func TestEncodeRequest_FirstUserGuarantee(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	msgs := result["messages"].([]any)
-	firstMsg := msgs[0].(map[string]any)
+	msgs, ok := result["messages"].([]any)
+	require.True(t, ok)
+	firstMsg, ok := msgs[0].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "user", firstMsg["role"])
 }
 
@@ -140,9 +146,11 @@ func TestEncodeResponse_Basic(t *testing.T) {
 	assert.Equal(t, "assistant", result["role"])
 	assert.Equal(t, "end_turn", result["stop_reason"])
 
-	content := result["content"].([]any)
+	content, ok := result["content"].([]any)
+	require.True(t, ok)
 	assert.Len(t, content, 1)
-	block := content[0].(map[string]any)
+	block, ok := content[0].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "text", block["type"])
 	assert.Equal(t, "你好", block["text"])
 }
@@ -160,10 +168,12 @@ func TestEncodeModelsResponse(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	data := result["data"].([]any)
+	data, ok := result["data"].([]any)
+	require.True(t, ok)
 	assert.Len(t, data, 1)
 
-	model := data[0].(map[string]any)
+	model, ok := data[0].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "claude-3-opus", model["id"])
 	// created 应为 RFC3339 格式
 	createdAt, ok := model["created_at"].(string)
@@ -280,11 +290,14 @@ func TestEncodeRequest_ConsecutiveRoleMerge(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	msgs := result["messages"].([]any)
+	msgs, ok := result["messages"].([]any)
+	require.True(t, ok)
 	assert.Len(t, msgs, 1)
-	userMsg := msgs[0].(map[string]any)
+	userMsg, ok := msgs[0].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "user", userMsg["role"])
-	content := userMsg["content"].([]any)
+	content, ok := userMsg["content"].([]any)
+	require.True(t, ok)
 	assert.Len(t, content, 2)
 }
 
@@ -321,7 +334,8 @@ func TestEncodeResponse_ReasoningTokens(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	usage := result["usage"].(map[string]any)
+	usage, ok := result["usage"].(map[string]any)
+	require.True(t, ok)
 	_, hasReasoning := usage["reasoning_tokens"]
 	assert.False(t, hasReasoning)
 }
@@ -341,9 +355,11 @@ func TestEncodeResponse_ToolUse(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	content := result["content"].([]any)
+	content, ok := result["content"].([]any)
+	require.True(t, ok)
 	assert.Len(t, content, 1)
-	block := content[0].(map[string]any)
+	block, ok := content[0].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "tool_use", block["type"])
 	assert.Equal(t, "tool_1", block["id"])
 	assert.Equal(t, "search", block["name"])

backend/internal/conversion/anthropic/stream_decoder.go

@@ -28,7 +28,7 @@ func NewStreamDecoder() *StreamDecoder {
 func (d *StreamDecoder) ProcessChunk(rawChunk []byte) []canonical.CanonicalStreamEvent {
 	data := rawChunk
 	if len(d.utf8Remainder) > 0 {
-		data = append(d.utf8Remainder, rawChunk...)
+		data = append(append([]byte{}, d.utf8Remainder...), rawChunk...)
 		d.utf8Remainder = nil
 	}
 
@@ -50,9 +50,10 @@ func (d *StreamDecoder) ProcessChunk(rawChunk []byte) []canonical.CanonicalStrea
 
 	for _, line := range strings.Split(text, "\n") {
 		line = strings.TrimRight(line, "\r")
-		if strings.HasPrefix(line, "event: ") {
+		switch {
+		case strings.HasPrefix(line, "event: "):
 			eventType = strings.TrimPrefix(line, "event: ")
-		} else if strings.HasPrefix(line, "data: ") {
+		case strings.HasPrefix(line, "data: "):
 			eventData = strings.TrimPrefix(line, "data: ")
 			if eventType != "" && eventData != "" {
 				chunkEvents := d.processEvent(eventType, []byte(eventData))
@@ -60,8 +61,8 @@ func (d *StreamDecoder) ProcessChunk(rawChunk []byte) []canonical.CanonicalStrea
 			}
 			eventType = ""
 			eventData = ""
-		} else if line == "" {
-			// SSE 事件分隔符
+		case line == "":
+			continue
 		}
 	}
 
@@ -135,7 +136,7 @@ func (d *StreamDecoder) processMessageStart(data []byte) []canonical.CanonicalSt
 // processContentBlockStart 处理内容块开始事件
 func (d *StreamDecoder) processContentBlockStart(data []byte) []canonical.CanonicalStreamEvent {
 	var raw struct {
-		Index        int    `json:"index"`
+		Index        int `json:"index"`
 		ContentBlock struct {
 			Type     string `json:"type"`
 			Text     string `json:"text"`

backend/internal/conversion/anthropic/stream_decoder_test.go

@@ -47,23 +47,23 @@ func TestStreamDecoder_ContentBlockDelta(t *testing.T) {
 		checkValue string
 	}{
 		{
-			name:      "text_delta",
-			deltaType: "text_delta",
-			deltaData: map[string]any{"type": "text_delta", "text": "你好"},
+			name:       "text_delta",
+			deltaType:  "text_delta",
+			deltaData:  map[string]any{"type": "text_delta", "text": "你好"},
 			checkField: "text",
 			checkValue: "你好",
 		},
 		{
-			name:      "input_json_delta",
-			deltaType: "input_json_delta",
-			deltaData: map[string]any{"type": "input_json_delta", "partial_json": "{\"key\":"},
+			name:       "input_json_delta",
+			deltaType:  "input_json_delta",
+			deltaData:  map[string]any{"type": "input_json_delta", "partial_json": "{\"key\":"},
 			checkField: "partial_json",
 			checkValue: "{\"key\":",
 		},
 		{
-			name:      "thinking_delta",
-			deltaType: "thinking_delta",
-			deltaData: map[string]any{"type": "thinking_delta", "thinking": "思考中"},
+			name:       "thinking_delta",
+			deltaType:  "thinking_delta",
+			deltaData:  map[string]any{"type": "thinking_delta", "thinking": "思考中"},
 			checkField: "thinking",
 			checkValue: "思考中",
 		},
@@ -74,7 +74,7 @@ func TestStreamDecoder_ContentBlockDelta(t *testing.T) {
 			payload := map[string]any{
 				"type":  "content_block_delta",
 				"index": 0,
-				"delta":  tt.deltaData,
+				"delta": tt.deltaData,
 			}
 			raw := makeAnthropicEvent("content_block_delta", payload)
 
@@ -298,7 +298,7 @@ func TestStreamDecoder_WebSearchToolResult_Suppressed(t *testing.T) {
 		"type":  "content_block_start",
 		"index": 3,
 		"content_block": map[string]any{
-			"type": "web_search_tool_result",
+			"type":        "web_search_tool_result",
 			"tool_use_id": "search_1",
 		},
 	}
@@ -331,8 +331,8 @@ func TestStreamDecoder_CitationsDelta_Discarded(t *testing.T) {
 		"type":  "content_block_delta",
 		"index": 0,
 		"delta": map[string]any{
-			"type":        "citations_delta",
-			"citation":    map[string]any{"title": "ref1"},
+			"type":     "citations_delta",
+			"citation": map[string]any{"title": "ref1"},
 		},
 	}
 	raw := makeAnthropicEvent("content_block_delta", payload)
@@ -466,7 +466,7 @@ func TestStreamDecoder_MessageDelta_UsageNotAccumulated(t *testing.T) {
 		},
 	}
 	deltaPayload1 := map[string]any{
-		"type": "message_delta",
+		"type":  "message_delta",
 		"delta": map[string]any{"stop_reason": "end_turn"},
 		"usage": map[string]any{"output_tokens": 25},
 	}
@@ -478,7 +478,7 @@ func TestStreamDecoder_MessageDelta_UsageNotAccumulated(t *testing.T) {
 	assert.Equal(t, 25, events[0].Usage.OutputTokens)
 
 	deltaPayload2 := map[string]any{
-		"type": "message_delta",
+		"type":  "message_delta",
 		"delta": map[string]any{"stop_reason": "end_turn"},
 		"usage": map[string]any{"output_tokens": 30},
 	}

backend/internal/conversion/anthropic/stream_encoder_test.go

@@ -80,7 +80,8 @@ func TestStreamEncoder_ContentBlockStart_Text(t *testing.T) {
 			break
 		}
 	}
-	cb := payload["content_block"].(map[string]any)
+	cb, ok := payload["content_block"].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "text", cb["type"])
 }
 
@@ -107,7 +108,8 @@ func TestStreamEncoder_ContentBlockStart_ToolUse(t *testing.T) {
 			break
 		}
 	}
-	cb := payload["content_block"].(map[string]any)
+	cb, ok := payload["content_block"].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "tool_use", cb["type"])
 	assert.Equal(t, "toolu_1", cb["id"])
 	assert.Equal(t, "search", cb["name"])
@@ -131,7 +133,8 @@ func TestStreamEncoder_ContentBlockStart_Thinking(t *testing.T) {
 			break
 		}
 	}
-	cb := payload["content_block"].(map[string]any)
+	cb, ok := payload["content_block"].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "thinking", cb["type"])
 }
 
@@ -173,7 +176,8 @@ func TestStreamEncoder_MessageDelta_WithStopReason(t *testing.T) {
 			break
 		}
 	}
-	delta := payload["delta"].(map[string]any)
+	delta, okd := payload["delta"].(map[string]any)
+	require.True(t, okd)
 	assert.Equal(t, "end_turn", delta["stop_reason"])
 }
 
@@ -199,7 +203,8 @@ func TestStreamEncoder_MessageDelta_WithUsage(t *testing.T) {
 			break
 		}
 	}
-	u := payload["usage"].(map[string]any)
+	u, oku := payload["usage"].(map[string]any)
+	require.True(t, oku)
 	assert.Equal(t, float64(88), u["output_tokens"])
 }
 

backend/internal/conversion/anthropic/supplemental_test.go

@@ -173,13 +173,15 @@ func TestDecodeMessage_UserWithOnlyToolResults(t *testing.T) {
 }
 
 func TestDecodeContentBlocks_Nil(t *testing.T) {
-	blocks := decodeContentBlocks(nil)
+	blocks, err := decodeContentBlocks(nil)
+	require.NoError(t, err)
 	assert.Len(t, blocks, 1)
 	assert.Equal(t, "", blocks[0].Text)
 }
 
 func TestDecodeContentBlocks_String(t *testing.T) {
-	blocks := decodeContentBlocks("hello")
+	blocks, err := decodeContentBlocks("hello")
+	require.NoError(t, err)
 	assert.Len(t, blocks, 1)
 	assert.Equal(t, "hello", blocks[0].Text)
 }
@@ -217,8 +219,10 @@ func TestEncodeToolChoice(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			result := encodeToolChoice(tt.choice)
-			assert.Equal(t, tt.want["type"], result.(map[string]any)["type"])
-			assert.Equal(t, tt.want["name"], result.(map[string]any)["name"])
+			r, ok := result.(map[string]any)
+			require.True(t, ok)
+			assert.Equal(t, tt.want["type"], r["type"])
+			assert.Equal(t, tt.want["name"], r["name"])
 		})
 	}
 }
@@ -315,12 +319,15 @@ func TestEncodeRequest_WithTools(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	tools := result["tools"].([]any)
+	tools, okt := result["tools"].([]any)
+	require.True(t, okt)
 	assert.Len(t, tools, 1)
-	tool := tools[0].(map[string]any)
+	tool, okt2 := tools[0].(map[string]any)
+	require.True(t, okt2)
 	assert.Equal(t, "search", tool["name"])
 	assert.Equal(t, "Search things", tool["description"])
-	tc := result["tool_choice"].(map[string]any)
+	tc, oktc := result["tool_choice"].(map[string]any)
+	require.True(t, oktc)
 	assert.Equal(t, "auto", tc["type"])
 }
 
@@ -354,9 +361,9 @@ func TestEncodeResponse_UsageWithCacheAndCreation(t *testing.T) {
 		Content:    []canonical.ContentBlock{canonical.NewTextBlock("ok")},
 		StopReason: &sr,
 		Usage: canonical.CanonicalUsage{
-			InputTokens:        100,
-			OutputTokens:       50,
-			CacheReadTokens:    &cacheRead,
+			InputTokens:         100,
+			OutputTokens:        50,
+			CacheReadTokens:     &cacheRead,
 			CacheCreationTokens: &cacheCreation,
 		},
 	}
@@ -366,7 +373,8 @@ func TestEncodeResponse_UsageWithCacheAndCreation(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	usage := result["usage"].(map[string]any)
+	usage, oku := result["usage"].(map[string]any)
+	require.True(t, oku)
 	assert.Equal(t, float64(100), usage["input_tokens"])
 	assert.Equal(t, float64(30), usage["cache_read_input_tokens"])
 	assert.Equal(t, float64(10), usage["cache_creation_input_tokens"])

backend/internal/conversion/anthropic/types.go

@@ -6,22 +6,22 @@ import (
 
 // MessagesRequest Anthropic Messages 请求
 type MessagesRequest struct {
-	Model               string          `json:"model"`
-	Messages            []Message       `json:"messages"`
-	System              any             `json:"system,omitempty"`
-	MaxTokens           int             `json:"max_tokens"`
-	Temperature         *float64        `json:"temperature,omitempty"`
-	TopP                *float64        `json:"top_p,omitempty"`
-	TopK                *int            `json:"top_k,omitempty"`
-	StopSequences       []string        `json:"stop_sequences,omitempty"`
-	Stream              bool            `json:"stream,omitempty"`
-	Tools               []Tool          `json:"tools,omitempty"`
-	ToolChoice          any             `json:"tool_choice,omitempty"`
-	Metadata            *RequestMetadata `json:"metadata,omitempty"`
-	Thinking            *ThinkingConfig `json:"thinking,omitempty"`
-	OutputConfig        *OutputConfig   `json:"output_config,omitempty"`
-	DisableParallelToolUse *bool        `json:"disable_parallel_tool_use,omitempty"`
-	Container           any             `json:"container,omitempty"`
+	Model                  string           `json:"model"`
+	Messages               []Message        `json:"messages"`
+	System                 any              `json:"system,omitempty"`
+	MaxTokens              int              `json:"max_tokens"`
+	Temperature            *float64         `json:"temperature,omitempty"`
+	TopP                   *float64         `json:"top_p,omitempty"`
+	TopK                   *int             `json:"top_k,omitempty"`
+	StopSequences          []string         `json:"stop_sequences,omitempty"`
+	Stream                 bool             `json:"stream,omitempty"`
+	Tools                  []Tool           `json:"tools,omitempty"`
+	ToolChoice             any              `json:"tool_choice,omitempty"`
+	Metadata               *RequestMetadata `json:"metadata,omitempty"`
+	Thinking               *ThinkingConfig  `json:"thinking,omitempty"`
+	OutputConfig           *OutputConfig    `json:"output_config,omitempty"`
+	DisableParallelToolUse *bool            `json:"disable_parallel_tool_use,omitempty"`
+	Container              any              `json:"container,omitempty"`
 }
 
 // RequestMetadata 请求元数据
@@ -122,8 +122,8 @@ type ContentBlock struct {
 
 // ResponseUsage 响应用量
 type ResponseUsage struct {
-	InputTokens              int `json:"input_tokens"`
-	OutputTokens             int `json:"output_tokens"`
+	InputTokens              int  `json:"input_tokens"`
+	OutputTokens             int  `json:"output_tokens"`
 	CacheReadInputTokens     *int `json:"cache_read_input_tokens,omitempty"`
 	CacheCreationInputTokens *int `json:"cache_creation_input_tokens,omitempty"`
 }

backend/internal/conversion/canonical/extended.go

@@ -38,8 +38,8 @@ type CanonicalEmbeddingResponse struct {
 
 // EmbeddingData 嵌入数据项
 type EmbeddingData struct {
-	Index     int    `json:"index"`
-	Embedding any    `json:"embedding"` // 根据格式不同可能是 []float64 或 base64 字符串
+	Index     int `json:"index"`
+	Embedding any `json:"embedding"` // 根据格式不同可能是 []float64 或 base64 字符串
 }
 
 // EmbeddingUsage 嵌入用量

backend/internal/conversion/canonical/stream.go

@@ -18,17 +18,17 @@ const (
 type DeltaType string
 
 const (
-	DeltaTypeText        DeltaType = "text_delta"
-	DeltaTypeInputJSON   DeltaType = "input_json_delta"
-	DeltaTypeThinking    DeltaType = "thinking_delta"
+	DeltaTypeText      DeltaType = "text_delta"
+	DeltaTypeInputJSON DeltaType = "input_json_delta"
+	DeltaTypeThinking  DeltaType = "thinking_delta"
 )
 
 // StreamDelta 流式增量联合体
 type StreamDelta struct {
-	Type         string `json:"type"`
-	Text         string `json:"text,omitempty"`
-	PartialJSON  string `json:"partial_json,omitempty"`
-	Thinking     string `json:"thinking,omitempty"`
+	Type        string `json:"type"`
+	Text        string `json:"text,omitempty"`
+	PartialJSON string `json:"partial_json,omitempty"`
+	Thinking    string `json:"thinking,omitempty"`
 }
 
 // StreamContentBlock 流式内容块联合体
@@ -48,12 +48,12 @@ type CanonicalStreamEvent struct {
 	Message *StreamMessage `json:"message,omitempty"`
 
 	// ContentBlockStartEvent / ContentBlockDeltaEvent / ContentBlockStopEvent
-	Index        *int              `json:"index,omitempty"`
+	Index        *int                `json:"index,omitempty"`
 	ContentBlock *StreamContentBlock `json:"content_block,omitempty"`
-	Delta        *StreamDelta      `json:"delta,omitempty"`
+	Delta        *StreamDelta        `json:"delta,omitempty"`
 
 	// MessageDeltaEvent
-	StopReason *StopReason    `json:"stop_reason,omitempty"`
+	StopReason *StopReason     `json:"stop_reason,omitempty"`
 	Usage      *CanonicalUsage `json:"usage,omitempty"`
 
 	// ErrorEvent

backend/internal/conversion/canonical/types.go

@@ -40,8 +40,8 @@ type ContentBlock struct {
 	Text string `json:"text,omitempty"`
 
 	// ToolUseBlock
-	ID   string          `json:"id,omitempty"`
-	Name string          `json:"name,omitempty"`
+	ID    string          `json:"id,omitempty"`
+	Name  string          `json:"name,omitempty"`
 	Input json.RawMessage `json:"input,omitempty"`
 
 	// ToolResultBlock
@@ -138,43 +138,43 @@ type ThinkingConfig struct {
 
 // OutputFormat 输出格式联合体
 type OutputFormat struct {
-	Type       string          `json:"type"`
-	Name       string          `json:"name,omitempty"`
-	Schema     json.RawMessage `json:"schema,omitempty"`
-	Strict     *bool           `json:"strict,omitempty"`
+	Type   string          `json:"type"`
+	Name   string          `json:"name,omitempty"`
+	Schema json.RawMessage `json:"schema,omitempty"`
+	Strict *bool           `json:"strict,omitempty"`
 }
 
 // CanonicalRequest 规范请求
 type CanonicalRequest struct {
-	Model           string            `json:"model"`
-	System          any               `json:"system,omitempty"` // nil, string, or []SystemBlock
+	Model           string             `json:"model"`
+	System          any                `json:"system,omitempty"` // nil, string, or []SystemBlock
 	Messages        []CanonicalMessage `json:"messages"`
-	Tools           []CanonicalTool   `json:"tools,omitempty"`
-	ToolChoice      *ToolChoice       `json:"tool_choice,omitempty"`
-	Parameters      RequestParameters `json:"parameters"`
-	Thinking        *ThinkingConfig   `json:"thinking,omitempty"`
-	Stream          bool              `json:"stream"`
-	UserID          string            `json:"user_id,omitempty"`
-	OutputFormat    *OutputFormat     `json:"output_format,omitempty"`
-	ParallelToolUse *bool             `json:"parallel_tool_use,omitempty"`
+	Tools           []CanonicalTool    `json:"tools,omitempty"`
+	ToolChoice      *ToolChoice        `json:"tool_choice,omitempty"`
+	Parameters      RequestParameters  `json:"parameters"`
+	Thinking        *ThinkingConfig    `json:"thinking,omitempty"`
+	Stream          bool               `json:"stream"`
+	UserID          string             `json:"user_id,omitempty"`
+	OutputFormat    *OutputFormat      `json:"output_format,omitempty"`
+	ParallelToolUse *bool              `json:"parallel_tool_use,omitempty"`
 }
 
 // CanonicalUsage 规范用量
 type CanonicalUsage struct {
-	InputTokens        int  `json:"input_tokens"`
-	OutputTokens       int  `json:"output_tokens"`
-	CacheReadTokens    *int `json:"cache_read_tokens,omitempty"`
+	InputTokens         int  `json:"input_tokens"`
+	OutputTokens        int  `json:"output_tokens"`
+	CacheReadTokens     *int `json:"cache_read_tokens,omitempty"`
 	CacheCreationTokens *int `json:"cache_creation_tokens,omitempty"`
-	ReasoningTokens    *int `json:"reasoning_tokens,omitempty"`
+	ReasoningTokens     *int `json:"reasoning_tokens,omitempty"`
 }
 
 // CanonicalResponse 规范响应
 type CanonicalResponse struct {
-	ID         string          `json:"id"`
-	Model      string          `json:"model"`
-	Content    []ContentBlock  `json:"content"`
-	StopReason *StopReason     `json:"stop_reason,omitempty"`
-	Usage      CanonicalUsage  `json:"usage"`
+	ID         string         `json:"id"`
+	Model      string         `json:"model"`
+	Content    []ContentBlock `json:"content"`
+	StopReason *StopReason    `json:"stop_reason,omitempty"`
+	Usage      CanonicalUsage `json:"usage"`
 }
 
 // GetSystemString 获取系统消息字符串

backend/internal/conversion/canonical/types_test.go

@@ -10,9 +10,9 @@ import (
 
 func TestGetSystemString(t *testing.T) {
 	tests := []struct {
-		name    string
-		system  any
-		want    string
+		name   string
+		system any
+		want   string
 	}{
 		{"string", "hello", "hello"},
 		{"nil", nil, ""},
@@ -97,11 +97,11 @@ func TestCanonicalRequest_RoundTrip(t *testing.T) {
 func TestCanonicalResponse_RoundTrip(t *testing.T) {
 	sr := StopReasonEndTurn
 	resp := &CanonicalResponse{
-		ID:      "resp-1",
-		Model:   "gpt-4",
-		Content: []ContentBlock{NewTextBlock("hello")},
+		ID:         "resp-1",
+		Model:      "gpt-4",
+		Content:    []ContentBlock{NewTextBlock("hello")},
 		StopReason: &sr,
-		Usage:   CanonicalUsage{InputTokens: 10, OutputTokens: 5},
+		Usage:      CanonicalUsage{InputTokens: 10, OutputTokens: 5},
 	}
 
 	data, err := json.Marshal(resp)

backend/internal/conversion/engine.go

@@ -114,7 +114,7 @@ func (e *ConversionEngine) ConvertHttpRequest(spec HTTPRequestSpec, clientProtoc
 	}
 
 	interfaceType := clientAdapter.DetectInterfaceType(nativePath)
-	providerUrl := providerAdapter.BuildUrl(nativePath, interfaceType)
+	providerURL := providerAdapter.BuildUrl(nativePath, interfaceType)
 	providerHeaders := providerAdapter.BuildHeaders(provider)
 	providerBody, err := e.convertBody(interfaceType, clientAdapter, providerAdapter, provider, spec.Body)
 	if err != nil {
@@ -122,7 +122,7 @@ func (e *ConversionEngine) ConvertHttpRequest(spec HTTPRequestSpec, clientProtoc
 	}
 
 	return &HTTPRequestSpec{
-		URL:     provider.BaseURL + providerUrl,
+		URL:     provider.BaseURL + providerURL,
 		Method:  spec.Method,
 		Headers: providerHeaders,
 		Body:    providerBody,
@@ -134,24 +134,21 @@ func (e *ConversionEngine) ConvertHttpResponse(spec HTTPResponseSpec, clientProt
 	if e.IsPassthrough(clientProtocol, providerProtocol) {
 		// Smart Passthrough: 同协议时最小化改写 model 字段
 		if modelOverride != "" && len(spec.Body) > 0 {
-			adapter, err := e.registry.Get(clientProtocol)
-			if err != nil {
-				return &spec, nil
-			}
-
-			rewrittenBody, err := adapter.RewriteResponseModelName(spec.Body, modelOverride, interfaceType)
-			if err != nil {
+			adapter, getErr := e.registry.Get(clientProtocol)
+			if getErr == nil {
+				rewrittenBody, rewriteErr := adapter.RewriteResponseModelName(spec.Body, modelOverride, interfaceType)
+				if rewriteErr != nil {
 					e.logger.Warn("Smart Passthrough 改写响应失败，使用原始响应体",
-						zap.Error(err),
+						zap.Error(rewriteErr),
 						zap.String("interface", string(interfaceType)))
-				return &spec, nil
+				} else {
+					return &HTTPResponseSpec{
+						StatusCode: spec.StatusCode,
+						Headers:    spec.Headers,
+						Body:       rewrittenBody,
+					}, nil
+				}
 			}
-
-			return &HTTPResponseSpec{
-				StatusCode: spec.StatusCode,
-				Headers:    spec.Headers,
-				Body:       rewrittenBody,
-			}, nil
 		}
 		return &spec, nil
 	}
@@ -182,11 +179,10 @@ func (e *ConversionEngine) CreateStreamConverter(clientProtocol, providerProtoco
 	if e.IsPassthrough(clientProtocol, providerProtocol) {
 		// Smart Passthrough: 同协议流式场景需要逐 chunk 改写 model 字段
 		if modelOverride != "" {
-			adapter, err := e.registry.Get(clientProtocol)
-			if err != nil {
-				return NewPassthroughStreamConverter(), nil
+			adapter, getErr := e.registry.Get(clientProtocol)
+			if getErr == nil {
+				return NewSmartPassthroughStreamConverter(adapter, modelOverride, interfaceType), nil
 			}
-			return NewSmartPassthroughStreamConverter(adapter, modelOverride, interfaceType), nil
 		}
 		return NewPassthroughStreamConverter(), nil
 	}
@@ -201,9 +197,9 @@ func (e *ConversionEngine) CreateStreamConverter(clientProtocol, providerProtoco
 	}
 
 	ctx := ConversionContext{
-		ConversionID:   uuid.New().String(),
-		InterfaceType:  InterfaceTypeChat,
-		Timestamp:      time.Now(),
+		ConversionID:  uuid.New().String(),
+		InterfaceType: InterfaceTypeChat,
+		Timestamp:     time.Now(),
 	}
 
 	return NewCanonicalStreamConverterWithMiddleware(
@@ -306,7 +302,7 @@ func (e *ConversionEngine) convertChatResponseBody(clientAdapter, providerAdapte
 func (e *ConversionEngine) convertModelsResponseBody(clientAdapter, providerAdapter ProtocolAdapter, body []byte) ([]byte, error) {
 	models, err := providerAdapter.DecodeModelsResponse(body)
 	if err != nil {
-		e.logger.Warn("解码 Models 响应失败，返回原始响应", zap.String("error", err.Error()))
+		e.logger.Warn("解码 Models 响应失败，返回原始响应", zap.Error(err))
 		return body, nil
 	}
 	encoded, err := clientAdapter.EncodeModelsResponse(models)
@@ -320,12 +316,12 @@ func (e *ConversionEngine) convertModelsResponseBody(clientAdapter, providerAdap
 func (e *ConversionEngine) convertModelInfoResponseBody(clientAdapter, providerAdapter ProtocolAdapter, body []byte) ([]byte, error) {
 	info, err := providerAdapter.DecodeModelInfoResponse(body)
 	if err != nil {
-		e.logger.Warn("解码 ModelInfo 响应失败，返回原始响应", zap.String("error", err.Error()))
+		e.logger.Warn("解码 ModelInfo 响应失败，返回原始响应", zap.Error(err))
 		return body, nil
 	}
 	encoded, err := clientAdapter.EncodeModelInfoResponse(info)
 	if err != nil {
-		e.logger.Warn("编码 ModelInfo 响应失败，返回原始响应", zap.String("error", err.Error()))
+		e.logger.Warn("编码 ModelInfo 响应失败，返回原始响应", zap.Error(err))
 		return body, nil
 	}
 	return encoded, nil
@@ -334,7 +330,7 @@ func (e *ConversionEngine) convertModelInfoResponseBody(clientAdapter, providerA
 func (e *ConversionEngine) convertEmbeddingBody(clientAdapter, providerAdapter ProtocolAdapter, provider *TargetProvider, body []byte) ([]byte, error) {
 	req, err := clientAdapter.DecodeEmbeddingRequest(body)
 	if err != nil {
-		e.logger.Warn("解码 Embedding 请求失败，返回原始请求", zap.String("error", err.Error()))
+		e.logger.Warn("解码 Embedding 请求失败，返回原始请求", zap.Error(err))
 		return body, nil
 	}
 	return providerAdapter.EncodeEmbeddingRequest(req, provider)
@@ -343,7 +339,7 @@ func (e *ConversionEngine) convertEmbeddingBody(clientAdapter, providerAdapter P
 func (e *ConversionEngine) convertEmbeddingResponseBody(clientAdapter, providerAdapter ProtocolAdapter, body []byte, modelOverride string) ([]byte, error) {
 	resp, err := providerAdapter.DecodeEmbeddingResponse(body)
 	if err != nil {
-		e.logger.Warn("解码 Embedding 响应失败，返回原始响应", zap.String("error", err.Error()))
+		e.logger.Warn("解码 Embedding 响应失败，返回原始响应", zap.Error(err))
 		return body, nil
 	}
 	if modelOverride != "" {
@@ -355,21 +351,22 @@ func (e *ConversionEngine) convertEmbeddingResponseBody(clientAdapter, providerA
 func (e *ConversionEngine) convertRerankBody(clientAdapter, providerAdapter ProtocolAdapter, provider *TargetProvider, body []byte) ([]byte, error) {
 	req, err := clientAdapter.DecodeRerankRequest(body)
 	if err != nil {
-		e.logger.Warn("解码 Rerank 请求失败，返回原始请求", zap.String("error", err.Error()))
+		e.logger.Warn("解码 Rerank 请求失败，返回原始请求", zap.Error(err))
 		return body, nil
 	}
 	return providerAdapter.EncodeRerankRequest(req, provider)
 }
 
 func (e *ConversionEngine) convertRerankResponseBody(clientAdapter, providerAdapter ProtocolAdapter, body []byte, modelOverride string) ([]byte, error) {
-	resp, err := providerAdapter.DecodeRerankResponse(body)
-	if err != nil {
-		return body, nil
+	resp, decodeErr := providerAdapter.DecodeRerankResponse(body)
+	if decodeErr == nil {
+		if modelOverride != "" {
+			resp.Model = modelOverride
+		}
+		return clientAdapter.EncodeRerankResponse(resp)
 	}
-	if modelOverride != "" {
-		resp.Model = modelOverride
-	}
-	return clientAdapter.EncodeRerankResponse(resp)
+
+	return body, nil
 }
 
 // DetectInterfaceType 检测接口类型
@@ -391,8 +388,12 @@ func (e *ConversionEngine) EncodeError(err *ConversionError, clientProtocol stri
 				"type":    "internal_error",
 			},
 		}
-		body, _ := json.Marshal(fallback)
-		return body, 500, nil
+		body, marshalErr := json.Marshal(fallback)
+		if marshalErr == nil {
+			return body, 500, nil
+		}
+
+		return []byte(`{"error":{"message":"internal error","type":"internal_error"}}`), 500, nil
 	}
 	body, statusCode := adapter.EncodeError(err)
 	return body, statusCode, nil

backend/internal/conversion/engine_test.go

@@ -38,8 +38,8 @@ func newMockAdapter(name string, passthrough bool) *mockProtocolAdapter {
 	}
 }
 
-func (m *mockProtocolAdapter) ProtocolName() string  { return m.protocolName }
-func (m *mockProtocolAdapter) ProtocolVersion() string { return "1.0" }
+func (m *mockProtocolAdapter) ProtocolName() string      { return m.protocolName }
+func (m *mockProtocolAdapter) ProtocolVersion() string   { return "1.0" }
 func (m *mockProtocolAdapter) SupportsPassthrough() bool { return m.passthrough }
 
 func (m *mockProtocolAdapter) DetectInterfaceType(nativePath string) InterfaceType {
@@ -190,14 +190,16 @@ func (m *mockProtocolAdapter) RewriteResponseModelName(body []byte, newModel str
 // noopStreamDecoder 空流式解码器
 type noopStreamDecoder struct{}
 
-func (d *noopStreamDecoder) ProcessChunk(rawChunk []byte) []canonical.CanonicalStreamEvent { return nil }
-func (d *noopStreamDecoder) Flush() []canonical.CanonicalStreamEvent                       { return nil }
+func (d *noopStreamDecoder) ProcessChunk(rawChunk []byte) []canonical.CanonicalStreamEvent {
+	return nil
+}
+func (d *noopStreamDecoder) Flush() []canonical.CanonicalStreamEvent { return nil }
 
 // noopStreamEncoder 空流式编码器
 type noopStreamEncoder struct{}
 
 func (e *noopStreamEncoder) EncodeEvent(event canonical.CanonicalStreamEvent) [][]byte { return nil }
-func (e *noopStreamEncoder) Flush() [][]byte                                          { return nil }
+func (e *noopStreamEncoder) Flush() [][]byte                                           { return nil }
 
 // ============ 测试用例 ============
 
@@ -615,6 +617,7 @@ func (d *engineTestStreamDecoder) ProcessChunk(raw []byte) []canonical.Canonical
 	}
 	return nil
 }
+
 func (d *engineTestStreamDecoder) Flush() []canonical.CanonicalStreamEvent {
 	if d.flushFn != nil {
 		return d.flushFn()
@@ -634,6 +637,7 @@ func (e *engineTestStreamEncoder) EncodeEvent(event canonical.CanonicalStreamEve
 	}
 	return nil
 }
+
 func (e *engineTestStreamEncoder) Flush() [][]byte {
 	if e.flushFn != nil {
 		return e.flushFn()

backend/internal/conversion/errors.go

@@ -6,17 +6,17 @@ import "fmt"
 type ErrorCode string
 
 const (
-	ErrorCodeInvalidInput            ErrorCode = "INVALID_INPUT"
-	ErrorCodeMissingRequiredField    ErrorCode = "MISSING_REQUIRED_FIELD"
-	ErrorCodeIncompatibleFeature     ErrorCode = "INCOMPATIBLE_FEATURE"
-	ErrorCodeFieldMappingFailure     ErrorCode = "FIELD_MAPPING_FAILURE"
-	ErrorCodeToolCallParseError      ErrorCode = "TOOL_CALL_PARSE_ERROR"
-	ErrorCodeJSONParseError          ErrorCode = "JSON_PARSE_ERROR"
-	ErrorCodeStreamStateError        ErrorCode = "STREAM_STATE_ERROR"
-	ErrorCodeUTF8DecodeError         ErrorCode = "UTF8_DECODE_ERROR"
-	ErrorCodeProtocolConstraint      ErrorCode = "PROTOCOL_CONSTRAINT_VIOLATION"
-	ErrorCodeEncodingFailure         ErrorCode = "ENCODING_FAILURE"
-	ErrorCodeInterfaceNotSupported   ErrorCode = "INTERFACE_NOT_SUPPORTED"
+	ErrorCodeInvalidInput          ErrorCode = "INVALID_INPUT"
+	ErrorCodeMissingRequiredField  ErrorCode = "MISSING_REQUIRED_FIELD"
+	ErrorCodeIncompatibleFeature   ErrorCode = "INCOMPATIBLE_FEATURE"
+	ErrorCodeFieldMappingFailure   ErrorCode = "FIELD_MAPPING_FAILURE"
+	ErrorCodeToolCallParseError    ErrorCode = "TOOL_CALL_PARSE_ERROR"
+	ErrorCodeJSONParseError        ErrorCode = "JSON_PARSE_ERROR"
+	ErrorCodeStreamStateError      ErrorCode = "STREAM_STATE_ERROR"
+	ErrorCodeUTF8DecodeError       ErrorCode = "UTF8_DECODE_ERROR"
+	ErrorCodeProtocolConstraint    ErrorCode = "PROTOCOL_CONSTRAINT_VIOLATION"
+	ErrorCodeEncodingFailure       ErrorCode = "ENCODING_FAILURE"
+	ErrorCodeInterfaceNotSupported ErrorCode = "INTERFACE_NOT_SUPPORTED"
 )
 
 // ConversionError 协议转换错误

backend/internal/conversion/interface.go

@@ -4,10 +4,10 @@ package conversion
 type InterfaceType string
 
 const (
-	InterfaceTypeChat      InterfaceType = "CHAT"
-	InterfaceTypeModels    InterfaceType = "MODELS"
-	InterfaceTypeModelInfo InterfaceType = "MODEL_INFO"
-	InterfaceTypeEmbeddings InterfaceType = "EMBEDDINGS"
-	InterfaceTypeRerank    InterfaceType = "RERANK"
+	InterfaceTypeChat        InterfaceType = "CHAT"
+	InterfaceTypeModels      InterfaceType = "MODELS"
+	InterfaceTypeModelInfo   InterfaceType = "MODEL_INFO"
+	InterfaceTypeEmbeddings  InterfaceType = "EMBEDDINGS"
+	InterfaceTypeRerank      InterfaceType = "RERANK"
 	InterfaceTypePassthrough InterfaceType = "PASSTHROUGH"
 )

backend/internal/conversion/openai/adapter.go

@@ -138,7 +138,10 @@ func (a *Adapter) EncodeError(err *conversion.ConversionError) ([]byte, int) {
 			Code:    string(err.Code),
 		},
 	}
-	body, _ := json.Marshal(errMsg)
+	body, marshalErr := json.Marshal(errMsg)
+	if marshalErr != nil {
+		return []byte(`{"error":{"message":"internal error","type":"internal_error","code":"INTERNAL_ERROR"}}`), statusCode
+	}
 	return body, statusCode
 }
 
@@ -248,7 +251,11 @@ func locateModelFieldInRequest(body []byte, ifaceType conversion.InterfaceType)
 			return "", nil, err
 		}
 		rewriteFunc := func(newModel string) ([]byte, error) {
-			m["model"], _ = json.Marshal(newModel)
+			encodedModel, err := json.Marshal(newModel)
+			if err != nil {
+				return nil, err
+			}
+			m["model"] = encodedModel
 			return json.Marshal(m)
 		}
 		return current, rewriteFunc, nil
@@ -282,12 +289,20 @@ func (a *Adapter) RewriteResponseModelName(body []byte, newModel string, ifaceTy
 	switch ifaceType {
 	case conversion.InterfaceTypeChat, conversion.InterfaceTypeEmbeddings:
 		// Chat/Embedding 响应必须有 model 字段（协议要求），存在则改写，不存在则添加
-		m["model"], _ = json.Marshal(newModel)
+		encodedModel, err := json.Marshal(newModel)
+		if err != nil {
+			return nil, err
+		}
+		m["model"] = encodedModel
 		return json.Marshal(m)
 	case conversion.InterfaceTypeRerank:
 		// Rerank 响应：存在 model 字段则改写，不存在则不添加
 		if _, exists := m["model"]; exists {
-			m["model"], _ = json.Marshal(newModel)
+			encodedModel, err := json.Marshal(newModel)
+			if err != nil {
+				return nil, err
+			}
+			m["model"] = encodedModel
 		}
 		return json.Marshal(m)
 	default:

backend/internal/conversion/openai/adapter_test.go

@@ -48,10 +48,10 @@ func TestAdapter_BuildUrl(t *testing.T) {
 	a := NewAdapter()
 
 	tests := []struct {
-		name         string
-		nativePath   string
+		name          string
+		nativePath    string
 		interfaceType conversion.InterfaceType
-		expected     string
+		expected      string
 	}{
 		{"聊天", "/chat/completions", conversion.InterfaceTypeChat, "/chat/completions"},
 		{"模型", "/models", conversion.InterfaceTypeModels, "/models"},
@@ -92,9 +92,9 @@ func TestAdapter_SupportsInterface(t *testing.T) {
 	a := NewAdapter()
 
 	tests := []struct {
-		name         string
+		name          string
 		interfaceType conversion.InterfaceType
-		expected     bool
+		expected      bool
 	}{
 		{"聊天", conversion.InterfaceTypeChat, true},
 		{"模型", conversion.InterfaceTypeModels, true},

backend/internal/conversion/openai/decoder.go

@@ -215,10 +215,16 @@ func decodeUserContent(content any) []canonical.ContentBlock {
 		var blocks []canonical.ContentBlock
 		for _, item := range v {
 			if m, ok := item.(map[string]any); ok {
-				t, _ := m["type"].(string)
+				t, ok := m["type"].(string)
+				if !ok {
+					continue
+				}
 				switch t {
 				case "text":
-					text, _ := m["text"].(string)
+					text, ok := m["text"].(string)
+					if !ok {
+						text = ""
+					}
 					blocks = append(blocks, canonical.NewTextBlock(text))
 				case "image_url":
 					blocks = append(blocks, canonical.ContentBlock{Type: "image"})
@@ -242,9 +248,9 @@ func decodeUserContent(content any) []canonical.ContentBlock {
 
 // contentPart 内容部分
 type contentPart struct {
-	Type     string
-	Text     string
-	Refusal  string
+	Type    string
+	Text    string
+	Refusal string
 }
 
 // decodeContentParts 解码内容部分
@@ -256,13 +262,22 @@ func decodeContentParts(content any) []contentPart {
 	var result []contentPart
 	for _, item := range parts {
 		if m, ok := item.(map[string]any); ok {
-			t, _ := m["type"].(string)
+			t, ok := m["type"].(string)
+			if !ok {
+				continue
+			}
 			switch t {
 			case "text":
-				text, _ := m["text"].(string)
+				text, ok := m["text"].(string)
+				if !ok {
+					text = ""
+				}
 				result = append(result, contentPart{Type: "text", Text: text})
 			case "refusal":
-				refusal, _ := m["refusal"].(string)
+				refusal, ok := m["refusal"].(string)
+				if !ok {
+					refusal = ""
+				}
 				result = append(result, contentPart{Type: "refusal", Refusal: refusal})
 			}
 		}
@@ -307,21 +322,33 @@ func decodeToolChoice(toolChoice any) *canonical.ToolChoice {
 			return canonical.NewToolChoiceAny()
 		}
 	case map[string]any:
-		t, _ := v["type"].(string)
+		t, ok := v["type"].(string)
+		if !ok {
+			return nil
+		}
 		switch t {
 		case "function":
 			if fn, ok := v["function"].(map[string]any); ok {
-				name, _ := fn["name"].(string)
+				name, ok := fn["name"].(string)
+				if !ok {
+					name = ""
+				}
 				return canonical.NewToolChoiceNamed(name)
 			}
 		case "custom":
 			if custom, ok := v["custom"].(map[string]any); ok {
-				name, _ := custom["name"].(string)
+				name, ok := custom["name"].(string)
+				if !ok {
+					name = ""
+				}
 				return canonical.NewToolChoiceNamed(name)
 			}
 		case "allowed_tools":
 			if at, ok := v["allowed_tools"].(map[string]any); ok {
-				mode, _ := at["mode"].(string)
+				mode, ok := at["mode"].(string)
+				if !ok {
+					mode = ""
+				}
 				if mode == "required" {
 					return canonical.NewToolChoiceAny()
 				}
@@ -443,7 +470,7 @@ func decodeDeprecatedFields(req *ChatCompletionRequest) {
 		case map[string]any:
 			if name, ok := v["name"].(string); ok {
 				req.ToolChoice = map[string]any{
-					"type": "function",
+					"type":     "function",
 					"function": map[string]any{"name": name},
 				}
 			}

backend/internal/conversion/openai/encoder.go

@@ -450,7 +450,7 @@ func encodeEmbeddingResponse(resp *canonical.CanonicalEmbeddingResponse) ([]byte
 		"object": "list",
 		"data":   data,
 		"model":  resp.Model,
-		"usage":   resp.Usage,
+		"usage":  resp.Usage,
 	})
 }
 

backend/internal/conversion/openai/encoder_test.go

@@ -45,9 +45,11 @@ func TestEncodeRequest_SystemInjection(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	msgs := result["messages"].([]any)
+	msgs, ok := result["messages"].([]any)
+	require.True(t, ok)
 	assert.Len(t, msgs, 2)
-	firstMsg := msgs[0].(map[string]any)
+	firstMsg, ok := msgs[0].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "system", firstMsg["role"])
 	assert.Equal(t, "你是助手", firstMsg["content"])
 }
@@ -72,12 +74,15 @@ func TestEncodeRequest_ToolCalls(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	msgs := result["messages"].([]any)
-	assistantMsg := msgs[0].(map[string]any)
+	msgs, ok := result["messages"].([]any)
+	require.True(t, ok)
+	assistantMsg, ok := msgs[0].(map[string]any)
+	require.True(t, ok)
 	toolCalls, ok := assistantMsg["tool_calls"].([]any)
 	require.True(t, ok)
 	assert.Len(t, toolCalls, 1)
-	tc := toolCalls[0].(map[string]any)
+	tc, ok := toolCalls[0].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "call_1", tc["id"])
 }
 
@@ -100,11 +105,11 @@ func TestEncodeRequest_Thinking(t *testing.T) {
 func TestEncodeResponse_Basic(t *testing.T) {
 	sr := canonical.StopReasonEndTurn
 	resp := &canonical.CanonicalResponse{
-		ID:      "resp-1",
-		Model:   "gpt-4",
-		Content: []canonical.ContentBlock{canonical.NewTextBlock("你好")},
+		ID:         "resp-1",
+		Model:      "gpt-4",
+		Content:    []canonical.ContentBlock{canonical.NewTextBlock("你好")},
 		StopReason: &sr,
-		Usage:   canonical.CanonicalUsage{InputTokens: 10, OutputTokens: 5},
+		Usage:      canonical.CanonicalUsage{InputTokens: 10, OutputTokens: 5},
 	}
 
 	body, err := encodeResponse(resp)
@@ -115,9 +120,12 @@ func TestEncodeResponse_Basic(t *testing.T) {
 	assert.Equal(t, "resp-1", result["id"])
 	assert.Equal(t, "chat.completion", result["object"])
 
-	choices := result["choices"].([]any)
-	choice := choices[0].(map[string]any)
-	msg := choice["message"].(map[string]any)
+	choices, ok := result["choices"].([]any)
+	require.True(t, ok)
+	choice, ok := choices[0].(map[string]any)
+	require.True(t, ok)
+	msg, ok := choice["message"].(map[string]any)
+	require.True(t, ok)
 	assert.Equal(t, "你好", msg["content"])
 	assert.Equal(t, "stop", choice["finish_reason"])
 }
@@ -126,9 +134,9 @@ func TestEncodeResponse_ToolUse(t *testing.T) {
 	sr := canonical.StopReasonToolUse
 	input := json.RawMessage(`{"q":"test"}`)
 	resp := &canonical.CanonicalResponse{
-		ID:      "resp-2",
-		Model:   "gpt-4",
-		Content: []canonical.ContentBlock{canonical.NewToolUseBlock("call_1", "search", input)},
+		ID:         "resp-2",
+		Model:      "gpt-4",
+		Content:    []canonical.ContentBlock{canonical.NewToolUseBlock("call_1", "search", input)},
 		StopReason: &sr,
 	}
 
@@ -137,8 +145,12 @@ func TestEncodeResponse_ToolUse(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	choices := result["choices"].([]any)
-	msg := choices[0].(map[string]any)["message"].(map[string]any)
+	choices, okc := result["choices"].([]any)
+	require.True(t, okc)
+	msgMap, okm := choices[0].(map[string]any)
+	require.True(t, okm)
+	msg, okmsg := msgMap["message"].(map[string]any)
+	require.True(t, okmsg)
 	tcs, ok := msg["tool_calls"].([]any)
 	require.True(t, ok)
 	assert.Len(t, tcs, 1)
@@ -158,7 +170,8 @@ func TestEncodeModelsResponse(t *testing.T) {
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
 	assert.Equal(t, "list", result["object"])
-	data := result["data"].([]any)
+	data, okd := result["data"].([]any)
+	require.True(t, okd)
 	assert.Len(t, data, 2)
 }
 
@@ -317,8 +330,12 @@ func TestEncodeResponse_Thinking(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	choices := result["choices"].([]any)
-	msg := choices[0].(map[string]any)["message"].(map[string]any)
+	choices, okch := result["choices"].([]any)
+	require.True(t, okch)
+	msgMap, okmm := choices[0].(map[string]any)
+	require.True(t, okmm)
+	msg, okmsg := msgMap["message"].(map[string]any)
+	require.True(t, okmsg)
 	assert.Equal(t, "回答", msg["content"])
 	assert.Equal(t, "思考过程", msg["reasoning_content"])
 }

backend/internal/conversion/openai/stream_decoder_test.go

@@ -18,9 +18,9 @@ func TestStreamDecoder_BasicText(t *testing.T) {
 	d := NewStreamDecoder()
 
 	chunk := map[string]any{
-		"id":      "chatcmpl-1",
-		"object":  "chat.completion.chunk",
-		"model":   "gpt-4",
+		"id":     "chatcmpl-1",
+		"object": "chat.completion.chunk",
+		"model":  "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -56,8 +56,8 @@ func TestStreamDecoder_ToolCalls(t *testing.T) {
 
 	idx := 0
 	chunk := map[string]any{
-		"id":     "chatcmpl-1",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-1",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -98,8 +98,8 @@ func TestStreamDecoder_Thinking(t *testing.T) {
 	d := NewStreamDecoder()
 
 	chunk := map[string]any{
-		"id":     "chatcmpl-1",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-1",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -127,8 +127,8 @@ func TestStreamDecoder_FinishReason(t *testing.T) {
 	d := NewStreamDecoder()
 
 	chunk := map[string]any{
-		"id":     "chatcmpl-1",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-1",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index":         0,
@@ -161,8 +161,8 @@ func TestStreamDecoder_DoneSignal(t *testing.T) {
 
 	// 先发送一个文本 chunk
 	chunk := map[string]any{
-		"id":     "chatcmpl-1",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-1",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -190,8 +190,8 @@ func TestStreamDecoder_RefusalReuse(t *testing.T) {
 	// 连续两个 refusal delta chunk
 	for _, text := range []string{"拒绝", "原因"} {
 		chunk := map[string]any{
-			"id":     "chatcmpl-1",
-			"model":  "gpt-4",
+			"id":    "chatcmpl-1",
+			"model": "gpt-4",
 			"choices": []any{
 				map[string]any{
 					"index": 0,
@@ -250,8 +250,8 @@ func TestStreamDecoder_MultipleToolCalls(t *testing.T) {
 
 	idx0 := 0
 	chunk1 := map[string]any{
-		"id":     "chatcmpl-mt",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-mt",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -274,8 +274,8 @@ func TestStreamDecoder_MultipleToolCalls(t *testing.T) {
 
 	idx1 := 1
 	chunk2 := map[string]any{
-		"id":     "chatcmpl-mt",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-mt",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -322,8 +322,8 @@ func TestStreamDecoder_MultipleChunks_Text(t *testing.T) {
 	d := NewStreamDecoder()
 
 	chunk1 := map[string]any{
-		"id":     "chatcmpl-multi",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-multi",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -332,8 +332,8 @@ func TestStreamDecoder_MultipleChunks_Text(t *testing.T) {
 		},
 	}
 	chunk2 := map[string]any{
-		"id":     "chatcmpl-multi",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-multi",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -358,8 +358,8 @@ func TestStreamDecoder_UTF8Truncation(t *testing.T) {
 	d := NewStreamDecoder()
 
 	chunk := map[string]any{
-		"id":     "chatcmpl-utf8",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-utf8",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -390,8 +390,8 @@ func TestStreamDecoder_ToolCallSubsequentDelta(t *testing.T) {
 
 	idx := 0
 	chunk1 := map[string]any{
-		"id":     "chatcmpl-tc",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-tc",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,
@@ -412,8 +412,8 @@ func TestStreamDecoder_ToolCallSubsequentDelta(t *testing.T) {
 		},
 	}
 	chunk2 := map[string]any{
-		"id":     "chatcmpl-tc",
-		"model":  "gpt-4",
+		"id":    "chatcmpl-tc",
+		"model": "gpt-4",
 		"choices": []any{
 			map[string]any{
 				"index": 0,

backend/internal/conversion/openai/stream_encoder.go

@@ -10,9 +10,9 @@ import (
 
 // StreamEncoder OpenAI 流式编码器
 type StreamEncoder struct {
-	bufferedStart      *canonical.CanonicalStreamEvent
-	toolCallIndexMap   map[string]int
-	nextToolCallIndex  int
+	bufferedStart     *canonical.CanonicalStreamEvent
+	toolCallIndexMap  map[string]int
+	nextToolCallIndex int
 }
 
 // NewStreamEncoder 创建 OpenAI 流式编码器
@@ -195,8 +195,8 @@ func (e *StreamEncoder) encodeMessageDelta(event canonical.CanonicalStreamEvent)
 func (e *StreamEncoder) encodeDelta(delta map[string]any) [][]byte {
 	chunk := map[string]any{
 		"choices": []map[string]any{{
-			"index":         0,
-			"delta":         delta,
+			"index": 0,
+			"delta": delta,
 		}},
 	}
 	return e.marshalChunk(chunk)

backend/internal/conversion/openai/stream_encoder_test.go

@@ -27,8 +27,12 @@ func TestStreamEncoder_MessageStart(t *testing.T) {
 	data := strings.TrimPrefix(s, "data: ")
 	data = strings.TrimRight(data, "\n")
 	require.NoError(t, json.Unmarshal([]byte(data), &payload))
-	choices := payload["choices"].([]any)
-	delta := choices[0].(map[string]any)["delta"].(map[string]any)
+	choices, okch := payload["choices"].([]any)
+	require.True(t, okch)
+	msgMap, okmm := choices[0].(map[string]any)
+	require.True(t, okmm)
+	delta, okd := msgMap["delta"].(map[string]any)
+	require.True(t, okd)
 	assert.Equal(t, "assistant", delta["role"])
 }
 

backend/internal/conversion/openai/supplemental_test.go

@@ -177,7 +177,8 @@ func TestEncodeRerankResponse(t *testing.T) {
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
 	assert.Equal(t, "rerank-1", result["model"])
-	results := result["results"].([]any)
+	results, okr := result["results"].([]any)
+	require.True(t, okr)
 	assert.Len(t, results, 1)
 }
 
@@ -356,9 +357,9 @@ func TestEncodeResponse_UsageWithCacheAndReasoning(t *testing.T) {
 	reasoning := 20
 	sr := canonical.StopReasonEndTurn
 	resp := &canonical.CanonicalResponse{
-		ID:      "r1",
-		Model:   "gpt-4",
-		Content: []canonical.ContentBlock{canonical.NewTextBlock("ok")},
+		ID:         "r1",
+		Model:      "gpt-4",
+		Content:    []canonical.ContentBlock{canonical.NewTextBlock("ok")},
 		StopReason: &sr,
 		Usage: canonical.CanonicalUsage{
 			InputTokens:     100,
@@ -373,7 +374,8 @@ func TestEncodeResponse_UsageWithCacheAndReasoning(t *testing.T) {
 
 	var result map[string]any
 	require.NoError(t, json.Unmarshal(body, &result))
-	usage := result["usage"].(map[string]any)
+	usage, oku := result["usage"].(map[string]any)
+	require.True(t, oku)
 	assert.Equal(t, float64(100), usage["prompt_tokens"])
 	ptd, ok := usage["prompt_tokens_details"].(map[string]any)
 	require.True(t, ok)
@@ -412,8 +414,10 @@ func TestEncodeResponse_StopReasons(t *testing.T) {
 
 			var result map[string]any
 			require.NoError(t, json.Unmarshal(body, &result))
-			choices := result["choices"].([]any)
-			choice := choices[0].(map[string]any)
+			choices, okch := result["choices"].([]any)
+			require.True(t, okch)
+			choice, okc := choices[0].(map[string]any)
+			require.True(t, okc)
 			assert.Equal(t, tt.want, choice["finish_reason"])
 		})
 	}

backend/internal/conversion/openai/types.go

@@ -4,42 +4,42 @@ import "encoding/json"
 
 // ChatCompletionRequest OpenAI Chat Completion 请求
 type ChatCompletionRequest struct {
-	Model            string            `json:"model"`
-	Messages         []Message         `json:"messages"`
-	Tools            []Tool            `json:"tools,omitempty"`
-	ToolChoice       any               `json:"tool_choice,omitempty"`
-	MaxTokens        *int              `json:"max_tokens,omitempty"`
-	MaxCompletionTokens *int           `json:"max_completion_tokens,omitempty"`
-	Temperature      *float64          `json:"temperature,omitempty"`
-	TopP             *float64          `json:"top_p,omitempty"`
-	FrequencyPenalty *float64          `json:"frequency_penalty,omitempty"`
-	PresencePenalty  *float64          `json:"presence_penalty,omitempty"`
-	Stop             any               `json:"stop,omitempty"`
-	Stream           bool              `json:"stream,omitempty"`
-	StreamOptions    *StreamOptions    `json:"stream_options,omitempty"`
-	User             string            `json:"user,omitempty"`
-	ResponseFormat   *ResponseFormat   `json:"response_format,omitempty"`
-	ParallelToolCalls *bool            `json:"parallel_tool_calls,omitempty"`
-	ReasoningEffort  string            `json:"reasoning_effort,omitempty"`
-	N                *int              `json:"n,omitempty"`
-	Seed             *int              `json:"seed,omitempty"`
-	Logprobs         *bool             `json:"logprobs,omitempty"`
-	TopLogprobs      *int              `json:"top_logprobs,omitempty"`
+	Model               string          `json:"model"`
+	Messages            []Message       `json:"messages"`
+	Tools               []Tool          `json:"tools,omitempty"`
+	ToolChoice          any             `json:"tool_choice,omitempty"`
+	MaxTokens           *int            `json:"max_tokens,omitempty"`
+	MaxCompletionTokens *int            `json:"max_completion_tokens,omitempty"`
+	Temperature         *float64        `json:"temperature,omitempty"`
+	TopP                *float64        `json:"top_p,omitempty"`
+	FrequencyPenalty    *float64        `json:"frequency_penalty,omitempty"`
+	PresencePenalty     *float64        `json:"presence_penalty,omitempty"`
+	Stop                any             `json:"stop,omitempty"`
+	Stream              bool            `json:"stream,omitempty"`
+	StreamOptions       *StreamOptions  `json:"stream_options,omitempty"`
+	User                string          `json:"user,omitempty"`
+	ResponseFormat      *ResponseFormat `json:"response_format,omitempty"`
+	ParallelToolCalls   *bool           `json:"parallel_tool_calls,omitempty"`
+	ReasoningEffort     string          `json:"reasoning_effort,omitempty"`
+	N                   *int            `json:"n,omitempty"`
+	Seed                *int            `json:"seed,omitempty"`
+	Logprobs            *bool           `json:"logprobs,omitempty"`
+	TopLogprobs         *int            `json:"top_logprobs,omitempty"`
 
 	// 已废弃字段
-	Functions     []FunctionDef `json:"functions,omitempty"`
-	FunctionCall  any           `json:"function_call,omitempty"`
+	Functions    []FunctionDef `json:"functions,omitempty"`
+	FunctionCall any           `json:"function_call,omitempty"`
 }
 
 // Message OpenAI 消息
 type Message struct {
-	Role             string          `json:"role"`
-	Content          any             `json:"content"`
-	Name             string          `json:"name,omitempty"`
-	ToolCalls        []ToolCall      `json:"tool_calls,omitempty"`
-	ToolCallID       string          `json:"tool_call_id,omitempty"`
-	Refusal          string          `json:"refusal,omitempty"`
-	ReasoningContent string          `json:"reasoning_content,omitempty"`
+	Role             string     `json:"role"`
+	Content          any        `json:"content"`
+	Name             string     `json:"name,omitempty"`
+	ToolCalls        []ToolCall `json:"tool_calls,omitempty"`
+	ToolCallID       string     `json:"tool_call_id,omitempty"`
+	Refusal          string     `json:"refusal,omitempty"`
+	ReasoningContent string     `json:"reasoning_content,omitempty"`
 
 	// 已废弃
 	FunctionCall *FunctionCallMsg `json:"function_call,omitempty"`
@@ -88,8 +88,8 @@ type FunctionDef struct {
 
 // ResponseFormat OpenAI 响应格式
 type ResponseFormat struct {
-	Type       string          `json:"type"`
-	JSONSchema *JSONSchemaDef  `json:"json_schema,omitempty"`
+	Type       string         `json:"type"`
+	JSONSchema *JSONSchemaDef `json:"json_schema,omitempty"`
 }
 
 // JSONSchemaDef JSON Schema 定义
@@ -118,7 +118,7 @@ type ChatCompletionResponse struct {
 
 // Choice OpenAI 选择项
 type Choice struct {
-	Index        int     `json:"index"`
+	Index        int      `json:"index"`
 	Message      *Message `json:"message,omitempty"`
 	Delta        *Message `json:"delta,omitempty"`
 	FinishReason *string  `json:"finish_reason"`
@@ -127,10 +127,10 @@ type Choice struct {
 
 // Usage OpenAI 用量
 type Usage struct {
-	PromptTokens            int                  `json:"prompt_tokens"`
-	CompletionTokens        int                  `json:"completion_tokens"`
-	TotalTokens             int                  `json:"total_tokens"`
-	PromptTokensDetails     *PromptTokensDetails `json:"prompt_tokens_details,omitempty"`
+	PromptTokens            int                      `json:"prompt_tokens"`
+	CompletionTokens        int                      `json:"completion_tokens"`
+	TotalTokens             int                      `json:"total_tokens"`
+	PromptTokensDetails     *PromptTokensDetails     `json:"prompt_tokens_details,omitempty"`
 	CompletionTokensDetails *CompletionTokensDetails `json:"completion_tokens_details,omitempty"`
 }