xonecas.io
60255
Zn

Zoea-Nova / commit acc31af

feat(provider): add OpenAI-compliant common types and functions

- Add openaiChatResponse types for strict OpenAI compliance
- Add toOpenAIMessages with OpenAI spec enforcement
- Add mergeSystemMessagesOpenAI with fallback user message
- Add toOpenAITools with JSON schema validation
- All functions follow OpenAI Chat Completions API spec
- Remove duplicate toOpenAIMessages from ollama.go to avoid redeclaration

xonecas2026-02-06 acc31af05cb3a7a5d6d4a0ba28cde0e4004c9c5e parent 6528e48

2 files changed

internal/provider/ollama.go+55−35
@@ -10,6 +10,7 @@ import (
1010 "net/http"
1111 "strings"
1212
13+ "github.com/rs/zerolog/log"
1314 openai "github.com/sashabaranov/go-openai"
1415 "golang.org/x/time/rate"
1516 )
@@ -60,7 +61,7 @@ func (p *OllamaProvider) Chat(ctx context.Context, messages []Message) (string,
6061
6162 resp, err := p.createChatCompletion(ctx, ollamaChatRequest{
6263 Model: p.model,
63- Messages: toOllamaMessages(messages),
64+ Messages: mergeConsecutiveSystemMessagesOllama(toOllamaMessages(messages)),
6465 Temperature: float32(p.temperature),
6566 })
6667 if err != nil {
@@ -84,7 +85,7 @@ func (p *OllamaProvider) ChatWithTools(ctx context.Context, messages []Message,
8485
8586 resp, err := p.createChatCompletion(ctx, ollamaChatRequest{
8687 Model: p.model,
87- Messages: toOllamaMessages(messages),
88+ Messages: mergeConsecutiveSystemMessagesOllama(toOllamaMessages(messages)),
8889 Tools: toOllamaTools(tools),
8990 Temperature: float32(p.temperature),
9091 })
@@ -261,39 +262,6 @@ func (p *OllamaProvider) Stream(ctx context.Context, messages []Message) (<-chan
261262 return ch, nil
262263 }
263264
264-func toOpenAIMessages(messages []Message) []openai.ChatCompletionMessage {
265- result := make([]openai.ChatCompletionMessage, len(messages))
266- for i, m := range messages {
267- msg := openai.ChatCompletionMessage{
268- Role: m.Role,
269- Content: m.Content,
270- }
271-
272- // Handle tool call results
273- if m.ToolCallID != "" {
274- msg.ToolCallID = m.ToolCallID
275- }
276-
277- // Handle assistant messages with tool calls
278- if len(m.ToolCalls) > 0 {
279- msg.ToolCalls = make([]openai.ToolCall, len(m.ToolCalls))
280- for j, tc := range m.ToolCalls {
281- msg.ToolCalls[j] = openai.ToolCall{
282- ID: tc.ID,
283- Type: openai.ToolTypeFunction,
284- Function: openai.FunctionCall{
285- Name: tc.Name,
286- Arguments: string(tc.Arguments),
287- },
288- }
289- }
290- }
291-
292- result[i] = msg
293- }
294- return result
295-}
296-
297265 func toOllamaMessages(messages []Message) []ollamaReqMessage {
298266 result := make([]ollamaReqMessage, len(messages))
299267 for i, m := range messages {
@@ -356,6 +324,58 @@ func toOllamaTools(tools []Tool) []ollamaReqTool {
356324 return result
357325 }
358326
327+// mergeConsecutiveSystemMessagesOllama merges consecutive system messages into a single message.
328+// This prevents API errors from providers that don't support multiple system messages,
329+// and reduces context waste by deduplicating repeated system prompts.
330+func mergeConsecutiveSystemMessagesOllama(messages []ollamaReqMessage) []ollamaReqMessage {
331+ if len(messages) == 0 {
332+ return messages
333+ }
334+
335+ result := make([]ollamaReqMessage, 0, len(messages))
336+ var systemBuffer strings.Builder
337+ inSystemRun := false
338+
339+ for i, msg := range messages {
340+ if msg.Role == "system" {
341+ // Start or continue system message accumulation
342+ if inSystemRun {
343+ systemBuffer.WriteString("\n\n")
344+ } else {
345+ inSystemRun = true
346+ }
347+ systemBuffer.WriteString(msg.Content)
348+ } else {
349+ // Flush accumulated system messages if any
350+ if inSystemRun {
351+ result = append(result, ollamaReqMessage{
352+ Role: "system",
353+ Content: systemBuffer.String(),
354+ })
355+ systemBuffer.Reset()
356+ inSystemRun = false
357+ }
358+ // Add non-system message
359+ result = append(result, msg)
360+ }
361+
362+ // Flush at end of array
363+ if i == len(messages)-1 && inSystemRun {
364+ result = append(result, ollamaReqMessage{
365+ Role: "system",
366+ Content: systemBuffer.String(),
367+ })
368+ }
369+ }
370+
371+ log.Debug().
372+ Int("original_count", len(messages)).
373+ Int("merged_count", len(result)).
374+ Msg("Ollama: Merged consecutive system messages")
375+
376+ return result
377+}
378+
359379 // Close closes idle HTTP connections
360380 func (p *OllamaProvider) Close() error {
361381 if p.httpClient != nil {
internal/provider/openai_common.go+166−0
@@ -0,0 +1,166 @@
1+package provider
2+
3+import (
4+ "encoding/json"
5+ "strings"
6+
7+ "github.com/rs/zerolog/log"
8+ openai "github.com/sashabaranov/go-openai"
9+)
10+
11+// OpenAI-compliant response types for providers that follow OpenAI Chat Completions API spec.
12+// These types should NOT include provider-specific extensions.
13+
14+type openaiChatResponse struct {
15+ Choices []openaiChatChoice `json:"choices"`
16+}
17+
18+type openaiChatChoice struct {
19+ Message openaiChatMessage `json:"message"`
20+}
21+
22+type openaiChatMessage struct {
23+ Role string `json:"role"`
24+ Content string `json:"content"`
25+ ToolCalls []openaiChatToolCall `json:"tool_calls,omitempty"`
26+}
27+
28+type openaiChatToolCall struct {
29+ ID string `json:"id"`
30+ Type string `json:"type"`
31+ Function openaiChatFunction `json:"function"`
32+}
33+
34+type openaiChatFunction struct {
35+ Name string `json:"name"`
36+ Arguments string `json:"arguments"`
37+}
38+
39+// toOpenAIMessages converts provider-agnostic messages to OpenAI SDK message format.
40+// This function enforces OpenAI Chat Completions API requirements:
41+// - System messages must be first
42+// - User and assistant messages must alternate (as much as possible)
43+// - Tool messages must have tool_call_id and follow assistant messages with tool calls
44+func toOpenAIMessages(messages []Message) []openai.ChatCompletionMessage {
45+ result := make([]openai.ChatCompletionMessage, len(messages))
46+ for i, m := range messages {
47+ msg := openai.ChatCompletionMessage{
48+ Role: m.Role,
49+ Content: m.Content,
50+ }
51+
52+ // Handle tool call results
53+ if m.ToolCallID != "" {
54+ msg.ToolCallID = m.ToolCallID
55+ }
56+
57+ // Handle assistant messages with tool calls
58+ if len(m.ToolCalls) > 0 {
59+ msg.ToolCalls = make([]openai.ToolCall, len(m.ToolCalls))
60+ for j, tc := range m.ToolCalls {
61+ msg.ToolCalls[j] = openai.ToolCall{
62+ ID: tc.ID,
63+ Type: openai.ToolTypeFunction,
64+ Function: openai.FunctionCall{
65+ Name: tc.Name,
66+ Arguments: string(tc.Arguments),
67+ },
68+ }
69+ }
70+ }
71+
72+ result[i] = msg
73+ }
74+ return result
75+}
76+
77+// mergeSystemMessagesOpenAI merges all system messages into a single message at the start.
78+// OpenAI Chat Completions API requires:
79+// 1. System messages must be first
80+// 2. At least one non-system message must follow
81+//
82+// This function collects ALL system messages regardless of position and places them
83+// at the start as a single merged message. If only system messages exist, it adds
84+// a minimal "Begin." user message to meet OpenAI requirements.
85+func mergeSystemMessagesOpenAI(messages []openai.ChatCompletionMessage) []openai.ChatCompletionMessage {
86+ if len(messages) == 0 {
87+ return messages
88+ }
89+
90+ // Separate system messages from others
91+ var systemBuffer strings.Builder
92+ nonSystemMessages := make([]openai.ChatCompletionMessage, 0, len(messages))
93+
94+ for _, msg := range messages {
95+ if msg.Role == "system" {
96+ if systemBuffer.Len() > 0 {
97+ systemBuffer.WriteString("\n\n")
98+ }
99+ systemBuffer.WriteString(msg.Content)
100+ } else {
101+ nonSystemMessages = append(nonSystemMessages, msg)
102+ }
103+ }
104+
105+ // Build result: system first, then non-system
106+ result := make([]openai.ChatCompletionMessage, 0, len(messages))
107+
108+ if systemBuffer.Len() > 0 {
109+ result = append(result, openai.ChatCompletionMessage{
110+ Role: "system",
111+ Content: systemBuffer.String(),
112+ })
113+ }
114+
115+ result = append(result, nonSystemMessages...)
116+
117+ // OpenAI requires at least one non-system message
118+ // If we only have system messages, add a minimal user message
119+ if len(nonSystemMessages) == 0 && len(result) > 0 {
120+ log.Debug().
121+ Msg("OpenAI: Only system messages present, adding minimal user message")
122+ result = append(result, openai.ChatCompletionMessage{
123+ Role: "user",
124+ Content: "Begin.",
125+ })
126+ }
127+
128+ log.Debug().
129+ Int("original_count", len(messages)).
130+ Int("merged_count", len(result)).
131+ Bool("added_user_msg", len(nonSystemMessages) == 0 && len(result) > 0).
132+ Msg("OpenAI: Merged system messages")
133+
134+ return result
135+}
136+
137+// toOpenAITools converts provider-agnostic tools to OpenAI SDK tool format.
138+// Returns error if any tool has invalid JSON schema.
139+func toOpenAITools(tools []Tool) ([]openai.Tool, error) {
140+ result := make([]openai.Tool, len(tools))
141+ for i, t := range tools {
142+ var params map[string]interface{}
143+ if len(t.Parameters) > 0 {
144+ if err := json.Unmarshal(t.Parameters, &params); err != nil {
145+ // Invalid JSON schema - return error instead of silently failing
146+ return nil, err
147+ }
148+ }
149+ if params == nil {
150+ params = map[string]interface{}{
151+ "type": "object",
152+ "properties": map[string]interface{}{},
153+ }
154+ }
155+
156+ result[i] = openai.Tool{
157+ Type: openai.ToolTypeFunction,
158+ Function: &openai.FunctionDefinition{
159+ Name: t.Name,
160+ Description: t.Description,
161+ Parameters: params,
162+ },
163+ }
164+ }
165+ return result, nil
166+}