@standardagents/anthropic 0.0.0-stub.ffffff → 0.17.1

package/dist/index.js

@@ -0,0 +1,1432 @@
+// src/AnthropicProvider.ts
+import { ProviderError, defineTool } from "@standardagents/spec";
+import { z } from "zod";
+
+// src/transformers.ts
+import { mapReasoningLevel } from "@standardagents/spec";
+
+// src/pricing.ts
+var TOKENS_PER_MILLION = 1e6;
+var CACHE_WRITE_5M_MULTIPLIER = 1.25;
+var CACHE_WRITE_1H_MULTIPLIER = 2;
+var CACHE_READ_MULTIPLIER = 0.1;
+var MODEL_PRICING = [
+  ["claude-fable-5", { inputPerMillion: 10, outputPerMillion: 50 }],
+  ["claude-mythos", { inputPerMillion: 10, outputPerMillion: 50 }],
+  ["claude-opus-4-8", { inputPerMillion: 5, outputPerMillion: 25 }],
+  ["claude-opus-4-7", { inputPerMillion: 5, outputPerMillion: 25 }],
+  ["claude-opus-4-6", { inputPerMillion: 5, outputPerMillion: 25 }],
+  ["claude-opus-4-5", { inputPerMillion: 5, outputPerMillion: 25 }],
+  ["claude-opus-4-1", { inputPerMillion: 15, outputPerMillion: 75 }],
+  ["claude-opus-4", { inputPerMillion: 15, outputPerMillion: 75 }],
+  ["claude-sonnet-4-6", { inputPerMillion: 3, outputPerMillion: 15 }],
+  ["claude-sonnet-4-5", { inputPerMillion: 3, outputPerMillion: 15 }],
+  ["claude-sonnet-4", { inputPerMillion: 3, outputPerMillion: 15 }],
+  ["claude-haiku-4-5", { inputPerMillion: 1, outputPerMillion: 5 }],
+  ["claude-3-7-sonnet", { inputPerMillion: 3, outputPerMillion: 15 }],
+  ["claude-3-5-sonnet", { inputPerMillion: 3, outputPerMillion: 15 }],
+  ["claude-3-5-haiku", { inputPerMillion: 0.8, outputPerMillion: 4 }],
+  ["claude-3-opus", { inputPerMillion: 15, outputPerMillion: 75 }],
+  ["claude-3-haiku", { inputPerMillion: 0.25, outputPerMillion: 1.25 }]
+];
+function getAnthropicModelPricing(modelId) {
+  if (!modelId) return null;
+  const normalized = modelId.trim().toLowerCase();
+  let best = null;
+  for (const [prefix, pricing] of MODEL_PRICING) {
+    if (normalized.startsWith(prefix) && (!best || prefix.length > best.prefix.length)) {
+      best = { prefix, pricing };
+    }
+  }
+  return best ? { ...best.pricing } : null;
+}
+function extractUsageBuckets(usage) {
+  const totalCacheWrite = usage.cache_creation_input_tokens ?? 0;
+  const write1h = usage.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+  const write5m = usage.cache_creation?.ephemeral_5m_input_tokens ?? Math.max(totalCacheWrite - write1h, 0);
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+    cacheWrite5mTokens: write5m,
+    cacheWrite1hTokens: write1h
+  };
+}
+function roundCost(value) {
+  return Number(value.toFixed(12));
+}
+function calculateAnthropicUsageCost(modelId, buckets) {
+  const pricing = getAnthropicModelPricing(modelId);
+  if (!pricing) return void 0;
+  const inputRate = pricing.inputPerMillion / TOKENS_PER_MILLION;
+  const outputRate = pricing.outputPerMillion / TOKENS_PER_MILLION;
+  const cost = buckets.inputTokens * inputRate + buckets.cacheWrite5mTokens * inputRate * CACHE_WRITE_5M_MULTIPLIER + buckets.cacheWrite1hTokens * inputRate * CACHE_WRITE_1H_MULTIPLIER + buckets.cacheReadTokens * inputRate * CACHE_READ_MULTIPLIER + buckets.outputTokens * outputRate;
+  return roundCost(cost);
+}
+
+// src/transformers.ts
+var THINKING_FORMAT = "anthropic-thinking-v1";
+var REDACTED_THINKING_FORMAT = "anthropic-redacted-thinking-v1";
+var DEFAULT_REASONING_LEVELS = {
+  0: null,
+  33: "low",
+  66: "medium",
+  100: "high"
+};
+var ANTHROPIC_NATIVE_TOOLS = /* @__PURE__ */ new Set(["web_search"]);
+var DEFAULT_MAX_OUTPUT_TOKENS = 8192;
+var THINKING_MODE_PREFIXES = [
+  ["claude-fable-5", "adaptive"],
+  ["claude-mythos", "adaptive"],
+  ["claude-opus-4-8", "adaptive"],
+  ["claude-opus-4-7", "adaptive"],
+  ["claude-opus-4-6", "adaptive"],
+  ["claude-opus-4-5", "budget"],
+  ["claude-opus-4-1", "budget"],
+  ["claude-opus-4-0", "budget"],
+  ["claude-opus-4-2", "budget"],
+  // dated full IDs like claude-opus-4-20250514
+  ["claude-sonnet-4-6", "adaptive"],
+  ["claude-sonnet-4-5", "budget"],
+  ["claude-sonnet-4-0", "budget"],
+  ["claude-sonnet-4-2", "budget"],
+  // dated full IDs like claude-sonnet-4-20250514
+  ["claude-haiku-4-5", "budget"],
+  ["claude-3-7-sonnet", "budget"],
+  ["claude-3", "none"]
+];
+function getThinkingMode(modelId) {
+  for (const [prefix, mode] of THINKING_MODE_PREFIXES) {
+    if (modelId.startsWith(prefix)) {
+      return mode;
+    }
+  }
+  return "adaptive";
+}
+function parseDataUri(value) {
+  const match = /^data:([^;,]+)?(;base64)?,(.*)$/s.exec(value);
+  if (!match) return null;
+  return {
+    mediaType: match[1] || "application/octet-stream",
+    data: match[3]
+  };
+}
+var SUPPORTED_IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+function normalizeImageMediaType(mediaType) {
+  if (mediaType && SUPPORTED_IMAGE_MEDIA_TYPES.has(mediaType)) {
+    return mediaType;
+  }
+  return "image/png";
+}
+function imageBlock(data, mediaType) {
+  if (data.startsWith("http://") || data.startsWith("https://")) {
+    return { type: "image", source: { type: "url", url: data } };
+  }
+  const parsed = parseDataUri(data);
+  if (parsed) {
+    return {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: normalizeImageMediaType(parsed.mediaType),
+        data: parsed.data
+      }
+    };
+  }
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: normalizeImageMediaType(mediaType),
+      data
+    }
+  };
+}
+function decodeBase64Text(data) {
+  try {
+    const binary = atob(data);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return data;
+  }
+}
+function fileBlock(data, mediaType, filename) {
+  const parsed = parseDataUri(data);
+  const base64 = parsed ? parsed.data : data;
+  const resolvedMediaType = parsed?.mediaType || mediaType;
+  if (data.startsWith("http://") || data.startsWith("https://")) {
+    return { type: "document", source: { type: "url", url: data } };
+  }
+  if (resolvedMediaType === "application/pdf") {
+    return {
+      type: "document",
+      source: { type: "base64", media_type: "application/pdf", data: base64 },
+      ...filename ? { title: filename } : {}
+    };
+  }
+  if (resolvedMediaType.startsWith("text/") || resolvedMediaType === "application/json") {
+    return {
+      type: "document",
+      source: { type: "text", media_type: "text/plain", data: decodeBase64Text(base64) },
+      ...filename ? { title: filename } : {}
+    };
+  }
+  return {
+    type: "text",
+    text: `[Unsupported file attachment${filename ? `: ${filename}` : ""} (${resolvedMediaType})]`
+  };
+}
+function transformContentPart(part) {
+  if (part.type === "text") {
+    return { type: "text", text: part.text };
+  }
+  if (part.type === "image") {
+    return imageBlock(part.data || "", part.mediaType);
+  }
+  if (part.type === "image_url") {
+    return imageBlock(part.image_url?.url || "");
+  }
+  return fileBlock(part.data || "", part.mediaType || "application/octet-stream", part.filename);
+}
+function transformMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map(transformContentPart);
+}
+function transformAssistantMessage(msg) {
+  const content = [];
+  if (msg.reasoningDetails) {
+    for (const detail of msg.reasoningDetails) {
+      if (detail.format === THINKING_FORMAT && detail.text !== void 0) {
+        content.push({
+          type: "thinking",
+          thinking: detail.text,
+          signature: detail.data ?? ""
+        });
+      } else if (detail.format === REDACTED_THINKING_FORMAT && detail.data) {
+        content.push({ type: "redacted_thinking", data: detail.data });
+      }
+    }
+  }
+  if (msg.content) {
+    content.push({ type: "text", text: msg.content });
+  }
+  if (msg.toolCalls) {
+    for (const tc of msg.toolCalls) {
+      if (ANTHROPIC_NATIVE_TOOLS.has(tc.name)) {
+        continue;
+      }
+      content.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.name,
+        input: tc.arguments
+      });
+    }
+  }
+  if (content.length === 0) {
+    return null;
+  }
+  return { role: "assistant", content };
+}
+function transformToolMessage(msg) {
+  if (ANTHROPIC_NATIVE_TOOLS.has(msg.toolName)) {
+    return null;
+  }
+  let text;
+  let isError = false;
+  if (typeof msg.content === "string") {
+    text = msg.content;
+  } else if ("type" in msg.content) {
+    if (msg.content.type === "text") {
+      text = msg.content.text;
+    } else if (msg.content.type === "error") {
+      text = msg.content.error;
+      isError = true;
+    } else {
+      text = JSON.stringify(msg.content);
+    }
+  } else {
+    text = JSON.stringify(msg.content);
+  }
+  const blocks = [];
+  if (text) {
+    blocks.push({ type: "text", text });
+  }
+  if (msg.attachments?.length) {
+    for (const attachment of msg.attachments) {
+      if (attachment.type === "image" && attachment.data) {
+        blocks.push(imageBlock(attachment.data, attachment.mediaType));
+      }
+    }
+  }
+  return {
+    type: "tool_result",
+    tool_use_id: msg.toolCallId,
+    ...blocks.length > 0 ? { content: blocks } : {},
+    ...isError ? { is_error: true } : {}
+  };
+}
+function transformMessages(messages) {
+  let system;
+  const anthropicMessages = [];
+  let pendingToolResults = [];
+  const flushToolResults = () => {
+    if (pendingToolResults.length > 0) {
+      anthropicMessages.push({ role: "user", content: pendingToolResults });
+      pendingToolResults = [];
+    }
+  };
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "system":
+        system = system ? `${system}
+
+${msg.content}` : msg.content;
+        break;
+      case "user":
+        flushToolResults();
+        anthropicMessages.push({
+          role: "user",
+          content: transformMessageContent(msg.content)
+        });
+        break;
+      case "assistant": {
+        flushToolResults();
+        const assistantMessage = transformAssistantMessage(msg);
+        if (assistantMessage) {
+          anthropicMessages.push(assistantMessage);
+        }
+        break;
+      }
+      case "tool": {
+        const toolResult = transformToolMessage(msg);
+        if (toolResult) {
+          pendingToolResults.push(toolResult);
+        }
+        break;
+      }
+    }
+  }
+  flushToolResults();
+  return { anthropicMessages, system };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function transformTool(tool) {
+  const parameters = isRecord(tool.function.parameters) ? tool.function.parameters : { type: "object", properties: {} };
+  return {
+    name: tool.function.name,
+    ...tool.function.description ? { description: tool.function.description } : {},
+    input_schema: {
+      ...parameters,
+      type: "object"
+    }
+  };
+}
+function transformTools(tools) {
+  const result = [];
+  for (const tool of tools) {
+    const toolName = tool.function.name;
+    if (tool.executionMode === "provider" && ANTHROPIC_NATIVE_TOOLS.has(toolName)) {
+      if (toolName === "web_search") {
+        result.push({ type: "web_search_20250305", name: "web_search" });
+      }
+    } else {
+      result.push(transformTool(tool));
+    }
+  }
+  return result;
+}
+function transformToolChoice(choice, parallelToolCalls) {
+  const disable = parallelToolCalls === false ? { disable_parallel_tool_use: true } : {};
+  if (choice === "none") {
+    return { type: "none" };
+  }
+  if (choice === "required") {
+    return { type: "any", ...disable };
+  }
+  if (typeof choice === "object" && choice !== null && "name" in choice) {
+    return { type: "tool", name: choice.name, ...disable };
+  }
+  if (choice === "auto" || parallelToolCalls === false) {
+    return { type: "auto", ...disable };
+  }
+  return void 0;
+}
+function mapFinishReason(stopReason) {
+  switch (stopReason) {
+    case "end_turn":
+    case "stop_sequence":
+    case "pause_turn":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool_calls";
+    case "refusal":
+      return "content_filter";
+    default:
+      return "stop";
+  }
+}
+function extractTextContent(content) {
+  const textParts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      textParts.push(block.text);
+    }
+  }
+  return textParts.length > 0 ? textParts.join("") : null;
+}
+function extractReasoningContent(content) {
+  let reasoning = null;
+  const reasoningDetails = [];
+  for (const block of content) {
+    if (block.type === "thinking") {
+      if (block.thinking) {
+        reasoning = reasoning ? `${reasoning}
+${block.thinking}` : block.thinking;
+      }
+      reasoningDetails.push({
+        type: "text",
+        text: block.thinking,
+        data: block.signature,
+        format: THINKING_FORMAT
+      });
+    } else if (block.type === "redacted_thinking") {
+      reasoningDetails.push({
+        type: "encrypted",
+        data: block.data,
+        format: REDACTED_THINKING_FORMAT
+      });
+    }
+  }
+  return {
+    reasoning,
+    reasoningDetails: reasoningDetails.length > 0 ? reasoningDetails : void 0
+  };
+}
+function extractToolCalls(content) {
+  const toolCalls = [];
+  for (const block of content) {
+    if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        name: block.name,
+        arguments: isRecord(block.input) ? block.input : {}
+      });
+    }
+  }
+  return toolCalls.length > 0 ? toolCalls : void 0;
+}
+function webSearchToolResult(id, input, resultContent) {
+  const query = isRecord(input) && typeof input.query === "string" ? input.query : void 0;
+  let status = "completed";
+  let sources;
+  if (Array.isArray(resultContent)) {
+    sources = resultContent.filter(isRecord).filter((item) => item.type === "web_search_result" && typeof item.url === "string").map((item) => ({
+      type: "url",
+      url: item.url,
+      ...typeof item.title === "string" ? { title: item.title } : {}
+    }));
+  } else if (isRecord(resultContent) && resultContent.type === "web_search_tool_result_error") {
+    status = "failed";
+  }
+  return {
+    name: "web_search",
+    type: "web_search",
+    provider: "anthropic",
+    id,
+    status,
+    result: {
+      actions: [{
+        type: "search",
+        ...query ? { query } : {},
+        ...sources && sources.length > 0 ? { sources } : {}
+      }]
+    }
+  };
+}
+function extractProviderToolResults(content) {
+  const providerTools = [];
+  const serverToolUses = /* @__PURE__ */ new Map();
+  for (const block of content) {
+    if (block.type === "server_tool_use") {
+      serverToolUses.set(block.id, { name: block.name, input: block.input });
+    } else if (block.type === "web_search_tool_result") {
+      const use = serverToolUses.get(block.tool_use_id);
+      providerTools.push(
+        webSearchToolResult(block.tool_use_id, use?.input, block.content)
+      );
+    }
+  }
+  return providerTools.length > 0 ? providerTools : void 0;
+}
+function transformUsage(usage, modelId) {
+  if (!usage) {
+    return { promptTokens: 0, completionTokens: 0, totalTokens: 0, provider: "anthropic" };
+  }
+  const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+  const cacheRead = usage.cache_read_input_tokens ?? 0;
+  const promptTokens = usage.input_tokens + cacheCreation + cacheRead;
+  const completionTokens = usage.output_tokens;
+  const reasoningTokens = usage.output_tokens_details?.thinking_tokens;
+  const cost = modelId ? calculateAnthropicUsageCost(modelId, extractUsageBuckets(usage)) : void 0;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    ...reasoningTokens !== void 0 ? { reasoningTokens } : {},
+    ...cacheRead > 0 ? { cachedTokens: cacheRead } : {},
+    ...cost !== void 0 ? { cost } : {},
+    provider: "anthropic"
+  };
+}
+function transformResponse(message) {
+  const content = extractTextContent(message.content);
+  const { reasoning, reasoningDetails } = extractReasoningContent(message.content);
+  const toolCalls = extractToolCalls(message.content);
+  const providerTools = extractProviderToolResults(message.content);
+  return {
+    content,
+    reasoning,
+    reasoningDetails,
+    toolCalls,
+    providerTools,
+    finishReason: mapFinishReason(message.stop_reason),
+    usage: transformUsage(message.usage, message.model),
+    metadata: {
+      model: message.model,
+      provider: "anthropic",
+      requestId: message.id,
+      ...message.stop_sequence ? { stopSequence: message.stop_sequence } : {},
+      ...message.usage?.cache_creation_input_tokens ? { cacheCreationInputTokens: message.usage.cache_creation_input_tokens } : {},
+      ...message.usage?.cache_read_input_tokens ? { cacheReadInputTokens: message.usage.cache_read_input_tokens } : {},
+      ...message.usage?.service_tier ? { serviceTier: message.usage.service_tier } : {},
+      ...message.usage?.server_tool_use ? { serverToolUse: { ...message.usage.server_tool_use } } : {}
+    }
+  };
+}
+function resolveThinkingOverride(value) {
+  if (!isRecord(value)) return void 0;
+  const display = value.display === "summarized" || value.display === "omitted" ? value.display : void 0;
+  if (value.type === "adaptive") {
+    return { type: "adaptive", ...display ? { display } : {} };
+  }
+  if (value.type === "enabled" && typeof value.budget_tokens === "number") {
+    return {
+      type: "enabled",
+      budget_tokens: value.budget_tokens,
+      ...display ? { display } : {}
+    };
+  }
+  if (value.type === "disabled") {
+    return { type: "disabled" };
+  }
+  return void 0;
+}
+function resolveThinkingBudget(level, maxTokens, explicitBudget) {
+  if (maxTokens < 2048) {
+    return null;
+  }
+  const ceiling = maxTokens - 1024;
+  const scaled = explicitBudget ?? Math.floor(maxTokens * Math.min(level, 100) / 100 * 0.75);
+  return Math.max(1024, Math.min(scaled, ceiling));
+}
+function buildCreateParams(request, reasoningLevels = DEFAULT_REASONING_LEVELS, defaultMaxTokens = DEFAULT_MAX_OUTPUT_TOKENS) {
+  const { anthropicMessages, system } = transformMessages(request.messages);
+  const maxTokens = request.maxOutputTokens ?? defaultMaxTokens;
+  const params = {
+    model: request.model,
+    max_tokens: maxTokens,
+    messages: anthropicMessages
+  };
+  const providerOptions = isRecord(request.providerOptions) ? request.providerOptions : {};
+  const {
+    cacheSystemPrompt,
+    thinking: thinkingOverride,
+    ...passthroughOptions
+  } = providerOptions;
+  let systemText = system;
+  if (request.responseFormat?.type === "json") {
+    if (request.responseFormat.schema) {
+      params.output_config = {
+        format: { type: "json_schema", schema: request.responseFormat.schema }
+      };
+    } else {
+      const jsonInstruction = "Respond with valid JSON only. Do not include any text outside the JSON.";
+      systemText = systemText ? `${systemText}
+
+${jsonInstruction}` : jsonInstruction;
+    }
+  }
+  if (systemText) {
+    params.system = cacheSystemPrompt === true ? [{ type: "text", text: systemText, cache_control: { type: "ephemeral" } }] : systemText;
+  }
+  if (request.tools && request.tools.length > 0) {
+    params.tools = transformTools(request.tools);
+  }
+  const toolChoice = transformToolChoice(request.toolChoice, request.parallelToolCalls);
+  if (toolChoice && params.tools && params.tools.length > 0) {
+    params.tool_choice = toolChoice;
+  }
+  const thinkingMode = getThinkingMode(request.model);
+  let thinkingEnabled = false;
+  const resolvedOverride = resolveThinkingOverride(thinkingOverride);
+  if (resolvedOverride) {
+    params.thinking = resolvedOverride;
+    thinkingEnabled = resolvedOverride.type !== "disabled";
+  } else if (request.reasoning?.level !== void 0 && request.reasoning.level > 0) {
+    if (thinkingMode === "adaptive") {
+      params.thinking = {
+        type: "adaptive",
+        ...request.reasoning.exclude ? { display: "omitted" } : {}
+      };
+      const effort = mapReasoningLevel(request.reasoning.level, reasoningLevels);
+      if (effort) {
+        params.output_config = {
+          ...params.output_config,
+          effort
+        };
+      }
+      thinkingEnabled = true;
+    } else if (thinkingMode === "budget") {
+      const budget = resolveThinkingBudget(
+        request.reasoning.level,
+        maxTokens,
+        request.reasoning.maxTokens
+      );
+      if (budget !== null) {
+        params.thinking = {
+          type: "enabled",
+          budget_tokens: budget,
+          ...request.reasoning.exclude ? { display: "omitted" } : {}
+        };
+        thinkingEnabled = true;
+      }
+    }
+  }
+  if (!thinkingEnabled) {
+    if (request.temperature !== void 0) {
+      params.temperature = request.temperature;
+    }
+    if (request.topP !== void 0) {
+      params.top_p = request.topP;
+    }
+    if (request.topK !== void 0) {
+      params.top_k = request.topK;
+    }
+  }
+  if (request.stopSequences && request.stopSequences.length > 0) {
+    params.stop_sequences = request.stopSequences;
+  }
+  Object.assign(params, passthroughOptions);
+  return params;
+}
+function createStreamState() {
+  return {
+    toolCallsByIndex: /* @__PURE__ */ new Map(),
+    thinkingByIndex: /* @__PURE__ */ new Map(),
+    serverToolsByIndex: /* @__PURE__ */ new Map(),
+    pendingServerTools: /* @__PURE__ */ new Map(),
+    reasoningDetails: [],
+    hasContent: false,
+    hasReasoning: false,
+    usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, provider: "anthropic" },
+    buckets: {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWrite5mTokens: 0,
+      cacheWrite1hTokens: 0
+    },
+    finishReason: "stop",
+    model: null,
+    messageId: null,
+    serverToolUse: null
+  };
+}
+function parseToolCallArguments(argumentsJson) {
+  try {
+    const parsed = argumentsJson ? JSON.parse(argumentsJson) : {};
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function applyDeltaUsage(state, usage) {
+  const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+  const cacheRead = usage.cache_read_input_tokens ?? 0;
+  if (usage.input_tokens !== null && usage.input_tokens !== void 0) {
+    state.usage.promptTokens = usage.input_tokens + cacheCreation + cacheRead;
+    if (cacheRead > 0) {
+      state.usage.cachedTokens = cacheRead;
+    }
+    state.buckets.inputTokens = usage.input_tokens;
+    state.buckets.cacheReadTokens = cacheRead;
+    state.buckets.cacheWrite5mTokens = Math.max(
+      cacheCreation - state.buckets.cacheWrite1hTokens,
+      0
+    );
+  }
+  state.buckets.outputTokens = usage.output_tokens;
+  state.usage.completionTokens = usage.output_tokens;
+  const thinkingTokens = usage.output_tokens_details?.thinking_tokens;
+  if (thinkingTokens !== void 0) {
+    state.usage.reasoningTokens = thinkingTokens;
+  }
+  state.usage.totalTokens = state.usage.promptTokens + state.usage.completionTokens;
+  if (usage.server_tool_use) {
+    state.serverToolUse = { ...usage.server_tool_use };
+  }
+}
+function processStreamEvent(event, state) {
+  const chunks = [];
+  switch (event.type) {
+    case "message_start": {
+      const usage = event.message.usage;
+      const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+      const cacheRead = usage.cache_read_input_tokens ?? 0;
+      state.usage.promptTokens = usage.input_tokens + cacheCreation + cacheRead;
+      if (cacheRead > 0) {
+        state.usage.cachedTokens = cacheRead;
+      }
+      state.usage.completionTokens = usage.output_tokens;
+      state.usage.totalTokens = state.usage.promptTokens + state.usage.completionTokens;
+      state.buckets = extractUsageBuckets(usage);
+      state.model = event.message.model;
+      state.messageId = event.message.id;
+      break;
+    }
+    case "content_block_start": {
+      const block = event.content_block;
+      if (block.type === "tool_use") {
+        state.toolCallsByIndex.set(event.index, {
+          id: block.id,
+          name: block.name,
+          argumentsJson: ""
+        });
+        chunks.push({ type: "tool-call-start", id: block.id, name: block.name });
+      } else if (block.type === "thinking") {
+        state.thinkingByIndex.set(event.index, {
+          thinking: block.thinking || "",
+          signature: block.signature || ""
+        });
+      } else if (block.type === "redacted_thinking") {
+        state.reasoningDetails.push({
+          type: "encrypted",
+          data: block.data,
+          format: REDACTED_THINKING_FORMAT
+        });
+      } else if (block.type === "server_tool_use") {
+        state.serverToolsByIndex.set(event.index, {
+          id: block.id,
+          name: block.name,
+          inputJson: ""
+        });
+      } else if (block.type === "web_search_tool_result") {
+        const use = state.pendingServerTools.get(block.tool_use_id);
+        chunks.push({
+          type: "provider-tool-done",
+          tool: webSearchToolResult(block.tool_use_id, use?.input, block.content)
+        });
+        state.pendingServerTools.delete(block.tool_use_id);
+      }
+      break;
+    }
+    case "content_block_delta": {
+      const delta = event.delta;
+      if (delta.type === "text_delta") {
+        state.hasContent = true;
+        chunks.push({ type: "content-delta", delta: delta.text });
+      } else if (delta.type === "thinking_delta") {
+        state.hasReasoning = true;
+        const thinkingBlock = state.thinkingByIndex.get(event.index);
+        if (thinkingBlock) {
+          thinkingBlock.thinking += delta.thinking;
+        }
+        chunks.push({ type: "reasoning-delta", delta: delta.thinking });
+      } else if (delta.type === "signature_delta") {
+        const thinkingBlock = state.thinkingByIndex.get(event.index);
+        if (thinkingBlock) {
+          thinkingBlock.signature += delta.signature;
+        }
+      } else if (delta.type === "input_json_delta") {
+        const toolCall = state.toolCallsByIndex.get(event.index);
+        if (toolCall) {
+          toolCall.argumentsJson += delta.partial_json;
+          chunks.push({
+            type: "tool-call-delta",
+            id: toolCall.id,
+            argumentsDelta: delta.partial_json
+          });
+        } else {
+          const serverTool = state.serverToolsByIndex.get(event.index);
+          if (serverTool) {
+            serverTool.inputJson += delta.partial_json;
+          }
+        }
+      }
+      break;
+    }
+    case "content_block_stop": {
+      const toolCall = state.toolCallsByIndex.get(event.index);
+      if (toolCall) {
+        chunks.push({
+          type: "tool-call-done",
+          id: toolCall.id,
+          arguments: parseToolCallArguments(toolCall.argumentsJson)
+        });
+        state.toolCallsByIndex.delete(event.index);
+        break;
+      }
+      const thinkingBlock = state.thinkingByIndex.get(event.index);
+      if (thinkingBlock) {
+        state.reasoningDetails.push({
+          type: "text",
+          text: thinkingBlock.thinking,
+          data: thinkingBlock.signature,
+          format: THINKING_FORMAT
+        });
+        state.thinkingByIndex.delete(event.index);
+        break;
+      }
+      const serverTool = state.serverToolsByIndex.get(event.index);
+      if (serverTool) {
+        state.pendingServerTools.set(serverTool.id, {
+          name: serverTool.name,
+          input: parseToolCallArguments(serverTool.inputJson)
+        });
+        state.serverToolsByIndex.delete(event.index);
+      }
+      break;
+    }
+    case "message_delta": {
+      if (event.delta.stop_reason) {
+        state.finishReason = mapFinishReason(event.delta.stop_reason);
+      }
+      applyDeltaUsage(state, event.usage);
+      break;
+    }
+    case "message_stop": {
+      if (state.hasContent) {
+        chunks.push({ type: "content-done" });
+      }
+      if (state.hasReasoning) {
+        chunks.push({ type: "reasoning-done" });
+      }
+      const cost = calculateAnthropicUsageCost(state.model, state.buckets);
+      chunks.push({
+        type: "finish",
+        finishReason: state.finishReason,
+        usage: { ...state.usage, ...cost !== void 0 ? { cost } : {} },
+        ...state.reasoningDetails.length > 0 ? { reasoningDetails: [...state.reasoningDetails] } : {}
+      });
+      break;
+    }
+    default:
+      break;
+  }
+  return chunks;
+}
+function createErrorChunk(error, code) {
+  return { type: "error", error, code };
+}
+function isBase64Like(str) {
+  if (str.startsWith("data:")) return true;
+  if (str.length > 200) {
+    const base64Pattern = /^[A-Za-z0-9+/]+=*$/;
+    return base64Pattern.test(str.substring(0, 200));
+  }
+  return false;
+}
+function truncateBase64String(str, maxLength = 50) {
+  if (str.length <= maxLength) return str;
+  const preview = str.substring(0, maxLength);
+  return `${preview}...[truncated, ${str.length.toLocaleString()} chars]`;
+}
+function truncateBase64(obj, maxLength = 50) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    if (isBase64Like(obj)) {
+      return truncateBase64String(obj, maxLength);
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => truncateBase64(item, maxLength));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = truncateBase64(value, maxLength);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/icons.ts
+var ANTHROPIC_ICON = `<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48" fill="none">
+<rect width="48" height="48" fill="#F0EFEA"/>
+<path d="M32.84 10H26.72L37.88 38H44L32.84 10Z" fill="black"/>
+<path d="M15.16 10L4 38H10.24L12.5224 32.12H24.1976L26.48 38H32.72L21.56 10H15.16ZM14.5408 26.92L18.36 17.08L22.1793 26.92H14.5408Z" fill="black"/>
+</svg>`;
+function svgToDataUri(svg) {
+  const encoded = encodeURIComponent(svg).replace(/'/g, "%27").replace(/"/g, "%22");
+  return `data:image/svg+xml,${encoded}`;
+}
+function normalizeIcon(icon) {
+  if (icon.startsWith("data:") || icon.endsWith(".svg") || icon.includes(".svg?")) {
+    return icon;
+  }
+  return svgToDataUri(icon);
+}
+function getAnthropicIconDataUri() {
+  return normalizeIcon(ANTHROPIC_ICON);
+}
+
+// src/AnthropicProvider.ts
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseRetryAfter(headers) {
+  let raw;
+  if (isObjectLike(headers)) {
+    const get = headers.get;
+    if (typeof get === "function") {
+      raw = get.call(headers, "retry-after");
+    } else {
+      raw = headers["retry-after"];
+    }
+  }
+  if (typeof raw === "number") {
+    return raw;
+  }
+  if (typeof raw === "string") {
+    const parsed = parseInt(raw, 10);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  }
+  return void 0;
+}
+var ADAPTIVE_REASONING_LEVELS = DEFAULT_REASONING_LEVELS;
+var BUDGET_REASONING_LEVELS = { 0: null, 100: "enabled" };
+var NO_REASONING_LEVELS = { 0: null };
+var AnthropicProvider = class _AnthropicProvider {
+  name = "anthropic";
+  specificationVersion = "1";
+  client = null;
+  config;
+  /** Cache for models list to avoid repeated API calls */
+  static modelsCache = null;
+  static modelsCacheTime = 0;
+  static CACHE_TTL = 5 * 60 * 1e3;
+  // 5 minutes
+  constructor(config) {
+    this.config = config;
+  }
+  async getClient() {
+    if (!this.client) {
+      const { default: Anthropic } = await import("@anthropic-ai/sdk");
+      this.client = new Anthropic({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl,
+        timeout: this.config.timeout
+      });
+    }
+    return this.client;
+  }
+  supportsModel(modelId) {
+    return modelId.startsWith("claude-");
+  }
+  /**
+   * Get the icon for this provider as a data URI.
+   * Always returns the Anthropic icon since all models are from Anthropic.
+   */
+  getIcon(_modelId) {
+    return getAnthropicIconDataUri();
+  }
+  // ============================================================================
+  // Model Capabilities
+  // ============================================================================
+  /**
+   * Capability mappings for Anthropic models, keyed by model ID prefix.
+   * Used as a fallback when the live Models API is unavailable; the API's
+   * capability listing takes precedence when reachable.
+   */
+  static MODEL_CAPABILITIES = {
+    "claude-fable-5": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1e6,
+      maxOutputTokens: 128e3,
+      reasoningLevels: ADAPTIVE_REASONING_LEVELS
+    },
+    "claude-mythos": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1e6,
+      maxOutputTokens: 128e3,
+      reasoningLevels: ADAPTIVE_REASONING_LEVELS
+    },
+    "claude-opus-4-8": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1e6,
+      maxOutputTokens: 128e3,
+      reasoningLevels: ADAPTIVE_REASONING_LEVELS
+    },
+    "claude-opus-4-7": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1e6,
+      maxOutputTokens: 128e3,
+      reasoningLevels: ADAPTIVE_REASONING_LEVELS
+    },
+    "claude-opus-4-6": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1e6,
+      maxOutputTokens: 128e3,
+      reasoningLevels: ADAPTIVE_REASONING_LEVELS
+    },
+    "claude-opus-4-5": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 64e3,
+      reasoningLevels: BUDGET_REASONING_LEVELS
+    },
+    "claude-opus-4-1": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 32e3,
+      reasoningLevels: BUDGET_REASONING_LEVELS
+    },
+    "claude-opus-4": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 32e3,
+      reasoningLevels: BUDGET_REASONING_LEVELS
+    },
+    "claude-sonnet-4-6": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1e6,
+      maxOutputTokens: 64e3,
+      reasoningLevels: ADAPTIVE_REASONING_LEVELS
+    },
+    "claude-sonnet-4-5": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 64e3,
+      reasoningLevels: BUDGET_REASONING_LEVELS
+    },
+    "claude-sonnet-4": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 64e3,
+      reasoningLevels: BUDGET_REASONING_LEVELS
+    },
+    "claude-haiku-4-5": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 64e3,
+      reasoningLevels: BUDGET_REASONING_LEVELS
+    },
+    "claude-3-7-sonnet": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 64e3,
+      reasoningLevels: BUDGET_REASONING_LEVELS
+    },
+    "claude-3-5-sonnet": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 8192,
+      reasoningLevels: NO_REASONING_LEVELS
+    },
+    "claude-3-5-haiku": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 8192,
+      reasoningLevels: NO_REASONING_LEVELS
+    },
+    "claude-3-opus": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 4096,
+      reasoningLevels: NO_REASONING_LEVELS
+    },
+    "claude-3-haiku": {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 4096,
+      reasoningLevels: NO_REASONING_LEVELS
+    }
+  };
+  /**
+   * Look up static capabilities for a model by exact then prefix match.
+   */
+  static lookupStaticCapabilities(modelId) {
+    if (_AnthropicProvider.MODEL_CAPABILITIES[modelId]) {
+      return { ..._AnthropicProvider.MODEL_CAPABILITIES[modelId] };
+    }
+    let best = null;
+    for (const [prefix, caps] of Object.entries(_AnthropicProvider.MODEL_CAPABILITIES)) {
+      if (modelId.startsWith(prefix) && (!best || prefix.length > best.prefix.length)) {
+        best = { prefix, caps };
+      }
+    }
+    return best ? { ...best.caps } : null;
+  }
+  /**
+   * Map a live Models API capability listing to Standard Agents capabilities.
+   */
+  static mapLiveCapabilities(model) {
+    const caps = model.capabilities;
+    if (!caps) return null;
+    let reasoningLevels;
+    if (caps.thinking.types.adaptive.supported && caps.effort.supported) {
+      reasoningLevels = ADAPTIVE_REASONING_LEVELS;
+    } else if (caps.thinking.supported) {
+      reasoningLevels = BUDGET_REASONING_LEVELS;
+    } else {
+      reasoningLevels = NO_REASONING_LEVELS;
+    }
+    return {
+      supportsImages: caps.image_input.supported,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: caps.structured_outputs.supported,
+      ...model.max_input_tokens ? { maxContextTokens: model.max_input_tokens } : {},
+      ...model.max_tokens ? { maxOutputTokens: model.max_tokens } : {},
+      reasoningLevels
+    };
+  }
+  /**
+   * Get capabilities for a specific model.
+   * Prefers the live Models API (which reports per-model capability flags)
+   * and falls back to the static prefix table when the API is unreachable.
+   */
+  async getModelCapabilities(modelId) {
+    try {
+      const models = await this.fetchModelsWithCache();
+      const model = models.find((m) => m.id === modelId);
+      if (model) {
+        const live = _AnthropicProvider.mapLiveCapabilities(model);
+        if (live) {
+          return live;
+        }
+      }
+    } catch {
+    }
+    const staticCaps = _AnthropicProvider.lookupStaticCapabilities(modelId);
+    if (staticCaps) {
+      return staticCaps;
+    }
+    return {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 2e5,
+      maxOutputTokens: 8192,
+      reasoningLevels: ADAPTIVE_REASONING_LEVELS
+    };
+  }
+  // ============================================================================
+  // Provider-Embedded Tools
+  // ============================================================================
+  /**
+   * Provider-embedded tools using defineTool().
+   * These are Anthropic's server-side tools that execute on Anthropic's
+   * servers. The execute function is a no-op since execution is handled by
+   * the provider; results surface as providerTools entries on the response.
+   */
+  static TOOLS = {
+    web_search: defineTool({
+      description: "Search the web for up-to-date information with citations",
+      args: z.object({
+        query: z.string().describe("Search query")
+      }),
+      execute: async (_state, _args) => {
+        return { status: "success", result: "Handled by Anthropic" };
+      },
+      executionMode: "provider",
+      executionProvider: "anthropic"
+    })
+  };
+  /**
+   * Get tools embedded in this provider.
+   * Anthropic's web_search server tool is available on all current models.
+   *
+   * @param modelId - Optional filter to get tools available for a specific model
+   * @returns Record of tool name to tool definition
+   */
+  getTools(_modelId) {
+    return { ..._AnthropicProvider.TOOLS };
+  }
+  // ============================================================================
+  // Model Listing
+  // ============================================================================
+  /**
+   * Fetch models from the Anthropic Models API with caching.
+   */
+  async fetchModelsWithCache() {
+    const now = Date.now();
+    if (_AnthropicProvider.modelsCache && now - _AnthropicProvider.modelsCacheTime < _AnthropicProvider.CACHE_TTL) {
+      return _AnthropicProvider.modelsCache;
+    }
+    const client = await this.getClient();
+    const models = [];
+    for await (const model of client.models.list({ limit: 100 })) {
+      models.push(model);
+    }
+    _AnthropicProvider.modelsCache = models;
+    _AnthropicProvider.modelsCacheTime = now;
+    return models;
+  }
+  /**
+   * Map Anthropic model info to ProviderModelInfo.
+   */
+  mapToProviderModelInfo(model) {
+    const capabilities = _AnthropicProvider.mapLiveCapabilities(model) ?? _AnthropicProvider.lookupStaticCapabilities(model.id) ?? void 0;
+    return {
+      id: model.id,
+      name: model.display_name,
+      contextLength: model.max_input_tokens ?? capabilities?.maxContextTokens,
+      iconId: this.getIcon(model.id),
+      ...capabilities ? { capabilities } : {}
+    };
+  }
+  /**
+   * Get list of available models from Anthropic.
+   * Fetches from the Models API with caching.
+   *
+   * @param filter - Optional search string to filter models by name/id
+   */
+  async getModels(filter) {
+    try {
+      const rawModels = await this.fetchModelsWithCache();
+      let models = rawModels.map((m) => this.mapToProviderModelInfo(m));
+      if (filter) {
+        const lowerFilter = filter.toLowerCase();
+        models = models.filter(
+          (m) => m.id.toLowerCase().includes(lowerFilter) || m.name.toLowerCase().includes(lowerFilter)
+        );
+      }
+      return models;
+    } catch (error) {
+      console.error("Failed to fetch models from Anthropic:", error);
+      return [];
+    }
+  }
+  // ============================================================================
+  // Generation Methods
+  // ============================================================================
+  /**
+   * Resolve the default max_tokens for a model from the static capability
+   * table, clamped so non-streaming requests stay under HTTP timeouts.
+   */
+  defaultMaxTokensFor(modelId) {
+    const caps = _AnthropicProvider.lookupStaticCapabilities(modelId);
+    return Math.min(caps?.maxOutputTokens ?? 8192, 8192);
+  }
+  async generate(request) {
+    const client = await this.getClient();
+    try {
+      const params = buildCreateParams(
+        request,
+        DEFAULT_REASONING_LEVELS,
+        this.defaultMaxTokensFor(request.model)
+      );
+      const response = await client.messages.create(
+        { ...params, stream: false },
+        { signal: request.signal }
+      );
+      return transformResponse(response);
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  async stream(request) {
+    const client = await this.getClient();
+    const self = this;
+    try {
+      const params = buildCreateParams(
+        request,
+        DEFAULT_REASONING_LEVELS,
+        this.defaultMaxTokensFor(request.model)
+      );
+      const stream = await client.messages.create(
+        { ...params, stream: true },
+        { signal: request.signal }
+      );
+      return {
+        async *[Symbol.asyncIterator]() {
+          const state = createStreamState();
+          try {
+            for await (const event of stream) {
+              const chunks = processStreamEvent(event, state);
+              for (const chunk of chunks) {
+                yield chunk;
+              }
+            }
+          } catch (error) {
+            const providerError = self.toProviderError(error);
+            yield createErrorChunk(providerError.message, providerError.code);
+          }
+        }
+      };
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  // ============================================================================
+  // Error Handling
+  // ============================================================================
+  toProviderError(error) {
+    if (error instanceof ProviderError) {
+      return error;
+    }
+    const record = isObjectLike(error) ? error : null;
+    const status = typeof record?.status === "number" ? record.status : typeof record?.statusCode === "number" ? record.statusCode : void 0;
+    const message = error instanceof Error ? error.message : String(error);
+    if (status === 429) {
+      return new ProviderError(message, "rate_limit", status, parseRetryAfter(record?.headers));
+    }
+    if (status === 401 || status === 403) {
+      return new ProviderError(message, "auth_error", status);
+    }
+    if (status === 400 || status === 404 || status === 413) {
+      return new ProviderError(message, "invalid_request", status);
+    }
+    if (status !== void 0 && status >= 500) {
+      return new ProviderError(message, "server_error", status);
+    }
+    if (error instanceof Error && error.name === "AbortError" || record?.code === "ETIMEDOUT") {
+      return new ProviderError(message, "timeout");
+    }
+    return new ProviderError(message, "unknown", status);
+  }
+  // ============================================================================
+  // Inspection
+  // ============================================================================
+  /**
+   * Transform a ProviderRequest to Anthropic Messages API format for inspection.
+   * Returns the exact request body that would be sent, with base64 data truncated.
+   */
+  async inspectRequest(request) {
+    const params = buildCreateParams(
+      request,
+      DEFAULT_REASONING_LEVELS,
+      this.defaultMaxTokensFor(request.model)
+    );
+    const body = JSON.parse(JSON.stringify(params));
+    return {
+      body: truncateBase64(body),
+      messagesPath: "messages",
+      metadata: {
+        endpoint: "messages.create"
+      }
+    };
+  }
+};
+
+// src/providerOptions.ts
+import { z as z2 } from "zod";
+var anthropicProviderOptions = z2.object({
+  /** Request priority tier: 'auto' uses priority capacity when available, 'standard_only' opts out */
+  service_tier: z2.enum(["auto", "standard_only"]).optional(),
+  /** Request metadata. user_id is an opaque identifier for abuse monitoring */
+  metadata: z2.object({
+    user_id: z2.string().optional()
+  }).optional(),
+  /**
+   * Cache the system prompt with a prompt-caching breakpoint.
+   * Adds `cache_control: { type: 'ephemeral' }` to the system prompt so
+   * repeated requests with the same prefix bill cached-input rates.
+   */
+  cacheSystemPrompt: z2.boolean().optional(),
+  /**
+   * Explicit thinking configuration override. When set, this takes precedence
+   * over the thinking config derived from the request's reasoning level.
+   * Accepts the Anthropic API shape, e.g. `{ type: 'adaptive' }` or
+   * `{ type: 'enabled', budget_tokens: 8192 }`.
+   */
+  thinking: z2.record(z2.string(), z2.unknown()).optional()
+}).passthrough();
+
+// src/index.ts
+var anthropic = Object.assign(
+  (config) => new AnthropicProvider(config),
+  { providerOptions: anthropicProviderOptions }
+);
+export {
+  AnthropicProvider,
+  anthropic,
+  anthropicProviderOptions,
+  calculateAnthropicUsageCost,
+  extractUsageBuckets,
+  getAnthropicModelPricing
+};
+//# sourceMappingURL=index.js.map