xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / provider / openai_common_test.go

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