@warlock.js/ai-anthropic 5.29.0 → 5.31.0

package/esm/model.mjs

@@ -1,23 +1,43 @@
+import { anthropicPricingFor, withAnthropicCacheWriteRates } from "./known-pricing.mjs";
+import { acceptsTemperature, inferPreservedThinking, inferThinkingMode, noReasoningForm } from "./thinking-mode.mjs";
+import { inferMaxOutputTokens } from "./known-output-limits.mjs";
 import { inferVisionCapability } from "./known-vision-models.mjs";
-import { acceptsTemperature, inferThinkingMode } from "./thinking-mode.mjs";
+import { applyAnthropicCacheUsage, requestCacheTtl } from "./utils/cache-usage.mjs";
 import { mapStopReason } from "./utils/map-stop-reason.mjs";
+import { toProviderBlocks } from "./utils/provider-blocks.mjs";
 import { toAnthropicMessages } from "./utils/to-anthropic-messages.mjs";
 import { toAnthropicTools } from "./utils/to-anthropic-tools.mjs";
 import { wrapAnthropicError } from "./utils/wrap-anthropic-error.mjs";
 import "./utils/index.mjs";
-import { safeJsonParse } from "@warlock.js/ai";
+import { AIError, InvalidRequestError, computeCost, resolveStreamChunks, safeJsonParse, selectProviderTools } from "@warlock.js/ai";
 import { log } from "@warlock.js/logger";
 
-//#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
@@ -36,11 +56,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,
@@ -65,6 +84,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`.
 *
@@ -110,8 +135,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),
@@ -127,24 +154,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 AIError ? thrown : new 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
@@ -153,50 +208,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 = 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") {
@@ -217,10 +316,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;
@@ -243,20 +354,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 = 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
@@ -264,10 +390,118 @@ 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 = 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 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 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
 	* `stream()` (each adds its own `stream` literal so the SDK's create
 	* overload resolves to the right return type). Hoists the system
@@ -279,13 +513,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 {
@@ -295,12 +529,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.
 	*
@@ -318,7 +571,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 };
 	}
@@ -329,13 +582,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 } : {}
 		};
 	}
 	/**
@@ -357,12 +615,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]);
@@ -380,6 +654,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.
 	*
@@ -392,18 +682,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 } = 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
@@ -477,27 +774,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 = computeCost(usage, this.pricing);
+		if (cost) usage.cost = cost;
+		return usage;
 	}
 	/**
 	* Wrap a thrown provider error into the typed `AIError` hierarchy and
@@ -513,6 +817,152 @@ 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 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
 export { AnthropicModel };