xonecas.io
6119
My

mysis / files

mysis / internal / provider / ollama_test.go

12.5 KB
1package provider
2
3import (
4	"context"
5	"encoding/json"
6	"net/http"
7	"net/http/httptest"
8	"strings"
9	"testing"
10)
11
12// TestOllama_SystemMessagesAnywhere tests that Ollama provider correctly handles
13// system messages anywhere in the conversation (not just at the start).
14func TestOllama_SystemMessagesAnywhere(t *testing.T) {
15	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
16		var req struct {
17			Messages []struct {
18				Role    string `json:"role"`
19				Content string `json:"content"`
20			} `json:"messages"`
21		}
22		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
23			t.Fatalf("failed to decode request: %v", err)
24		}
25
26		// Verify message order: system, user, system (merged), assistant
27		// Ollama allows system messages anywhere, but consecutive ones should be merged
28		expectedRoles := []string{"system", "user", "system", "assistant"}
29		if len(req.Messages) != len(expectedRoles) {
30			t.Errorf("expected %d messages, got %d", len(expectedRoles), len(req.Messages))
31		}
32
33		for i, expected := range expectedRoles {
34			if i >= len(req.Messages) {
35				break
36			}
37			if req.Messages[i].Role != expected {
38				t.Errorf("message %d: expected role=%s, got %s", i, expected, req.Messages[i].Role)
39			}
40		}
41
42		// Verify first system message
43		if !strings.Contains(req.Messages[0].Content, "helpful assistant") {
44			t.Error("expected first system message to contain 'helpful assistant'")
45		}
46
47		// Verify third message merges two consecutive system messages
48		if !strings.Contains(req.Messages[2].Content, "Be concise") {
49			t.Error("expected merged system message to contain 'Be concise'")
50		}
51		if !strings.Contains(req.Messages[2].Content, "Use simple language") {
52			t.Error("expected merged system message to contain 'Use simple language'")
53		}
54
55		w.Header().Set("Content-Type", "application/json")
56		_ = json.NewEncoder(w).Encode(map[string]interface{}{
57			"choices": []map[string]interface{}{
58				{
59					"message": map[string]interface{}{
60						"role":    "assistant",
61						"content": "Got it!",
62					},
63				},
64			},
65		})
66	}))
67	defer server.Close()
68
69	// Remove /v1 suffix since NewOllama adds it
70	baseURL := strings.TrimSuffix(server.URL, "/v1")
71	provider := NewOllama(baseURL, "test-model")
72	ctx := context.Background()
73
74	// System messages at different positions, including consecutive ones
75	messages := make([]Message, 0, 5)
76	messages = append(messages,
77		Message{Role: "system", Content: "You are a helpful assistant."},
78		Message{Role: "user", Content: "Hello"},
79		Message{Role: "system", Content: "Be concise in your responses."},
80		Message{Role: "system", Content: "Use simple language."},
81		Message{Role: "assistant", Content: "Hi there!"},
82	)
83
84	_, err := provider.Chat(ctx, messages)
85	if err != nil {
86		t.Fatalf("Chat() error: %v", err)
87	}
88}
89
90// TestOllama_ConsecutiveSystemMessagesMerge tests that consecutive system messages
91// are merged in place (Ollama-specific behavior).
92func TestOllama_ConsecutiveSystemMessagesMerge(t *testing.T) {
93	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
94		var req struct {
95			Messages []struct {
96				Role    string `json:"role"`
97				Content string `json:"content"`
98			} `json:"messages"`
99		}
100		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
101			t.Fatalf("failed to decode request: %v", err)
102		}
103
104		// Verify: 3 system messages should be merged into 1
105		systemCount := 0
106		for i, msg := range req.Messages {
107			if msg.Role == "system" {
108				systemCount++
109				// Should be first message
110				if i != 0 {
111					t.Errorf("expected system message at position 0, got %d", i)
112				}
113				// Should contain all three system prompts merged
114				if !strings.Contains(msg.Content, "instruction one") {
115					t.Error("expected merged system to contain 'instruction one'")
116				}
117				if !strings.Contains(msg.Content, "instruction two") {
118					t.Error("expected merged system to contain 'instruction two'")
119				}
120				if !strings.Contains(msg.Content, "instruction three") {
121					t.Error("expected merged system to contain 'instruction three'")
122				}
123			}
124		}
125
126		if systemCount != 1 {
127			t.Errorf("expected 1 system message after merge, got %d", systemCount)
128		}
129
130		// Total messages should be 2 (1 merged system + 1 user)
131		if len(req.Messages) != 2 {
132			t.Errorf("expected 2 messages total, got %d", len(req.Messages))
133		}
134
135		w.Header().Set("Content-Type", "application/json")
136		_ = json.NewEncoder(w).Encode(map[string]interface{}{
137			"choices": []map[string]interface{}{
138				{
139					"message": map[string]interface{}{
140						"role":    "assistant",
141						"content": "Ready.",
142					},
143				},
144			},
145		})
146	}))
147	defer server.Close()
148
149	baseURL := strings.TrimSuffix(server.URL, "/v1")
150	provider := NewOllama(baseURL, "test-model")
151	ctx := context.Background()
152
153	// Three consecutive system messages followed by user message
154	messages := make([]Message, 0, 4)
155	messages = append(messages,
156		Message{Role: "system", Content: "This is instruction one."},
157		Message{Role: "system", Content: "This is instruction two."},
158		Message{Role: "system", Content: "This is instruction three."},
159		Message{Role: "user", Content: "Hello"},
160	)
161
162	_, err := provider.Chat(ctx, messages)
163	if err != nil {
164		t.Fatalf("Chat() error: %v", err)
165	}
166}
167
168// TestOllama_ToolCalls tests that Ollama provider correctly handles
169// messages with tool calls.
170func TestOllama_ToolCalls(t *testing.T) {
171	requestCount := 0
172	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
173		requestCount++
174
175		var req struct {
176			Messages []struct {
177				Role      string `json:"role"`
178				Content   string `json:"content"`
179				ToolCalls []struct {
180					ID       string `json:"id"`
181					Function struct {
182						Name      string `json:"name"`
183						Arguments string `json:"arguments"`
184					} `json:"function"`
185				} `json:"tool_calls,omitempty"`
186				ToolCallID string `json:"tool_call_id,omitempty"`
187			} `json:"messages"`
188			Tools []map[string]interface{} `json:"tools,omitempty"`
189		}
190		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
191			t.Fatalf("failed to decode request: %v", err)
192		}
193
194		w.Header().Set("Content-Type", "application/json")
195
196		// First request: return tool call
197		if requestCount == 1 {
198			// Verify tools are present
199			if len(req.Tools) == 0 {
200				t.Error("expected tools in request")
201			}
202
203			// Verify tool structure matches Ollama format
204			tool := req.Tools[0]
205			if tool["type"] != "function" {
206				t.Errorf("expected tool type=function, got %v", tool["type"])
207			}
208
209			_ = json.NewEncoder(w).Encode(map[string]interface{}{
210				"choices": []map[string]interface{}{
211					{
212						"message": map[string]interface{}{
213							"role":    "assistant",
214							"content": "",
215							"tool_calls": []map[string]interface{}{
216								{
217									"id":   "call_abc",
218									"type": "function",
219									"function": map[string]interface{}{
220										"name":      "calculate",
221										"arguments": `{"operation":"add","a":5,"b":3}`,
222									},
223								},
224							},
225						},
226					},
227				},
228			})
229			return
230		}
231
232		// Second request: verify tool result message
233		if requestCount == 2 {
234			foundToolResult := false
235			for _, msg := range req.Messages {
236				if msg.Role == "tool" && msg.ToolCallID == "call_abc" {
237					foundToolResult = true
238					if msg.Content != "8" {
239						t.Errorf("expected tool result='8', got %q", msg.Content)
240					}
241				}
242			}
243			if !foundToolResult {
244				t.Error("expected tool result message in second request")
245			}
246
247			_ = json.NewEncoder(w).Encode(map[string]interface{}{
248				"choices": []map[string]interface{}{
249					{
250						"message": map[string]interface{}{
251							"role":    "assistant",
252							"content": "The result is 8.",
253						},
254					},
255				},
256			})
257		}
258	}))
259	defer server.Close()
260
261	baseURL := strings.TrimSuffix(server.URL, "/v1")
262	provider := NewOllama(baseURL, "test-model")
263	ctx := context.Background()
264
265	// First call with tools
266	tools := []Tool{
267		{
268			Name:        "calculate",
269			Description: "Perform calculations",
270			Parameters:  json.RawMessage(`{"type":"object","properties":{"operation":{"type":"string"},"a":{"type":"number"},"b":{"type":"number"}}}`),
271		},
272	}
273
274	messages := make([]Message, 0, 1)
275	messages = append(messages, Message{Role: "user", Content: "What is 5 plus 3?"})
276
277	resp1, err := provider.ChatWithTools(ctx, messages, tools)
278	if err != nil {
279		t.Fatalf("ChatWithTools() error: %v", err)
280	}
281
282	// Verify tool call
283	if len(resp1.ToolCalls) != 1 {
284		t.Fatalf("expected 1 tool call, got %d", len(resp1.ToolCalls))
285	}
286	if resp1.ToolCalls[0].Name != "calculate" {
287		t.Errorf("expected tool name=calculate, got %s", resp1.ToolCalls[0].Name)
288	}
289
290	// Second call with tool result
291	messages = append(messages, Message{
292		Role:      "assistant",
293		Content:   "",
294		ToolCalls: resp1.ToolCalls,
295	})
296	messages = append(messages, Message{
297		Role:       "tool",
298		Content:    "8",
299		ToolCallID: "call_abc",
300	})
301
302	resp2, err := provider.ChatWithTools(ctx, messages, tools)
303	if err != nil {
304		t.Fatalf("ChatWithTools() error: %v", err)
305	}
306
307	if !strings.Contains(resp2.Content, "8") {
308		t.Errorf("expected response to contain '8', got %q", resp2.Content)
309	}
310}
311
312// TestOllama_ReasoningField tests that Ollama provider extracts reasoning
313// from both "reasoning" and "reasoning_content" fields (Ollama extension).
314func TestOllama_ReasoningField(t *testing.T) {
315	tests := []struct {
316		name          string
317		responseField string
318		responseValue string
319	}{
320		{
321			name:          "reasoning field",
322			responseField: "reasoning",
323			responseValue: "I need to think about this...",
324		},
325		{
326			name:          "reasoning_content field",
327			responseField: "reasoning_content",
328			responseValue: "Let me analyze this step by step.",
329		},
330	}
331
332	for _, tt := range tests {
333		t.Run(tt.name, func(t *testing.T) {
334			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
335				w.Header().Set("Content-Type", "application/json")
336
337				// Build response with specified reasoning field
338				response := map[string]interface{}{
339					"choices": []map[string]interface{}{
340						{
341							"message": map[string]interface{}{
342								"role":           "assistant",
343								"content":        "Answer",
344								tt.responseField: tt.responseValue,
345							},
346						},
347					},
348				}
349
350				_ = json.NewEncoder(w).Encode(response)
351			}))
352			defer server.Close()
353
354			baseURL := strings.TrimSuffix(server.URL, "/v1")
355			provider := NewOllama(baseURL, "test-model")
356			ctx := context.Background()
357
358			messages := make([]Message, 0, 1)
359			messages = append(messages, Message{Role: "user", Content: "Question?"})
360
361			tools := []Tool{
362				{Name: "dummy", Description: "Dummy tool"},
363			}
364
365			resp, err := provider.ChatWithTools(ctx, messages, tools)
366			if err != nil {
367				t.Fatalf("ChatWithTools() error: %v", err)
368			}
369
370			if resp.Reasoning != tt.responseValue {
371				t.Errorf("expected reasoning=%q, got %q", tt.responseValue, resp.Reasoning)
372			}
373		})
374	}
375}
376
377// TestOllama_SystemMessagesAtEnd tests that system messages at the end
378// are preserved (Ollama allows this, unlike OpenAI).
379func TestOllama_SystemMessagesAtEnd(t *testing.T) {
380	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
381		var req struct {
382			Messages []struct {
383				Role    string `json:"role"`
384				Content string `json:"content"`
385			} `json:"messages"`
386		}
387		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
388			t.Fatalf("failed to decode request: %v", err)
389		}
390
391		// Verify last message is system
392		lastMsg := req.Messages[len(req.Messages)-1]
393		if lastMsg.Role != "system" {
394			t.Errorf("expected last message role=system, got %s", lastMsg.Role)
395		}
396		if !strings.Contains(lastMsg.Content, "final instruction") {
397			t.Error("expected last system message to contain 'final instruction'")
398		}
399
400		w.Header().Set("Content-Type", "application/json")
401		_ = json.NewEncoder(w).Encode(map[string]interface{}{
402			"choices": []map[string]interface{}{
403				{
404					"message": map[string]interface{}{
405						"role":    "assistant",
406						"content": "Understood final instruction.",
407					},
408				},
409			},
410		})
411	}))
412	defer server.Close()
413
414	baseURL := strings.TrimSuffix(server.URL, "/v1")
415	provider := NewOllama(baseURL, "test-model")
416	ctx := context.Background()
417
418	// System message at the end
419	messages := make([]Message, 0, 3)
420	messages = append(messages,
421		Message{Role: "user", Content: "Hello"},
422		Message{Role: "assistant", Content: "Hi!"},
423		Message{Role: "system", Content: "Here's a final instruction."},
424	)
425
426	resp, err := provider.Chat(ctx, messages)
427	if err != nil {
428		t.Fatalf("Chat() error: %v", err)
429	}
430
431	if !strings.Contains(resp, "final instruction") {
432		t.Errorf("expected response to acknowledge final instruction, got %q", resp)
433	}
434}