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
339 if tool.GetType() == ai.ToolTypeFunction {
340 ft, ok := tool.(ai.FunctionTool)
341 if !ok {
342 continue
343 }
344 required := []string{}
345 var properties any
346 if props, ok := ft.InputSchema["properties"]; ok {
347 properties = props
348 }
349 if req, ok := ft.InputSchema["required"]; ok {
350 if reqArr, ok := req.([]string); ok {
351 required = reqArr
352 }
353 }
354 cacheControl := getCacheControl(ft.ProviderOptions)
355
356 anthropicTool := anthropic.ToolParam{
357 Name: ft.Name,
358 Description: anthropic.String(ft.Description),
359 InputSchema: anthropic.ToolInputSchemaParam{
360 Properties: properties,
361 Required: required,
362 },
363 }
364 if cacheControl != nil {
365 anthropicTool.CacheControl = anthropic.NewCacheControlEphemeralParam()
366 }
367 anthropicTools = append(anthropicTools, anthropic.ToolUnionParam{OfTool: &anthropicTool})
368 continue
369 }
370 // TODO: handle provider tool calls
371 warnings = append(warnings, ai.CallWarning{
372 Type: ai.CallWarningTypeUnsupportedTool,
373 Tool: tool,
374 Message: "tool is not supported",
375 })
376 }
377 if toolChoice == nil {
378 return
379 }
380
381 switch *toolChoice {
382 case ai.ToolChoiceAuto:
383 anthropicToolChoice = &anthropic.ToolChoiceUnionParam{
384 OfAuto: &anthropic.ToolChoiceAutoParam{
385 Type: "auto",
386 DisableParallelToolUse: param.NewOpt(disableParallelToolCalls),
387 },
388 }
389 case ai.ToolChoiceRequired:
390 anthropicToolChoice = &anthropic.ToolChoiceUnionParam{
391 OfAny: &anthropic.ToolChoiceAnyParam{
392 Type: "any",
393 DisableParallelToolUse: param.NewOpt(disableParallelToolCalls),
394 },
395 }
396 default:
397 anthropicToolChoice = &anthropic.ToolChoiceUnionParam{
398 OfTool: &anthropic.ToolChoiceToolParam{
399 Type: "tool",
400 Name: string(*toolChoice),
401 DisableParallelToolUse: param.NewOpt(disableParallelToolCalls),
402 },
403 }
404 }
405 return
406}
407
408func toAnthropicPrompt(prompt ai.Prompt, sendReasoningData bool) ([]anthropic.TextBlockParam, []anthropic.MessageParam, []ai.CallWarning) {
409 var systemBlocks []anthropic.TextBlockParam
410 var messages []anthropic.MessageParam
411 var warnings []ai.CallWarning
412
413 blocks := groupIntoBlocks(prompt)
414 finishedSystemBlock := false
415 for _, block := range blocks {
416 switch block.Role {
417 case ai.MessageRoleSystem:
418 if finishedSystemBlock {
419 // skip multiple system messages that are separated by user/assistant messages
420 // TODO: see if we need to send error here?
421 continue
422 }
423 finishedSystemBlock = true
424 for _, msg := range block.Messages {
425 for _, part := range msg.Content {
426 cacheControl := getCacheControl(part.Options())
427 text, ok := ai.AsMessagePart[ai.TextPart](part)
428 if !ok {
429 continue
430 }
431 textBlock := anthropic.TextBlockParam{
432 Text: text.Text,
433 }
434 if cacheControl != nil {
435 textBlock.CacheControl = anthropic.NewCacheControlEphemeralParam()
436 }
437 systemBlocks = append(systemBlocks, textBlock)
438 }
439 }
440
441 case ai.MessageRoleUser:
442 var anthropicContent []anthropic.ContentBlockParamUnion
443 for _, msg := range block.Messages {
444 if msg.Role == ai.MessageRoleUser {
445 for i, part := range msg.Content {
446 isLastPart := i == len(msg.Content)-1
447 cacheControl := getCacheControl(part.Options())
448 if cacheControl == nil && isLastPart {
449 cacheControl = getCacheControl(msg.ProviderOptions)
450 }
451 switch part.GetType() {
452 case ai.ContentTypeText:
453 text, ok := ai.AsMessagePart[ai.TextPart](part)
454 if !ok {
455 continue
456 }
457 textBlock := &anthropic.TextBlockParam{
458 Text: text.Text,
459 }
460 if cacheControl != nil {
461 textBlock.CacheControl = anthropic.NewCacheControlEphemeralParam()
462 }
463 anthropicContent = append(anthropicContent, anthropic.ContentBlockParamUnion{
464 OfText: textBlock,
465 })
466 case ai.ContentTypeFile:
467 file, ok := ai.AsMessagePart[ai.FilePart](part)
468 if !ok {
469 continue
470 }
471 // TODO: handle other file types
472 if !strings.HasPrefix(file.MediaType, "image/") {
473 continue
474 }
475
476 base64Encoded := base64.StdEncoding.EncodeToString(file.Data)
477 imageBlock := anthropic.NewImageBlockBase64(file.MediaType, base64Encoded)
478 if cacheControl != nil {
479 imageBlock.OfImage.CacheControl = anthropic.NewCacheControlEphemeralParam()
480 }
481 anthropicContent = append(anthropicContent, imageBlock)
482 }
483 }
484 } else if msg.Role == ai.MessageRoleTool {
485 for i, part := range msg.Content {
486 isLastPart := i == len(msg.Content)-1
487 cacheControl := getCacheControl(part.Options())
488 if cacheControl == nil && isLastPart {
489 cacheControl = getCacheControl(msg.ProviderOptions)
490 }
491 result, ok := ai.AsMessagePart[ai.ToolResultPart](part)
492 if !ok {
493 continue
494 }
495 toolResultBlock := anthropic.ToolResultBlockParam{
496 ToolUseID: result.ToolCallID,
497 }
498 switch result.Output.GetType() {
499 case ai.ToolResultContentTypeText:
500 content, ok := ai.AsToolResultOutputType[ai.ToolResultOutputContentText](result.Output)
501 if !ok {
502 continue
503 }
504 toolResultBlock.Content = []anthropic.ToolResultBlockParamContentUnion{
505 {
506 OfText: &anthropic.TextBlockParam{
507 Text: content.Text,
508 },
509 },
510 }
511 case ai.ToolResultContentTypeMedia:
512 content, ok := ai.AsToolResultOutputType[ai.ToolResultOutputContentMedia](result.Output)
513 if !ok {
514 continue
515 }
516 toolResultBlock.Content = []anthropic.ToolResultBlockParamContentUnion{
517 {
518 OfImage: anthropic.NewImageBlockBase64(content.MediaType, content.Data).OfImage,
519 },
520 }
521 case ai.ToolResultContentTypeError:
522 content, ok := ai.AsToolResultOutputType[ai.ToolResultOutputContentError](result.Output)
523 if !ok {
524 continue
525 }
526 toolResultBlock.Content = []anthropic.ToolResultBlockParamContentUnion{
527 {
528 OfText: &anthropic.TextBlockParam{
529 Text: content.Error.Error(),
530 },
531 },
532 }
533 toolResultBlock.IsError = param.NewOpt(true)
534 }
535 if cacheControl != nil {
536 toolResultBlock.CacheControl = anthropic.NewCacheControlEphemeralParam()
537 }
538 anthropicContent = append(anthropicContent, anthropic.ContentBlockParamUnion{
539 OfToolResult: &toolResultBlock,
540 })
541 }
542 }
543 }
544 messages = append(messages, anthropic.NewUserMessage(anthropicContent...))
545 case ai.MessageRoleAssistant:
546 var anthropicContent []anthropic.ContentBlockParamUnion
547 for _, msg := range block.Messages {
548 for i, part := range msg.Content {
549 isLastPart := i == len(msg.Content)-1
550 cacheControl := getCacheControl(part.Options())
551 if cacheControl == nil && isLastPart {
552 cacheControl = getCacheControl(msg.ProviderOptions)
553 }
554 switch part.GetType() {
555 case ai.ContentTypeText:
556 text, ok := ai.AsMessagePart[ai.TextPart](part)
557 if !ok {
558 continue
559 }
560 textBlock := &anthropic.TextBlockParam{
561 Text: text.Text,
562 }
563 if cacheControl != nil {
564 textBlock.CacheControl = anthropic.NewCacheControlEphemeralParam()
565 }
566 anthropicContent = append(anthropicContent, anthropic.ContentBlockParamUnion{
567 OfText: textBlock,
568 })
569 case ai.ContentTypeReasoning:
570 reasoning, ok := ai.AsMessagePart[ai.ReasoningPart](part)
571 if !ok {
572 continue
573 }
574 if !sendReasoningData {
575 warnings = append(warnings, ai.CallWarning{
576 Type: "other",
577 Message: "sending reasoning content is disabled for this model",
578 })
579 continue
580 }
581 reasoningMetadata := getReasoningMetadata(part.Options())
582 if reasoningMetadata == nil {
583 warnings = append(warnings, ai.CallWarning{
584 Type: "other",
585 Message: "unsupported reasoning metadata",
586 })
587 continue
588 }
589
590 if reasoningMetadata.Signature != "" {
591 anthropicContent = append(anthropicContent, anthropic.NewThinkingBlock(reasoningMetadata.Signature, reasoning.Text))
592 } else if reasoningMetadata.RedactedData != "" {
593 anthropicContent = append(anthropicContent, anthropic.NewRedactedThinkingBlock(reasoningMetadata.RedactedData))
594 } else {
595 warnings = append(warnings, ai.CallWarning{
596 Type: "other",
597 Message: "unsupported reasoning metadata",
598 })
599 continue
600 }
601 case ai.ContentTypeToolCall:
602 toolCall, ok := ai.AsMessagePart[ai.ToolCallPart](part)
603 if !ok {
604 continue
605 }
606 if toolCall.ProviderExecuted {
607 // TODO: implement provider executed call
608 continue
609 }
610
611 var inputMap map[string]any
612 err := json.Unmarshal([]byte(toolCall.Input), &inputMap)
613 if err != nil {
614 continue
615 }
616 toolUseBlock := anthropic.NewToolUseBlock(toolCall.ToolCallID, inputMap, toolCall.ToolName)
617 if cacheControl != nil {
618 toolUseBlock.OfToolUse.CacheControl = anthropic.NewCacheControlEphemeralParam()
619 }
620 anthropicContent = append(anthropicContent, toolUseBlock)
621 case ai.ContentTypeToolResult:
622 // TODO: implement provider executed tool result
623 }
624
625 }
626 }
627 messages = append(messages, anthropic.NewAssistantMessage(anthropicContent...))
628 }
629 }
630 return systemBlocks, messages, warnings
631}
632
633func (o anthropicLanguageModel) handleError(err error) error {
634 var apiErr *anthropic.Error
635 if errors.As(err, &apiErr) {
636 requestDump := apiErr.DumpRequest(true)
637 responseDump := apiErr.DumpResponse(true)
638 headers := map[string]string{}
639 for k, h := range apiErr.Response.Header {
640 v := h[len(h)-1]
641 headers[strings.ToLower(k)] = v
642 }
643 return ai.NewAPICallError(
644 apiErr.Error(),
645 apiErr.Request.URL.String(),
646 string(requestDump),
647 apiErr.StatusCode,
648 headers,
649 string(responseDump),
650 apiErr,
651 false,
652 )
653 }
654 return err
655}
656
657func mapAnthropicFinishReason(finishReason string) ai.FinishReason {
658 switch finishReason {
659 case "end", "stop_sequence":
660 return ai.FinishReasonStop
661 case "max_tokens":
662 return ai.FinishReasonLength
663 case "tool_use":
664 return ai.FinishReasonToolCalls
665 default:
666 return ai.FinishReasonUnknown
667 }
668}
669
670// Generate implements ai.LanguageModel.
671func (a anthropicLanguageModel) Generate(ctx context.Context, call ai.Call) (*ai.Response, error) {
672 params, warnings, err := a.prepareParams(call)
673 if err != nil {
674 return nil, err
675 }
676 response, err := a.client.Messages.New(ctx, *params)
677 if err != nil {
678 return nil, a.handleError(err)
679 }
680
681 var content []ai.Content
682 for _, block := range response.Content {
683 switch block.Type {
684 case "text":
685 text, ok := block.AsAny().(anthropic.TextBlock)
686 if !ok {
687 continue
688 }
689 content = append(content, ai.TextContent{
690 Text: text.Text,
691 })
692 case "thinking":
693 reasoning, ok := block.AsAny().(anthropic.ThinkingBlock)
694 if !ok {
695 continue
696 }
697 content = append(content, ai.ReasoningContent{
698 Text: reasoning.Thinking,
699 ProviderMetadata: map[string]map[string]any{
700 "anthropic": {
701 "signature": reasoning.Signature,
702 },
703 },
704 })
705 case "redacted_thinking":
706 reasoning, ok := block.AsAny().(anthropic.RedactedThinkingBlock)
707 if !ok {
708 continue
709 }
710 content = append(content, ai.ReasoningContent{
711 Text: "",
712 ProviderMetadata: map[string]map[string]any{
713 "anthropic": {
714 "redacted_data": reasoning.Data,
715 },
716 },
717 })
718 case "tool_use":
719 toolUse, ok := block.AsAny().(anthropic.ToolUseBlock)
720 if !ok {
721 continue
722 }
723 content = append(content, ai.ToolCallContent{
724 ToolCallID: toolUse.ID,
725 ToolName: toolUse.Name,
726 Input: string(toolUse.Input),
727 ProviderExecuted: false,
728 })
729 }
730 }
731
732 return &ai.Response{
733 Content: content,
734 Usage: ai.Usage{
735 InputTokens: response.Usage.InputTokens,
736 OutputTokens: response.Usage.OutputTokens,
737 TotalTokens: response.Usage.InputTokens + response.Usage.OutputTokens,
738 CacheCreationTokens: response.Usage.CacheCreationInputTokens,
739 CacheReadTokens: response.Usage.CacheReadInputTokens,
740 },
741 FinishReason: mapAnthropicFinishReason(string(response.StopReason)),
742 ProviderMetadata: ai.ProviderMetadata{
743 "anthropic": make(map[string]any),
744 },
745 Warnings: warnings,
746 }, nil
747}
748
749// Stream implements ai.LanguageModel.
750func (a anthropicLanguageModel) Stream(ctx context.Context, call ai.Call) (ai.StreamResponse, error) {
751 params, warnings, err := a.prepareParams(call)
752 if err != nil {
753 return nil, err
754 }
755
756 stream := a.client.Messages.NewStreaming(ctx, *params)
757 acc := anthropic.Message{}
758 return func(yield func(ai.StreamPart) bool) {
759 if len(warnings) > 0 {
760 if !yield(ai.StreamPart{
761 Type: ai.StreamPartTypeWarnings,
762 Warnings: warnings,
763 }) {
764 return
765 }
766 }
767
768 for stream.Next() {
769 chunk := stream.Current()
770 acc.Accumulate(chunk)
771 switch chunk.Type {
772 case "content_block_start":
773 contentBlockType := chunk.ContentBlock.Type
774 switch contentBlockType {
775 case "text":
776 if !yield(ai.StreamPart{
777 Type: ai.StreamPartTypeTextStart,
778 ID: fmt.Sprintf("%d", chunk.Index),
779 }) {
780 return
781 }
782 case "thinking":
783 if !yield(ai.StreamPart{
784 Type: ai.StreamPartTypeReasoningStart,
785 ID: fmt.Sprintf("%d", chunk.Index),
786 }) {
787 return
788 }
789 case "redacted_thinking":
790 if !yield(ai.StreamPart{
791 Type: ai.StreamPartTypeReasoningStart,
792 ID: fmt.Sprintf("%d", chunk.Index),
793 ProviderMetadata: ai.ProviderMetadata{
794 "anthropic": {
795 "redacted_data": chunk.ContentBlock.Data,
796 },
797 },
798 }) {
799 return
800 }
801 case "tool_use":
802 if !yield(ai.StreamPart{
803 Type: ai.StreamPartTypeToolInputStart,
804 ID: chunk.ContentBlock.ID,
805 ToolCallName: chunk.ContentBlock.Name,
806 ToolCallInput: "",
807 }) {
808 return
809 }
810 }
811 case "content_block_stop":
812 if len(acc.Content)-1 < int(chunk.Index) {
813 continue
814 }
815 contentBlock := acc.Content[int(chunk.Index)]
816 switch contentBlock.Type {
817 case "text":
818 if !yield(ai.StreamPart{
819 Type: ai.StreamPartTypeTextEnd,
820 ID: fmt.Sprintf("%d", chunk.Index),
821 }) {
822 return
823 }
824 case "thinking":
825 if !yield(ai.StreamPart{
826 Type: ai.StreamPartTypeReasoningEnd,
827 ID: fmt.Sprintf("%d", chunk.Index),
828 }) {
829 return
830 }
831 case "tool_use":
832 if !yield(ai.StreamPart{
833 Type: ai.StreamPartTypeToolInputEnd,
834 ID: contentBlock.ID,
835 }) {
836 return
837 }
838 if !yield(ai.StreamPart{
839 Type: ai.StreamPartTypeToolCall,
840 ID: contentBlock.ID,
841 ToolCallName: contentBlock.Name,
842 ToolCallInput: string(contentBlock.Input),
843 }) {
844 return
845 }
846
847 }
848 case "content_block_delta":
849 switch chunk.Delta.Type {
850 case "text_delta":
851 if !yield(ai.StreamPart{
852 Type: ai.StreamPartTypeTextDelta,
853 ID: fmt.Sprintf("%d", chunk.Index),
854 Delta: chunk.Delta.Text,
855 }) {
856 return
857 }
858 case "thinking_delta":
859 if !yield(ai.StreamPart{
860 Type: ai.StreamPartTypeReasoningDelta,
861 ID: fmt.Sprintf("%d", chunk.Index),
862 Delta: chunk.Delta.Text,
863 }) {
864 return
865 }
866 case "signature_delta":
867 if !yield(ai.StreamPart{
868 Type: ai.StreamPartTypeReasoningDelta,
869 ID: fmt.Sprintf("%d", chunk.Index),
870 ProviderMetadata: ai.ProviderMetadata{
871 "anthropic": {
872 "signature": chunk.Delta.Signature,
873 },
874 },
875 }) {
876 return
877 }
878 case "input_json_delta":
879 if len(acc.Content)-1 < int(chunk.Index) {
880 continue
881 }
882 contentBlock := acc.Content[int(chunk.Index)]
883 if !yield(ai.StreamPart{
884 Type: ai.StreamPartTypeToolInputDelta,
885 ID: contentBlock.ID,
886 ToolCallInput: chunk.Delta.PartialJSON,
887 }) {
888 return
889 }
890
891 }
892 case "message_stop":
893 }
894 }
895
896 err := stream.Err()
897 if err == nil || errors.Is(err, io.EOF) {
898 yield(ai.StreamPart{
899 Type: ai.StreamPartTypeFinish,
900 ID: acc.ID,
901 FinishReason: mapAnthropicFinishReason(string(acc.StopReason)),
902 Usage: ai.Usage{
903 InputTokens: acc.Usage.InputTokens,
904 OutputTokens: acc.Usage.OutputTokens,
905 TotalTokens: acc.Usage.InputTokens + acc.Usage.OutputTokens,
906 CacheCreationTokens: acc.Usage.CacheCreationInputTokens,
907 CacheReadTokens: acc.Usage.CacheReadInputTokens,
908 },
909 ProviderMetadata: ai.ProviderMetadata{
910 "anthropic": make(map[string]any),
911 },
912 })
913 return
914 } else {
915 yield(ai.StreamPart{
916 Type: ai.StreamPartTypeError,
917 Error: a.handleError(err),
918 })
919 return
920 }
921 }, nil
922}