xonecas.io
6312
Ga

go-opencode-ai-zen-sdk / files

go-opencode-ai-zen-sdk / normalized_test.go

12.1 KB
1package zen
2
3import (
4	"encoding/json"
5	"testing"
6)
7
8// toolHistory is a two-turn tool-use history shared across all endpoint tests:
9//
10//	user → assistant+tool_calls → tool result → assistant
11var 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
26func 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	if len(userMsg.Content) != 1 || userMsg.Content[0].Text == "" {
51		t.Fatalf("item[0] content should have input_text, got %+v", userMsg.Content)
52	}
53
54	// [1] function_call item for assistant tool call
55	fc, ok := items[1].(ResponsesFunctionCall)
56	if !ok {
57		t.Fatalf("item[1] should be ResponsesFunctionCall, got %T %+v", items[1], items[1])
58	}
59	if fc.Type != "function_call" {
60		t.Fatalf("item[1] type: want function_call, got %q", fc.Type)
61	}
62	if fc.CallID != "call_1" {
63		t.Fatalf("item[1] call_id: want call_1, got %q", fc.CallID)
64	}
65	if fc.Name != "get_weather" {
66		t.Fatalf("item[1] name: want get_weather, got %q", fc.Name)
67	}
68
69	// [2] function_call_output item for tool result
70	fco, ok := items[2].(ResponsesFunctionCallOutput)
71	if !ok {
72		t.Fatalf("item[2] should be ResponsesFunctionCallOutput, got %T %+v", items[2], items[2])
73	}
74	if fco.Type != "function_call_output" {
75		t.Fatalf("item[2] type: want function_call_output, got %q", fco.Type)
76	}
77	if fco.CallID != "call_1" {
78		t.Fatalf("item[2] call_id: want call_1, got %q", fco.CallID)
79	}
80	if fco.Output != "Sunny, 22°C" {
81		t.Fatalf("item[2] output: want %q, got %q", "Sunny, 22°C", fco.Output)
82	}
83
84	// [3] final assistant message
85	assistantMsg, ok := items[3].(ResponsesInputMessage)
86	if !ok || assistantMsg.Role != "assistant" {
87		t.Fatalf("item[3] should be assistant ResponsesInputMessage, got %T %+v", items[3], items[3])
88	}
89	if len(assistantMsg.Content) != 1 || assistantMsg.Content[0].Type != "output_text" {
90		t.Fatalf("item[3] content should be output_text, got %+v", assistantMsg.Content)
91	}
92}
93
94func TestNormalizedToChatCompletionsToolHistory(t *testing.T) {
95	req := NormalizedRequest{
96		Model:    "gpt-5.2",
97		Messages: toolHistory,
98	}
99
100	chat, err := req.ToChatCompletionsRequest()
101	if err != nil {
102		t.Fatalf("ToChatCompletionsRequest error: %v", err)
103	}
104
105	// No system message injected (System is empty), so 4 messages.
106	if len(chat.Messages) != 4 {
107		t.Fatalf("expected 4 messages, got %d", len(chat.Messages))
108	}
109
110	// [0] user
111	if chat.Messages[0].Role != "user" {
112		t.Fatalf("msg[0] role: want user, got %q", chat.Messages[0].Role)
113	}
114
115	// [1] assistant with tool_calls
116	asst := chat.Messages[1]
117	if asst.Role != "assistant" {
118		t.Fatalf("msg[1] role: want assistant, got %q", asst.Role)
119	}
120	if len(asst.ToolCalls) != 1 {
121		t.Fatalf("msg[1] tool_calls length: want 1, got %d", len(asst.ToolCalls))
122	}
123	if asst.ToolCalls[0].ID != "call_1" {
124		t.Fatalf("msg[1] tool_calls[0].ID: want call_1, got %q", asst.ToolCalls[0].ID)
125	}
126	if asst.ToolCalls[0].Type != "function" {
127		t.Fatalf("msg[1] tool_calls[0].Type: want function, got %q", asst.ToolCalls[0].Type)
128	}
129	if asst.ToolCalls[0].Function.Name != "get_weather" {
130		t.Fatalf("msg[1] tool_calls[0].Function.Name: want get_weather, got %q", asst.ToolCalls[0].Function.Name)
131	}
132	if asst.ToolCalls[0].Function.Arguments != `{"city":"Paris"}` {
133		t.Fatalf("msg[1] tool_calls[0].Function.Arguments: want %q, got %q", `{"city":"Paris"}`, asst.ToolCalls[0].Function.Arguments)
134	}
135
136	// [2] tool result
137	toolMsg := chat.Messages[2]
138	if toolMsg.Role != "tool" {
139		t.Fatalf("msg[2] role: want tool, got %q", toolMsg.Role)
140	}
141	if toolMsg.ToolCallID != "call_1" {
142		t.Fatalf("msg[2] tool_call_id: want call_1, got %q", toolMsg.ToolCallID)
143	}
144	if toolMsg.Content != "Sunny, 22°C" {
145		t.Fatalf("msg[2] content: want %q, got %q", "Sunny, 22°C", toolMsg.Content)
146	}
147
148	// [3] final assistant
149	if chat.Messages[3].Role != "assistant" {
150		t.Fatalf("msg[3] role: want assistant, got %q", chat.Messages[3].Role)
151	}
152}
153
154func TestNormalizedToMessagesToolHistory(t *testing.T) {
155	req := NormalizedRequest{
156		Model:    "claude-sonnet-4-6",
157		Messages: toolHistory,
158	}
159
160	msg, err := req.ToMessagesRequest()
161	if err != nil {
162		t.Fatalf("ToMessagesRequest error: %v", err)
163	}
164
165	if len(msg.Messages) != 4 {
166		t.Fatalf("expected 4 messages, got %d", len(msg.Messages))
167	}
168
169	// [0] user plain text
170	m0 := msg.Messages[0]
171	if m0.Role != "user" {
172		t.Fatalf("msg[0] role: want user, got %q", m0.Role)
173	}
174	if m0.Content.(string) != "What's the weather in Paris?" {
175		t.Fatalf("msg[0] content mismatch")
176	}
177
178	// [1] assistant with tool_use block
179	m1 := msg.Messages[1]
180	if m1.Role != "assistant" {
181		t.Fatalf("msg[1] role: want assistant, got %q", m1.Role)
182	}
183	blocks1, ok := m1.Content.([]AnthropicContentBlock)
184	if !ok {
185		t.Fatalf("msg[1] content should be []AnthropicContentBlock, got %T", m1.Content)
186	}
187	if len(blocks1) != 1 {
188		t.Fatalf("msg[1] content blocks: want 1, got %d", len(blocks1))
189	}
190	if blocks1[0].Type != "tool_use" {
191		t.Fatalf("msg[1] block[0].Type: want tool_use, got %q", blocks1[0].Type)
192	}
193	if blocks1[0].ID != "call_1" {
194		t.Fatalf("msg[1] block[0].ID: want call_1, got %q", blocks1[0].ID)
195	}
196	if blocks1[0].Name != "get_weather" {
197		t.Fatalf("msg[1] block[0].Name: want get_weather, got %q", blocks1[0].Name)
198	}
199
200	// [2] user with tool_result block (tool role → user message)
201	m2 := msg.Messages[2]
202	if m2.Role != "user" {
203		t.Fatalf("msg[2] role: want user (tool_result), got %q", m2.Role)
204	}
205	blocks2, ok := m2.Content.([]AnthropicContentBlock)
206	if !ok {
207		t.Fatalf("msg[2] content should be []AnthropicContentBlock, got %T", m2.Content)
208	}
209	if len(blocks2) != 1 || blocks2[0].Type != "tool_result" {
210		t.Fatalf("msg[2] should have 1 tool_result block, got %+v", blocks2)
211	}
212	if blocks2[0].ToolUseID != "call_1" {
213		t.Fatalf("msg[2] block[0].ToolUseID: want call_1, got %q", blocks2[0].ToolUseID)
214	}
215	if blocks2[0].Content != "Sunny, 22°C" {
216		t.Fatalf("msg[2] block[0].Content: want %q, got %q", "Sunny, 22°C", blocks2[0].Content)
217	}
218
219	// [3] final assistant plain text
220	m3 := msg.Messages[3]
221	if m3.Role != "assistant" {
222		t.Fatalf("msg[3] role: want assistant, got %q", m3.Role)
223	}
224	if m3.Content.(string) != "The weather in Paris is sunny and 22°C." {
225		t.Fatalf("msg[3] content mismatch")
226	}
227}
228
229func TestNormalizedToGeminiToolHistory(t *testing.T) {
230	req := NormalizedRequest{
231		Model:    "gemini-3-pro",
232		Messages: toolHistory,
233	}
234
235	gem, err := req.ToGeminiRequest()
236	if err != nil {
237		t.Fatalf("ToGeminiRequest error: %v", err)
238	}
239
240	if len(gem.Contents) != 4 {
241		t.Fatalf("expected 4 contents, got %d", len(gem.Contents))
242	}
243
244	// [0] user plain text
245	c0 := gem.Contents[0]
246	if c0.Role != "user" {
247		t.Fatalf("content[0] role: want user, got %q", c0.Role)
248	}
249	if len(c0.Parts) != 1 || c0.Parts[0].Text != "What's the weather in Paris?" {
250		t.Fatalf("content[0] parts mismatch: %+v", c0.Parts)
251	}
252
253	// [1] model with functionCall part
254	c1 := gem.Contents[1]
255	if c1.Role != "model" {
256		t.Fatalf("content[1] role: want model, got %q", c1.Role)
257	}
258	if len(c1.Parts) != 1 || c1.Parts[0].FunctionCall == nil {
259		t.Fatalf("content[1] should have 1 functionCall part, got %+v", c1.Parts)
260	}
261	if c1.Parts[0].FunctionCall.Name != "get_weather" {
262		t.Fatalf("content[1] functionCall.Name: want get_weather, got %q", c1.Parts[0].FunctionCall.Name)
263	}
264
265	// [2] user with functionResponse part
266	c2 := gem.Contents[2]
267	if c2.Role != "user" {
268		t.Fatalf("content[2] role: want user, got %q", c2.Role)
269	}
270	if len(c2.Parts) != 1 || c2.Parts[0].FunctionResponse == nil {
271		t.Fatalf("content[2] should have 1 functionResponse part, got %+v", c2.Parts)
272	}
273	if c2.Parts[0].FunctionResponse.Name != "get_weather" {
274		t.Fatalf("content[2] functionResponse.Name: want get_weather, got %q", c2.Parts[0].FunctionResponse.Name)
275	}
276	if c2.Parts[0].FunctionResponse.Response.Output != "Sunny, 22°C" {
277		t.Fatalf("content[2] functionResponse.Response.Output: want %q, got %q", "Sunny, 22°C", c2.Parts[0].FunctionResponse.Response.Output)
278	}
279
280	// [3] final model plain text
281	c3 := gem.Contents[3]
282	if c3.Role != "model" {
283		t.Fatalf("content[3] role: want model, got %q", c3.Role)
284	}
285	if len(c3.Parts) != 1 || c3.Parts[0].Text != "The weather in Paris is sunny and 22°C." {
286		t.Fatalf("content[3] parts mismatch: %+v", c3.Parts)
287	}
288}
289
290func TestNormalizedToResponses(t *testing.T) {
291	req := NormalizedRequest{
292		Model:  "gpt-5.2-codex",
293		System: "system",
294		Messages: []NormalizedMessage{
295			{Role: "user", Content: "hi"},
296		},
297		Tools: []NormalizedTool{
298			{Name: "tool", Description: "desc", Parameters: json.RawMessage(`{"type":"object"}`)},
299		},
300		ToolChoice: &NormalizedToolChoice{Type: ToolChoiceTool, Name: "tool"},
301		Reasoning:  &NormalizedReasoning{Effort: "low"},
302	}
303
304	resp, err := req.ToResponsesRequest()
305	if err != nil {
306		t.Fatalf("ToResponsesRequest error: %v", err)
307	}
308	if resp.Model != req.Model {
309		t.Fatalf("model mismatch: %s", resp.Model)
310	}
311	if resp.Input == nil {
312		t.Fatalf("input should be set")
313	}
314	if resp.Reasoning == nil || resp.Reasoning.Effort != "low" {
315		t.Fatalf("reasoning not mapped")
316	}
317	if len(resp.Tools) != 1 || resp.Tools[0].Name != "tool" {
318		t.Fatalf("tools not mapped")
319	}
320	choice, ok := resp.ToolChoice.(map[string]any)
321	if !ok {
322		t.Fatalf("tool choice type mismatch")
323	}
324	function, ok := choice["function"].(map[string]any)
325	if !ok || function["name"] != "tool" {
326		t.Fatalf("tool choice name mismatch")
327	}
328}
329
330func TestNormalizedToChatCompletions(t *testing.T) {
331	req := NormalizedRequest{
332		Model:  "gpt-5.2",
333		System: "system",
334		Messages: []NormalizedMessage{
335			{Role: "user", Content: "hi"},
336		},
337		ToolChoice: &NormalizedToolChoice{Type: ToolChoiceAuto},
338	}
339
340	chat, err := req.ToChatCompletionsRequest()
341	if err != nil {
342		t.Fatalf("ToChatCompletionsRequest error: %v", err)
343	}
344	if len(chat.Messages) != 2 || chat.Messages[0].Role != "system" {
345		t.Fatalf("system message not injected")
346	}
347	if chat.ToolChoice != "auto" {
348		t.Fatalf("tool choice not mapped")
349	}
350}
351
352func TestNormalizedToMessages(t *testing.T) {
353	req := NormalizedRequest{
354		Model:  "claude-sonnet-4-6",
355		System: "system",
356		Messages: []NormalizedMessage{
357			{Role: "user", Content: "hi"},
358			{Role: "assistant", Content: "hello"},
359		},
360		Reasoning: &NormalizedReasoning{Effort: "medium"},
361	}
362
363	msg, err := req.ToMessagesRequest()
364	if err != nil {
365		t.Fatalf("ToMessagesRequest error: %v", err)
366	}
367	if msg.System == "" {
368		t.Fatalf("system should be set")
369	}
370	if len(msg.Messages) != 2 {
371		t.Fatalf("messages not mapped")
372	}
373	if msg.Thinking == nil || msg.Thinking.BudgetTokens == 0 {
374		t.Fatalf("thinking not mapped")
375	}
376}
377
378func TestNormalizedToGemini(t *testing.T) {
379	req := NormalizedRequest{
380		Model:  "gemini-3-pro",
381		System: "system",
382		Messages: []NormalizedMessage{
383			{Role: "user", Content: "hi"},
384		},
385		ToolChoice: &NormalizedToolChoice{Type: ToolChoiceRequired},
386		Reasoning:  &NormalizedReasoning{Effort: "high"},
387	}
388
389	gem, err := req.ToGeminiRequest()
390	if err != nil {
391		t.Fatalf("ToGeminiRequest error: %v", err)
392	}
393	if gem.SystemInstruction == nil {
394		t.Fatalf("system instruction not set")
395	}
396	if gem.ToolConfig == nil || gem.ToolConfig.FunctionCallingConfig == nil {
397		t.Fatalf("tool config missing")
398	}
399	if gem.ToolConfig.FunctionCallingConfig.Mode != "ANY" {
400		t.Fatalf("tool choice not mapped to ANY")
401	}
402	if gem.GenerationConfig == nil || gem.GenerationConfig.ThinkingConfig == nil {
403		t.Fatalf("thinking config missing")
404	}
405}