@warlock.js/ai-bedrock 5.30.0 → 5.31.0

package/CHANGELOG.md

@@ -4,6 +4,33 @@ All notable changes to `@warlock.js/ai-bedrock` 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.31.0 - 2026-10-18
+
+### Fixed
+
+- Usage is marked `inputIncludesCache: false` (Converse `inputTokens` excludes cache reads and writes) and reports 1-hour cache writes from `cacheDetails` in `cacheWrite1hTokens`, so cost bills each cache token once at its own rate.
+- A `toolUse` block with `type: "server_tool_use"` (a system tool run by Bedrock) is no longer returned as a tool call for the agent to dispatch.
+- Converse conversion compiles with strict indexed-access checks while preserving empty and system-only histories.
+- Provider body options merge plain-object fields one level deep, preserving neutral reasoning, generation and structured-output settings unless the caller overrides their keys.
+- Converse conversion combines adjacent same-role turns in content order, preserving parallel tool results and automatic compaction summaries beside assistant tool calls.
+
+### Added
+
+- With a `cacheControl` breakpoint, a `cachePoint` is also placed after the system prompt and, for Claude, after the tool definitions — the prefix segments Bedrock caches in `tools` → `system` → `messages` order. `ttl: "1h"` (per call, or the new `promptCacheTtl` model option) is sent only to models that accept it.
+- Built-in Claude prices for `global.` and `us.` inference profiles (`BEDROCK_GLOBAL_PRICING`, `BEDROCK_US_PRICING`, `bedrockPricingFor`), from AWS's Bedrock price list as of 2026-10-17; caller pricing for Claude models gets the 1.25x / 2x cache-write rates filled (`withClaudeCacheWriteRates`). `complete()` and the streaming `done` chunk attach `usage.cost` when priced.
+- Claude 5 families and Nova 2 Lite are recognised as prompt-caching capable.
+- `ServiceUnavailableException` throws `ProviderOverloadedError`; wrapped errors carry `status`, `billed` and `retryable`.
+- `new BedrockSDK({ apiKey, region })` authenticates with an Amazon Bedrock API key: requests carry `Authorization: Bearer <apiKey>` instead of a SigV4 signature and the AWS credential chain is not consulted (the adapter sets the AWS SDK's `token` and `authSchemePreference: ["httpBearerAuth"]`). An empty key, or a key combined with `credentials` or `token`, throws `InvalidRequestError`.
+- An adapter contract test verifies that aborting `signal` rejects `complete()` and `stream()` and cancels the HTTP/2 request.
+- With `streamChunks`, `stream()` yields `reasoning` for `reasoningContent.text` deltas and `tool-args` for client `toolUse.input` deltas.
+- `ai.providerTool({ provider: "bedrock", definition })` appends a Converse `Tool` member such as `{ systemTool: { name: "nova_grounding" } }` verbatim; other providers' tools are skipped with a warning.
+- `providerOptions.bedrock.body` forwards native per-call request options for completions and streams while protecting the model, conversation and tool definitions.
+- Models expose native `countTokens()` preflight using the generation request's Converse conversation, tools and additional model fields.
+
+### Upgrading
+
+- Calls that ask for `cacheControl` breakpoints now also write the system prompt and (Claude) tool definitions to the cache. Writes cost more than plain input on the first call; repeated prefixes then read at the cache rate.
+
 ## 5.30.0 - 2026-10-16
 
 ### Changed
@@ -85,6 +112,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### Changed
 
 - Lockstep release maintenance and dependency refresh.
+
 ## 5.20.0 - 2026-09-24
 
 ### Changed

package/cjs/index.cjs

@@ -147,9 +147,22 @@ function toBedrockMessages(messages) {
 	}
 	return {
 		system: system.length > 0 ? system : void 0,
-		messages: mapped
+		messages: mergeAdjacentTurns(mapped)
 	};
 }
