@warlock.js/ai-anthropic 5.30.0 → 5.31.0

package/cjs/index.cjs

@@ -31,58 +31,166 @@ _anthropic_ai_sdk = __toESM(_anthropic_ai_sdk, 1);
 let _warlock_js_ai = require("@warlock.js/ai");
 let _warlock_js_logger = require("@warlock.js/logger");
 
-//#region ../../packages/ai-anthropic/src/known-vision-models.ts
+//#region ../../packages/ai-anthropic/src/known-pricing.ts
 /**
-* Model-name prefixes for Claude families that accept image input
-* (vision) on the Messages API.
+* 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.
 *
-* Every Claude 3, Claude 3.5/3.7, Claude 4 and Claude 5 family model is
-* multimodal, so the list covers both the dotted legacy naming
-* (`claude-3-haiku-...`, `claude-3-5-sonnet-...`) and the current
-* `claude-<tier>-4-*` naming (`claude-opus-4-7`, `claude-sonnet-4-6`,
-* `claude-haiku-4-5`). Pre-3 families (`claude-2`, `claude-instant`)
-* are text-only and intentionally absent.
+* 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.
 *
-* The Claude 5 series is multimodal too (claude-api ref, cached
-* 2026-09-25): its vision examples use `claude-opus-5-5`; the models list
-* credits Claude Fable 5.1 with vision and Claude Sonnet 5 with
-* high-resolution vision; Claude Mythos 5.1 has "same capabilities" as
-* Fable 5.1. The tier-5 prefixes cover every 5.x release
-* (`claude-opus-5`, `claude-opus-5-5`, `claude-sonnet-5-5`,
-* `claude-fable-5-1`, …). Opus/Sonnet 4.6–4.8 are already covered by the
-* tier-4 prefixes.
+* 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:
 *
-* Matched as a prefix so dated variants (`claude-opus-4-20250514`) are
-* covered without listing every release tag. Devs can always override
-* per-model via `anthropic.model({ name, vision: true | false })` —
-* explicit config wins over inference in either direction.
+* - 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 VISION_CAPABLE_PREFIXES = [
-	"claude-3",
-	"claude-4",
-	"claude-opus-4",
-	"claude-sonnet-4",
-	"claude-haiku-4",
-	"claude-opus-5",
-	"claude-sonnet-5",
-	"claude-fable-5",
-	"claude-mythos-5"
-];
+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}$/;
 /**
-* Infer whether a given Claude model name supports vision based on the
-* known-prefix list. Unknown models default to `false` so that passing
-* an image attachment to an unsupported model surfaces a clear,
-* agent-side capability error instead of an opaque Anthropic 400.
+* 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
-* inferVisionCapability("claude-sonnet-4-6");      // → true
-* inferVisionCapability("claude-3-5-sonnet-latest"); // → true
-* inferVisionCapability("claude-2.1");             // → false
-* inferVisionCapability("custom-proxy-llm");       // → false
+* anthropicPricingFor("claude-haiku-4-5-20251001"); // { input: 1, output: 5, … }
+* anthropicPricingFor("claude-haiku-5-5"); // undefined (prompt-length tiers)
 */
