@tanstack/ai-anthropic 0.7.4 → 0.8.0

package/src/adapters/text.ts

@@ -9,6 +9,7 @@ import {
 import type {
   ANTHROPIC_MODELS,
   AnthropicChatModelProviderOptionsByName,
+  AnthropicChatModelToolCapabilitiesByName,
   AnthropicModelInputModalitiesByName,
 } from '../model-meta'
 import type {
@@ -45,6 +46,11 @@ import type {
 } from '../message-types'
 import type { AnthropicClientConfig } from '../utils'
 
+/** Cast an event object to StreamChunk. Adapters construct events with string
+ *  literal types which are structurally compatible with the EventType enum. */
+const asChunk = (chunk: Record<string, unknown>) =>
+  chunk as unknown as StreamChunk
+
 /**
  * Configuration for Anthropic text adapter
  */
@@ -84,6 +90,11 @@ type ResolveInputModalities<TModel extends string> =
     ? AnthropicModelInputModalitiesByName[TModel]
     : readonly ['text', 'image', 'document']
 
+type ResolveToolCapabilities<TModel extends string> =
+  TModel extends keyof AnthropicChatModelToolCapabilitiesByName
+    ? NonNullable<AnthropicChatModelToolCapabilitiesByName[TModel]>
+    : readonly []
+
 // ===========================
 // Adapter Implementation
 // ===========================
@@ -96,14 +107,17 @@ type ResolveInputModalities<TModel extends string> =
  */
 export class AnthropicTextAdapter<
   TModel extends (typeof ANTHROPIC_MODELS)[number],
-  TProviderOptions extends object = ResolveProviderOptions<TModel>,
+  TProviderOptions extends Record<string, any> = ResolveProviderOptions<TModel>,
   TInputModalities extends ReadonlyArray<Modality> =
     ResolveInputModalities<TModel>,
+  TToolCapabilities extends ReadonlyArray<string> =
+    ResolveToolCapabilities<TModel>,
 > extends BaseTextAdapter<
   TModel,
   TProviderOptions,
   TInputModalities,
-  AnthropicMessageMetadataByModality
+  AnthropicMessageMetadataByModality,
+  TToolCapabilities
 > {
   readonly kind = 'text' as const
   readonly name = 'anthropic' as const
@@ -116,7 +130,7 @@ export class AnthropicTextAdapter<
   }
 
   async *chatStream(
-    options: TextOptions<AnthropicTextProviderOptions>,
+    options: TextOptions<TProviderOptions>,
   ): AsyncIterable<StreamChunk> {
     try {
       const requestParams = this.mapCommonOptionsToAnthropic(options)
@@ -129,20 +143,22 @@ export class AnthropicTextAdapter<
         },
       )
 
-      yield* this.processAnthropicStream(stream, options.model, () =>
+      yield* this.processAnthropicStream(stream, options, () =>
         generateId(this.name),
       )
     } catch (error: unknown) {
       const err = error as Error & { status?: number; code?: string }
-      yield {
+      yield asChunk({
         type: 'RUN_ERROR',
         model: options.model,
         timestamp: Date.now(),
+        message: err.message || 'Unknown error occurred',
+        code: err.code || String(err.status),
         error: {
           message: err.message || 'Unknown error occurred',
           code: err.code || String(err.status),
         },
-      }
+      })
     }
   }
 
@@ -153,7 +169,7 @@ export class AnthropicTextAdapter<
    * The outputSchema is already JSON Schema (converted in the ai layer).
    */
   async structuredOutput(
-    options: StructuredOutputOptions<AnthropicTextProviderOptions>,
+    options: StructuredOutputOptions<TProviderOptions>,
   ): Promise<StructuredOutputResult<unknown>> {
     const { chatOptions, outputSchema } = options
 
@@ -523,9 +539,10 @@ export class AnthropicTextAdapter<
 
   private async *processAnthropicStream(
     stream: AsyncIterable<Anthropic_SDK.Beta.BetaRawMessageStreamEvent>,
-    model: string,
+    options: TextOptions<AnthropicTextProviderOptions>,
     genId: () => string,
   ): AsyncIterable<StreamChunk> {
+    const model = options.model
     let accumulatedContent = ''
     let accumulatedThinking = ''
     const timestamp = Date.now()
@@ -536,9 +553,12 @@ export class AnthropicTextAdapter<
     let currentToolIndex = -1
 
     // AG-UI lifecycle tracking
-    const runId = genId()
+    const runId = options.runId ?? genId()
+    const threadId = options.threadId ?? genId()
     const messageId = genId()
     let stepId: string | null = null
+    let reasoningMessageId: string | null = null
+    let hasClosedReasoning = false
     let hasEmittedRunStarted = false
     let hasEmittedTextMessageStart = false
     let hasEmittedRunFinished = false
@@ -550,12 +570,13 @@ export class AnthropicTextAdapter<
         // Emit RUN_STARTED on first event
         if (!hasEmittedRunStarted) {
           hasEmittedRunStarted = true
-          yield {
+          yield asChunk({
             type: 'RUN_STARTED',
             runId,
+            threadId,
             model,
             timestamp,
-          }
+          })
         }
 
         if (event.type === 'content_block_start') {
@@ -570,77 +591,126 @@ export class AnthropicTextAdapter<
             })
           } else if (event.content_block.type === 'thinking') {
             accumulatedThinking = ''
-            // Emit STEP_STARTED for thinking
+            // Emit REASONING and STEP_STARTED for thinking
             stepId = genId()
-            yield {
+            reasoningMessageId = genId()
+
+            // Spec REASONING events
+            yield asChunk({
+              type: 'REASONING_START',
+              messageId: reasoningMessageId,
+              model,
+              timestamp,
+            })
+            yield asChunk({
+              type: 'REASONING_MESSAGE_START',
+              messageId: reasoningMessageId,
+              role: 'reasoning' as const,
+              model,
+              timestamp,
+            })
+
+            // Legacy STEP events (kept during transition)
+            yield asChunk({
               type: 'STEP_STARTED',
+              stepName: stepId,
               stepId,
               model,
               timestamp,
               stepType: 'thinking',
-            }
+            })
           }
         } else if (event.type === 'content_block_delta') {
           if (event.delta.type === 'text_delta') {
+            // Close reasoning before text starts
+            if (reasoningMessageId && !hasClosedReasoning) {
+              hasClosedReasoning = true
+              yield asChunk({
+                type: 'REASONING_MESSAGE_END',
+                messageId: reasoningMessageId,
+                model,
+                timestamp,
+              })
+              yield asChunk({
+                type: 'REASONING_END',
+                messageId: reasoningMessageId,
+                model,
+                timestamp,
+              })
+            }
+
             // Emit TEXT_MESSAGE_START on first text content
             if (!hasEmittedTextMessageStart) {
               hasEmittedTextMessageStart = true
-              yield {
+              yield asChunk({
                 type: 'TEXT_MESSAGE_START',
                 messageId,
                 model,
                 timestamp,
                 role: 'assistant',
-              }
+              })
             }
 
             const delta = event.delta.text
             accumulatedContent += delta
-            yield {
+            yield asChunk({
               type: 'TEXT_MESSAGE_CONTENT',
               messageId,
               model,
               timestamp,
               delta,
               content: accumulatedContent,
-            }
+            })
           } else if (event.delta.type === 'thinking_delta') {
             const delta = event.delta.thinking
             accumulatedThinking += delta
-            yield {
+
+            // Spec REASONING content event
+            yield asChunk({
+              type: 'REASONING_MESSAGE_CONTENT',
+              messageId: reasoningMessageId!,
+              delta,
+              model,
+              timestamp,
+            })
+
+            // Legacy STEP event
+            yield asChunk({
               type: 'STEP_FINISHED',
+              stepName: stepId || genId(),
               stepId: stepId || genId(),
               model,
               timestamp,
               delta,
               content: accumulatedThinking,
-            }
+            })
           } else if (event.delta.type === 'input_json_delta') {
             const existing = toolCallsMap.get(currentToolIndex)
             if (existing) {
               // Emit TOOL_CALL_START on first args delta
               if (!existing.started) {
                 existing.started = true
-                yield {
+                yield asChunk({
                   type: 'TOOL_CALL_START',
                   toolCallId: existing.id,
+                  toolCallName: existing.name,
                   toolName: existing.name,
                   model,
                   timestamp,
                   index: currentToolIndex,
-                }
+                })
               }
 
               existing.input += event.delta.partial_json
 
-              yield {
+              yield asChunk({
                 type: 'TOOL_CALL_ARGS',
                 toolCallId: existing.id,
                 model,
                 timestamp,
                 delta: event.delta.partial_json,
                 args: existing.input,
-              }
+              })
             }
           }
         } else if (event.type === 'content_block_stop') {
@@ -650,14 +720,15 @@ export class AnthropicTextAdapter<
               // If tool call wasn't started yet (no args), start it now
               if (!existing.started) {
                 existing.started = true
-                yield {
+                yield asChunk({
                   type: 'TOOL_CALL_START',
                   toolCallId: existing.id,
+                  toolCallName: existing.name,
                   toolName: existing.name,
                   model,
                   timestamp,
                   index: currentToolIndex,
-                }
+                })
               }
 
               // Emit TOOL_CALL_END
@@ -669,14 +740,15 @@ export class AnthropicTextAdapter<
                 parsedInput = {}
               }
 
