fix: support think tags in responses conversion

internal/transformer/convert/claude_openai.go

@@ -317,7 +317,7 @@ func OpenAIRespToClaude(openaiResp []byte) ([]byte, error) {
 	if len(resp.Choices) > 0 {
 		choice := resp.Choices[0]
 		if choice.Message.Content != "" {
-			content = append(content, map[string]interface{}{"type": "text", "text": choice.Message.Content})
+			content = append(content, splitThinkTaggedText(choice.Message.Content)...)
 		}
 		for _, tc := range choice.Message.ToolCalls {
 			var args map[string]interface{}
@@ -667,4 +667,3 @@ func extractToolResultContent(content interface{}) string {
 	}
 	return ""
 }
-

internal/transformer/convert/claude_openai2.go

@@ -204,7 +204,7 @@ func OpenAI2RespToClaude(openai2Resp []byte) ([]byte, error) {
 		case "message":
 			for _, part := range item.Content {
 				if part.Type == "output_text" {
-					content = append(content, map[string]interface{}{"type": "text", "text": part.Text})
+					content = append(content, splitThinkTaggedText(part.Text)...)
 				}
 			}
 		case "function_call":
@@ -335,7 +335,7 @@ func ClaudeStreamToOpenAI2(event []byte, ctx *transformer.StreamContext) ([]byte
 			partial := delta["partial_json"].(string)
 			ctx.ToolArguments += partial
 			writeEvent(map[string]interface{}{
-				"type": "response.function_call_arguments.delta",
+				"type":         "response.function_call_arguments.delta",
 				"output_index": ctx.ToolIndex, "delta": partial,
 			})
 		}
@@ -347,7 +347,7 @@ func ClaudeStreamToOpenAI2(event []byte, ctx *transformer.StreamContext) ([]byte
 		if ctx.ToolBlockStarted && blockIdx == ctx.ToolIndex {
 			// function_call_arguments.done
 			writeEvent(map[string]interface{}{
-				"type": "response.function_call_arguments.done",
+				"type":         "response.function_call_arguments.done",
 				"output_index": blockIdx, "arguments": ctx.ToolArguments,
 			})
 			// output_item.done for function_call
@@ -414,7 +414,38 @@ func OpenAI2StreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte
 	_, jsonData := parseSSE(event)
 	if jsonData == "" || jsonData == "[DONE]" {
 		if jsonData == "[DONE]" {
-			return buildClaudeEvent("message_stop", map[string]interface{}{}), nil
+			var result []byte
+			if ctx.InThinkingTag || ctx.PendingThinkingText != "" || ctx.ThinkingBuffer != "" {
+				pending := ctx.PendingThinkingText + ctx.ThinkingBuffer
+				if pending != "" {
+					if !ctx.ContentBlockStarted {
+						ctx.ContentBlockStarted = true
+						result = append(result, buildClaudeEvent("content_block_start", map[string]interface{}{
+							"index": ctx.ContentIndex, "content_block": map[string]interface{}{"type": "text", "text": ""},
+						})...)
+					}
+					result = append(result, buildClaudeEvent("content_block_delta", map[string]interface{}{
+						"index": ctx.ContentIndex, "delta": map[string]interface{}{"type": "text_delta", "text": pending},
+					})...)
+				}
+				ctx.InThinkingTag = false
+				ctx.PendingThinkingText = ""
+				ctx.ThinkingBuffer = ""
+			}
+			if ctx.ThinkingBlockStarted {
+				result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ThinkingIndex})...)
+				ctx.ThinkingBlockStarted = false
+			}
+			if ctx.ContentBlockStarted {
+				result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ContentIndex})...)
+				ctx.ContentBlockStarted = false
+			}
+			if ctx.ToolBlockStarted {
+				result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ToolIndex})...)
+				ctx.ToolBlockStarted = false
+			}
+			result = append(result, buildClaudeEvent("message_stop", map[string]interface{}{})...)
+			return result, nil
 		}
 		return nil, nil
 	}
@@ -440,18 +471,106 @@ func OpenAI2StreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte
 		})...)
 
 	case "response.output_text.delta":
