xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / provider / openai_common.go

5.7 KB
1package provider
2
3import (
4	"encoding/json"
5	"errors"
6	"strings"
7
8	"github.com/rs/zerolog/log"
9	openai "github.com/sashabaranov/go-openai"
10)
11
12// OpenAI-compliant response types for providers that follow OpenAI Chat Completions API spec.
13// These types should NOT include provider-specific extensions.
14
15type openaiChatResponse struct {
16	Choices []openaiChatChoice `json:"choices"`
17}
18
19type openaiChatChoice struct {
20	Message openaiChatMessage `json:"message"`
21}
22
23type openaiChatMessage struct {
24	Role      string               `json:"role"`
25	Content   string               `json:"content"`
26	ToolCalls []openaiChatToolCall `json:"tool_calls,omitempty"`
27}
28
29type openaiChatToolCall struct {
30	ID       string             `json:"id"`
31	Type     string             `json:"type"`
32	Function openaiChatFunction `json:"function"`
33}
34
35type openaiChatFunction struct {
36	Name      string `json:"name"`
37	Arguments string `json:"arguments"`
38}
39
40// toOpenAIMessages converts provider-agnostic messages to OpenAI SDK message format.
41// This function enforces OpenAI Chat Completions API requirements:
42// - System messages must be first
43// - User and assistant messages must alternate (as much as possible)
44// - Tool messages must have tool_call_id and follow assistant messages with tool calls
45func toOpenAIMessages(messages []Message) []openai.ChatCompletionMessage {
46	result := make([]openai.ChatCompletionMessage, len(messages))
47	for i, m := range messages {
48		msg := openai.ChatCompletionMessage{
49			Role:    m.Role,
50			Content: m.Content,
51		}
52
53		// Handle tool call results
54		if m.ToolCallID != "" {
55			msg.ToolCallID = m.ToolCallID
56		}
57
58		// Handle assistant messages with tool calls
59		if len(m.ToolCalls) > 0 {
60			msg.ToolCalls = make([]openai.ToolCall, len(m.ToolCalls))
61			for j, tc := range m.ToolCalls {
62				msg.ToolCalls[j] = openai.ToolCall{
63					ID:   tc.ID,
64					Type: openai.ToolTypeFunction,
65					Function: openai.FunctionCall{
66						Name:      tc.Name,
67						Arguments: string(tc.Arguments),
68					},
69				}
70			}
71		}
72
73		result[i] = msg
74	}
75	return result
76}
77
78// validateOpenAIMessages ensures message structure meets OpenAI API requirements:
79// 1. At least one non-system message exists
80// 2. Conversation ends with user message (if expecting completion)
81// 3. No consecutive assistant messages without user messages between them
82//
83// Returns error if validation fails.
84func validateOpenAIMessages(messages []openai.ChatCompletionMessage) error {
85	if len(messages) == 0 {
86		return errors.New("messages array is empty")
87	}
88
89	// Count message types
90	hasUser := false
91	hasAssistant := false
92	lastRole := ""
93
94	for _, msg := range messages {
95		if msg.Role == "user" {
96			hasUser = true
97		}
98		if msg.Role == "assistant" {
99			hasAssistant = true
100			// Check for consecutive assistant messages
101			if lastRole == "assistant" {
102				log.Warn().Msg("OpenAI: Consecutive assistant messages detected")
103			}
104		}
105		lastRole = msg.Role
106	}
107
108	// If we have assistant messages but no user messages, that's invalid
109	if hasAssistant && !hasUser {
110		return errors.New("conversation has assistant messages but no user messages")
111	}
112
113	// If last message is assistant (and we're expecting a completion), that's invalid
114	if lastRole == "assistant" {
115		log.Warn().Msg("OpenAI: Conversation ends with assistant message - may cause issues")
116	}
117
118	return nil
119}
120
121// mergeSystemMessagesOpenAI merges system messages intelligently while preserving conversation flow.
122//
123// Strategy:
124// 1. Separate initial system messages (before any user/assistant messages)
125// 2. Keep user/assistant conversation intact
126// 3. Merge any mid-conversation system messages into the initial system prompt
127//
128// OpenAI requires:
129// - System messages at the start
130// - At least one non-system message
131// - Proper user/assistant alternation
132func mergeSystemMessagesOpenAI(messages []openai.ChatCompletionMessage) []openai.ChatCompletionMessage {
133	if len(messages) == 0 {
134		return messages
135	}
136
137	// Separate system messages from conversation messages
138	var systemMessages []string
139	var conversationMessages []openai.ChatCompletionMessage
140
141	for _, msg := range messages {
142		if msg.Role == "system" {
143			systemMessages = append(systemMessages, msg.Content)
144		} else {
145			conversationMessages = append(conversationMessages, msg)
146		}
147	}
148
149	// Build result: merged system message + conversation
150	result := make([]openai.ChatCompletionMessage, 0, len(messages))
151
152	// Add merged system message if any system messages exist
153	if len(systemMessages) > 0 {
154		mergedSystem := strings.Join(systemMessages, "\n\n")
155		result = append(result, openai.ChatCompletionMessage{
156			Role:    "system",
157			Content: mergedSystem,
158		})
159	}
160
161	// Add conversation messages
162	result = append(result, conversationMessages...)
163
164	log.Debug().
165		Int("original_count", len(messages)).
166		Int("merged_count", len(result)).
167		Int("system_merged", len(systemMessages)).
168		Int("conversation_kept", len(conversationMessages)).
169		Msg("OpenAI: Merged system messages")
170
171	return result
172}
173
174// toOpenAITools converts provider-agnostic tools to OpenAI SDK tool format.
175// Returns error if any tool has invalid JSON schema.
176func toOpenAITools(tools []Tool) ([]openai.Tool, error) {
177	result := make([]openai.Tool, len(tools))
178	for i, t := range tools {
179		var params map[string]interface{}
180		if len(t.Parameters) > 0 {
181			if err := json.Unmarshal(t.Parameters, &params); err != nil {
182				// Invalid JSON schema - return error instead of silently failing
183				return nil, err
184			}
185		}
186		if params == nil {
187			params = map[string]interface{}{
188				"type":       "object",
189				"properties": map[string]interface{}{},
190			}
191		}
192
193		result[i] = openai.Tool{
194			Type: openai.ToolTypeFunction,
195			Function: &openai.FunctionDefinition{
196				Name:        t.Name,
197				Description: t.Description,
198				Parameters:  params,
199			},
200		}
201	}
202	return result, nil
203}