From 1c1c41a457cc3ba062484880b35568b0ca06695e Mon Sep 17 00:00:00 2001 From: Alex Castillo Date: Mon, 19 Oct 2026 23:58:35 -0400 Subject: [PATCH 1/2] fix: report tool_use when an OpenAI stream ends a tool call with finish_reason stop OpenAI-compatible providers such as Gemini finish tool calls with finish_reason "stop". OpenAIStreamToClaude mapped that to end_turn even though a tool_use block had been sent, so Claude clients stopped instead of running the tool. It now reports tool_use when a tool block was started, also when the stream ends with [DONE] without a finish_reason. Co-Authored-By: Claude Sonnet 5.5 --- internal/transformer/convert/claude_openai.go | 11 ++++- .../transformer/convert/claude_openai_test.go | 48 +++++++++++++++++++ 2 files changed, 57 insertions(+), 2 deletions(-) diff --git a/internal/transformer/convert/claude_openai.go b/internal/transformer/convert/claude_openai.go index 5d1c7e1a..25bf1f0d 100644 --- a/internal/transformer/convert/claude_openai.go +++ b/internal/transformer/convert/claude_openai.go @@ -449,6 +449,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 +465,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 +616,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,7 +630,8 @@ 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" } result = append(result, buildClaudeEvent("message_delta", map[string]interface{}{ diff --git a/internal/transformer/convert/claude_openai_test.go b/internal/transformer/convert/claude_openai_test.go index 111da0fd..ec36567f 100644 --- a/internal/transformer/convert/claude_openai_test.go +++ b/internal/transformer/convert/claude_openai_test.go @@ -435,3 +435,51 @@ 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") +} From d57ffdc066dd2fc90b8949163de2e8adf6aa4cb9 Mon Sep 17 00:00:00 2001 From: Alex Castillo Date: Tue, 20 Oct 2026 15:20:13 -0400 Subject: [PATCH 2/2] fix: report truncation between Claude max_tokens and OpenAI length The Claude <-> OpenAI Chat converters never mapped a truncated reply. Claude stop_reason max_tokens always became finish_reason stop, and OpenAI finish_reason length always became end_turn, so clients treated a cut-off reply as complete. Map them in the non-stream and stream converters, both directions. Co-Authored-By: Claude Sonnet 5.5 --- internal/transformer/convert/claude_openai.go | 27 ++++++++---- .../transformer/convert/claude_openai_test.go | 44 +++++++++++++++++++ 2 files changed, 63 insertions(+), 8 deletions(-) diff --git a/internal/transformer/convert/claude_openai.go b/internal/transformer/convert/claude_openai.go index 25bf1f0d..d9b23916 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 @@ -633,6 +630,8 @@ func OpenAIStreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte, // 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}, @@ -646,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 ec36567f..7de6e9ca 100644 --- a/internal/transformer/convert/claude_openai_test.go +++ b/internal/transformer/convert/claude_openai_test.go @@ -483,3 +483,47 @@ func TestOpenAIStreamToClaudeDoneWithToolCallAndNoFinishReasonReportsToolUse(t * 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") + } +}