@warlock.js/ai-anthropic 5.28.0 → 5.30.0

package/CHANGELOG.md

@@ -4,6 +4,37 @@ All notable changes to `@warlock.js/ai-anthropic` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.30.0 - 2026-10-16
+
+### Upgrading
+
+- `model_context_window_exceeded` now maps to `finishReason: "context_exceeded"` (was `length`), `pause_turn` to `pause_turn` and `refusal` to `refusal` (both were `error`).
+- `providerOptions.anthropic.body` may not set `model`, `messages`, `system`, `tools`, `mcp_servers` or `stream`: the call fails with `InvalidRequestError` instead of silently replacing the conversation, the model or the registered tools.
+
+### Added
+
+- Responses with thinking, redacted-thinking, compaction, server-tool or cited-text blocks return the whole ordered turn as `ModelResponse.blocks` (and on the streaming `done` chunk); an assistant message carrying Anthropic `blocks` is replayed verbatim (WR-022).
+- `providerOptions.anthropic` (`AnthropicCallOptions`): `betas` routes the call through `client.beta.messages`, `body` merges extra request fields last (`context_management`, `fallbacks`, `inference_geo`, …), `thinkingDisplay` sets `thinking.display` (WR-025).
+- `AnthropicModel.countTokens(messages, options?)` counts input tokens through `messages.countTokens`; `AnthropicModel` is exported and `AnthropicSDK.model()` returns it (WR-025).
+- Per-call `cacheControl.ttl` overrides the model's `promptCacheTtl`.
+
+### Changed
+
+- Consecutive tool results are sent as one `user` message with several `tool_result` blocks, as Anthropic expects for parallel tool use (WR-024).
+- Claude 5-family thinking rules: Opus 5.5, Sonnet 5.5 and Fable 5 / 5.1 never receive `budget_tokens` or `disabled` (WR-026).
+- `effort: "none"` on Claude Sonnet 5.5 sends `thinking: { type: "between_tools" }` (its only thinking-off form, sent alone with no `output_config.effort` or `display`); it used to omit `thinking`, so the model still thought at its default effort. Opus 5.5 and Fable 5 / 5.1 have no thinking-off form and keep omitting `thinking` (WR-026).
+
+### Fixed
+
+- `providerOptions.anthropic.thinkingDisplay` is applied only to adaptive thinking, so it is never sent beside `between_tools` (a 400).
+- **Security:** a stored block is replayed only when its `data.type` equals its declared `type` and the type is one Claude returns on an assistant turn (text, thinking, redacted thinking, tool use, server-tool use and results, MCP, container upload, compaction). A transcript from outside the process can no longer smuggle a `tool_use` or user-side block past the tool-id check; such turns are rebuilt from `content` + `toolCalls`.
+
+## 5.29.0 - 2026-10-01
+
+### Changed
+
+- Lockstep release; package APIs are unchanged. Skills refer to other topics by name instead of file paths, so cross-references keep working after `agent-kit` copies them into an app.
+
 ## 5.28.0 - 2026-10-01
 
 ### Changed

package/cjs/index.cjs

