@warlock.js/ai-anthropic 5.29.0 → 5.31.0

package/esm/config.type.d.mts

@@ -2,7 +2,7 @@ import { AnthropicThinkingMode } from "./thinking-mode.mjs";
 import { ClientOptions } from "@anthropic-ai/sdk";
 import { ModelConfig, ModelPricing } from "@warlock.js/ai";
 
-//#region ../ai-anthropic/src/config.type.d.ts
+//#region ../../packages/ai-anthropic/src/config.type.d.ts
 /**
  * Configuration for the Anthropic SDK adapter.
  *
@@ -58,6 +58,18 @@ type AnthropicModelConfig = ModelConfig & {
    * deployments or capability-degraded testing.
    */
   vision?: boolean;
+  /**
+   * The model's maximum output tokens, used to size the default
+   * `max_tokens` when no `maxTokens` is set. Inferred from known Claude
+   * ids (`known-output-limits.ts`: 128K for the Claude 5 family and
+   * Opus 4.6–4.8 / Sonnet 4.6, 64K for Opus / Sonnet / Haiku 4.5); set it
+   * for gateway or proxy ids the adapter does not recognise. Unknown ids
+   * default to 16384.
+   *
+   * @example
+   * anthropic.model({ name: "my-gateway/opus", maxOutputTokens: 128_000 });
+   */
+  maxOutputTokens?: number;
   /**
    * Override the inferred `structuredOutput` capability. When omitted,
    * the adapter treats the model as capable and forwards
@@ -92,7 +104,8 @@ type AnthropicModelConfig = ModelConfig & {
    * Lifetime for prompt-cache entries emitted by `promptCaching` and
    * explicit `cacheControl.breakpoints`. Omit for Anthropic's default
    * five-minute TTL; use `"1h"` only when its higher write cost is worth
-   * retaining a stable prefix for longer.
+   * retaining a stable prefix for longer. A per-call
+   * `ModelCallOptions.cacheControl.ttl` overrides it for that call.
    */
   promptCacheTtl?: "5m" | "1h";
   /**
@@ -123,7 +136,161 @@ type AnthropicModelConfig = ModelConfig & {
    * anthropic.model({ name: "my-gateway/haiku", thinkingMode: "budget" });
    */
   thinkingMode?: AnthropicThinkingMode;
+  /**
+   * Override whether the model runs Anthropic's preserved-thinking
+   * conversation check (a replayed thinking block is valid only while
+   * everything before it is unchanged). When omitted it is inferred from the
+   * model name: `true` for Claude Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5
+   * and unknown ids on adaptive thinking; `false` for older models and every
+   * budget-mode model.
+   *
+   * When `true`, assistant turns that client-side compaction kept after its
+   * summary (`Message.compaction === "retained"`) are replayed without their
+   * thinking blocks, which were produced against the replaced history.
+   */
+  preservedThinking?: boolean;
+};
+/**
+ * `clear_tool_uses_20250919` context editing: the API replaces the oldest
+ * tool results with a placeholder once the prompt passes `trigger`. Omitted
+ * fields use the API defaults (trigger 100,000 input tokens, keep 3 tool
+ * uses; Anthropic docs, "Context editing", read 2026-10-17).
+ */
+type AnthropicClearToolUses = {
+  /** When clearing starts: an input-token count or a tool-use count. */trigger?: {
+    inputTokens: number;
+  } | {
+    toolUses: number;
+  }; /** How many of the most recent tool uses keep their results. */
+  keep?: number; /** Apply only when at least this many input tokens can be cleared. */
+  clearAtLeast?: number; /** Tool names whose uses and results are never cleared. */
+  excludeTools?: string[]; /** Also clear the tool-use inputs: `true` for every tool, or a list of tool names. */
+  clearToolInputs?: boolean | string[];
+};
+/**
+ * `clear_thinking_20251015` context editing: keep thinking blocks for only
+ * the most recent `keep` assistant turns, or `"all"`. Omitted, the
+ * model's default applies (keep all on Opus 4.5+, Sonnet 4.6+, Haiku 5.5 and
+ * the Fable / Mythos models; last turn only on older ones).
+ */
+type AnthropicClearThinking = {
+  keep?: number | "all";
+};
+/**
+ * Typed Anthropic context editing (beta `context-management-2025-06-27`,
+ * added automatically). Server-side edits don't count as history edits for
+ * preserved thinking: the API checks the conversation as you sent it.
+ */
+type AnthropicContextManagement = {
+  /** Clear old tool results. `true` uses the API defaults. */clearToolUses?: true | AnthropicClearToolUses; /** Clear thinking blocks from older turns. `true` uses the model default. */
+  clearThinking?: true | AnthropicClearThinking;
+};
+/**
+ * Server-side compaction at a token threshold (`compact_20260112`, beta
+ * `compact-2026-01-12`, added automatically). When the prompt reaches
+ * `triggerTokens` the API summarizes earlier context into a `compaction`
+ * block at the start of the response; the agent keeps it on the turn's
+ * `blocks` and the next request sends it back, so the API drops what came
+ * before it. Source: Anthropic docs, "Compaction at a token threshold",
+ * read 2026-10-17.
+ */
+type AnthropicServerCompaction = {
+  /** Input tokens that trigger compaction. At least 50,000; API default 150,000. */triggerTokens?: number;
+  /**
+   * Replaces the default summarization prompt entirely. When the request has
+   * tools, say "do not call any tools", or the summary step may call one.
+   */
+  instructions?: string;
+};
+/**
+ * Anthropic-only request options, passed per call (or through the agent's
+ * `modelOptions`) as `providerOptions.anthropic`. Other adapters ignore
+ * this key, so the same options object is safe in a cross-provider
+ * fallback chain.
+ *
+ * @example
+ * // Server-side compaction and tool-result clearing (betas added for you).
+ * const agent = ai.agent({
+ *   model: anthropic.model({ name: "claude-opus-5-5" }),
+ *   modelOptions: {
+ *     providerOptions: {
+ *       anthropic: {
+ *         serverCompaction: { triggerTokens: 200_000 },
+ *         contextManagement: { clearToolUses: { trigger: { inputTokens: 100_000 }, keep: 5 } },
+ *       },
+ *     },
+ *   },
+ * });
+ *
+ * @example
+ * // Readable thinking summaries plus the refusal fallback.
+ * await model.complete(messages, {
+ *   reasoning: { effort: "high" },
+ *   providerOptions: {
+ *     anthropic: {
+ *       thinkingDisplay: "summarized",
+ *       betas: ["server-side-fallback-2026-07-01"],
+ *       body: { fallbacks: "default" },
+ *     },
+ *   },
+ * });
+ */
+type AnthropicCallOptions = {
+  /**
+   * Beta flags (`anthropic-beta` header values). When non-empty the
+   * request goes through the SDK's `client.beta.messages` endpoint, which
+   * accepts the beta-only body fields (`context_management`, `fallbacks`,
+   * `speed`, …) and returns beta-only blocks such as `compaction`.
+   */
+  betas?: string[];
+  /**
+   * Extra Messages API body fields, merged last over the adapter-built
+   * body — e.g. `context_management`, `fallbacks`, `inference_geo`,
+   * `tool_choice`, `metadata`. Sent as-is: the adapter does not validate
+   * them, so a field the endpoint or model rejects surfaces as the
+   * provider's 400. The fields the adapter builds from the call —
+   * `model`, `messages`, `system`, `tools`, `mcp_servers`, `stream` — are
+   * refused with `InvalidRequestError`. Never pass end-user input here.
+   */
+  body?: Record<string, unknown>;
+  /**
+   * `thinking.display` for adaptive-thinking models: `"summarized"`
+   * returns readable thinking summaries, `"omitted"` (the API default on
+   * Claude 5-family models) returns empty thinking text, `"updates"`
+   * returns between-tool progress notes (needs the
+   * `thinking-display-updates-2026-08-18` beta). Applied whenever the
+   * adapter sends `thinking` to an adaptive-mode model — i.e. alongside a
+   * `reasoning` option (on Claude 5-family models, `reasoning: { effort }`
+   * is enough). Ignored on budget-mode models.
+   */
+  thinkingDisplay?: "summarized" | "omitted" | "updates";
+  /**
+   * Typed context editing: clear old tool results and/or old thinking
+   * blocks server-side. Adds `context_management.edits` and the
+   * `context-management-2025-06-27` beta. Cannot be combined with a
+   * `context_management` field in `body`.
+   */
+  contextManagement?: AnthropicContextManagement;
+  /**
+   * Server-side compaction at a token threshold: `true` for the API
+   * defaults, or `{ triggerTokens, instructions }`. Adds the
+   * `compact_20260112` edit and the `compact-2026-01-12` beta. Cannot be
+   * combined with a `context_management` field in `body`.
+   */
+  serverCompaction?: boolean | AnthropicServerCompaction;
+  /**
+   * `thinking.block_binding.prefix_mismatch_behavior` (beta
+   * `thinking-binding-controls-2026-08-01`, added automatically): what the
+   * API does with a replayed thinking block whose conversation changed —
+   * `"error"` (a 400) or `"drop_block"` (drop it and every later one,
+   * reported in `input_transformations`). Use `"drop_block"` to recover a
+   * stored conversation that was edited. Applied to adaptive and
+   * budget-mode thinking; ignored, with a debug log, when the request sends
+   * thinking in another shape. While set, retained turns are replayed with
+   * their thinking blocks and the API decides.
+   */
+  thinkingBlockBinding?: "error" | "drop_block";
 };
 //#endregion
