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}