@@ -31,7 +31,7 @@ _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-vision-models.ts
 /**
 * Model-name prefixes for Claude families that accept image input
 * (vision) on the Messages API.
@@ -86,7 +86,7 @@ function inferVisionCapability(modelName) {
 }
 
 //#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).
@@ -163,39 +163,150 @@ 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) {
+	const normalized = modelName.toLowerCase();
+	const id = normalized.slice(normalized.lastIndexOf(".") + 1);
+	return BETWEEN_TOOLS_RELEASE_ROOTS.some((root) => matchesReleaseRoot(id, root));
+}
 
 //#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 +317,24 @@ 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`.
+*
+* Other consecutive same-role turns are left as-is — the Messages API
+* merges them server-side.
 *
 * @example
 * const { system, messages } = toAnthropicMessages([
@@ -233,16 +353,29 @@ 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;
 		}
+		if (message.role === "assistant") {
+			const replayed = fromProviderBlocks(message.blocks, message.toolCalls);
+			if (replayed) {
+				mapped.push({
+					role: "assistant",
+					content: replayed
+				});
+				continue;
+			}
+		}
 		if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
 			const blocks = extractThinkingBlocks(message.toolCalls);
 			const text = stringifyContent(message.content);
@@ -305,6 +438,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 +500,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 +533,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.
@@ -545,7 +686,7 @@ function parseRetryAfter(headers) {
 }
 
 //#endregion
-//#region ../ai-anthropic/src/model.ts
+//#region ../../packages/ai-anthropic/src/model.ts
 const LOG_MODULE = "ai.anthropic";
 /**
 * Anthropic requires `max_tokens` on every request (unlike OpenAI,
@@ -602,6 +743,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`.
 *
@@ -672,16 +819,17 @@ var AnthropicModel = class {
 		});
 		let response;
 		try {
-			response = await this.client.messages.create({
-				...this.buildParams(messages, options),
+			response = await this.send({
+				...this.buildBody(messages, options),
 				stream: false
-			}, options?.signal ? { signal: options.signal } : void 0);
+			}, options, "create");
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
 		}
 		const finishReason = mapStopReason(response.stop_reason);
 		const usage = this.extractUsage(response.usage);
 		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,10 +838,32 @@ 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 body = this.buildBody(messages, options);
+		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;
+		} 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
@@ -709,10 +879,10 @@ var AnthropicModel = class {
 		});
 		let stream;
 		try {
-			stream = await this.client.messages.create({
-				...this.buildParams(messages, options),
+			stream = await this.send({
+				...this.buildBody(messages, options),
 				stream: true
-			}, options?.signal ? { signal: options.signal } : void 0);
+			}, options, "create");
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
 		}
@@ -724,8 +894,10 @@ var AnthropicModel = class {
 		};
 		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;
@@ -794,6 +966,7 @@ var AnthropicModel = class {
 		}
 		usage.total = usage.input + usage.output;
 		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,7 +974,79 @@ 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.
+	*/
+	send(body, options, method) {
+		const betas = resolveAnthropicOptions(options).betas;
+		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);
+	}
+	/**
+	* 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}.
+	*/
+	buildBody(messages, options) {
+		const anthropic = resolveAnthropicOptions(options);
+		const body = { ...this.buildParams(messages, options) };
+		if (anthropic.thinkingDisplay && this.thinkingMode === "adaptive" && body.thinking?.type === "adaptive") body.thinking = {
+			...body.thinking,
+			display: anthropic.thinkingDisplay
+		};
+		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
 		};
 	}
 	/**
@@ -832,7 +1077,7 @@ var AnthropicModel = class {
 			...this.buildAutomaticCacheControl(options?.cacheControl),
 			...this.buildSystem(system, options?.cacheControl),
 			...sendTemperature ? { temperature } : {},
-			...this.buildTools(options?.tools),
+			...this.buildTools(options?.tools, options?.cacheControl),
 			...this.buildOutputConfig(options?.responseSchema, thinking.effort),
 			...thinking.thinking ? { thinking: thinking.thinking } : {}
 		};
@@ -855,7 +1100,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 +1111,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 +1144,22 @@ 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:
+	* - 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.
+	* - 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 acceptsBetweenTools(this.name) ? { thinking: { type: "between_tools" } } : {};
 		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]);
@@ -929,7 +1189,7 @@ var AnthropicModel = class {
 	* breakpoint there would pay the ~1.25x write surcharge every turn
 	* with no reads.
 	*/
-	buildTools(tools) {
+	buildTools(tools, cacheControl) {
 		const mapped = toAnthropicTools(tools);
 		if (!mapped) return {};
 		if (this.config.promptCaching && mapped.length > 0) {
@@ -937,7 +1197,7 @@ var AnthropicModel = class {
 			const lastTool = mapped[last];
 			if (lastTool) mapped[last] = {
 				...lastTool,
-				cache_control: this.cacheControl()
+				cache_control: this.cacheControl(cacheControl?.ttl)
 			};
 		}
 		return { tools: mapped };
@@ -1050,9 +1310,42 @@ 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"
+];
+/** 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 +1411,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 +1422,6 @@ var AnthropicSDK = class {
 };
 
 //#endregion
+exports.AnthropicModel = AnthropicModel;
 exports.AnthropicSDK = AnthropicSDK;
 //# sourceMappingURL=index.cjs.map