@warlock.js/ai-anthropic 5.30.0 → 5.31.0

package/esm/config.type.d.mts

@@ -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
@@ -124,6 +136,71 @@ 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
@@ -132,14 +209,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 } },
  *       },
  *     },
  *   },
@@ -187,7 +264,33 @@ 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 };
+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":["../../../../../../../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":";;;;;;;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,5 +1,10 @@
-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, 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,4 +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 { AnthropicModel, 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/model.d.mts

@@ -1,4 +1,5 @@
 import { AnthropicModelConfig } from "./config.type.mjs";
+import { AnthropicNonStreamingRequest, AnthropicRequest, AnthropicRequestOptions, AnthropicStreamingRequest } from "./request.type.mjs";
 import Anthropic from "@anthropic-ai/sdk";
 import { Message, ModelCallOptions, ModelCapabilities, ModelContract, ModelPricing, ModelResponse, ModelStreamChunk } from "@warlock.js/ai";
 
@@ -49,6 +50,9 @@ declare class AnthropicModel implements ModelContract {
   private readonly client;
   private readonly config;
   private readonly thinkingMode;
+  /** Documented max output tokens of this model, when known. Sizes the default `max_tokens`. */
+  private readonly maxOutputTokens?;
+  private readonly preservedThinking;
   private readonly logger;
   constructor(client: Anthropic, config: AnthropicModelConfig, provider?: string);
   /**
@@ -58,6 +62,29 @@ declare class AnthropicModel implements ModelContract {
    * instance's `ModelConfig` defaults for this call only.
    */
   complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse>;
+  /** Build a detached request snapshot without sending it to Anthropic. */
+  buildRequest(messages: Message[], options: ModelCallOptions & {
+    stream: true;
+  }): AnthropicStreamingRequest;
+  buildRequest(messages: Message[], options?: ModelCallOptions & {
+    stream?: false;
+  }): AnthropicNonStreamingRequest;
+  buildRequest(messages: Message[], options?: ModelCallOptions & {
+    stream?: boolean;
+  }): AnthropicRequest;
+  /**
+   * `buildRequest()` for the adapter's own calls: a build failure (a reserved
+   * body key, a `providerOptions.anthropic.body` value `structuredClone`
+   * cannot copy) is logged like a send failure and rejects as an `AIError`.
+   * Errors that are not already an `AIError` become an `InvalidRequestError`,
+   * since nothing reached Anthropic and retrying cannot help.
+   */
+  private buildLoggedRequest;
+  /** Send a built request without rebuilding its body or applying model defaults. */
+  send(request: AnthropicNonStreamingRequest, options?: AnthropicRequestOptions): Promise<ModelResponse>;
+  send(request: AnthropicStreamingRequest, options?: AnthropicRequestOptions): AsyncIterable<ModelStreamChunk>;
+  send(request: AnthropicRequest, options?: AnthropicRequestOptions): Promise<ModelResponse> | AsyncIterable<ModelStreamChunk>;
+  private completeRequest;
   /**
    * Count the input tokens a request would use, through Anthropic's
    * `messages.countTokens` endpoint (a network call; no tokens are
@@ -76,8 +103,14 @@ declare class AnthropicModel implements ModelContract {
    * arguments have fully accumulated, and a terminal `done` carrying the
    * final finish reason + usage totals. Callers consume it with
    * `for await`.
+   *
+   * With `options.streamChunks` it also yields `reasoning` for every
+   * non-empty `thinking_delta`, `tool-args` for every `input_json_delta`
+   * of a client `tool_use` block, and `usage` after `message_start` and
+   * each `message_delta` (whose counts are cumulative).
    */
   stream(messages: Message[], options?: ModelCallOptions): AsyncIterable<ModelStreamChunk>;
+  private streamRequest;
   /**
    * Fold one stream event into the per-index block accumulator. Unknown
    * block and delta types (beta `compaction`, future additions) are kept
@@ -93,16 +126,26 @@ declare class AnthropicModel implements ModelContract {
    * and the beta-only body fields); otherwise to `client.messages`. The
    * cancellation signal rides in the request options, as before.
    */
-  private send;
+  private dispatch;
   /**
-   * The full request body: the adapter-built params, then
-   * `thinking.display` when thinking is sent on an adaptive model, then
-   * `providerOptions.anthropic.body` merged last (caller fields win). The
-   * body may add fields the adapter does not build (`context_management`,
-   * `fallbacks`, …) but may not replace the conversation or the model —
-   * see {@link RESERVED_BODY_FIELDS}.
+   * The full request body and the beta flags it needs: the adapter-built
+   * params, then `thinking.display` when thinking is sent on an adaptive
+   * model, the typed `thinkingBlockBinding`, `contextManagement` and
+   * `serverCompaction` options, then `providerOptions.anthropic.body`
+   * merged last (caller fields win). The body may add fields the adapter
+   * does not build (`fallbacks`, …) but may not replace the conversation or
+   * the model — see {@link RESERVED_BODY_FIELDS}.
    */
   private buildBody;
+  /**
+   * Set `thinking.block_binding.prefix_mismatch_behavior`. It rides on
+   * adaptive or budget (`enabled`) thinking. A model that runs adaptive
+   * thinking when `thinking` is omitted (every preserved-thinking model) gets
+   * an explicit `{ type: "adaptive" }`, which is the same request. Any other
+   * shape (`between_tools`, `disabled`) takes no extra field, so the option
+   * is skipped with a debug log.
+   */
+  private applyBlockBinding;
   /**
    * Assemble the Anthropic request body shared by `complete()` and
    * `stream()` (each adds its own `stream` literal so the SDK's create
@@ -116,6 +159,20 @@ declare class AnthropicModel implements ModelContract {
    * reject any explicit temperature (see `acceptsTemperature`).
    */
   private buildParams;
+  /**
+   * The `max_tokens` sent when neither the call nor the model config sets
+   * `maxTokens`:
+   *
+   * - streaming: the model's documented max output, or
+   *   `DEFAULT_MAX_TOKENS` (16384) for an unknown id;
+   * - non-streaming: `DEFAULT_MAX_TOKENS`, capped by the model's max output
+   *   (the SDK requires streaming for larger non-streaming requests unless
+   *   the client sets a `timeout`; see `DEFAULT_MAX_TOKENS`).
+   *
+   * With thinking on, the value is raised to at least the thinking budget
+   * plus `MIN_ANSWER_TOKENS`, and never exceeds the model's max output.
+   */
+  private resolveDefaultMaxTokens;
   /**
    * Spread-friendly `system` fragment. Returns an empty object when no
    * system prompt was hoisted out of the messages.
@@ -161,12 +218,18 @@ declare class AnthropicModel implements ModelContract {
    *   `messages.d.ts:1084`), so the budget is floored at that minimum.
    *
    * The neutral `effort: "none"` ("run without reasoning") is mapped per
-   * model:
-   * - Claude Sonnet 5.5 (`acceptsBetweenTools`): `thinking: { type:
-   *   "between_tools" }`, its only thinking-off form. It is sent alone —
-   *   no `output_config.effort` (the model default, `high`, is within the
-   *   `high`-or-below range it requires) and no `display`, both of which
-   *   the API rejects alongside it.
+   * model by `noReasoningForm` (see `thinking-mode.ts` for the sources):
+   * - Claude Sonnet 5.5: `thinking: { type: "between_tools" }`, its only
+   *   thinking-off form. It is sent alone — no `output_config.effort` (the
+   *   model default, `high`, is within the `high`-or-below range it
+   *   requires) and no `display`, both of which the API rejects alongside it.
+   * - Claude Sonnet 5 and Claude Haiku 5.5: `thinking: { type: "disabled" }`
+   *   with no effort and no `display`. Haiku 5.5 accepts `disabled` only at
+   *   effort `high` or below; its default (`medium`) applies.
+   * - Claude Opus 5: adaptive thinking at `output_config.effort: "low"`.
+   *   Opus 5 accepts `disabled`, but with it the model can write a tool call
+   *   as plain text (the call never runs) and leak thinking tags; the lowest
+   *   effort is the documented alternative.
    * - Opus 5.5 and Fable 5/5.1: no `thinking` field. These models have no
    *   thinking-off form (`disabled` and `budget_tokens` are a 400 at every
    *   effort), so thinking still runs at the model's default effort. Pass
@@ -174,6 +237,11 @@ declare class AnthropicModel implements ModelContract {
    * - Every other model: no `thinking` field, as before.
    */
   private buildThinking;
+  /**
+   * The thinking settings for `reasoning: { effort: "none" }`, per
+   * `noReasoningForm(this.name)` (documented on `buildThinking`).
+   */
+  private buildNoReasoning;
   /**
    * Spread-friendly tools fragment. Returns an empty object when no
    * tools were supplied so the caller can unconditionally spread it.
@@ -230,12 +298,16 @@ declare class AnthropicModel implements ModelContract {
   /**
    * Normalize Anthropic's `usage` block into the neutral `Usage` shape.
    * Anthropic reports `input_tokens` / `output_tokens` separately with
-   * no pre-summed total, so `total` is computed. Cache-read tokens are
-   * surfaced as `cachedTokens` and cache-write tokens as
-   * `cacheWriteTokens`, each only when non-zero. Anthropic also reports
+   * no pre-summed total, so `total` is computed. `input_tokens` is the
+   * uncached remainder only — cache reads (`cachedTokens`) and writes
+   * (`cacheWriteTokens`, with the 1-hour share in `cacheWrite1hTokens`)
+   * come on top of it — so the usage is marked
+   * `inputIncludesCache: false`. Anthropic also reports
    * `output_tokens_details.thinking_tokens` as the reasoning subset of
    * its inclusive `output_tokens`; it is surfaced as `reasoningTokens`
-   * when present, without changing the billing total.
+   * when present, without changing the billing total. Server-side
+   * compaction iterations are added in (see {@link compactionIterationUsage}).
+   * `cost` is attached when the model is priced.
    */
   private extractUsage;
   /**