-export { AnthropicModelConfig, AnthropicSDKConfig };
+export { AnthropicCallOptions, AnthropicClearThinking, AnthropicClearToolUses, AnthropicContextManagement, AnthropicModelConfig, AnthropicSDKConfig, AnthropicServerCompaction };
 //# sourceMappingURL=config.type.d.mts.map

package/esm/config.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../ai-anthropic/src/config.type.ts"],"mappings":";;;;;;;AAiCA;;;;;;;;;;;;;;AAOuC;AAWvC;;;;;;;;;;;;KAlBY,kBAAA,GAAqB,aAAA;EAC/B,QAAA;;;;;;EAMA,OAAA,GAAU,MAAA,SAAe,YAAA;AAAA;;;;;;;;;KAWf,oBAAA,GAAuB,WAAA;;;;;;;;EAQjC,MAAA;;;;;;;;;EASA,gBAAA;;;;;;;;;;;;;;;;;;;;;EAqBA,aAAA;;;;;;;EAOA,cAAA;;;;;;;;;;EAUA,SAAA;;;;;;;;;;;;;;;;;;EAkBA,YAAA,GAAe,qBAAqB;AAAA"}
+{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-anthropic/src/config.type.ts"],"mappings":";;;;;;;AAiCA;;;;;;;;;;;;;;AAOuC;AAWvC;;;;;;;;;;;;KAlBY,kBAAA,GAAqB,aAAA;EAC/B,QAAA;EAoHiB;AAAA;AASnB;;;EAvHE,OAAA,GAAU,MAAA,SAAe,YAAA;AAAA;;;;;;;;AAiIV;KAtHL,oBAAA,GAAuB,WAAA;EA+HD;;;AAAS;AAO3C;;;EA9HE,MAAA;EAgIA;;;;;AAE6C;AAY/C;;;;AAOc;EAzIZ,eAAA;EA6K8B;;;;;;;;EApK9B,gBAAA;EAqLO;;;;;;;;AAqCa;;;;;;;;;;;;EArMpB,aAAA;;;;;;;;EAQA,cAAA;;;;;;;;;;EAUA,SAAA;;;;;;;;;;;;;;;;;;EAkBA,YAAA,GAAe,qBAAqB;;;;;;;;;;;;;EAapC,iBAAA;AAAA;;;;;;;KASU,sBAAA;wEAEV,OAAA;IAAY,WAAA;EAAA;IAA0B,QAAA;EAAA;EAEtC,IAAA;EAEA,YAAA;EAEA,YAAA;EAEA,eAAA;AAAA;;;;;;;KASU,sBAAA;EAA2B,IAAI;AAAA;;;;;;KAO/B,0BAAA;8DAEV,aAAA,UAAuB,sBAAA;EAEvB,aAAA,UAAuB,sBAAsB;AAAA;;;;;;;;;;KAYnC,yBAAA;oFAEV,aAAA;;;;;EAKA,YAAY;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoCF,oBAAA;;;;;;;EAOV,KAAA;;;;;;;;;;EAUA,IAAA,GAAO,MAAA;;;;;;;;;;;EAWP,eAAA;;;;;;;EAOA,iBAAA,GAAoB,0BAAA;;;;;;;EAOpB,gBAAA,aAA6B,yBAAA;;;;;;;;;;;;EAY7B,oBAAA;AAAA"}

package/esm/index.d.mts

@@ -1,4 +1,10 @@
-import { AnthropicThinkingMode } from "./thinking-mode.mjs";
-import { AnthropicModelConfig, AnthropicSDKConfig } from "./config.type.mjs";
+import { AnthropicThinkingMode, inferPreservedThinking } from "./thinking-mode.mjs";
+import { AnthropicCallOptions, AnthropicClearThinking, AnthropicClearToolUses, AnthropicContextManagement, AnthropicModelConfig, AnthropicSDKConfig, AnthropicServerCompaction } from "./config.type.mjs";
+import { AnthropicNonStreamingRequest, AnthropicRequest, AnthropicRequestOptions, AnthropicStreamingRequest } from "./request.type.mjs";
+import { AnthropicModel } from "./model.mjs";
 import { AnthropicSDK } from "./sdk.mjs";
-export { type AnthropicModelConfig, AnthropicSDK, type AnthropicSDKConfig, type AnthropicThinkingMode };
+import { ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, anthropicPricingFor, withAnthropicCacheWriteRates } from "./known-pricing.mjs";
+import { ANTHROPIC_BLOCK_FORMAT, fromProviderBlocks, toProviderBlocks } from "./utils/provider-blocks.mjs";
+import { AnthropicMessages, ToAnthropicMessagesOptions, toAnthropicMessages } from "./utils/to-anthropic-messages.mjs";
+import { toAnthropicTools } from "./utils/to-anthropic-tools.mjs";
+export { ANTHROPIC_BLOCK_FORMAT, ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, type AnthropicCallOptions, type AnthropicClearThinking, type AnthropicClearToolUses, type AnthropicContextManagement, type AnthropicMessages, AnthropicModel, type AnthropicModelConfig, type AnthropicNonStreamingRequest, type AnthropicRequest, type AnthropicRequestOptions, AnthropicSDK, type AnthropicSDKConfig, type AnthropicServerCompaction, type AnthropicStreamingRequest, type AnthropicThinkingMode, type ToAnthropicMessagesOptions, anthropicPricingFor, fromProviderBlocks, inferPreservedThinking, toAnthropicMessages, toAnthropicTools, toProviderBlocks, withAnthropicCacheWriteRates };

package/esm/index.mjs

@@ -1,3 +1,10 @@
+import { ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, anthropicPricingFor, withAnthropicCacheWriteRates } from "./known-pricing.mjs";
+import { inferPreservedThinking } from "./thinking-mode.mjs";
+import { ANTHROPIC_BLOCK_FORMAT, fromProviderBlocks, toProviderBlocks } from "./utils/provider-blocks.mjs";
+import { toAnthropicMessages } from "./utils/to-anthropic-messages.mjs";
+import { toAnthropicTools } from "./utils/to-anthropic-tools.mjs";
+import "./utils/index.mjs";
+import { AnthropicModel } from "./model.mjs";
 import { AnthropicSDK } from "./sdk.mjs";
 
-export { AnthropicSDK };
+export { ANTHROPIC_BLOCK_FORMAT, ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, AnthropicModel, AnthropicSDK, anthropicPricingFor, fromProviderBlocks, inferPreservedThinking, toAnthropicMessages, toAnthropicTools, toProviderBlocks, withAnthropicCacheWriteRates };

package/esm/known-output-limits.mjs

@@ -0,0 +1,46 @@
+import { matchesReleaseRoot } from "./thinking-mode.mjs";
+
+//#region ../../packages/ai-anthropic/src/known-output-limits.ts
+/** Family prefixes whose every release has a 128K output limit. */
+const FAMILY_128K_PREFIXES = [
+	"claude-fable-5",
+	"claude-mythos-5",
+	"claude-opus-5",
+	"claude-sonnet-5",
+	"claude-haiku-5"
+];
+/** Individual releases, matched as a release root (dated / `@` variants included). */
+const RELEASE_OUTPUT_LIMITS = [
+	["claude-opus-4-8", 128e3],
+	["claude-opus-4-7", 128e3],
+	["claude-opus-4-6", 128e3],
+	["claude-sonnet-4-6", 128e3],
+	["claude-opus-4-5", 64e3],
+	["claude-sonnet-4-5", 64e3],
+	["claude-haiku-4-5", 64e3]
+];
+/**
+* The documented maximum output tokens of a Claude model, or `undefined`
+* when the id is not a known Claude model. Platform prefixes before
+* `claude-` (`anthropic.`, `us.anthropic.`) and dated or `@` snapshot
+* suffixes are accepted, so the Bedrock / Google Cloud ids of a known
+* model resolve too. Override per model with
+* `anthropic.model({ name, maxOutputTokens })`.
+*
+* @example
+* inferMaxOutputTokens("claude-opus-5-5");           // → 128000
+* inferMaxOutputTokens("claude-haiku-4-5-20251001"); // → 64000
+* inferMaxOutputTokens("my-gateway/model");          // → undefined
+*/
+function inferMaxOutputTokens(modelName) {
+	const lowered = modelName.toLowerCase();
+	const start = lowered.indexOf("claude-");
+	if (start === -1) return;
+	const normalized = lowered.slice(start);
+	if (FAMILY_128K_PREFIXES.some((prefix) => normalized.startsWith(prefix))) return 128e3;
+	for (const [root, limit] of RELEASE_OUTPUT_LIMITS) if (matchesReleaseRoot(normalized, root)) return limit;
+}
+
+//#endregion
+export { inferMaxOutputTokens };
+//# sourceMappingURL=known-output-limits.mjs.map

package/esm/known-output-limits.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-output-limits.mjs","names":[],"sources":["../../../../../../../packages/ai-anthropic/src/known-output-limits.ts"],"sourcesContent":["import { matchesReleaseRoot } from \"./thinking-mode\";\n\n/*\n * Documented maximum output tokens (`max_tokens`) on the synchronous\n * Messages API. Source: Anthropic's model pages and models overview,\n * platform.claude.com/docs/en/about-claude/models/overview and\n * …/models/{opus-4-5,sonnet-4-5,haiku-4-5}/overview, checked 2026-10-17.\n *\n * | Model ids                                                    | Max output |\n * |--------------------------------------------------------------|------------|\n * | Claude 5 family: fable-5 / 5.1, mythos-5 / 5.1, opus-5 / 5.5, | 128K       |\n * | sonnet-5 / 5.5, haiku-5-5                                    |            |\n * | claude-opus-4-8, claude-opus-4-7, claude-opus-4-6,           | 128K       |\n * | claude-sonnet-4-6                                            |            |\n * | claude-opus-4-5, claude-sonnet-4-5, claude-haiku-4-5         | 64K        |\n *\n * Older models (Claude 3.x, Opus 4 / 4.1, Sonnet 4) are retired and have no\n * entry; like any id not listed they fall back to the adapter default.\n */\n\n/** Family prefixes whose every release has a 128K output limit. */\nconst FAMILY_128K_PREFIXES = [\n  \"claude-fable-5\",\n  \"claude-mythos-5\",\n  \"claude-opus-5\",\n  \"claude-sonnet-5\",\n  \"claude-haiku-5\",\n];\n\n/** Individual releases, matched as a release root (dated / `@` variants included). */\nconst RELEASE_OUTPUT_LIMITS: ReadonlyArray<readonly [root: string, limit: number]> = [\n  [\"claude-opus-4-8\", 128_000],\n  [\"claude-opus-4-7\", 128_000],\n  [\"claude-opus-4-6\", 128_000],\n  [\"claude-sonnet-4-6\", 128_000],\n  [\"claude-opus-4-5\", 64_000],\n  [\"claude-sonnet-4-5\", 64_000],\n  [\"claude-haiku-4-5\", 64_000],\n];\n\n/**\n * The documented maximum output tokens of a Claude model, or `undefined`\n * when the id is not a known Claude model. Platform prefixes before\n * `claude-` (`anthropic.`, `us.anthropic.`) and dated or `@` snapshot\n * suffixes are accepted, so the Bedrock / Google Cloud ids of a known\n * model resolve too. Override per model with\n * `anthropic.model({ name, maxOutputTokens })`.\n *\n * @example\n * inferMaxOutputTokens(\"claude-opus-5-5\");           // → 128000\n * inferMaxOutputTokens(\"claude-haiku-4-5-20251001\"); // → 64000\n * inferMaxOutputTokens(\"my-gateway/model\");          // → undefined\n */\nexport function inferMaxOutputTokens(modelName: string): number | undefined {\n  const lowered = modelName.toLowerCase();\n  const start = lowered.indexOf(\"claude-\");\n\n  if (start === -1) {\n    return undefined;\n  }\n\n  const normalized = lowered.slice(start);\n\n  if (FAMILY_128K_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {\n    return 128_000;\n  }\n\n  for (const [root, limit] of RELEASE_OUTPUT_LIMITS) {\n    if (matchesReleaseRoot(normalized, root)) {\n      return limit;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;AAqBA,MAAM,uBAAuB;CAC3B;CACA;CACA;CACA;CACA;AACF;;AAGA,MAAM,wBAA+E;CACnF,CAAC,mBAAmB,KAAO;CAC3B,CAAC,mBAAmB,KAAO;CAC3B,CAAC,mBAAmB,KAAO;CAC3B,CAAC,qBAAqB,KAAO;CAC7B,CAAC,mBAAmB,IAAM;CAC1B,CAAC,qBAAqB,IAAM;CAC5B,CAAC,oBAAoB,IAAM;AAC7B;;;;;;;;;;;;;;AAeA,SAAgB,qBAAqB,WAAuC;CAC1E,MAAM,UAAU,UAAU,YAAY;CACtC,MAAM,QAAQ,QAAQ,QAAQ,SAAS;CAEvC,IAAI,UAAU,IACZ;CAGF,MAAM,aAAa,QAAQ,MAAM,KAAK;CAEtC,IAAI,qBAAqB,MAAM,WAAW,WAAW,WAAW,MAAM,CAAC,GACrE,OAAO;CAGT,KAAK,MAAM,CAAC,MAAM,UAAU,uBAC1B,IAAI,mBAAmB,YAAY,IAAI,GACrC,OAAO;AAKb"}

