@@ -0,0 +1,505 @@
1+package provider
2+
3+import (
4+ "encoding/json"
5+ "testing"
6+
7+ openai "github.com/sashabaranov/go-openai"
8+)
9+
10+// TestMergeSystemMessagesOpenAI_MultipleSystemMessages tests that multiple
11+// system messages are merged into a single message at the start.
12+func TestMergeSystemMessagesOpenAI_MultipleSystemMessages(t *testing.T) {
13+ messages := []openai.ChatCompletionMessage{
14+ {Role: "system", Content: "You are helpful."},
15+ {Role: "user", Content: "Hello"},
16+ {Role: "system", Content: "Be concise."},
17+ {Role: "assistant", Content: "Hi!"},
18+ {Role: "system", Content: "Use simple words."},
19+ }
20+
21+ result := mergeSystemMessagesOpenAI(messages)
22+
23+ // Should have: 1 merged system + 2 non-system = 3 messages
24+ if len(result) != 3 {
25+ t.Fatalf("expected 3 messages, got %d", len(result))
26+ }
27+
28+ // First message should be merged system message
29+ if result[0].Role != "system" {
30+ t.Errorf("expected first role=system, got %s", result[0].Role)
31+ }
32+ expected := "You are helpful.\n\nBe concise.\n\nUse simple words."
33+ if result[0].Content != expected {
34+ t.Errorf("expected content=%q, got %q", expected, result[0].Content)
35+ }
36+
37+ // Non-system messages should follow in order
38+ if result[1].Role != "user" || result[1].Content != "Hello" {
39+ t.Errorf("expected user message 'Hello', got role=%s content=%q", result[1].Role, result[1].Content)
40+ }
41+ if result[2].Role != "assistant" || result[2].Content != "Hi!" {
42+ t.Errorf("expected assistant message 'Hi!', got role=%s content=%q", result[2].Role, result[2].Content)
43+ }
44+}
45+
46+// TestMergeSystemMessagesOpenAI_OnlySystemMessages tests that when only
47+// system messages exist, a fallback "Begin." user message is added.
48+func TestMergeSystemMessagesOpenAI_OnlySystemMessages(t *testing.T) {
49+ messages := []openai.ChatCompletionMessage{
50+ {Role: "system", Content: "You are helpful."},
51+ {Role: "system", Content: "Be concise."},
52+ }
53+
54+ result := mergeSystemMessagesOpenAI(messages)
55+
56+ // Should have: 1 merged system + 1 fallback user = 2 messages
57+ if len(result) != 2 {
58+ t.Fatalf("expected 2 messages, got %d", len(result))
59+ }
60+
61+ // First message should be merged system
62+ if result[0].Role != "system" {
63+ t.Errorf("expected first role=system, got %s", result[0].Role)
64+ }
65+ expected := "You are helpful.\n\nBe concise."
66+ if result[0].Content != expected {
67+ t.Errorf("expected content=%q, got %q", expected, result[0].Content)
68+ }
69+
70+ // Second message should be fallback user message
71+ if result[1].Role != "user" {
72+ t.Errorf("expected second role=user, got %s", result[1].Role)
73+ }
74+ if result[1].Content != "Begin." {
75+ t.Errorf("expected content='Begin.', got %q", result[1].Content)
76+ }
77+}
78+
79+// TestMergeSystemMessagesOpenAI_NoSystemMessages tests that when no system
80+// messages exist, the messages are returned unchanged.
81+func TestMergeSystemMessagesOpenAI_NoSystemMessages(t *testing.T) {
82+ messages := []openai.ChatCompletionMessage{
83+ {Role: "user", Content: "Hello"},
84+ {Role: "assistant", Content: "Hi!"},
85+ }
86+
87+ result := mergeSystemMessagesOpenAI(messages)
88+
89+ // Should be unchanged
90+ if len(result) != 2 {
91+ t.Fatalf("expected 2 messages, got %d", len(result))
92+ }
93+ if result[0].Role != "user" || result[0].Content != "Hello" {
94+ t.Errorf("expected user message unchanged, got role=%s content=%q", result[0].Role, result[0].Content)
95+ }
96+ if result[1].Role != "assistant" || result[1].Content != "Hi!" {
97+ t.Errorf("expected assistant message unchanged, got role=%s content=%q", result[1].Role, result[1].Content)
98+ }
99+}
100+
101+// TestMergeSystemMessagesOpenAI_Empty tests empty input.
102+func TestMergeSystemMessagesOpenAI_Empty(t *testing.T) {
103+ messages := []openai.ChatCompletionMessage{}
104+
105+ result := mergeSystemMessagesOpenAI(messages)
106+
107+ if len(result) != 0 {
108+ t.Errorf("expected empty result, got %d messages", len(result))
109+ }
110+}
111+
112+// TestMergeSystemMessagesOpenAI_SystemFirst tests that system messages are
113+// moved to the start when mixed with other messages.
114+func TestMergeSystemMessagesOpenAI_SystemFirst(t *testing.T) {
115+ messages := []openai.ChatCompletionMessage{
116+ {Role: "user", Content: "Hello"},
117+ {Role: "system", Content: "You are helpful."},
118+ {Role: "assistant", Content: "Hi!"},
119+ }
120+
121+ result := mergeSystemMessagesOpenAI(messages)
122+
123+ // Should have: 1 system + 2 non-system = 3 messages
124+ if len(result) != 3 {
125+ t.Fatalf("expected 3 messages, got %d", len(result))
126+ }
127+
128+ // System should be first
129+ if result[0].Role != "system" {
130+ t.Errorf("expected first role=system, got %s", result[0].Role)
131+ }
132+ if result[0].Content != "You are helpful." {
133+ t.Errorf("expected content='You are helpful.', got %q", result[0].Content)
134+ }
135+
136+ // Non-system messages should follow
137+ if result[1].Role != "user" {
138+ t.Errorf("expected second role=user, got %s", result[1].Role)
139+ }
140+ if result[2].Role != "assistant" {
141+ t.Errorf("expected third role=assistant, got %s", result[2].Role)
142+ }
143+}
144+
145+// TestToOpenAIMessages_ToolCalls tests conversion of assistant messages
146+// with tool calls.
147+func TestToOpenAIMessages_ToolCalls(t *testing.T) {
148+ messages := []Message{
149+ {Role: "user", Content: "What's the weather?"},
150+ {
151+ Role: "assistant",
152+ Content: "",
153+ ToolCalls: []ToolCall{
154+ {
155+ ID: "call_123",
156+ Name: "get_weather",
157+ Arguments: json.RawMessage(`{"location":"NYC"}`),
158+ },
159+ {
160+ ID: "call_456",
161+ Name: "get_forecast",
162+ Arguments: json.RawMessage(`{"days":3}`),
163+ },
164+ },
165+ },
166+ }
167+
168+ result := toOpenAIMessages(messages)
169+
170+ if len(result) != 2 {
171+ t.Fatalf("expected 2 messages, got %d", len(result))
172+ }
173+
174+ // Check user message
175+ if result[0].Role != "user" || result[0].Content != "What's the weather?" {
176+ t.Errorf("expected user message, got role=%s content=%q", result[0].Role, result[0].Content)
177+ }
178+
179+ // Check assistant message with tool calls
180+ assistantMsg := result[1]
181+ if assistantMsg.Role != "assistant" {
182+ t.Errorf("expected role=assistant, got %s", assistantMsg.Role)
183+ }
184+ if len(assistantMsg.ToolCalls) != 2 {
185+ t.Fatalf("expected 2 tool calls, got %d", len(assistantMsg.ToolCalls))
186+ }
187+
188+ // Check first tool call
189+ tc1 := assistantMsg.ToolCalls[0]
190+ if tc1.ID != "call_123" {
191+ t.Errorf("expected ID=call_123, got %s", tc1.ID)
192+ }
193+ if tc1.Type != openai.ToolTypeFunction {
194+ t.Errorf("expected Type=function, got %s", tc1.Type)
195+ }
196+ if tc1.Function.Name != "get_weather" {
197+ t.Errorf("expected Name=get_weather, got %s", tc1.Function.Name)
198+ }
199+ if tc1.Function.Arguments != `{"location":"NYC"}` {
200+ t.Errorf("expected Arguments={\"location\":\"NYC\"}, got %s", tc1.Function.Arguments)
201+ }
202+
203+ // Check second tool call
204+ tc2 := assistantMsg.ToolCalls[1]
205+ if tc2.ID != "call_456" {
206+ t.Errorf("expected ID=call_456, got %s", tc2.ID)
207+ }
208+ if tc2.Function.Name != "get_forecast" {
209+ t.Errorf("expected Name=get_forecast, got %s", tc2.Function.Name)
210+ }
211+}
212+
213+// TestToOpenAIMessages_ToolResults tests conversion of tool result messages
214+// with tool_call_id.
215+func TestToOpenAIMessages_ToolResults(t *testing.T) {
216+ messages := []Message{
217+ {Role: "user", Content: "What's the weather?"},
218+ {
219+ Role: "assistant",
220+ Content: "",
221+ ToolCalls: []ToolCall{
222+ {ID: "call_123", Name: "get_weather", Arguments: json.RawMessage(`{}`)},
223+ },
224+ },
225+ {
226+ Role: "tool",
227+ Content: `{"temp":72,"condition":"sunny"}`,
228+ ToolCallID: "call_123",
229+ },
230+ }
231+
232+ result := toOpenAIMessages(messages)
233+
234+ if len(result) != 3 {
235+ t.Fatalf("expected 3 messages, got %d", len(result))
236+ }
237+
238+ // Check tool result message
239+ toolMsg := result[2]
240+ if toolMsg.Role != "tool" {
241+ t.Errorf("expected role=tool, got %s", toolMsg.Role)
242+ }
243+ if toolMsg.ToolCallID != "call_123" {
244+ t.Errorf("expected ToolCallID=call_123, got %s", toolMsg.ToolCallID)
245+ }
246+ if toolMsg.Content != `{"temp":72,"condition":"sunny"}` {
247+ t.Errorf("unexpected content: %s", toolMsg.Content)
248+ }
249+}
250+
251+// TestToOpenAIMessages_EmptyMessages tests empty input.
252+func TestToOpenAIMessages_EmptyMessages(t *testing.T) {
253+ messages := []Message{}
254+
255+ result := toOpenAIMessages(messages)
256+
257+ if len(result) != 0 {
258+ t.Errorf("expected empty result, got %d messages", len(result))
259+ }
260+}
261+
262+// TestToOpenAIMessages_EmptyContent tests messages with empty content.
263+func TestToOpenAIMessages_EmptyContent(t *testing.T) {
264+ messages := []Message{
265+ {Role: "user", Content: ""},
266+ {Role: "assistant", Content: ""},
267+ }
268+
269+ result := toOpenAIMessages(messages)
270+
271+ if len(result) != 2 {
272+ t.Fatalf("expected 2 messages, got %d", len(result))
273+ }
274+ if result[0].Content != "" {
275+ t.Errorf("expected empty content, got %q", result[0].Content)
276+ }
277+ if result[1].Content != "" {
278+ t.Errorf("expected empty content, got %q", result[1].Content)
279+ }
280+}
281+
282+// TestToOpenAITools_ValidJSON tests conversion of tools with valid JSON schema.
283+func TestToOpenAITools_ValidJSON(t *testing.T) {
284+ tools := []Tool{
285+ {
286+ Name: "get_weather",
287+ Description: "Get current weather",
288+ Parameters: json.RawMessage(`{"type":"object","properties":{"location":{"type":"string"}},"required":["location"]}`),
289+ },
290+ {
291+ Name: "get_time",
292+ Description: "Get current time",
293+ Parameters: json.RawMessage(`{"type":"object","properties":{"timezone":{"type":"string"}}}`),
294+ },
295+ }
296+
297+ result, err := toOpenAITools(tools)
298+ if err != nil {
299+ t.Fatalf("toOpenAITools() error: %v", err)
300+ }
301+
302+ if len(result) != 2 {
303+ t.Fatalf("expected 2 tools, got %d", len(result))
304+ }
305+
306+ // Check first tool
307+ tool1 := result[0]
308+ if tool1.Type != openai.ToolTypeFunction {
309+ t.Errorf("expected Type=function, got %s", tool1.Type)
310+ }
311+ if tool1.Function.Name != "get_weather" {
312+ t.Errorf("expected Name=get_weather, got %s", tool1.Function.Name)
313+ }
314+ if tool1.Function.Description != "Get current weather" {
315+ t.Errorf("expected Description='Get current weather', got %s", tool1.Function.Description)
316+ }
317+
318+ // Check parameters are valid map
319+ params1, ok := tool1.Function.Parameters.(map[string]interface{})
320+ if !ok {
321+ t.Fatalf("expected Parameters to be map[string]interface{}, got %T", tool1.Function.Parameters)
322+ }
323+ if params1["type"] != "object" {
324+ t.Errorf("expected type=object, got %v", params1["type"])
325+ }
326+ props1, ok := params1["properties"].(map[string]interface{})
327+ if !ok {
328+ t.Fatalf("expected properties to be map, got %T", params1["properties"])
329+ }
330+ if _, ok := props1["location"]; !ok {
331+ t.Error("expected location property")
332+ }
333+
334+ // Check second tool
335+ tool2 := result[1]
336+ if tool2.Function.Name != "get_time" {
337+ t.Errorf("expected Name=get_time, got %s", tool2.Function.Name)
338+ }
339+}
340+
341+// TestToOpenAITools_InvalidJSON tests that invalid JSON schema returns error.
342+func TestToOpenAITools_InvalidJSON(t *testing.T) {
343+ tools := []Tool{
344+ {
345+ Name: "bad_tool",
346+ Description: "Tool with invalid JSON",
347+ Parameters: json.RawMessage(`{invalid json}`),
348+ },
349+ }
350+
351+ result, err := toOpenAITools(tools)
352+ if err == nil {
353+ t.Fatal("expected error for invalid JSON, got nil")
354+ }
355+ if result != nil {
356+ t.Errorf("expected nil result on error, got %v", result)
357+ }
358+}
359+
360+// TestToOpenAITools_EmptyParameters tests tools with empty parameters.
361+func TestToOpenAITools_EmptyParameters(t *testing.T) {
362+ tools := []Tool{
363+ {
364+ Name: "no_params",
365+ Description: "Tool with no parameters",
366+ Parameters: json.RawMessage(``),
367+ },
368+ }
369+
370+ result, err := toOpenAITools(tools)
371+ if err != nil {
372+ t.Fatalf("toOpenAITools() error: %v", err)
373+ }
374+
375+ if len(result) != 1 {
376+ t.Fatalf("expected 1 tool, got %d", len(result))
377+ }
378+
379+ // Should have default object schema with empty properties
380+ params, ok := result[0].Function.Parameters.(map[string]interface{})
381+ if !ok {
382+ t.Fatalf("expected Parameters to be map[string]interface{}, got %T", result[0].Function.Parameters)
383+ }
384+ if params["type"] != "object" {
385+ t.Errorf("expected type=object, got %v", params["type"])
386+ }
387+ props, ok := params["properties"].(map[string]interface{})
388+ if !ok {
389+ t.Fatalf("expected properties to be map, got %T", params["properties"])
390+ }
391+ if len(props) != 0 {
392+ t.Errorf("expected empty properties, got %v", props)
393+ }
394+}
395+
396+// TestToOpenAITools_NilParameters tests tools with nil parameters.
397+func TestToOpenAITools_NilParameters(t *testing.T) {
398+ tools := []Tool{
399+ {
400+ Name: "nil_params",
401+ Description: "Tool with nil parameters",
402+ Parameters: nil,
403+ },
404+ }
405+
406+ result, err := toOpenAITools(tools)
407+ if err != nil {
408+ t.Fatalf("toOpenAITools() error: %v", err)
409+ }
410+
411+ if len(result) != 1 {
412+ t.Fatalf("expected 1 tool, got %d", len(result))
413+ }
414+
415+ // Should have default object schema
416+ params, ok := result[0].Function.Parameters.(map[string]interface{})
417+ if !ok {
418+ t.Fatalf("expected Parameters to be map[string]interface{}, got %T", result[0].Function.Parameters)
419+ }
420+ if params["type"] != "object" {
421+ t.Errorf("expected type=object, got %v", params["type"])
422+ }
423+}
424+
425+// TestToOpenAITools_Empty tests empty tool list.
426+func TestToOpenAITools_Empty(t *testing.T) {
427+ tools := []Tool{}
428+
429+ result, err := toOpenAITools(tools)
430+ if err != nil {
431+ t.Fatalf("toOpenAITools() error: %v", err)
432+ }
433+
434+ if len(result) != 0 {
435+ t.Errorf("expected empty result, got %d tools", len(result))
436+ }
437+}
438+
439+// TestToOpenAITools_ComplexSchema tests tools with complex nested schemas.
440+func TestToOpenAITools_ComplexSchema(t *testing.T) {
441+ complexSchema := `{
442+ "type": "object",
443+ "properties": {
444+ "user": {
445+ "type": "object",
446+ "properties": {
447+ "name": {"type": "string"},
448+ "age": {"type": "number"}
449+ },
450+ "required": ["name"]
451+ },
452+ "tags": {
453+ "type": "array",
454+ "items": {"type": "string"}
455+ }
456+ },
457+ "required": ["user"]
458+ }`
459+
460+ tools := []Tool{
461+ {
462+ Name: "create_user",
463+ Description: "Create a new user",
464+ Parameters: json.RawMessage(complexSchema),
465+ },
466+ }
467+
468+ result, err := toOpenAITools(tools)
469+ if err != nil {
470+ t.Fatalf("toOpenAITools() error: %v", err)
471+ }
472+
473+ if len(result) != 1 {
474+ t.Fatalf("expected 1 tool, got %d", len(result))
475+ }
476+
477+ params, ok := result[0].Function.Parameters.(map[string]interface{})
478+ if !ok {
479+ t.Fatalf("expected Parameters to be map[string]interface{}, got %T", result[0].Function.Parameters)
480+ }
481+
482+ // Verify nested structure
483+ props, ok := params["properties"].(map[string]interface{})
484+ if !ok {
485+ t.Fatalf("expected properties to be map, got %T", params["properties"])
486+ }
487+
488+ userProp, ok := props["user"].(map[string]interface{})
489+ if !ok {
490+ t.Fatalf("expected user property to be map, got %T", props["user"])
491+ }
492+
493+ if userProp["type"] != "object" {
494+ t.Errorf("expected user type=object, got %v", userProp["type"])
495+ }
496+
497+ tagsProp, ok := props["tags"].(map[string]interface{})
498+ if !ok {
499+ t.Fatalf("expected tags property to be map, got %T", props["tags"])
500+ }
501+
502+ if tagsProp["type"] != "array" {
503+ t.Errorf("expected tags type=array, got %v", tagsProp["type"])
504+ }
505+}