History

fix(gemini): normalize Claude thinking signatures in Gemini request and response conversion

Luis Pater committed 2 months ago

Commit b3f72ce1 parent 65071f74 files · +195 −4Browse files

Unified · Split

4 files
  1. internal/translator/claude/gemini/claude_gemini_response.go +36 −1
  2. internal/translator/claude/gemini/claude_gemini_response_test.go +113 −0
  3. internal/translator/gemini/claude/gemini_claude_compat_test.go +43 −2
  4. internal/translator/gemini/claude/gemini_claude_request.go +3 −1
internal/translator/claude/gemini/claude_gemini_response.go+36−1
@@ -11,6 +11,7 @@ import ( · 10 unmodified lines
1111 "strings"
1212 "time"
1313
14+ sigcompat "github.com/router-for-me/CLIProxyAPI/v7/internal/signature"
1415 translatorcommon "github.com/router-for-me/CLIProxyAPI/v7/internal/translator/common"
1516 "github.com/tidwall/gjson"
1617 "github.com/tidwall/sjson"
@@ -116,6 +117,13 @@ func ConvertClaudeResponseToGemini(_ context.Context, modelName string, original · 99 unmodified lines
116117 }
117118 (*param).(*ConvertAnthropicResponseToGeminiParams).ToolUseIDs[idx] = toolID
118119 }
120+ } else if cb.Get("type").String() == "thinking" {
121+ if sig := cb.Get("signature"); sig.Exists() && sig.String() != "" {
122+ thinkingPart := []byte(`{"thought":true,"thoughtSignature":""}`)
123+ thinkingPart, _ = sjson.SetBytes(thinkingPart, "thoughtSignature", sigcompat.GeminiReplaySignatureOrBypass(sig.String(), sigcompat.SignatureBlockKindGeminiModelPart))
124+ template, _ = sjson.SetRawBytes(template, "candidates.0.content.parts.-1", thinkingPart)
125+ return [][]byte{template}
126+ }
119127 }
120128 }
121129 return [][]byte{}
@@ -140,6 +148,12 @@ func ConvertClaudeResponseToGemini(_ context.Context, modelName string, original · 18 unmodified lines
140148 thinkingPart, _ = sjson.SetBytes(thinkingPart, "text", text.String())
141149 template, _ = sjson.SetRawBytes(template, "candidates.0.content.parts.-1", thinkingPart)
142150 }
151+ case "signature_delta":
152+ if sig := delta.Get("signature"); sig.Exists() && sig.String() != "" {
153+ thinkingPart := []byte(`{"thought":true,"thoughtSignature":""}`)
154+ thinkingPart, _ = sjson.SetBytes(thinkingPart, "thoughtSignature", sigcompat.GeminiReplaySignatureOrBypass(sig.String(), sigcompat.SignatureBlockKindGeminiModelPart))
155+ template, _ = sjson.SetRawBytes(template, "candidates.0.content.parts.-1", thinkingPart)
156+ }
143157 case "input_json_delta":
144158 // Tool use input delta - accumulate partial_json by index for later assembly at content_block_stop
145159 idx := int(root.Get("index").Int())
@@ -376,6 +390,12 @@ func ConvertClaudeResponseToGeminiNonStream(_ context.Context, modelName string, · 230 unmodified lines
376390 }
377391 newParam.ToolUseIDs[idx] = toolID
378392 }
393+ } else if cb.Get("type").String() == "thinking" {
394+ if sig := cb.Get("signature"); sig.Exists() && sig.String() != "" {
395+ partJSON := []byte(`{"thought":true,"thoughtSignature":""}`)
396+ partJSON, _ = sjson.SetBytes(partJSON, "thoughtSignature", sigcompat.GeminiReplaySignatureOrBypass(sig.String(), sigcompat.SignatureBlockKindGeminiModelPart))
397+ allParts = append(allParts, partJSON)
398+ }
379399 }
380400 }
381401 continue
@@ -399,6 +419,12 @@ func ConvertClaudeResponseToGeminiNonStream(_ context.Context, modelName string, · 17 unmodified lines
399419 partJSON, _ = sjson.SetBytes(partJSON, "text", text.String())
400420 allParts = append(allParts, partJSON)
401421 }
422+ case "signature_delta":
423+ if sig := delta.Get("signature"); sig.Exists() && sig.String() != "" {
424+ partJSON := []byte(`{"thought":true,"thoughtSignature":""}`)
425+ partJSON, _ = sjson.SetBytes(partJSON, "thoughtSignature", sigcompat.GeminiReplaySignatureOrBypass(sig.String(), sigcompat.SignatureBlockKindGeminiModelPart))
426+ allParts = append(allParts, partJSON)
427+ }
402428 case "input_json_delta":
403429 // accumulate args partial_json for this index
404430 idx := int(root.Get("index").Int())
@@ -535,6 +561,7 @@ func consolidateParts(parts [][]byte) [][]byte { · 130 unmodified lines
535561 var consolidated [][]byte
536562 var currentTextPart strings.Builder
537563 var currentThoughtPart strings.Builder
564+ var currentThoughtSignature string
538565 var hasText, hasThought bool
539566
540567 flushText := func() {
@@ -550,11 +577,15 @@ func consolidateParts(parts [][]byte) [][]byte { · 9 unmodified lines
550577
551578 flushThought := func() {
552579 // Flush accumulated thinking content to the consolidated parts array
553− if hasThought && currentThoughtPart.Len() > 0 {
580+ if hasThought && (currentThoughtPart.Len() > 0 || currentThoughtSignature != "") {
554581 thoughtPartJSON := []byte(`{"thought":true,"text":""}`)
555582 thoughtPartJSON, _ = sjson.SetBytes(thoughtPartJSON, "text", currentThoughtPart.String())
583+ if currentThoughtSignature != "" {
584+ thoughtPartJSON, _ = sjson.SetBytes(thoughtPartJSON, "thoughtSignature", currentThoughtSignature)
585+ }
556586 consolidated = append(consolidated, thoughtPartJSON)
557587 currentThoughtPart.Reset()
588+ currentThoughtSignature = ""
558589 hasThought = false
559590 }
560591 }
@@ -578,6 +609,10 @@ func consolidateParts(parts [][]byte) [][]byte { · 17 unmodified lines
578609 currentThoughtPart.WriteString(text.String())
579610 hasThought = true
580611 }
612+ if sig := part.Get("thoughtSignature"); sig.Exists() && sig.Type == gjson.String && sig.String() != "" {
613+ currentThoughtSignature = sig.String()
614+ hasThought = true
615+ }
581616 } else if text := part.Get("text"); text.Exists() && text.Type == gjson.String {
582617 // This is a regular text part - flush any pending thought first
583618 flushThought() // Flush any pending thought first
internal/translator/claude/gemini/claude_gemini_response_test.go+113−0
@@ -51,3 +51,116 @@ func TestConvertClaudeResponseToGeminiNonStreamPreservesToolUseID(t *testing.T) · 50 unmodified lines
5151 t.Fatalf("expected functionCall.id %q, got %q; chunk=%s", "toolu_gateway", got, string(out))
5252 }
5353 }
54+
55+func TestConvertClaudeResponseToGemini_StreamThinkingSignature(t *testing.T) {
56+ const validGeminiSignature = "EjQKMgEMOdbHO0Gd+c9Mxk4ELwPGbpCEcp2mFfYYLix2UVtBH3fL8GECc4+JITVnHF4qZDsA"
57+
58+ tests := []struct {
59+ name string
60+ signature string
61+ wantSignature string
62+ }{
63+ {
64+ name: "foreign claude signature maps to bypass sentinel",
65+ signature: "foreign_claude_sig_123",
66+ wantSignature: "skip_thought_signature_validator",
67+ },
68+ {
69+ name: "preserves valid gemini signature",
70+ signature: "gemini#" + validGeminiSignature,
71+ wantSignature: validGeminiSignature,
72+ },
73+ }
74+
75+ for _, tt := range tests {
76+ t.Run(tt.name, func(t *testing.T) {
77+ ctx := context.Background()
78+ var param any
79+
80+ chunks := [][]byte{
81+ []byte(`data: {"type":"message_start","message":{"id":"msg_123","model":"claude-3-7-sonnet-20250219"}}`),
82+ []byte(`data: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":""}}`),
83+ []byte(`data: {"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"thinking text"}}`),
84+ []byte(`data: {"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":"` + tt.signature + `"}}`),
85+ []byte(`data: {"type":"content_block_stop","index":0}`),
86+ []byte(`data: {"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}`),
87+ []byte(`data: {"type":"content_block_delta","index":1,"delta":{"type":"text_delta","text":"final answer"}}`),
88+ []byte(`data: {"type":"content_block_stop","index":1}`),
89+ []byte(`data: {"type":"message_stop"}`),
90+ }
91+
92+ var emittedParts []gjson.Result
93+ for _, chunk := range chunks {
94+ out := ConvertClaudeResponseToGemini(ctx, "gemini-2.5-pro", nil, nil, chunk, &param)
95+ for _, c := range out {
96+ parts := gjson.GetBytes(c, "candidates.0.content.parts").Array()
97+ emittedParts = append(emittedParts, parts...)
98+ }
99+ }
100+
101+ var foundSignature string
102+ for _, p := range emittedParts {
103+ if p.Get("thought").Bool() && p.Get("thoughtSignature").Exists() {
104+ foundSignature = p.Get("thoughtSignature").String()
105+ }
106+ }
107+
108+ if foundSignature != tt.wantSignature {
109+ t.Fatalf("expected thoughtSignature %q, got %q", tt.wantSignature, foundSignature)
110+ }
111+ })
112+ }
113+}
114+
115+func TestConvertClaudeResponseToGeminiNonStream_ThinkingSignature(t *testing.T) {
116+ const validGeminiSignature = "EjQKMgEMOdbHO0Gd+c9Mxk4ELwPGbpCEcp2mFfYYLix2UVtBH3fL8GECc4+JITVnHF4qZDsA"
117+
118+ tests := []struct {
119+ name string
120+ signature string
121+ wantSignature string
122+ }{
123+ {
124+ name: "foreign claude signature maps to bypass sentinel",
125+ signature: "foreign_claude_sig_123",
126+ wantSignature: "skip_thought_signature_validator",
127+ },
128+ {
129+ name: "preserves valid gemini signature",
130+ signature: "gemini#" + validGeminiSignature,
131+ wantSignature: validGeminiSignature,
132+ },
133+ }
134+
135+ for _, tt := range tests {
136+ t.Run(tt.name, func(t *testing.T) {
137+ ctx := context.Background()
138+ raw := []byte(strings.Join([]string{
139+ `data: {"type":"message_start","message":{"id":"msg_123","model":"claude-3-7-sonnet-20250219"}}`,
140+ `data: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":""}}`,
141+ `data: {"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"thinking text"}}`,
142+ `data: {"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":"` + tt.signature + `"}}`,
143+ `data: {"type":"content_block_stop","index":0}`,
144+ `data: {"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}`,
145+ `data: {"type":"content_block_delta","index":1,"delta":{"type":"text_delta","text":"final answer"}}`,
146+ `data: {"type":"content_block_stop","index":1}`,
147+ `data: {"type":"message_stop"}`,
148+ }, "\n"))
149+
150+ out := ConvertClaudeResponseToGeminiNonStream(ctx, "gemini-2.5-pro", nil, nil, raw, nil)
151+
152+ thoughtPart := gjson.GetBytes(out, "candidates.0.content.parts.0")
153+ if !thoughtPart.Get("thought").Bool() || thoughtPart.Get("text").String() != "thinking text" {
154+ t.Fatalf("expected thought part with text 'thinking text', got %s", thoughtPart.Raw)
155+ }
156+ if got := thoughtPart.Get("thoughtSignature").String(); got != tt.wantSignature {
157+ t.Fatalf("expected thoughtSignature %q, got %q", tt.wantSignature, got)
158+ }
159+
160+ textPart := gjson.GetBytes(out, "candidates.0.content.parts.1")
161+ if textPart.Get("text").String() != "final answer" {
162+ t.Fatalf("expected text part 'final answer', got %s", textPart.Raw)
163+ }
164+ })
165+ }
166+}
internal/translator/gemini/claude/gemini_claude_compat_test.go+43−2
@@ -3,9 +3,50 @@ package claude · 2 unmodified lines
33 import (
44 "testing"
55
6+ "github.com/router-for-me/CLIProxyAPI/v7/internal/signature"
67 "github.com/tidwall/gjson"
78 )
89
10+const capturedGeminiThinkingSignature = "EjQKMgEMOdbHO0Gd+c9Mxk4ELwPGbpCEcp2mFfYYLix2UVtBH3fL8GECc4+JITVnHF4qZDsA"
11+
12+func TestConvertClaudeRequestToGeminiWithCompat_SignatureCompatibility(t *testing.T) {
13+ tests := []struct {
14+ name string
15+ signature string
16+ wantSignature string
17+ }{
18+ {
19+ name: "preserves valid gemini signature",
20+ signature: "gemini#" + capturedGeminiThinkingSignature,
21+ wantSignature: capturedGeminiThinkingSignature,
22+ },
23+ {
24+ name: "foreign claude signature maps to bypass sentinel",
25+ signature: "claude#opaque-signature-12345",
26+ wantSignature: signature.GeminiSkipThoughtSignatureValidator,
27+ },
28+ {
29+ name: "empty signature maps to bypass sentinel",
30+ signature: "",
31+ wantSignature: signature.GeminiSkipThoughtSignatureValidator,
32+ },
33+ }
34+
35+ for _, tt := range tests {
36+ t.Run(tt.name, func(t *testing.T) {
37+ payload := []byte(`{"messages":[{"role":"assistant","content":[{"type":"thinking","thinking":"reason","signature":"` + tt.signature + `"}]}]}`)
38+ withCompat := ConvertClaudeRequestToGeminiWithCompat("deepseek-v4", payload, false)
39+ part := gjson.GetBytes(withCompat, "contents.0.parts.0")
40+ if !part.Get("thought").Bool() || part.Get("text").String() != "reason" {
41+ t.Fatalf("compat translation missing thought part: %s", withCompat)
42+ }
43+ if got := part.Get("thoughtSignature").String(); got != tt.wantSignature {
44+ t.Fatalf("thoughtSignature = %q, want %q; output: %s", got, tt.wantSignature, withCompat)
45+ }
46+ })
47+ }
48+}
49+
950 func TestConvertClaudeRequestToGeminiWithCompatPreservesEmptyThinking(t *testing.T) {
1051 payload := []byte(`{"messages":[{"role":"assistant","content":[{"type":"thinking","thinking":"reason","signature":""}]}]}`)
1152
@@ -19,7 +60,7 @@ func TestConvertClaudeRequestToGeminiWithCompatPreservesEmptyThinking(t *testing · 7 unmodified lines
1960 if !part.Get("thought").Bool() || part.Get("text").String() != "reason" {
2061 t.Fatalf("compat translation missing thought part: %s", withCompat)
2162 }
22− if !part.Get("thoughtSignature").Exists() || part.Get("thoughtSignature").String() != "" {
23− t.Fatalf("compat translation did not preserve empty signature: %s", withCompat)
63+ if !part.Get("thoughtSignature").Exists() || part.Get("thoughtSignature").String() != signature.GeminiSkipThoughtSignatureValidator {
64+ t.Fatalf("compat translation did not preserve bypass signature: %s", withCompat)
2465 }
2566 }
internal/translator/gemini/claude/gemini_claude_request.go+3−1
@@ -9,6 +9,7 @@ import ( · 8 unmodified lines
99 "strings"
1010
1111 "github.com/router-for-me/CLIProxyAPI/v7/internal/registry"
12+ sigcompat "github.com/router-for-me/CLIProxyAPI/v7/internal/signature"
1213 translatorcommon "github.com/router-for-me/CLIProxyAPI/v7/internal/translator/common"
1314 "github.com/router-for-me/CLIProxyAPI/v7/internal/translator/gemini/common"
1415 "github.com/router-for-me/CLIProxyAPI/v7/internal/util"
@@ -119,7 +120,8 @@ func convertClaudeRequestToGemini(modelName string, inputRawJSON []byte, _ bool, · 104 unmodified lines
119120 }
120121 part := []byte(`{"text":"","thought":true,"thoughtSignature":""}`)
121122 part, _ = sjson.SetBytes(part, "text", contentResult.Get("thinking").String())
122− part, _ = sjson.SetBytes(part, "thoughtSignature", contentResult.Get("signature").String())
123+ signature := sigcompat.GeminiReplaySignatureOrBypass(contentResult.Get("signature").String(), sigcompat.SignatureBlockKindGeminiModelPart)
124+ part, _ = sjson.SetBytes(part, "thoughtSignature", signature)
123125 partItems = append(partItems, part)
124126
125127 case "tool_use":

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t