+/** Converse requires alternating turns; preserve every content block in order. */
+function mergeAdjacentTurns(messages) {
+	const merged = [];
+	for (const message of messages) {
+		const previous = merged[merged.length - 1];
+		if (previous && previous.role === message.role) previous.content.push(...message.content ?? []);
+		else merged.push({
+			...message,
+			content: [...message.content ?? []]
+		});
+	}
+	return merged;
+}
 /**
 * Recover opaque Converse reasoning blocks retained on a prior tool call.
 * Bedrock requires them to be replayed before the assistant's text and
@@ -293,6 +306,10 @@ function wrapBedrockError(thrown) {
 		cause: thrown,
 		context
 	});
+	if (shape.name === "ServiceUnavailableException" || shape.httpStatusCode === 503) return new _warlock_js_ai.ProviderOverloadedError(message, {
+		cause: thrown,
+		context
+	});
 	if (shape.name === "ValidationException") {
 		if (/too long|context window|maximum context|exceeds the maximum/i.test(message)) return new _warlock_js_ai.ContextLengthExceededError(message, {
 			cause: thrown,
@@ -465,6 +482,38 @@ var BedrockEmbedder = class {
 	}
 };
 
+//#endregion
+//#region ../../packages/ai-bedrock/src/provider-options.ts
+const RESERVED_FIELDS = new Set([
+	"modelId",
+	"messages",
+	"system",
+	"toolConfig"
+]);
+function mergeProviderBody(built, options) {
+	const body = (options?.providerOptions?.bedrock)?.body ?? {};
+	const reserved = Object.keys(body).filter((key) => RESERVED_FIELDS.has(key));
+	if (reserved.length > 0) throw new _warlock_js_ai.InvalidRequestError(`providerOptions.bedrock.body cannot set ${reserved.join(", ")}: use the call's messages, tools and model options.`, { context: { fields: reserved } });
+	const defaults = built;
+	const overrides = Object.fromEntries(Object.entries(body).map(([key, value]) => {
+		const previous = defaults[key];
+		return [key, isPlainObject(previous) && isPlainObject(value) ? {
+			...previous,
+			...value
+		} : value];
+	}));
+	return {
+		...built,
+		...overrides
+	};
+}
+/** Merge only plain objects; arrays, null and provider scalar values replace the field. */
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
 //#endregion
 //#region ../../packages/ai-bedrock/src/known-capabilities.ts
 /**
@@ -498,8 +547,10 @@ const REASONING_CAPABLE_SUBSTRINGS = [
 ];
 /**
 * Families that honor Converse `cachePoint` prompt-cache breakpoints.
-* Anthropic Claude 3.5+ / 3.7 / 4 and the Amazon Nova line support
-* cache points; text-only legacy families do not.
+* Anthropic Claude 3.5+ / 3.7 / 4 / 5 and the Amazon Nova line support
+* cache points; text-only legacy families do not. Per the "Supported
+* models" table of https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html
+* (checked 2026-10-17).
 */
 const PROMPT_CACHING_CAPABLE_SUBSTRINGS = [
 	"claude-3-5",
@@ -507,6 +558,12 @@ const PROMPT_CACHING_CAPABLE_SUBSTRINGS = [
 	"claude-sonnet-4",
 	"claude-opus-4",
 	"claude-haiku-4",
+	"claude-sonnet-5",
+	"claude-opus-5",
+	"claude-haiku-5",
+	"claude-fable-5",
+	"claude-mythos-5",
+	"nova-2-lite",
 	"nova-lite",
 	"nova-pro",
 	"nova-premier",
@@ -570,6 +627,133 @@ function inferPromptCachingCapability(modelId) {
 function inferPdfCapability(modelId) {
 	return matchesAny(modelId, PDF_CAPABLE_SUBSTRINGS);
 }
+/**
+* Claude on Bedrock accepts a `cachePoint` in `system`, `messages` and
+* `tools`; Amazon Nova accepts one only in `system` and `messages`
+* (https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html,
+* "Fields that accept prompt cache checkpoints", checked 2026-10-17).
+* Unknown families get no tool cache point.
+*
+* @example
+* supportsToolCachePoint("global.anthropic.claude-sonnet-4-6"); // true
+* supportsToolCachePoint("amazon.nova-pro-v1:0"); // false
+*/
+function supportsToolCachePoint(modelId) {
+	return modelId.toLowerCase().includes("anthropic.claude");
+}
+/** Claude families whose cache points accept the 1-hour TTL. */
+const ONE_HOUR_TTL_PATTERN = /anthropic\.claude-(?:(?:opus|sonnet|haiku|fable|mythos)-5|opus-4-[5-9]|sonnet-4-[5-9]|haiku-4-5)/;
+/**
+* Claude models whose Converse `cachePoint` accepts `ttl: "1h"`: Claude
+* Haiku 4.5, the 4.5+ Sonnet / Opus line and every Claude 5 family. Any
+* other model gets no `ttl` field (the 5-minute default), since AWS
+* warns that sending it to a 5-minute-only model "can result in a
+* ValidationException" (same page, checked 2026-10-17).
+*
+* @example
+* supportsOneHourCacheTtl("anthropic.claude-haiku-4-5-20251001-v1:0"); // true
+* supportsOneHourCacheTtl("anthropic.claude-3-7-sonnet-20250219-v1:0"); // false
+*/
+function supportsOneHourCacheTtl(modelId) {
+	return ONE_HOUR_TTL_PATTERN.test(modelId.toLowerCase());
+}
+
+//#endregion
+//#region ../../packages/ai-bedrock/src/known-pricing.ts
+/**
+* Bedrock on-demand list prices for Anthropic Claude, USD per 1,000,000
+* tokens, keyed by Bedrock model id (without an inference-profile
+* prefix). `cacheWrite` is the 5-minute write rate, `cacheWrite1h` the
+* 1-hour write rate, `cachedInput` the cache-read rate.
+*
+* Source: https://aws.amazon.com/bedrock/pricing/ — the page's own price
+* feed for "US East (N. Virginia)", fetched 2026-10-17 (Sonnet 5.5 cache
+* reads already at the rate effective 2026-10-07). Model ids from
+* https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html.
+*
+* Two tables, because AWS prices them differently:
+* - {@link BEDROCK_GLOBAL_PRICING} — `global.` cross-Region inference
+*   profiles.
+* - {@link BEDROCK_US_PRICING} — `us.` geographic profiles (the
+*   "Geo / In-region" rates, 10% above global for these models).
+*
+* In-Region ids without a profile prefix, other geographies (`eu.`,
+* `apac.`, …), Claude Haiku 5.5 and non-Claude models stay unpriced —
+* their rates vary by Region or were not verified — so pass `pricing`
+* yourself for them.
+*/
+const BEDROCK_GLOBAL_PRICING = {
+	"anthropic.claude-sonnet-5-5": claude(2, 10, .1),
+	"anthropic.claude-opus-5-5": claude(4, 20, .2),
+	"anthropic.claude-fable-5-1": claude(10, 50, .25),
+	"anthropic.claude-opus-5": claude(5, 25, .5),
+	"anthropic.claude-sonnet-5": claude(2, 10, .2),
+	"anthropic.claude-fable-5": claude(10, 50, 1),
+	"anthropic.claude-opus-4-8": claude(5, 25, .5),
+	"anthropic.claude-opus-4-7": claude(5, 25, .5),
+	"anthropic.claude-opus-4-6-v1": claude(5, 25, .5),
+	"anthropic.claude-sonnet-4-6": claude(3, 15, .3),
+	"anthropic.claude-opus-4-5-20251101-v1:0": claude(5, 25, .5),
+	"anthropic.claude-sonnet-4-5-20250929-v1:0": claude(3, 15, .3),
+	"anthropic.claude-haiku-4-5-20251001-v1:0": claude(1, 5, .1)
+};
+/** `us.` geographic-profile prices — see {@link BEDROCK_GLOBAL_PRICING}. */
+const BEDROCK_US_PRICING = {
+	"anthropic.claude-sonnet-5-5": claude(2.2, 11, .11),
+	"anthropic.claude-opus-5-5": claude(4.4, 22, .22),
+	"anthropic.claude-fable-5-1": claude(11, 55, .275),
+	"anthropic.claude-opus-5": claude(5.5, 27.5, .55),
+	"anthropic.claude-sonnet-5": claude(2.2, 11, .22),
+	"anthropic.claude-fable-5": claude(11, 55, 1.1),
+	"anthropic.claude-opus-4-8": claude(5.5, 27.5, .55),
+	"anthropic.claude-opus-4-7": claude(5.5, 27.5, .55),
+	"anthropic.claude-opus-4-6-v1": claude(5.5, 27.5, .55),
+	"anthropic.claude-sonnet-4-6": claude(3.3, 16.5, .33),
+	"anthropic.claude-opus-4-5-20251101-v1:0": claude(5.5, 27.5, .55),
+	"anthropic.claude-sonnet-4-5-20250929-v1:0": claude(3.3, 16.5, .33),
+	"anthropic.claude-haiku-4-5-20251001-v1:0": claude(1.1, 5.5, .11)
+};
+/**
+* Look up the built-in price for a Bedrock model id or inference-profile
+* id: `global.<model>` reads {@link BEDROCK_GLOBAL_PRICING}, `us.<model>`
+* reads {@link BEDROCK_US_PRICING}; anything else is `undefined`.
+*
+* @example
+* bedrockPricingFor("global.anthropic.claude-sonnet-4-6"); // { input: 3, output: 15, … }
+* bedrockPricingFor("anthropic.claude-sonnet-4-6"); // undefined — in-Region rates vary
+*/
+function bedrockPricingFor(modelId) {
+	if (modelId.startsWith("global.")) return BEDROCK_GLOBAL_PRICING[modelId.slice(7)];
+	if (modelId.startsWith("us.")) return BEDROCK_US_PRICING[modelId.slice(3)];
+}
+/**
+* Fill the Claude cache-write rates (5-minute 1.25x, 1-hour 2x the input
+* rate — the ratio of every Claude row in the tables above) into a
+* caller-supplied entry for a Claude model that omits them. Non-Claude
+* models are returned unchanged.
+*/
+function withClaudeCacheWriteRates(modelId, pricing) {
+	if (!pricing || !modelId.toLowerCase().includes("anthropic.claude")) return pricing;
+	if (pricing.cacheWrite !== void 0 && pricing.cacheWrite1h !== void 0) return pricing;
+	return {
+		...pricing,
+		cacheWrite: pricing.cacheWrite ?? pricing.cachedOutput ?? round(pricing.input * 1.25),
+		cacheWrite1h: pricing.cacheWrite1h ?? round(pricing.input * 2)
+	};
+}
+function claude(input, output, cachedInput) {
+	return {
+		input,
+		output,
+		cachedInput,
+		cacheWrite: round(input * 1.25),
+		cacheWrite1h: round(input * 2)
+	};
+}
+/** Trim binary floating-point noise (2.2 * 1.25 = 2.7500000000000004). */
+function round(value) {
+	return Math.round(value * 1e9) / 1e9;
+}
 
 //#endregion
 //#region ../../packages/ai-bedrock/src/known-vision-models.ts
@@ -622,6 +806,10 @@ function inferVisionCapability(modelId) {
 //#endregion
 //#region ../../packages/ai-bedrock/src/model.ts
 const LOG_MODULE = "ai.bedrock";
+/** `provider` value of `ai.providerTool()` entries this adapter sends verbatim. */
+const BEDROCK_WIRE_FORMAT = "bedrock";
+/** Converse `ToolUseBlock.type` of a tool use run by Bedrock itself (SDK `ToolUseType`). */
+const SERVER_TOOL_USE = "server_tool_use";
 /** Default output allowance added to a thinking budget when maxTokens is unset. */
 const DEFAULT_MAX_TOKENS = 4096;
 const MIN_THINKING_BUDGET = 1024;
@@ -682,7 +870,7 @@ var BedrockModel = class {
 		this.config = config;
 		this.name = config.name;
 		this.provider = provider;
-		this.pricing = config.pricing;
+		this.pricing = withClaudeCacheWriteRates(config.name, config.pricing ?? bedrockPricingFor(config.name));
 		this.capabilities = {
 			structuredOutput: config.structuredOutput ?? true,
 			vision: config.vision ?? inferVisionCapability(config.name),
@@ -713,7 +901,7 @@ var BedrockModel = class {
 		}
 		const blocks = response.output?.message?.content ?? [];
 		const finishReason = mapStopReason(response.stopReason);
-		const usage = this.extractUsage(response.usage);
+		const usage = (0, _warlock_js_ai.attachCost)(this.extractUsage(response.usage), this.pricing);
 		const toolCalls = this.extractToolCalls(blocks);
 		this.logger.debug(LOG_MODULE, "response", "Converse call succeeded", {
 			finishReason,
@@ -726,11 +914,36 @@ var BedrockModel = class {
 			toolCalls
 		};
 	}
+	/** Count native input tokens from the same Converse conversation and tool configuration. */
+	async countTokens(messages, options) {
+		const request = this.buildRequest(messages, options);
+		try {
+			const response = await this.client.send(new _aws_sdk_client_bedrock_runtime.CountTokensCommand({
+				modelId: request.modelId,
+				input: { converse: {
+					messages: request.messages,
+					system: request.system,
+					toolConfig: request.toolConfig,
+					additionalModelRequestFields: request.additionalModelRequestFields
+				} }
+			}), options?.signal ? { abortSignal: options.signal } : void 0);
+			if (response.inputTokens === void 0) throw new _warlock_js_ai.InvalidRequestError("Bedrock countTokens returned no inputTokens.");
+			return response.inputTokens;
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+	}
 	/**
 	* Incremental streaming completion via ConverseStream. Yields neutral
 	* `ModelStreamChunk`s — `delta` for text, `tool-call` once a
 	* `toolUse` block's accumulated input JSON is complete, and a
 	* terminal `done` with the final finish reason + usage totals.
+	*
+	* With `options.streamChunks` it also yields `reasoning` for each
+	* `reasoningContent.text` delta and `tool-args` for each client
+	* `toolUse.input` delta. Usage arrives once, in the final `metadata`
+	* event, so no `usage` chunk is emitted. A system tool's
+	* `server_tool_use` block never becomes a `tool-call`.
 	*/
 	async *stream(messages, options) {
 		this.logger.debug(LOG_MODULE, "request", "Starting ConverseStream call", {
@@ -746,11 +959,12 @@ var BedrockModel = class {
 			throw this.logAndWrap(thrown);
 		}
 		let rawStopReason;
-		const usage = {
+		let usage = {
 			input: 0,
 			output: 0,
 			total: 0
 		};
+		const want = (0, _warlock_js_ai.resolveStreamChunks)(options);
 		const toolBlocks = /* @__PURE__ */ new Map();
 		const reasoningBlocks = /* @__PURE__ */ new Map();
 		const completedReasoningBlocks = [];
@@ -758,6 +972,7 @@ var BedrockModel = class {
 			for await (const event of response.stream ?? []) {
 				if (event.contentBlockStart?.start?.toolUse) {
 					const start = event.contentBlockStart.start.toolUse;
+					if (start.type === SERVER_TOOL_USE) continue;
 					toolBlocks.set(event.contentBlockStart.contentBlockIndex ?? 0, {
 						id: start.toolUseId ?? "",
 						name: start.name ?? "",
@@ -773,11 +988,25 @@ var BedrockModel = class {
 					};
 					else if (delta.toolUse) {
 						const accumulator = toolBlocks.get(event.contentBlockDelta.contentBlockIndex ?? 0);
-						if (accumulator) accumulator.json += delta.toolUse.input ?? "";
+						if (accumulator) {
+							accumulator.json += delta.toolUse.input ?? "";
+							if (want.toolArgs && delta.toolUse.input) yield {
+								type: "tool-args",
+								callId: accumulator.id,
+								name: accumulator.name,
+								delta: delta.toolUse.input
+							};
+						}
 					} else if (delta.reasoningContent) {
 						const index = event.contentBlockDelta.contentBlockIndex ?? 0;
 						const accumulator = reasoningBlocks.get(index) ?? {};
-						if (delta.reasoningContent.text !== void 0) accumulator.text = (accumulator.text ?? "") + delta.reasoningContent.text;
+						if (delta.reasoningContent.text !== void 0) {
+							accumulator.text = (accumulator.text ?? "") + delta.reasoningContent.text;
+							if (want.reasoning && delta.reasoningContent.text !== "") yield {
+								type: "reasoning",
+								delta: delta.reasoningContent.text
+							};
+						}
 						if (delta.reasoningContent.signature !== void 0) accumulator.signature = delta.reasoningContent.signature;
 						if (delta.reasoningContent.redactedContent !== void 0) accumulator.redactedContent = delta.reasoningContent.redactedContent;
 						reasoningBlocks.set(index, accumulator);
@@ -806,19 +1035,13 @@ var BedrockModel = class {
 					continue;
 				}
 				if (event.messageStop) rawStopReason = event.messageStop.stopReason;
-				if (event.metadata?.usage) {
-					const raw = event.metadata.usage;
-					usage.input = raw.inputTokens ?? 0;
-					usage.output = raw.outputTokens ?? 0;
-					usage.total = raw.totalTokens ?? usage.input + usage.output;
-					if (raw.cacheReadInputTokens && raw.cacheReadInputTokens > 0) usage.cachedTokens = raw.cacheReadInputTokens;
-					if (raw.cacheWriteInputTokens && raw.cacheWriteInputTokens > 0) usage.cacheWriteTokens = raw.cacheWriteInputTokens;
-				}
+				if (event.metadata?.usage) usage = this.extractUsage(event.metadata.usage);
 			}
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
 		}
 		const finishReason = mapStopReason(rawStopReason);
+		(0, _warlock_js_ai.attachCost)(usage, this.pricing);
 		this.logger.debug(LOG_MODULE, "response", "ConverseStream call succeeded", {
 			finishReason,
 			usage
@@ -841,44 +1064,58 @@ var BedrockModel = class {
 		const configuredMaxTokens = options?.maxTokens ?? this.config.maxTokens;
 		const maxTokens = this.resolveMaxTokens(configuredMaxTokens, thinkingBudget);
 		const temperature = options?.temperature ?? this.config.temperature;
-		const cachedMessages = this.applyCacheBreakpoints(bedrockMessages, options?.cacheControl);
-		return {
+		const cachePoint = this.resolveCachePoint(options?.cacheControl);
+		const cachedMessages = this.applyCacheBreakpoints(bedrockMessages, cachePoint);
+		const cachedSystem = system && cachePoint ? [...system, { cachePoint }] : system;
+		return mergeProviderBody({
 			modelId: this.name,
 			messages: cachedMessages,
-			...system ? { system } : {},
+			...cachedSystem ? { system: cachedSystem } : {},
 			inferenceConfig: {
 				...maxTokens !== void 0 ? { maxTokens } : {},
 				...temperature !== void 0 ? { temperature } : {}
 			},
-			...this.buildToolConfig(options?.tools),
+			...this.buildToolConfig(options, cachePoint),
 			...this.buildOutputConfig(options?.responseSchema),
 			...this.buildReasoningConfig(thinkingBudget)
-		};
+		}, options);
 	}
 	/**
-	* Append a Converse `cachePoint` block to the LAST message when the
-	* caller supplies a `cacheControl` write breakpoint and the model is
-	* `promptCaching`-capable. A cache point tells Bedrock to cache the
-	* whole prefix up to that block, so subsequent calls reusing the same
-	* prefix bill the cached portion at the discounted read rate
-	* (surfaced as `Usage.cachedTokens`). No-ops gracefully when caching
-	* is unsupported, no breakpoint was requested, or there are no
-	* messages to mark — Bedrock then prices the call normally.
+	* Resolve the Converse `cachePoint` to place for this call, or
+	* `undefined` when no cache point applies (the model is not
+	* `promptCaching`-capable or no `cacheControl` breakpoint was asked
+	* for). Bedrock only honors `type: "default"`; the neutral
+	* `breakpoints` count is a presence hint.
 	*
-	* Bedrock only honors `CachePointType.DEFAULT`; the neutral
-	* `breakpoints` count is a presence hint (one trailing breakpoint is
-	* the only placement Converse supports without manual block surgery),
-	* so any positive value marks the trailing message.
+	* The lifetime is the per-call `cacheControl.ttl`, else the model's
+	* `promptCacheTtl`. `ttl: "1h"` is sent only to models that accept it
+	* ({@link supportsOneHourCacheTtl}); any other model gets the 5-minute
+	* default, because AWS rejects the field there.
 	*/
-	applyCacheBreakpoints(messages, cacheControl) {
+	resolveCachePoint(cacheControl) {
 		const breakpoints = cacheControl?.breakpoints ?? 0;
-		if (!this.capabilities.promptCaching || breakpoints <= 0 || !messages || messages.length === 0) return messages;
+		if (!this.capabilities.promptCaching || breakpoints <= 0) return;
+		return (cacheControl?.ttl ?? this.config.promptCacheTtl) === "1h" && supportsOneHourCacheTtl(this.name) ? {
+			type: "default",
+			ttl: "1h"
+		} : { type: "default" };
+	}
+	/**
+	* Append the call's `cachePoint` to the LAST message. Together with the
+	* `system` and `tools` cache points (see `buildRequest` /
+	* `buildToolConfig`) this caches every stable segment of the prefix —
+	* Bedrock processes them in `tools` → `system` → `messages` order, at
+	* most three of the four checkpoints it allows — so later calls reusing
+	* the prefix bill it at the cache-read rate (`Usage.cachedTokens`).
+	*/
+	applyCacheBreakpoints(messages, cachePoint) {
+		if (!cachePoint || !messages || messages.length === 0) return messages;
 		const last = messages.length - 1;
 		const lastMessage = messages[last];
 		if (!lastMessage) return messages;
 		return [...messages.slice(0, last), {
 			...lastMessage,
-			content: [...lastMessage.content ?? [], { cachePoint: { type: "default" } }]
+			content: [...lastMessage.content ?? [], { cachePoint }]
 		}];
 	}
 	/**
@@ -914,11 +1151,26 @@ var BedrockModel = class {
 	}
 	/**
 	* Spread-friendly tool fragment. Returns an empty object when no
-	* tools were supplied (Bedrock rejects an empty `tools` array).
+	* tools were supplied (Bedrock rejects an empty `tools` array). With a
+	* cache point, a trailing `{ cachePoint }` caches every tool definition
+	* — Claude only, since Nova accepts no cache point in `tools`.
 	*/
-	buildToolConfig(tools) {
+	buildToolConfig(options, cachePoint) {
+		const { tools, definitions } = (0, _warlock_js_ai.selectProviderTools)(options, {
+			accepts: [BEDROCK_WIRE_FORMAT, this.provider],
+			module: LOG_MODULE,
+			model: this.name,
+			logger: this.logger
+		});
 		const toolConfig = toBedrockToolConfig(tools);
-		return toolConfig ? { toolConfig } : {};
+		const providerDefined = definitions;
+		const allTools = [...toolConfig?.tools ?? [], ...providerDefined];
+		if (allTools.length === 0) return toolConfig ? { toolConfig } : {};
+		const withCachePoint = cachePoint && supportsToolCachePoint(this.name) ? [...allTools, { cachePoint }] : allTools;
+		return { toolConfig: {
+			...toolConfig,
+			tools: withCachePoint
+		} };
 	}
 	/**
 	* Translate the neutral `responseSchema` into Converse's native
@@ -956,7 +1208,7 @@ var BedrockModel = class {
 	extractToolCalls(blocks) {
 		const toolCalls = [];
 		const reasoningBlocks = blocks.map(toReasoningMetadata).filter((block) => block !== void 0);
-		for (const block of blocks) if ("toolUse" in block && block.toolUse) toolCalls.push({
+		for (const block of blocks) if ("toolUse" in block && block.toolUse && block.toolUse.type !== SERVER_TOOL_USE) toolCalls.push({
 			id: block.toolUse.toolUseId ?? "",
 			name: block.toolUse.name ?? "",
 			input: block.toolUse.input ?? {},
@@ -976,10 +1228,13 @@ var BedrockModel = class {
 	* Normalize Converse's `TokenUsage` into the neutral `Usage` shape.
 	* Bedrock supplies a pre-summed `totalTokens`; cache-read and
 	* cache-write tokens are surfaced as `cachedTokens` /
-	* `cacheWriteTokens` only when non-zero so callers can price the
-	* discounted read rate and the one-time write cost separately.
-	* Bedrock's Converse `TokenUsage` carries no reasoning-token channel,
-	* so `Usage.reasoningTokens` is intentionally left unset here.
+	* `cacheWriteTokens` only when non-zero, and the 1-hour share of the
+	* writes (`cacheDetails` entries with `ttl: "1h"`) as
+	* `cacheWrite1hTokens`. With caching, `inputTokens` "represents only
+	* the non-cached input tokens" (AWS prompt-caching guide), so the usage
+	* is marked `inputIncludesCache: false`. Bedrock's Converse `TokenUsage`
+	* carries no reasoning-token channel, so `Usage.reasoningTokens` is
+	* intentionally left unset here.
 	*/
 	extractUsage(raw) {
 		if (!raw) return {
@@ -991,12 +1246,15 @@ var BedrockModel = class {
 		const output = raw.outputTokens ?? 0;
 		const cached = raw.cacheReadInputTokens;
 		const cacheWrite = raw.cacheWriteInputTokens;
+		const cacheWrite1h = (raw.cacheDetails ?? []).filter((detail) => detail.ttl === "1h").reduce((sum, detail) => sum + (detail.inputTokens ?? 0), 0);
 		return {
 			input,
 			output,
 			total: raw.totalTokens ?? input + output,
+			inputIncludesCache: false,
 			...cached && cached > 0 ? { cachedTokens: cached } : {},
-			...cacheWrite && cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {}
+			...cacheWrite && cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {},
+			...cacheWrite && cacheWrite > 0 && cacheWrite1h > 0 ? { cacheWrite1hTokens: Math.min(cacheWrite1h, cacheWrite) } : {}
 		};
 	}
 	/**
@@ -1041,11 +1299,15 @@ var BedrockModel = class {
 * const bedrock = new BedrockSDK({ region: "us-east-1" });
 * const model = bedrock.model({ name: "anthropic.claude-sonnet-4-5-20250929-v1:0" });
 * const embedder = bedrock.embedder({ name: "amazon.titan-embed-text-v2:0" });
+*
+* @example
+* // Amazon Bedrock API key (bearer auth) instead of the AWS credential chain
+* const bedrock = new BedrockSDK({ apiKey: process.env.BEDROCK_API_KEY!, region: "us-east-1" });
 */
 var BedrockSDK = class {
 	constructor(config) {
-		const { provider, pricing, ...clientConfig } = config;
-		this.client = new _aws_sdk_client_bedrock_runtime.BedrockRuntimeClient(clientConfig);
+		const { provider, pricing, apiKey, ...clientConfig } = config;
+		this.client = new _aws_sdk_client_bedrock_runtime.BedrockRuntimeClient(apiKey === void 0 ? clientConfig : withApiKey(clientConfig, apiKey));
 		this.provider = provider ?? "bedrock";
 		this.pricing = pricing;
 	}
@@ -1088,7 +1350,38 @@ var BedrockSDK = class {
 		return new BedrockEmbedder(this.client, config, this.provider);
 	}
 };
+/**
+* Configure the runtime client for an Amazon Bedrock API key.
+*
+* Bedrock API keys are bearer tokens: the request carries
+* `Authorization: Bearer <key>` instead of a SigV4 signature (AWS docs,
+* "Use an Amazon Bedrock API key",
+* https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys-use.html,
+* checked 2026-10-17). The installed `@aws-sdk/client-bedrock-runtime`
+* supports this natively: its auth scheme provider offers
+* `smithy.api#httpBearerAuth` beside SigV4, fed by the client's `token`
+* option, and `authSchemePreference: ["httpBearerAuth"]` selects it ahead
+* of SigV4, so the AWS credential chain is never consulted.
+*
+* Fails closed on an empty key, and on a key combined with `credentials`
+* or `token` — two credentials for one client leave which one signs the
+* request ambiguous.
+*/
+function withApiKey(clientConfig, apiKey) {
+	if (typeof apiKey !== "string" || apiKey.trim() === "") throw new _warlock_js_ai.InvalidRequestError("BedrockSDK: `apiKey` must be a non-empty string.");
+	const conflicting = ["credentials", "token"].filter((field) => clientConfig[field] !== void 0);
+	if (conflicting.length > 0) throw new _warlock_js_ai.InvalidRequestError(`BedrockSDK: pass either \`apiKey\` or ${conflicting.map((field) => `\`${field}\``).join(" / ")}, not both.`, { context: { fields: conflicting } });
+	return {
+		...clientConfig,
+		token: { token: apiKey },
+		authSchemePreference: ["httpBearerAuth"]
+	};
+}
 
 //#endregion
+exports.BEDROCK_GLOBAL_PRICING = BEDROCK_GLOBAL_PRICING;
+exports.BEDROCK_US_PRICING = BEDROCK_US_PRICING;
 exports.BedrockSDK = BedrockSDK;
+exports.bedrockPricingFor = bedrockPricingFor;
+exports.withClaudeCacheWriteRates = withClaudeCacheWriteRates;
 //# sourceMappingURL=index.cjs.map