@warlock.js/ai-anthropic 5.30.0 → 5.32.0

package/esm/config.type.d.mts

@@ -1,7 +1,6 @@
 import { AnthropicThinkingMode } from "./thinking-mode.mjs";
 import { ClientOptions } from "@anthropic-ai/sdk";
 import { ModelConfig, ModelPricing } from "@warlock.js/ai";
-
 //#region ../../packages/ai-anthropic/src/config.type.d.ts
 /**
  * Configuration for the Anthropic SDK adapter.
@@ -32,7 +31,7 @@ import { ModelConfig, ModelPricing } from "@warlock.js/ai";
  *   },
  * });
  */
-type AnthropicSDKConfig = ClientOptions & {
+export type AnthropicSDKConfig = ClientOptions & {
   provider?: string;
   /**
    * Per-model USD pricing registry, keyed by model name. Surfaced onto
@@ -49,7 +48,7 @@ type AnthropicSDKConfig = ClientOptions & {
  * anthropic.model({ name: "claude-sonnet-4-6" });               // vision auto-true
  * anthropic.model({ name: "custom-proxy-model", vision: false }); // dev override
  */
-type AnthropicModelConfig = ModelConfig & {
+export type AnthropicModelConfig = ModelConfig & {
   /**
    * Override the auto-inferred vision capability. When omitted, the
    * adapter checks the model name against the known Claude vision
@@ -58,6 +57,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
@@ -124,6 +135,79 @@ 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).
+ */
+export 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).
+ */
+export 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.
+ */
+export 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.
+ */
+export 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
@@ -132,14 +216,14 @@ type AnthropicModelConfig = ModelConfig & {
  * fallback chain.
  *
  * @example
- * // Server-side compaction (beta) on a long-running agent.
+ * // 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: {
- *         betas: ["compact-2026-01-12"],
- *         body: { context_management: { edits: [{ type: "compact_20260112" }] } },
+ *         serverCompaction: { triggerTokens: 200_000 },
+ *         contextManagement: { clearToolUses: { trigger: { inputTokens: 100_000 }, keep: 5 } },
  *       },
  *     },
  *   },
@@ -158,7 +242,7 @@ type AnthropicModelConfig = ModelConfig & {
  *   },
  * });
  */
-type AnthropicCallOptions = {
+export type AnthropicCallOptions = {
   /**
    * Beta flags (`anthropic-beta` header values). When non-empty the
    * request goes through the SDK's `client.beta.messages` endpoint, which
@@ -187,7 +271,32 @@ type AnthropicCallOptions = {
    * 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 { AnthropicCallOptions, AnthropicModelConfig, AnthropicSDKConfig };
 //# sourceMappingURL=config.type.d.mts.map

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

@@ -1 +1 @@
-{"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;EA+HU;;;;;EAzHV,OAAA,GAAU,MAAA,SAAe,YAAA;AAAA;;;AAqJV;;;;;;KA1IL,oBAAA,GAAuB,WAAA;;;;;;;;EAQjC,MAAA;;;;;;;;;EASA,gBAAA;;;;;;;;;;;;;;;;;;;;;EAqBA,aAAA;;;;;;;;EAQA,cAAA;;;;;;;;;;EAUA,SAAA;;;;;;;;;;;;;;;;;;EAkBA,YAAA,GAAe,qBAAqB;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoC1B,oBAAA;;;;;;;EAOV,KAAA;;;;;;;;;;EAUA,IAAA,GAAO,MAAM;;;;;;;;;;;EAWb,eAAA;AAAA"}
+{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-anthropic/src/config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiCY,qBAAqB;EAC/B;;;;;;EAMA,UAAU,eAAe;;;;;;;;;;YAWf,uBAAuB;;;;;;;;EAQjC;;;;;;;;;;;;EAYA;;;;;;;;;EASA;;;;;;;;;;;;;;;;;;;;;EAqBA;;;;;;;;EAQA;;;;;;;;;;EAUA;;;;;;;;;;;;;;;;;;EAkBA,eAAe;;;;;;;;;;;;;EAaf;;;;;;;;YASU;;EAEV;IAAY;;IAA0B;;;EAEtC;;EAEA;;EAEA;;EAEA;;;;;;;;YASU;EAA2B;;;;;;;YAO3B;;EAEV,uBAAuB;;EAEvB,uBAAuB;;;;;;;;;;;YAYb;;EAEV;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoCU;;;;;;;EAOV;;;;;;;;;;EAUA,OAAO;;;;;;;;;;;EAWP;;;;;;;EAOA,oBAAoB;;;;;;;EAOpB,6BAA6B;;;;;;;;;;;;EAY7B"}

package/esm/index.d.mts

@@ -1,5 +1,11 @@
-import { AnthropicThinkingMode } from "./thinking-mode.mjs";
-import { AnthropicCallOptions, 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 AnthropicCallOptions, AnthropicModel, type AnthropicModelConfig, AnthropicSDK, type AnthropicSDKConfig, type AnthropicThinkingMode };
+import { ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, ANTHROPIC_SERVER_TOOL_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";
+import "./utils/index.mjs";
+export { ANTHROPIC_BLOCK_FORMAT, ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, ANTHROPIC_SERVER_TOOL_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,4 +1,10 @@
+import { ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, ANTHROPIC_SERVER_TOOL_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 { AnthropicModel, AnthropicSDK };
+export { ANTHROPIC_BLOCK_FORMAT, ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, ANTHROPIC_SERVER_TOOL_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,63 @@
+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).
+ */
+export declare const ANTHROPIC_CACHE_WRITE_MULTIPLIER = 1.25;
+export 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}.
+ */
+export 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)
+ */
+export 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 }
+ */
+export declare function withAnthropicCacheWriteRates(pricing: ModelPricing | undefined): ModelPricing | undefined;
+/** USD per request, verified 2026-10-18. Tokens are additional.
+ * https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool#usage-and-pricing
+ * https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool#usage-and-pricing */
+export declare const ANTHROPIC_SERVER_TOOL_PRICING: {
+  webSearch: number;
+  webFetch: number;
+};
+//#endregion
+//# 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":";;;;;;;;;;qBAUa;qBACA;;;;;;;;;;;;;;;;;;;qBAoBA,yBAAyB,SAAS,eAAe;;;;;;;;;;;wBA+C9C,oBAAoB,oBAAoB;;;;;;;;;;;;wBAqBxC,6BACd,SAAS,2BACR;;;;qBAmBU;EAAkC;EAAiB"}

package/esm/known-pricing.mjs

@@ -0,0 +1,172 @@
+//#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
+	};
+}
+/** USD per request, verified 2026-10-18. Tokens are additional.
+* https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool#usage-and-pricing
+* https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool#usage-and-pricing */
+const ANTHROPIC_SERVER_TOOL_PRICING = {
+	webSearch: .01,
+	webFetch: 0
+};
+
+//#endregion
+export { ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_MULTIPLIER, ANTHROPIC_MODEL_PRICING, ANTHROPIC_SERVER_TOOL_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\n/** USD per request, verified 2026-10-18. Tokens are additional.\n * https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool#usage-and-pricing\n * https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool#usage-and-pricing */\nexport const ANTHROPIC_SERVER_TOOL_PRICING = { webSearch: 0.01, webFetch: 0 };\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;;;;AAKA,MAAa,gCAAgC;CAAE,WAAW;CAAM,UAAU;AAAE"}