-              yield {
+              yield asChunk({
                 type: 'TOOL_CALL_END',
                 toolCallId: existing.id,
+                toolCallName: existing.name,
                 toolName: existing.name,
                 model,
                 timestamp,
                 input: parsedInput,
-              }
+              })
 
               // Reset so a new TEXT_MESSAGE_START is emitted if text follows tool calls
               hasEmittedTextMessageStart = false
@@ -684,36 +756,73 @@ export class AnthropicTextAdapter<
           } else {
             // Emit TEXT_MESSAGE_END only for text blocks (not tool_use blocks)
             if (hasEmittedTextMessageStart && accumulatedContent) {
-              yield {
+              yield asChunk({
                 type: 'TEXT_MESSAGE_END',
                 messageId,
                 model,
                 timestamp,
-              }
+              })
             }
           }
           currentBlockType = null
         } else if (event.type === 'message_stop') {
+          // Close reasoning events if still open
+          if (reasoningMessageId && !hasClosedReasoning) {
+            hasClosedReasoning = true
+            yield asChunk({
+              type: 'REASONING_MESSAGE_END',
+              messageId: reasoningMessageId,
+              model,
+              timestamp,
+            })
+            yield asChunk({
+              type: 'REASONING_END',
+              messageId: reasoningMessageId,
+              model,
+              timestamp,
+            })
+          }
+
           // Only emit RUN_FINISHED from message_stop if message_delta didn't already emit one.
           // message_delta carries the real stop_reason (tool_use, end_turn, etc.),
           // while message_stop is just a completion signal.
           if (!hasEmittedRunFinished) {
-            yield {
+            yield asChunk({
               type: 'RUN_FINISHED',
               runId,
+              threadId,
               model,
               timestamp,
               finishReason: 'stop',
-            }
+            })
           }
         } else if (event.type === 'message_delta') {
           if (event.delta.stop_reason) {
             hasEmittedRunFinished = true
+
+            // Close reasoning events if still open
+            if (reasoningMessageId && !hasClosedReasoning) {
+              hasClosedReasoning = true
+              yield asChunk({
+                type: 'REASONING_MESSAGE_END',
+                messageId: reasoningMessageId,
+                model,
+                timestamp,
+              })
+              yield asChunk({
+                type: 'REASONING_END',
+                messageId: reasoningMessageId,
+                model,
+                timestamp,
+              })
+            }
+
             switch (event.delta.stop_reason) {
               case 'tool_use': {
-                yield {
+                yield asChunk({
                   type: 'RUN_FINISHED',
                   runId,
+                  threadId,
                   model,
                   timestamp,
                   finishReason: 'tool_calls',
@@ -724,27 +833,31 @@ export class AnthropicTextAdapter<
                       (event.usage.input_tokens || 0) +
                       (event.usage.output_tokens || 0),
                   },
-                }
+                })
                 break
               }
               case 'max_tokens': {
-                yield {
+                yield asChunk({
                   type: 'RUN_ERROR',
                   runId,
                   model,
                   timestamp,
+                  message:
+                    'The response was cut off because the maximum token limit was reached.',
+                  code: 'max_tokens',
                   error: {
                     message:
                       'The response was cut off because the maximum token limit was reached.',
                     code: 'max_tokens',
                   },
-                }
+                })
                 break
               }
               default: {
-                yield {
+                yield asChunk({
                   type: 'RUN_FINISHED',
                   runId,
+                  threadId,
                   model,
                   timestamp,
                   finishReason: 'stop',
@@ -755,7 +868,7 @@ export class AnthropicTextAdapter<
                       (event.usage.input_tokens || 0) +
                       (event.usage.output_tokens || 0),
                   },
-                }
+                })
               }
             }
           }