package/esm/known-pricing.d.mts

@@ -0,0 +1,58 @@
+import { ModelPricing } from "@warlock.js/ai";
+
+//#region ../../packages/ai-anthropic/src/known-pricing.d.ts
+/**
+ * Anthropic's prompt-cache write multipliers, relative to the base input
+ * rate: a 5-minute write costs 1.25x, a 1-hour write 2x. They hold for
+ * every Claude model on Anthropic's price list.
+ *
+ * Source: https://platform.claude.com/docs/en/about-claude/pricing
+ * (fetched 2026-10-17).
+ */
+declare const ANTHROPIC_CACHE_WRITE_MULTIPLIER = 1.25;
+declare const ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = 2;
+/**
+ * Built-in Claude API list prices, USD per 1,000,000 tokens, keyed by
+ * model id. `cachedInput` is the cache-hit rate, `cacheWrite` the
+ * 5-minute write rate and `cacheWrite1h` the 1-hour write rate.
+ *
+ * Source: https://platform.claude.com/docs/en/about-claude/pricing,
+ * "Model pricing" table, fetched 2026-10-17. Standard (global) routing,
+ * non-batch. Not covered, so pass `pricing` yourself when you need them:
+ *
+ * - Claude Haiku 5.5 — priced by prompt length (higher rates above
+ *   100,000 prompt tokens), which a flat `ModelPricing` cannot express.
+ * - US-only inference (`inference_geo: "us"`, 1.1x), fast mode, the Batch
+ *   API, and Claude on Bedrock / Vertex AI (partner-priced).
+ * - Limited-availability models (Mythos) and retired models.
+ *
+ * Dated snapshot ids (`claude-haiku-4-5-20251001`) resolve to their alias
+ * entry through {@link anthropicPricingFor}.
+ */
+declare const ANTHROPIC_MODEL_PRICING: Readonly<Record<string, ModelPricing>>;
+/**
+ * Look up the built-in list price for a Claude model id. Accepts the
+ * alias (`claude-sonnet-4-5`) or a dated snapshot
+ * (`claude-sonnet-4-5-20250929`). Returns `undefined` for any id not in
+ * {@link ANTHROPIC_MODEL_PRICING}, so cost stays unknown rather than wrong.
+ *
+ * @example
+ * anthropicPricingFor("claude-haiku-4-5-20251001"); // { input: 1, output: 5, … }
+ * anthropicPricingFor("claude-haiku-5-5"); // undefined (prompt-length tiers)
+ */
+declare function anthropicPricingFor(modelName: string): ModelPricing | undefined;
+/**
+ * Fill the cache-write rates Anthropic derives from the input rate
+ * (5-minute writes 1.25x, 1-hour writes 2x) into a pricing entry that
+ * omits them, so a caller who supplies only `{ input, output }` is no
+ * longer billed nothing for cache writes. Explicit rates always win; the
+ * cache-read rate is left alone because it differs per model.
+ *
+ * @example
+ * withAnthropicCacheWriteRates({ input: 3, output: 15 });
+ * // { input: 3, output: 15, cacheWrite: 3.75, cacheWrite1h: 6 }
+ */
+declare function withAnthropicCacheWriteRates(pricing: ModelPricing | undefined): ModelPricing | undefined;
+//#endregion
+export { ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, anthropicPricingFor, withAnthropicCacheWriteRates };
+//# sourceMappingURL=known-pricing.d.mts.map