-		if !ctx.ContentBlockStarted {
-			ctx.ContentBlockStarted = true
+		content := ctx.ThinkingBuffer + evt.Delta
+		ctx.ThinkingBuffer = ""
+
+		startTextBlock := func() {
+			if !ctx.ContentBlockStarted {
+				ctx.ContentBlockStarted = true
+				result = append(result, buildClaudeEvent("content_block_start", map[string]interface{}{
+					"index": ctx.ContentIndex, "content_block": map[string]interface{}{"type": "text", "text": ""},
+				})...)
+			}
+		}
+
+		emitText := func(text string) {
+			if text == "" {
+				return
+			}
+			if ctx.ThinkingBlockStarted && !ctx.ContentBlockStarted && !ctx.InThinkingTag {
+				result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ThinkingIndex})...)
+				ctx.ThinkingBlockStarted = false
+			}
+			startTextBlock()
+			result = append(result, buildClaudeEvent("content_block_delta", map[string]interface{}{
+				"index": ctx.ContentIndex, "delta": map[string]interface{}{"type": "text_delta", "text": text},
+			})...)
+		}
+
+		startThinkingBlock := func() {
+			if ctx.ContentBlockStarted {
+				result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ContentIndex})...)
+				ctx.ContentBlockStarted = false
+				ctx.ContentIndex++
+			}
+			ctx.ThinkingBlockStarted = true
+			ctx.ThinkingIndex = ctx.ContentIndex
+			ctx.ContentIndex++
 			result = append(result, buildClaudeEvent("content_block_start", map[string]interface{}{
-				"index": ctx.ContentIndex, "content_block": map[string]interface{}{"type": "text", "text": ""},
+				"index": ctx.ThinkingIndex, "content_block": map[string]interface{}{"type": "thinking", "thinking": ""},
+			})...)
+		}
+
+		emitThinking := func(text string) {
+			if text == "" {
+				return
+			}
+			if !ctx.ThinkingBlockStarted {
+				startThinkingBlock()
+			}
+			result = append(result, buildClaudeEvent("content_block_delta", map[string]interface{}{
+				"index": ctx.ThinkingIndex, "delta": map[string]interface{}{"type": "thinking_delta", "thinking": text},
 			})...)
 		}
-		result = append(result, buildClaudeEvent("content_block_delta", map[string]interface{}{
-			"index": ctx.ContentIndex, "delta": map[string]interface{}{"type": "text_delta", "text": evt.Delta},
-		})...)
+
+		stopThinkingBlock := func() {
+			if ctx.ThinkingBlockStarted {
+				result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ThinkingIndex})...)
+			}
+			ctx.ThinkingBlockStarted = false
+		}
+
+		for len(content) > 0 {
+			if ctx.InThinkingTag {
+				closeIdx := strings.Index(content, "</think>")
+				if closeIdx == -1 {
+					text, buffer := splitTrailingPartialTag(content, "</think>")
+					ctx.PendingThinkingText += text
+					ctx.ThinkingBuffer = buffer
+					content = ""
+					continue
+				}
+				ctx.PendingThinkingText += content[:closeIdx]
+				if ctx.PendingThinkingText != "" {
+					startThinkingBlock()
+					emitThinking(ctx.PendingThinkingText)
+					stopThinkingBlock()
+				}
+				ctx.PendingThinkingText = ""
+				ctx.InThinkingTag = false
+				content = content[closeIdx+len("</think>"):]
+				continue
+			}
+
+			openIdx := strings.Index(content, "<think>")
+			if openIdx == -1 {
+				text, buffer := splitTrailingPartialTag(content, "<think>")
+				emitText(text)
+				ctx.ThinkingBuffer = buffer
+				content = ""
+				continue
+			}
+			emitText(content[:openIdx])
+			ctx.InThinkingTag = true
+			content = content[openIdx+len("<think>"):]
+		}
 
 	case "response.output_item.added":
 		if evt.Item != nil && evt.Item.Type == "function_call" {
+			if ctx.ThinkingBlockStarted {
+				result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ThinkingIndex})...)
+				ctx.ThinkingBlockStarted = false
+			}
 			// Close text block if open
 			if ctx.ContentBlockStarted {
 				result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ContentIndex})...)
@@ -486,8 +605,30 @@ func OpenAI2StreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte
 		}
 
 	case "response.completed":
