@warlock.js/ai-anthropic 5.29.0 → 5.31.0

package/cjs/index.cjs

@@ -31,62 +31,170 @@ _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 ../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
-//#region ../ai-anthropic/src/thinking-mode.ts
+//#region ../../packages/ai-anthropic/src/thinking-mode.ts
 /**
 * Family prefixes that are budget-mode in their entirety — plain
 * `startsWith` match (dated and `-latest` variants included).
@@ -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);
@@ -163,39 +276,402 @@ function inferThinkingMode(modelName) {
 function acceptsTemperature(mode) {
 	return mode === "budget";
 }
+/**
+* Model release roots that accept `thinking: { type: "between_tools" }`,
+* the only way to turn thinking off on them. Source: claude-api ref,
+* "Thinking & Effort" per-model table (cached 2026-10-06): Claude Sonnet
+* 5.5 returns a 400 on `{ type: "disabled" }` and takes `between_tools`
+* instead (no other field alongside it, effort `high` or below). No other
+* current model is documented to accept it. Opus 5.5 and Fable 5/5.1 have
+* no thinking-off form at all: `disabled` and `budget_tokens` are a 400 at
+* every effort, so the lowest they go is `effort: "low"`.
+*/
+const BETWEEN_TOOLS_RELEASE_ROOTS = ["claude-sonnet-5-5"];
+/**
+* Whether `effort: "none"` can turn thinking off on this model with
+* `thinking: { type: "between_tools" }`. Matches the release id with or
+* without a platform prefix (`anthropic.claude-sonnet-5-5` on Bedrock)
+* and with dated or tagged suffixes, but not a later minor release.
+*
+* @example
+* acceptsBetweenTools("claude-sonnet-5-5"); // → true
+* 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 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
-//#region ../ai-anthropic/src/utils/map-stop-reason.ts
+//#region ../../packages/ai-anthropic/src/utils/map-stop-reason.ts
 const stopReasonMap = {
 	end_turn: "stop",
 	stop_sequence: "stop",
+	compaction: "stop",
 	max_tokens: "length",
-	model_context_window_exceeded: "length",
+	model_context_window_exceeded: "context_exceeded",
+	pause_turn: "pause_turn",
+	refusal: "refusal",
 	tool_use: "tool_calls"
 };
 /**
 * Map Anthropic's `stop_reason` to the normalized `FinishReason` union.
 *
-* `end_turn` / `stop_sequence` are both natural stops. `max_tokens` and
-* `model_context_window_exceeded` map to `length`. `tool_use` maps to
-* `tool_calls`. Everything else —
-* `refusal` (policy intervention), `pause_turn` (incomplete
-* long-running turn), `null`, or any value a future API version adds —
-* falls through to `"error"` so the agent treats the trip as a
-* non-clean terminal rather than silently accepting a partial result.
+* `end_turn` / `stop_sequence` (and beta `compaction`) are natural stops,
+* `max_tokens` maps to `length`, `tool_use` to `tool_calls`.
+* `model_context_window_exceeded`, `pause_turn` and `refusal` keep their
+* own reasons (`context_exceeded`, `pause_turn`, `refusal`) because each
+* needs a different reaction: compact the history, send the turn back to
+* resume, or fall back to another model. `null` and any value a future
+* API version adds fall through to `"error"`.
 *
 * @example
-* mapStopReason("end_turn");  // "stop"
-* mapStopReason("tool_use");  // "tool_calls"
-* mapStopReason("refusal");   // "error"
-* mapStopReason(null);        // "error"
+* mapStopReason("end_turn");   // "stop"
+* mapStopReason("tool_use");   // "tool_calls"
+* mapStopReason("refusal");    // "refusal"
+* mapStopReason("pause_turn"); // "pause_turn"
+* mapStopReason(null);         // "error"
 */
 function mapStopReason(raw) {
 	return stopReasonMap[raw ?? ""] ?? "error";
 }
 
 //#endregion