package/esm/known-pricing.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-pricing.d.mts","names":[],"sources":["../../../../../../../packages/ai-anthropic/src/known-pricing.ts"],"mappings":";;;;;AAUA;;;;AAA6C;AAC7C;cADa,gCAAA;AAAA,cACA,mCAAA;;AAAmC;AAoBhD;;;;;;;;;;;;AAA0E;AA+C1E;;;cA/Ca,uBAAA,EAAyB,QAAA,CAAS,MAAA,SAAe,YAAA;AA+CM;AAqBpE;;;;;;;;AAEe;AAvBqD,iBAApD,mBAAA,CAAoB,SAAA,WAAoB,YAAY;;;;;;;;;;;;iBAqBpD,4BAAA,CACd,OAAA,EAAS,YAAA,eACR,YAAY"}

package/esm/known-pricing.mjs

@@ -0,0 +1,165 @@
+//#region ../../packages/ai-anthropic/src/known-pricing.ts
+/**
+* Anthropic's prompt-cache write multipliers, relative to the base input
+* rate: a 5-minute write costs 1.25x, a 1-hour write 2x. They hold for
+* every Claude model on Anthropic's price list.
+*
+* Source: https://platform.claude.com/docs/en/about-claude/pricing
+* (fetched 2026-10-17).
+*/
+const ANTHROPIC_CACHE_WRITE_MULTIPLIER = 1.25;
+const ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = 2;
+/**
+* Built-in Claude API list prices, USD per 1,000,000 tokens, keyed by
+* model id. `cachedInput` is the cache-hit rate, `cacheWrite` the
+* 5-minute write rate and `cacheWrite1h` the 1-hour write rate.
+*
+* Source: https://platform.claude.com/docs/en/about-claude/pricing,
+* "Model pricing" table, fetched 2026-10-17. Standard (global) routing,
+* non-batch. Not covered, so pass `pricing` yourself when you need them:
+*
+* - Claude Haiku 5.5 — priced by prompt length (higher rates above
+*   100,000 prompt tokens), which a flat `ModelPricing` cannot express.
+* - US-only inference (`inference_geo: "us"`, 1.1x), fast mode, the Batch
+*   API, and Claude on Bedrock / Vertex AI (partner-priced).
+* - Limited-availability models (Mythos) and retired models.
+*
+* Dated snapshot ids (`claude-haiku-4-5-20251001`) resolve to their alias
+* entry through {@link anthropicPricingFor}.
+*/
+const ANTHROPIC_MODEL_PRICING = {
+	"claude-fable-5-1": {
+		input: 10,
+		output: 50,
+		cachedInput: .25,
+		cacheWrite: 12.5,
+		cacheWrite1h: 20
+	},
+	"claude-fable-5": {
+		input: 10,
+		output: 50,
+		cachedInput: 1,
+		cacheWrite: 12.5,
+		cacheWrite1h: 20
+	},
+	"claude-opus-5-5": {
+		input: 4,
+		output: 20,
+		cachedInput: .2,
+		cacheWrite: 5,
+		cacheWrite1h: 8
+	},
+	"claude-opus-5": {
+		input: 5,
+		output: 25,
+		cachedInput: .5,
+		cacheWrite: 6.25,
+		cacheWrite1h: 10
+	},
+	"claude-opus-4-8": {
+		input: 5,
+		output: 25,
+		cachedInput: .5,
+		cacheWrite: 6.25,
+		cacheWrite1h: 10
+	},
+	"claude-opus-4-7": {
+		input: 5,
+		output: 25,
+		cachedInput: .5,
+		cacheWrite: 6.25,
+		cacheWrite1h: 10
+	},
+	"claude-opus-4-6": {
+		input: 5,
+		output: 25,
+		cachedInput: .5,
+		cacheWrite: 6.25,
+		cacheWrite1h: 10
+	},
+	"claude-opus-4-5": {
+		input: 5,
+		output: 25,
+		cachedInput: .5,
+		cacheWrite: 6.25,
+		cacheWrite1h: 10
+	},
+	"claude-sonnet-5-5": {
+		input: 2,
+		output: 10,
+		cachedInput: .1,
+		cacheWrite: 2.5,
+		cacheWrite1h: 4
+	},
+	"claude-sonnet-5": {
+		input: 2,
+		output: 10,
+		cachedInput: .2,
+		cacheWrite: 2.5,
+		cacheWrite1h: 4
+	},
+	"claude-sonnet-4-6": {
+		input: 3,
+		output: 15,
+		cachedInput: .3,
+		cacheWrite: 3.75,
+		cacheWrite1h: 6
+	},
+	"claude-sonnet-4-5": {
+		input: 3,
+		output: 15,
+		cachedInput: .3,
+		cacheWrite: 3.75,
+		cacheWrite1h: 6
+	},
+	"claude-haiku-4-5": {
+		input: 1,
+		output: 5,
+		cachedInput: .1,
+		cacheWrite: 1.25,
+		cacheWrite1h: 2
+	}
+};
+/** A trailing `-YYYYMMDD` snapshot date on a Claude model id. */
+const SNAPSHOT_SUFFIX = /-\d{8}$/;
+/**
+* Look up the built-in list price for a Claude model id. Accepts the
+* alias (`claude-sonnet-4-5`) or a dated snapshot
+* (`claude-sonnet-4-5-20250929`). Returns `undefined` for any id not in
+* {@link ANTHROPIC_MODEL_PRICING}, so cost stays unknown rather than wrong.
+*
+* @example
+* anthropicPricingFor("claude-haiku-4-5-20251001"); // { input: 1, output: 5, … }
+* anthropicPricingFor("claude-haiku-5-5"); // undefined (prompt-length tiers)
+*/
+function anthropicPricingFor(modelName) {
+	const exact = ANTHROPIC_MODEL_PRICING[modelName];
+	if (exact) return exact;
+	return ANTHROPIC_MODEL_PRICING[modelName.replace(SNAPSHOT_SUFFIX, "")];
+}
+/**
+* Fill the cache-write rates Anthropic derives from the input rate
+* (5-minute writes 1.25x, 1-hour writes 2x) into a pricing entry that
+* omits them, so a caller who supplies only `{ input, output }` is no
+* longer billed nothing for cache writes. Explicit rates always win; the
+* cache-read rate is left alone because it differs per model.
+*
+* @example
+* withAnthropicCacheWriteRates({ input: 3, output: 15 });
+* // { input: 3, output: 15, cacheWrite: 3.75, cacheWrite1h: 6 }
+*/
+function withAnthropicCacheWriteRates(pricing) {
+	if (!pricing) return;
+	const cacheWrite = pricing.cacheWrite ?? pricing.cachedOutput ?? pricing.input * 1.25;
+	const cacheWrite1h = pricing.cacheWrite1h ?? pricing.input * 2;
+	if (pricing.cacheWrite === cacheWrite && pricing.cacheWrite1h === cacheWrite1h) return pricing;
+	return {
+		...pricing,
+		cacheWrite,
+		cacheWrite1h
+	};
+}
+
+//#endregion
+export { ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, anthropicPricingFor, withAnthropicCacheWriteRates };
+//# sourceMappingURL=known-pricing.mjs.map

