fix: preserve responses reasoning metadata

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ganisback

internal/inference/openai.go

@@ -255,11 +255,13 @@ func sanitizeOpenAIRequestBody(modelName string, reqBody map[string]interface{})
 			}
 			out["top_p"] = 0.95
 		}
+	}
+	if openAIModelRequiresToolCallReasoningContent(modelName) {
 		messages := reqBody["messages"]
 		if out != nil {
 			messages = out["messages"]
 		}
-		if normalized, changed := normalizeKimiToolCallMessages(messages); changed {
+		if normalized, changed := normalizeToolCallReasoningContentMessages(messages); changed {
 			if out == nil {
 				out = cloneOpenAIRequestBody(reqBody)
 			}
@@ -290,13 +292,20 @@ func openAIModelRequiresTemperatureOne(modelName string) bool {
 	return strings.HasPrefix(modelName, "kimi-") || strings.HasPrefix(modelName, "moonshot-")
 }
 
-func normalizeKimiToolCallMessages(messages interface{}) (interface{}, bool) {
+func openAIModelRequiresToolCallReasoningContent(modelName string) bool {
+	modelName = strings.TrimSpace(strings.ToLower(modelName))
+	return strings.HasPrefix(modelName, "kimi-") ||
+		strings.HasPrefix(modelName, "moonshot-") ||
+		strings.Contains(modelName, "deepseek-v4")
+}
+
+func normalizeToolCallReasoningContentMessages(messages interface{}) (interface{}, bool) {
 	switch v := messages.(type) {
 	case []map[string]interface{}:
 		out := make([]map[string]interface{}, len(v))
 		changed := false
 		for i, msg := range v {
-			next, msgChanged := normalizeKimiToolCallMessageMap(msg)
+			next, msgChanged := normalizeToolCallReasoningContentMessageMap(msg)
 			out[i] = next
 			changed = changed || msgChanged
 		}
@@ -312,7 +321,7 @@ func normalizeKimiToolCallMessages(messages interface{}) (interface{}, bool) {
 				out[i] = item
 				continue
 			}
-			next, msgChanged := normalizeKimiToolCallMessageMap(msg)
+			next, msgChanged := normalizeToolCallReasoningContentMessageMap(msg)
 			out[i] = next
 			changed = changed || msgChanged
 		}
@@ -339,7 +348,7 @@ func normalizeKimiToolCallMessages(messages interface{}) (interface{}, bool) {
 			if msg.ReasoningContent != "" {
 				next["reasoning_content"] = msg.ReasoningContent
 			}
-			normalized, msgChanged := normalizeKimiToolCallMessageMap(next)
+			normalized, msgChanged := normalizeToolCallReasoningContentMessageMap(next)
 			out[i] = normalized
 			changed = changed || msgChanged
 		}
@@ -350,7 +359,7 @@ func normalizeKimiToolCallMessages(messages interface{}) (interface{}, bool) {
 	return messages, false
 }
 
-func normalizeKimiToolCallMessageMap(msg map[string]interface{}) (map[string]interface{}, bool) {
+func normalizeToolCallReasoningContentMessageMap(msg map[string]interface{}) (map[string]interface{}, bool) {
 	if strings.TrimSpace(fmt.Sprint(msg["role"])) != "assistant" {
 		return msg, false
 	}

internal/inference/openai_test.go

@@ -255,3 +255,53 @@ func TestOpenAIEngineChatCompletionAddsKimiReasoningContentToToolCalls(t *testin
 		t.Fatalf("top_p = %v, want 0.95", got["top_p"])
 	}
 }
+
+func TestOpenAIEngineChatCompletionAddsDeepSeekV4ReasoningContentToToolCalls(t *testing.T) {
+	var got map[string]interface{}
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := json.NewDecoder(r.Body).Decode(&got); err != nil {
+			t.Fatalf("decode request: %v", err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprint(w, `{"choices":[{"message":{"content":"ok"}}]}`)
+	}))
+	defer ts.Close()
+
+	eng := NewOpenAIEngine(ts.URL, "deepseek-v4-pro", "test-token")
+	resp, err := eng.(ChatCompletionProxier).ChatCompletion(context.Background(), map[string]interface{}{
+		"model": "deepseek-v4-pro",
+		"messages": []map[string]interface{}{
+			{"role": "user", "content": "use a tool"},
+			{
+				"role":    "assistant",
+				"content": nil,
+				"tool_calls": []map[string]interface{}{{
+					"id":   "call_1",
+					"type": "function",
+					"function": map[string]interface{}{
+						"name":      "lookup",
+						"arguments": "{}",
+					},
+				}},
+			},
+			{"role": "tool", "tool_call_id": "call_1", "content": "result"},
+		},
+	})
+	if err != nil {
+		t.Fatalf("ChatCompletion returned error: %v", err)
+	}
+	resp.Body.Close()
+
+	messages, ok := got["messages"].([]interface{})
+	if !ok || len(messages) != 3 {
+		t.Fatalf("messages = %#v", got["messages"])
+	}
+	assistant, ok := messages[1].(map[string]interface{})
+	if !ok {
+		t.Fatalf("assistant message = %#v", messages[1])
+	}
+	if value, ok := assistant["reasoning_content"]; !ok || value != "" {
+		t.Fatalf("reasoning_content = %#v, want empty string", assistant["reasoning_content"])
+	}
+}

internal/server/handlers_responses.go

@@ -1154,7 +1154,7 @@ func buildResponsesOutputItem(itemID, text, status string) map[string]interface{
 }
 
 func buildResponsesReasoningItem(itemID, text, status string) map[string]interface{} {
-	return map[string]interface{}{
+	item := map[string]interface{}{
 		"id":      itemID,
 		"type":    "reasoning",
 		"status":  status,
@@ -1164,6 +1164,14 @@ func buildResponsesReasoningItem(itemID, text, status string) map[string]interfa
 			"text": text,
 		}},
 	}
+	if text != "" {
+		item["summary"] = []map[string]interface{}{{
+			"type": "summary_text",
+			"text": text,
+		}}
+		item["encrypted_content"] = text
+	}
+	return item
 }
 
 func buildResponsesResponse(id, itemID, modelID, text string, created int64, status string, inputTokens int) map[string]interface{} {

internal/server/handlers_responses_test.go

@@ -157,6 +157,42 @@ func TestResponsesInputReasoningAttachedToToolCallAssistant(t *testing.T) {
 	}
 }
 
+func TestResponsesInputEncryptedReasoningAttachedToToolCallAssistant(t *testing.T) {
+	input := []interface{}{
+		map[string]interface{}{
+			"type":              "reasoning",
+			"encrypted_content": "opaque reasoning replay",
+		},
+		map[string]interface{}{
+			"type":      "function_call",
+			"call_id":   "call_1",
+			"name":      "list_dir",
+			"arguments": `{}`,
+		},
+		map[string]interface{}{
+			"type":    "function_call_output",
+			"name":    "list_dir",
+			"call_id": "call_1",
+			"output":  "ok",
+		},
+	}
+
+	messages, err := responsesInputToOpenAIMessages(input)
+	if err != nil {
+		t.Fatalf("responsesInputToOpenAIMessages() error = %v", err)
+	}
+	if len(messages) != 2 {
+		t.Fatalf("len(messages) = %d, want 2", len(messages))
+	}
+	toolAssistant := messages[0]
+	if len(toolAssistant.ToolCalls) != 1 || toolAssistant.ToolCalls[0].Function.Name != "list_dir" {
+		t.Fatalf("tool assistant = %#v", toolAssistant)
+	}
+	if toolAssistant.ReasoningContent != "opaque reasoning replay" {
+		t.Fatalf("ReasoningContent = %q, want opaque reasoning replay", toolAssistant.ReasoningContent)
+	}
+}
+
 func TestResponsesOutputFromOpenAIChatResponseIncludesReasoningItem(t *testing.T) {
 	resp := api.OpenAIChatResponse{
 		Choices: []api.OpenAIChoice{{
@@ -182,4 +218,11 @@ func TestResponsesOutputFromOpenAIChatResponseIncludesReasoningItem(t *testing.T
 	if reasoning["type"] != "reasoning" || responsesReasoningItemText(reasoning) != "hidden reasoning" {
 		t.Fatalf("reasoning item = %#v, want hidden reasoning", reasoning)
 	}
+	if reasoning["encrypted_content"] != "hidden reasoning" {
+		t.Fatalf("encrypted_content = %#v, want hidden reasoning", reasoning["encrypted_content"])
+	}
+	summary, ok := reasoning["summary"].([]map[string]interface{})
+	if !ok || len(summary) != 1 || summary[0]["text"] != "hidden reasoning" {
+		t.Fatalf("summary = %#v, want hidden reasoning summary", reasoning["summary"])
+	}
 }