-//#region ../ai-anthropic/src/utils/to-anthropic-messages.ts
+//#region ../../packages/ai-anthropic/src/utils/provider-blocks.ts
+/** The `ProviderContentBlock.provider` value this adapter writes and replays. */
+const ANTHROPIC_BLOCK_FORMAT = "anthropic";
+/** Block types the neutral `content` + `toolCalls` fields already carry losslessly. */
+const NEUTRAL_BLOCK_TYPES = new Set(["text", "tool_use"]);
+/** Block types that carry a model-requested call whose id must match `toolCalls`. */
+const TOOL_USE_BLOCK_TYPES = new Set(["tool_use"]);
+/**
+* Assistant-turn block types that may be sent back verbatim. Server-tool
+* results all end in `_tool_result` (`web_search_tool_result`,
+* `code_execution_tool_result`, …) and are matched by suffix; anything
+* else (an unknown or user-side type such as `image`, `document` or a
+* client `tool_result`) is not replayed.
+*/
+const REPLAYABLE_BLOCK_TYPES = new Set([
+	"text",
+	"thinking",
+	"redacted_thinking",
+	"tool_use",
+	"server_tool_use",
+	"mcp_tool_use",
+	"mcp_tool_result",
+	"container_upload",
+	"compaction"
+]);
+const SERVER_TOOL_RESULT_TYPE = /^[a-z][a-z0-9_]*_tool_result$/;
+/**
+* Wrap an assistant turn's content blocks as `ProviderContentBlock`s, or
+* return `undefined` when the neutral fields already carry the whole turn
+* (only plain text and `tool_use` blocks). Any other block — thinking,
+* redacted thinking, compaction, server-tool use/results, cited text —
+* makes the full ordered list worth keeping so the next request can
+* replay the turn verbatim.
+*
+* @example
+* toProviderBlocks([{ type: "text", text: "hi", citations: null }]); // undefined
+* toProviderBlocks([{ type: "thinking", thinking: "", signature: "s" }, { type: "text", text: "hi" }]);
+* // [{ provider: "anthropic", type: "thinking", data: {...} }, { provider: "anthropic", type: "text", data: {...} }]
+*/
+function toProviderBlocks(content) {
+	if (!content.some(needsVerbatimReplay)) return;
+	return content.map((block) => ({
+		provider: ANTHROPIC_BLOCK_FORMAT,
+		type: block.type,
+		data: { ...block }
+	}));
+}
+/**
+* Rebuild an assistant turn's Anthropic content from stored blocks.
+* Returns `undefined` — so the caller falls back to `content` +
+* `toolCalls` — when there are no blocks, when any block belongs to
+* another provider's format, when a block is not a well-formed
+* assistant-turn block (its `data.type` must equal its `type`, and the
+* type must be one Anthropic returns on an assistant turn), or when the
+* blocks' `tool_use` ids differ from the message's `toolCalls` (the turn
+* was edited after the response, e.g. by a middleware or a recovered
+* stream call, so a verbatim replay would no longer match the tool
+* results that follow). The checks matter when a transcript comes from
+* outside the process (a client, a store): the block data is sent as is.
+*/
+function fromProviderBlocks(blocks, toolCalls) {
+	if (!blocks || blocks.length === 0) return;
+	if (!blocks.every((block) => block.provider === "anthropic" && isReplayable(block))) return;
+	const blockToolIds = blocks.filter((block) => TOOL_USE_BLOCK_TYPES.has(block.type)).map((block) => block.data.id);
+	const requestedIds = (toolCalls ?? []).map((toolCall) => toolCall.id);
+	if (blockToolIds.length !== requestedIds.length || blockToolIds.some((id, index) => id !== requestedIds[index])) return;
+	return blocks.map((block) => ({ ...block.data }));
+}
+function needsVerbatimReplay(block) {
+	if (!NEUTRAL_BLOCK_TYPES.has(block.type)) return true;
+	const citations = block.citations;
+	return Array.isArray(citations) && citations.length > 0;
+}
+function isReplayable(block) {
+	const data = block.data;
+	if (data === null || typeof data !== "object" || Array.isArray(data)) return false;
+	if (data.type !== block.type) return false;
+	return REPLAYABLE_BLOCK_TYPES.has(block.type) || SERVER_TOOL_RESULT_TYPE.test(block.type);
+}
+
+//#endregion
+//#region ../../packages/ai-anthropic/src/utils/to-anthropic-messages.ts
 /**
 * Convert vendor-neutral `Message[]` into Anthropic's request shape.
 *
@@ -206,15 +682,27 @@ function mapStopReason(raw) {
 *    separated) and returned separately as the top-level `system`
 *    parameter.
 * 2. **Tool results are `user` turns.** A neutral `tool` message becomes
-*    a `user` message whose content is a single `tool_result` block
-*    keyed by `tool_use_id`.
+*    a `tool_result` block keyed by `tool_use_id`. Consecutive tool
+*    messages (the results of one parallel tool-use turn) are grouped
+*    into a single `user` message, as Anthropic expects — splitting them
+*    across messages teaches the model to stop calling tools in parallel.
 * 3. **Tool calls are `tool_use` content blocks.** An assistant message
 *    carrying `toolCalls` becomes an `assistant` message whose content
 *    is an optional leading `text` block followed by one `tool_use`
 *    block per call.
 *
-* Consecutive same-role turns are left as-is — the Messages API merges
-* them server-side.
+* An assistant message that carries Anthropic `blocks` (thinking,
+* redacted thinking, compaction, server-tool blocks — see
+* `ProviderContentBlock`) is replayed verbatim from those blocks, which
+* keeps signed thinking and compaction state valid. Blocks from another
+* 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.
 *
 * @example
 * const { system, messages } = toAnthropicMessages([
@@ -224,7 +712,7 @@ function mapStopReason(raw) {
 * // system === "Be concise."
 * // messages === [{ role: "user", content: "Hi" }]
 */
