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

package/dist/adapters/index.js

@@ -103,6 +103,63 @@ function textToolOutput(value, fallback) {
   return toolOutputForProvider(value, "unsupported").map((part) => part.text).join("\n");
 }
 
+// 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/core/openai-parameters.ts
 function capabilities(model) {
   const gpt = /^gpt-(\d+)(?:\.(\d+))?(?:-(.+))?$/i.exec(model);
@@ -113,6 +170,19 @@ function capabilities(model) {
   const supportsNone = major === 5 && minor >= 1 && !chat || /^gpt-6-(?:sol|luna)(?:-\d{4}-\d{2}-\d{2})?$/i.test(model);
   return { major, minor, reasoning, supportsNone };
 }
+function filterOpenAIResponseInclude(model, include, options = {}) {
+  const c = capabilities(model);
+  let result = include;
+  if (options.parameterPolicy !== "passthrough" && c.reasoning && !(options.reasoningEffort === "none" && c.supportsNone) && include.includes("message.output_text.logprobs")) {
+    result = include.filter(
+      (value) => value !== "message.output_text.logprobs"
+    );
+    (options.onWarning ?? console.warn)(
+      `[llm-sdk] ${model}: omitted message.output_text.logprobs because reasoning is enabled.`
+    );
+  }
+  return result.length ? result : void 0;
+}
 function requiresOpenAIResponses(model, baseUrl, options = {}) {
   if (options.parameterPolicy === "passthrough") return false;
   const c = capabilities(model);
@@ -284,7 +354,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;
@@ -305,6 +390,7 @@ function toOpenAIResponseFormat(rf) {
   };
 }
 function toOpenAIResponsesTextFormat(rf) {
+  if (rf?.type === "json_object") return { type: "json_object" };
   if (!rf || rf.type !== "json_schema") return void 0;
   return {
     type: "json_schema",
@@ -526,21 +612,14 @@ function messageToOpenAIContent(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");
 }
@@ -551,6 +630,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 });
@@ -641,6 +728,63 @@ function formatMessagesForOpenAI(messages, systemPrompt, preserveProviderMetadat
   return formatted;
 }
 
+// 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/openai-responses.ts
 function resolveOpenAITransport(defaults, overrides) {
   return {
@@ -688,6 +832,54 @@ function responseMetadata(response) {
     }
   };
 }
+function responseReplayMetadata(metadata) {
+  const response = metadata?.openai?.response;
+  if (!response) return metadata;
+  const output = response.output.map((item) => {
+    const fields = ["type", "id", "status"];
+    switch (item.type) {
+      case "reasoning":
+        fields.push("encrypted_content");
+        break;
+      case "message":
+        fields.push("role", "phase");
+        break;
+      case "function_call":
+        fields.push("call_id", "name", "namespace", "arguments");
+        break;
+      case "tool_search_call":
+        fields.push("call_id", "execution", "arguments");
+        break;
+      case "tool_search_output":
+        fields.push("call_id", "tools");
+        break;
+      case "web_search_call":
+        fields.push("action");
+        break;
+      default:
+        return stripItemDiagnostics(item);
+    }
+    const replay = Object.fromEntries(
+      fields.filter((key) => item[key] !== void 0).map((key) => [key, item[key]])
+    );
+    if (item.type === "reasoning") replay.summary = [];
+    if (item.type === "message")
+      replay.content = Array.isArray(item.content) ? item.content.flatMap(
+        (part) => part?.type === "output_text" && typeof part.text === "string" ? [{ type: "output_text", text: part.text, annotations: [] }] : part?.type === "refusal" && typeof part.refusal === "string" ? [{ type: "refusal", refusal: part.refusal }] : []
+      ) : [];
+    return stripItemDiagnostics(replay);
+  });
+  return { openai: { response: { output, refusals: [] } } };
+}
+function stripItemDiagnostics(item) {
+  const {
+    usage: _usage,
+    logprobs: _logprobs,
+    metadata: _metadata,
+    ...state
+  } = item;
+  return state;
+}
 function getResponseReplay(metadata) {
   const response = metadata?.openai?.response;
   if (response === void 0) return void 0;
@@ -696,29 +888,7 @@ function getResponseReplay(metadata) {
       "Invalid OpenAI Responses replay metadata: output must contain typed items"
     );
   }
-  return response.output;
-}
-
-// src/core/provider-error.ts
-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;
+  return responseReplayMetadata(metadata)?.openai?.response?.output;
 }
 
 // src/core/utils.ts
