@@ -5,6 +5,282 @@ import (
55 "testing"
66 )
77
8+// toolHistory is a two-turn tool-use history shared across all endpoint tests:
9+//
10+// user → assistant+tool_calls → tool result → assistant
11+var toolHistory = []NormalizedMessage{
12+ {Role: "user", Content: "What's the weather in Paris?"},
13+ {
14+ Role: "assistant",
15+ Content: "",
16+ ToolCalls: []NormalizedToolCall{
17+ {ID: "call_1", Name: "get_weather", Arguments: json.RawMessage(`{"city":"Paris"}`)},
18+ },
19+ },
20+ // FunctionName is intentionally omitted: ToGeminiRequest derives it from
21+ // the preceding assistant message's ToolCalls via ToolCallID.
22+ {Role: "tool", Content: "Sunny, 22°C", ToolCallID: "call_1"},
23+ {Role: "assistant", Content: "The weather in Paris is sunny and 22°C."},
24+}
25+
26+func TestNormalizedToResponsesToolHistory(t *testing.T) {
27+ req := NormalizedRequest{
28+ Model: "gpt-5.2-codex",
29+ Messages: toolHistory,
30+ }
31+
32+ resp, err := req.ToResponsesRequest()
33+ if err != nil {
34+ t.Fatalf("ToResponsesRequest error: %v", err)
35+ }
36+
37+ items, ok := resp.Input.([]any)
38+ if !ok {
39+ t.Fatalf("Input is not []any, got %T", resp.Input)
40+ }
41+ if len(items) != 4 {
42+ t.Fatalf("expected 4 input items, got %d", len(items))
43+ }
44+
45+ // [0] user message
46+ userMsg, ok := items[0].(ResponsesInputMessage)
47+ if !ok || userMsg.Role != "user" {
48+ t.Fatalf("item[0] should be user ResponsesInputMessage, got %T %+v", items[0], items[0])
49+ }
50+
51+ // [1] function_call item for assistant tool call
52+ fc, ok := items[1].(ResponsesFunctionCall)
53+ if !ok {
54+ t.Fatalf("item[1] should be ResponsesFunctionCall, got %T %+v", items[1], items[1])
55+ }
56+ if fc.Type != "function_call" {
57+ t.Fatalf("item[1] type: want function_call, got %q", fc.Type)
58+ }
59+ if fc.CallID != "call_1" {
60+ t.Fatalf("item[1] call_id: want call_1, got %q", fc.CallID)
61+ }
62+ if fc.Name != "get_weather" {
63+ t.Fatalf("item[1] name: want get_weather, got %q", fc.Name)
64+ }
65+
66+ // [2] function_call_output item for tool result
67+ fco, ok := items[2].(ResponsesFunctionCallOutput)
68+ if !ok {
69+ t.Fatalf("item[2] should be ResponsesFunctionCallOutput, got %T %+v", items[2], items[2])
70+ }
71+ if fco.Type != "function_call_output" {
72+ t.Fatalf("item[2] type: want function_call_output, got %q", fco.Type)
73+ }
74+ if fco.CallID != "call_1" {
75+ t.Fatalf("item[2] call_id: want call_1, got %q", fco.CallID)
76+ }
77+ if fco.Output != "Sunny, 22°C" {
78+ t.Fatalf("item[2] output: want %q, got %q", "Sunny, 22°C", fco.Output)
79+ }
80+
81+ // [3] final assistant message
82+ assistantMsg, ok := items[3].(ResponsesInputMessage)
83+ if !ok || assistantMsg.Role != "assistant" {
84+ t.Fatalf("item[3] should be assistant ResponsesInputMessage, got %T %+v", items[3], items[3])
85+ }
86+}
87+
88+func TestNormalizedToChatCompletionsToolHistory(t *testing.T) {
89+ req := NormalizedRequest{
90+ Model: "gpt-5.2",
91+ Messages: toolHistory,
92+ }
93+
94+ chat, err := req.ToChatCompletionsRequest()
95+ if err != nil {
96+ t.Fatalf("ToChatCompletionsRequest error: %v", err)
97+ }
98+
99+ // No system message injected (System is empty), so 4 messages.
100+ if len(chat.Messages) != 4 {
101+ t.Fatalf("expected 4 messages, got %d", len(chat.Messages))
102+ }
103+
104+ // [0] user
105+ if chat.Messages[0].Role != "user" {
106+ t.Fatalf("msg[0] role: want user, got %q", chat.Messages[0].Role)
107+ }
108+
109+ // [1] assistant with tool_calls
110+ asst := chat.Messages[1]
111+ if asst.Role != "assistant" {
112+ t.Fatalf("msg[1] role: want assistant, got %q", asst.Role)
113+ }
114+ if len(asst.ToolCalls) != 1 {
115+ t.Fatalf("msg[1] tool_calls length: want 1, got %d", len(asst.ToolCalls))
116+ }
117+ if asst.ToolCalls[0].ID != "call_1" {
118+ t.Fatalf("msg[1] tool_calls[0].ID: want call_1, got %q", asst.ToolCalls[0].ID)
119+ }
120+ if asst.ToolCalls[0].Type != "function" {
121+ t.Fatalf("msg[1] tool_calls[0].Type: want function, got %q", asst.ToolCalls[0].Type)
122+ }
123+ if asst.ToolCalls[0].Function.Name != "get_weather" {
124+ t.Fatalf("msg[1] tool_calls[0].Function.Name: want get_weather, got %q", asst.ToolCalls[0].Function.Name)
125+ }
126+ if asst.ToolCalls[0].Function.Arguments != `{"city":"Paris"}` {
127+ t.Fatalf("msg[1] tool_calls[0].Function.Arguments: want %q, got %q", `{"city":"Paris"}`, asst.ToolCalls[0].Function.Arguments)
128+ }
129+
130+ // [2] tool result
131+ toolMsg := chat.Messages[2]
132+ if toolMsg.Role != "tool" {
133+ t.Fatalf("msg[2] role: want tool, got %q", toolMsg.Role)
134+ }
135+ if toolMsg.ToolCallID != "call_1" {
136+ t.Fatalf("msg[2] tool_call_id: want call_1, got %q", toolMsg.ToolCallID)
137+ }
138+ if toolMsg.Content != "Sunny, 22°C" {
139+ t.Fatalf("msg[2] content: want %q, got %q", "Sunny, 22°C", toolMsg.Content)
140+ }
141+
142+ // [3] final assistant
143+ if chat.Messages[3].Role != "assistant" {
144+ t.Fatalf("msg[3] role: want assistant, got %q", chat.Messages[3].Role)
145+ }
146+}
147+
148+func TestNormalizedToMessagesToolHistory(t *testing.T) {
149+ req := NormalizedRequest{
150+ Model: "claude-sonnet-4-6",
151+ Messages: toolHistory,
152+ }
153+
154+ msg, err := req.ToMessagesRequest()
155+ if err != nil {
156+ t.Fatalf("ToMessagesRequest error: %v", err)
157+ }
158+
159+ if len(msg.Messages) != 4 {
160+ t.Fatalf("expected 4 messages, got %d", len(msg.Messages))
161+ }
162+
163+ // [0] user plain text
164+ m0 := msg.Messages[0]
165+ if m0.Role != "user" {
166+ t.Fatalf("msg[0] role: want user, got %q", m0.Role)
167+ }
168+ if m0.Content.(string) != "What's the weather in Paris?" {
169+ t.Fatalf("msg[0] content mismatch")
170+ }
171+
172+ // [1] assistant with tool_use block
173+ m1 := msg.Messages[1]
174+ if m1.Role != "assistant" {
175+ t.Fatalf("msg[1] role: want assistant, got %q", m1.Role)
176+ }
177+ blocks1, ok := m1.Content.([]AnthropicContentBlock)
178+ if !ok {
179+ t.Fatalf("msg[1] content should be []AnthropicContentBlock, got %T", m1.Content)
180+ }
181+ if len(blocks1) != 1 {
182+ t.Fatalf("msg[1] content blocks: want 1, got %d", len(blocks1))
183+ }
184+ if blocks1[0].Type != "tool_use" {
185+ t.Fatalf("msg[1] block[0].Type: want tool_use, got %q", blocks1[0].Type)
186+ }
187+ if blocks1[0].ID != "call_1" {
188+ t.Fatalf("msg[1] block[0].ID: want call_1, got %q", blocks1[0].ID)
189+ }
190+ if blocks1[0].Name != "get_weather" {
191+ t.Fatalf("msg[1] block[0].Name: want get_weather, got %q", blocks1[0].Name)
192+ }
193+
194+ // [2] user with tool_result block (tool role → user message)
195+ m2 := msg.Messages[2]
196+ if m2.Role != "user" {
197+ t.Fatalf("msg[2] role: want user (tool_result), got %q", m2.Role)
198+ }
199+ blocks2, ok := m2.Content.([]AnthropicContentBlock)
200+ if !ok {
201+ t.Fatalf("msg[2] content should be []AnthropicContentBlock, got %T", m2.Content)
202+ }
203+ if len(blocks2) != 1 || blocks2[0].Type != "tool_result" {
204+ t.Fatalf("msg[2] should have 1 tool_result block, got %+v", blocks2)
205+ }
206+ if blocks2[0].ToolUseID != "call_1" {
207+ t.Fatalf("msg[2] block[0].ToolUseID: want call_1, got %q", blocks2[0].ToolUseID)
208+ }
209+ if blocks2[0].Content != "Sunny, 22°C" {
210+ t.Fatalf("msg[2] block[0].Content: want %q, got %q", "Sunny, 22°C", blocks2[0].Content)
211+ }
212+
213+ // [3] final assistant plain text
214+ m3 := msg.Messages[3]
215+ if m3.Role != "assistant" {
216+ t.Fatalf("msg[3] role: want assistant, got %q", m3.Role)
217+ }
218+ if m3.Content.(string) != "The weather in Paris is sunny and 22°C." {
219+ t.Fatalf("msg[3] content mismatch")
220+ }
221+}
222+
223+func TestNormalizedToGeminiToolHistory(t *testing.T) {
224+ req := NormalizedRequest{
225+ Model: "gemini-3-pro",
226+ Messages: toolHistory,
227+ }
228+
229+ gem, err := req.ToGeminiRequest()
230+ if err != nil {
231+ t.Fatalf("ToGeminiRequest error: %v", err)
232+ }
233+
234+ if len(gem.Contents) != 4 {
235+ t.Fatalf("expected 4 contents, got %d", len(gem.Contents))
236+ }
237+
238+ // [0] user plain text
239+ c0 := gem.Contents[0]
240+ if c0.Role != "user" {
241+ t.Fatalf("content[0] role: want user, got %q", c0.Role)
242+ }
243+ if len(c0.Parts) != 1 || c0.Parts[0].Text != "What's the weather in Paris?" {
244+ t.Fatalf("content[0] parts mismatch: %+v", c0.Parts)
245+ }
246+
247+ // [1] model with functionCall part
248+ c1 := gem.Contents[1]
249+ if c1.Role != "model" {
250+ t.Fatalf("content[1] role: want model, got %q", c1.Role)
251+ }
252+ if len(c1.Parts) != 1 || c1.Parts[0].FunctionCall == nil {
253+ t.Fatalf("content[1] should have 1 functionCall part, got %+v", c1.Parts)
254+ }
255+ if c1.Parts[0].FunctionCall.Name != "get_weather" {
256+ t.Fatalf("content[1] functionCall.Name: want get_weather, got %q", c1.Parts[0].FunctionCall.Name)
257+ }
258+
259+ // [2] user with functionResponse part
260+ c2 := gem.Contents[2]
261+ if c2.Role != "user" {
262+ t.Fatalf("content[2] role: want user, got %q", c2.Role)
263+ }
264+ if len(c2.Parts) != 1 || c2.Parts[0].FunctionResponse == nil {
265+ t.Fatalf("content[2] should have 1 functionResponse part, got %+v", c2.Parts)
266+ }
267+ if c2.Parts[0].FunctionResponse.Name != "get_weather" {
268+ t.Fatalf("content[2] functionResponse.Name: want get_weather, got %q", c2.Parts[0].FunctionResponse.Name)
269+ }
270+ if c2.Parts[0].FunctionResponse.Response.Output != "Sunny, 22°C" {
271+ t.Fatalf("content[2] functionResponse.Response.Output: want %q, got %q", "Sunny, 22°C", c2.Parts[0].FunctionResponse.Response.Output)
272+ }
273+
274+ // [3] final model plain text
275+ c3 := gem.Contents[3]
276+ if c3.Role != "model" {
277+ t.Fatalf("content[3] role: want model, got %q", c3.Role)
278+ }
279+ if len(c3.Parts) != 1 || c3.Parts[0].Text != "The weather in Paris is sunny and 22°C." {
280+ t.Fatalf("content[3] parts mismatch: %+v", c3.Parts)
281+ }
282+}
283+
8284 func TestNormalizedToResponses(t *testing.T) {
9285 req := NormalizedRequest{
10286 Model: "gpt-5.2-codex",
@@ -32,7 +308,7 @@ func TestNormalizedToResponses(t *testing.T) {
32308 if resp.Reasoning == nil || resp.Reasoning.Effort != "low" {
33309 t.Fatalf("reasoning not mapped")
34310 }
35- if len(resp.Tools) != 1 || resp.Tools[0].Function.Name != "tool" {
311+ if len(resp.Tools) != 1 || resp.Tools[0].Name != "tool" {
36312 t.Fatalf("tools not mapped")
37313 }
38314 choice, ok := resp.ToolChoice.(map[string]any)