@tanstack/ai-anthropic 0.0.3 → 0.2.0

package/src/{anthropic-adapter.ts → adapters/text.ts}

@@ -1,32 +1,20 @@
-import Anthropic_SDK from '@anthropic-ai/sdk'
-import { BaseAdapter } from '@tanstack/ai'
-import { ANTHROPIC_MODELS } from './model-meta'
-import { convertToolsToProviderFormat } from './tools/tool-converter'
-import { validateTextProviderOptions } from './text/text-provider-options'
-import type {
-  AnthropicDocumentMetadata,
-  AnthropicImageMetadata,
-  AnthropicMessageMetadataByModality,
-  AnthropicTextMetadata,
-} from './message-types'
-import type {
-  ChatOptions,
-  ContentPart,
-  EmbeddingOptions,
-  EmbeddingResult,
-  ModelMessage,
-  StreamChunk,
-  SummarizationOptions,
-  SummarizationResult,
-} from '@tanstack/ai'
+import { BaseTextAdapter } from '@tanstack/ai/adapters'
+import { convertToolsToProviderFormat } from '../tools/tool-converter'
+import { validateTextProviderOptions } from '../text/text-provider-options'
+import {
+  createAnthropicClient,
+  generateId,
+  getAnthropicApiKeyFromEnv,
+} from '../utils'
 import type {
+  ANTHROPIC_MODELS,
   AnthropicChatModelProviderOptionsByName,
   AnthropicModelInputModalitiesByName,
-} from './model-meta'
+} from '../model-meta'
 import type {
-  ExternalTextProviderOptions,
-  InternalTextProviderOptions,
-} from './text/text-provider-options'
+  StructuredOutputOptions,
+  StructuredOutputResult,
+} from '@tanstack/ai/adapters'
 import type {
   Base64ImageSource,
   Base64PDFSource,
@@ -37,16 +25,35 @@ import type {
   URLImageSource,
   URLPDFSource,
 } from '@anthropic-ai/sdk/resources/messages'
+import type Anthropic_SDK from '@anthropic-ai/sdk'
+import type {
+  ContentPart,
+  Modality,
+  ModelMessage,
+  StreamChunk,
+  TextOptions,
+} from '@tanstack/ai'
+import type {
+  ExternalTextProviderOptions,
+  InternalTextProviderOptions,
+} from '../text/text-provider-options'
+import type {
+  AnthropicDocumentMetadata,
+  AnthropicImageMetadata,
+  AnthropicMessageMetadataByModality,
+  AnthropicTextMetadata,
+} from '../message-types'
+import type { AnthropicClientConfig } from '../utils'
 
-export interface AnthropicConfig {
-  apiKey: string
-}
+/**
+ * Configuration for Anthropic text adapter
+ */
+export interface AnthropicTextConfig extends AnthropicClientConfig {}
 
 /**
- * Anthropic-specific provider options
- * @see https://ai-sdk.dev/providers/ai-sdk-providers/anthropic
+ * Anthropic-specific provider options for text/chat
  */
-export type AnthropicProviderOptions = ExternalTextProviderOptions
+export type AnthropicTextProviderOptions = ExternalTextProviderOptions
 
 type AnthropicContentBlocks =
   Extract<MessageParam['content'], Array<unknown>> extends Array<infer Block>
@@ -55,36 +62,63 @@ type AnthropicContentBlocks =
 type AnthropicContentBlock =
   AnthropicContentBlocks extends Array<infer Block> ? Block : never
 
-export class Anthropic extends BaseAdapter<
-  typeof ANTHROPIC_MODELS,
-  [],
-  AnthropicProviderOptions,
-  Record<string, any>,
-  AnthropicChatModelProviderOptionsByName,
-  AnthropicModelInputModalitiesByName,
+// ===========================
+// Type Resolution Helpers
+// ===========================
+
+/**
+ * Resolve provider options for a specific model.
+ * If the model has explicit options in the map, use those; otherwise use base options.
+ */
+type ResolveProviderOptions<TModel extends string> =
+  TModel extends keyof AnthropicChatModelProviderOptionsByName
+    ? AnthropicChatModelProviderOptionsByName[TModel]
+    : AnthropicTextProviderOptions
+
+/**
+ * Resolve input modalities for a specific model.
+ * If the model has explicit modalities in the map, use those; otherwise use default.
+ */
+type ResolveInputModalities<TModel extends string> =
+  TModel extends keyof AnthropicModelInputModalitiesByName
+    ? AnthropicModelInputModalitiesByName[TModel]
+    : readonly ['text', 'image', 'document']
+
+// ===========================
+// Adapter Implementation
+// ===========================
+
+/**
+ * Anthropic Text (Chat) Adapter
+ *
+ * Tree-shakeable adapter for Anthropic chat/text completion functionality.
+ * Import only what you need for smaller bundle sizes.
+ */
+export class AnthropicTextAdapter<
+  TModel extends (typeof ANTHROPIC_MODELS)[number],
+  TProviderOptions extends object = ResolveProviderOptions<TModel>,
+  TInputModalities extends ReadonlyArray<Modality> =
+    ResolveInputModalities<TModel>,
+> extends BaseTextAdapter<
+  TModel,
+  TProviderOptions,
+  TInputModalities,
   AnthropicMessageMetadataByModality
 > {
-  name = 'anthropic' as const
-  models = ANTHROPIC_MODELS
-
-  declare _modelProviderOptionsByName: AnthropicChatModelProviderOptionsByName
-  declare _modelInputModalitiesByName: AnthropicModelInputModalitiesByName
-  declare _messageMetadataByModality: AnthropicMessageMetadataByModality
+  readonly kind = 'text' as const
+  readonly name = 'anthropic' as const
 
   private client: Anthropic_SDK
 
-  constructor(config: AnthropicConfig) {
-    super({})
-    this.client = new Anthropic_SDK({
-      apiKey: config.apiKey,
-    })
+  constructor(config: AnthropicTextConfig, model: TModel) {
+    super({}, model)
+    this.client = createAnthropicClient(config)
   }
 
   async *chatStream(
-    options: ChatOptions<string, AnthropicProviderOptions>,
+    options: TextOptions<AnthropicTextProviderOptions>,
   ): AsyncIterable<StreamChunk> {
     try {
-      // Map common options to Anthropic format using the centralized mapping function
       const requestParams = this.mapCommonOptionsToAnthropic(options)
 
       const stream = await this.client.beta.messages.create(
@@ -96,105 +130,111 @@ export class Anthropic extends BaseAdapter<
       )
 
       yield* this.processAnthropicStream(stream, options.model, () =>
-        this.generateId(),
+        generateId(this.name),
       )
-    } catch (error: any) {
-      console.error('[Anthropic Adapter] Error in chatStream:', {
-        message: error?.message,
-        status: error?.status,
-        statusText: error?.statusText,
-        code: error?.code,
-        type: error?.type,
-        error: error,
-        stack: error?.stack,
-      })
-
-      // Emit an error chunk
+    } catch (error: unknown) {
+      const err = error as Error & { status?: number; code?: string }
       yield {
         type: 'error',
-        id: this.generateId(),
+        id: generateId(this.name),
         model: options.model,
         timestamp: Date.now(),
         error: {
-          message: error?.message || 'Unknown error occurred',
-          code: error?.code || error?.status,
+          message: err.message || 'Unknown error occurred',
+          code: err.code || String(err.status),
         },
       }
     }
   }
 
-  async summarize(options: SummarizationOptions): Promise<SummarizationResult> {
-    const systemPrompt = this.buildSummarizationPrompt(options)
-
-    const response = await this.client.messages.create({
-      model: options.model,
-      messages: [{ role: 'user', content: options.text }],
-      system: systemPrompt,
-      max_tokens: options.maxLength || 500,
-      temperature: 0.3,
-      stream: false,
-    })
-
-    const content = response.content
-      .map((c) => (c.type === 'text' ? c.text : ''))
-      .join('')
-
-    return {
-      id: response.id,
-      model: response.model,
-      summary: content,
-      usage: {
-        promptTokens: response.usage.input_tokens,
-        completionTokens: response.usage.output_tokens,
-        totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+  /**
+   * Generate structured output using Anthropic's tool-based approach.
+   * Anthropic doesn't have native structured output, so we use a tool with the schema
+   * and force the model to call it.
+   * The outputSchema is already JSON Schema (converted in the ai layer).
+   */
+  async structuredOutput(
+    options: StructuredOutputOptions<AnthropicTextProviderOptions>,
+  ): Promise<StructuredOutputResult<unknown>> {
+    const { chatOptions, outputSchema } = options
+
+    const requestParams = this.mapCommonOptionsToAnthropic(chatOptions)
+
+    // Create a tool that will capture the structured output
+    // Anthropic's SDK requires input_schema with type: 'object' literal
+    const structuredOutputTool = {
+      name: 'structured_output',
+      description:
+        'Use this tool to provide your response in the required structured format.',
+      input_schema: {
+        type: 'object' as const,
+        properties: outputSchema.properties ?? {},
+        required: outputSchema.required ?? [],
       },
     }
-  }
 
-  createEmbeddings(_options: EmbeddingOptions): Promise<EmbeddingResult> {
-    // Note: Anthropic doesn't have a native embeddings API
-    // You would need to use a different service or implement a workaround
-    throw new Error(
-      'Embeddings are not natively supported by Anthropic. Consider using OpenAI or another provider for embeddings.',
-    )
-  }
+    try {
+      // Make non-streaming request with tool_choice forced to our structured output tool
+      const response = await this.client.messages.create(
+        {
+          ...requestParams,
+          stream: false,
+          tools: [structuredOutputTool],
+          tool_choice: { type: 'tool', name: 'structured_output' },
+        },
+        {
+          signal: chatOptions.request?.signal,
+          headers: chatOptions.request?.headers,
+        },
+      )
 
-  private buildSummarizationPrompt(options: SummarizationOptions): string {
-    let prompt = 'You are a professional summarizer. '
-
-    switch (options.style) {
-      case 'bullet-points':
-        prompt += 'Provide a summary in bullet point format. '
-        break
-      case 'paragraph':
-        prompt += 'Provide a summary in paragraph format. '
-        break
-      case 'concise':
-        prompt += 'Provide a very concise summary in 1-2 sentences. '
-        break
-      default:
-        prompt += 'Provide a clear and concise summary. '
-    }
+      // Extract the tool use content from the response
+      let parsed: unknown = null
+      let rawText = ''
 
-    if (options.focus && options.focus.length > 0) {
-      prompt += `Focus on the following aspects: ${options.focus.join(', ')}. `
-    }
+      for (const block of response.content) {
+        if (block.type === 'tool_use' && block.name === 'structured_output') {
+          parsed = block.input
+          rawText = JSON.stringify(block.input)
+          break
+        }
+      }
 
-    if (options.maxLength) {
-      prompt += `Keep the summary under ${options.maxLength} tokens. `
-    }
+      if (parsed === null) {
+        // Fallback: try to extract text content and parse as JSON
+        rawText = response.content
+          .map((b) => {
+            if (b.type === 'text') {
+              return b.text
+            }
+            return ''
+          })
+          .join('')
+        try {
+          parsed = JSON.parse(rawText)
+        } catch {
+          throw new Error(
+            `Failed to extract structured output from response. Content: ${rawText.slice(0, 200)}${rawText.length > 200 ? '...' : ''}`,
+          )
+        }
+      }
 
-    return prompt
+      return {
+        data: parsed,
+        rawText,
+      }
+    } catch (error: unknown) {
+      const err = error as Error
+      throw new Error(
+        `Structured output generation failed: ${err.message || 'Unknown error occurred'}`,
+      )
+    }
   }
 
-  /**
-   * Maps common options to Anthropic-specific format
-   * Handles translation of normalized options to Anthropic's API format
-   */
   private mapCommonOptionsToAnthropic(
-    options: ChatOptions<string, AnthropicProviderOptions>,
+    options: TextOptions<AnthropicTextProviderOptions>,
   ) {
-    const providerOptions = options.providerOptions as
+    const modelOptions = options.modelOptions as
       | InternalTextProviderOptions
       | undefined
 
@@ -203,9 +243,8 @@ export class Anthropic extends BaseAdapter<
       ? convertToolsToProviderFormat(options.tools)
       : undefined
 
-    // Filter out invalid fields from providerOptions (like 'store' which is OpenAI-specific)
     const validProviderOptions: Partial<InternalTextProviderOptions> = {}
-    if (providerOptions) {
+    if (modelOptions) {
       const validKeys: Array<keyof InternalTextProviderOptions> = [
         'container',
         'context_management',
@@ -218,34 +257,34 @@ export class Anthropic extends BaseAdapter<
         'top_k',
       ]
       for (const key of validKeys) {
-        if (key in providerOptions) {
-          const value = providerOptions[key]
-          // Anthropic expects tool_choice to be an object, not a string
+        if (key in modelOptions) {
+          const value = modelOptions[key]
           if (key === 'tool_choice' && typeof value === 'string') {
-            ;(validProviderOptions as any)[key] = { type: value }
+            ;(validProviderOptions as Record<string, unknown>)[key] = {
+              type: value,
+            }
           } else {
-            ;(validProviderOptions as any)[key] = value
+            ;(validProviderOptions as Record<string, unknown>)[key] = value
           }
         }
       }
     }
 
-    // Ensure max_tokens is greater than thinking.budget_tokens if thinking is enabled
     const thinkingBudget =
       validProviderOptions.thinking?.type === 'enabled'
         ? validProviderOptions.thinking.budget_tokens
         : undefined
-    const defaultMaxTokens = options.options?.maxTokens || 1024
+    const defaultMaxTokens = options.maxTokens || 1024
     const maxTokens =
       thinkingBudget && thinkingBudget >= defaultMaxTokens
-        ? thinkingBudget + 1 // Ensure max_tokens is greater than budget_tokens
+        ? thinkingBudget + 1
         : defaultMaxTokens
 
     const requestParams: InternalTextProviderOptions = {
       model: options.model,
       max_tokens: maxTokens,
-      temperature: options.options?.temperature,
-      top_p: options.options?.topP,
+      temperature: options.temperature,
+      top_p: options.topP,
       messages: formattedMessages,
       system: options.systemPrompts?.join('\n'),
       tools: tools,
@@ -260,9 +299,7 @@ export class Anthropic extends BaseAdapter<
   ): TextBlockParam | ImageBlockParam | DocumentBlockParam {
     switch (part.type) {
       case 'text': {
-        const metadata = part.metadata as any as
-          | AnthropicTextMetadata
-          | undefined
+        const metadata = part.metadata as AnthropicTextMetadata | undefined
         return {
           type: 'text',
           text: part.content,
@@ -271,9 +308,7 @@ export class Anthropic extends BaseAdapter<
       }
 
       case 'image': {
-        const metadata = part.metadata as any as
-          | AnthropicImageMetadata
-          | undefined
+        const metadata = part.metadata as AnthropicImageMetadata | undefined
         const imageSource: Base64ImageSource | URLImageSource =
           part.source.type === 'data'
             ? {
@@ -285,8 +320,7 @@ export class Anthropic extends BaseAdapter<
                 type: 'url',
                 url: part.source.value,
               }
-        // exclude the media type
-        const { mediaType, ...meta } = metadata || {}
+        const { mediaType: _mediaType, ...meta } = metadata || {}
         return {
           type: 'image',
           source: imageSource,
@@ -294,9 +328,7 @@ export class Anthropic extends BaseAdapter<
         }
       }
       case 'document': {
-        const metadata = part.metadata as any as
-          | AnthropicDocumentMetadata
-          | undefined
+        const metadata = part.metadata as AnthropicDocumentMetadata | undefined
         const docSource: Base64PDFSource | URLPDFSource =
           part.source.type === 'data'
             ? {
@@ -316,12 +348,10 @@ export class Anthropic extends BaseAdapter<
       }
       case 'audio':
       case 'video':
-        // Anthropic doesn't support audio/video directly, treat as text with a note
         throw new Error(
           `Anthropic does not support ${part.type} content directly`,
         )
       default: {
-        // Exhaustive check - this should never happen with known types
         const _exhaustiveCheck: never = part
         throw new Error(
           `Unsupported content part type: ${(_exhaustiveCheck as ContentPart).type}`,
@@ -393,7 +423,6 @@ export class Anthropic extends BaseAdapter<
         continue
       }
 
-      // Handle user messages with multimodal content
       if (role === 'user' && Array.isArray(message.content)) {
         const contentBlocks = message.content.map((part) =>
           this.convertContentPartToAnthropic(part),
@@ -424,7 +453,7 @@ export class Anthropic extends BaseAdapter<
   private async *processAnthropicStream(
     stream: AsyncIterable<Anthropic_SDK.Beta.BetaRawMessageStreamEvent>,
     model: string,
-    generateId: () => string,
+    genId: () => string,
   ): AsyncIterable<StreamChunk> {
     let accumulatedContent = ''
     let accumulatedThinking = ''
@@ -446,7 +475,6 @@ export class Anthropic extends BaseAdapter<
               input: '',
             })
           } else if (event.content_block.type === 'thinking') {
-            // Reset thinking content when a new thinking block starts
             accumulatedThinking = ''
           }
         } else if (event.type === 'content_block_delta') {
@@ -455,7 +483,7 @@ export class Anthropic extends BaseAdapter<
             accumulatedContent += delta
             yield {
               type: 'content',
-              id: generateId(),
+              id: genId(),
               model: model,
               timestamp,
               delta,
@@ -463,29 +491,24 @@ export class Anthropic extends BaseAdapter<
               role: 'assistant',
             }
           } else if (event.delta.type === 'thinking_delta') {
-            // Handle thinking content
             const delta = event.delta.thinking
             accumulatedThinking += delta
             yield {
               type: 'thinking',
-              id: generateId(),
+              id: genId(),
               model: model,
               timestamp,
               delta,
               content: accumulatedThinking,
             }
           } else if (event.delta.type === 'input_json_delta') {
-            // Tool input is being streamed
             const existing = toolCallsMap.get(currentToolIndex)
             if (existing) {
-              // Accumulate the input for final processing
               existing.input += event.delta.partial_json
 
-              // Yield the DELTA (partial_json), not the full accumulated input
-              // The stream processor will concatenate these deltas
               yield {
                 type: 'tool_call',
-                id: generateId(),
+                id: genId(),
                 model: model,
                 timestamp,
                 toolCall: {
@@ -501,14 +524,11 @@ export class Anthropic extends BaseAdapter<
             }
           }
         } else if (event.type === 'content_block_stop') {
-          // If this is a tool call and we haven't received any input deltas,
-          // emit a tool_call chunk with empty arguments
           const existing = toolCallsMap.get(currentToolIndex)
           if (existing && existing.input === '') {
-            // No input_json_delta events received, emit empty arguments
             yield {
               type: 'tool_call',
-              id: generateId(),
+              id: genId(),
               model: model,
               timestamp,
               toolCall: {
@@ -525,7 +545,7 @@ export class Anthropic extends BaseAdapter<
         } else if (event.type === 'message_stop') {
           yield {
             type: 'done',
-            id: generateId(),
+            id: genId(),
             model: model,
             timestamp,
             finishReason: 'stop',
@@ -536,11 +556,10 @@ export class Anthropic extends BaseAdapter<
               case 'tool_use': {
                 yield {
                   type: 'done',
-                  id: generateId(),
+                  id: genId(),
                   model: model,
                   timestamp,
                   finishReason: 'tool_calls',
-
                   usage: {
                     promptTokens: event.usage.input_tokens || 0,
                     completionTokens: event.usage.output_tokens || 0,
@@ -554,7 +573,7 @@ export class Anthropic extends BaseAdapter<
               case 'max_tokens': {
                 yield {
                   type: 'error',
-                  id: generateId(),
+                  id: genId(),
                   model: model,
                   timestamp,
                   error: {
@@ -565,37 +584,10 @@ export class Anthropic extends BaseAdapter<
                 }
                 break
               }
-              case 'model_context_window_exceeded': {
-                yield {
-                  type: 'error',
-                  id: generateId(),
-                  model: model,
-                  timestamp,
-                  error: {
-                    message:
-                      "The response was cut off because the model's context window was exceeded.",
-                    code: 'context_window_exceeded',
-                  },
-                }
-                break
-              }
-              case 'refusal': {
-                yield {
-                  type: 'error',
-                  id: generateId(),
-                  model: model,
-                  timestamp,
-                  error: {
-                    message: 'The model refused to complete the request.',
-                    code: 'refusal',
-                  },
-                }
-                break
-              }
               default: {
                 yield {
                   type: 'done',
-                  id: generateId(),
+                  id: genId(),
                   model: model,
                   timestamp,
                   finishReason: 'stop',
@@ -612,84 +604,53 @@ export class Anthropic extends BaseAdapter<
           }
         }
       }
-    } catch (error: any) {
-      console.error('[Anthropic Adapter] Error in processAnthropicStream:', {
-        message: error?.message,
-        status: error?.status,
-        statusText: error?.statusText,
-        code: error?.code,
-        type: error?.type,
-        error: error,
-        stack: error?.stack,
-      })
+    } catch (error: unknown) {
+      const err = error as Error & { status?: number; code?: string }
 
       yield {
         type: 'error',
-        id: generateId(),
+        id: genId(),
         model: model,
         timestamp,
         error: {
-          message: error?.message || 'Unknown error occurred',
-          code: error?.code || error?.status,
+          message: err.message || 'Unknown error occurred',
+          code: err.code || String(err.status),
         },
       }
     }
   }
 }
+
 /**
- * Creates an Anthropic adapter with simplified configuration
- * @param apiKey - Your Anthropic API key
- * @returns A fully configured Anthropic adapter instance
- *
- * @example
- * ```typescript
- * const anthropic = createAnthropic("sk-ant-...");
- *
- * const ai = new AI({
- *   adapters: {
- *     anthropic,
- *   }
- * });
- * ```
+ * Creates an Anthropic chat adapter with explicit API key.
+ * Type resolution happens here at the call site.
  */
-export function createAnthropic(
+export function createAnthropicChat<
+  TModel extends (typeof ANTHROPIC_MODELS)[number],
+>(
+  model: TModel,
   apiKey: string,
-  config?: Omit<AnthropicConfig, 'apiKey'>,
-): Anthropic {
-  return new Anthropic({ apiKey, ...config })
+  config?: Omit<AnthropicTextConfig, 'apiKey'>,
+): AnthropicTextAdapter<
+  TModel,
+  ResolveProviderOptions<TModel>,
+  ResolveInputModalities<TModel>
+> {
+  return new AnthropicTextAdapter({ apiKey, ...config }, model)
 }
 
 /**
- * Create an Anthropic adapter with automatic API key detection from environment variables.
- *
- * Looks for `ANTHROPIC_API_KEY` in:
- * - `process.env` (Node.js)
- * - `window.env` (Browser with injected env)
- *
- * @param config - Optional configuration (excluding apiKey which is auto-detected)
- * @returns Configured Anthropic adapter instance
- * @throws Error if ANTHROPIC_API_KEY is not found in environment
- *
- * @example
- * ```typescript
- * // Automatically uses ANTHROPIC_API_KEY from environment
- * const aiInstance = ai(anthropic());
- * ```
+ * Creates an Anthropic text adapter with automatic API key detection.
+ * Type resolution happens here at the call site.
  */
-export function anthropic(config?: Omit<AnthropicConfig, 'apiKey'>): Anthropic {
-  const env =
-    typeof globalThis !== 'undefined' && (globalThis as any).window?.env
-      ? (globalThis as any).window.env
-      : typeof process !== 'undefined'
-        ? process.env
-        : undefined
-  const key = env?.ANTHROPIC_API_KEY
-
-  if (!key) {
-    throw new Error(
-      'ANTHROPIC_API_KEY is required. Please set it in your environment variables or use createAnthropic(apiKey, config) instead.',
-    )
-  }
-
-  return createAnthropic(key, config)
+export function anthropicText<TModel extends (typeof ANTHROPIC_MODELS)[number]>(
+  model: TModel,
+  config?: Omit<AnthropicTextConfig, 'apiKey'>,
+): AnthropicTextAdapter<
+  TModel,
+  ResolveProviderOptions<TModel>,
+  ResolveInputModalities<TModel>
+> {
+  const apiKey = getAnthropicApiKeyFromEnv()
+  return createAnthropicChat(model, apiKey, config)
 }