package/esm/known-pricing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-pricing.mjs","names":[],"sources":["../../../../../../../packages/ai-anthropic/src/known-pricing.ts"],"sourcesContent":["import type { ModelPricing } from \"@warlock.js/ai\";\n\n/**\n * Anthropic's prompt-cache write multipliers, relative to the base input\n * rate: a 5-minute write costs 1.25x, a 1-hour write 2x. They hold for\n * every Claude model on Anthropic's price list.\n *\n * Source: https://platform.claude.com/docs/en/about-claude/pricing\n * (fetched 2026-10-17).\n */\nexport const ANTHROPIC_CACHE_WRITE_MULTIPLIER = 1.25;\nexport const ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = 2;\n\n/**\n * Built-in Claude API list prices, USD per 1,000,000 tokens, keyed by\n * model id. `cachedInput` is the cache-hit rate, `cacheWrite` the\n * 5-minute write rate and `cacheWrite1h` the 1-hour write rate.\n *\n * Source: https://platform.claude.com/docs/en/about-claude/pricing,\n * \"Model pricing\" table, fetched 2026-10-17. Standard (global) routing,\n * non-batch. Not covered, so pass `pricing` yourself when you need them:\n *\n * - Claude Haiku 5.5 — priced by prompt length (higher rates above\n *   100,000 prompt tokens), which a flat `ModelPricing` cannot express.\n * - US-only inference (`inference_geo: \"us\"`, 1.1x), fast mode, the Batch\n *   API, and Claude on Bedrock / Vertex AI (partner-priced).\n * - Limited-availability models (Mythos) and retired models.\n *\n * Dated snapshot ids (`claude-haiku-4-5-20251001`) resolve to their alias\n * entry through {@link anthropicPricingFor}.\n */\nexport const ANTHROPIC_MODEL_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"claude-fable-5-1\": {\n    input: 10,\n    output: 50,\n    cachedInput: 0.25,\n    cacheWrite: 12.5,\n    cacheWrite1h: 20,\n  },\n  \"claude-fable-5\": { input: 10, output: 50, cachedInput: 1, cacheWrite: 12.5, cacheWrite1h: 20 },\n  \"claude-opus-5-5\": { input: 4, output: 20, cachedInput: 0.2, cacheWrite: 5, cacheWrite1h: 8 },\n  \"claude-opus-5\": { input: 5, output: 25, cachedInput: 0.5, cacheWrite: 6.25, cacheWrite1h: 10 },\n  \"claude-opus-4-8\": { input: 5, output: 25, cachedInput: 0.5, cacheWrite: 6.25, cacheWrite1h: 10 },\n  \"claude-opus-4-7\": { input: 5, output: 25, cachedInput: 0.5, cacheWrite: 6.25, cacheWrite1h: 10 },\n  \"claude-opus-4-6\": { input: 5, output: 25, cachedInput: 0.5, cacheWrite: 6.25, cacheWrite1h: 10 },\n  \"claude-opus-4-5\": { input: 5, output: 25, cachedInput: 0.5, cacheWrite: 6.25, cacheWrite1h: 10 },\n  \"claude-sonnet-5-5\": { input: 2, output: 10, cachedInput: 0.1, cacheWrite: 2.5, cacheWrite1h: 4 },\n  \"claude-sonnet-5\": { input: 2, output: 10, cachedInput: 0.2, cacheWrite: 2.5, cacheWrite1h: 4 },\n  \"claude-sonnet-4-6\": {\n    input: 3,\n    output: 15,\n    cachedInput: 0.3,\n    cacheWrite: 3.75,\n    cacheWrite1h: 6,\n  },\n  \"claude-sonnet-4-5\": {\n    input: 3,\n    output: 15,\n    cachedInput: 0.3,\n    cacheWrite: 3.75,\n    cacheWrite1h: 6,\n  },\n  \"claude-haiku-4-5\": { input: 1, output: 5, cachedInput: 0.1, cacheWrite: 1.25, cacheWrite1h: 2 },\n};\n\n/** A trailing `-YYYYMMDD` snapshot date on a Claude model id. */\nconst SNAPSHOT_SUFFIX = /-\\d{8}$/;\n\n/**\n * Look up the built-in list price for a Claude model id. Accepts the\n * alias (`claude-sonnet-4-5`) or a dated snapshot\n * (`claude-sonnet-4-5-20250929`). Returns `undefined` for any id not in\n * {@link ANTHROPIC_MODEL_PRICING}, so cost stays unknown rather than wrong.\n *\n * @example\n * anthropicPricingFor(\"claude-haiku-4-5-20251001\"); // { input: 1, output: 5, … }\n * anthropicPricingFor(\"claude-haiku-5-5\"); // undefined (prompt-length tiers)\n */\nexport function anthropicPricingFor(modelName: string): ModelPricing | undefined {\n  const exact = ANTHROPIC_MODEL_PRICING[modelName];\n\n  if (exact) {\n    return exact;\n  }\n\n  return ANTHROPIC_MODEL_PRICING[modelName.replace(SNAPSHOT_SUFFIX, \"\")];\n}\n\n/**\n * Fill the cache-write rates Anthropic derives from the input rate\n * (5-minute writes 1.25x, 1-hour writes 2x) into a pricing entry that\n * omits them, so a caller who supplies only `{ input, output }` is no\n * longer billed nothing for cache writes. Explicit rates always win; the\n * cache-read rate is left alone because it differs per model.\n *\n * @example\n * withAnthropicCacheWriteRates({ input: 3, output: 15 });\n * // { input: 3, output: 15, cacheWrite: 3.75, cacheWrite1h: 6 }\n */\nexport function withAnthropicCacheWriteRates(\n  pricing: ModelPricing | undefined,\n): ModelPricing | undefined {\n  if (!pricing) {\n    return undefined;\n  }\n\n  const cacheWrite =\n    pricing.cacheWrite ?? pricing.cachedOutput ?? pricing.input * ANTHROPIC_CACHE_WRITE_MULTIPLIER;\n  const cacheWrite1h = pricing.cacheWrite1h ?? pricing.input * ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER;\n\n  if (pricing.cacheWrite === cacheWrite && pricing.cacheWrite1h === cacheWrite1h) {\n    return pricing;\n  }\n\n  return { ...pricing, cacheWrite, cacheWrite1h };\n}\n"],"mappings":";;;;;;;;;AAUA,MAAa,mCAAmC;AAChD,MAAa,sCAAsC;;;;;;;;;;;;;;;;;;;AAoBnD,MAAa,0BAAkE;CAC7E,oBAAoB;EAClB,OAAO;EACP,QAAQ;EACR,aAAa;EACb,YAAY;EACZ,cAAc;CAChB;CACA,kBAAkB;EAAE,OAAO;EAAI,QAAQ;EAAI,aAAa;EAAG,YAAY;EAAM,cAAc;CAAG;CAC9F,mBAAmB;EAAE,OAAO;EAAG,QAAQ;EAAI,aAAa;EAAK,YAAY;EAAG,cAAc;CAAE;CAC5F,iBAAiB;EAAE,OAAO;EAAG,QAAQ;EAAI,aAAa;EAAK,YAAY;EAAM,cAAc;CAAG;CAC9F,mBAAmB;EAAE,OAAO;EAAG,QAAQ;EAAI,aAAa;EAAK,YAAY;EAAM,cAAc;CAAG;CAChG,mBAAmB;EAAE,OAAO;EAAG,QAAQ;EAAI,aAAa;EAAK,YAAY;EAAM,cAAc;CAAG;CAChG,mBAAmB;EAAE,OAAO;EAAG,QAAQ;EAAI,aAAa;EAAK,YAAY;EAAM,cAAc;CAAG;CAChG,mBAAmB;EAAE,OAAO;EAAG,QAAQ;EAAI,aAAa;EAAK,YAAY;EAAM,cAAc;CAAG;CAChG,qBAAqB;EAAE,OAAO;EAAG,QAAQ;EAAI,aAAa;EAAK,YAAY;EAAK,cAAc;CAAE;CAChG,mBAAmB;EAAE,OAAO;EAAG,QAAQ;EAAI,aAAa;EAAK,YAAY;EAAK,cAAc;CAAE;CAC9F,qBAAqB;EACnB,OAAO;EACP,QAAQ;EACR,aAAa;EACb,YAAY;EACZ,cAAc;CAChB;CACA,qBAAqB;EACnB,OAAO;EACP,QAAQ;EACR,aAAa;EACb,YAAY;EACZ,cAAc;CAChB;CACA,oBAAoB;EAAE,OAAO;EAAG,QAAQ;EAAG,aAAa;EAAK,YAAY;EAAM,cAAc;CAAE;AACjG;;AAGA,MAAM,kBAAkB;;;;;;;;;;;AAYxB,SAAgB,oBAAoB,WAA6C;CAC/E,MAAM,QAAQ,wBAAwB;CAEtC,IAAI,OACF,OAAO;CAGT,OAAO,wBAAwB,UAAU,QAAQ,iBAAiB,EAAE;AACtE;;;;;;;;;;;;AAaA,SAAgB,6BACd,SAC0B;CAC1B,IAAI,CAAC,SACH;CAGF,MAAM,aACJ,QAAQ,cAAc,QAAQ,gBAAgB,QAAQ;CACxD,MAAM,eAAe,QAAQ,gBAAgB,QAAQ;CAErD,IAAI,QAAQ,eAAe,cAAc,QAAQ,iBAAiB,cAChE,OAAO;CAGT,OAAO;EAAE,GAAG;EAAS;EAAY;CAAa;AAChD"}

