diff --git a/internal/transformer/convert/claude_openai.go b/internal/transformer/convert/claude_openai.go index 5d1c7e1..d9b2391 100644 --- a/internal/transformer/convert/claude_openai.go +++ b/internal/transformer/convert/claude_openai.go @@ -303,10 +303,7 @@ func ClaudeRespToOpenAI(claudeResp []byte, model string) ([]byte, error) { message["tool_calls"] = toolCalls } - finishReason := "stop" - if resp.StopReason == "tool_use" { - finishReason = "tool_calls" - } + finishReason := claudeStopReasonToOpenAI(resp.StopReason) openaiResp := map[string]interface{}{ "id": resp.ID, @@ -349,6 +346,9 @@ func OpenAIRespToClaude(openaiResp []byte) ([]byte, error) { }) stopReason = "tool_use" } + if choice.FinishReason == "length" { + stopReason = "max_tokens" + } } claudeResp := map[string]interface{}{ @@ -426,10 +426,7 @@ func ClaudeStreamToOpenAI(event []byte, ctx *transformer.StreamContext, model st case "message_delta": if delta, ok := data["delta"].(map[string]interface{}); ok { stopReason, _ := delta["stop_reason"].(string) - finish := "stop" - if stopReason == "tool_use" { - finish = "tool_calls" - } + finish := claudeStopReasonToOpenAI(stopReason) return buildOpenAIChunk(ctx.MessageID, model, "", nil, finish) } return nil, nil @@ -449,6 +446,7 @@ func OpenAIStreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte, var result []byte emitText, emitThinking := makeThinkEmitters(ctx, &result) flushThinkTaggedStream(ctx, emitText, emitThinking) + hadToolCall := ctx.ToolBlockStarted // Close any open content blocks before message_stop if ctx.ThinkingBlockStarted { result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ThinkingIndex})...) @@ -464,8 +462,12 @@ func OpenAIStreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte, } // Send message_delta with stop_reason if not sent if !ctx.FinishReasonSent { + stopReason := "end_turn" + if hadToolCall { + stopReason = "tool_use" + } result = append(result, buildClaudeEvent("message_delta", map[string]interface{}{ - "delta": map[string]interface{}{"stop_reason": "end_turn", "stop_sequence": nil}, + "delta": map[string]interface{}{"stop_reason": stopReason, "stop_sequence": nil}, "usage": map[string]interface{}{"output_tokens": 0}, })...) } @@ -611,6 +613,7 @@ func OpenAIStreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte, // Finish if choice.FinishReason != nil { + hadToolCall := ctx.ToolBlockStarted if ctx.ThinkingBlockStarted { result = append(result, buildClaudeEvent("content_block_stop", map[string]interface{}{"index": ctx.ThinkingIndex})...) ctx.ThinkingBlockStarted = false @@ -624,8 +627,11 @@ func OpenAIStreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte, ctx.ToolBlockStarted = false } stopReason := "end_turn" - if *choice.FinishReason == "tool_calls" { + // Some OpenAI-compatible providers (Gemini) end tool calls with "stop". + if *choice.FinishReason == "tool_calls" || (*choice.FinishReason == "stop" && hadToolCall) { stopReason = "tool_use" + } else if *choice.FinishReason == "length" { + stopReason = "max_tokens" } result = append(result, buildClaudeEvent("message_delta", map[string]interface{}{ "delta": map[string]interface{}{"stop_reason": stopReason, "stop_sequence": nil}, @@ -639,6 +645,18 @@ func OpenAIStreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte, // Helper functions +// claudeStopReasonToOpenAI maps a Claude stop_reason to an OpenAI finish_reason. +func claudeStopReasonToOpenAI(stopReason string) string { + switch stopReason { + case "tool_use": + return "tool_calls" + case "max_tokens": + return "length" + default: + return "stop" + } +} + func convertClaudeContentToOpenAI(content []interface{}) (interface{}, []transformer.OpenAIToolCall) { var textParts []string var toolCalls []transformer.OpenAIToolCall diff --git a/internal/transformer/convert/claude_openai_test.go b/internal/transformer/convert/claude_openai_test.go index 111da0f..7de6e9c 100644 --- a/internal/transformer/convert/claude_openai_test.go +++ b/internal/transformer/convert/claude_openai_test.go @@ -435,3 +435,95 @@ func TestClaudeReqToOpenAIThinkingOnly(t *testing.T) { } } } + +func streamToClaude(t *testing.T, chunks []string) string { + t.Helper() + ctx := transformer.NewStreamContext() + ctx.ModelName = "claude-3-sonnet-20240229" + var all []string + for _, chunk := range chunks { + events, err := OpenAIStreamToClaude([]byte(chunk), ctx) + if err != nil { + t.Fatalf("OpenAIStreamToClaude failed: %v", err) + } + if events != nil { + all = append(all, string(events)) + } + } + return strings.Join(all, "") +} + +// Gemini's OpenAI-compatible endpoint ends tool calls with finish_reason "stop". +func TestOpenAIStreamToClaudeStopWithToolCallReportsToolUse(t *testing.T) { + events := streamToClaude(t, []string{ + `data: {"id":"1","choices":[{"index":0,"delta":{"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{\"city\":\"Paris\"}"}}]},"finish_reason":"stop"}]}`, + `data: [DONE]`, + }) + + assertContains(t, events, `"stop_reason":"tool_use"`, "Expected stop_reason tool_use for a tool call finished with \"stop\"") + if strings.Contains(events, `"stop_reason":"end_turn"`) { + t.Error("stop_reason end_turn must not be sent when the message has a tool_use block") + } +} + +func TestOpenAIStreamToClaudeStopWithoutToolCallReportsEndTurn(t *testing.T) { + events := streamToClaude(t, []string{ + `data: {"id":"1","choices":[{"index":0,"delta":{"role":"assistant","content":"Hello!"},"finish_reason":"stop"}]}`, + `data: [DONE]`, + }) + + assertContains(t, events, `"stop_reason":"end_turn"`, "Expected stop_reason end_turn for a plain text reply") +} + +func TestOpenAIStreamToClaudeDoneWithToolCallAndNoFinishReasonReportsToolUse(t *testing.T) { + events := streamToClaude(t, []string{ + `data: {"id":"1","choices":[{"index":0,"delta":{"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{}"}}]}}]}`, + `data: [DONE]`, + }) + + assertContains(t, events, `"stop_reason":"tool_use"`, "Expected stop_reason tool_use when the stream ends after a tool call") +} + +func TestClaudeRespToOpenAIMaxTokensReportsLength(t *testing.T) { + claudeResp := `{"id":"msg_1","type":"message","role":"assistant","model":"claude-sonnet-4-5","content":[{"type":"text","text":"Once upon a"}],"stop_reason":"max_tokens","usage":{"input_tokens":5,"output_tokens":3}}` + + out, err := ClaudeRespToOpenAI([]byte(claudeResp), "gpt-4o") + if err != nil { + t.Fatalf("ClaudeRespToOpenAI failed: %v", err) + } + + assertContains(t, string(out), `"finish_reason":"length"`, "Expected finish_reason length for a Claude max_tokens stop") +} + +func TestClaudeStreamToOpenAIMaxTokensReportsLength(t *testing.T) { + ctx := transformer.NewStreamContext() + out, err := ClaudeStreamToOpenAI([]byte("event: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"max_tokens\"}}\n\n"), ctx, "gpt-4o") + if err != nil { + t.Fatalf("ClaudeStreamToOpenAI failed: %v", err) + } + + assertContains(t, string(out), `"finish_reason":"length"`, "Expected finish_reason length for a Claude max_tokens stop") +} + +func TestOpenAIRespToClaudeLengthReportsMaxTokens(t *testing.T) { + openaiResp := `{"id":"chatcmpl-1","object":"chat.completion","model":"gpt-4o","choices":[{"index":0,"message":{"role":"assistant","content":"Once upon a"},"finish_reason":"length"}],"usage":{"prompt_tokens":5,"completion_tokens":3,"total_tokens":8}}` + + out, err := OpenAIRespToClaude([]byte(openaiResp)) + if err != nil { + t.Fatalf("OpenAIRespToClaude failed: %v", err) + } + + assertContains(t, string(out), `"stop_reason":"max_tokens"`, "Expected stop_reason max_tokens for an OpenAI length finish") +} + +func TestOpenAIStreamToClaudeLengthReportsMaxTokens(t *testing.T) { + events := streamToClaude(t, []string{ + `data: {"id":"1","choices":[{"index":0,"delta":{"role":"assistant","content":"Once upon a"},"finish_reason":"length"}]}`, + `data: [DONE]`, + }) + + assertContains(t, events, `"stop_reason":"max_tokens"`, "Expected stop_reason max_tokens for an OpenAI length finish") + if strings.Contains(events, `"stop_reason":"end_turn"`) { + t.Error("stop_reason end_turn must not be sent when the reply was cut off by the token limit") + } +}