-function inferVisionCapability(modelName) {
-	const normalized = modelName.toLowerCase();
-	return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+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
@@ -121,6 +229,11 @@ const BUDGET_RELEASE_ROOTS = [
 * Dates (`-20250514`) and tags (`-latest`, `-v1`) are not minor versions.
 */
 const NEXT_MINOR_VERSION = /^-\d{1,2}(?!\d)/;
+/**
+* Whether a lower-cased model id is the release `root` itself, or a dated /
+* tagged / `@` snapshot of it — but not a later minor version of the same
+* line (`claude-opus-4` matches `claude-opus-4-20250514`, not `claude-opus-4-7`).
+*/
 function matchesReleaseRoot(name, root) {
 	if (!name.startsWith(root)) return false;
 	const rest = name.slice(root.length);
@@ -185,9 +298,261 @@ const BETWEEN_TOOLS_RELEASE_ROOTS = ["claude-sonnet-5-5"];
 * acceptsBetweenTools("claude-opus-5-5");   // → false
 */
 function acceptsBetweenTools(modelName) {
+	return matchesAnyRelease(modelName, BETWEEN_TOOLS_RELEASE_ROOTS);
+}
+/**
+* Whether the model id — lower-cased, with any platform prefix
+* (`anthropic.`, `us.anthropic.` on Bedrock) removed — is one of these
+* releases, dated or tagged, but not a later minor release.
+*/
+function matchesAnyRelease(modelName, roots) {
 	const normalized = modelName.toLowerCase();
 	const id = normalized.slice(normalized.lastIndexOf(".") + 1);
-	return BETWEEN_TOOLS_RELEASE_ROOTS.some((root) => matchesReleaseRoot(id, root));
+	return roots.some((root) => matchesReleaseRoot(id, root));
+}
+/**
+* Releases that accept `thinking: { type: "disabled" }` and run reliably
+* with it. Source: claude-api ref, "Thinking & Effort" per-model table
+* (cached 2026-10-06): Claude Sonnet 5 accepts `disabled`; Claude Haiku 5.5
+* accepts it at effort `low`, `medium` and `high` (a 400 at `xhigh` /
+* `max`). No effort is sent alongside it, so Haiku 5.5 runs at its default,
+* `medium`, which is inside the accepted range.
+*/
+const DISABLED_THINKING_RELEASE_ROOTS = ["claude-sonnet-5", "claude-haiku-5-5"];
+/**
+* Releases that accept `disabled` but are kept on adaptive thinking at the
+* lowest effort instead. Claude Opus 5 accepts `disabled` at effort `high`
+* or below, but the claude-api ref ("Two failure modes when thinking is
+* disabled", cached 2026-10-06) documents that with thinking disabled it
+* occasionally writes a tool call into its visible text instead of a
+* `tool_use` block — the call never runs and no error is raised — and can
+* leak `<thinking>` tags into the response. The ref's primary
+* recommendation is to keep thinking on and lower `effort`, so the adapter
+* does exactly that.
+*/
+const LOWEST_EFFORT_RELEASE_ROOTS = ["claude-opus-5"];
+/**
+* The wire form for `reasoning: { effort: "none" }` on this model:
+*
+* | Model                                  | Form              |
+* |----------------------------------------|-------------------|
+* | Claude Sonnet 5.5                      | `between_tools`   |
+* | Claude Sonnet 5, Claude Haiku 5.5      | `disabled`        |
+* | Claude Opus 5                          | `lowest-effort`   |
+* | Opus 5.5, Fable 5/5.1, everything else | `omit`            |
+*
+* Opus 5.5 and Fable 5/5.1 have no thinking-off form (`disabled` and
+* `budget_tokens` are a 400 at every effort), so nothing is sent and the
+* model runs at its default effort; older models run without thinking when
+* the field is absent.
+*
+* @example
+* noReasoningForm("claude-sonnet-5");   // → "disabled"
+* noReasoningForm("claude-opus-5");     // → "lowest-effort"
+* noReasoningForm("claude-opus-5-5");   // → "omit"
+*/
+function noReasoningForm(modelName) {
+	if (acceptsBetweenTools(modelName)) return "between_tools";
+	if (matchesAnyRelease(modelName, DISABLED_THINKING_RELEASE_ROOTS)) return "disabled";
+	if (matchesAnyRelease(modelName, LOWEST_EFFORT_RELEASE_ROOTS)) return "lowest-effort";
+	return "omit";
+}
+const PREFIX_CHECK_RELEASE_ROOTS = [
+	"claude-fable-5-1",
+	"claude-opus-5-5",
+	"claude-sonnet-5-5",
+	"claude-haiku-5-5"
+];
+/** Releases documented not to run the conversation check. */
+const NO_PREFIX_CHECK_RELEASE_ROOTS = [
+	"claude-mythos-5-1",
+	"claude-mythos-5",
+	"claude-mythos-preview",
+	"claude-fable-5",
+	"claude-opus-5",
+	"claude-sonnet-5"
+];
+/** Families released before Claude Fable 5.1 in their entirety. */
+const NO_PREFIX_CHECK_FAMILY_PREFIXES = [
+	...BUDGET_FAMILY_PREFIXES,
+	"claude-opus-4",
+	"claude-sonnet-4"
+];
+/**
+* Whether this model binds a replayed thinking block to the exact
+* conversation before it (preserved thinking). Unknown and future ids are
+* assumed to run the check — the safe direction: reasoning a kept turn
+* can't use is left out instead of risking a 400. Matches the id with or
+* without a platform prefix and with dated or tagged suffixes.
+*
+* @example
+* inferPreservedThinking("claude-opus-5-5"); // → true
+* inferPreservedThinking("claude-opus-5");   // → false
+* inferPreservedThinking("claude-opus-4-8"); // → false
+*/
+function inferPreservedThinking(modelName) {
+	const normalized = modelName.toLowerCase();
+	const id = normalized.slice(normalized.lastIndexOf(".") + 1);
+	if (PREFIX_CHECK_RELEASE_ROOTS.some((root) => matchesReleaseRoot(id, root))) return true;
+	if (NO_PREFIX_CHECK_RELEASE_ROOTS.some((root) => matchesReleaseRoot(id, root)) || NO_PREFIX_CHECK_FAMILY_PREFIXES.some((prefix) => id.startsWith(prefix))) return false;
+	return true;
+}
+
+//#endregion
+//#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
+//#region ../../packages/ai-anthropic/src/known-vision-models.ts
+/**
+* Model-name prefixes for Claude families that accept image input
+* (vision) on the Messages API.
+*
+* Every Claude 3, Claude 3.5/3.7, Claude 4 and Claude 5 family model is
+* multimodal, so the list covers both the dotted legacy naming
+* (`claude-3-haiku-...`, `claude-3-5-sonnet-...`) and the current
+* `claude-<tier>-4-*` naming (`claude-opus-4-7`, `claude-sonnet-4-6`,
+* `claude-haiku-4-5`). Pre-3 families (`claude-2`, `claude-instant`)
+* are text-only and intentionally absent.
+*
+* The Claude 5 series is multimodal too (claude-api ref, cached
+* 2026-09-25): its vision examples use `claude-opus-5-5`; the models list
+* credits Claude Fable 5.1 with vision and Claude Sonnet 5 with
+* high-resolution vision; Claude Mythos 5.1 has "same capabilities" as
+* Fable 5.1. The tier-5 prefixes cover every 5.x release
+* (`claude-opus-5`, `claude-opus-5-5`, `claude-sonnet-5-5`,
+* `claude-fable-5-1`, …). Opus/Sonnet 4.6–4.8 are already covered by the
+* tier-4 prefixes.
+*
+* Matched as a prefix so dated variants (`claude-opus-4-20250514`) are
+* covered without listing every release tag. Devs can always override
+* per-model via `anthropic.model({ name, vision: true | false })` —
+* explicit config wins over inference in either direction.
+*/
+const VISION_CAPABLE_PREFIXES = [
+	"claude-3",
+	"claude-4",
+	"claude-opus-4",
+	"claude-sonnet-4",
+	"claude-haiku-4",
+	"claude-opus-5",
+	"claude-sonnet-5",
+	"claude-fable-5",
+	"claude-mythos-5"
+];
+/**
+* Infer whether a given Claude model name supports vision based on the
+* known-prefix list. Unknown models default to `false` so that passing
+* an image attachment to an unsupported model surfaces a clear,
+* agent-side capability error instead of an opaque Anthropic 400.
+*
+* @example
+* inferVisionCapability("claude-sonnet-4-6");      // → true
+* inferVisionCapability("claude-3-5-sonnet-latest"); // → true
+* inferVisionCapability("claude-2.1");             // → false
+* inferVisionCapability("custom-proxy-llm");       // → false
+*/
+function inferVisionCapability(modelName) {
+	const normalized = modelName.toLowerCase();
+	return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+//#endregion
+//#region ../../packages/ai-anthropic/src/utils/cache-usage.ts
+/**
+* Copy Anthropic's cache counters onto a neutral `Usage`.
+*
+* - `cache_read_input_tokens` → `cachedTokens`
+* - `cache_creation_input_tokens` → `cacheWriteTokens`
+* - `cache_creation.ephemeral_1h_input_tokens` → `cacheWrite1hTokens`
+*   (the 1-hour writes, billed at 2x input instead of 1.25x)
+*
+* When Anthropic omits the per-lifetime breakdown, `requestTtl` decides:
+* a request whose every cache marker asked for `"1h"` wrote only 1-hour
+* entries. Counters are set only when positive, so an absent channel
+* stays undefined. Anthropic's `input_tokens` excludes all of these, so
+* the caller marks the usage `inputIncludesCache: false`.
+*/
+function applyAnthropicCacheUsage(usage, raw, requestTtl) {
+	const cacheRead = raw.cache_read_input_tokens;
+	if (typeof cacheRead === "number" && cacheRead > 0) usage.cachedTokens = cacheRead;
+	const cacheWrite = raw.cache_creation_input_tokens;
+	if (typeof cacheWrite !== "number" || cacheWrite <= 0) return;
+	usage.cacheWriteTokens = cacheWrite;
+	const reported1h = raw.cache_creation?.ephemeral_1h_input_tokens;
+	const writes1h = typeof reported1h === "number" ? reported1h : requestTtl === "1h" ? cacheWrite : 0;
+	if (writes1h > 0) usage.cacheWrite1hTokens = Math.min(writes1h, cacheWrite);
+}
+/**
+* Scan a request body (top level, system, tools, messages) for
+* `cache_control` markers and report the lifetime they request. Used only
+* as a fallback when the response lacks Anthropic's per-lifetime
+* cache-write breakdown.
+*
+* @example
+* requestCacheTtl({ cache_control: { type: "ephemeral", ttl: "1h" } }); // "1h"
+*/
+function requestCacheTtl(body) {
+	let found;
+	const visit = (value, depth) => {
+		if (depth > 8 || typeof value !== "object" || value === null) return;
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item, depth + 1);
+			return;
+		}
+		const record = value;
+		const marker = record.cache_control;
+		if (typeof marker === "object" && marker !== null) {
+			const ttl = marker.ttl === "1h" ? "1h" : "5m";
+			found = found === void 0 || found === ttl ? ttl : "mixed";
+		}
+		for (const key of [
+			"system",
+			"tools",
+			"messages",
+			"content"
+		]) if (key in record) visit(record[key], depth + 1);
+	};
+	visit(body, 0);
+	return found;
 }
 
 //#endregion
@@ -333,6 +698,9 @@ function isReplayable(block) {
 * provider, or blocks whose `tool_use` ids no longer match `toolCalls`,
 * are ignored and the turn is rebuilt from `content` + `toolCalls`.
 *
+* With `dropRetainedThinking`, a turn marked `compaction: "retained"` is
+* replayed without its thinking blocks (see {@link ToAnthropicMessagesOptions}).
+*
 * Other consecutive same-role turns are left as-is — the Messages API
 * merges them server-side.
 *
@@ -344,7 +712,7 @@ function isReplayable(block) {
 * // system === "Be concise."
 * // messages === [{ role: "user", content: "Hi" }]
 */
-function toAnthropicMessages(messages) {
+function toAnthropicMessages(messages, options = {}) {
 	const systemParts = [];
 	const mapped = [];
 	for (const message of messages) {
@@ -366,18 +734,20 @@ function toAnthropicMessages(messages) {
 			});
 			continue;
 		}
+		const dropThinking = options.dropRetainedThinking === true && message.compaction === "retained";
 		if (message.role === "assistant") {
 			const replayed = fromProviderBlocks(message.blocks, message.toolCalls);
-			if (replayed) {
+			const content = dropThinking ? replayed?.filter((block) => !isThinkingBlock(block)) : replayed;
+			if (content && content.length > 0) {
 				mapped.push({
 					role: "assistant",
-					content: replayed
+					content
 				});
 				continue;
 			}
 		}
 		if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
-			const blocks = extractThinkingBlocks(message.toolCalls);
+			const blocks = dropThinking ? [] : extractThinkingBlocks(message.toolCalls);
 			const text = stringifyContent(message.content);
 			if (text) blocks.push({
 				type: "text",
@@ -412,6 +782,9 @@ function toAnthropicMessages(messages) {
 		messages: mapped
 	};
 }
+function isThinkingBlock(block) {
+	return block.type === "thinking" || block.type === "redacted_thinking";
+}
 /**
 * Recover signed extended-thinking blocks stored by this adapter on a tool
 * request. Anthropic requires these blocks to be replayed before the
@@ -583,6 +956,11 @@ function wrapAnthropicError(thrown) {
 		context,
 		retryAfter: parseRetryAfter(shape.headers)
 	});
+	if (shape.type === "overloaded_error" || shape.status === 529) return new _warlock_js_ai.ProviderOverloadedError(message, {
+		cause: thrown,
+		context,
+		retryAfter: parseRetryAfter(shape.headers)
+	});
 	if (shape.type === "invalid_request_error" || isClientStatus(shape.status)) {
 		if (/prompt is too long/i.test(message)) return new _warlock_js_ai.ContextLengthExceededError(message, {
 			cause: thrown,
@@ -688,14 +1066,30 @@ function parseRetryAfter(headers) {
 //#endregion
 //#region ../../packages/ai-anthropic/src/model.ts
 const LOG_MODULE = "ai.anthropic";
+/** `provider` value of `ai.providerTool()` entries this adapter sends verbatim. */
+const ANTHROPIC_WIRE_FORMAT = "anthropic";
 /**
 * Anthropic requires `max_tokens` on every request (unlike OpenAI,
-* where it is optional). When neither the per-call option nor the
-* model config supplies one, fall back to a generous default so a
-* caller who never thought about token caps still gets a complete
-* answer instead of a 400.
+* where it is optional). When neither the per-call option nor the model
+* config supplies one, the adapter picks a default large enough for agent
+* work (see `resolveDefaultMaxTokens`):
+*
+* - streaming: the model's documented max output (`known-output-limits.ts`,
+*   or `config.maxOutputTokens`), else this value;
+* - non-streaming: this value, capped by the model's max output. The
+*   installed `@anthropic-ai/sdk` (0.129.0, `calculateNonstreamingTimeout`)
+*   refuses a non-streaming request whose `max_tokens` implies more than
+*   ten minutes (above ~21,333 tokens) unless the client sets a `timeout`,
+*   so the non-streaming default stays below that.
 */
-const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_MAX_TOKENS = 16384;
+/**
+* Answer room kept on top of a thinking budget when the default
+* `max_tokens` is sized: thinking counts toward `max_tokens` (installed
+* SDK `ThinkingConfigParam` docs, `messages.d.ts:1105`), and in budget
+* mode `max_tokens` must exceed `budget_tokens`.
+*/
+const MIN_ANSWER_TOKENS = 4096;
 /**
 * Anthropic rejects an extended-thinking budget below 1024 tokens, so
 * any resolved budget is floored at this minimum before it reaches the
@@ -714,11 +1108,10 @@ const DEFAULT_THINKING_EFFORT = "medium";
 *
 * - Budget-mode models: sent as `thinking.budget_tokens` when the caller
 *   doesn't pass an explicit `reasoning.maxTokens`.
-* - Both modes: reserved on top of `DEFAULT_MAX_TOKENS` when the caller
-*   sets no `maxTokens`, because thinking counts toward `max_tokens`
-*   (installed SDK `ThinkingConfigParam` docs, `messages.d.ts:1105`).
-*   Adaptive models therefore get the same `max_tokens` the budget path
-*   has always produced.
+* - Both modes: when the caller sets no `maxTokens`, the default
+*   `max_tokens` keeps at least this budget plus `MIN_ANSWER_TOKENS`,
+*   because thinking counts toward `max_tokens` (installed SDK
+*   `ThinkingConfigParam` docs, `messages.d.ts:1105`).
 */
 const EFFORT_THINKING_BUDGET = {
 	minimal: 1024,
@@ -794,8 +1187,10 @@ var AnthropicModel = class {
 		this.config = config;
 		this.name = config.name;
 		this.provider = provider;
-		this.pricing = config.pricing;
+		this.pricing = withAnthropicCacheWriteRates(config.pricing ?? anthropicPricingFor(config.name));
 		this.thinkingMode = config.thinkingMode ?? inferThinkingMode(config.name);
+		this.maxOutputTokens = config.maxOutputTokens ?? inferMaxOutputTokens(config.name);
+		this.preservedThinking = config.preservedThinking ?? (this.thinkingMode === "adaptive" && inferPreservedThinking(config.name));
 		this.capabilities = {
 			structuredOutput: config.structuredOutput ?? true,
 			vision: config.vision ?? inferVisionCapability(config.name),
@@ -811,23 +1206,50 @@ var AnthropicModel = class {
 	* instance's `ModelConfig` defaults for this call only.
 	*/
 	async complete(messages, options) {
-		this.logger.debug(LOG_MODULE, "request", "Starting call to messages.create", {
-			model: this.name,
-			messageCount: messages.length,
-			streaming: false,
-			toolCount: options?.tools?.length ?? 0
+		return this.send(this.buildLoggedRequest(messages, {
+			...options,
+			stream: false
+		}), { signal: options?.signal });
+	}
+	buildRequest(messages, options) {
+		const built = this.buildBody(messages, options);
+		const betas = [...new Set([...resolveAnthropicOptions(options).betas ?? [], ...built.betas])];
+		const body = structuredClone({
+			...built.body,
+			stream: options?.stream ?? false
 		});
+		return {
+			endpoint: betas.length > 0 ? "beta.messages" : "messages",
+			body,
+			betas
+		};
+	}
+	buildLoggedRequest(messages, options) {
+		try {
+			return this.buildRequest(messages, options);
+		} catch (thrown) {
+			throw this.logAndWrap(thrown instanceof _warlock_js_ai.AIError ? thrown : new _warlock_js_ai.InvalidRequestError(`Could not build the Anthropic request: ${thrown instanceof Error ? thrown.message : String(thrown)}`, { cause: thrown }));
+		}
+	}
+	send(request, options) {
+		const message = request.body.stream ? "Starting streaming call to messages.create" : "Starting call to messages.create";
+		this.logger.debug(LOG_MODULE, "request", message, {
+			model: request.body.model,
+			messageCount: Array.isArray(request.body.messages) ? request.body.messages.length : 0,
+			streaming: request.body.stream,
+			toolCount: Array.isArray(request.body.tools) ? request.body.tools.length : 0
+		});
+		return request.body.stream ? this.streamRequest(request, options) : this.completeRequest(request, options);
+	}
+	async completeRequest(request, options) {
 		let response;
 		try {
-			response = await this.send({
-				...this.buildBody(messages, options),
-				stream: false
-			}, options, "create");
+			response = await this.dispatch(request, options, "create");
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
 		}
 		const finishReason = mapStopReason(response.stop_reason);
-		const usage = this.extractUsage(response.usage);
+		const usage = this.extractUsage(response.usage, requestCacheTtl(request.body));
 		const toolCalls = this.extractToolCalls(response.content);
 		const blocks = toProviderBlocks(response.content);
 		this.logger.debug(LOG_MODULE, "response", "call to messages.create succeeded", {
@@ -854,11 +1276,18 @@ var AnthropicModel = class {
 	* const tokens = await model.countTokens(messages, { tools });
 	*/
 	async countTokens(messages, options) {
-		const body = this.buildBody(messages, options);
+		const request = this.buildLoggedRequest(messages, {
+			...options,
+			stream: options?.stream === true
+		});
+		const body = request.body;
 		const countBody = {};
 		for (const key of COUNT_TOKENS_FIELDS) if (body[key] !== void 0) countBody[key] = body[key];
 		try {
-			return (await this.send(countBody, options, "countTokens")).input_tokens;
+			return (await this.dispatch({
+				...request,
+				body: countBody
+			}, options, "countTokens")).input_tokens;
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
 		}
@@ -869,29 +1298,38 @@ var AnthropicModel = class {
 	* 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).
 	*/
 	async *stream(messages, options) {
-		this.logger.debug(LOG_MODULE, "request", "Starting streaming call to messages.create", {
-			model: this.name,
-			messageCount: messages.length,
-			streaming: true,
-			toolCount: options?.tools?.length ?? 0
+		yield* this.send(this.buildLoggedRequest(messages, {
+			...options,
+			stream: true
+		}), {
+			signal: options?.signal,
+			streamChunks: options?.streamChunks
 		});
+	}
+	async *streamRequest(request, options) {
 		let stream;
 		try {
-			stream = await this.send({
-				...this.buildBody(messages, options),
-				stream: true
-			}, options, "create");
+			stream = await this.dispatch(request, options, "create");
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
 		}
 		let rawStopReason = null;
+		let compaction = compactionIterationUsage(void 0);
 		const usage = {
 			input: 0,
 			output: 0,
-			total: 0
+			total: 0,
+			inputIncludesCache: false
 		};
+		const cacheTtl = requestCacheTtl(request.body);
+		const want = (0, _warlock_js_ai.resolveStreamChunks)(options);
 		const toolBlocks = /* @__PURE__ */ new Map();
 		const thinkingBlocks = /* @__PURE__ */ new Map();
 		const streamedBlocks = /* @__PURE__ */ new Map();
@@ -902,10 +1340,14 @@ var AnthropicModel = class {
 					usage.input = event.message.usage.input_tokens ?? 0;
 					const thinkingTokens = event.message.usage.output_tokens_details?.thinking_tokens;
 					if (thinkingTokens !== null && thinkingTokens !== void 0) usage.reasoningTokens = thinkingTokens;
-					const cacheRead = event.message.usage.cache_read_input_tokens;
-					if (cacheRead !== null && cacheRead !== void 0 && cacheRead > 0) usage.cachedTokens = cacheRead;
-					const cacheWrite = event.message.usage.cache_creation_input_tokens;
-					if (cacheWrite !== null && cacheWrite !== void 0 && cacheWrite > 0) usage.cacheWriteTokens = cacheWrite;
+					applyAnthropicCacheUsage(usage, event.message.usage, cacheTtl);
+					if (want.usage) yield {
+						type: "usage",
+						usage: {
+							...usage,
+							total: usage.input + usage.output
+						}
+					};
 					continue;
 				}
 				if (event.type === "content_block_start") {
@@ -926,10 +1368,22 @@ var AnthropicModel = class {
 					};
 					else if (event.delta.type === "input_json_delta") {
 						const accumulator = toolBlocks.get(event.index);
-						if (accumulator) accumulator.json += event.delta.partial_json;
+						if (accumulator) {
+							accumulator.json += event.delta.partial_json;
+							if (want.toolArgs && event.delta.partial_json !== "") yield {
+								type: "tool-args",
+								callId: accumulator.id,
+								name: accumulator.name,
+								delta: event.delta.partial_json
+							};
+						}
 					} else if (event.delta.type === "thinking_delta") {
 						const thinking = thinkingBlocks.get(event.index);
 						if (thinking?.type === "thinking") thinking.thinking += event.delta.thinking;
+						if (want.reasoning && event.delta.thinking !== "") yield {
+							type: "reasoning",
+							delta: event.delta.thinking
+						};
 					} else if (event.delta.type === "signature_delta") {
 						const thinking = thinkingBlocks.get(event.index);
 						if (thinking?.type === "thinking") thinking.signature += event.delta.signature;
@@ -952,19 +1406,33 @@ var AnthropicModel = class {
 				}
 				if (event.type === "message_delta") {
 					rawStopReason = event.delta.stop_reason ?? rawStopReason;
+					if (Array.isArray(event.usage.iterations)) compaction = compactionIterationUsage(event.usage);
 					usage.output = event.usage.output_tokens ?? usage.output;
 					const thinkingTokens = event.usage.output_tokens_details?.thinking_tokens;
 					if (thinkingTokens !== null && thinkingTokens !== void 0) usage.reasoningTokens = thinkingTokens;
-					const cacheRead = event.usage.cache_read_input_tokens;
-					if (cacheRead !== null && cacheRead !== void 0 && cacheRead > 0) usage.cachedTokens = cacheRead;
-					const cacheWrite = event.usage.cache_creation_input_tokens;
-					if (cacheWrite !== null && cacheWrite !== void 0 && cacheWrite > 0) usage.cacheWriteTokens = cacheWrite;
+					applyAnthropicCacheUsage(usage, {
+						cache_read_input_tokens: event.usage.cache_read_input_tokens,
+						cache_creation_input_tokens: event.usage.cache_creation_input_tokens,
+						cache_creation: usage.cacheWrite1hTokens !== void 0 ? { ephemeral_1h_input_tokens: usage.cacheWrite1hTokens } : void 0
+					}, cacheTtl);
+					if (want.usage) yield {
+						type: "usage",
+						usage: {
+							...usage,
+							total: usage.input + usage.output
+						}
+					};
 				}
 			}
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
 		}
+		usage.input += compaction.input;
+		usage.output += compaction.output;
+		addCacheCounts(usage, compaction);
 		usage.total = usage.input + usage.output;
+		const cost = (0, _warlock_js_ai.computeCost)(usage, this.pricing);
+		if (cost) usage.cost = cost;
 		const finishReason = mapStopReason(rawStopReason);
 		const blocks = toProviderBlocks(this.finishStreamedBlocks(streamedBlocks));
 		this.logger.debug(LOG_MODULE, "response", "Streaming call to messages.create succeeded", {
@@ -1018,38 +1486,74 @@ var AnthropicModel = class {
 	* and the beta-only body fields); otherwise to `client.messages`. The
 	* cancellation signal rides in the request options, as before.
 	*/
-	send(body, options, method) {
-		const betas = resolveAnthropicOptions(options).betas;
+	dispatch(request, options, method) {
 		const requestOptions = options?.signal ? { signal: options.signal } : void 0;
-		const api = betas && betas.length > 0 ? this.client.beta.messages : this.client.messages;
-		return api[method].call(api, betas && betas.length > 0 ? {
-			...body,
-			betas
-		} : body, requestOptions);
+		const api = request.endpoint === "beta.messages" ? this.client.beta.messages : this.client.messages;
+		return api[method].call(api, request.endpoint === "beta.messages" ? {
+			...request.body,
+			betas: request.betas
+		} : request.body, requestOptions);
 	}
 	/**
-	* 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}.
 	*/
 	buildBody(messages, options) {
 		const anthropic = resolveAnthropicOptions(options);
-		const body = { ...this.buildParams(messages, options) };
+		const betas = [];
+		const body = { ...this.buildParams(messages, options, { dropRetainedThinking: this.preservedThinking && anthropic.thinkingBlockBinding === void 0 }) };
 		if (anthropic.thinkingDisplay && this.thinkingMode === "adaptive" && body.thinking?.type === "adaptive") body.thinking = {
 			...body.thinking,
 			display: anthropic.thinkingDisplay
 		};
+		if (anthropic.thinkingBlockBinding) this.applyBlockBinding(body, anthropic.thinkingBlockBinding, betas);
+		const edits = buildContextEdits(anthropic);
+		if (edits.length > 0) {
+			if (anthropic.body?.context_management !== void 0) throw new _warlock_js_ai.InvalidRequestError("providerOptions.anthropic.contextManagement / serverCompaction cannot be combined with body.context_management: set the edits in one place.", { context: { fields: ["context_management"] } });
+			body.context_management = { edits };
+			if (edits.some((edit) => edit.type !== "compact_20260112")) betas.push(CONTEXT_MANAGEMENT_BETA);
+			if (edits.some((edit) => edit.type === "compact_20260112")) betas.push(COMPACTION_BETA);
+		}
 		const reserved = Object.keys(anthropic.body ?? {}).filter((key) => RESERVED_BODY_FIELDS.has(key));
 		if (reserved.length > 0) throw new _warlock_js_ai.InvalidRequestError(`providerOptions.anthropic.body cannot set ${reserved.map((key) => `"${key}"`).join(", ")}: the adapter builds these from the call's messages, tools and model. Use the agent/model options instead.`, { context: { fields: reserved } });
 		return {
-			...body,
-			...anthropic.body
+			body: {
+				...body,
+				...anthropic.body
+			},
+			betas
 		};
 	}
 	/**
+	* 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.
+	*/
+	applyBlockBinding(body, behavior, betas) {
+		const thinking = body.thinking;
+		const type = thinking?.type ?? (this.preservedThinking ? "adaptive" : void 0);
+		if (type !== "adaptive" && type !== "enabled") {
+			this.logger.debug(LOG_MODULE, "thinking-block-binding.ignored", "thinkingBlockBinding needs adaptive or budget thinking on this request; not sent", {
+				model: this.name,
+				thinking: thinking?.type ?? "none"
+			});
+			return;
+		}
+		body.thinking = {
+			...thinking ?? { type },
+			block_binding: { prefix_mismatch_behavior: behavior }
+		};
+		betas.push(THINKING_BINDING_BETA);
+	}
+	/**
 	* Assemble the Anthropic request body shared by `complete()` and
 	* `stream()` (each adds its own `stream` literal so the SDK's create
 	* overload resolves to the right return type). Hoists the system
@@ -1061,13 +1565,13 @@ var AnthropicModel = class {
 	* rejects the two together, and always for adaptive-mode models, which
 	* reject any explicit temperature (see `acceptsTemperature`).
 	*/
-	buildParams(messages, options) {
-		const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
+	buildParams(messages, options, conversion) {
+		const { system, messages: anthropicMessages } = toAnthropicMessages(messages, conversion);
 		const thinking = this.buildThinking(options?.reasoning);
 		const temperature = options?.temperature ?? this.config.temperature;
 		const configuredMaxTokens = options?.maxTokens ?? this.config.maxTokens;
 		const thinkingBudget = thinking.thinking?.type === "enabled" ? thinking.thinking.budget_tokens : void 0;
-		const maxTokens = configuredMaxTokens ?? (thinking.reservedTokens !== void 0 ? thinking.reservedTokens + DEFAULT_MAX_TOKENS : DEFAULT_MAX_TOKENS);
+		const maxTokens = configuredMaxTokens ?? this.resolveDefaultMaxTokens(options?.stream === true, thinking.reservedTokens);
 		const sendTemperature = temperature !== void 0 && !thinking.thinking && acceptsTemperature(this.thinkingMode);
 		if (thinkingBudget !== void 0 && configuredMaxTokens !== void 0 && configuredMaxTokens <= thinkingBudget) throw new Error(`Anthropic maxTokens (${configuredMaxTokens}) must be greater than thinking budget_tokens (${thinkingBudget})`);
 		return {
@@ -1077,12 +1581,31 @@ var AnthropicModel = class {
 			...this.buildAutomaticCacheControl(options?.cacheControl),
 			...this.buildSystem(system, options?.cacheControl),
 			...sendTemperature ? { temperature } : {},
-			...this.buildTools(options?.tools, options?.cacheControl),
+			...this.buildTools(options, options?.cacheControl),
 			...this.buildOutputConfig(options?.responseSchema, thinking.effort),
 			...thinking.thinking ? { thinking: thinking.thinking } : {}
 		};
 	}
 	/**
+	* 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.
+	*/
+	resolveDefaultMaxTokens(stream, reservedTokens) {
+		const limit = this.maxOutputTokens;
+		const base = stream ? limit ?? DEFAULT_MAX_TOKENS : limit === void 0 ? DEFAULT_MAX_TOKENS : Math.min(limit, DEFAULT_MAX_TOKENS);
+		const withThinking = reservedTokens === void 0 ? base : Math.max(base, reservedTokens + MIN_ANSWER_TOKENS);
+		return limit === void 0 ? withThinking : Math.min(withThinking, limit);
+	}
+	/**
 	* Spread-friendly `system` fragment. Returns an empty object when no
 	* system prompt was hoisted out of the messages.
 	*
@@ -1145,12 +1668,18 @@ var AnthropicModel = class {
 	*   `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
@@ -1159,7 +1688,7 @@ var AnthropicModel = class {
 	*/
 	buildThinking(reasoning) {
 		if (!this.capabilities.reasoning || !reasoning) return {};
-		if (reasoning.effort === "none") return acceptsBetweenTools(this.name) ? { thinking: { type: "between_tools" } } : {};
+		if (reasoning.effort === "none") return this.buildNoReasoning();
 		if (reasoning.maxTokens === void 0 && reasoning.effort === void 0) return {};
 		const effort = reasoning.effort ?? DEFAULT_THINKING_EFFORT;
 		const budget = Math.max(MIN_THINKING_BUDGET, reasoning.maxTokens ?? EFFORT_THINKING_BUDGET[effort]);
@@ -1177,6 +1706,22 @@ var AnthropicModel = class {
 		};
 	}
 	/**
+	* The thinking settings for `reasoning: { effort: "none" }`, per
+	* `noReasoningForm(this.name)` (documented on `buildThinking`).
+	*/
+	buildNoReasoning() {
+		switch (noReasoningForm(this.name)) {
+			case "between_tools": return { thinking: { type: "between_tools" } };
+			case "disabled": return { thinking: { type: "disabled" } };
+			case "lowest-effort": return {
+				thinking: { type: "adaptive" },
+				effort: EFFORT_TO_OUTPUT_EFFORT.low,
+				reservedTokens: EFFORT_THINKING_BUDGET.low
+			};
+			case "omit": return {};
+		}
+	}
+	/**
 	* Spread-friendly tools fragment. Returns an empty object when no
 	* tools were supplied so the caller can unconditionally spread it.
 	*
@@ -1189,9 +1734,16 @@ var AnthropicModel = class {
 	* breakpoint there would pay the ~1.25x write surcharge every turn
 	* with no reads.
 	*/
-	buildTools(tools, cacheControl) {
+	buildTools(options, cacheControl) {
+		const { tools, definitions } = (0, _warlock_js_ai.selectProviderTools)(options, {
+			accepts: [ANTHROPIC_WIRE_FORMAT, this.provider],
+			module: LOG_MODULE,
+			model: this.name,
+			logger: this.logger
+		});
 		const mapped = toAnthropicTools(tools);
-		if (!mapped) return {};
+		const providerDefined = definitions;
+		if (!mapped) return providerDefined.length > 0 ? { tools: providerDefined } : {};
 		if (this.config.promptCaching && mapped.length > 0) {
 			const last = mapped.length - 1;
 			const lastTool = mapped[last];
@@ -1200,7 +1752,7 @@ var AnthropicModel = class {
 				cache_control: this.cacheControl(cacheControl?.ttl)
 			};
 		}
-		return { tools: mapped };
+		return { tools: [...providerDefined, ...mapped] };
 	}
 	/**
 	* Spread-friendly `output_config` fragment carrying both the native
@@ -1274,27 +1826,34 @@ var AnthropicModel = class {
 	/**
 	* 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.
 	*/
-	extractUsage(raw) {
-		const input = raw.input_tokens ?? 0;
-		const output = raw.output_tokens ?? 0;
-		const cacheRead = raw.cache_read_input_tokens;
-		const cacheWrite = raw.cache_creation_input_tokens;
+	extractUsage(raw, cacheTtl) {
+		const compaction = compactionIterationUsage(raw);
+		const input = (raw.input_tokens ?? 0) + compaction.input;
+		const output = (raw.output_tokens ?? 0) + compaction.output;
 		const thinkingTokens = raw.output_tokens_details?.thinking_tokens;
-		return {
+		const usage = {
 			input,
 			output,
 			total: input + output,
-			...cacheRead !== null && cacheRead !== void 0 && cacheRead > 0 ? { cachedTokens: cacheRead } : {},
-			...cacheWrite !== null && cacheWrite !== void 0 && cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {},
+			inputIncludesCache: false,
 			...thinkingTokens !== null && thinkingTokens !== void 0 ? { reasoningTokens: thinkingTokens } : {}
 		};
+		applyAnthropicCacheUsage(usage, raw, cacheTtl);
+		addCacheCounts(usage, compaction);
+		const cost = (0, _warlock_js_ai.computeCost)(usage, this.pricing);
+		if (cost) usage.cost = cost;
+		return usage;
 	}
 	/**
 	* Wrap a thrown provider error into the typed `AIError` hierarchy and
@@ -1338,6 +1897,119 @@ const COUNT_TOKENS_FIELDS = [
 	"context_management",
 	"mcp_servers"
 ];
+/** Beta flag for typed context editing (Anthropic docs, "Context editing", read 2026-10-17). */
+const CONTEXT_MANAGEMENT_BETA = "context-management-2025-06-27";
+/** Beta flag for threshold compaction (Anthropic docs, "Compaction at a token threshold"). */
+const COMPACTION_BETA = "compact-2026-01-12";
+/** Beta flag for `thinking.block_binding` (Anthropic docs, "Preserved thinking"). */
+const THINKING_BINDING_BETA = "thinking-binding-controls-2026-08-01";
+/** The API rejects a compaction trigger below 50,000 input tokens. */
+const MIN_COMPACTION_TRIGGER = 5e4;
+/**
+* Translate the typed `contextManagement` / `serverCompaction` options into
+* `context_management.edits`. `clear_thinking_20251015` must come first
+* when strategies are combined (Anthropic docs, "Context editing").
+*/
+function buildContextEdits(anthropic) {
+	const edits = [];
+	const { clearThinking, clearToolUses } = anthropic.contextManagement ?? {};
+	if (clearThinking) edits.push(clearThinkingEdit(clearThinking === true ? {} : clearThinking));
+	if (clearToolUses) edits.push(clearToolUsesEdit(clearToolUses === true ? {} : clearToolUses));
+	if (anthropic.serverCompaction) {
+		const compaction = anthropic.serverCompaction === true ? {} : anthropic.serverCompaction;
+		if (compaction.triggerTokens !== void 0) assertCount("serverCompaction.triggerTokens", compaction.triggerTokens, MIN_COMPACTION_TRIGGER);
+		edits.push({
+			type: "compact_20260112",
+			...compaction.triggerTokens !== void 0 ? { trigger: {
+				type: "input_tokens",
+				value: compaction.triggerTokens
+			} } : {},
+			...compaction.instructions ? { instructions: compaction.instructions } : {}
+		});
+	}
+	return edits;
+}
+function clearThinkingEdit(options) {
+	if (options.keep === void 0 || options.keep === "all") return {
+		type: "clear_thinking_20251015",
+		...options.keep ? { keep: "all" } : {}
+	};
+	assertCount("contextManagement.clearThinking.keep", options.keep, 1);
+	return {
+		type: "clear_thinking_20251015",
+		keep: {
+			type: "thinking_turns",
+			value: options.keep
+		}
+	};
+}
+function clearToolUsesEdit(options) {
+	const edit = { type: "clear_tool_uses_20250919" };
+	if (options.trigger) {
+		const trigger = "inputTokens" in options.trigger ? {
+			type: "input_tokens",
+			value: options.trigger.inputTokens
+		} : {
+			type: "tool_uses",
+			value: options.trigger.toolUses
+		};
+		assertCount("contextManagement.clearToolUses.trigger", trigger.value, 1);
+		edit.trigger = trigger;
+	}
+	if (options.keep !== void 0) {
+		assertCount("contextManagement.clearToolUses.keep", options.keep, 0);
+		edit.keep = {
+			type: "tool_uses",
+			value: options.keep
+		};
+	}
+	if (options.clearAtLeast !== void 0) {
+		assertCount("contextManagement.clearToolUses.clearAtLeast", options.clearAtLeast, 1);
+		edit.clear_at_least = {
+			type: "input_tokens",
+			value: options.clearAtLeast
+		};
+	}
+	if (options.excludeTools !== void 0) edit.exclude_tools = [...options.excludeTools];
+	if (options.clearToolInputs !== void 0) edit.clear_tool_inputs = Array.isArray(options.clearToolInputs) ? [...options.clearToolInputs] : options.clearToolInputs;
+	return edit;
+}
+function assertCount(field, value, minimum) {
+	if (!Number.isSafeInteger(value) || value < minimum) throw new _warlock_js_ai.InvalidRequestError(`providerOptions.anthropic.${field} must be an integer of at least ${minimum}; got ${value}.`, { context: { field } });
+}
+/**
+* Tokens of the `compaction` entries in a beta response's `usage.iterations`.
+* With server-side compaction the top-level `input_tokens` / `output_tokens`
+* cover only the non-compaction iterations; the billed total is the sum
+* over every iteration (Anthropic docs, "Compaction at a token threshold" →
+* "Understanding usage", read 2026-10-17). Zeros when there are none.
+*/
+function compactionIterationUsage(raw) {
+	const totals = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0
+	};
+	const iterations = raw?.iterations;
+	if (!Array.isArray(iterations)) return totals;
+	for (const entry of iterations) {
+		const iteration = entry;
+		if (iteration?.type !== "compaction") continue;
+		totals.input += numberOrZero(iteration.input_tokens);
+		totals.output += numberOrZero(iteration.output_tokens);
+		totals.cacheRead += numberOrZero(iteration.cache_read_input_tokens);
+		totals.cacheWrite += numberOrZero(iteration.cache_creation_input_tokens);
+	}
+	return totals;
+}
+function numberOrZero(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function addCacheCounts(usage, extra) {
+	if (extra.cacheRead > 0) usage.cachedTokens = (usage.cachedTokens ?? 0) + extra.cacheRead;
+	if (extra.cacheWrite > 0) usage.cacheWriteTokens = (usage.cacheWriteTokens ?? 0) + extra.cacheWrite;
+}
 /** Read `providerOptions.anthropic`, tolerating its absence or a wrong shape. */
 function resolveAnthropicOptions(options) {
 	const raw = options?.providerOptions?.anthropic;
@@ -1422,6 +2094,17 @@ var AnthropicSDK = class {
 };
 
 //#endregion
+exports.ANTHROPIC_BLOCK_FORMAT = ANTHROPIC_BLOCK_FORMAT;
+exports.ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER;
+exports.ANTHROPIC_CACHE_WRITE_MULTIPLIER = ANTHROPIC_CACHE_WRITE_MULTIPLIER;
+exports.ANTHROPIC_MODEL_PRICING = ANTHROPIC_MODEL_PRICING;
 exports.AnthropicModel = AnthropicModel;
 exports.AnthropicSDK = AnthropicSDK;
+exports.anthropicPricingFor = anthropicPricingFor;
+exports.fromProviderBlocks = fromProviderBlocks;
+exports.inferPreservedThinking = inferPreservedThinking;
+exports.toAnthropicMessages = toAnthropicMessages;
+exports.toAnthropicTools = toAnthropicTools;
+exports.toProviderBlocks = toProviderBlocks;
+exports.withAnthropicCacheWriteRates = withAnthropicCacheWriteRates;
 //# sourceMappingURL=index.cjs.map