@@ -764,16 +877,18 @@ export class AnthropicTextAdapter<
     } catch (error: unknown) {
       const err = error as Error & { status?: number; code?: string }
 
-      yield {
+      yield asChunk({
         type: 'RUN_ERROR',
         runId,
         model,
         timestamp,
+        message: err.message || 'Unknown error occurred',
+        code: err.code || String(err.status),
         error: {
           message: err.message || 'Unknown error occurred',
           code: err.code || String(err.status),
         },
-      }
+      })
     }
   }
 }

package/src/index.ts

@@ -24,9 +24,10 @@ export {
 // ============================================================================
 
 export type {
+  AnthropicChatModel,
   AnthropicChatModelProviderOptionsByName,
+  AnthropicChatModelToolCapabilitiesByName,
   AnthropicModelInputModalitiesByName,
-  AnthropicChatModel,
 } from './model-meta'
 export { ANTHROPIC_MODELS } from './model-meta'
 export type {

package/src/model-meta.ts

@@ -21,6 +21,15 @@ interface ModelMeta<
     extended_thinking?: boolean
     adaptive_thinking?: boolean
     priority_tier?: boolean
+    tools?: Array<
+      | 'web_search'
+      | 'web_fetch'
+      | 'code_execution'
+      | 'computer_use'
+      | 'bash'
+      | 'text_editor'
+      | 'memory'
+    >
   }
   context_window?: number
   max_output_tokens?: number
@@ -66,6 +75,15 @@ const CLAUDE_OPUS_4_6 = {
     input: ['text', 'image', 'document'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -96,6 +114,15 @@ const CLAUDE_OPUS_4_5 = {
     input: ['text', 'image', 'document'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -127,6 +154,15 @@ const CLAUDE_SONNET_4_6 = {
     extended_thinking: true,
     adaptive_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -157,6 +193,15 @@ const CLAUDE_SONNET_4_5 = {
     input: ['text', 'image', 'document'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -187,6 +232,15 @@ const CLAUDE_HAIKU_4_5 = {
     input: ['text', 'image', 'document'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -217,6 +271,15 @@ const CLAUDE_OPUS_4_1 = {
     input: ['text', 'image', 'document'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -247,6 +310,15 @@ const CLAUDE_SONNET_4 = {
     input: ['text', 'image', 'document'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -276,6 +348,15 @@ const CLAUDE_SONNET_3_7 = {
     input: ['text', 'image', 'document'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -306,6 +387,15 @@ const CLAUDE_OPUS_4 = {
     input: ['text', 'image', 'document'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -336,6 +426,7 @@ const CLAUDE_HAIKU_3_5 = {
     input: ['text', 'image', 'document'],
     extended_thinking: false,
     priority_tier: true,
+    tools: ['web_search', 'web_fetch'],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -366,6 +457,7 @@ const CLAUDE_HAIKU_3 = {
     input: ['text', 'image', 'document'],
     extended_thinking: false,
     priority_tier: false,
+    tools: ['web_search'],
   },
 } as const satisfies ModelMeta<
   AnthropicContainerOptions &
@@ -432,6 +524,15 @@ const CLAUDE_OPUS_4_6_FAST = {
     input: ['text', 'image'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
   pricing: {
     input: {
@@ -462,6 +563,15 @@ const CLAUDE_OPUS_4_7 = {
     input: ['text', 'image'],
     extended_thinking: true,
     priority_tier: true,
+    tools: [
+      'web_search',
+      'web_fetch',
+      'code_execution',
+      'computer_use',
+      'bash',
+      'text_editor',
+      'memory',
+    ],
   },
   pricing: {
     input: {
@@ -619,6 +729,22 @@ export type AnthropicChatModelProviderOptionsByName = {
     AnthropicSamplingOptions
 }
 
+export type AnthropicChatModelToolCapabilitiesByName = {
+  [CLAUDE_OPUS_4_6.id]: typeof CLAUDE_OPUS_4_6.supports.tools
+  [CLAUDE_OPUS_4_5.id]: typeof CLAUDE_OPUS_4_5.supports.tools
+  [CLAUDE_SONNET_4_6.id]: typeof CLAUDE_SONNET_4_6.supports.tools
+  [CLAUDE_SONNET_4_5.id]: typeof CLAUDE_SONNET_4_5.supports.tools
+  [CLAUDE_HAIKU_4_5.id]: typeof CLAUDE_HAIKU_4_5.supports.tools
+  [CLAUDE_OPUS_4_1.id]: typeof CLAUDE_OPUS_4_1.supports.tools
+  [CLAUDE_SONNET_4.id]: typeof CLAUDE_SONNET_4.supports.tools
+  [CLAUDE_SONNET_3_7.id]: typeof CLAUDE_SONNET_3_7.supports.tools
+  [CLAUDE_OPUS_4.id]: typeof CLAUDE_OPUS_4.supports.tools
+  [CLAUDE_HAIKU_3_5.id]: typeof CLAUDE_HAIKU_3_5.supports.tools
+  [CLAUDE_HAIKU_3.id]: typeof CLAUDE_HAIKU_3.supports.tools
+  [CLAUDE_OPUS_4_6_FAST.id]: typeof CLAUDE_OPUS_4_6_FAST.supports.tools
+  [CLAUDE_OPUS_4_7.id]: typeof CLAUDE_OPUS_4_7.supports.tools
+}
+
 /**
  * Type-only map from chat model name to its supported input modalities.
  * All Anthropic Claude models support text, image, and document (PDF) input.