@@ -0,0 +1,433 @@
1+package provider
2+
3+import (
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).
14+func 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 := []Message{
76+ {Role: "system", Content: "You are a helpful assistant."},
77+ {Role: "user", Content: "Hello"},
78+ {Role: "system", Content: "Be concise in your responses."},
79+ {Role: "system", Content: "Use simple language."},
80+ {Role: "assistant", Content: "Hi there!"},
81+ }
82+
83+ _, err := provider.Chat(ctx, messages)
84+ if err != nil {
85+ t.Fatalf("Chat() error: %v", err)
86+ }
87+}
88+
89+// TestOllama_ConsecutiveSystemMessagesMerge tests that consecutive system messages
90+// are merged in place (Ollama-specific behavior).
91+func TestOllama_ConsecutiveSystemMessagesMerge(t *testing.T) {
92+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
93+ var req struct {
94+ Messages []struct {
95+ Role string `json:"role"`
96+ Content string `json:"content"`
97+ } `json:"messages"`
98+ }
99+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
100+ t.Fatalf("failed to decode request: %v", err)
101+ }
102+
103+ // Verify: 3 system messages should be merged into 1
104+ systemCount := 0
105+ for i, msg := range req.Messages {
106+ if msg.Role == "system" {
107+ systemCount++
108+ // Should be first message
109+ if i != 0 {
110+ t.Errorf("expected system message at position 0, got %d", i)
111+ }
112+ // Should contain all three system prompts merged
113+ if !strings.Contains(msg.Content, "instruction one") {
114+ t.Error("expected merged system to contain 'instruction one'")
115+ }
116+ if !strings.Contains(msg.Content, "instruction two") {
117+ t.Error("expected merged system to contain 'instruction two'")
118+ }
119+ if !strings.Contains(msg.Content, "instruction three") {
120+ t.Error("expected merged system to contain 'instruction three'")
121+ }
122+ }
123+ }
124+
125+ if systemCount != 1 {
126+ t.Errorf("expected 1 system message after merge, got %d", systemCount)
127+ }
128+
129+ // Total messages should be 2 (1 merged system + 1 user)
130+ if len(req.Messages) != 2 {
131+ t.Errorf("expected 2 messages total, got %d", len(req.Messages))
132+ }
133+
134+ w.Header().Set("Content-Type", "application/json")
135+ json.NewEncoder(w).Encode(map[string]interface{}{
136+ "choices": []map[string]interface{}{
137+ {
138+ "message": map[string]interface{}{
139+ "role": "assistant",
140+ "content": "Ready.",
141+ },
142+ },
143+ },
144+ })
145+ }))
146+ defer server.Close()
147+
148+ baseURL := strings.TrimSuffix(server.URL, "/v1")
149+ provider := NewOllama(baseURL, "test-model")
150+ ctx := context.Background()
151+
152+ // Three consecutive system messages followed by user message
153+ messages := []Message{
154+ {Role: "system", Content: "This is instruction one."},
155+ {Role: "system", Content: "This is instruction two."},
156+ {Role: "system", Content: "This is instruction three."},
157+ {Role: "user", Content: "Hello"},
158+ }
159+
160+ _, err := provider.Chat(ctx, messages)
161+ if err != nil {
162+ t.Fatalf("Chat() error: %v", err)
163+ }
164+}
165+
166+// TestOllama_ToolCalls tests that Ollama provider correctly handles
167+// messages with tool calls.
168+func TestOllama_ToolCalls(t *testing.T) {
169+ requestCount := 0
170+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
171+ requestCount++
172+
173+ var req struct {
174+ Messages []struct {
175+ Role string `json:"role"`
176+ Content string `json:"content"`
177+ ToolCalls []struct {
178+ ID string `json:"id"`
179+ Function struct {
180+ Name string `json:"name"`
181+ Arguments string `json:"arguments"`
182+ } `json:"function"`
183+ } `json:"tool_calls,omitempty"`
184+ ToolCallID string `json:"tool_call_id,omitempty"`
185+ } `json:"messages"`
186+ Tools []map[string]interface{} `json:"tools,omitempty"`
187+ }
188+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
189+ t.Fatalf("failed to decode request: %v", err)
190+ }
191+
192+ w.Header().Set("Content-Type", "application/json")
193+
194+ // First request: return tool call
195+ if requestCount == 1 {
196+ // Verify tools are present
197+ if len(req.Tools) == 0 {
198+ t.Error("expected tools in request")
199+ }
200+
201+ // Verify tool structure matches Ollama format
202+ tool := req.Tools[0]
203+ if tool["type"] != "function" {
204+ t.Errorf("expected tool type=function, got %v", tool["type"])
205+ }
206+
207+ json.NewEncoder(w).Encode(map[string]interface{}{
208+ "choices": []map[string]interface{}{
209+ {
210+ "message": map[string]interface{}{
211+ "role": "assistant",
212+ "content": "",
213+ "tool_calls": []map[string]interface{}{
214+ {
215+ "id": "call_abc",
216+ "type": "function",
217+ "function": map[string]interface{}{
218+ "name": "calculate",
219+ "arguments": `{"operation":"add","a":5,"b":3}`,
220+ },
221+ },
222+ },
223+ },
224+ },
225+ },
226+ })
227+ return
228+ }
229+
230+ // Second request: verify tool result message
231+ if requestCount == 2 {
232+ foundToolResult := false
233+ for _, msg := range req.Messages {
234+ if msg.Role == "tool" && msg.ToolCallID == "call_abc" {
235+ foundToolResult = true
236+ if msg.Content != "8" {
237+ t.Errorf("expected tool result='8', got %q", msg.Content)
238+ }
239+ }
240+ }
241+ if !foundToolResult {
242+ t.Error("expected tool result message in second request")
243+ }
244+
245+ json.NewEncoder(w).Encode(map[string]interface{}{
246+ "choices": []map[string]interface{}{
247+ {
248+ "message": map[string]interface{}{
249+ "role": "assistant",
250+ "content": "The result is 8.",
251+ },
252+ },
253+ },
254+ })
255+ }
256+ }))
257+ defer server.Close()
258+
259+ baseURL := strings.TrimSuffix(server.URL, "/v1")
260+ provider := NewOllama(baseURL, "test-model")
261+ ctx := context.Background()
262+
263+ // First call with tools
264+ tools := []Tool{
265+ {
266+ Name: "calculate",
267+ Description: "Perform calculations",
268+ Parameters: json.RawMessage(`{"type":"object","properties":{"operation":{"type":"string"},"a":{"type":"number"},"b":{"type":"number"}}}`),
269+ },
270+ }
271+
272+ messages := []Message{
273+ {Role: "user", Content: "What is 5 plus 3?"},
274+ }
275+
276+ resp1, err := provider.ChatWithTools(ctx, messages, tools)
277+ if err != nil {
278+ t.Fatalf("ChatWithTools() error: %v", err)
279+ }
280+
281+ // Verify tool call
282+ if len(resp1.ToolCalls) != 1 {
283+ t.Fatalf("expected 1 tool call, got %d", len(resp1.ToolCalls))
284+ }
285+ if resp1.ToolCalls[0].Name != "calculate" {
286+ t.Errorf("expected tool name=calculate, got %s", resp1.ToolCalls[0].Name)
287+ }
288+
289+ // Second call with tool result
290+ messages = append(messages, Message{
291+ Role: "assistant",
292+ Content: "",
293+ ToolCalls: resp1.ToolCalls,
294+ })
295+ messages = append(messages, Message{
296+ Role: "tool",
297+ Content: "8",
298+ ToolCallID: "call_abc",
299+ })
300+
301+ resp2, err := provider.ChatWithTools(ctx, messages, tools)
302+ if err != nil {
303+ t.Fatalf("ChatWithTools() error: %v", err)
304+ }
305+
306+ if !strings.Contains(resp2.Content, "8") {
307+ t.Errorf("expected response to contain '8', got %q", resp2.Content)
308+ }
309+}
310+
311+// TestOllama_ReasoningField tests that Ollama provider extracts reasoning
312+// from both "reasoning" and "reasoning_content" fields (Ollama extension).
313+func TestOllama_ReasoningField(t *testing.T) {
314+ tests := []struct {
315+ name string
316+ responseField string
317+ responseValue string
318+ }{
319+ {
320+ name: "reasoning field",
321+ responseField: "reasoning",
322+ responseValue: "I need to think about this...",
323+ },
324+ {
325+ name: "reasoning_content field",
326+ responseField: "reasoning_content",
327+ responseValue: "Let me analyze this step by step.",
328+ },
329+ }
330+
331+ for _, tt := range tests {
332+ t.Run(tt.name, func(t *testing.T) {
333+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
334+ w.Header().Set("Content-Type", "application/json")
335+
336+ // Build response with specified reasoning field
337+ response := map[string]interface{}{
338+ "choices": []map[string]interface{}{
339+ {
340+ "message": map[string]interface{}{
341+ "role": "assistant",
342+ "content": "Answer",
343+ tt.responseField: tt.responseValue,
344+ },
345+ },
346+ },
347+ }
348+
349+ json.NewEncoder(w).Encode(response)
350+ }))
351+ defer server.Close()
352+
353+ baseURL := strings.TrimSuffix(server.URL, "/v1")
354+ provider := NewOllama(baseURL, "test-model")
355+ ctx := context.Background()
356+
357+ messages := []Message{
358+ {Role: "user", Content: "Question?"},
359+ }
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).
379+func 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 := []Message{
420+ {Role: "user", Content: "Hello"},
421+ {Role: "assistant", Content: "Hi!"},
422+ {Role: "system", Content: "Here's a final instruction."},
423+ }
424+
425+ resp, err := provider.Chat(ctx, messages)
426+ if err != nil {
427+ t.Fatalf("Chat() error: %v", err)
428+ }
429+
430+ if !strings.Contains(resp, "final instruction") {
431+ t.Errorf("expected response to acknowledge final instruction, got %q", resp)
432+ }
433+}