package/esm/known-vision-models.mjs

@@ -1,4 +1,4 @@
-//#region ../ai-anthropic/src/known-vision-models.ts
+//#region ../../packages/ai-anthropic/src/known-vision-models.ts
 /**
 * Model-name prefixes for Claude families that accept image input
 * (vision) on the Messages API.

package/esm/known-vision-models.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"known-vision-models.mjs","names":[],"sources":["../../../../../../ai-anthropic/src/known-vision-models.ts"],"sourcesContent":["/**\n * Model-name prefixes for Claude families that accept image input\n * (vision) on the Messages API.\n *\n * Every Claude 3, Claude 3.5/3.7, Claude 4 and Claude 5 family model is\n * multimodal, so the list covers both the dotted legacy naming\n * (`claude-3-haiku-...`, `claude-3-5-sonnet-...`) and the current\n * `claude-<tier>-4-*` naming (`claude-opus-4-7`, `claude-sonnet-4-6`,\n * `claude-haiku-4-5`). Pre-3 families (`claude-2`, `claude-instant`)\n * are text-only and intentionally absent.\n *\n * The Claude 5 series is multimodal too (claude-api ref, cached\n * 2026-09-25): its vision examples use `claude-opus-5-5`; the models list\n * credits Claude Fable 5.1 with vision and Claude Sonnet 5 with\n * high-resolution vision; Claude Mythos 5.1 has \"same capabilities\" as\n * Fable 5.1. The tier-5 prefixes cover every 5.x release\n * (`claude-opus-5`, `claude-opus-5-5`, `claude-sonnet-5-5`,\n * `claude-fable-5-1`, …). Opus/Sonnet 4.6–4.8 are already covered by the\n * tier-4 prefixes.\n *\n * Matched as a prefix so dated variants (`claude-opus-4-20250514`) are\n * covered without listing every release tag. Devs can always override\n * per-model via `anthropic.model({ name, vision: true | false })` —\n * explicit config wins over inference in either direction.\n */\nconst VISION_CAPABLE_PREFIXES = [\n  \"claude-3\",\n  \"claude-4\",\n  \"claude-opus-4\",\n  \"claude-sonnet-4\",\n  \"claude-haiku-4\",\n  \"claude-opus-5\",\n  \"claude-sonnet-5\",\n  \"claude-fable-5\",\n  \"claude-mythos-5\",\n];\n\n/**\n * Infer whether a given Claude model name supports vision based on the\n * known-prefix list. Unknown models default to `false` so that passing\n * an image attachment to an unsupported model surfaces a clear,\n * agent-side capability error instead of an opaque Anthropic 400.\n *\n * @example\n * inferVisionCapability(\"claude-sonnet-4-6\");      // → true\n * inferVisionCapability(\"claude-3-5-sonnet-latest\"); // → true\n * inferVisionCapability(\"claude-2.1\");             // → false\n * inferVisionCapability(\"custom-proxy-llm\");       // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,0BAA0B;CAC9B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;AAcA,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,wBAAwB,MAAM,WAAW,WAAW,WAAW,MAAM,CAAC;AAC/E"}
+{"version":3,"file":"known-vision-models.mjs","names":[],"sources":["../../../../../../../packages/ai-anthropic/src/known-vision-models.ts"],"sourcesContent":["/**\n * Model-name prefixes for Claude families that accept image input\n * (vision) on the Messages API.\n *\n * Every Claude 3, Claude 3.5/3.7, Claude 4 and Claude 5 family model is\n * multimodal, so the list covers both the dotted legacy naming\n * (`claude-3-haiku-...`, `claude-3-5-sonnet-...`) and the current\n * `claude-<tier>-4-*` naming (`claude-opus-4-7`, `claude-sonnet-4-6`,\n * `claude-haiku-4-5`). Pre-3 families (`claude-2`, `claude-instant`)\n * are text-only and intentionally absent.\n *\n * The Claude 5 series is multimodal too (claude-api ref, cached\n * 2026-09-25): its vision examples use `claude-opus-5-5`; the models list\n * credits Claude Fable 5.1 with vision and Claude Sonnet 5 with\n * high-resolution vision; Claude Mythos 5.1 has \"same capabilities\" as\n * Fable 5.1. The tier-5 prefixes cover every 5.x release\n * (`claude-opus-5`, `claude-opus-5-5`, `claude-sonnet-5-5`,\n * `claude-fable-5-1`, …). Opus/Sonnet 4.6–4.8 are already covered by the\n * tier-4 prefixes.\n *\n * Matched as a prefix so dated variants (`claude-opus-4-20250514`) are\n * covered without listing every release tag. Devs can always override\n * per-model via `anthropic.model({ name, vision: true | false })` —\n * explicit config wins over inference in either direction.\n */\nconst VISION_CAPABLE_PREFIXES = [\n  \"claude-3\",\n  \"claude-4\",\n  \"claude-opus-4\",\n  \"claude-sonnet-4\",\n  \"claude-haiku-4\",\n  \"claude-opus-5\",\n  \"claude-sonnet-5\",\n  \"claude-fable-5\",\n  \"claude-mythos-5\",\n];\n\n/**\n * Infer whether a given Claude model name supports vision based on the\n * known-prefix list. Unknown models default to `false` so that passing\n * an image attachment to an unsupported model surfaces a clear,\n * agent-side capability error instead of an opaque Anthropic 400.\n *\n * @example\n * inferVisionCapability(\"claude-sonnet-4-6\");      // → true\n * inferVisionCapability(\"claude-3-5-sonnet-latest\"); // → true\n * inferVisionCapability(\"claude-2.1\");             // → false\n * inferVisionCapability(\"custom-proxy-llm\");       // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,0BAA0B;CAC9B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;AAcA,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,wBAAwB,MAAM,WAAW,WAAW,WAAW,MAAM,CAAC;AAC/E"}