@namzu/cli 34.1.1 → 36.0.0

package/dist/chunks/dist-OTTZ7WVD.js

@@ -0,0 +1,1415 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  Anthropic
+} from "./chunk-THNCQJ33.js";
+import {
+  ProviderRegistry,
+  ProviderRequestError,
+  assertStrictSchema,
+  attributionHeaders,
+  isCallerAbortError,
+  isProviderRequestError,
+  modelVersionAtLeast,
+  parseVersionedModelId,
+  providerVendorError,
+  toSchemaDialect,
+  toolResultToText
+} from "./chunk-K5HARZ7G.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// ../providers/anthropic/dist/client.js
+import { execFileSync } from "node:child_process";
+
+// ../providers/anthropic/dist/search-replay.js
+import { createHash } from "node:crypto";
+var digest = /* @__PURE__ */ __name((blocks) => createHash("sha256").update(JSON.stringify(blocks)).digest("hex"), "digest");
+function searchReplay(blocks, route, text) {
+  return {
+    kind: "namzu-anthropic-search",
+    version: 1,
+    blocks,
+    route,
+    text,
+    digest: digest(blocks)
+  };
+}
+__name(searchReplay, "searchReplay");
+function restoreSearch(msg, route) {
+  const source = msg.source;
+  if (!source || source.type !== "model" || source.providerId !== route.providerId || source.model !== route.model || source.chainIndex !== route.chainIndex)
+    return;
+  const state = source.replayState;
+  if (!state || state.kind !== "namzu-anthropic-search" || state.version !== 1 || JSON.stringify(state.route) !== JSON.stringify(route) || !Array.isArray(state.blocks) || state.blocks.some((b) => !b || typeof b !== "object") || state.digest !== digest(state.blocks) || state.text !== msg.content)
+    return;
+  const calls = state.blocks.filter((b) => b.type === "tool_use");
+  if (calls.length !== (msg.toolCalls?.length ?? 0))
+    return;
+  try {
+    if (calls.some((b, i) => {
+      const call = msg.toolCalls?.[i];
+      if (!call)
+        return true;
+      return b.id !== call.id || b.name !== call.function.name || JSON.stringify(b.input) !== JSON.stringify(JSON.parse(call.function.arguments));
+    }))
+      return;
+  } catch {
+    return;
+  }
+  const thinking = state.blocks.filter((b) => b.type === "thinking" || b.type === "redacted_thinking");
+  if (thinking.length !== (msg.reasoning?.length ?? 0) || thinking.some((b, i) => {
+    const r = msg.reasoning?.[i];
+    if (!r)
+      return true;
+    return b.type !== r.type || (b.type === "thinking" ? b.thinking !== r.text || b.signature !== r.signature : b.data !== r.encrypted);
+  }))
+    return;
+  return structuredClone(state.blocks);
+}
+__name(restoreSearch, "restoreSearch");
+function replayInput(json) {
+  if (!json)
+    return {};
+  try {
+    return JSON.parse(json);
+  } catch {
+    return {};
+  }
+}
+__name(replayInput, "replayInput");
+var SearchBlocks = class {
+  static {
+    __name(this, "SearchBlocks");
+  }
+  blocks = /* @__PURE__ */ new Map();
+  json = /* @__PURE__ */ new Map();
+  active = /* @__PURE__ */ new Set();
+  sources = /* @__PURE__ */ new Set();
+  hasSearch = false;
+  start(index, block) {
+    this.blocks.set(index, structuredClone(block));
+    this.active.add(index);
+    if (block.type === "server_tool_use" || block.type === "web_search_tool_result")
+      this.hasSearch = true;
+    for (const citation of Array.isArray(block.citations) ? block.citations : [])
+      this.cite(citation);
+  }
+  cite(value) {
+    const c = value;
+    if (typeof c?.url === "string" && /^https?:\/\//.test(c.url))
+      this.sources.add(c.url);
+  }
+  delta(index, delta) {
+    const b = this.blocks.get(index);
+    if (!b)
+      return;
+    if (delta.type === "text_delta")
+      b.text = String(b.text ?? "") + (delta.text ?? "");
+    if (delta.type === "thinking_delta")
+      b.thinking = String(b.thinking ?? "") + (delta.thinking ?? "");
+    if (delta.type === "signature_delta")
+      b.signature = String(b.signature ?? "") + (delta.signature ?? "");
+    if (delta.type === "input_json_delta")
+      this.json.set(index, (this.json.get(index) ?? "") + (delta.partial_json ?? ""));
+    if (delta.type === "citations_delta" && delta.citation) {
+      b.citations = [...Array.isArray(b.citations) ? b.citations : [], delta.citation];
+      this.cite(delta.citation);
+    }
+  }
+  stop(index) {
+    const b = this.blocks.get(index);
+    if (b && this.json.has(index))
+      b.input = replayInput(this.json.get(index) ?? "");
+    this.active.delete(index);
+  }
+  complete(route) {
+    if (!this.hasSearch)
+      return;
+    if (this.active.size)
+      throw new Error("Anthropic search stream ended with incomplete content blocks.");
+    const blocks = [...this.blocks.entries()].sort(([a], [b]) => a - b).map(([, b]) => b);
+    const text = blocks.filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("");
+    const missing = [...this.sources].filter((url) => !text.includes(url));
+    const appendix = missing.length ? `
+
+Sources:
+${missing.map((url) => `- ${url}`).join("\n")}` : "";
+    return { appendix, replay: searchReplay(blocks, route, text + appendix) };
+  }
+};
+
+// ../providers/anthropic/dist/version-floor.js
+function reachesFloor(version, floors) {
+  return floors.some((floor) => floor.family === version.family && (version.major > floor.major || version.major === floor.major && version.minor >= floor.minor));
+}
+__name(reachesFloor, "reachesFloor");
+
+// ../providers/anthropic/dist/thinking-capability.js
+var NO_EFFORT = [];
+var FULL_EFFORT = ["low", "medium", "high", "xhigh", "max"];
+var EFFORT_WITHOUT_XHIGH = ["low", "medium", "high", "max"];
+var EFFORT_BASE = ["low", "medium", "high"];
+var MANUAL_ONLY = {
+  adaptive: false,
+  manual: true,
+  canDisable: true,
+  effort: NO_EFFORT,
+  effortWhenDisabled: NO_EFFORT
+};
+var ALWAYS_ON = {
+  adaptive: true,
+  manual: false,
+  canDisable: false,
+  effort: FULL_EFFORT,
+  effortWhenDisabled: FULL_EFFORT
+};
+var ALWAYS_ON_FROM = [
+  { family: "fable", major: 0, minor: 0 },
+  { family: "mythos", major: 0, minor: 0 },
+  { family: "opus", major: 5, minor: 5 }
+];
+var MODEL_ID_GRAMMAR = {
+  product: "claude",
+  families: ["haiku", "sonnet", "opus", "fable", "mythos"],
+  routingPrefix: "anthropic/"
+};
+function resolveThinkingCapability(model) {
+  const normalized = model.toLowerCase();
+  if (/^(?:anthropic\/)?claude-mythos-preview$/.test(normalized)) {
+    return {
+      adaptive: true,
+      manual: true,
+      canDisable: false,
+      // `max` but NOT `xhigh` — the combination it is easy to assume
+      // away, because reading the levels as a ladder makes anything
+      // accepting the top rung look like it accepts the one below. That
+      // reading is what put all five levels on this row, and it sends a
+      // level the wire refuses.
+      //
+      // SOURCED, NOT MEASURED, and the distinction is recorded because
+      // this file has been wrong from exactly this evidence class
+      // before. The reference states this model's availability twice: it
+      // is in the `max` list both times and in the `xhigh` list neither,
+      // and it says outright that some models supporting `max` do not
+      // support `xhigh`. The model is not reachable from the tenant used
+      // for the live contract suite (404), so no probe can confirm it
+      // here.
+      //
+      // What IS measured is that the pairing exists and this wire reports
+      // it exactly this way — `claude-sonnet-4-6` answers `xhigh` with
+      // "This model does not support effort level 'xhigh'. Supported
+      // levels: high, low, max, medium." and accepts `max`. So the row
+      // below is not a guess about a shape nobody has seen; it is a
+      // documented instance of a shape the wire demonstrably has.
+      effort: EFFORT_WITHOUT_XHIGH,
+      effortWhenDisabled: EFFORT_WITHOUT_XHIGH
+    };
+  }
+  const parsed = parseVersionedModelId(model, MODEL_ID_GRAMMAR);
+  if (!parsed)
+    return MANUAL_ONLY;
+  const { family, major, minor } = parsed;
+  if (reachesFloor(parsed, ALWAYS_ON_FROM))
+    return ALWAYS_ON;
+  if (major > 4 || major === 4 && minor >= 7) {
+    const opus5Plus = family === "opus" && major >= 5;
+    return {
+      adaptive: true,
+      manual: false,
+      canDisable: true,
+      effort: FULL_EFFORT,
+      effortWhenDisabled: opus5Plus ? EFFORT_BASE : FULL_EFFORT
+    };
+  }
+  if (major === 4 && minor === 6) {
+    return {
+      adaptive: true,
+      manual: true,
+      canDisable: true,
+      effort: EFFORT_WITHOUT_XHIGH,
+      effortWhenDisabled: EFFORT_WITHOUT_XHIGH
+    };
+  }
+  const isOpus45 = family === "opus" && major === 4 && minor === 5;
+  const base = isOpus45 ? EFFORT_BASE : NO_EFFORT;
+  return { ...MANUAL_ONLY, effort: base, effortWhenDisabled: base };
+}
+__name(resolveThinkingCapability, "resolveThinkingCapability");
+function resolveThinkingBody(thinking, capability) {
+  if (!thinking)
+    return void 0;
+  const display = thinking.display ? { display: thinking.display } : {};
+  if (thinking.type === "disabled") {
+    return capability.canDisable ? { type: "disabled" } : void 0;
+  }
+  if (thinking.type === "adaptive") {
+    if (capability.adaptive)
+      return { type: "adaptive", ...display };
+    return capability.manual ? { type: "enabled", ...display } : void 0;
+  }
+  if (capability.manual) {
+    return {
+      type: "enabled",
+      ...thinking.budgetTokens !== void 0 ? { budget_tokens: thinking.budgetTokens } : {},
+      ...display
+    };
+  }
+  return capability.adaptive ? { type: "adaptive", ...display } : void 0;
+}
+__name(resolveThinkingBody, "resolveThinkingBody");
+function resolveEffort(effort, thinkingBody, capability, model) {
+  if (effort === void 0)
+    return void 0;
+  const allowed = thinkingBody?.type === "disabled" ? capability.effortWhenDisabled : capability.effort;
+  if (allowed.includes(effort))
+    return effort;
+  const target = model ? ` by model "${model}"` : " by this model/thinking combination";
+  const offered = allowed.length > 0 ? allowed.join(", ") : "none";
+  throw new Error(`AnthropicProvider: effort "${effort}" is not supported${target}. Supported levels: ${offered}. Choose one of those levels or omit \`effort\`.`);
+}
+__name(resolveEffort, "resolveEffort");
+
+// ../providers/anthropic/dist/tool-choice.js
+var REFUSES_FORCED_TOOL_CHOICE_FROM = [
+  { family: "opus", major: 5, minor: 5 },
+  { family: "fable", major: 5, minor: 1 },
+  { family: "mythos", major: 5, minor: 1 }
+];
+function isForced(toolChoice) {
+  return toolChoice === "required" || typeof toolChoice === "object" && toolChoice.type === "function";
+}
+__name(isForced, "isForced");
+function forcedToolChoiceRefusal(model, thinkingBody) {
+  const version = parseVersionedModelId(model, MODEL_ID_GRAMMAR);
+  if (version && reachesFloor(version, REFUSES_FORCED_TOOL_CHOICE_FROM))
+    return "model";
+  if (thinkingBody?.type === "enabled")
+    return "manual-thinking";
+  return void 0;
+}
+__name(forcedToolChoiceRefusal, "forcedToolChoiceRefusal");
+function acceptsForcedToolChoice(model, thinking) {
+  const body = resolveThinkingBody(thinking, resolveThinkingCapability(model));
+  return forcedToolChoiceRefusal(model, body) === void 0;
+}
+__name(acceptsForcedToolChoice, "acceptsForcedToolChoice");
+function assertForcedToolChoiceAccepted(toolChoice, thinkingBody, model) {
+  if (!isForced(toolChoice))
+    return;
+  const refusal = forcedToolChoiceRefusal(model, thinkingBody);
+  if (refusal === void 0)
+    return;
+  throw new ProviderRequestError({
+    kind: "bad_request",
+    providerId: "anthropic",
+    providerCode: "forced_tool_choice_unsupported",
+    detail: refusal === "model" ? `Model "${model}" does not accept a forced tool choice (toolChoice "required" or a named function). Use toolChoice "auto" and say in the prompt which tool to call, or responseFormat for a fixed JSON shape.` : `A forced tool choice (toolChoice "required" or a named function) cannot be combined with manual extended thinking, which this request's thinking setting resolves to on model "${model}". Use toolChoice "auto", or leave thinking off for this step.`
+  });
+}
+__name(assertForcedToolChoiceAccepted, "assertForcedToolChoiceAccepted");
+
+// ../providers/anthropic/dist/client.js
+var DEFAULT_MAX_TOKENS = 64e3;
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 0;
+var OAUTH_BETAS = "claude-code-20250219,oauth-2025-04-20";
+var CLAUDE_CODE_SYSTEM_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
+var CLAUDE_CODE_VERSION_FALLBACK = "2.1.74";
+var claudeCodeVersionCache = null;
+function detectClaudeCodeVersion() {
+  if (claudeCodeVersionCache !== null)
+    return claudeCodeVersionCache;
+  for (const bin of ["claude", "claude-code"]) {
+    try {
+      const out = execFileSync(
+        /* turbopackIgnore: true */
+        bin,
+        ["--version"],
+        {
+          encoding: "utf8",
+          timeout: 5e3,
+          stdio: ["ignore", "pipe", "ignore"]
+        }
+      ).trim().split(/\s+/)[0];
+      if (out && /^\d/.test(out)) {
+        claudeCodeVersionCache = out;
+        return out;
+      }
+    } catch {
+    }
+  }
+  claudeCodeVersionCache = CLAUDE_CODE_VERSION_FALLBACK;
+  return CLAUDE_CODE_VERSION_FALLBACK;
+}
+__name(detectClaudeCodeVersion, "detectClaudeCodeVersion");
+function extractSystem(messages, cachingEnabled) {
+  const blocks = [];
+  let lastCacheTagged;
+  for (const msg of messages) {
+    if (msg.role === "system" && typeof msg.content === "string" && msg.content.length > 0) {
+      const block = { type: "text", text: msg.content };
+      blocks.push(block);
+      if (msg.cacheHint === "cache")
+        lastCacheTagged = block;
+    }
+  }
+  if (blocks.length === 0)
+    return void 0;
+  if (cachingEnabled && lastCacheTagged) {
+    lastCacheTagged.cache_control = { type: "ephemeral" };
+  }
+  return blocks;
+}
+__name(extractSystem, "extractSystem");
+function resolveAnthropicRoute(model, candidate) {
+  if (candidate === void 0)
+    return { providerId: "anthropic", model, chainIndex: 0 };
+  if (candidate.providerId !== "anthropic" || candidate.model !== model || !Number.isSafeInteger(candidate.chainIndex) || candidate.chainIndex < 0) {
+    throw new Error("AnthropicProvider: providerRoute must name this provider, the requested model, and a non-negative integer chainIndex.");
+  }
+  return candidate;
+}
+__name(resolveAnthropicRoute, "resolveAnthropicRoute");
+function sameRoute(left, right) {
+  return left.providerId === right.providerId && left.model === right.model && left.chainIndex === right.chainIndex;
+}
+__name(sameRoute, "sameRoute");
+function isAnthropicReplayState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const state = value;
+  const route = state.route;
+  if (state.kind !== "namzu-anthropic-reasoning" || state.version !== 1 || typeof route !== "object" || route === null || Array.isArray(route) || typeof route.providerId !== "string" || typeof route.model !== "string" || !Number.isSafeInteger(route.chainIndex) || route.chainIndex < 0 || !Array.isArray(state.blocks)) {
+    return false;
+  }
+  return state.blocks.every((value2) => {
+    if (typeof value2 !== "object" || value2 === null || Array.isArray(value2))
+      return false;
+    const block = value2;
+    return block.type === "thinking" ? typeof block.thinking === "string" && typeof block.signature === "string" : block.type === "redacted_thinking" && typeof block.data === "string";
+  });
+}
+__name(isAnthropicReplayState, "isAnthropicReplayState");
+function durableAnthropicReasoning(reasoning) {
+  if (!reasoning || reasoning.length === 0)
+    return void 0;
+  const blocks = [];
+  for (const block of reasoning) {
+    if (block.type === "thinking") {
+      if (typeof block.text !== "string" || typeof block.signature !== "string" || block.signature.length === 0 || block.encrypted !== void 0) {
+        return void 0;
+      }
+      blocks.push({
+        type: "thinking",
+        thinking: block.text,
+        signature: block.signature
+      });
+      continue;
+    }
+    if (typeof block.encrypted !== "string" || block.encrypted.length === 0 || block.text !== void 0 || block.signature !== void 0) {
+      return void 0;
+    }
+    blocks.push({ type: "redacted_thinking", data: block.encrypted });
+  }
+  return blocks;
+}
+__name(durableAnthropicReasoning, "durableAnthropicReasoning");
+function replayBlocksEqual(left, right) {
+  return left.length === right.length && left.every((block, index) => {
+    const other = right[index];
+    if (!other || block.type !== other.type)
+      return false;
+    return block.type === "thinking" && other.type === "thinking" ? block.thinking === other.thinking && block.signature === other.signature : block.type === "redacted_thinking" && other.type === "redacted_thinking" && block.data === other.data;
+  });
+}
+__name(replayBlocksEqual, "replayBlocksEqual");
+function replayReasoning(msg, targetRoute) {
+  const source = msg.source;
+  if (!source || source.type !== "model" || !sameRoute(source, targetRoute))
+    return [];
+  const state = source.replayState;
+  if (!isAnthropicReplayState(state) || !sameRoute(state.route, source))
+    return [];
+  const durable = durableAnthropicReasoning(msg.reasoning);
+  if (!durable || !replayBlocksEqual(durable, state.blocks))
+    return [];
+  return state.blocks.map((block) => ({ ...block }));
+}
+__name(replayReasoning, "replayReasoning");
+function toolResultContent(content) {
+  if (content === void 0)
+    return "";
+  if (typeof content === "string")
+    return content;
+  const blocks = [];
+  for (const block of content) {
+    if (block.type === "image") {
+      blocks.push({
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: block.mediaType,
+          data: block.data
+        }
+      });
+      continue;
+    }
+    const text = toolResultToText([block]);
+    if (text.length > 0)
+      blocks.push({ type: "text", text });
+  }
+  return blocks.length > 0 ? blocks : "";
+}
+__name(toolResultContent, "toolResultContent");
+function toAnthropicMessages(messages, targetRoute) {
+  const out = [];
+  let cacheEnd;
+  let pendingToolResults = [];
+  const flushToolResults = /* @__PURE__ */ __name(() => {
+    if (pendingToolResults.length > 0) {
+      out.push({ role: "user", content: pendingToolResults });
+      pendingToolResults = [];
+    }
+  }, "flushToolResults");
+  for (const msg of messages) {
+    if (msg.role === "system")
+      continue;
+    if (msg.role === "user" && msg.source?.type === "runtime-context" && msg.source.kind === "step-context") {
+      flushToolResults();
+      cacheEnd ??= out.length;
+    }
+    if (msg.role === "assistant") {
+      const restored = restoreSearch(msg, targetRoute);
+      if (restored) {
+        flushToolResults();
+        out.push({
+          role: "assistant",
+          content: restored
+        });
+        continue;
+      }
+    }
+    if (msg.role === "tool") {
+      const toolMsg = msg;
+      pendingToolResults.push({
+        type: "tool_result",
+        tool_use_id: toolMsg.toolCallId ?? "unknown",
+        content: toolResultContent(toolMsg.content)
+      });
+      continue;
+    }
+    flushToolResults();
+    if (msg.role === "assistant" && "toolCalls" in msg && msg.toolCalls) {
+      const blocks = [...replayReasoning(msg, targetRoute)];
+      if (msg.content && typeof msg.content === "string") {
+        blocks.push({ type: "text", text: msg.content });
+      }
+      for (const tc of msg.toolCalls) {
+        let parsedInput = {};
+        try {
+          parsedInput = JSON.parse(tc.function.arguments || "{}");
+        } catch {
+          parsedInput = {};
+        }
+        blocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: parsedInput
+        });
+      }
+      out.push({ role: "assistant", content: blocks });
+      continue;
+    }
+    const replayed = msg.role === "assistant" ? replayReasoning(msg, targetRoute) : [];
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    if (replayed.length > 0) {
+      const trailing = content.length > 0 ? [{ type: "text", text: content }] : [];
+      out.push({ role: "assistant", content: [...replayed, ...trailing] });
+      continue;
+    }
+    const attachments = msg.attachments;
+    if (msg.role === "user" && attachments && attachments.length > 0) {
+      const blocks = [];
+      if (content.length > 0)
+        blocks.push({ type: "text", text: content });
+      for (const att of attachments) {
+        if (att.type === "document") {
+          blocks.push({
+            type: "document",
+            source: {
+              type: "base64",
+              media_type: att.mediaType,
+              data: att.data
+            },
+            ...att.name ? { title: att.name } : {},
+            // Opt-in: citations cost tokens, so they are requested
+            // only when the caller asked to be able to check the
+            // answer.
+            ...att.citations ? { citations: { enabled: true } } : {}
+          });
+          continue;
+        }
+        if (att.type === "stored") {
+          throw new Error(`A stored attachment ("${att.ref}") reached the driver unresolved. Resolve it against the run's attachment store before sending.`);
+        }
+        blocks.push({
+          type: "image",
+          source: { type: "base64", media_type: att.mediaType, data: att.data }
+        });
+      }
+      out.push({ role: "user", content: blocks });
+      continue;
+    }
+    out.push({
+      role: msg.role === "assistant" ? "assistant" : "user",
+      content
+    });
+  }
+  flushToolResults();
+  return { messages: out, cacheEnd: cacheEnd ?? out.length };
+}
+__name(toAnthropicMessages, "toAnthropicMessages");
+function toAnthropicTools(params, cachingEnabled, strictToolUseEnabled) {
+  if (!params.tools || params.tools.length === 0)
+    return void 0;
+  const enforcedNames = new Set(params.enforceToolInputSchema ?? []);
+  const tools = params.tools.map((t) => {
+    const strict = strictToolUseEnabled && enforcedNames.has(t.function.name);
+    const inputSchema = toSchemaDialect(objectToolInputSchema(t.function.name, t.function.parameters), "2020-12");
+    if (strict)
+      assertStrictSchema(t.function.name, inputSchema);
+    return {
+      name: t.function.name,
+      description: t.function.description ?? "",
+      // This wire parses draft 2020-12, and the renderer emits draft-07.
+      // The two disagree about tuples — draft-07 puts the positional
+      // schemas in `items`, 2020-12 in `prefixItems` — and the wire
+      // rejects the WHOLE request for it, not the one field. Converting
+      // here rather than in the renderer keeps the dialect where the
+      // knowledge is: only this file knows which wire it is talking to.
+      input_schema: inputSchema,
+      ...strict ? { strict: true } : {}
+    };
+  });
+  if (cachingEnabled) {
+    const tail = tools[tools.length - 1];
+    if (tail)
+      tail.cache_control = { type: "ephemeral" };
+  }
+  return tools;
+}
+__name(toAnthropicTools, "toAnthropicTools");
+var EMPTY_OBJECT_TOOL_SCHEMA = Object.freeze({ type: "object" });
+var ROOTED_OBJECT_TOOL_SCHEMAS = /* @__PURE__ */ new WeakMap();
+function objectToolInputSchema(toolName, schema) {
+  if (schema === void 0)
+    return EMPTY_OBJECT_TOOL_SCHEMA;
+  if (!isSchemaObject(schema)) {
+    throw new Error(`Tool "${toolName}" input schema must be a JSON object schema.`);
+  }
+  for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+    if (Object.hasOwn(schema, keyword)) {
+      throw new Error(`Tool "${toolName}" model-facing input schema cannot use root keyword "${keyword}" on Anthropic. Define a flat object in ToolDefinition.modelInputSchema and validate conditional branch requirements when the tool executes.`);
+    }
+  }
+  if (schema.type === "object")
+    return schema;
+  if (schema.type !== void 0) {
+    throw new Error(`Tool "${toolName}" input schema must describe an object; received root type ${JSON.stringify(schema.type)}.`);
+  }
+  const cached = ROOTED_OBJECT_TOOL_SCHEMAS.get(schema);
+  if (cached)
+    return cached;
+  const rooted = Object.freeze({ ...schema, type: "object" });
+  ROOTED_OBJECT_TOOL_SCHEMAS.set(schema, rooted);
+  return rooted;
+}
+__name(objectToolInputSchema, "objectToolInputSchema");
+function isSchemaObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isSchemaObject, "isSchemaObject");
+function shouldUseStrictToolInputs(model, mode = "auto") {
+  if (mode === "on")
+    return true;
+  if (mode === "off")
+    return false;
+  const normalized = model.toLowerCase();
+  if (/^(?:anthropic\/)?claude-mythos-preview$/.test(normalized))
+    return true;
+  return modelVersionAtLeast(normalized, MODEL_ID_GRAMMAR, 4, 5);
+}
+__name(shouldUseStrictToolInputs, "shouldUseStrictToolInputs");
+function toAnthropicToolChoice(tc, parallelToolCalls) {
+  const disable = parallelToolCalls === false ? { disable_parallel_tool_use: true } : void 0;
+  if (tc === void 0) {
+    return disable ? { type: "auto", ...disable } : void 0;
+  }
+  if (tc === "auto")
+    return { type: "auto", ...disable };
+  if (tc === "required")
+    return { type: "any", ...disable };
+  if (tc === "none")
+    return { type: "none" };
+  if (typeof tc === "object" && tc.type === "function") {
+    return { type: "tool", name: tc.function.name, ...disable };
+  }
+  return void 0;
+}
+__name(toAnthropicToolChoice, "toAnthropicToolChoice");
+function applyMessageCacheBreakpoint(messages, cacheEnd) {
+  for (let i = cacheEnd - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg)
+      continue;
+    if (typeof msg.content === "string") {
+      if (msg.content.length === 0)
+        continue;
+      msg.content = [
+        {
+          type: "text",
+          text: msg.content,
+          cache_control: { type: "ephemeral" }
+        }
+      ];
+      return;
+    }
+    if (msg.content.length > 0) {
+      const last = msg.content[msg.content.length - 1];
+      if (last)
+        last.cache_control = { type: "ephemeral" };
+      return;
+    }
+  }
+}
+__name(applyMessageCacheBreakpoint, "applyMessageCacheBreakpoint");
+function emptyUsage() {
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+    cachedTokens: 0,
+    cacheWriteTokens: 0
+  };
+}
+__name(emptyUsage, "emptyUsage");
+function parseUsage(raw) {
+  if (!raw)
+    return emptyUsage();
+  const input = raw.input_tokens ?? 0;
+  const output = raw.output_tokens ?? 0;
+  const thinking = raw.output_tokens_details?.thinking_tokens;
+  return {
+    promptTokens: input,
+    completionTokens: output,
+    totalTokens: input + output,
+    cachedTokens: raw.cache_read_input_tokens ?? 0,
+    cacheWriteTokens: raw.cache_creation_input_tokens ?? 0,
+    // Only when reported. Defaulting to 0 would say "this turn did no
+    // thinking" about every turn on every driver that stays silent, and
+    // about every streamed event before the last one.
+    ...thinking !== void 0 ? { reasoningTokens: thinking } : {}
+  };
+}
+__name(parseUsage, "parseUsage");
+function finishDetail(reason) {
+  return reason === "model_context_window_exceeded" ? { finishDetail: "context_window" } : {};
+}
+__name(finishDetail, "finishDetail");
+function mapStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "tool_use":
+      return "tool_calls";
+    // Both stop the output where it stands. `model_context_window_exceeded`
+    // is the context window rather than `max_tokens`, and fell to 'stop':
+    // a tool call it cut off mid-JSON then read as one the model finished
+    // and got wrong.
+    case "max_tokens":
+    case "model_context_window_exceeded":
+      return "length";
+    // A refusal can end the response inside a tool_use block. As 'stop' it
+    // read as a finished turn, and the unfinished call as malformed.
+    case "refusal":
+      return "content_filter";
+    default:
+      return "stop";
+  }
+}
+__name(mapStopReason, "mapStopReason");
+function toCitation(raw, index) {
+  const citedText = raw.cited_text;
+  if (!citedText)
+    return void 0;
+  const location = (() => {
+    if (raw.start_page_number !== void 0 && raw.end_page_number !== void 0) {
+      return {
+        kind: "page",
+        start: raw.start_page_number,
+        end: raw.end_page_number
+      };
+    }
+    if (raw.start_char_index !== void 0 && raw.end_char_index !== void 0) {
+      return {
+        kind: "char",
+        start: raw.start_char_index,
+        end: raw.end_char_index
+      };
+    }
+    if (raw.start_block_index !== void 0 && raw.end_block_index !== void 0) {
+      return {
+        kind: "block",
+        start: raw.start_block_index,
+        end: raw.end_block_index
+      };
+    }
+    return void 0;
+  })();
+  if (!location)
+    return void 0;
+  return {
+    citedText,
+    documentIndex: raw.document_index ?? index,
+    ...raw.document_title ? { documentTitle: raw.document_title } : {},
+    location
+  };
+}
+__name(toCitation, "toCitation");
+var ANTHROPIC_CAPABILITIES = {
+  supportsNativeStructuredOutput: true,
+  supportsHostedWebSearch: true,
+  supportsTools: true,
+  supportsStreaming: true,
+  supportsFunctionCalling: true,
+  supportsVision: true,
+  supportsDocuments: true,
+  supportsToolResultImages: true,
+  supportsToolResultDocuments: false
+};
+var AnthropicProvider = class {
+  static {
+    __name(this, "AnthropicProvider");
+  }
+  id = "anthropic";
+  name = "Anthropic";
+  capabilities = ANTHROPIC_CAPABILITIES;
+  client;
+  config;
+  constructor(config) {
+    if (!config.apiKey && !config.authToken) {
+      throw new Error("AnthropicProvider: either `apiKey` or `authToken` is required");
+    }
+    if (config.maxRetries !== void 0 && (!Number.isSafeInteger(config.maxRetries) || config.maxRetries < 0))
+      throw new Error("maxRetries must be a nonnegative integer.");
+    this.config = config;
+    const clientOpts = {
+      timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,
+      maxRetries: config.maxRetries ?? 0
+    };
+    if (config.authToken) {
+      clientOpts.authToken = config.authToken;
+      const headers = {
+        "anthropic-beta": OAUTH_BETAS,
+        "user-agent": `claude-code/${detectClaudeCodeVersion()} (external, cli)`,
+        "x-app": "cli",
+        ...config.defaultHeaders ?? {}
+      };
+      clientOpts.defaultHeaders = headers;
+    } else {
+      clientOpts.apiKey = config.apiKey;
+      clientOpts.defaultHeaders = {
+        ...attributionHeaders(),
+        ...config.defaultHeaders ?? {}
+      };
+    }
+    if (config.baseURL)
+      clientOpts.baseURL = config.baseURL;
+    this.client = new Anthropic(clientOpts);
+  }
+  resolveModel(params) {
+    const model = params.model || this.config.model;
+    if (!model) {
+      throw new Error("AnthropicProvider: no model specified. Pass `model` on the chat params or set a default via config.");
+    }
+    return model;
+  }
+  supportsHostedWebSearchFor(model, mode) {
+    return mode === "live" && /^claude-(?:(?:opus|sonnet|haiku|fable)-[45](?:-|$)|3-5-(?:sonnet|haiku)(?:-|$)|3-7-sonnet(?:-|$)|mythos-)/.test(model) && (!this.config.baseURL || this.config.baseURL.replace(/\/$/, "") === "https://api.anthropic.com");
+  }
+  buildCreateParams(params, stream) {
+    const cachingEnabled = params.cacheControl !== void 0;
+    const model = this.resolveModel(params);
+    const providerRoute = resolveAnthropicRoute(model, params.providerRoute);
+    const system = extractSystem(params.messages, cachingEnabled);
+    const { messages, cacheEnd } = toAnthropicMessages(params.messages, providerRoute);
+    if (cachingEnabled)
+      applyMessageCacheBreakpoint(messages, cacheEnd);
+    const tools = toAnthropicTools(params, cachingEnabled, shouldUseStrictToolInputs(model, this.config.strictToolUse));
+    const toolChoice = toAnthropicToolChoice(params.toolChoice, params.parallelToolCalls);
+    const body = {
+      model,
+      messages,
+      max_tokens: params.maxTokens ?? this.config.maxTokens ?? DEFAULT_MAX_TOKENS,
+      stream
+    };
+    if (this.config.authToken) {
+      const ccBlock = {
+        type: "text",
+        text: CLAUDE_CODE_SYSTEM_PREFIX
+      };
+      body.system = system ? [ccBlock, ...system] : [ccBlock];
+    } else if (system) {
+      body.system = system;
+    }
+    if (params.webSearch && (params.responseFormat || !this.supportsHostedWebSearchFor(model, params.webSearch.mode)))
+      throw new Error("Anthropic native search requires a supported Claude API model and live mode.");
+    if (tools || params.webSearch)
+      body.tools = [
+        ...tools ?? [],
+        ...params.webSearch ? [{ type: "web_search_20250305", name: "web_search" }] : []
+      ];
+    if (tools && toolChoice)
+      body.tool_choice = toolChoice;
+    const capability = resolveThinkingCapability(model);
+    const thinkingBody = resolveThinkingBody(params.thinking, capability);
+    if (thinkingBody)
+      body.thinking = thinkingBody;
+    if (body.tool_choice !== void 0) {
+      assertForcedToolChoiceAccepted(params.toolChoice, thinkingBody, model);
+    }
+    const effort = resolveEffort(params.effort, thinkingBody, capability, model);
+    const outputConfig = {};
+    if (effort)
+      outputConfig.effort = effort;
+    if (params.responseFormat) {
+      if (params.responseFormat.type !== "json_schema")
+        throw new ProviderRequestError({
+          kind: "bad_request",
+          providerId: "anthropic",
+          detail: "Anthropic responseFormat requires json_schema; schema-free json_object is unsupported."
+        });
+      if (params.responseFormat.json_schema.strict === false)
+        throw new ProviderRequestError({
+          kind: "bad_request",
+          providerId: "anthropic",
+          detail: "Anthropic native JSON output cannot disable schema enforcement; omit strict or set it to true."
+        });
+      outputConfig.format = {
+        type: "json_schema",
+        schema: params.responseFormat.json_schema.schema
+      };
+    }
+    if (Object.keys(outputConfig).length)
+      body.output_config = outputConfig;
+    if (params.temperature !== void 0)
+      body.temperature = params.temperature;
+    if (params.topP !== void 0)
+      body.top_p = params.topP;
+    if (params.topK !== void 0)
+      body.top_k = params.topK;
+    if (params.stop)
+      body.stop_sequences = params.stop;
+    return body;
+  }
+  /**
+   * The SDK's `messages.create` is overloaded on the `stream` flag. We build
+   * the request as an untyped object bag and narrow the response shape ourselves.
+   * Casting via `unknown` keeps us out of `any` territory while acknowledging
+   * that the translation layer bridges two type worlds.
+   */
+  createRaw(body, opts) {
+    const create = this.client.messages.create;
+    return create.call(this.client.messages, body, { signal: opts?.signal });
+  }
+  async *chatStream(params) {
+    const providerRoute = resolveAnthropicRoute(this.resolveModel(params), params.providerRoute);
+    const createParams = this.buildCreateParams(params, true);
+    const signal = params.signal;
+    let stream;
+    try {
+      stream = await this.createRaw(createParams, {
+        signal
+      });
+    } catch (err) {
+      if (isCallerAbortError(err, signal))
+        throw signal?.reason ?? err;
+      if (isProviderRequestError(err))
+        throw err;
+      throw providerVendorError({ providerId: "anthropic", error: err });
+    }
+    let messageId = "";
+    const activeTools = /* @__PURE__ */ new Map();
+    const searchBlocks = new SearchBlocks();
+    let searchReplayEmitted = false;
+    const serverTools = /* @__PURE__ */ new Map();
+    const serverToolInput = /* @__PURE__ */ new Map();
+    const serverQueries = /* @__PURE__ */ new Map();
+    const activeReasoning = /* @__PURE__ */ new Set();
+    const nativeReasoning = /* @__PURE__ */ new Map();
+    let replayStateEmitted = false;
+    const completedReplayState = /* @__PURE__ */ __name(() => {
+      if (replayStateEmitted || activeReasoning.size > 0 || nativeReasoning.size === 0) {
+        return void 0;
+      }
+      const blocks = [...nativeReasoning.entries()].sort(([left], [right]) => left - right).map(([, block]) => ({ ...block }));
+      if (blocks.some((block) => block.type === "thinking" ? block.signature.length === 0 : block.data.length === 0)) {
+        return void 0;
+      }
+      replayStateEmitted = true;
+      return {
+        kind: "namzu-anthropic-reasoning",
+        version: 1,
+        route: providerRoute,
+        blocks
+      };
+    }, "completedReplayState");
+    const streamIdleTimeoutMs = this.config.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+    const iter = stream[Symbol.asyncIterator]();
+    const nextWithIdleTimeout = /* @__PURE__ */ __name(async () => {
+      if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0) {
+        return iter.next();
+      }
+      let timer;
+      try {
+        return await Promise.race([
+          iter.next(),
+          new Promise((_, reject) => {
+            timer = setTimeout(() => {
+              reject(new ProviderRequestError({
+                kind: "network",
+                providerId: "anthropic",
+                detail: `stream idle for ${Math.round(streamIdleTimeoutMs / 1e3)}s \u2014 aborting so the turn lifecycle can emit turn_failed`
+              }));
+            }, streamIdleTimeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer !== void 0)
+          clearTimeout(timer);
+      }
+    }, "nextWithIdleTimeout");
+    try {
+      for (; ; ) {
+        signal?.throwIfAborted();
+        const result = await nextWithIdleTimeout();
+        if (result.done)
+          break;
+        const event = result.value;
+        try {
+          switch (event.type) {
+            case "message_start": {
+              if (event.message?.id)
+                messageId = event.message.id;
+              if (event.message?.usage) {
+                yield {
+                  id: messageId,
+                  delta: {},
+                  usage: parseUsage(event.message.usage)
+                };
+              }
+              break;
+            }
+            case "content_block_start": {
+              const idx = event.index ?? 0;
+              const block = event.content_block;
+              if (block)
+                searchBlocks.start(idx, block);
+              if (block?.type === "server_tool_use") {
+                if (block.name !== "web_search")
+                  throw new Error("Unexpected hosted tool in Anthropic search response.");
+                const serverId = block.id ?? `search-${idx}`;
+                serverTools.set(idx, serverId);
+                yield {
+                  id: messageId,
+                  delta: {
+                    hostedTool: {
+                      id: serverId,
+                      name: "web_search",
+                      status: "running"
+                    }
+                  }
+                };
+                break;
+              }
+              if (block?.type === "web_search_tool_result") {
+                const result2 = block;
+                const failed = !Array.isArray(result2.content);
+                const query = serverQueries.get(result2.tool_use_id);
+                yield {
+                  id: messageId,
+                  delta: {
+                    hostedTool: {
+                      id: result2.tool_use_id,
+                      name: "web_search",
+                      status: failed ? "failed" : "completed",
+                      ...query ? { query } : {},
+                      ...Array.isArray(result2.content) ? { results: result2.content.length } : {}
+                    }
+                  }
+                };
+                break;
+              }
+              if (block?.type === "thinking" || block?.type === "redacted_thinking") {
+                activeReasoning.add(idx);
+                if (block.type === "thinking") {
+                  nativeReasoning.set(idx, {
+                    type: "thinking",
+                    thinking: block.thinking ?? "",
+                    signature: block.signature ?? ""
+                  });
+                } else {
+                  nativeReasoning.set(idx, {
+                    type: "redacted_thinking",
+                    data: block.data ?? ""
+                  });
+                }
+                yield {
+                  id: messageId,
+                  delta: {
+                    reasoning: {
+                      index: idx,
+                      type: block.type,
+                      ...block.data ? { encrypted: block.data } : {}
+                    }
+                  }
+                };
+                break;
+              }
+              if (block?.type === "tool_use") {
+                const toolId = block.id ?? `tool-${Date.now()}`;
+                activeTools.set(idx, { id: toolId, name: block.name ?? "" });
+                yield {
+                  id: messageId,
+                  delta: {
+                    toolCalls: [
+                      {
+                        index: idx,
+                        id: toolId,
+                        type: "function",
+                        function: { name: block.name ?? "" }
+                      }
+                    ]
+                  }
+                };
+              }
+              break;
+            }
+            case "content_block_delta": {
+              const idx = event.index ?? 0;
+              const delta = event.delta;
+              if (delta)
+                searchBlocks.delta(idx, delta);
+              if (serverTools.has(idx)) {
+                if (delta?.type === "input_json_delta" && delta.partial_json !== void 0)
+                  serverToolInput.set(idx, (serverToolInput.get(idx) ?? "") + delta.partial_json);
+                break;
+              }
+              if (delta?.type === "text_delta" && delta.text) {
+                yield { id: messageId, delta: { content: delta.text } };
+              } else if (delta?.type === "thinking_delta" && delta.thinking !== void 0) {
+                const native = nativeReasoning.get(idx);
+                if (native?.type === "thinking")
+                  native.thinking += delta.thinking;
+                yield {
+                  id: messageId,
+                  delta: { reasoning: { index: idx, text: delta.thinking } }
+                };
+              } else if (delta?.type === "signature_delta" && delta.signature !== void 0) {
+                const native = nativeReasoning.get(idx);
+                if (native?.type === "thinking")
+                  native.signature += delta.signature;
+                yield {
+                  id: messageId,
+                  delta: {
+                    reasoning: { index: idx, signature: delta.signature }
+                  }
+                };
+              } else if (delta?.type === "citations_delta" && delta.citation) {
+                const citation = toCitation(delta.citation, idx);
+                if (citation)
+                  yield { id: messageId, delta: { citation } };
+              } else if (delta?.type === "input_json_delta" && delta.partial_json !== void 0) {
+                const active = activeTools.get(idx);
+                yield {
+                  id: messageId,
+                  delta: {
+                    toolCalls: [
+                      {
+                        index: idx,
+                        id: active?.id,
+                        function: { arguments: delta.partial_json }
+                      }
+                    ]
+                  }
+                };
+              }
+              break;
+            }
+            case "content_block_stop": {
+              searchBlocks.stop(event.index ?? 0);
+              const serverId = serverTools.get(event.index ?? 0);
+              if (serverId !== void 0) {
+                const query = hostedSearchQuery(serverToolInput.get(event.index ?? 0));
+                if (query)
+                  serverQueries.set(serverId, query);
+                serverToolInput.delete(event.index ?? 0);
+                serverTools.delete(event.index ?? 0);
+                break;
+              }
+              const idx = event.index ?? 0;
+              if (activeReasoning.delete(idx)) {
+                yield {
+                  id: messageId,
+                  delta: { reasoning: { index: idx, done: true } }
+                };
+                break;
+              }
+              const active = activeTools.get(idx);
+              if (active) {
+                yield {
+                  id: messageId,
+                  delta: {
+                    toolCallEnd: { index: idx, id: active.id }
+                  }
+                };
+                activeTools.delete(idx);
+              }
+              break;
+            }
+            case "message_delta": {
+              if (event.delta?.stop_reason) {
+                if (event.delta.stop_reason === "pause_turn")
+                  throw new Error("Anthropic paused hosted search before completing its answer.");
+                const search = searchBlocks.complete(providerRoute);
+                if (search?.appendix)
+                  yield {
+                    id: messageId,
+                    delta: { content: search.appendix, contentOrigin: "driver" }
+                  };
+                searchReplayEmitted = Boolean(search);
+                const replayState = search?.replay ?? completedReplayState();
+                yield {
+                  id: messageId,
+                  ...replayState !== void 0 ? { replayState } : {},
+                  delta: {},
+                  finishReason: mapStopReason(event.delta.stop_reason),
+                  ...finishDetail(event.delta.stop_reason),
+                  usage: event.usage ? parseUsage(event.usage) : void 0
+                };
+              } else if (event.usage) {
+                yield {
+                  id: messageId,
+                  delta: {},
+                  usage: parseUsage(event.usage)
+                };
+              }
+              break;
+            }
+            case "message_stop": {
+              if (searchReplayEmitted)
+                return;
+              const search = searchBlocks.complete(providerRoute);
+              if (search) {
+                if (search.appendix)
+                  yield {
+                    id: messageId,
+                    delta: { content: search.appendix, contentOrigin: "driver" }
+                  };
+                yield { id: messageId, delta: {}, replayState: search.replay };
+                return;
+              }
+              const replayState = completedReplayState();
+              if (replayState !== void 0) {
+                yield { id: messageId, delta: {}, replayState };
+              }
+              return;
+            }
+            default:
+              break;
+          }
+        } catch (parseErr) {
+          if (isProviderRequestError(parseErr))
+            throw parseErr;
+          throw new ProviderRequestError({
+            kind: "server",
+            providerId: "anthropic",
+            detail: "the provider stream returned malformed data"
+          });
+        }
+      }
+    } catch (err) {
+      if (isCallerAbortError(err, signal))
+        throw signal?.reason ?? err;
+      if (isProviderRequestError(err))
+        throw err;
+      throw providerVendorError({ providerId: "anthropic", error: err });
+    } finally {
+      await iter.return?.().catch(() => void 0);
+    }
+  }
+  async listModels(signal) {
+    signal?.throwIfAborted();
+    try {
+      const models = await this.listModelsStrict(signal);
+      return models.length ? models : this.knownModels();
+    } catch {
+      if (signal?.aborted)
+        throw signal.reason;
+      return this.knownModels();
+    }
+  }
+  /** Actual Models API rows and errors, without the legacy offline menu fallback. */
+  async listModelsStrict(signal) {
+    signal?.throwIfAborted();
+    const clientLike = this.client;
+    const models = clientLike.models;
+    if (typeof models?.list !== "function")
+      throw new Error("This SDK version cannot publish an actual model catalogue.");
+    try {
+      let page = await models.list({ limit: 100 }, signal ? { signal } : void 0);
+      const catalogue = [];
+      let rows = 0;
+      for (let pages = 1; ; pages++) {
+        signal?.throwIfAborted();
+        const data = page?.data ?? [];
+        rows += data.length;
+        if (rows > 1e4)
+          throw new Error("The actual model catalogue exceeded its row limit.");
+        for (const model of data) {
+          if (typeof model.id !== "string" || !model.id.length)
+            continue;
+          catalogue.push({
+            id: model.id,
+            name: model.display_name || model.id,
+            supportsToolUse: true,
+            supportsStreaming: true
+          });
+        }
+        if (!page?.hasNextPage?.())
+          return catalogue;
+        if (pages >= 100)
+          throw new Error("The actual model catalogue exceeded its page limit.");
+        if (typeof page.getNextPage !== "function")
+          throw new Error("This SDK version cannot read the next actual model catalogue page.");
+        signal?.throwIfAborted();
+        page = await page.getNextPage();
+      }
+    } catch (error) {
+      if (signal?.aborted)
+        throw signal.reason;
+      throw error;
+    }
+  }
+  /**
+   * Ask the API whether this credential works, and let the answer through.
+   *
+   * The same call `listModels` makes, without the `catch` that turns a real
+   * `401` into a hardcoded catalogue. That fallback is right for a menu and
+   * fatal for a probe: it reported an invalid key as working, because the
+   * failure it swallowed was the entire answer.
+   *
+   * An SDK too old to expose `models.list` throws rather than passing, so the
+   * caller reports unverifiable — nothing was asked, so nothing is known.
+   */
+  async probeCredential(signal) {
+    signal?.throwIfAborted();
+    const clientLike = this.client;
+    const models = clientLike.models;
+    if (typeof models?.list !== "function") {
+      throw new Error("This SDK version cannot list models, so the key cannot be checked here.");
+    }
+    await models.list({ limit: 1 }, signal ? { signal } : void 0);
+    signal?.throwIfAborted();
+  }
+  knownModels() {
+    return [...OFFLINE_MODEL_CATALOGUE];
+  }
+  async healthCheck() {
+    return Boolean(this.client) && Boolean(this.config.apiKey);
+  }
+  /**
+   * The levels this model will accept, under the thinking configuration the
+   * caller intends to send.
+   *
+   * Deliberately built from the SAME two functions the request path uses —
+   * `resolveThinkingCapability` then `resolveThinkingBody` — rather than
+   * reading `capability.effort` directly. Reading the field would answer the
+   * question for adaptive thinking and silently give the wrong answer while
+   * thinking is disabled, which is precisely the trap this method exists to
+   * remove. Sharing the resolution means a caller's picker and the request
+   * it produces cannot disagree: if they ever do, they do so together, and
+   * the capability tests catch it.
+   */
+  effortLevelsFor(model, thinking) {
+    const capability = resolveThinkingCapability(model);
+    const body = resolveThinkingBody(thinking, capability);
+    return body?.type === "disabled" ? capability.effortWhenDisabled : capability.effort;
+  }
+  reasoningEffortLevelsFor(model, thinking) {
+    return this.effortLevelsFor(model, thinking);
+  }
+};
+var OFFLINE_MODEL_CATALOGUE = [
+  {
+    id: "claude-sonnet-4-5-20250929",
+    name: "Claude Sonnet 4.5",
+    contextWindow: 2e5,
+    maxOutputTokens: 64e3,
+    inputPrice: 3,
+    outputPrice: 15,
+    supportsToolUse: true,
+    supportsStreaming: true
+  },
+  {
+    id: "claude-opus-4-1-20250805",
+    name: "Claude Opus 4.1",
+    contextWindow: 2e5,
+    maxOutputTokens: 32e3,
+    inputPrice: 15,
+    outputPrice: 75,
+    supportsToolUse: true,
+    supportsStreaming: true
+  },
+  {
+    id: "claude-haiku-4-5-20251001",
+    name: "Claude Haiku 4.5",
+    contextWindow: 2e5,
+    maxOutputTokens: 64e3,
+    inputPrice: 1,
+    outputPrice: 5,
+    supportsToolUse: true,
+    supportsStreaming: true
+  }
+];
+function hostedSearchQuery(json) {
+  if (!json)
+    return void 0;
+  try {
+    const input = JSON.parse(json);
+    return typeof input.query === "string" && input.query.trim().length > 0 ? input.query.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(hostedSearchQuery, "hostedSearchQuery");
+
+// ../providers/anthropic/dist/index.js
+function registerAnthropic(options) {
+  ProviderRegistry.register("anthropic", AnthropicProvider, ANTHROPIC_CAPABILITIES, options);
+}
+__name(registerAnthropic, "registerAnthropic");
+export {
+  ANTHROPIC_CAPABILITIES,
+  AnthropicProvider,
+  acceptsForcedToolChoice,
+  registerAnthropic,
+  resolveEffort,
+  resolveThinkingBody,
+  resolveThinkingCapability
+};
+//# sourceMappingURL=dist-OTTZ7WVD.js.map