1package provider
2
3import (
4 "context"
5 "encoding/json"
6 "errors"
7 "fmt"
8 "io"
9 "time"
10
11 "github.com/charmbracelet/crush/internal/config"
12 "github.com/charmbracelet/crush/internal/fur/provider"
13 "github.com/charmbracelet/crush/internal/llm/tools"
14 "github.com/charmbracelet/crush/internal/logging"
15 "github.com/charmbracelet/crush/internal/message"
16 "github.com/openai/openai-go"
17 "github.com/openai/openai-go/option"
18 "github.com/openai/openai-go/shared"
19)
20
21type openaiClient struct {
22 providerOptions providerClientOptions
23 client openai.Client
24}
25
26type OpenAIClient ProviderClient
27
28func newOpenAIClient(opts providerClientOptions) OpenAIClient {
29 openaiClientOptions := []option.RequestOption{}
30 if opts.apiKey != "" {
31 openaiClientOptions = append(openaiClientOptions, option.WithAPIKey(opts.apiKey))
32 }
33 if opts.baseURL != "" {
34 openaiClientOptions = append(openaiClientOptions, option.WithBaseURL(opts.baseURL))
35 }
36
37 if opts.extraHeaders != nil {
38 for key, value := range opts.extraHeaders {
39 openaiClientOptions = append(openaiClientOptions, option.WithHeader(key, value))
40 }
41 }
42
43 client := openai.NewClient(openaiClientOptions...)
44 return &openaiClient{
45 providerOptions: opts,
46 client: client,
47 }
48}
49
50func (o *openaiClient) convertMessages(messages []message.Message) (openaiMessages []openai.ChatCompletionMessageParamUnion) {
51 // Add system message first
52 openaiMessages = append(openaiMessages, openai.SystemMessage(o.providerOptions.systemMessage))
53
54 for _, msg := range messages {
55 switch msg.Role {
56 case message.User:
57 var content []openai.ChatCompletionContentPartUnionParam
58 textBlock := openai.ChatCompletionContentPartTextParam{Text: msg.Content().String()}
59 content = append(content, openai.ChatCompletionContentPartUnionParam{OfText: &textBlock})
60 for _, binaryContent := range msg.BinaryContent() {
61 imageURL := openai.ChatCompletionContentPartImageImageURLParam{URL: binaryContent.String(provider.InferenceProviderOpenAI)}
62 imageBlock := openai.ChatCompletionContentPartImageParam{ImageURL: imageURL}
63
64 content = append(content, openai.ChatCompletionContentPartUnionParam{OfImageURL: &imageBlock})
65 }
66
67 openaiMessages = append(openaiMessages, openai.UserMessage(content))
68
69 case message.Assistant:
70 assistantMsg := openai.ChatCompletionAssistantMessageParam{
71 Role: "assistant",
72 }
73
74 if msg.Content().String() != "" {
75 assistantMsg.Content = openai.ChatCompletionAssistantMessageParamContentUnion{
76 OfString: openai.String(msg.Content().String()),
77 }
78 }
79
80 if len(msg.ToolCalls()) > 0 {
81 assistantMsg.ToolCalls = make([]openai.ChatCompletionMessageToolCallParam, len(msg.ToolCalls()))
82 for i, call := range msg.ToolCalls() {
83 assistantMsg.ToolCalls[i] = openai.ChatCompletionMessageToolCallParam{
84 ID: call.ID,
85 Type: "function",
86 Function: openai.ChatCompletionMessageToolCallFunctionParam{
87 Name: call.Name,
88 Arguments: call.Input,
89 },
90 }
91 }
92 }
93
94 openaiMessages = append(openaiMessages, openai.ChatCompletionMessageParamUnion{
95 OfAssistant: &assistantMsg,
96 })
97
98 case message.Tool:
99 for _, result := range msg.ToolResults() {
100 openaiMessages = append(openaiMessages,
101 openai.ToolMessage(result.Content, result.ToolCallID),
102 )
103 }
104 }
105 }
106
107 return
108}
109
110func (o *openaiClient) convertTools(tools []tools.BaseTool) []openai.ChatCompletionToolParam {
111 openaiTools := make([]openai.ChatCompletionToolParam, len(tools))
112
113 for i, tool := range tools {
114 info := tool.Info()
115 openaiTools[i] = openai.ChatCompletionToolParam{
116 Function: openai.FunctionDefinitionParam{
117 Name: info.Name,
118 Description: openai.String(info.Description),
119 Parameters: openai.FunctionParameters{
120 "type": "object",
121 "properties": info.Parameters,
122 "required": info.Required,
123 },
124 },
125 }
126 }
127
128 return openaiTools
129}
130
131func (o *openaiClient) finishReason(reason string) message.FinishReason {
132 switch reason {
133 case "stop":
134 return message.FinishReasonEndTurn
135 case "length":
136 return message.FinishReasonMaxTokens
137 case "tool_calls":
138 return message.FinishReasonToolUse
139 default:
140 return message.FinishReasonUnknown
141 }
142}
143
144func (o *openaiClient) preparedParams(messages []openai.ChatCompletionMessageParamUnion, tools []openai.ChatCompletionToolParam) openai.ChatCompletionNewParams {
145 model := o.providerOptions.model(o.providerOptions.modelType)
146 cfg := config.Get()
147
148 modelConfig := cfg.Models.Large
149 if o.providerOptions.modelType == config.SmallModel {
150 modelConfig = cfg.Models.Small
151 }
152
153 reasoningEffort := model.ReasoningEffort
154 if modelConfig.ReasoningEffort != "" {
155 reasoningEffort = modelConfig.ReasoningEffort
156 }
157
158 params := openai.ChatCompletionNewParams{
159 Model: openai.ChatModel(model.ID),
160 Messages: messages,
161 Tools: tools,
162 }
163 if model.CanReason {
164 params.MaxCompletionTokens = openai.Int(o.providerOptions.maxTokens)
165 switch reasoningEffort {
166 case "low":
167 params.ReasoningEffort = shared.ReasoningEffortLow
168 case "medium":
169 params.ReasoningEffort = shared.ReasoningEffortMedium
170 case "high":
171 params.ReasoningEffort = shared.ReasoningEffortHigh
172 default:
173 params.ReasoningEffort = shared.ReasoningEffortMedium
174 }
175 } else {
176 params.MaxTokens = openai.Int(o.providerOptions.maxTokens)
177 }
178
179 return params
180}
181
182func (o *openaiClient) send(ctx context.Context, messages []message.Message, tools []tools.BaseTool) (response *ProviderResponse, err error) {
183 params := o.preparedParams(o.convertMessages(messages), o.convertTools(tools))
184 cfg := config.Get()
185 if cfg.Options.Debug {
186 jsonData, _ := json.Marshal(params)
187 logging.Debug("Prepared messages", "messages", string(jsonData))
188 }
189 attempts := 0
190 for {
191 attempts++
192 openaiResponse, err := o.client.Chat.Completions.New(
193 ctx,
194 params,
195 )
196 // If there is an error we are going to see if we can retry the call
197 if err != nil {
198 retry, after, retryErr := o.shouldRetry(attempts, err)
199 if retryErr != nil {
200 return nil, retryErr
201 }
202 if retry {
203 logging.WarnPersist(fmt.Sprintf("Retrying due to rate limit... attempt %d of %d", attempts, maxRetries), logging.PersistTimeArg, time.Millisecond*time.Duration(after+100))
204 select {
205 case <-ctx.Done():
206 return nil, ctx.Err()
207 case <-time.After(time.Duration(after) * time.Millisecond):
208 continue
209 }
210 }
211 return nil, retryErr
212 }
213
214 content := ""
215 if openaiResponse.Choices[0].Message.Content != "" {
216 content = openaiResponse.Choices[0].Message.Content
217 }
218
219 toolCalls := o.toolCalls(*openaiResponse)
220 finishReason := o.finishReason(string(openaiResponse.Choices[0].FinishReason))
221
222 if len(toolCalls) > 0 {
223 finishReason = message.FinishReasonToolUse
224 }
225
226 return &ProviderResponse{
227 Content: content,
228 ToolCalls: toolCalls,
229 Usage: o.usage(*openaiResponse),
230 FinishReason: finishReason,
231 }, nil
232 }
233}
234
235func (o *openaiClient) stream(ctx context.Context, messages []message.Message, tools []tools.BaseTool) <-chan ProviderEvent {
236 params := o.preparedParams(o.convertMessages(messages), o.convertTools(tools))
237 params.StreamOptions = openai.ChatCompletionStreamOptionsParam{
238 IncludeUsage: openai.Bool(true),
239 }
240
241 cfg := config.Get()
242 if cfg.Options.Debug {
243 jsonData, _ := json.Marshal(params)
244 logging.Debug("Prepared messages", "messages", string(jsonData))
245 }
246
247 attempts := 0
248 eventChan := make(chan ProviderEvent)
249
250 go func() {
251 for {
252 attempts++
253 openaiStream := o.client.Chat.Completions.NewStreaming(
254 ctx,
255 params,
256 )
257
258 acc := openai.ChatCompletionAccumulator{}
259 currentContent := ""
260 toolCalls := make([]message.ToolCall, 0)
261
262 for openaiStream.Next() {
263 chunk := openaiStream.Current()
264 acc.AddChunk(chunk)
265
266 for _, choice := range chunk.Choices {
267 if choice.Delta.Content != "" {
268 eventChan <- ProviderEvent{
269 Type: EventContentDelta,
270 Content: choice.Delta.Content,
271 }
272 currentContent += choice.Delta.Content
273 }
274 }
275 }
276
277 err := openaiStream.Err()
278 if err == nil || errors.Is(err, io.EOF) {
279 // Stream completed successfully
280 finishReason := o.finishReason(string(acc.ChatCompletion.Choices[0].FinishReason))
281 if len(acc.Choices[0].Message.ToolCalls) > 0 {
282 toolCalls = append(toolCalls, o.toolCalls(acc.ChatCompletion)...)
283 }
284 if len(toolCalls) > 0 {
285 finishReason = message.FinishReasonToolUse
286 }
287
288 eventChan <- ProviderEvent{
289 Type: EventComplete,
290 Response: &ProviderResponse{
291 Content: currentContent,
292 ToolCalls: toolCalls,
293 Usage: o.usage(acc.ChatCompletion),
294 FinishReason: finishReason,
295 },
296 }
297 close(eventChan)
298 return
299 }
300
301 // If there is an error we are going to see if we can retry the call
302 retry, after, retryErr := o.shouldRetry(attempts, err)
303 if retryErr != nil {
304 eventChan <- ProviderEvent{Type: EventError, Error: retryErr}
305 close(eventChan)
306 return
307 }
308 if retry {
309 logging.WarnPersist(fmt.Sprintf("Retrying due to rate limit... attempt %d of %d", attempts, maxRetries), logging.PersistTimeArg, time.Millisecond*time.Duration(after+100))
310 select {
311 case <-ctx.Done():
312 // context cancelled
313 if ctx.Err() == nil {
314 eventChan <- ProviderEvent{Type: EventError, Error: ctx.Err()}
315 }
316 close(eventChan)
317 return
318 case <-time.After(time.Duration(after) * time.Millisecond):
319 continue
320 }
321 }
322 eventChan <- ProviderEvent{Type: EventError, Error: retryErr}
323 close(eventChan)
324 return
325 }
326 }()
327
328 return eventChan
329}
330
331func (o *openaiClient) shouldRetry(attempts int, err error) (bool, int64, error) {
332 var apierr *openai.Error
333 if !errors.As(err, &apierr) {
334 return false, 0, err
335 }
336
337 if apierr.StatusCode != 429 && apierr.StatusCode != 500 {
338 return false, 0, err
339 }
340
341 if attempts > maxRetries {
342 return false, 0, fmt.Errorf("maximum retry attempts reached for rate limit: %d retries", maxRetries)
343 }
344
345 retryMs := 0
346 retryAfterValues := apierr.Response.Header.Values("Retry-After")
347
348 backoffMs := 2000 * (1 << (attempts - 1))
349 jitterMs := int(float64(backoffMs) * 0.2)
350 retryMs = backoffMs + jitterMs
351 if len(retryAfterValues) > 0 {
352 if _, err := fmt.Sscanf(retryAfterValues[0], "%d", &retryMs); err == nil {
353 retryMs = retryMs * 1000
354 }
355 }
356 return true, int64(retryMs), nil
357}
358
359func (o *openaiClient) toolCalls(completion openai.ChatCompletion) []message.ToolCall {
360 var toolCalls []message.ToolCall
361
362 if len(completion.Choices) > 0 && len(completion.Choices[0].Message.ToolCalls) > 0 {
363 for _, call := range completion.Choices[0].Message.ToolCalls {
364 toolCall := message.ToolCall{
365 ID: call.ID,
366 Name: call.Function.Name,
367 Input: call.Function.Arguments,
368 Type: "function",
369 Finished: true,
370 }
371 toolCalls = append(toolCalls, toolCall)
372 }
373 }
374
375 return toolCalls
376}
377
378func (o *openaiClient) usage(completion openai.ChatCompletion) TokenUsage {
379 cachedTokens := completion.Usage.PromptTokensDetails.CachedTokens
380 inputTokens := completion.Usage.PromptTokens - cachedTokens
381
382 return TokenUsage{
383 InputTokens: inputTokens,
384 OutputTokens: completion.Usage.CompletionTokens,
385 CacheCreationTokens: 0, // OpenAI doesn't provide this directly
386 CacheReadTokens: cachedTokens,
387 }
388}
389
390func (a *openaiClient) Model() config.Model {
391 return a.providerOptions.model(a.providerOptions.modelType)
392}