@@ -754,6 +924,8 @@ var OpenAIAdapter = class _OpenAIAdapter {
         apiKey: this.config.apiKey,
         baseURL: this.config.baseUrl,
         organization: this.config.organization,
+        project: this.config.project,
+        timeout: this.config.timeout,
         defaultHeaders: this.config.headers
       });
     }
@@ -876,7 +1048,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
   formatRawMessages(messages, preserveProviderMetadata = false) {
     return messages.map((message) => {
       const { attachments, providerMetadata, modelOutput, ...rest } = message;
-      let content = message.role === "tool" && !preserveProviderMetadata ? textToolOutput(modelOutput, String(message.content ?? "")) : message.content;
+      let content = message.role === "tool" && !preserveProviderMetadata && modelOutput !== void 0 ? textToolOutput(modelOutput, "") : message.content;
       if (preserveProviderMetadata && modelOutput)
         rest.modelOutput = modelOutput;
       if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0 && content === "") {
@@ -979,17 +1151,32 @@ var OpenAIAdapter = class _OpenAIAdapter {
     const seenCallIds = /* @__PURE__ */ new Set();
     const toolCalls = Array.isArray(response?.output) ? response.output.filter((item) => item?.type === "function_call").map((item) => {
       if (typeof item.call_id !== "string" || !item.call_id || typeof item.name !== "string" || !item.name || typeof item.arguments !== "string" || item.status && item.status !== "completed") {
-        throw new Error("Responses contains an incomplete function call");
+        throw invalidProviderResponse(
+          "Responses contains an incomplete function call"
+        );
       }
       if (seenCallIds.has(item.call_id))
-        throw new Error("Responses contains duplicate function call IDs");
+        throw invalidProviderResponse(
+          "Responses contains duplicate function call IDs"
+        );
       seenCallIds.add(item.call_id);
-      const args = JSON.parse(item.arguments);
+      let args;
+      try {
+        args = JSON.parse(item.arguments);
+      } catch {
+        throw invalidProviderResponse(
+          "Responses function arguments must be valid JSON"
+        );
+      }
       if (!args || typeof args !== "object" || Array.isArray(args))
-        throw new Error(
+        throw invalidProviderResponse(
           "Responses function arguments must be a JSON object"
         );
-      return { id: item.call_id, name: item.name, args };
+      return {
+        id: item.call_id,
+        name: item.name,
+        args
+      };
     }) : [];
     return {
       content,
@@ -1020,6 +1207,16 @@ var OpenAIAdapter = class _OpenAIAdapter {
       request.config?.responseFormat
     );
     const modelIdForPayload = request.config?.model || this.model;
+    const include = filterOpenAIResponseInclude(
+      modelIdForPayload,
+      [
+        .../* @__PURE__ */ new Set([
+          ...options?.include ?? [],
+          ...options?.store === false ? ["reasoning.encrypted_content"] : []
+        ])
+      ],
+      this.parameterOptions(request)
+    );
     const payload = {
       model: modelIdForPayload,
       instructions: request.systemPrompt,
@@ -1043,14 +1240,7 @@ var OpenAIAdapter = class _OpenAIAdapter {
       ...options?.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {},
       ...options?.promptCacheOptions !== void 0 ? { prompt_cache_options: options.promptCacheOptions } : {},
       ...options?.promptCacheRetention !== void 0 ? { prompt_cache_retention: options.promptCacheRetention } : {},
-      ...options?.store === false || options?.include ? {
-        include: [
-          .../* @__PURE__ */ new Set([
-            ...options?.include ?? [],
-            ...options?.store === false ? ["reasoning.encrypted_content"] : []
-          ])
-        ]
-      } : {},
+      ...include ? { include } : {},
       ...responsesTextFormat ? { text: { format: responsesTextFormat } } : {},
       stream
     };
@@ -1232,7 +1422,9 @@ var OpenAIAdapter = class _OpenAIAdapter {
     const uniqueCalls = /* @__PURE__ */ new Map();
     for (const call of toolCalls.values()) {
       if (!call.id || !call.name)
-        throw new Error("Responses stream contains an incomplete tool call");
+        throw invalidProviderResponse(
+          "Responses stream contains an incomplete tool call"
+        );
       uniqueCalls.set(call.id, call);
     }
     toolCalls.clear();
@@ -1419,15 +1611,20 @@ var OpenAIAdapter = class _OpenAIAdapter {
       }
       throwIfAborted(request.signal);
       if (!finishReason)
-        throw new Error("OpenAI stream ended without a finish reason");
+        throw invalidProviderResponse(
+          "OpenAI stream ended without a finish reason"
+        );
       if (toolCalls.size && !["tool_calls", "function_call"].includes(finishReason)) {
-        throw new Error("OpenAI stream ended with incomplete tool calls");
-      }
-      for (const call of toolCalls.values()) {
-        if (!call.id || !call.name)
-          throw new Error("OpenAI stream contains an incomplete tool call");
-        JSON.parse(call.arguments || "{}");
+        throw invalidProviderResponse(
+          "OpenAI stream ended with incomplete tool calls"
+        );
       }
+      validateToolCalls(
+        [...toolCalls.values()].map((call) => ({
+          ...call,
+          args: parseToolArguments(call.arguments)
+        }))
+      );
       for (const call of toolCalls.values()) {
         yield {
           type: "action:start",
@@ -1511,20 +1708,20 @@ var OpenAIAdapter = class _OpenAIAdapter {
     logProviderPayload("openai", "response payload", response, request.debug);
     const choice = response.choices?.[0];
     const message = choice?.message;
+    const toolCalls = (message?.tool_calls ?? []).map((toolCall) => ({
+      id: toolCall.id,
+      name: toolCall.function?.name,
+      args: parseToolArguments(toolCall.function?.arguments ?? "{}"),
+      ...toolCall.extra_content ? { extra_content: toolCall.extra_content } : {}
+    }));
+    validateToolCalls(toolCalls);
+    if (toolCalls.length && choice?.finish_reason && !["tool_calls", "function_call"].includes(choice.finish_reason))
+      throw invalidProviderResponse(
+        "OpenAI response ended with incomplete tool calls"
+      );
     return {
       content: message?.content ?? "",
-      toolCalls: message?.tool_calls?.map((toolCall) => ({
-        id: toolCall.id ?? generateToolCallId(),
-        name: toolCall.function?.name ?? "",
-        args: (() => {
-          try {
-            return JSON.parse(toolCall.function?.arguments ?? "{}");
-          } catch {
-            return {};
-          }
-        })(),
-        ...toolCall.extra_content ? { extra_content: toolCall.extra_content } : {}
-      })) ?? [],
+      toolCalls,
       usage: response.usage ? {
         promptTokens: response.usage.prompt_tokens,
         completionTokens: response.usage.completion_tokens,
@@ -1557,6 +1754,52 @@ function createOpenAIAdapter(config) {
   return new OpenAIAdapter(config);
 }
 
+// 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/adapters/anthropic.ts
 var AnthropicAdapter = class {
   constructor(config) {
@@ -1568,7 +1811,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;
@@ -1605,6 +1851,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 });
@@ -1780,7 +2035,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) {
@@ -1802,7 +2057,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: {
@@ -1844,12 +2109,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) {
@@ -1868,15 +2146,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 };
   }
   /**
@@ -1896,7 +2172,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",
@@ -1919,14 +2197,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
       };
@@ -1946,28 +2230,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;
@@ -1980,13 +2269,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)) {
@@ -2035,16 +2317,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;
             }
@@ -2057,18 +2334,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 = deduplicateCitations2(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");
     }
   }
 };