From 08179383a00ee9767579e5a147ef09ca1745de67 Mon Sep 17 00:00:00 2001 From: Alex Castillo Date: Tue, 20 Oct 2026 15:35:58 -0400 Subject: [PATCH] fix: report truncation between Gemini MAX_TOKENS and Claude/OpenAI The Gemini converters never mapped a reply cut off by the token limit. Gemini finishReason MAX_TOKENS always became Claude end_turn or OpenAI stop, and Claude max_tokens became Gemini STOP, so clients treated a truncated reply as complete. Map them in the Gemini <-> Claude and Gemini -> OpenAI converters. Co-Authored-By: Claude Sonnet 5.5 --- internal/transformer/convert/claude_gemini.go | 11 +++- .../convert/gemini_truncation_test.go | 63 +++++++++++++++++++ internal/transformer/convert/openai_gemini.go | 6 ++ 3 files changed, 79 insertions(+), 1 deletion(-) create mode 100644 internal/transformer/convert/gemini_truncation_test.go diff --git a/internal/transformer/convert/claude_gemini.go b/internal/transformer/convert/claude_gemini.go index d1524231..a7fc3c4f 100644 --- a/internal/transformer/convert/claude_gemini.go +++ b/internal/transformer/convert/claude_gemini.go @@ -222,8 +222,11 @@ func ClaudeRespToGemini(claudeResp []byte) ([]byte, error) { } finishReason := "STOP" - if resp.StopReason == "tool_use" { + switch resp.StopReason { + case "tool_use": finishReason = "TOOL_CODE" + case "max_tokens": + finishReason = "MAX_TOKENS" } geminiResp := map[string]interface{}{ @@ -279,6 +282,9 @@ func GeminiRespToClaude(geminiResp []byte) ([]byte, error) { stopReason = "tool_use" } } + if candidate.FinishReason == "MAX_TOKENS" { + stopReason = "max_tokens" + } } var inputTokens, outputTokens int @@ -435,6 +441,9 @@ func GeminiStreamToClaude(event []byte, ctx *transformer.StreamContext) ([]byte, if hasFunctionCall || candidate.FinishReason == "TOOL_CODE" { stopReason = "tool_use" } + if candidate.FinishReason == "MAX_TOKENS" { + stopReason = "max_tokens" + } result = append(result, buildClaudeEvent("message_delta", map[string]interface{}{ "delta": map[string]interface{}{"stop_reason": stopReason, "stop_sequence": nil}, "usage": currentClaudeUsage(ctx), diff --git a/internal/transformer/convert/gemini_truncation_test.go b/internal/transformer/convert/gemini_truncation_test.go new file mode 100644 index 00000000..302b136c --- /dev/null +++ b/internal/transformer/convert/gemini_truncation_test.go @@ -0,0 +1,63 @@ +package convert + +import ( + "testing" + + "github.com/lich0821/ccNexus/internal/transformer" +) + +const geminiTruncatedResp = `{"candidates":[{"content":{"role":"model","parts":[{"text":"Once upon a"}]},"finishReason":"MAX_TOKENS"}],"usageMetadata":{"promptTokenCount":5,"candidatesTokenCount":3,"totalTokenCount":8}}` + +const geminiTruncatedChunk = "data: " + geminiTruncatedResp + "\n\n" + +func TestGeminiRespToClaudeMaxTokensReportsMaxTokens(t *testing.T) { + out, err := GeminiRespToClaude([]byte(geminiTruncatedResp)) + if err != nil { + t.Fatalf("GeminiRespToClaude failed: %v", err) + } + + assertContains(t, string(out), `"stop_reason":"max_tokens"`, "Expected stop_reason max_tokens for a Gemini MAX_TOKENS finish") +} + +func TestGeminiStreamToClaudeMaxTokensReportsMaxTokens(t *testing.T) { + ctx := transformer.NewStreamContext() + ctx.ModelName = "gemini-3.8-flash" + + out, err := GeminiStreamToClaude([]byte(geminiTruncatedChunk), ctx) + if err != nil { + t.Fatalf("GeminiStreamToClaude failed: %v", err) + } + + assertContains(t, string(out), `"stop_reason":"max_tokens"`, "Expected stop_reason max_tokens for a Gemini MAX_TOKENS finish") +} + +func TestGeminiRespToOpenAIMaxTokensReportsLength(t *testing.T) { + out, err := GeminiRespToOpenAI([]byte(geminiTruncatedResp), "gemini-3.8-flash") + if err != nil { + t.Fatalf("GeminiRespToOpenAI failed: %v", err) + } + + assertContains(t, string(out), `"finish_reason":"length"`, "Expected finish_reason length for a Gemini MAX_TOKENS finish") +} + +func TestGeminiStreamToOpenAIMaxTokensReportsLength(t *testing.T) { + ctx := transformer.NewStreamContext() + + out, err := GeminiStreamToOpenAI([]byte(geminiTruncatedChunk), ctx, "gemini-3.8-flash") + if err != nil { + t.Fatalf("GeminiStreamToOpenAI failed: %v", err) + } + + assertContains(t, string(out), `"finish_reason":"length"`, "Expected finish_reason length for a Gemini MAX_TOKENS finish") +} + +func TestClaudeRespToGeminiMaxTokensReportsMaxTokens(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 := ClaudeRespToGemini([]byte(claudeResp)) + if err != nil { + t.Fatalf("ClaudeRespToGemini failed: %v", err) + } + + assertContains(t, string(out), `"finishReason":"MAX_TOKENS"`, "Expected finishReason MAX_TOKENS for a Claude max_tokens stop") +} diff --git a/internal/transformer/convert/openai_gemini.go b/internal/transformer/convert/openai_gemini.go index f2e1e5c5..b0b85f8d 100644 --- a/internal/transformer/convert/openai_gemini.go +++ b/internal/transformer/convert/openai_gemini.go @@ -150,6 +150,9 @@ func GeminiRespToOpenAI(geminiResp []byte, model string) ([]byte, error) { finishReason = "tool_calls" } } + if candidate.FinishReason == "MAX_TOKENS" { + finishReason = "length" + } } message := map[string]interface{}{"role": "assistant", "content": textContent} @@ -236,6 +239,9 @@ func GeminiStreamToOpenAI(event []byte, ctx *transformer.StreamContext, model st if hasToolCall || candidate.FinishReason == "TOOL_CODE" { finishReason = "tool_calls" } + if candidate.FinishReason == "MAX_TOKENS" { + finishReason = "length" + } usage := currentOpenAIUsage(ctx) chunk, _ := buildOpenAIChunkWithUsage("gemini-chunk", model, "", nil, finishReason, usage) result.Write(chunk)