+		if ctx.InThinkingTag || ctx.PendingThinkingText != "" || ctx.ThinkingBuffer != "" {
+			pending := ctx.PendingThinkingText + ctx.ThinkingBuffer
+			if pending != "" {
+				if !ctx.ContentBlockStarted {
+					ctx.ContentBlockStarted = true
+					result = append(result, buildClaudeEvent("content_block_start", map[string]interface{}{
+						"index": ctx.ContentIndex, "content_block": map[string]interface{}{"type": "text", "text": ""},
+					})...)
+				}
+				result = append(result, buildClaudeEvent("content_block_delta", map[string]interface{}{
+					"index": ctx.ContentIndex, "delta": map[string]interface{}{"type": "text_delta", "text": pending},
+				})...)
+			}
+			ctx.InThinkingTag = false
+			ctx.PendingThinkingText = ""
+			ctx.ThinkingBuffer = ""
+		}
+		if ctx.ThinkingBlockStarted {
+			result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ThinkingIndex})...)
+			ctx.ThinkingBlockStarted = false
+		}
 		if ctx.ContentBlockStarted {
 			result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ContentIndex})...)
+			ctx.ContentBlockStarted = false
 		}
 		stopReason := "end_turn"
 		if ctx.ToolIndex > 0 || ctx.CurrentToolID != "" {

internal/transformer/convert/claude_openai2_test.go

@@ -0,0 +1,91 @@
+package convert
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/lich0821/ccNexus/internal/transformer"
+)
+
+func TestOpenAI2RespToClaudeWithThinking(t *testing.T) {
+	openai2Resp := `{
+		"id": "resp_1",
+		"object": "response",
+		"status": "completed",
+		"output": [{
+			"type": "message",
+			"role": "assistant",
+			"content": [{
+				"type": "output_text",
+				"text": "<think>Reason</think>Answer"
+			}]
+		}],
+		"usage": {
+			"input_tokens": 3,
+			"output_tokens": 5,
+			"total_tokens": 8
+		}
+	}`
+
+	claudeRespBytes, err := OpenAI2RespToClaude([]byte(openai2Resp))
+	if err != nil {
+		t.Fatalf("OpenAI2RespToClaude failed: %v", err)
+	}
+
+	var claudeResp map[string]interface{}
+	if err := json.Unmarshal(claudeRespBytes, &claudeResp); err != nil {
+		t.Fatalf("Failed to unmarshal Claude response: %v", err)
+	}
+
+	content, ok := claudeResp["content"].([]interface{})
+	if !ok {
+		t.Fatalf("Expected content to be an array, got %T", claudeResp["content"])
+	}
+	if len(content) != 2 {
+		t.Fatalf("Expected 2 content blocks, got %d", len(content))
+	}
+	if content[0].(map[string]interface{})["type"] != "thinking" {
+		t.Fatalf("Expected first block thinking, got %v", content[0])
+	}
+	if content[1].(map[string]interface{})["type"] != "text" {
+		t.Fatalf("Expected second block text, got %v", content[1])
+	}
+}
+
+func TestOpenAI2StreamToClaudeWithThinking(t *testing.T) {
+	ctx := transformer.NewStreamContext()
+	ctx.ModelName = "claude-3-sonnet-20240229"
+
+	chunks := []string{
+		`data: {"type":"response.created","response":{"id":"resp_1","object":"response","status":"in_progress"}}`,
+		`data: {"type":"response.output_text.delta","delta":"<think>Reason</think>Hello"}`,
+		`data: {"type":"response.completed","response":{"id":"resp_1","object":"response","status":"completed"}}`,
+		`data: [DONE]`,
+	}
+
+	var allEvents []string
+	for _, chunk := range chunks {
+		events, err := OpenAI2StreamToClaude([]byte(chunk), ctx)
+		if err != nil {
+			t.Fatalf("OpenAI2StreamToClaude failed: %v", err)
+		}
+		if events != nil {
+			allEvents = append(allEvents, string(events))
+		}
+	}
+
+	fullEvents := strings.Join(allEvents, "")
+	if !strings.Contains(fullEvents, "\"type\":\"thinking\"") {
+		t.Fatalf("Expected thinking block start, but not found")
+	}
+	if !strings.Contains(fullEvents, "\"thinking\":\"Reason\"") {
+		t.Fatalf("Expected thinking delta 'Reason', but not found")
+	}
+	if !strings.Contains(fullEvents, "\"text\":\"Hello\"") {
+		t.Fatalf("Expected text delta 'Hello', but not found")
+	}
+	if strings.Contains(fullEvents, "<think>") || strings.Contains(fullEvents, "</think>") {
+		t.Fatalf("Unexpected think tags leaked into output")
+	}
+}