@warlock.js/ai-anthropic 5.29.0 → 5.30.0

package/esm/model.d.mts

@@ -0,0 +1,250 @@
+import { AnthropicModelConfig } from "./config.type.mjs";
+import Anthropic from "@anthropic-ai/sdk";
+import { Message, ModelCallOptions, ModelCapabilities, ModelContract, ModelPricing, ModelResponse, ModelStreamChunk } from "@warlock.js/ai";
+
+//#region ../../packages/ai-anthropic/src/model.d.ts
+/**
+ * Anthropic-backed implementation of `ModelContract`.
+ *
+ * **Role.** The provider-facing bridge between the vendor-neutral
+ * `@warlock.js/ai` agent runtime and the official `@anthropic-ai/sdk`
+ * Messages API. Agents, workflows, and supervisors never talk to
+ * Anthropic directly — they hold a `ModelContract`, and this class is
+ * what makes that contract concrete for Claude models.
+ *
+ * **Responsibility.**
+ * - Owns: a long-lived `Anthropic` client + frozen `ModelConfig`
+ *   (name, temperature, maxTokens) used as defaults for every call.
+ * - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into
+ *   Anthropic wire shapes (system hoisting, `tool_use` / `tool_result`
+ *   blocks) on the way out, and translating Anthropic's content-block
+ *   response (text, tool calls, stop reason, usage) back into the
+ *   neutral shapes on the way in.
+ * - Does NOT own: dispatching tools, deciding whether to loop, tracking
+ *   conversation history, or retrying on failure — those are agent
+ *   concerns. The model is a stateless (per-call) protocol adapter.
+ *
+ * Because it holds a live client and shared defaults, it is modeled as
+ * a class (see §4.2 of code-style.md — "long-lived state across
+ * calls").
+ *
+ * @example
+ * import Anthropic from "@anthropic-ai/sdk";
+ * const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+ * const model = new AnthropicModel(client, { name: "claude-sonnet-4-6" });
+ *
+ * const myAgent = agent({
+ *   model,
+ *   systemPrompt: "You are a helpful assistant.",
+ *   tools: [searchTool],
+ * });
+ *
+ * const result = await myAgent.execute("Summarize today's news.");
+ */
+declare class AnthropicModel implements ModelContract {
+  readonly name: string;
+  readonly provider: string;
+  readonly capabilities: ModelCapabilities;
+  readonly pricing?: ModelPricing;
+  private readonly client;
+  private readonly config;
+  private readonly thinkingMode;
+  private readonly logger;
+  constructor(client: Anthropic, config: AnthropicModelConfig, provider?: string);
+  /**
+   * Single-shot completion. Sends the full message list to the Messages
+   * endpoint, waits for the terminal response, and reshapes it into a
+   * vendor-neutral `ModelResponse`. Per-call `options` override the
+   * instance's `ModelConfig` defaults for this call only.
+   */
+  complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse>;
+  /**
+   * 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 });
+   */
+  countTokens(messages: Message[], options?: ModelCallOptions): Promise<number>;
+  /**
+   * 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`.
+   */
+  stream(messages: Message[], options?: ModelCallOptions): AsyncIterable<ModelStreamChunk>;
+  /**
+   * 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.
+   */
+  private trackStreamedBlock;
+  /** Close the accumulated stream blocks into an ordered content array. */
+  private finishStreamedBlocks;
+  /**
+   * 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.
+   */
+  private send;
+  /**
+   * 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}.
+   */
+  private buildBody;
+  /**
+   * 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
+   * prompt out of `messages`, resolves `max_tokens` (required by
+   * Anthropic) with the documented default, and conditionally attaches
+   * temperature, tools, native structured output, extended thinking
+   * (`reasoning`), and automatic or explicit prompt-cache control.
+   * Temperature is dropped when thinking is enabled, since Anthropic
+   * rejects the two together, and always for adaptive-mode models, which
+   * reject any explicit temperature (see `acceptsTemperature`).
+   */
+  private buildParams;
+  /**
+   * Spread-friendly `system` fragment. Returns an empty object when no
+   * system prompt was hoisted out of the messages.
+   *
+   * When a per-call `cacheControl.breakpoints` hint is present (≥ 1),
+   * the system prompt is emitted as a single `TextBlockParam` carrying
+   * `cache_control: ephemeral` — the system prompt is the longest stable
+   * prefix on a turn, so one breakpoint there lets multi-turn agents
+   * read it back at the ~0.1x cache-read rate. Without the hint the
+   * system prompt stays a plain string (left uncached) so a one-shot
+   * call never pays the ~1.25x cache-write surcharge.
+   */
+  private buildSystem;
+  /**
+   * Let Anthropic select the last cacheable block when caching is enabled
+   * without a caller-selected breakpoint. An explicit breakpoint remains
+   * authoritative, so the request-level form is deliberately omitted then.
+   */
+  private buildAutomaticCacheControl;
+  /**
+   * 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.
+   */
+  private cacheControl;
+  /**
+   * Translate the neutral `reasoning` option into Anthropic's thinking
+   * settings, in the shape this model accepts (`thinkingMode`). Emitted
+   * only when the model declares the `reasoning` capability AND a
+   * reasoning option is supplied; otherwise returns an empty object.
+   *
+   * - Adaptive mode (Opus 4.7+, Sonnet 5+, Fable 5+, unknown ids):
+   *   `thinking: { type: "adaptive" }` (installed SDK
+   *   `ThinkingConfigAdaptive`, `messages.d.ts:1065`) plus
+   *   `output_config.effort` from the neutral effort, defaulting to
+   *   `"medium"`. `budget_tokens` is never sent — these models 400 on it
+   *   (claude-api ref). `reasoning.maxTokens` only sizes the default
+   *   `max_tokens` headroom.
+   * - Budget mode (Haiku 4.5, Opus/Sonnet 4.6, older):
+   *   `thinking: { type: "enabled", budget_tokens }`. An explicit
+   *   `reasoning.maxTokens` wins; otherwise the effort maps to a tiered
+   *   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") 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.
+   */
+  private buildThinking;
+  /**
+   * Spread-friendly tools fragment. Returns an empty object when no
+   * tools were supplied so the caller can unconditionally spread it.
+   *
+   * When `config.promptCaching` is on, marks the LAST tool with
+   * `cache_control: ephemeral` — Anthropic caches the whole prefix up
+   * to a breakpoint, and tools sit before `system` in that prefix, so
+   * one breakpoint on the final tool caches every tool definition.
+   * Reads bill at ~0.1x after the first write. The system prompt is
+   * deliberately left uncached: it carries per-turn placeholders, so a
+   * breakpoint there would pay the ~1.25x write surcharge every turn
+   * with no reads.
+   */
+  private buildTools;
+  /**
+   * Spread-friendly `output_config` fragment carrying both the native
+   * structured-output `format` and the adaptive-thinking `effort`, merged
+   * into one object (both live under `OutputConfig`, installed SDK
+   * `messages.d.ts:796-806`). Returns an empty object when neither applies,
+   * so budget-mode requests carry `output_config` only when a schema asks
+   * for it.
+   */
+  private buildOutputConfig;
+  /**
+   * Translate the neutral `responseSchema` option into Anthropic's
+   * native `output_config.format` (JSON-schema structured outputs).
+   *
+   * Only returned when the model declares the `structuredOutput`
+   * capability AND the schema is a proper root-object JSON Schema —
+   * Anthropic rejects non-object roots. When the capability is off
+   * (config override) or the schema is non-object, returns `undefined`:
+   * the agent has already injected a soft schema hint into the system
+   * prompt as the fallback, and client-side `validate()` still enforces
+   * shape.
+   */
+  private buildStructuredOutputFormat;
+  /**
+   * Concatenate every `text` content block into the single neutral
+   * `content` string. `tool_use` and other block types are ignored
+   * here — tool calls are surfaced separately via `extractToolCalls`.
+   */
+  private extractText;
+  /**
+   * Reshape Anthropic's `tool_use` content blocks into the neutral
+   * `ModelToolCallRequest[]`. Returns `undefined` when the model
+   * requested no tools so callers can branch on presence.
+   */
+  private extractToolCalls;
+  /**
+   * Preserve Anthropic's opaque extended-thinking blocks beside a tool
+   * request so the next assistant turn can replay their signatures exactly.
+   */
+  private buildThinkingMetadata;
+  /**
+   * 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
+   * `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.
+   */
+  private extractUsage;
+  /**
+   * Wrap a thrown provider error into the typed `AIError` hierarchy and
+   * emit the standard error log line before it propagates. Shared by
+   * every catch site so the log shape stays identical.
+   */
+  private logAndWrap;
+}
+//#endregion
+export { AnthropicModel };
+//# sourceMappingURL=model.d.mts.map

