@yourgpt/llm-sdk 2.6.0-beta.2 → 2.6.0

package/dist/providers/anthropic/index.js

@@ -87,6 +87,120 @@ function toolOutputForProvider(value, provider) {
   });
 }
 
+// src/core/provider-error.ts
+function invalidProviderResponse(message) {
+  return Object.assign(new Error(message), {
+    name: "InvalidProviderResponseError",
+    status: 502,
+    code: "INVALID_PROVIDER_RESPONSE"
+  });
+}
+function providerErrorEvent(error, code) {
+  const details = error ?? {};
+  const event = {
+    type: "error",
+    message: error instanceof Error ? error.message : String(error),
+    code,
+    ...typeof details.status === "number" ? { status: details.status } : {},
+    ...typeof details.code === "string" ? { providerCode: details.code } : {},
+    ...typeof details.param === "string" ? { param: details.param } : {},
+    ...typeof details.request_id === "string" ? { requestId: details.request_id } : {}
+  };
+  Object.defineProperty(event, "cause", { value: error, enumerable: false });
+  return event;
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  throw error;
+}
+
+// src/core/tool-validation.ts
+function parseToolArguments(value) {
+  let args = value;
+  if (typeof value === "string") {
+    try {
+      args = JSON.parse(value || "{}");
+    } catch {
+      throw invalidProviderResponse("Tool arguments are not valid JSON");
+    }
+  }
+  if (args === null || typeof args !== "object" || Array.isArray(args))
+    throw invalidProviderResponse("Tool arguments must be a JSON object");
+  return args;
+}
+function validateToolCalls(calls) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    if (!call || typeof call.id !== "string" || !call.id || typeof call.name !== "string" || !call.name || ids.has(call.id))
+      throw invalidProviderResponse(
+        "Tool calls have missing or duplicate identities"
+      );
+    ids.add(call.id);
+    if (typeof call.args === "string")
+      throw invalidProviderResponse("Parsed tool arguments must be an object");
+    parseToolArguments(call.args);
+  }
+}
+
+// src/core/anthropic-replay.ts
+function anthropicReplay(content) {
+  if (!Array.isArray(content) || !content.some(
+    (b) => b?.type === "thinking" || b?.type === "redacted_thinking"
+  ))
+    return void 0;
+  const blocks = content.flatMap((block) => {
+    if (block?.type === "thinking" && typeof block.thinking === "string" && typeof block.signature === "string")
+      return [
+        {
+          type: "thinking",
+          thinking: block.thinking,
+          signature: block.signature
+        }
+      ];
+    if (block?.type === "redacted_thinking" && typeof block.data === "string")
+      return [{ type: "redacted_thinking", data: block.data }];
+    if (block?.type === "text" && typeof block.text === "string")
+      return [{ type: "text", text: block.text }];
+    if (block?.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string")
+      return [
+        {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        }
+      ];
+    return [];
+  });
+  return { anthropic: { content: blocks } };
+}
+function anthropicReplayContent(metadata) {
+  const state = metadata?.anthropic;
+  return anthropicReplay(state?.content)?.anthropic?.content;
+}
+function collectAnthropicContent(blocks, event) {
+  if (event.type === "content_block_start")
+    blocks[event.index] = { ...event.content_block };
+  const block = blocks[event.index];
+  if (event.type !== "content_block_delta" || !block) return;
+  const delta = event.delta;
+  if (delta.type === "thinking_delta")
+    block.thinking = (block.thinking ?? "") + delta.thinking;
+  else if (delta.type === "signature_delta")
+    block.signature = (block.signature ?? "") + delta.signature;
+  else if (delta.type === "text_delta")
+    block.text = (block.text ?? "") + delta.text;
+  else if (delta.type === "input_json_delta") {
+    block.partialInput = (block.partialInput ?? "") + delta.partial_json;
+    try {
+      block.input = JSON.parse(block.partialInput);
+    } catch {
+    }
+  }
+}
+
 // src/adapters/base.ts
 function stringifyForDebug(value) {
   return JSON.stringify(
@@ -165,7 +279,22 @@ function stripSchemaKeys(schema, keysToDrop, options = {}) {
   )) {
     if (keysToDrop.has(key)) continue;
     const renamed = options.renameKeys?.[key] ?? key;
-    out[renamed] = stripSchemaKeys(value, keysToDrop, options);
+    if ([
+      "properties",
+      "$defs",
+      "definitions",
+      "patternProperties",
+      "dependentSchemas"
+    ].includes(key) && value && typeof value === "object" && !Array.isArray(value)) {
+      out[renamed] = Object.fromEntries(
+        Object.entries(value).map(([name, child]) => [
+          name,
+          stripSchemaKeys(child, keysToDrop, options)
+        ])
+      );
+    } else if (["enum", "const", "default", "examples"].includes(key)) {
+      out[renamed] = value;
+    } else out[renamed] = stripSchemaKeys(value, keysToDrop, options);
   }
   if (options.forceAdditionalPropertiesFalse && out.type === "object") {
     out.additionalProperties = false;
@@ -294,21 +423,14 @@ function messageToAnthropicContent(message) {
   return blocks;
 }
 function extractAnthropicSystemPrompt(messages, systemPrompt) {
-  const parts = systemPrompt ? [systemPrompt] : [];
+  const explicit = typeof systemPrompt === "string" ? systemPrompt : "";
+  const parts = explicit ? [explicit] : [];
   for (const message of messages) {
     if (message.role !== "system") continue;
-    if (typeof message.content === "string") {
-      if (message.content) parts.push(message.content);
-    } else if (Array.isArray(message.content)) {
-      for (const block of message.content) {
-        if (block?.type !== "text" || typeof block.text !== "string") {
-          throw new TypeError("Anthropic system messages must contain text.");
-        }
-        if (block.text) parts.push(block.text);
-      }
-    } else {
-      throw new TypeError("Anthropic system messages must contain text.");
-    }
+    const text = typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content.filter(
+      (block) => block?.type === "text" && typeof block.text === "string"
+    ).map((block) => block.text).filter(Boolean).join("\n") : "";
+    if (text && text !== explicit) parts.push(text);
   }
   return parts.join("\n");
 }
@@ -319,6 +441,14 @@ function formatMessagesForAnthropic(messages, systemPrompt) {
     const msg = messages[i];
     if (msg.role === "system") continue;
     if (msg.role === "assistant") {
+      const replay = anthropicReplayContent(msg.providerMetadata);
+      if (replay) {
+        formatted.push({
+          role: "assistant",
+          content: replay
+        });
+        continue;
+      }
       const content = [];
       if (msg.content) {
         content.push({ type: "text", text: msg.content });
@@ -373,6 +503,52 @@ function formatMessagesForAnthropic(messages, systemPrompt) {
   };
 }
 
+// src/core/anthropic-parameters.ts
+function anthropicMaxTokens(maxTokens, thinking) {
+  return maxTokens ?? Math.max(4096, Number(thinking?.budget_tokens ?? 0) + 1);
+}
+function anthropicModelRules(model) {
+  const match = /^claude-(opus|sonnet|haiku)-(\d+)(?:-(\d{1,2})(?=-|$))?(?:-|$)/i.exec(
+    model
+  );
+  const family = match?.[1]?.toLowerCase();
+  const major = Number(match?.[2] ?? 0);
+  const minor = Number(match?.[3] ?? 0);
+  const adaptive = major >= 5 || major === 4 && minor >= 6;
+  return {
+    structured: major >= 5 || major === 4 && minor >= 5,
+    thinking: major >= 4 || /^claude-3-7-/.test(model),
+    adaptive,
+    rejectsSampling: major >= 5 || family === "opus" && major === 4 && minor >= 7
+  };
+}
+function anthropicInputTokens(usage) {
+  return (usage?.input_tokens ?? 0) + (usage?.cache_creation_input_tokens ?? 0) + (usage?.cache_read_input_tokens ?? 0);
+}
+function anthropicThinking(model, thinking) {
+  if (!thinking) return void 0;
+  if (thinking.type === "enabled") {
+    if (anthropicModelRules(model).adaptive) {
+      console.warn(
+        `[llm-sdk] ${model}: using adaptive thinking instead of a legacy token budget.`
+      );
+      return { type: "adaptive" };
+    }
+    return { type: "enabled", budget_tokens: thinking.budgetTokens ?? 1e4 };
+  }
+  return { ...thinking };
+}
+function anthropicTemperature(model, temperature, thinking = false) {
+  if (temperature === void 0) return {};
+  if (thinking || anthropicModelRules(model).rejectsSampling) {
+    console.warn(
+      `[llm-sdk] ${model}: omitted temperature because this model or thinking mode does not support it.`
+    );
+    return {};
+  }
+  return { temperature };
+}
+
 // src/providers/anthropic/provider.ts
 var ANTHROPIC_MODELS = {
   // Claude 4 series
@@ -482,6 +658,10 @@ function anthropic(modelId, options = {}) {
     return client;
   }
   const modelConfig = ANTHROPIC_MODELS[modelId] ?? ANTHROPIC_MODELS["claude-3-5-sonnet-latest"];
+  const thinking = anthropicThinking(
+    modelId,
+    options.thinking && ("enabled" in options.thinking ? options.thinking.enabled ? { type: "enabled", budgetTokens: options.thinking.budgetTokens } : void 0 : options.thinking)
+  );
   return {
     provider: "anthropic",
     modelId,
@@ -489,8 +669,8 @@ function anthropic(modelId, options = {}) {
       supportsVision: modelConfig.vision,
       supportsTools: modelConfig.tools,
       supportsStreaming: true,
-      supportsJsonMode: modelConfig.jsonMode,
-      supportsThinking: modelConfig.thinking,
+      supportsJsonMode: anthropicModelRules(modelId).structured,
+      supportsThinking: modelConfig.thinking || anthropicModelRules(modelId).thinking,
       supportsPDF: modelConfig.pdf,
       maxTokens: modelConfig.maxTokens,
       supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
@@ -500,25 +680,34 @@ function anthropic(modelId, options = {}) {
       const { system, messages } = formatMessagesForAnthropic2(params.messages);
       const requestOptions = {
         model: modelId,
-        max_tokens: params.maxTokens ?? 4096,
+        max_tokens: anthropicMaxTokens(params.maxTokens, thinking),
         system: system || void 0,
         messages,
-        tools: params.tools
+        tools: params.tools,
+        ...options.cacheControl ? { cache_control: { type: "ephemeral" } } : {}
       };
-      if (params.temperature !== void 0) {
-        requestOptions.temperature = params.temperature;
-      }
-      if (options.thinking?.enabled && modelConfig.thinking) {
-        requestOptions.thinking = {
-          type: "enabled",
-          budget_tokens: options.thinking.budgetTokens ?? 1e4
-        };
+      Object.assign(
+        requestOptions,
+        anthropicTemperature(
+          modelId,
+          params.temperature,
+          !!thinking && thinking.type !== "disabled"
+        )
+      );
+      if (params.responseFormat?.type === "json_object") {
+        requestOptions.system = (system || "") + "\n\nRespond with a single JSON object and no other text. Do not include Markdown code fences.";
       }
+      if (thinking) requestOptions.thinking = thinking;
       const outputConfig = toAnthropicOutputConfig(params.responseFormat);
-      if (outputConfig) {
-        requestOptions.output_config = outputConfig;
+      if (outputConfig || options.effort) {
+        requestOptions.output_config = {
+          ...outputConfig,
+          ...options.effort ? { effort: options.effort } : {}
+        };
       }
-      const response = await client2.messages.create(requestOptions);
+      const response = await client2.messages.create(requestOptions, {
+        signal: params.signal
+      });
       let text = "";
       const toolCalls = [];
       for (const block of response.content) {
@@ -532,14 +721,21 @@ function anthropic(modelId, options = {}) {
           });
         }
       }
+      validateToolCalls(toolCalls);
+      if (toolCalls.length && response.stop_reason !== "tool_use")
+        throw invalidProviderResponse(
+          "Anthropic response ended with incomplete tool calls"
+        );
       return {
         text,
+        reasoningText: response.content.filter((b) => b.type === "thinking").map((b) => b.thinking).join("") || void 0,
+        providerMetadata: anthropicReplay(response.content),
         toolCalls,
         finishReason: mapFinishReason(response.stop_reason),
         usage: {
-          promptTokens: response.usage?.input_tokens ?? 0,
+          promptTokens: anthropicInputTokens(response.usage),
           completionTokens: response.usage?.output_tokens ?? 0,
-          totalTokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0)
+          totalTokens: anthropicInputTokens(response.usage) + (response.usage?.output_tokens ?? 0)
         },
         rawResponse: response
       };
@@ -549,37 +745,47 @@ function anthropic(modelId, options = {}) {
       const { system, messages } = formatMessagesForAnthropic2(params.messages);
       const requestOptions = {
         model: modelId,
-        max_tokens: params.maxTokens ?? 4096,
+        max_tokens: anthropicMaxTokens(params.maxTokens, thinking),
         system: system || void 0,
         messages,
-        tools: params.tools
+        tools: params.tools,
+        ...options.cacheControl ? { cache_control: { type: "ephemeral" } } : {}
       };
-      if (params.temperature !== void 0) {
-        requestOptions.temperature = params.temperature;
-      }
-      if (options.thinking?.enabled && modelConfig.thinking) {
-        requestOptions.thinking = {
-          type: "enabled",
-          budget_tokens: options.thinking.budgetTokens ?? 1e4
-        };
+      Object.assign(
+        requestOptions,
+        anthropicTemperature(
+          modelId,
+          params.temperature,
+          !!thinking && thinking.type !== "disabled"
+        )
+      );
+      if (params.responseFormat?.type === "json_object") {
+        requestOptions.system = (system || "") + "\n\nRespond with a single JSON object and no other text. Do not include Markdown code fences.";
       }
+      if (thinking) requestOptions.thinking = thinking;
       const outputConfig = toAnthropicOutputConfig(params.responseFormat);
-      if (outputConfig) {
-        requestOptions.output_config = outputConfig;
+      if (outputConfig || options.effort) {
+        requestOptions.output_config = {
+          ...outputConfig,
+          ...options.effort ? { effort: options.effort } : {}
+        };
       }
-      const stream = await client2.messages.stream(requestOptions);
+      const stream = await client2.messages.stream(requestOptions, {
+        signal: params.signal
+      });
       let currentToolUse = null;
       let inputTokens = 0;
       let outputTokens = 0;
+      const content = [];
+      const toolCalls = [];
+      let stopReason;
       for await (const event of stream) {
-        if (params.signal?.aborted) {
-          yield { type: "error", error: new Error("Aborted") };
-          return;
-        }
+        collectAnthropicContent(content, event);
+        throwIfAborted(params.signal);
         switch (event.type) {
           case "message_start":
             if (event.message?.usage) {
-              inputTokens = event.message.usage.input_tokens ?? 0;
+              inputTokens = anthropicInputTokens(event.message.usage);
             }
             break;
           case "content_block_start":
@@ -594,20 +800,19 @@ function anthropic(modelId, options = {}) {
           case "content_block_delta":
             if (event.delta?.type === "text_delta") {
               yield { type: "text-delta", text: event.delta.text };
+            } else if (event.delta?.type === "thinking_delta") {
+              yield { type: "reasoning-delta", text: event.delta.thinking };
             } else if (event.delta?.type === "input_json_delta" && currentToolUse) {
               currentToolUse.input += event.delta.partial_json;
             }
             break;
           case "content_block_stop":
             if (currentToolUse) {
-              yield {
-                type: "tool-call",
-                toolCall: {
-                  id: currentToolUse.id,
-                  name: currentToolUse.name,
-                  args: JSON.parse(currentToolUse.input || "{}")
-                }
-              };
+              toolCalls.push({
+                id: currentToolUse.id,
+                name: currentToolUse.name,
+                args: parseToolArguments(currentToolUse.input)
+              });
               currentToolUse = null;
             }
             break;
@@ -616,19 +821,32 @@ function anthropic(modelId, options = {}) {
               outputTokens = event.usage.output_tokens ?? 0;
             }
             if (event.delta?.stop_reason) {
-              yield {
-                type: "finish",
-                finishReason: mapFinishReason(event.delta.stop_reason),
-                usage: {
-                  promptTokens: inputTokens,
-                  completionTokens: outputTokens,
-                  totalTokens: inputTokens + outputTokens
-                }
-              };
+              stopReason = event.delta.stop_reason;
             }
             break;
         }
       }
+      throwIfAborted(params.signal);
+      if (!stopReason || currentToolUse)
+        throw invalidProviderResponse(
+          "Anthropic stream ended before its turn completed"
+        );
+      validateToolCalls(toolCalls);
+      if (toolCalls.length && stopReason !== "tool_use")
+        throw invalidProviderResponse(
+          "Anthropic stream ended with incomplete tool calls"
+        );
+      for (const toolCall of toolCalls) yield { type: "tool-call", toolCall };
+      yield {
+        type: "finish",
+        finishReason: mapFinishReason(stopReason),
+        providerMetadata: anthropicReplay(content),
+        usage: {
+          promptTokens: inputTokens,
+          completionTokens: outputTokens,
+          totalTokens: inputTokens + outputTokens
+        }
+      };
     }
   };
 }
@@ -646,7 +864,7 @@ function mapFinishReason(reason) {
   }
 }
 function formatMessagesForAnthropic2(messages) {
-  let system = "";
+  const system = extractAnthropicSystemPrompt(messages);
   const formatted = [];
   const pendingToolResults = [];
   const flushToolResults = () => {
@@ -672,7 +890,6 @@ function formatMessagesForAnthropic2(messages) {
   };
   for (const msg of messages) {
     if (msg.role === "system") {
-      system += (system ? "\n" : "") + msg.content;
       continue;
     }
     if (msg.role === "assistant" && pendingToolResults.length > 0) {
@@ -710,6 +927,11 @@ function formatMessagesForAnthropic2(messages) {
         formatted.push({ role: "user", content });
       }
     } else if (msg.role === "assistant") {
+      const replay = anthropicReplayContent(msg.providerMetadata);
+      if (replay) {
+        formatted.push({ role: "assistant", content: replay });
+        continue;
+      }
       const content = [];
       if (msg.content) {
         content.push({ type: "text", text: msg.content });
@@ -765,7 +987,10 @@ var AnthropicAdapter = class {
     if (!this.client) {
       const { default: Anthropic } = await import('@anthropic-ai/sdk');
       this.client = new Anthropic({
-        apiKey: this.config.apiKey
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl,
+        timeout: this.config.timeout,
+        defaultHeaders: this.config.headers
       });
     }
     return this.client;
@@ -802,6 +1027,15 @@ var AnthropicAdapter = class {
           lastToolCallIds = [];
           toolResultIndex = 0;
         }
+        const replay = anthropicReplayContent(
+          msg.providerMetadata
+        );
+        if (replay) {
+          messages.push({ role: "assistant", content: replay });
+          lastToolCallIds = replay.filter((b) => b.type === "tool_use").map((b) => b.id);
+          toolResultIndex = 0;
+          continue;
+        }
         const content = [];
         if (msg.content && typeof msg.content === "string" && msg.content.trim()) {
           content.push({ type: "text", text: msg.content });
@@ -977,7 +1211,7 @@ var AnthropicAdapter = class {
    */
   buildRequestOptions(request) {
     const responseFormat = request.config?.responseFormat;
-    const jsonObjectSuffix = responseFormat?.type === "json_object" ? "\n\nRespond with a single JSON object and no other text." : "";
+    const jsonObjectSuffix = responseFormat?.type === "json_object" ? "\n\nRespond with a single JSON object and no other text. Do not include Markdown code fences." : "";
     let systemMessage;
     let messages;
     if (request.rawMessages && request.rawMessages.length > 0) {
@@ -999,7 +1233,17 @@ var AnthropicAdapter = class {
     const tools = anthropicNativeSearch?.enabled ? this.buildNativeSearchTools(
       request.toolDefinitions ?? [],
       anthropicNativeSearch.variant
-    ) : request.actions?.map((action) => ({
+    ) : request.toolDefinitions?.length ? request.toolDefinitions.filter((tool) => tool.available !== false).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      // Keep the original schema. Legacy ActionParameter conversion
+      // cannot represent unions, null, or nested required constraints.
+      input_schema: tool.inputSchema ?? {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    })) : request.actions?.map((action) => ({
       name: action.name,
       description: action.description,
       input_schema: {
@@ -1041,12 +1285,25 @@ var AnthropicAdapter = class {
         };
       }
     }
+    const thinking = anthropicThinking(
+      request.config?.model || this.model,
+      this.config.thinking
+    );
     const options = {
       model: request.config?.model || this.model,
-      max_tokens: request.config?.maxTokens || this.config.maxTokens || 4096,
+      max_tokens: anthropicMaxTokens(
+        request.config?.maxTokens ?? this.config.maxTokens,
+        thinking
+      ),
       system: systemMessage,
       messages,
-      tools: tools.length ? tools : void 0
+      tools: tools.length ? tools : void 0,
+      ...this.config.cacheControl ? { cache_control: { type: "ephemeral" } } : {},
+      ...anthropicTemperature(
+        request.config?.model || this.model,
+        request.config?.temperature ?? this.config.temperature,
+        !!this.config.thinking && this.config.thinking.type !== "disabled"
+      )
     };
     const anthropicToolOptions = request.providerToolOptions?.anthropic;
     if (tools.length > 0 && anthropicToolOptions) {
@@ -1065,15 +1322,13 @@ var AnthropicAdapter = class {
       options.server_tool_configuration = serverToolConfiguration;
     }
     const outputConfig = toAnthropicOutputConfig(responseFormat);
-    if (outputConfig) {
-      options.output_config = outputConfig;
-    }
-    if (this.config.thinking?.type === "enabled") {
-      options.thinking = {
-        type: "enabled",
-        budget_tokens: this.config.thinking.budgetTokens || 1e4
+    if (outputConfig || this.config.effort) {
+      options.output_config = {
+        ...outputConfig,
+        ...this.config.effort ? { effort: this.config.effort } : {}
       };
     }
+    if (thinking) options.thinking = thinking;
     return { options, messages };
   }
   /**
@@ -1093,7 +1348,9 @@ var AnthropicAdapter = class {
         nonStreamingOptions,
         request.debug
       );
-      const response = await client.messages.create(nonStreamingOptions);
+      const response = await client.messages.create(nonStreamingOptions, {
+        signal: request.signal
+      });
       logProviderPayload(
         "anthropic",
         "response payload",
@@ -1116,14 +1373,20 @@ var AnthropicAdapter = class {
           });
         }
       }
+      validateToolCalls(toolCalls);
+      if (toolCalls.length && response.stop_reason !== "tool_use")
+        throw invalidProviderResponse(
+          "Anthropic response ended with incomplete tool calls"
+        );
       return {
         content,
+        providerMetadata: anthropicReplay(response.content),
         toolCalls,
         thinking: thinking || void 0,
         usage: response.usage ? {
-          promptTokens: response.usage.input_tokens ?? 0,
+          promptTokens: anthropicInputTokens(response.usage),
           completionTokens: response.usage.output_tokens ?? 0,
-          totalTokens: (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0)
+          totalTokens: anthropicInputTokens(response.usage) + (response.usage.output_tokens ?? 0)
         } : void 0,
         rawResponse: response
       };
@@ -1143,28 +1406,33 @@ var AnthropicAdapter = class {
         options,
         request.debug
       );
-      const stream = await client.messages.stream(options);
+      const stream = await client.messages.stream(options, {
+        signal: request.signal
+      });
       let currentToolUse = null;
       let isInThinkingBlock = false;
+      const content = [];
+      const toolCalls = [];
+      let stopReason;
       const collectedCitations = [];
       let citationIndex = 0;
       let usage;
       for await (const event of stream) {
+        collectAnthropicContent(content, event);
         logProviderPayload("anthropic", "stream event", event, request.debug);
-        if (request.signal?.aborted) {
-          break;
-        }
+        throwIfAborted(request.signal);
         switch (event.type) {
           case "message_start":
             if (event.message?.usage) {
               usage = {
-                prompt_tokens: event.message.usage.input_tokens,
+                prompt_tokens: anthropicInputTokens(event.message.usage),
                 completion_tokens: 0,
-                total_tokens: event.message.usage.input_tokens
+                total_tokens: anthropicInputTokens(event.message.usage)
               };
             }
             break;
           case "message_delta":
+            if (event.delta?.stop_reason) stopReason = event.delta.stop_reason;
             if (event.usage && usage) {
               usage.completion_tokens = event.usage.output_tokens;
               usage.total_tokens = usage.prompt_tokens + event.usage.output_tokens;
@@ -1177,13 +1445,6 @@ var AnthropicAdapter = class {
                 name: event.content_block.name,
                 input: ""
               };
-              if (currentToolUse.name !== "web_search") {
-                yield {
-                  type: "action:start",
-                  id: currentToolUse.id,
-                  name: currentToolUse.name
-                };
-              }
             } else if (event.content_block.type === "web_search_tool_result") {
               const webSearchResult = event.content_block;
               if (webSearchResult.content && Array.isArray(webSearchResult.content)) {
@@ -1232,16 +1493,11 @@ var AnthropicAdapter = class {
           case "content_block_stop":
             if (currentToolUse) {
               if (currentToolUse.name !== "web_search") {
-                yield {
-                  type: "action:args",
-                  id: currentToolUse.id,
-                  args: currentToolUse.input
-                };
-                yield {
-                  type: "action:end",
+                toolCalls.push({
                   id: currentToolUse.id,
-                  name: currentToolUse.name
-                };
+                  name: currentToolUse.name,
+                  args: parseToolArguments(currentToolUse.input)
+                });
               }
               currentToolUse = null;
             }
@@ -1254,18 +1510,33 @@ var AnthropicAdapter = class {
             break;
         }
       }
+      throwIfAborted(request.signal);
+      if (!stopReason || currentToolUse)
+        throw invalidProviderResponse(
+          "Anthropic stream ended before its turn completed"
+        );
+      validateToolCalls(toolCalls);
+      if (toolCalls.length && stopReason !== "tool_use")
+        throw invalidProviderResponse(
+          "Anthropic stream ended with incomplete tool calls"
+        );
+      for (const call of toolCalls) {
+        yield { type: "action:start", id: call.id, name: call.name };
+        yield {
+          type: "action:args",
+          id: call.id,
+          args: JSON.stringify(call.args)
+        };
+        yield { type: "action:end", id: call.id, name: call.name };
+      }
       if (collectedCitations.length > 0) {
         const uniqueCitations = deduplicateCitations(collectedCitations);
         yield { type: "citation", citations: uniqueCitations };
       }
       yield { type: "message:end" };
-      yield { type: "done", usage };
+      yield { type: "done", usage, providerMetadata: anthropicReplay(content) };
     } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: "ANTHROPIC_ERROR"
-      };
+      yield providerErrorEvent(error, "ANTHROPIC_ERROR");
     }
   }
 };
@@ -1381,7 +1652,11 @@ function createAnthropic(config = {}) {
       apiKey,
       model: modelId,
       baseUrl: config.baseUrl,
-      thinking: config.thinkingBudget ? { type: "enabled", budgetTokens: config.thinkingBudget } : void 0
+      timeout: config.timeout,
+      headers: config.headers,
+      cacheControl: config.cacheControl,
+      thinking: config.thinking ?? (config.thinkingBudget ? { type: "enabled", budgetTokens: config.thinkingBudget } : void 0),
+      effort: config.effort
     });
   };
   const getCapabilities = (modelId) => {
@@ -1389,7 +1664,7 @@ function createAnthropic(config = {}) {
     return {
       supportsVision: model.vision,
       supportsTools: model.tools,
-      supportsThinking: model.thinking,
+      supportsThinking: anthropicModelRules(modelId).thinking,
       supportsStreaming: true,
       supportsPDF: true,
       supportsAudio: false,
@@ -1401,8 +1676,7 @@ function createAnthropic(config = {}) {
         "image/gif",
         "image/webp"
       ],
-      // Native `output_config.format` — GA on Claude 3.5 and newer.
-      supportsJsonMode: true,
+      supportsJsonMode: anthropicModelRules(modelId).structured,
       supportsSystemMessages: true
     };
   };