1package providers
2
3import (
4 "context"
5 "encoding/base64"
6 "encoding/json"
7 "errors"
8 "fmt"
9 "io"
10 "maps"
11 "strings"
12
13 "github.com/anthropics/anthropic-sdk-go"
14 "github.com/anthropics/anthropic-sdk-go/option"
15 "github.com/anthropics/anthropic-sdk-go/packages/param"
16 "github.com/charmbracelet/crush/internal/ai"
17)
18
19type AnthropicProviderOptions struct {
20 SendReasoning *bool `json:"send_reasoning,omitempty"`
21 Thinking *AnthropicThinkingProviderOption `json:"thinking,omitempty"`
22 DisableParallelToolUse *bool `json:"disable_parallel_tool_use,omitempty"`
23}
24
25type AnthropicThinkingProviderOption struct {
26 BudgetTokens int64 `json:"budget_tokens"`
27}
28
29type AnthropicReasoningMetadata struct {
30 Signature string `json:"signature"`
31 RedactedData string `json:"redacted_data"`
32}
33
34type AnthropicCacheControlProviderOptions struct {
35 Type string `json:"type"`
36}
37type AnthropicFilePartProviderOptions struct {
38 EnableCitations bool `json:"enable_citations"`
39 Title string `json:"title"`
40 Context string `json:"context"`
41}
42
43type anthropicProviderOptions struct {
44 baseURL string
45 apiKey string
46 name string
47 headers map[string]string
48 client option.HTTPClient
49}
50
51type anthropicProvider struct {
52 options anthropicProviderOptions
53}
54
55type AnthropicOption = func(*anthropicProviderOptions)
56
57func NewAnthropicProvider(opts ...AnthropicOption) ai.Provider {
58 options := anthropicProviderOptions{
59 headers: map[string]string{},
60 }
61 for _, o := range opts {
62 o(&options)
63 }
64 if options.baseURL == "" {
65 options.baseURL = "https://api.anthropic.com"
66 }
67
68 if options.name == "" {
69 options.name = "anthropic"
70 }
71
72 return &anthropicProvider{
73 options: options,
74 }
75}
76
77func WithAnthropicBaseURL(baseURL string) AnthropicOption {
78 return func(o *anthropicProviderOptions) {
79 o.baseURL = baseURL
80 }
81}
82
83func WithAnthropicAPIKey(apiKey string) AnthropicOption {
84 return func(o *anthropicProviderOptions) {
85 o.apiKey = apiKey
86 }
87}
88
89func WithAnthropicName(name string) AnthropicOption {
90 return func(o *anthropicProviderOptions) {
91 o.name = name
92 }
93}
94
95func WithAnthropicHeaders(headers map[string]string) AnthropicOption {
96 return func(o *anthropicProviderOptions) {
97 maps.Copy(o.headers, headers)
98 }
99}
100
101func WithAnthropicHTTPClient(client option.HTTPClient) AnthropicOption {
102 return func(o *anthropicProviderOptions) {
103 o.client = client
104 }
105}
106
107func (a *anthropicProvider) LanguageModel(modelID string) (ai.LanguageModel, error) {
108 anthropicClientOptions := []option.RequestOption{}
109 if a.options.apiKey != "" {
110 anthropicClientOptions = append(anthropicClientOptions, option.WithAPIKey(a.options.apiKey))
111 }
112 if a.options.baseURL != "" {
113 anthropicClientOptions = append(anthropicClientOptions, option.WithBaseURL(a.options.baseURL))
114 }
115
116 for key, value := range a.options.headers {
117 anthropicClientOptions = append(anthropicClientOptions, option.WithHeader(key, value))
118 }
119
120 if a.options.client != nil {
121 anthropicClientOptions = append(anthropicClientOptions, option.WithHTTPClient(a.options.client))
122 }
123 return anthropicLanguageModel{
124 modelID: modelID,
125 provider: fmt.Sprintf("%s.messages", a.options.name),
126 providerOptions: a.options,
127 client: anthropic.NewClient(anthropicClientOptions...),
128 }, nil
129}
130
131type anthropicLanguageModel struct {
132 provider string
133 modelID string
134 client anthropic.Client
135 providerOptions anthropicProviderOptions
136}
137
138// Model implements ai.LanguageModel.
139func (a anthropicLanguageModel) Model() string {
140 return a.modelID
141}
142
143// Provider implements ai.LanguageModel.
144func (a anthropicLanguageModel) Provider() string {
145 return a.provider
146}
147
148func (a anthropicLanguageModel) prepareParams(call ai.Call) (*anthropic.MessageNewParams, []ai.CallWarning, error) {
149 params := &anthropic.MessageNewParams{}
150 providerOptions := &AnthropicProviderOptions{}
151 if v, ok := call.ProviderOptions["anthropic"]; ok {
152 err := ai.ParseOptions(v, providerOptions)
153 if err != nil {
154 return nil, nil, err
155 }
156 }
157 sendReasoning := true
158 if providerOptions.SendReasoning != nil {
159 sendReasoning = *providerOptions.SendReasoning
160 }
161 systemBlocks, messages, warnings := toAnthropicPrompt(call.Prompt, sendReasoning)
162
163 if call.FrequencyPenalty != nil {
164 warnings = append(warnings, ai.CallWarning{
165 Type: ai.CallWarningTypeUnsupportedSetting,
166 Setting: "FrequencyPenalty",
167 })
168 }
169 if call.PresencePenalty != nil {
170 warnings = append(warnings, ai.CallWarning{
171 Type: ai.CallWarningTypeUnsupportedSetting,
172 Setting: "PresencePenalty",
173 })
174 }
175
176 params.System = systemBlocks
177 params.Messages = messages
178 params.Model = anthropic.Model(a.modelID)
179 params.MaxTokens = 4096
180
181 if call.MaxOutputTokens != nil {
182 params.MaxTokens = *call.MaxOutputTokens
183 }
184
185 if call.Temperature != nil {
186 params.Temperature = param.NewOpt(*call.Temperature)
187 }
188 if call.TopK != nil {
189 params.TopK = param.NewOpt(*call.TopK)
190 }
191 if call.TopP != nil {
192 params.TopP = param.NewOpt(*call.TopP)
193 }
194
195 isThinking := false
196 var thinkingBudget int64
197 if providerOptions.Thinking != nil {
198 isThinking = true
199 thinkingBudget = providerOptions.Thinking.BudgetTokens
200 }
201 if isThinking {
202 if thinkingBudget == 0 {
203 return nil, nil, ai.NewUnsupportedFunctionalityError("thinking requires budget", "")
204 }
205 params.Thinking = anthropic.ThinkingConfigParamOfEnabled(thinkingBudget)
206 if call.Temperature != nil {
207 params.Temperature = param.Opt[float64]{}
208 warnings = append(warnings, ai.CallWarning{
209 Type: ai.CallWarningTypeUnsupportedSetting,
210 Setting: "temperature",
211 Details: "temperature is not supported when thinking is enabled",
212 })
213 }
214 if call.TopP != nil {
215 params.TopP = param.Opt[float64]{}
216 warnings = append(warnings, ai.CallWarning{
217 Type: ai.CallWarningTypeUnsupportedSetting,
218 Setting: "TopP",
219 Details: "TopP is not supported when thinking is enabled",
220 })
221 }
222 if call.TopK != nil {
223 params.TopK = param.Opt[int64]{}
224 warnings = append(warnings, ai.CallWarning{
225 Type: ai.CallWarningTypeUnsupportedSetting,
226 Setting: "TopK",
227 Details: "TopK is not supported when thinking is enabled",
228 })
229 }
230 params.MaxTokens = params.MaxTokens + thinkingBudget
231 }
232
233 if len(call.Tools) > 0 {
234 disableParallelToolUse := false
235 if providerOptions.DisableParallelToolUse != nil {
236 disableParallelToolUse = *providerOptions.DisableParallelToolUse
237 }
238 tools, toolChoice, toolWarnings := toAnthropicTools(call.Tools, call.ToolChoice, disableParallelToolUse)
239 params.Tools = tools
240 if toolChoice != nil {
241 params.ToolChoice = *toolChoice
242 }
243 warnings = append(warnings, toolWarnings...)
244 }
245
246 return params, warnings, nil
247}
248
249func getCacheControl(providerOptions ai.ProviderOptions) *AnthropicCacheControlProviderOptions {
250 if anthropicOptions, ok := providerOptions["anthropic"]; ok {
251 if cacheControl, ok := anthropicOptions["cache_control"]; ok {
252 if cc, ok := cacheControl.(map[string]any); ok {
253 cacheControlOption := &AnthropicCacheControlProviderOptions{}
254 err := ai.ParseOptions(cc, cacheControlOption)
255 if err != nil {
256 return cacheControlOption
257 }
258 }
259 } else if cacheControl, ok := anthropicOptions["cacheControl"]; ok {
260 if cc, ok := cacheControl.(map[string]any); ok {
261 cacheControlOption := &AnthropicCacheControlProviderOptions{}
262 err := ai.ParseOptions(cc, cacheControlOption)
263 if err != nil {
264 return cacheControlOption
265 }
266 }
267 }
268 }
269 return nil
270}
271
272func getReasoningMetadata(providerOptions ai.ProviderOptions) *AnthropicReasoningMetadata {
273 if anthropicOptions, ok := providerOptions["anthropic"]; ok {
274 reasoningMetadata := &AnthropicReasoningMetadata{}
275 err := ai.ParseOptions(anthropicOptions, reasoningMetadata)
276 if err != nil {
277 return reasoningMetadata
278 }
279 }
280 return nil
281}
282
283type messageBlock struct {
284 Role ai.MessageRole
285 Messages []ai.Message
286}
287
288func groupIntoBlocks(prompt ai.Prompt) []*messageBlock {
289 var blocks []*messageBlock
290
291 var currentBlock *messageBlock
292
293 for _, msg := range prompt {
294 switch msg.Role {
295 case ai.MessageRoleSystem:
296 if currentBlock == nil || currentBlock.Role != ai.MessageRoleSystem {
297 currentBlock = &messageBlock{
298 Role: ai.MessageRoleSystem,
299 Messages: []ai.Message{},
300 }
301 blocks = append(blocks, currentBlock)
302 }
303 currentBlock.Messages = append(currentBlock.Messages, msg)
304 case ai.MessageRoleUser:
305 if currentBlock == nil || currentBlock.Role != ai.MessageRoleUser {
306 currentBlock = &messageBlock{
307 Role: ai.MessageRoleUser,
308 Messages: []ai.Message{},
309 }
310 blocks = append(blocks, currentBlock)
311 }
312 currentBlock.Messages = append(currentBlock.Messages, msg)
313 case ai.MessageRoleAssistant:
314 if currentBlock == nil || currentBlock.Role != ai.MessageRoleAssistant {
315 currentBlock = &messageBlock{
316 Role: ai.MessageRoleAssistant,
317 Messages: []ai.Message{},
318 }
319 blocks = append(blocks, currentBlock)
320 }
321 currentBlock.Messages = append(currentBlock.Messages, msg)
322 case ai.MessageRoleTool:
323 if currentBlock == nil || currentBlock.Role != ai.MessageRoleUser {
324 currentBlock = &messageBlock{
325 Role: ai.MessageRoleUser,
326 Messages: []ai.Message{},
327 }
328 blocks = append(blocks, currentBlock)
329 }
330 currentBlock.Messages = append(currentBlock.Messages, msg)
331 }
332 }
333 return blocks
334}
335
336func toAnthropicTools(tools []ai.Tool, toolChoice *ai.ToolChoice, disableParallelToolCalls bool) (anthropicTools []anthropic.ToolUnionParam, anthropicToolChoice *anthropic.ToolChoiceUnionParam, warnings []ai.CallWarning) {
337 for _, tool := range tools {
338 if tool.GetType() == ai.ToolTypeFunction {
339 ft, ok := tool.(ai.FunctionTool)
340 if !ok {
341 continue
342 }
343 required := []string{}
344 var properties any
345 if props, ok := ft.InputSchema["properties"]; ok {
346 properties = props
347 }
348 if req, ok := ft.InputSchema["required"]; ok {
349 if reqArr, ok := req.([]string); ok {
350 required = reqArr
351 }
352 }
353 cacheControl := getCacheControl(ft.ProviderOptions)
354
355 anthropicTool := anthropic.ToolParam{
356 Name: ft.Name,
357 Description: anthropic.String(ft.Description),
358 InputSchema: anthropic.ToolInputSchemaParam{
359 Properties: properties,
360 Required: required,
361 },
362 }
363 if cacheControl != nil {
364 anthropicTool.CacheControl = anthropic.NewCacheControlEphemeralParam()
365 }
366 anthropicTools = append(anthropicTools, anthropic.ToolUnionParam{OfTool: &anthropicTool})
367 continue
368 }
369 // TODO: handle provider tool calls
370 warnings = append(warnings, ai.CallWarning{
371 Type: ai.CallWarningTypeUnsupportedTool,
372 Tool: tool,
373 Message: "tool is not supported",
374 })
375 }
376 if toolChoice == nil {
377 return
378 }
379
380 switch *toolChoice {
381 case ai.ToolChoiceAuto:
382 anthropicToolChoice = &anthropic.ToolChoiceUnionParam{
383 OfAuto: &anthropic.ToolChoiceAutoParam{
384 Type: "auto",
385 DisableParallelToolUse: param.NewOpt(disableParallelToolCalls),
386 },
387 }
388 case ai.ToolChoiceRequired:
389 anthropicToolChoice = &anthropic.ToolChoiceUnionParam{
390 OfAny: &anthropic.ToolChoiceAnyParam{
391 Type: "any",
392 DisableParallelToolUse: param.NewOpt(disableParallelToolCalls),
393 },
394 }
395 default:
396 anthropicToolChoice = &anthropic.ToolChoiceUnionParam{
397 OfTool: &anthropic.ToolChoiceToolParam{
398 Type: "tool",
399 Name: string(*toolChoice),
400 DisableParallelToolUse: param.NewOpt(disableParallelToolCalls),
401 },
402 }
403 }
404 return
405}
406
407func toAnthropicPrompt(prompt ai.Prompt, sendReasoningData bool) ([]anthropic.TextBlockParam, []anthropic.MessageParam, []ai.CallWarning) {
408 var systemBlocks []anthropic.TextBlockParam
409 var messages []anthropic.MessageParam
410 var warnings []ai.CallWarning
411
412 blocks := groupIntoBlocks(prompt)
413 finishedSystemBlock := false
414 for _, block := range blocks {
415 switch block.Role {
416 case ai.MessageRoleSystem:
417 if finishedSystemBlock {
418 // skip multiple system messages that are separated by user/assistant messages
419 // TODO: see if we need to send error here?
420 continue
421 }
422 finishedSystemBlock = true
423 for _, msg := range block.Messages {
424 for _, part := range msg.Content {
425 cacheControl := getCacheControl(part.Options())
426 text, ok := ai.AsMessagePart[ai.TextPart](part)
427 if !ok {
428 continue
429 }
430 textBlock := anthropic.TextBlockParam{
431 Text: text.Text,
432 }
433 if cacheControl != nil {
434 textBlock.CacheControl = anthropic.NewCacheControlEphemeralParam()
435 }
436 systemBlocks = append(systemBlocks, textBlock)
437 }
438 }
439
440 case ai.MessageRoleUser:
441 var anthropicContent []anthropic.ContentBlockParamUnion
442 for _, msg := range block.Messages {
443 if msg.Role == ai.MessageRoleUser {
444 for i, part := range msg.Content {
445 isLastPart := i == len(msg.Content)-1
446 cacheControl := getCacheControl(part.Options())
447 if cacheControl == nil && isLastPart {
448 cacheControl = getCacheControl(msg.ProviderOptions)
449 }
450 switch part.GetType() {
451 case ai.ContentTypeText:
452 text, ok := ai.AsMessagePart[ai.TextPart](part)
453 if !ok {
454 continue
455 }
456 textBlock := &anthropic.TextBlockParam{
457 Text: text.Text,
458 }
459 if cacheControl != nil {
460 textBlock.CacheControl = anthropic.NewCacheControlEphemeralParam()
461 }
462 anthropicContent = append(anthropicContent, anthropic.ContentBlockParamUnion{
463 OfText: textBlock,
464 })
465 case ai.ContentTypeFile:
466 file, ok := ai.AsMessagePart[ai.FilePart](part)
467 if !ok {
468 continue
469 }
470 // TODO: handle other file types
471 if !strings.HasPrefix(file.MediaType, "image/") {
472 continue
473 }
474
475 base64Encoded := base64.StdEncoding.EncodeToString(file.Data)
476 imageBlock := anthropic.NewImageBlockBase64(file.MediaType, base64Encoded)
477 if cacheControl != nil {
478 imageBlock.OfImage.CacheControl = anthropic.NewCacheControlEphemeralParam()
479 }
480 anthropicContent = append(anthropicContent, imageBlock)
481 }
482 }
483 } else if msg.Role == ai.MessageRoleTool {
484 for i, part := range msg.Content {
485 isLastPart := i == len(msg.Content)-1
486 cacheControl := getCacheControl(part.Options())
487 if cacheControl == nil && isLastPart {
488 cacheControl = getCacheControl(msg.ProviderOptions)
489 }
490 result, ok := ai.AsMessagePart[ai.ToolResultPart](part)
491 if !ok {
492 continue
493 }
494 toolResultBlock := anthropic.ToolResultBlockParam{
495 ToolUseID: result.ToolCallID,
496 }
497 switch result.Output.GetType() {
498 case ai.ToolResultContentTypeText:
499 content, ok := ai.AsToolResultOutputType[ai.ToolResultOutputContentText](result.Output)
500 if !ok {
501 continue
502 }
503 toolResultBlock.Content = []anthropic.ToolResultBlockParamContentUnion{
504 {
505 OfText: &anthropic.TextBlockParam{
506 Text: content.Text,
507 },
508 },
509 }
510 case ai.ToolResultContentTypeMedia:
511 content, ok := ai.AsToolResultOutputType[ai.ToolResultOutputContentMedia](result.Output)
512 if !ok {
513 continue
514 }
515 toolResultBlock.Content = []anthropic.ToolResultBlockParamContentUnion{
516 {
517 OfImage: anthropic.NewImageBlockBase64(content.MediaType, content.Data).OfImage,
518 },
519 }
520 case ai.ToolResultContentTypeError:
521 content, ok := ai.AsToolResultOutputType[ai.ToolResultOutputContentError](result.Output)
522 if !ok {
523 continue
524 }
525 toolResultBlock.Content = []anthropic.ToolResultBlockParamContentUnion{
526 {
527 OfText: &anthropic.TextBlockParam{
528 Text: content.Error.Error(),
529 },
530 },
531 }
532 toolResultBlock.IsError = param.NewOpt(true)
533 }
534 if cacheControl != nil {
535 toolResultBlock.CacheControl = anthropic.NewCacheControlEphemeralParam()
536 }
537 anthropicContent = append(anthropicContent, anthropic.ContentBlockParamUnion{
538 OfToolResult: &toolResultBlock,
539 })
540 }
541 }
542 }
543 messages = append(messages, anthropic.NewUserMessage(anthropicContent...))
544 case ai.MessageRoleAssistant:
545 var anthropicContent []anthropic.ContentBlockParamUnion
546 for _, msg := range block.Messages {
547 for i, part := range msg.Content {
548 isLastPart := i == len(msg.Content)-1
549 cacheControl := getCacheControl(part.Options())
550 if cacheControl == nil && isLastPart {
551 cacheControl = getCacheControl(msg.ProviderOptions)
552 }
553 switch part.GetType() {
554 case ai.ContentTypeText:
555 text, ok := ai.AsMessagePart[ai.TextPart](part)
556 if !ok {
557 continue
558 }
559 textBlock := &anthropic.TextBlockParam{
560 Text: text.Text,
561 }
562 if cacheControl != nil {
563 textBlock.CacheControl = anthropic.NewCacheControlEphemeralParam()
564 }
565 anthropicContent = append(anthropicContent, anthropic.ContentBlockParamUnion{
566 OfText: textBlock,
567 })
568 case ai.ContentTypeReasoning:
569 reasoning, ok := ai.AsMessagePart[ai.ReasoningPart](part)
570 if !ok {
571 continue
572 }
573 if !sendReasoningData {
574 warnings = append(warnings, ai.CallWarning{
575 Type: "other",
576 Message: "sending reasoning content is disabled for this model",
577 })
578 continue
579 }
580 reasoningMetadata := getReasoningMetadata(part.Options())
581 if reasoningMetadata == nil {
582 warnings = append(warnings, ai.CallWarning{
583 Type: "other",
584 Message: "unsupported reasoning metadata",
585 })
586 continue
587 }
588
589 if reasoningMetadata.Signature != "" {
590 anthropicContent = append(anthropicContent, anthropic.NewThinkingBlock(reasoningMetadata.Signature, reasoning.Text))
591 } else if reasoningMetadata.RedactedData != "" {
592 anthropicContent = append(anthropicContent, anthropic.NewRedactedThinkingBlock(reasoningMetadata.RedactedData))
593 } else {
594 warnings = append(warnings, ai.CallWarning{
595 Type: "other",
596 Message: "unsupported reasoning metadata",
597 })
598 continue
599 }
600 case ai.ContentTypeToolCall:
601 toolCall, ok := ai.AsMessagePart[ai.ToolCallPart](part)
602 if !ok {
603 continue
604 }
605 if toolCall.ProviderExecuted {
606 // TODO: implement provider executed call
607 continue
608 }
609
610 var inputMap map[string]any
611 err := json.Unmarshal([]byte(toolCall.Input), &inputMap)
612 if err != nil {
613 continue
614 }
615 toolUseBlock := anthropic.NewToolUseBlock(toolCall.ToolCallID, inputMap, toolCall.ToolName)
616 if cacheControl != nil {
617 toolUseBlock.OfToolUse.CacheControl = anthropic.NewCacheControlEphemeralParam()
618 }
619 anthropicContent = append(anthropicContent, toolUseBlock)
620 case ai.ContentTypeToolResult:
621 // TODO: implement provider executed tool result
622 }
623 }
624 }
625 messages = append(messages, anthropic.NewAssistantMessage(anthropicContent...))
626 }
627 }
628 return systemBlocks, messages, warnings
629}
630
631func (o anthropicLanguageModel) handleError(err error) error {
632 var apiErr *anthropic.Error
633 if errors.As(err, &apiErr) {
634 requestDump := apiErr.DumpRequest(true)
635 responseDump := apiErr.DumpResponse(true)
636 headers := map[string]string{}
637 for k, h := range apiErr.Response.Header {
638 v := h[len(h)-1]
639 headers[strings.ToLower(k)] = v
640 }
641 return ai.NewAPICallError(
642 apiErr.Error(),
643 apiErr.Request.URL.String(),
644 string(requestDump),
645 apiErr.StatusCode,
646 headers,
647 string(responseDump),
648 apiErr,
649 false,
650 )
651 }
652 return err
653}
654
655func mapAnthropicFinishReason(finishReason string) ai.FinishReason {
656 switch finishReason {
657 case "end", "stop_sequence":
658 return ai.FinishReasonStop
659 case "max_tokens":
660 return ai.FinishReasonLength
661 case "tool_use":
662 return ai.FinishReasonToolCalls
663 default:
664 return ai.FinishReasonUnknown
665 }
666}
667
668// Generate implements ai.LanguageModel.
669func (a anthropicLanguageModel) Generate(ctx context.Context, call ai.Call) (*ai.Response, error) {
670 params, warnings, err := a.prepareParams(call)
671 if err != nil {
672 return nil, err
673 }
674 response, err := a.client.Messages.New(ctx, *params)
675 if err != nil {
676 return nil, a.handleError(err)
677 }
678
679 var content []ai.Content
680 for _, block := range response.Content {
681 switch block.Type {
682 case "text":
683 text, ok := block.AsAny().(anthropic.TextBlock)
684 if !ok {
685 continue
686 }
687 content = append(content, ai.TextContent{
688 Text: text.Text,
689 })
690 case "thinking":
691 reasoning, ok := block.AsAny().(anthropic.ThinkingBlock)
692 if !ok {
693 continue
694 }
695 content = append(content, ai.ReasoningContent{
696 Text: reasoning.Thinking,
697 ProviderMetadata: map[string]map[string]any{
698 "anthropic": {
699 "signature": reasoning.Signature,
700 },
701 },
702 })
703 case "redacted_thinking":
704 reasoning, ok := block.AsAny().(anthropic.RedactedThinkingBlock)
705 if !ok {
706 continue
707 }
708 content = append(content, ai.ReasoningContent{
709 Text: "",
710 ProviderMetadata: map[string]map[string]any{
711 "anthropic": {
712 "redacted_data": reasoning.Data,
713 },
714 },
715 })
716 case "tool_use":
717 toolUse, ok := block.AsAny().(anthropic.ToolUseBlock)
718 if !ok {
719 continue
720 }
721 content = append(content, ai.ToolCallContent{
722 ToolCallID: toolUse.ID,
723 ToolName: toolUse.Name,
724 Input: string(toolUse.Input),
725 ProviderExecuted: false,
726 })
727 }
728 }
729
730 return &ai.Response{
731 Content: content,
732 Usage: ai.Usage{
733 InputTokens: response.Usage.InputTokens,
734 OutputTokens: response.Usage.OutputTokens,
735 TotalTokens: response.Usage.InputTokens + response.Usage.OutputTokens,
736 CacheCreationTokens: response.Usage.CacheCreationInputTokens,
737 CacheReadTokens: response.Usage.CacheReadInputTokens,
738 },
739 FinishReason: mapAnthropicFinishReason(string(response.StopReason)),
740 ProviderMetadata: ai.ProviderMetadata{
741 "anthropic": make(map[string]any),
742 },
743 Warnings: warnings,
744 }, nil
745}
746
747// Stream implements ai.LanguageModel.
748func (a anthropicLanguageModel) Stream(ctx context.Context, call ai.Call) (ai.StreamResponse, error) {
749 params, warnings, err := a.prepareParams(call)
750 if err != nil {
751 return nil, err
752 }
753
754 stream := a.client.Messages.NewStreaming(ctx, *params)
755 acc := anthropic.Message{}
756 return func(yield func(ai.StreamPart) bool) {
757 if len(warnings) > 0 {
758 if !yield(ai.StreamPart{
759 Type: ai.StreamPartTypeWarnings,
760 Warnings: warnings,
761 }) {
762 return
763 }
764 }
765
766 for stream.Next() {
767 chunk := stream.Current()
768 acc.Accumulate(chunk)
769 switch chunk.Type {
770 case "content_block_start":
771 contentBlockType := chunk.ContentBlock.Type
772 switch contentBlockType {
773 case "text":
774 if !yield(ai.StreamPart{
775 Type: ai.StreamPartTypeTextStart,
776 ID: fmt.Sprintf("%d", chunk.Index),
777 }) {
778 return
779 }
780 case "thinking":
781 if !yield(ai.StreamPart{
782 Type: ai.StreamPartTypeReasoningStart,
783 ID: fmt.Sprintf("%d", chunk.Index),
784 }) {
785 return
786 }
787 case "redacted_thinking":
788 if !yield(ai.StreamPart{
789 Type: ai.StreamPartTypeReasoningStart,
790 ID: fmt.Sprintf("%d", chunk.Index),
791 ProviderMetadata: ai.ProviderMetadata{
792 "anthropic": {
793 "redacted_data": chunk.ContentBlock.Data,
794 },
795 },
796 }) {
797 return
798 }
799 case "tool_use":
800 if !yield(ai.StreamPart{
801 Type: ai.StreamPartTypeToolInputStart,
802 ID: chunk.ContentBlock.ID,
803 ToolCallName: chunk.ContentBlock.Name,
804 ToolCallInput: "",
805 }) {
806 return
807 }
808 }
809 case "content_block_stop":
810 if len(acc.Content)-1 < int(chunk.Index) {
811 continue
812 }
813 contentBlock := acc.Content[int(chunk.Index)]
814 switch contentBlock.Type {
815 case "text":
816 if !yield(ai.StreamPart{
817 Type: ai.StreamPartTypeTextEnd,
818 ID: fmt.Sprintf("%d", chunk.Index),
819 }) {
820 return
821 }
822 case "thinking":
823 if !yield(ai.StreamPart{
824 Type: ai.StreamPartTypeReasoningEnd,
825 ID: fmt.Sprintf("%d", chunk.Index),
826 }) {
827 return
828 }
829 case "tool_use":
830 if !yield(ai.StreamPart{
831 Type: ai.StreamPartTypeToolInputEnd,
832 ID: contentBlock.ID,
833 }) {
834 return
835 }
836 if !yield(ai.StreamPart{
837 Type: ai.StreamPartTypeToolCall,
838 ID: contentBlock.ID,
839 ToolCallName: contentBlock.Name,
840 ToolCallInput: string(contentBlock.Input),
841 }) {
842 return
843 }
844 }
845 case "content_block_delta":
846 switch chunk.Delta.Type {
847 case "text_delta":
848 if !yield(ai.StreamPart{
849 Type: ai.StreamPartTypeTextDelta,
850 ID: fmt.Sprintf("%d", chunk.Index),
851 Delta: chunk.Delta.Text,
852 }) {
853 return
854 }
855 case "thinking_delta":
856 if !yield(ai.StreamPart{
857 Type: ai.StreamPartTypeReasoningDelta,
858 ID: fmt.Sprintf("%d", chunk.Index),
859 Delta: chunk.Delta.Text,
860 }) {
861 return
862 }
863 case "signature_delta":
864 if !yield(ai.StreamPart{
865 Type: ai.StreamPartTypeReasoningDelta,
866 ID: fmt.Sprintf("%d", chunk.Index),
867 ProviderMetadata: ai.ProviderMetadata{
868 "anthropic": {
869 "signature": chunk.Delta.Signature,
870 },
871 },
872 }) {
873 return
874 }
875 case "input_json_delta":
876 if len(acc.Content)-1 < int(chunk.Index) {
877 continue
878 }
879 contentBlock := acc.Content[int(chunk.Index)]
880 if !yield(ai.StreamPart{
881 Type: ai.StreamPartTypeToolInputDelta,
882 ID: contentBlock.ID,
883 ToolCallInput: chunk.Delta.PartialJSON,
884 }) {
885 return
886 }
887 }
888 case "message_stop":
889 }
890 }
891
892 err := stream.Err()
893 if err == nil || errors.Is(err, io.EOF) {
894 yield(ai.StreamPart{
895 Type: ai.StreamPartTypeFinish,
896 ID: acc.ID,
897 FinishReason: mapAnthropicFinishReason(string(acc.StopReason)),
898 Usage: ai.Usage{
899 InputTokens: acc.Usage.InputTokens,
900 OutputTokens: acc.Usage.OutputTokens,
901 TotalTokens: acc.Usage.InputTokens + acc.Usage.OutputTokens,
902 CacheCreationTokens: acc.Usage.CacheCreationInputTokens,
903 CacheReadTokens: acc.Usage.CacheReadInputTokens,
904 },
905 ProviderMetadata: ai.ProviderMetadata{
906 "anthropic": make(map[string]any),
907 },
908 })
909 return
910 } else {
911 yield(ai.StreamPart{
912 Type: ai.StreamPartTypeError,
913 Error: a.handleError(err),
914 })
915 return
916 }
917 }, nil
918}