package/esm/model.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.mts","names":[],"sources":["../../../../../../../packages/ai-anthropic/src/model.ts"],"mappings":";;;;;;;AA8KA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,YAA0B,aAAA;EAAA,SACrB,IAAA;EAAA,SACA,QAAA;EAAA,SACA,YAAA,EAAc,iBAAA;EAAA,SACd,OAAA,GAAU,YAAA;EAAA,iBAET,MAAA;EAAA,iBACA,MAAA;EAAA,iBACA,YAAA;EAAA,iBACA,MAAA;cAGf,MAAA,EAAQ,SAAA,EACR,MAAA,EAAQ,oBAAA,EACR,QAAA;EA0FiC;;;;;;EAlDtB,QAAA,CAAS,QAAA,EAAU,OAAA,IAAW,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,aAAA;EA+E9E;;;;;;;;;;;EA7BW,WAAA,CAAY,QAAA,EAAU,OAAA,IAAW,OAAA,GAAU,gBAAA,GAAmB,OAAA;EAqbnE;;;;;;;EAzZM,MAAA,CACZ,QAAA,EAAU,OAAA,IACV,OAAA,GAAU,gBAAA,GACT,aAAA,CAAc,gBAAA;EA4nBT;;;AA4BU;;;EA5BV,QArdA,kBAAA;;UAoDA,oBAAA;;;;;;;UAkBA,IAAA;;;;;;;;;UAqBA,SAAA;;;;;;;;;;;;;UAgDA,WAAA;;;;;;;;;;;;;UA2DA,WAAA;;;;;;UA0BA,0BAAA;;;;;;UAeA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAyCA,aAAA;;;;;;;;;;;;;;UAkDA,UAAA;;;;;;;;;UA8BA,iBAAA;;;;;;;;;;;;;UA8BA,2BAAA;;;;;;UAmBA,WAAA;;;;;;UAYA,gBAAA;;;;;UAuBA,qBAAA;;;;;;;;;;;UAyBA,YAAA;;;;;;UA4BA,UAAA;AAAA"}

package/esm/model.mjs

@@ -1,14 +1,15 @@
 import { inferVisionCapability } from "./known-vision-models.mjs";
-import { acceptsTemperature, inferThinkingMode } from "./thinking-mode.mjs";
+import { acceptsBetweenTools, acceptsTemperature, inferThinkingMode } from "./thinking-mode.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 { InvalidRequestError, safeJsonParse } 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";
 /**
 * Anthropic requires `max_tokens` on every request (unlike OpenAI,
@@ -65,6 +66,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`.
 *
@@ -135,16 +142,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
@@ -153,10 +161,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
@@ -172,10 +202,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);
 		}
@@ -187,8 +217,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;
@@ -257,6 +289,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
@@ -264,7 +297,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 = 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 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
 		};
 	}
 	/**
@@ -295,7 +400,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 } : {}
 		};
@@ -318,7 +423,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 +434,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 +467,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]);
@@ -392,7 +512,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) {
@@ -400,7 +520,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 };
@@ -513,6 +633,39 @@ 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
 export { AnthropicModel };