@tanstack/ai-anthropic 0.15.8 → 0.15.9

package/dist/esm/adapters/text.js

@@ -1,851 +0,0 @@
-import { EventType, normalizeSystemPrompts } from "@tanstack/ai";
-import { toRunErrorRawEvent } from "@tanstack/ai/adapter-internals";
-import { BaseTextAdapter } from "@tanstack/ai/adapters";
-import { convertToolsToProviderFormat } from "../tools/tool-converter.js";
-import { readCodeExecutionSkills, readCodeExecutionConfig } from "../tools/code-execution-tool.js";
-import { validateTextProviderOptions } from "../text/text-provider-options.js";
-import { buildAnthropicUsage } from "../usage.js";
-import { createAnthropicClient, generateId, getAnthropicApiKeyFromEnv } from "../utils/client.js";
-import { ANTHROPIC_COMBINED_TOOLS_AND_SCHEMA_MODELS } from "../model-meta.js";
-function computeAnthropicBetas(tools, modelOptions) {
-  const betas = /* @__PURE__ */ new Set();
-  const useInterleavedThinking = modelOptions?.thinking?.type === "enabled" && typeof modelOptions.thinking.budget_tokens === "number" && modelOptions.thinking.budget_tokens > 0;
-  if (useInterleavedThinking) betas.add("interleaved-thinking-2025-05-14");
-  const codeExecTool = tools?.find((t) => t.name === "code_execution");
-  if (codeExecTool) {
-    const cfgType = readCodeExecutionConfig(codeExecTool)?.type;
-    betas.add(
-      cfgType === "code_execution_20250522" ? "code-execution-2025-05-22" : "code-execution-2025-08-25"
-    );
-  }
-  const hasSkills = tools?.some(
-    (t) => t.name === "code_execution" && (readCodeExecutionSkills(t)?.length ?? 0) > 0
-  );
-  if (hasSkills) betas.add("skills-2025-10-02");
-  return betas.size > 0 ? Array.from(betas) : void 0;
-}
-class AnthropicTextAdapter extends BaseTextAdapter {
-  kind = "text";
-  name = "anthropic";
-  client;
-  constructor(config, model) {
-    super({}, model);
-    this.client = createAnthropicClient(config);
-  }
-  async *chatStream(options) {
-    const { logger } = options;
-    try {
-      const requestParams = this.mapCommonOptionsToAnthropic(options);
-      logger.request(
-        `activity=chat provider=anthropic model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`,
-        { provider: "anthropic", model: this.model }
-      );
-      const betas = computeAnthropicBetas(options.tools, options.modelOptions);
-      const stream = await this.client.beta.messages.create(
-        {
-          ...requestParams,
-          stream: true,
-          ...betas && { betas }
-        },
-        {
-          signal: options.request?.signal,
-          headers: options.request?.headers
-        }
-      );
-      yield* this.processAnthropicStream(
-        stream,
-        options,
-        () => generateId(this.name),
-        logger
-      );
-    } catch (error) {
-      const err = error;
-      const rawEvent = toRunErrorRawEvent(error);
-      logger.errors("anthropic.chatStream fatal", {
-        error,
-        source: "anthropic.chatStream"
-      });
-      yield {
-        type: EventType.RUN_ERROR,
-        model: options.model,
-        timestamp: Date.now(),
-        message: err.message || "Unknown error occurred",
-        code: err.code || String(err.status),
-        // Forward the Anthropic SDK error's `.error` response body (e.g.
-        // `{ type, message }`) when present; never the raw exception object.
-        ...rawEvent !== void 0 && { rawEvent },
-        error: {
-          message: err.message || "Unknown error occurred",
-          code: err.code || String(err.status)
-        }
-      };
-    }
-  }
-  /**
-   * 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) {
-    const { chatOptions, outputSchema } = options;
-    const { logger } = chatOptions;
-    const requestParams = this.mapCommonOptionsToAnthropic(chatOptions);
-    const structuredOutputTool = {
-      name: "structured_output",
-      description: "Use this tool to provide your response in the required structured format.",
-      input_schema: {
-        type: "object",
-        properties: outputSchema.properties ?? {},
-        required: outputSchema.required ?? []
-      }
-    };
-    try {
-      logger.request(
-        `activity=chat provider=anthropic model=${this.model} messages=${chatOptions.messages.length} tools=${chatOptions.tools?.length ?? 0} stream=false`,
-        { provider: "anthropic", model: this.model }
-      );
-      const betas = computeAnthropicBetas(
-        chatOptions.tools,
-        chatOptions.modelOptions
-      );
-      const response = await this.client.beta.messages.create(
-        {
-          ...requestParams,
-          stream: false,
-          tools: [structuredOutputTool],
-          tool_choice: { type: "tool", name: "structured_output" },
-          ...betas && { betas }
-        },
-        {
-          signal: chatOptions.request?.signal,
-          headers: chatOptions.request?.headers
-        }
-      );
-      let parsed = null;
-      let rawText = "";
-      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 (parsed === null) {
-        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 {
-        data: parsed,
-        rawText,
-        usage: buildAnthropicUsage(response.usage)
-      };
-    } catch (error) {
-      const err = error;
-      logger.errors("anthropic.structuredOutput fatal", {
-        error,
-        source: "anthropic.structuredOutput"
-      });
-      throw new Error(
-        `Structured output generation failed: ${err.message || "Unknown error occurred"}`
-      );
-    }
-  }
-  mapCommonOptionsToAnthropic(options) {
-    const modelOptions = options.modelOptions;
-    const formattedMessages = this.formatMessages(options.messages);
-    const tools = options.tools ? convertToolsToProviderFormat(options.tools) : void 0;
-    const validProviderOptions = {};
-    if (modelOptions) {
-      const validKeys = [
-        "container",
-        "context_management",
-        "effort",
-        "mcp_servers",
-        "output_config",
-        "service_tier",
-        "stop_sequences",
-        "thinking",
-        "tool_choice",
-        "top_k",
-        "temperature",
-        "top_p"
-      ];
-      const droppedKeyExemptSet = /* @__PURE__ */ new Set([...validKeys, "max_tokens"]);
-      const droppedKeys = Object.keys(modelOptions).filter(
-        (key) => !droppedKeyExemptSet.has(key)
-      );
-      if (droppedKeys.length > 0) {
-        options.logger.errors(
-          `anthropic.mapCommonOptionsToAnthropic dropped unknown modelOptions key(s): ${droppedKeys.join(", ")}`,
-          {
-            source: "anthropic.mapCommonOptionsToAnthropic",
-            droppedKeys,
-            hint: droppedKeys.includes("system") ? "pass system prompts via the top-level `systemPrompts` option; `modelOptions.system` is no longer honored" : void 0
-          }
-        );
-      }
-      for (const key of validKeys) {
-        if (key in modelOptions) {
-          const value = modelOptions[key];
-          if (key === "tool_choice" && typeof value === "string") {
-            validProviderOptions[key] = {
-              type: value
-            };
-          } else {
-            validProviderOptions[key] = value;
-          }
-        }
-      }
-    }
-    const thinkingBudget = validProviderOptions.thinking?.type === "enabled" ? validProviderOptions.thinking.budget_tokens : void 0;
-    const defaultMaxTokens = modelOptions?.max_tokens ?? 1024;
-    const maxTokens = thinkingBudget && thinkingBudget >= defaultMaxTokens ? thinkingBudget + 1 : defaultMaxTokens;
-    const systemBlocks = (() => {
-      const normalized = normalizeSystemPrompts(
-        options.systemPrompts
-      );
-      if (normalized.length === 0) return void 0;
-      return normalized.map(
-        (p) => ({
-          type: "text",
-          text: p.content,
-          ...p.metadata?.cache_control && {
-            cache_control: p.metadata.cache_control
-          }
-        })
-      );
-    })();
-    const combinedSchema = options.outputSchema;
-    const outputConfig = combinedSchema ? {
-      output_config: {
-        ...validProviderOptions.output_config ?? {},
-        format: {
-          type: "json_schema",
-          schema: combinedSchema
-        }
-      }
-    } : void 0;
-    const toolSkills = options.tools?.map(
-      (tool) => tool.name === "code_execution" ? readCodeExecutionSkills(tool) : void 0
-    ).find((skills) => skills && skills.length > 0);
-    if (toolSkills && toolSkills.length > 0) {
-      const existingContainer = validProviderOptions.container ?? void 0;
-      validProviderOptions.container = {
-        id: existingContainer?.id ?? null,
-        skills: toolSkills
-      };
-    }
-    const requestParams = {
-      model: options.model,
-      max_tokens: maxTokens,
-      messages: formattedMessages,
-      ...systemBlocks !== void 0 && { system: systemBlocks },
-      ...tools !== void 0 && { tools },
-      ...validProviderOptions,
-      ...outputConfig ?? {}
-    };
-    validateTextProviderOptions(requestParams);
-    return requestParams;
-  }
-  /**
-   * Anthropic supports `output_config.format` + `tools` in a single streaming
-   * Messages request only for Claude 4.5+ (GA 2026-01-29). For 4.4 and
-   * earlier we keep the forced-tool-use workaround in
-   * {@link structuredOutput} via the engine's finalization path.
-   */
-  supportsCombinedToolsAndSchema() {
-    return ANTHROPIC_COMBINED_TOOLS_AND_SCHEMA_MODELS.has(this.model);
-  }
-  convertContentPartToAnthropic(part) {
-    switch (part.type) {
-      case "text": {
-        const metadata = part.metadata;
-        return {
-          type: "text",
-          text: part.content,
-          ...metadata
-        };
-      }
-      case "image": {
-        const metadata = part.metadata;
-        const imageSource = part.source.type === "data" ? {
-          type: "base64",
-          data: part.source.value,
-          media_type: part.source.mimeType
-        } : {
-          type: "url",
-          url: part.source.value
-        };
-        return {
-          type: "image",
-          source: imageSource,
-          ...metadata
-        };
-      }
-      case "document": {
-        const metadata = part.metadata;
-        const docSource = part.source.type === "data" ? {
-          type: "base64",
-          data: part.source.value,
-          media_type: part.source.mimeType
-        } : {
-          type: "url",
-          url: part.source.value
-        };
-        return {
-          type: "document",
-          source: docSource,
-          ...metadata
-        };
-      }
-      case "audio":
-      case "video":
-        throw new Error(
-          `Anthropic does not support ${part.type} content directly`
-        );
-      default: {
-        const _exhaustiveCheck = part;
-        throw new Error(
-          `Unsupported content part type: ${_exhaustiveCheck.type}`
-        );
-      }
-    }
-  }
-  formatMessages(messages) {
-    const formattedMessages = [];
-    for (const message of messages) {
-      const role = message.role;
-      if (role === "tool" && message.toolCallId) {
-        const toolContent = message.content;
-        formattedMessages.push({
-          role: "user",
-          content: [
-            {
-              type: "tool_result",
-              tool_use_id: message.toolCallId,
-              content: Array.isArray(toolContent) ? toolContent.map(
-                (part) => this.convertContentPartToAnthropic(part)
-              ) : typeof toolContent === "string" ? toolContent : ""
-            }
-          ]
-        });
-        continue;
-      }
-      if (role === "assistant" && message.toolCalls?.length) {
-        const contentBlocks = [];
-        this.appendThinkingBlocks(contentBlocks, message.thinking);
-        if (message.content) {
-          const content = typeof message.content === "string" ? message.content : "";
-          const textBlock = {
-            type: "text",
-            text: content
-          };
-          contentBlocks.push(textBlock);
-        }
-        for (const toolCall of message.toolCalls) {
-          let parsedInput = {};
-          try {
-            const parsed = toolCall.function.arguments ? JSON.parse(toolCall.function.arguments) : {};
-            parsedInput = parsed && typeof parsed === "object" ? parsed : {};
-          } catch {
-            parsedInput = toolCall.function.arguments;
-          }
-          const toolUseBlock = {
-            type: "tool_use",
-            id: toolCall.id,
-            name: toolCall.function.name,
-            input: parsedInput
-          };
-          contentBlocks.push(toolUseBlock);
-        }
-        formattedMessages.push({
-          role: "assistant",
-          content: contentBlocks
-        });
-        continue;
-      }
-      if (role === "assistant") {
-        const contentBlocks = [];
-        this.appendThinkingBlocks(contentBlocks, message.thinking);
-        if (Array.isArray(message.content)) {
-          for (const part of message.content) {
-            contentBlocks.push(this.convertContentPartToAnthropic(part));
-          }
-        } else if (message.content) {
-          contentBlocks.push({
-            type: "text",
-            text: message.content
-          });
-        }
-        formattedMessages.push({
-          role: "assistant",
-          content: contentBlocks.length > 0 ? contentBlocks : ""
-        });
-        continue;
-      }
-      if (role === "user" && Array.isArray(message.content)) {
-        const contentBlocks = message.content.map(
-          (part) => this.convertContentPartToAnthropic(part)
-        );
-        formattedMessages.push({
-          role: "user",
-          content: contentBlocks
-        });
-        continue;
-      }
-      formattedMessages.push({
-        role: "user",
-        content: typeof message.content === "string" ? message.content : message.content ? message.content.map(
-          (c) => this.convertContentPartToAnthropic(c)
-        ) : ""
-      });
-    }
-    return this.mergeConsecutiveSameRoleMessages(formattedMessages);
-  }
-  appendThinkingBlocks(contentBlocks, thinkingParts) {
-    if (!thinkingParts?.length) return;
-    for (const thinking of thinkingParts) {
-      if (!thinking.signature) continue;
-      const block = {
-        type: "thinking",
-        thinking: thinking.content,
-        signature: thinking.signature
-      };
-      contentBlocks.push(block);
-    }
-  }
-  /**
-   * Merge consecutive messages of the same role into a single message.
-   * Anthropic's API requires strictly alternating user/assistant roles.
-   * Tool results are wrapped as role:'user' messages, which can collide
-   * with actual user messages in multi-turn conversations.
-   *
-   * Also filters out empty assistant messages (e.g., from a previous failed request).
-   */
-  mergeConsecutiveSameRoleMessages(messages) {
-    const merged = [];
-    for (const msg of messages) {
-      if (msg.role === "assistant") {
-        const hasContent = Array.isArray(msg.content) ? msg.content.length > 0 : typeof msg.content === "string" && msg.content.length > 0;
-        if (!hasContent) {
-          continue;
-        }
-      }
-      const prev = merged[merged.length - 1];
-      if (prev && prev.role === msg.role) {
-        const prevBlocks = Array.isArray(prev.content) ? prev.content : typeof prev.content === "string" && prev.content ? [{ type: "text", text: prev.content }] : [];
-        const msgBlocks = Array.isArray(msg.content) ? msg.content : typeof msg.content === "string" && msg.content ? [{ type: "text", text: msg.content }] : [];
-        prev.content = [...prevBlocks, ...msgBlocks];
-      } else {
-        merged.push({ ...msg });
-      }
-    }
-    for (const msg of merged) {
-      if (Array.isArray(msg.content)) {
-        const seenToolResultIds = /* @__PURE__ */ new Set();
-        msg.content = msg.content.filter((block) => {
-          if (block.type === "tool_result" && block.tool_use_id) {
-            if (seenToolResultIds.has(block.tool_use_id)) {
-              return false;
-            }
-            seenToolResultIds.add(block.tool_use_id);
-          }
-          return true;
-        });
-      }
-    }
-    return merged;
-  }
-  async *processAnthropicStream(stream, options, genId, logger) {
-    const model = options.model;
-    let accumulatedContent = "";
-    let accumulatedThinking = "";
-    let accumulatedSignature = "";
-    const toolCallsMap = /* @__PURE__ */ new Map();
-    let currentToolIndex = -1;
-    let currentServerTool = null;
-    const runId = options.runId ?? genId();
-    const threadId = options.threadId ?? genId();
-    const messageId = genId();
-    let stepId = null;
-    let reasoningMessageId = null;
-    let hasClosedReasoning = false;
-    let hasEmittedRunStarted = false;
-    let hasEmittedTextMessageStart = false;
-    let hasEmittedRunFinished = false;
-    let currentBlockType = null;
-    try {
-      for await (const event of stream) {
-        logger.provider(`provider=anthropic type=${event.type}`, {
-          chunk: event
-        });
-        if (!hasEmittedRunStarted) {
-          hasEmittedRunStarted = true;
-          yield {
-            type: EventType.RUN_STARTED,
-            runId,
-            threadId,
-            model,
-            timestamp: Date.now(),
-            parentRunId: options.parentRunId
-          };
-        }
-        if (event.type === "content_block_start") {
-          currentBlockType = event.content_block.type;
-          if (event.content_block.type === "tool_use") {
-            currentToolIndex++;
-            toolCallsMap.set(currentToolIndex, {
-              id: event.content_block.id,
-              name: event.content_block.name,
-              input: "",
-              started: false
-            });
-          } else if (event.content_block.type === "server_tool_use") {
-            currentServerTool = {
-              id: event.content_block.id,
-              name: event.content_block.name,
-              input: ""
-            };
-          } else if (event.content_block.type === "web_fetch_tool_result" || event.content_block.type === "web_search_tool_result") {
-            const content = event.content_block.content;
-            const errorBlock = !Array.isArray(content) && (content.type === "web_fetch_tool_result_error" || content.type === "web_search_tool_result_error") ? content : null;
-            if (errorBlock) {
-              logger.errors(
-                `anthropic.${event.content_block.type} error_code=${errorBlock.error_code}`,
-                {
-                  toolUseId: event.content_block.tool_use_id,
-                  blockType: event.content_block.type,
-                  errorCode: errorBlock.error_code,
-                  source: "anthropic.processAnthropicStream"
-                }
-              );
-            }
-          } else if (event.content_block.type === "thinking") {
-            accumulatedThinking = "";
-            accumulatedSignature = "";
-            stepId = genId();
-            reasoningMessageId = genId();
-            yield {
-              type: EventType.REASONING_START,
-              messageId: reasoningMessageId,
-              model,
-              timestamp: Date.now()
-            };
-            yield {
-              type: EventType.REASONING_MESSAGE_START,
-              messageId: reasoningMessageId,
-              role: "reasoning",
-              model,
-              timestamp: Date.now()
-            };
-            yield {
-              type: EventType.STEP_STARTED,
-              stepName: stepId,
-              stepId,
-              model,
-              timestamp: Date.now(),
-              stepType: "thinking"
-            };
-          }
-        } else if (event.type === "content_block_delta") {
-          if (event.delta.type === "text_delta") {
-            if (reasoningMessageId && !hasClosedReasoning) {
-              hasClosedReasoning = true;
-              yield {
-                type: EventType.REASONING_MESSAGE_END,
-                messageId: reasoningMessageId,
-                model,
-                timestamp: Date.now()
-              };
-              yield {
-                type: EventType.REASONING_END,
-                messageId: reasoningMessageId,
-                model,
-                timestamp: Date.now()
-              };
-            }
-            if (!hasEmittedTextMessageStart) {
-              hasEmittedTextMessageStart = true;
-              yield {
-                type: EventType.TEXT_MESSAGE_START,
-                messageId,
-                model,
-                timestamp: Date.now(),
-                role: "assistant"
-              };
-            }
-            const delta = event.delta.text;
-            accumulatedContent += delta;
-            yield {
-              type: EventType.TEXT_MESSAGE_CONTENT,
-              messageId,
-              model,
-              timestamp: Date.now(),
-              delta,
-              content: accumulatedContent
-            };
-          } else if (event.delta.type === "thinking_delta" && reasoningMessageId) {
-            const delta = event.delta.thinking;
-            accumulatedThinking += delta;
-            yield {
-              type: EventType.REASONING_MESSAGE_CONTENT,
-              messageId: reasoningMessageId,
-              delta,
-              model,
-              timestamp: Date.now()
-            };
-            yield {
-              type: EventType.STEP_FINISHED,
-              stepName: stepId || genId(),
-              stepId: stepId || genId(),
-              model,
-              timestamp: Date.now(),
-              delta,
-              content: accumulatedThinking
-            };
-          } else if (event.delta.type === "signature_delta") {
-            accumulatedSignature += event.delta.signature || "";
-          } else if (event.delta.type === "input_json_delta") {
-            if (currentBlockType === "tool_use") {
-              const existing = toolCallsMap.get(currentToolIndex);
-              if (existing) {
-                if (!existing.started) {
-                  existing.started = true;
-                  yield {
-                    type: EventType.TOOL_CALL_START,
-                    toolCallId: existing.id,
-                    toolCallName: existing.name,
-                    toolName: existing.name,
-                    parentMessageId: messageId,
-                    model,
-                    timestamp: Date.now(),
-                    index: currentToolIndex
-                  };
-                }
-                existing.input += event.delta.partial_json;
-                yield {
-                  type: EventType.TOOL_CALL_ARGS,
-                  toolCallId: existing.id,
-                  model,
-                  timestamp: Date.now(),
-                  delta: event.delta.partial_json,
-                  args: existing.input
-                };
-              }
-            } else if (currentBlockType === "server_tool_use" && currentServerTool) {
-              currentServerTool.input += event.delta.partial_json;
-            }
-          }
-        } else if (event.type === "content_block_stop") {
-          if (currentBlockType === "thinking") {
-            if (accumulatedSignature && stepId) {
-              yield {
-                type: EventType.STEP_FINISHED,
-                stepName: stepId,
-                stepId,
-                model,
-                timestamp: Date.now(),
-                delta: "",
-                content: accumulatedThinking,
-                signature: accumulatedSignature
-              };
-            }
-          } else if (currentBlockType === "tool_use") {
-            const existing = toolCallsMap.get(currentToolIndex);
-            if (existing) {
-              if (!existing.started) {
-                existing.started = true;
-                yield {
-                  type: EventType.TOOL_CALL_START,
-                  toolCallId: existing.id,
-                  toolCallName: existing.name,
-                  toolName: existing.name,
-                  parentMessageId: messageId,
-                  model,
-                  timestamp: Date.now(),
-                  index: currentToolIndex
-                };
-              }
-              let parsedInput = {};
-              try {
-                const parsed = existing.input ? JSON.parse(existing.input) : {};
-                parsedInput = parsed && typeof parsed === "object" ? parsed : {};
-              } catch {
-                parsedInput = {};
-              }
-              yield {
-                type: EventType.TOOL_CALL_END,
-                toolCallId: existing.id,
-                toolCallName: existing.name,
-                toolName: existing.name,
-                model,
-                timestamp: Date.now(),
-                input: parsedInput
-              };
-              hasEmittedTextMessageStart = false;
-            }
-          } else if (currentBlockType === "server_tool_use") {
-            if (currentServerTool) {
-              logger.provider(
-                `provider=anthropic server_tool_use name=${currentServerTool.name}`,
-                {
-                  toolUseId: currentServerTool.id,
-                  name: currentServerTool.name,
-                  input: currentServerTool.input
-                }
-              );
-            }
-            currentServerTool = null;
-          } else if (currentBlockType === "web_fetch_tool_result" || currentBlockType === "web_search_tool_result") {
-          } else {
-            if (hasEmittedTextMessageStart && accumulatedContent) {
-              yield {
-                type: EventType.TEXT_MESSAGE_END,
-                messageId,
-                model,
-                timestamp: Date.now()
-              };
-            }
-          }
-          currentBlockType = null;
-        } else if (event.type === "message_stop") {
-          if (reasoningMessageId && !hasClosedReasoning) {
-            hasClosedReasoning = true;
-            yield {
-              type: EventType.REASONING_MESSAGE_END,
-              messageId: reasoningMessageId,
-              model,
-              timestamp: Date.now()
-            };
-            yield {
-              type: EventType.REASONING_END,
-              messageId: reasoningMessageId,
-              model,
-              timestamp: Date.now()
-            };
-          }
-          if (!hasEmittedRunFinished) {
-            yield {
-              type: EventType.RUN_FINISHED,
-              runId,
-              threadId,
-              model,
-              timestamp: Date.now(),
-              finishReason: "stop"
-            };
-          }
-        } else if (event.type === "message_delta") {
-          if (event.delta.stop_reason) {
-            hasEmittedRunFinished = true;
-            if (reasoningMessageId && !hasClosedReasoning) {
-              hasClosedReasoning = true;
-              yield {
-                type: EventType.REASONING_MESSAGE_END,
-                messageId: reasoningMessageId,
-                model,
-                timestamp: Date.now()
-              };
-              yield {
-                type: EventType.REASONING_END,
-                messageId: reasoningMessageId,
-                model,
-                timestamp: Date.now()
-              };
-            }
-            switch (event.delta.stop_reason) {
-              case "tool_use": {
-                yield {
-                  type: EventType.RUN_FINISHED,
-                  runId,
-                  threadId,
-                  model,
-                  timestamp: Date.now(),
-                  finishReason: "tool_calls",
-                  usage: buildAnthropicUsage(event.usage)
-                };
-                break;
-              }
-              case "max_tokens": {
-                yield {
-                  type: EventType.RUN_ERROR,
-                  model,
-                  timestamp: Date.now(),
-                  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;
-              }
-              case "stop_sequence":
-              case "end_turn":
-              case "pause_turn":
-              case "refusal":
-              case "model_context_window_exceeded":
-              case "compaction":
-              default: {
-                yield {
-                  type: EventType.RUN_FINISHED,
-                  runId,
-                  threadId,
-                  model,
-                  timestamp: Date.now(),
-                  finishReason: "stop",
-                  usage: buildAnthropicUsage(event.usage)
-                };
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      const err = error;
-      const rawEvent = toRunErrorRawEvent(error);
-      logger.errors("anthropic.processAnthropicStream fatal", {
-        error,
-        source: "anthropic.processAnthropicStream"
-      });
-      yield {
-        type: EventType.RUN_ERROR,
-        model,
-        timestamp: Date.now(),
-        message: err.message || "Unknown error occurred",
-        code: err.code || String(err.status),
-        // Forward the Anthropic SDK error's `.error` response body when present.
-        ...rawEvent !== void 0 && { rawEvent },
-        error: {
-          message: err.message || "Unknown error occurred",
-          code: err.code || String(err.status)
-        }
-      };
-    }
-  }
-}
-function createAnthropicChat(model, apiKey, config) {
-  return new AnthropicTextAdapter({ apiKey, ...config }, model);
-}
-function anthropicText(model, config) {
-  const apiKey = getAnthropicApiKeyFromEnv();
-  return createAnthropicChat(model, apiKey, config);
-}
-export {
-  AnthropicTextAdapter,
-  anthropicText,
-  computeAnthropicBetas,
-  createAnthropicChat
-};
-//# sourceMappingURL=text.js.map