-function toAnthropicMessages(messages) {
+function toAnthropicMessages(messages, options = {}) {
 	const systemParts = [];
 	const mapped = [];
 	for (const message of messages) {
@@ -233,18 +721,33 @@ function toAnthropicMessages(messages) {
 			continue;
 		}
 		if (message.role === "tool") {
-			mapped.push({
+			const toolResult = {
+				type: "tool_result",
+				tool_use_id: message.toolCallId ?? "",
+				content: stringifyContent(message.content)
+			};
+			const previous = mapped[mapped.length - 1];
+			if (previous && previous.role === "user" && isToolResultTurn(previous)) previous.content.push(toolResult);
+			else mapped.push({
 				role: "user",
-				content: [{
-					type: "tool_result",
-					tool_use_id: message.toolCallId ?? "",
-					content: stringifyContent(message.content)
-				}]
+				content: [toolResult]
 			});
 			continue;
 		}
+		const dropThinking = options.dropRetainedThinking === true && message.compaction === "retained";
+		if (message.role === "assistant") {
+			const replayed = fromProviderBlocks(message.blocks, message.toolCalls);
+			const content = dropThinking ? replayed?.filter((block) => !isThinkingBlock(block)) : replayed;
+			if (content && content.length > 0) {
+				mapped.push({
+					role: "assistant",
+					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",
@@ -279,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
@@ -305,6 +811,14 @@ function toAnthropicThinkingBlock(block) {
 	}];
 	return [];
 }
+/**
+* A `user` turn this function built from tool results — its content is a
+* non-empty array made only of `tool_result` blocks. Later tool results
+* of the same tool-use turn are appended to it.
+*/
+function isToolResultTurn(message) {
+	return Array.isArray(message.content) && message.content.length > 0 && message.content.every((block) => block.type === "tool_result");
+}
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
 }
@@ -359,7 +873,7 @@ function toAnthropicContentBlock(part) {
 }
 
 //#endregion
-//#region ../ai-anthropic/src/utils/to-anthropic-tools.ts
+//#region ../../packages/ai-anthropic/src/utils/to-anthropic-tools.ts
 /**
 * Convert vendor-neutral `ToolConfig[]` into Anthropic's `tools` array.
 * Uses the shared `extractJsonSchema` helper; Anthropic requires the
@@ -392,7 +906,7 @@ function toInputSchema(input) {
 }
 
 //#endregion
-//#region ../ai-anthropic/src/utils/wrap-anthropic-error.ts
+//#region ../../packages/ai-anthropic/src/utils/wrap-anthropic-error.ts
 /**
 * Wrap any thrown value caught inside the Anthropic adapter into the
 * appropriate `@warlock.js/ai` `AIError` subclass.
@@ -442,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,
@@ -545,16 +1064,32 @@ function parseRetryAfter(headers) {
 }
 
 //#endregion
-//#region ../ai-anthropic/src/model.ts
+//#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 = 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 DEFAULT_MAX_TOKENS = 4096;
+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
@@ -573,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,
@@ -602,6 +1136,12 @@ const EFFORT_TO_OUTPUT_EFFORT = {
 	xhigh: "xhigh",
 	max: "max"
 };
+/** Content-block types whose input arrives as `input_json_delta` while streaming. */
+const STREAMED_INPUT_BLOCK_TYPES = new Set([
+	"tool_use",
+	"server_tool_use",
+	"mcp_tool_use"
+]);
 /**
 * Anthropic-backed implementation of `ModelContract`.
 *
@@ -647,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),
@@ -664,24 +1206,52 @@ 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.client.messages.create({
-				...this.buildParams(messages, options),
-				stream: false
-			}, options?.signal ? { signal: options.signal } : void 0);
+			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", {
 			finishReason,
 			usage
@@ -690,50 +1260,94 @@ var AnthropicModel = class {
 			content: this.extractText(response.content),
 			finishReason,
 			usage,
-			toolCalls
+			toolCalls,
+			...blocks ? { blocks } : {}
 		};
 	}
 	/**
+	* Count the input tokens a request would use, through Anthropic's
+	* `messages.countTokens` endpoint (a network call; no tokens are
+	* generated or billed as output). Takes the same messages and options
+	* as `complete()` — system prompt, tools, thinking and
+	* `providerOptions.anthropic.betas` are counted exactly as they would be
+	* sent. For an offline estimate use `AnthropicSDK.count()`.
+	*
+	* @example
+	* const tokens = await model.countTokens(messages, { tools });
+	*/
+	async countTokens(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.dispatch({
+				...request,
+				body: countBody
+			}, options, "countTokens")).input_tokens;
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+	}
+	/**
 	* Incremental streaming completion. Yields neutral `ModelStreamChunk`s
 	* — `delta` for text tokens, `tool-call` once a `tool_use` block's
 	* 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.client.messages.create({
-				...this.buildParams(messages, options),
-				stream: true
-			}, options?.signal ? { signal: options.signal } : void 0);
+			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();
 		try {
 			for await (const event of stream) {
+				this.trackStreamedBlock(streamedBlocks, event);
 				if (event.type === "message_start") {
 					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") {
@@ -754,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;
@@ -780,20 +1406,35 @@ 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", {
 			finishReason,
 			usage
@@ -801,8 +1442,116 @@ var AnthropicModel = class {
 		yield {
 			type: "done",
 			finishReason,
-			usage
+			usage,
+			...blocks ? { blocks } : {}
+		};
+	}
+	/**
+	* Fold one stream event into the per-index block accumulator. Unknown
+	* block and delta types (beta `compaction`, future additions) are kept
+	* as their start payload plus whatever their delta carries, so they
+	* round-trip without the adapter knowing their shape.
+	*/
+	trackStreamedBlock(blocks, event) {
+		if (event.type === "content_block_start") {
+			const block = { ...event.content_block };
+			blocks.set(event.index, {
+				block,
+				...STREAMED_INPUT_BLOCK_TYPES.has(String(block.type)) ? { json: "" } : {}
+			});
+			return;
+		}
+		if (event.type !== "content_block_delta") return;
+		const entry = blocks.get(event.index);
+		if (!entry) return;
+		const delta = event.delta;
+		const block = entry.block;
+		if (delta.type === "text_delta") block.text = String(block.text ?? "") + String(delta.text ?? "");
+		else if (delta.type === "thinking_delta") block.thinking = String(block.thinking ?? "") + String(delta.thinking ?? "");
+		else if (delta.type === "signature_delta") block.signature = String(block.signature ?? "") + String(delta.signature ?? "");
+		else if (delta.type === "input_json_delta") entry.json = (entry.json ?? "") + String(delta.partial_json ?? "");
+		else if (delta.type === "citations_delta") block.citations = [...Array.isArray(block.citations) ? block.citations : [], delta.citation];
+		else for (const [key, value] of Object.entries(delta)) if (key !== "type") block[key] = value;
+	}
+	/** Close the accumulated stream blocks into an ordered content array. */
+	finishStreamedBlocks(blocks) {
+		return Array.from(blocks.entries()).sort(([left], [right]) => left - right).map(([, { block, json }]) => {
+			if (json !== void 0) block.input = (0, _warlock_js_ai.safeJsonParse)(json, {});
+			return block;
+		});
+	}
+	/**
+	* Send a request through the SDK. With `providerOptions.anthropic.betas`
+	* the call goes to `client.beta.messages` (which takes the `betas` list
+	* and the beta-only body fields); otherwise to `client.messages`. The
+	* cancellation signal rides in the request options, as before.
+	*/
+	dispatch(request, options, method) {
+		const requestOptions = options?.signal ? { signal: options.signal } : void 0;
+		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 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 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: {
+				...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
@@ -816,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 {
@@ -832,12 +1581,31 @@ var AnthropicModel = class {
 			...this.buildAutomaticCacheControl(options?.cacheControl),
 			...this.buildSystem(system, options?.cacheControl),
 			...sendTemperature ? { temperature } : {},
-			...this.buildTools(options?.tools),
+			...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.
 	*
@@ -855,7 +1623,7 @@ var AnthropicModel = class {
 		if (this.capabilities.promptCaching && breakpoints > 0) return { system: [{
 			type: "text",
 			text: system,
-			cache_control: this.cacheControl()
+			cache_control: this.cacheControl(cacheControl?.ttl)
 		}] };
 		return { system };
 	}
@@ -866,13 +1634,18 @@ var AnthropicModel = class {
 	*/
 	buildAutomaticCacheControl(cacheControl) {
 		const breakpoints = cacheControl?.breakpoints ?? 0;
-		return this.config.promptCaching && breakpoints <= 0 ? { cache_control: this.cacheControl() } : {};
+		return this.config.promptCaching && breakpoints <= 0 ? { cache_control: this.cacheControl(cacheControl?.ttl) } : {};
 	}
-	/** Build a typed cache-control marker, omitting TTL for Anthropic's 5-minute default. */
-	cacheControl() {
+	/**
+	* Build a typed cache-control marker. The per-call
+	* `cacheControl.ttl` wins over the model's `promptCacheTtl`; with
+	* neither, TTL is omitted for Anthropic's 5-minute default.
+	*/
+	cacheControl(callTtl) {
+		const ttl = callTtl ?? this.config.promptCacheTtl;
 		return {
 			type: "ephemeral",
-			...this.config.promptCacheTtl ? { ttl: this.config.promptCacheTtl } : {}
+			...ttl ? { ttl } : {}
 		};
 	}
 	/**
@@ -894,12 +1667,28 @@ var AnthropicModel = class {
 	*   budget. `budget_tokens` must be ≥ 1024 (`ThinkingConfigEnabled`,
 	*   `messages.d.ts:1084`), so the budget is floored at that minimum.
 	*
-	* The neutral `effort: "none"` ("run without reasoning") maps to no
-	* `thinking` field at all in both modes.
+	* The neutral `effort: "none"` ("run without reasoning") is mapped per
+	* 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
+	*   `effort: "low"` to spend less.
+	* - Every other model: no `thinking` field, as before.
 	*/
 	buildThinking(reasoning) {
 		if (!this.capabilities.reasoning || !reasoning) return {};
-		if (reasoning.effort === "none") return {};
+		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]);
@@ -917,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.
 	*
@@ -929,18 +1734,25 @@ var AnthropicModel = class {
 	* breakpoint there would pay the ~1.25x write surcharge every turn
 	* with no reads.
 	*/
-	buildTools(tools) {
+	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];
 			if (lastTool) mapped[last] = {
 				...lastTool,
-				cache_control: this.cacheControl()
+				cache_control: this.cacheControl(cacheControl?.ttl)
 			};
 		}
-		return { tools: mapped };
+		return { tools: [...providerDefined, ...mapped] };
 	}
 	/**
 	* Spread-friendly `output_config` fragment carrying both the native
@@ -1014,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
@@ -1050,9 +1869,155 @@ var AnthropicModel = class {
 		return wrapped;
 	}
 };
+/**
+* Request fields `providerOptions.anthropic.body` may not set: they carry
+* the conversation, the model and the tool surface the agent registered,
+* so an override would silently replace the agent's input (or let the
+* model call tools the agent never registered). `stream` is chosen per
+* call by `complete()` / `stream()`.
+*/
+const RESERVED_BODY_FIELDS = new Set([
+	"model",
+	"messages",
+	"system",
+	"tools",
+	"mcp_servers",
+	"stream"
+]);
+/** Body fields `messages.countTokens` accepts, copied from the full request body. */
+const COUNT_TOKENS_FIELDS = [
+	"model",
+	"messages",
+	"system",
+	"tools",
+	"tool_choice",
+	"thinking",
+	"output_config",
+	"cache_control",
+	"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;
+	return typeof raw === "object" && raw !== null ? raw : {};
+}
 
 //#endregion
-//#region ../ai-anthropic/src/sdk.ts
+//#region ../../packages/ai-anthropic/src/sdk.ts
 /**
 * Anthropic-backed implementation of `SDKAdapterContract`.
 *
@@ -1118,9 +2083,9 @@ var AnthropicSDK = class {
 	* Rough token-count estimate for a given text. Uses the
 	* character-heuristic (`approximateTokenCount`) from the core package
 	* — good enough for budgeting and quota guards, not for billing.
-	* Anthropic does expose a `messages.countTokens` endpoint, but that
-	* is a network round-trip; `count()` is intentionally offline and
-	* synchronous-cost. The optional model id is reserved for future
+	* For an exact count use `AnthropicModel.countTokens()`, which calls
+	* Anthropic's `messages.countTokens` endpoint (a network round-trip);
+	* `count()` is intentionally offline and synchronous-cost. The optional model id is reserved for future
 	* per-model tokenizer dispatch; currently ignored.
 	*/
 	async count(text, _model) {
@@ -1129,5 +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