xonecas.io
6119
My

mysis / files

mysis / internal / provider / opencode.go

11.3 KB
1package provider
2
3import (
4	"bytes"
5	"context"
6	"encoding/json"
7	"errors"
8	"fmt"
9	"io"
10	"net/http"
11	"strings"
12	"time"
13
14	"github.com/rs/zerolog/log"
15	openai "github.com/sashabaranov/go-openai"
16)
17
18// openCodeRequest is a custom request struct to ensure stream:false is serialized
19// The openai.ChatCompletionRequest has omitempty on Stream, which omits false values
20type openCodeRequest struct {
21	Model       string                         `json:"model"`
22	Messages    []openai.ChatCompletionMessage `json:"messages"`
23	Tools       []openai.Tool                  `json:"tools,omitempty"`
24	Temperature float32                        `json:"temperature,omitempty"`
25	Stream      bool                           `json:"stream"` // NO omitempty - always serialize
26}
27
28// OpenCodeProvider implements the Provider interface for OpenCode Zen.
29type OpenCodeProvider struct {
30	name        string
31	client      *openai.Client
32	baseURL     string
33	apiKey      string
34	httpClient  *http.Client
35	model       string
36	temperature float64
37}
38
39var opencodeRetryDelays = []time.Duration{5 * time.Second, 10 * time.Second, 15 * time.Second}
40
41const (
42	opencodeChatCompletionsEndpoint = "/chat/completions"
43	opencodeMessagesEndpoint        = "/messages"
44	opencodeResponsesEndpoint       = "/responses"
45)
46
47var opencodeModelEndpoints = map[string]string{
48	"big-pickle":                 opencodeChatCompletionsEndpoint,
49	"gemini-3-pro":               "/models/gemini-3-pro",
50	"gemini-3-flash":             "/models/gemini-3-flash",
51	"glm-4.7-free":               opencodeChatCompletionsEndpoint,
52	"gpt-5-nano":                 opencodeChatCompletionsEndpoint, // Using chat/completions despite docs saying /responses (500 errors)
53	"kimi-k2.5-free":             opencodeChatCompletionsEndpoint,
54	"minimax-m2.1-free":          opencodeMessagesEndpoint,
55	"trinity-large-preview-free": opencodeChatCompletionsEndpoint,
56}
57
58// NewOpenCode creates a new OpenCode Zen provider.
59func NewOpenCode(endpoint, model, apiKey string) *OpenCodeProvider {
60	return NewOpenCodeWithTemp("opencode_zen", endpoint, model, apiKey, 0.7)
61}
62
63func NewOpenCodeWithTemp(name string, endpoint, model, apiKey string, temperature float64) *OpenCodeProvider {
64	config := openai.DefaultConfig(apiKey)
65	baseURL := strings.TrimRight(endpoint, "/")
66	config.BaseURL = baseURL
67
68	return &OpenCodeProvider{
69		name:        name,
70		client:      openai.NewClientWithConfig(config),
71		baseURL:     baseURL,
72		apiKey:      apiKey,
73		httpClient:  &http.Client{},
74		model:       model,
75		temperature: temperature,
76	}
77}
78
79// Name returns the provider identifier.
80func (p *OpenCodeProvider) Name() string {
81	return p.name
82}
83
84// Chat sends messages and returns the complete response.
85func (p *OpenCodeProvider) Chat(ctx context.Context, messages []Message) (string, error) {
86	resp, err := p.createChatCompletion(ctx, openai.ChatCompletionRequest{
87		Model:       p.model,
88		Messages:    mergeSystemMessagesOpenAI(toOpenAIMessages(messages)),
89		Temperature: float32(p.temperature),
90		Stream:      false,
91	})
92	if err != nil {
93		return "", err
94	}
95
96	if len(resp.Choices) == 0 {
97		return "", errors.New("no response choices")
98	}
99
100	return resp.Choices[0].Message.Content, nil
101}
102
103// ChatWithTools sends messages with available tools and returns response with potential tool calls.
104func (p *OpenCodeProvider) ChatWithTools(ctx context.Context, messages []Message, tools []Tool) (*ChatResponse, error) {
105	// Convert tools to OpenAI format
106	openaiTools, err := toOpenAITools(tools)
107	if err != nil {
108		return nil, fmt.Errorf("invalid tool schema: %w", err)
109	}
110
111	resp, err := p.createChatCompletion(ctx, openai.ChatCompletionRequest{
112		Model:       p.model,
113		Messages:    mergeSystemMessagesOpenAI(toOpenAIMessages(messages)),
114		Tools:       openaiTools,
115		Temperature: float32(p.temperature),
116		Stream:      false,
117	})
118	if err != nil {
119		return nil, err
120	}
121
122	if len(resp.Choices) == 0 {
123		log.Error().
124			Str("provider", p.name).
125			Msg("OpenCode returned empty choices array")
126		return nil, errors.New("no response choices")
127	}
128
129	choice := resp.Choices[0]
130	result := &ChatResponse{
131		Content:   choice.Message.Content,
132		Reasoning: "", // OpenAI standard doesn't provide reasoning field
133	}
134
135	log.Debug().
136		Str("provider", p.name).
137		Str("content", choice.Message.Content).
138		Int("tool_call_count", len(choice.Message.ToolCalls)).
139		Msg("OpenCode ChatWithTools result")
140
141	// Extract tool calls if present
142	if len(choice.Message.ToolCalls) > 0 {
143		result.ToolCalls = make([]ToolCall, len(choice.Message.ToolCalls))
144		for i, tc := range choice.Message.ToolCalls {
145			result.ToolCalls[i] = ToolCall{
146				ID:        tc.ID,
147				Name:      tc.Function.Name,
148				Arguments: json.RawMessage(tc.Function.Arguments),
149			}
150			log.Debug().
151				Str("provider", p.name).
152				Str("tool_call_id", tc.ID).
153				Str("tool_name", tc.Function.Name).
154				Str("arguments", tc.Function.Arguments).
155				Msg("OpenCode tool call extracted")
156		}
157	}
158
159	return result, nil
160}
161
162func (p *OpenCodeProvider) createChatCompletion(ctx context.Context, req openai.ChatCompletionRequest) (*openaiChatResponse, error) {
163	// Use custom struct to ensure stream:false is serialized
164	customReq := openCodeRequest{
165		Model:       req.Model,
166		Messages:    req.Messages,
167		Tools:       req.Tools,
168		Temperature: req.Temperature,
169		Stream:      req.Stream,
170	}
171	body, err := json.Marshal(customReq)
172	if err != nil {
173		return nil, err
174	}
175
176	url := p.baseURL + opencodeEndpointForModel(p.model)
177
178	// Retry logic for transient errors (rate limits, server outages)
179	maxRetries := len(opencodeRetryDelays)
180
181	var lastErr error
182	for attempt := 0; attempt <= maxRetries; attempt++ {
183		if attempt > 0 {
184			delay := opencodeRetryDelays[attempt-1]
185			log.Warn().
186				Str("provider", p.name).
187				Int("attempt", attempt).
188				Dur("delay", delay).
189				Msg("Retrying OpenCode request after transient error")
190
191			select {
192			case <-time.After(delay):
193			case <-ctx.Done():
194				return nil, ctx.Err()
195			}
196		}
197
198		// Log at Info level for first attempt, Debug for retries
199		if attempt == 0 {
200			log.Info().
201				Str("provider", p.name).
202				Str("model", req.Model).
203				Int("message_count", len(req.Messages)).
204				Int("tool_count", len(req.Tools)).
205				Msg("OpenCode request started")
206		}
207
208		log.Debug().
209			Str("provider", p.name).
210			Str("url", url).
211			Str("model", req.Model).
212			Bool("has_api_key", p.apiKey != "").
213			Int("message_count", len(req.Messages)).
214			Int("tool_count", len(req.Tools)).
215			Int("attempt", attempt+1).
216			Str("request_body", string(body)).
217			Msg("OpenCode chat completion request")
218
219		httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
220		if err != nil {
221			return nil, err
222		}
223		httpReq.Header.Set("Content-Type", "application/json")
224		if p.apiKey != "" {
225			httpReq.Header.Set("Authorization", "Bearer "+p.apiKey)
226		}
227
228		resp, err := p.httpClient.Do(httpReq)
229		if err != nil {
230			// Do not retry on context cancellation or timeout
231			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
232				return nil, err
233			}
234			lastErr = err
235			continue // Network error - retry
236		}
237		log.Debug().
238			Str("provider", p.name).
239			Str("url", url).
240			Int("status", resp.StatusCode).
241			Int("attempt", attempt+1).
242			Msg("OpenCode chat completion response")
243
244		// Check for retryable status codes
245		if resp.StatusCode == 429 || resp.StatusCode == 500 || resp.StatusCode == 502 ||
246			resp.StatusCode == 503 || resp.StatusCode == 504 {
247			payload, _ := io.ReadAll(resp.Body)
248			if err := resp.Body.Close(); err != nil {
249				log.Warn().Err(err).Msg("Failed to close response body")
250			}
251			lastErr = fmt.Errorf("chat completion status %d: %s", resp.StatusCode, strings.TrimSpace(string(payload)))
252
253			log.Warn().
254				Str("provider", p.name).
255				Int("status", resp.StatusCode).
256				Int("attempt", attempt+1).
257				Str("body", string(payload)).
258				Msg("OpenCode retryable error")
259
260			continue // Retry on transient server errors and rate limits
261		}
262
263		// Non-retryable client error (4xx except 429)
264		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
265			payload, _ := io.ReadAll(resp.Body)
266			if err := resp.Body.Close(); err != nil {
267				log.Warn().Err(err).Msg("Failed to close response body")
268			}
269			log.Error().
270				Str("provider", p.name).
271				Int("status", resp.StatusCode).
272				Str("body", string(payload)).
273				Msg("OpenCode non-2xx response")
274			return nil, fmt.Errorf("chat completion status %d: %s", resp.StatusCode, strings.TrimSpace(string(payload)))
275		}
276
277		// Success - read and decode body
278		bodyBytes, err := io.ReadAll(resp.Body)
279		if closeErr := resp.Body.Close(); closeErr != nil {
280			log.Warn().Err(closeErr).Msg("Failed to close response body")
281		}
282		if err != nil {
283			log.Error().
284				Str("provider", p.name).
285				Err(err).
286				Msg("OpenCode failed to read response body")
287			return nil, fmt.Errorf("read response body: %w", err)
288		}
289
290		var decoded openaiChatResponse
291		if err := json.Unmarshal(bodyBytes, &decoded); err != nil {
292			log.Error().
293				Str("provider", p.name).
294				Err(err).
295				Str("body", string(bodyBytes)).
296				Msg("OpenCode JSON decode failed")
297			return nil, fmt.Errorf("decode response: %w", err)
298		}
299
300		log.Debug().
301			Str("provider", p.name).
302			Int("choice_count", len(decoded.Choices)).
303			Msg("OpenCode response decoded")
304
305		// Log successful request at Info level for visibility
306		log.Info().
307			Str("provider", p.name).
308			Str("model", p.model).
309			Int("status", resp.StatusCode).
310			Int("attempt", attempt+1).
311			Int("message_count", len(req.Messages)).
312			Int("choice_count", len(decoded.Choices)).
313			Msg("OpenCode request successful")
314
315		return &decoded, nil
316	}
317
318	// All retries exhausted
319	log.Error().
320		Str("provider", p.name).
321		Str("model", p.model).
322		Int("max_retries", maxRetries).
323		Int("total_attempts", maxRetries+1).
324		Err(lastErr).
325		Msg("OpenCode request failed after all retries")
326	return nil, fmt.Errorf("request failed after %d retries: %w", maxRetries, lastErr)
327}
328
329// Stream sends messages and returns a channel that streams response chunks.
330func (p *OpenCodeProvider) Stream(ctx context.Context, messages []Message) (<-chan StreamChunk, error) {
331	if opencodeEndpointForModel(p.model) != opencodeChatCompletionsEndpoint {
332		return nil, fmt.Errorf("opencode model %q does not support streaming via chat completions endpoint", p.model)
333	}
334
335	stream, err := p.client.CreateChatCompletionStream(ctx, openai.ChatCompletionRequest{
336		Model:       p.model,
337		Messages:    mergeSystemMessagesOpenAI(toOpenAIMessages(messages)),
338		Temperature: float32(p.temperature),
339	})
340	if err != nil {
341		return nil, err
342	}
343
344	ch := make(chan StreamChunk)
345	go func() {
346		defer close(ch)
347		defer func() {
348			if err := stream.Close(); err != nil {
349				log.Warn().Err(err).Msg("Failed to close stream")
350			}
351		}()
352
353		for {
354			resp, err := stream.Recv()
355			if errors.Is(err, io.EOF) {
356				ch <- StreamChunk{Done: true}
357				return
358			}
359			if err != nil {
360				ch <- StreamChunk{Err: err}
361				return
362			}
363
364			if len(resp.Choices) > 0 {
365				ch <- StreamChunk{Content: resp.Choices[0].Delta.Content}
366			}
367		}
368	}()
369
370	return ch, nil
371}
372
373func opencodeEndpointForModel(model string) string {
374	if endpoint, ok := opencodeModelEndpoints[model]; ok {
375		return endpoint
376	}
377
378	switch {
379	case strings.HasPrefix(model, "gpt-"):
380		return opencodeResponsesEndpoint
381	case strings.HasPrefix(model, "claude-"):
382		return opencodeMessagesEndpoint
383	default:
384		return opencodeChatCompletionsEndpoint
385	}
386}
387
388// Close closes idle HTTP connections
389func (p *OpenCodeProvider) Close() error {
390	if p.httpClient != nil {
391		p.httpClient.CloseIdleConnections()
392	}
393	return nil
394}