@warlock.js/ai-bedrock 5.29.0 → 5.31.0

package/esm/known-capabilities.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"known-capabilities.mjs","names":[],"sources":["../../../../../../ai-bedrock/src/known-capabilities.ts"],"sourcesContent":["/**\n * Cost-truth capability inference for Bedrock Converse model ids.\n *\n * Bedrock model ids are provider-prefixed and version-suffixed\n * (`anthropic.claude-3-7-sonnet-20250219-v1:0`, `us.amazon.nova-pro-v1:0`),\n * so — exactly like `known-vision-models.ts` — a lowercase substring scan\n * is the only robust check across cross-region inference-profile prefixes\n * (`us.`, `eu.`, `apac.`) and date/version tags.\n *\n * Each predicate answers a single `ModelCapabilities` flag the agent reads\n * to decide whether to forward a cost-truth option (`reasoning`,\n * `cacheControl`) or up-front-reject an attachment (`pdf`). Unknown ids\n * default to `false` so an unsupported request fails fast with a clear\n * capability error instead of an opaque Bedrock `ValidationException`.\n * Every inference is overridable per-model via `bedrock.model({ name, … })`.\n */\n\n/**\n * Families that expose Anthropic-style extended thinking on Bedrock\n * Converse via `additionalModelRequestFields.thinking`. Only Claude 3.7\n * and the Claude 4 line (Sonnet / Opus / Haiku) support a configurable\n * thinking budget; earlier Claude, Nova, Llama, Mistral and Cohere do\n * not, so they are intentionally absent.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\n  \"claude-3-7\",\n  \"claude-sonnet-4\",\n  \"claude-opus-4\",\n  \"claude-haiku-4\",\n];\n\n/**\n * Families that honor Converse `cachePoint` prompt-cache breakpoints.\n * Anthropic Claude 3.5+ / 3.7 / 4 and the Amazon Nova line support\n * cache points; text-only legacy families do not.\n */\nconst PROMPT_CACHING_CAPABLE_SUBSTRINGS = [\n  \"claude-3-5\",\n  \"claude-3-7\",\n  \"claude-sonnet-4\",\n  \"claude-opus-4\",\n  \"claude-haiku-4\",\n  \"nova-lite\",\n  \"nova-pro\",\n  \"nova-premier\",\n  \"nova-micro\",\n];\n\n/**\n * Families that accept Converse `document` content blocks (PDF / docx /\n * txt input). The multimodal Claude 3+ and Nova families support\n * document blocks; the substring set mirrors the vision-capable list\n * minus the image-only Llama entries (Llama on Bedrock takes images but\n * not document blocks via Converse).\n */\nconst PDF_CAPABLE_SUBSTRINGS = [\n  \"claude-3\",\n  \"claude-sonnet-4\",\n  \"claude-opus-4\",\n  \"claude-haiku-4\",\n  \"nova-lite\",\n  \"nova-pro\",\n  \"nova-premier\",\n];\n\nfunction matchesAny(modelId: string, fragments: string[]): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return fragments.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Infer whether a Bedrock model id exposes extended-thinking / reasoning\n * (Claude 3.7 + Claude 4). When true the adapter forwards\n * `ModelCallOptions.reasoning` as Converse\n * `additionalModelRequestFields.thinking`.\n *\n * @example\n * inferReasoningCapability(\"anthropic.claude-3-7-sonnet-20250219-v1:0\"); // → true\n * inferReasoningCapability(\"us.amazon.nova-pro-v1:0\");                    // → false\n */\nexport function inferReasoningCapability(modelId: string): boolean {\n  return matchesAny(modelId, REASONING_CAPABLE_SUBSTRINGS);\n}\n\n/**\n * Infer whether a Bedrock model id honors Converse `cachePoint`\n * breakpoints (Claude 3.5+ / Nova). When true the adapter both maps\n * `ModelCallOptions.cacheControl` write breakpoints to cache points and\n * reports `Usage.cachedTokens` / `Usage.cacheWriteTokens`.\n *\n * @example\n * inferPromptCachingCapability(\"us.amazon.nova-pro-v1:0\");                       // → true\n * inferPromptCachingCapability(\"meta.llama3-1-8b-instruct-v1:0\");                // → false\n */\nexport function inferPromptCachingCapability(modelId: string): boolean {\n  return matchesAny(modelId, PROMPT_CACHING_CAPABLE_SUBSTRINGS);\n}\n\n/**\n * Infer whether a Bedrock model id accepts Converse `document` content\n * blocks (PDF / document input — Claude 3+ / Nova). When false the agent\n * rejects a PDF attachment up front instead of dropping it at the wire.\n *\n * @example\n * inferPdfCapability(\"anthropic.claude-3-5-sonnet-20240620-v1:0\"); // → true\n * inferPdfCapability(\"meta.llama3-2-90b-instruct-v1:0\");           // → false\n */\nexport function inferPdfCapability(modelId: string): boolean {\n  return matchesAny(modelId, PDF_CAPABLE_SUBSTRINGS);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAM,+BAA+B;CACnC;CACA;CACA;CACA;AACF;;;;;;AAOA,MAAM,oCAAoC;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;AASA,MAAM,yBAAyB;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,SAAS,WAAW,SAAiB,WAA8B;CACjE,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,UAAU,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnE;;;;;;;;;;;AAYA,SAAgB,yBAAyB,SAA0B;CACjE,OAAO,WAAW,SAAS,4BAA4B;AACzD;;;;;;;;;;;AAYA,SAAgB,6BAA6B,SAA0B;CACrE,OAAO,WAAW,SAAS,iCAAiC;AAC9D;;;;;;;;;;AAWA,SAAgB,mBAAmB,SAA0B;CAC3D,OAAO,WAAW,SAAS,sBAAsB;AACnD"}
+{"version":3,"file":"known-capabilities.mjs","names":[],"sources":["../../../../../../../packages/ai-bedrock/src/known-capabilities.ts"],"sourcesContent":["/**\n * Cost-truth capability inference for Bedrock Converse model ids.\n *\n * Bedrock model ids are provider-prefixed and version-suffixed\n * (`anthropic.claude-3-7-sonnet-20250219-v1:0`, `us.amazon.nova-pro-v1:0`),\n * so — exactly like `known-vision-models.ts` — a lowercase substring scan\n * is the only robust check across cross-region inference-profile prefixes\n * (`us.`, `eu.`, `apac.`) and date/version tags.\n *\n * Each predicate answers a single `ModelCapabilities` flag the agent reads\n * to decide whether to forward a cost-truth option (`reasoning`,\n * `cacheControl`) or up-front-reject an attachment (`pdf`). Unknown ids\n * default to `false` so an unsupported request fails fast with a clear\n * capability error instead of an opaque Bedrock `ValidationException`.\n * Every inference is overridable per-model via `bedrock.model({ name, … })`.\n */\n\n/**\n * Families that expose Anthropic-style extended thinking on Bedrock\n * Converse via `additionalModelRequestFields.thinking`. Only Claude 3.7\n * and the Claude 4 line (Sonnet / Opus / Haiku) support a configurable\n * thinking budget; earlier Claude, Nova, Llama, Mistral and Cohere do\n * not, so they are intentionally absent.\n */\nconst REASONING_CAPABLE_SUBSTRINGS = [\n  \"claude-3-7\",\n  \"claude-sonnet-4\",\n  \"claude-opus-4\",\n  \"claude-haiku-4\",\n];\n\n/**\n * Families that honor Converse `cachePoint` prompt-cache breakpoints.\n * Anthropic Claude 3.5+ / 3.7 / 4 / 5 and the Amazon Nova line support\n * cache points; text-only legacy families do not. Per the \"Supported\n * models\" table of https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html\n * (checked 2026-10-17).\n */\nconst PROMPT_CACHING_CAPABLE_SUBSTRINGS = [\n  \"claude-3-5\",\n  \"claude-3-7\",\n  \"claude-sonnet-4\",\n  \"claude-opus-4\",\n  \"claude-haiku-4\",\n  \"claude-sonnet-5\",\n  \"claude-opus-5\",\n  \"claude-haiku-5\",\n  \"claude-fable-5\",\n  \"claude-mythos-5\",\n  \"nova-2-lite\",\n  \"nova-lite\",\n  \"nova-pro\",\n  \"nova-premier\",\n  \"nova-micro\",\n];\n\n/**\n * Families that accept Converse `document` content blocks (PDF / docx /\n * txt input). The multimodal Claude 3+ and Nova families support\n * document blocks; the substring set mirrors the vision-capable list\n * minus the image-only Llama entries (Llama on Bedrock takes images but\n * not document blocks via Converse).\n */\nconst PDF_CAPABLE_SUBSTRINGS = [\n  \"claude-3\",\n  \"claude-sonnet-4\",\n  \"claude-opus-4\",\n  \"claude-haiku-4\",\n  \"nova-lite\",\n  \"nova-pro\",\n  \"nova-premier\",\n];\n\nfunction matchesAny(modelId: string, fragments: string[]): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return fragments.some((fragment) => normalized.includes(fragment));\n}\n\n/**\n * Infer whether a Bedrock model id exposes extended-thinking / reasoning\n * (Claude 3.7 + Claude 4). When true the adapter forwards\n * `ModelCallOptions.reasoning` as Converse\n * `additionalModelRequestFields.thinking`.\n *\n * @example\n * inferReasoningCapability(\"anthropic.claude-3-7-sonnet-20250219-v1:0\"); // → true\n * inferReasoningCapability(\"us.amazon.nova-pro-v1:0\");                    // → false\n */\nexport function inferReasoningCapability(modelId: string): boolean {\n  return matchesAny(modelId, REASONING_CAPABLE_SUBSTRINGS);\n}\n\n/**\n * Infer whether a Bedrock model id honors Converse `cachePoint`\n * breakpoints (Claude 3.5+ / Nova). When true the adapter both maps\n * `ModelCallOptions.cacheControl` write breakpoints to cache points and\n * reports `Usage.cachedTokens` / `Usage.cacheWriteTokens`.\n *\n * @example\n * inferPromptCachingCapability(\"us.amazon.nova-pro-v1:0\");                       // → true\n * inferPromptCachingCapability(\"meta.llama3-1-8b-instruct-v1:0\");                // → false\n */\nexport function inferPromptCachingCapability(modelId: string): boolean {\n  return matchesAny(modelId, PROMPT_CACHING_CAPABLE_SUBSTRINGS);\n}\n\n/**\n * Infer whether a Bedrock model id accepts Converse `document` content\n * blocks (PDF / document input — Claude 3+ / Nova). When false the agent\n * rejects a PDF attachment up front instead of dropping it at the wire.\n *\n * @example\n * inferPdfCapability(\"anthropic.claude-3-5-sonnet-20240620-v1:0\"); // → true\n * inferPdfCapability(\"meta.llama3-2-90b-instruct-v1:0\");           // → false\n */\nexport function inferPdfCapability(modelId: string): boolean {\n  return matchesAny(modelId, PDF_CAPABLE_SUBSTRINGS);\n}\n\n/**\n * Claude on Bedrock accepts a `cachePoint` in `system`, `messages` and\n * `tools`; Amazon Nova accepts one only in `system` and `messages`\n * (https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html,\n * \"Fields that accept prompt cache checkpoints\", checked 2026-10-17).\n * Unknown families get no tool cache point.\n *\n * @example\n * supportsToolCachePoint(\"global.anthropic.claude-sonnet-4-6\"); // true\n * supportsToolCachePoint(\"amazon.nova-pro-v1:0\"); // false\n */\nexport function supportsToolCachePoint(modelId: string): boolean {\n  return modelId.toLowerCase().includes(\"anthropic.claude\");\n}\n\n/** Claude families whose cache points accept the 1-hour TTL. */\nconst ONE_HOUR_TTL_PATTERN =\n  /anthropic\\.claude-(?:(?:opus|sonnet|haiku|fable|mythos)-5|opus-4-[5-9]|sonnet-4-[5-9]|haiku-4-5)/;\n\n/**\n * Claude models whose Converse `cachePoint` accepts `ttl: \"1h\"`: Claude\n * Haiku 4.5, the 4.5+ Sonnet / Opus line and every Claude 5 family. Any\n * other model gets no `ttl` field (the 5-minute default), since AWS\n * warns that sending it to a 5-minute-only model \"can result in a\n * ValidationException\" (same page, checked 2026-10-17).\n *\n * @example\n * supportsOneHourCacheTtl(\"anthropic.claude-haiku-4-5-20251001-v1:0\"); // true\n * supportsOneHourCacheTtl(\"anthropic.claude-3-7-sonnet-20250219-v1:0\"); // false\n */\nexport function supportsOneHourCacheTtl(modelId: string): boolean {\n  return ONE_HOUR_TTL_PATTERN.test(modelId.toLowerCase());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAM,+BAA+B;CACnC;CACA;CACA;CACA;AACF;;;;;;;;AASA,MAAM,oCAAoC;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;AASA,MAAM,yBAAyB;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,SAAS,WAAW,SAAiB,WAA8B;CACjE,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,UAAU,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnE;;;;;;;;;;;AAYA,SAAgB,yBAAyB,SAA0B;CACjE,OAAO,WAAW,SAAS,4BAA4B;AACzD;;;;;;;;;;;AAYA,SAAgB,6BAA6B,SAA0B;CACrE,OAAO,WAAW,SAAS,iCAAiC;AAC9D;;;;;;;;;;AAWA,SAAgB,mBAAmB,SAA0B;CAC3D,OAAO,WAAW,SAAS,sBAAsB;AACnD;;;;;;;;;;;;AAaA,SAAgB,uBAAuB,SAA0B;CAC/D,OAAO,QAAQ,YAAY,CAAC,CAAC,SAAS,kBAAkB;AAC1D;;AAGA,MAAM,uBACJ;;;;;;;;;;;;AAaF,SAAgB,wBAAwB,SAA0B;CAChE,OAAO,qBAAqB,KAAK,QAAQ,YAAY,CAAC;AACxD"}

package/esm/known-pricing.d.mts

@@ -0,0 +1,48 @@
+import { ModelPricing } from "@warlock.js/ai";
+
+//#region ../../packages/ai-bedrock/src/known-pricing.d.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.
+ */
+declare const BEDROCK_GLOBAL_PRICING: Readonly<Record<string, ModelPricing>>;
+/** `us.` geographic-profile prices — see {@link BEDROCK_GLOBAL_PRICING}. */
+declare const BEDROCK_US_PRICING: Readonly<Record<string, ModelPricing>>;
+/**
+ * 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
+ */
+declare function bedrockPricingFor(modelId: string): ModelPricing | undefined;
+/**
+ * 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.
+ */
+declare function withClaudeCacheWriteRates(modelId: string, pricing: ModelPricing | undefined): ModelPricing | undefined;
+//#endregion
+export { BEDROCK_GLOBAL_PRICING, BEDROCK_US_PRICING, bedrockPricingFor, withClaudeCacheWriteRates };
+//# sourceMappingURL=known-pricing.d.mts.map

package/esm/known-pricing.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-pricing.d.mts","names":[],"sources":["../../../../../../../packages/ai-bedrock/src/known-pricing.ts"],"mappings":";;;;;AAwBA;;;;;;;;;;;;AAAyE;AAiBzE;;;;;;;cAjBa,sBAAA,EAAwB,QAAA,CAAS,MAAA,SAAe,YAAA;;cAiBhD,kBAAA,EAAoB,QAAA,CAAS,MAAA,SAAe,YAAA;;;AAAY;AAyBrE;;;;AAAgE;AAkBhE;iBAlBgB,iBAAA,CAAkB,OAAA,WAAkB,YAAY;;;;;;;iBAkBhD,yBAAA,CACd,OAAA,UACA,OAAA,EAAS,YAAA,eACR,YAAY"}

package/esm/known-pricing.mjs

@@ -0,0 +1,99 @@
+//#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
+export { BEDROCK_GLOBAL_PRICING, BEDROCK_US_PRICING, bedrockPricingFor, withClaudeCacheWriteRates };
+//# sourceMappingURL=known-pricing.mjs.map

package/esm/known-pricing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-pricing.mjs","names":[],"sources":["../../../../../../../packages/ai-bedrock/src/known-pricing.ts"],"sourcesContent":["import type { ModelPricing } from \"@warlock.js/ai\";\n\n/**\n * Bedrock on-demand list prices for Anthropic Claude, USD per 1,000,000\n * tokens, keyed by Bedrock model id (without an inference-profile\n * prefix). `cacheWrite` is the 5-minute write rate, `cacheWrite1h` the\n * 1-hour write rate, `cachedInput` the cache-read rate.\n *\n * Source: https://aws.amazon.com/bedrock/pricing/ — the page's own price\n * feed for \"US East (N. Virginia)\", fetched 2026-10-17 (Sonnet 5.5 cache\n * reads already at the rate effective 2026-10-07). Model ids from\n * https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html.\n *\n * Two tables, because AWS prices them differently:\n * - {@link BEDROCK_GLOBAL_PRICING} — `global.` cross-Region inference\n *   profiles.\n * - {@link BEDROCK_US_PRICING} — `us.` geographic profiles (the\n *   \"Geo / In-region\" rates, 10% above global for these models).\n *\n * In-Region ids without a profile prefix, other geographies (`eu.`,\n * `apac.`, …), Claude Haiku 5.5 and non-Claude models stay unpriced —\n * their rates vary by Region or were not verified — so pass `pricing`\n * yourself for them.\n */\nexport const BEDROCK_GLOBAL_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"anthropic.claude-sonnet-5-5\": claude(2, 10, 0.1),\n  \"anthropic.claude-opus-5-5\": claude(4, 20, 0.2),\n  \"anthropic.claude-fable-5-1\": claude(10, 50, 0.25),\n  \"anthropic.claude-opus-5\": claude(5, 25, 0.5),\n  \"anthropic.claude-sonnet-5\": claude(2, 10, 0.2),\n  \"anthropic.claude-fable-5\": claude(10, 50, 1),\n  \"anthropic.claude-opus-4-8\": claude(5, 25, 0.5),\n  \"anthropic.claude-opus-4-7\": claude(5, 25, 0.5),\n  \"anthropic.claude-opus-4-6-v1\": claude(5, 25, 0.5),\n  \"anthropic.claude-sonnet-4-6\": claude(3, 15, 0.3),\n  \"anthropic.claude-opus-4-5-20251101-v1:0\": claude(5, 25, 0.5),\n  \"anthropic.claude-sonnet-4-5-20250929-v1:0\": claude(3, 15, 0.3),\n  \"anthropic.claude-haiku-4-5-20251001-v1:0\": claude(1, 5, 0.1),\n};\n\n/** `us.` geographic-profile prices — see {@link BEDROCK_GLOBAL_PRICING}. */\nexport const BEDROCK_US_PRICING: Readonly<Record<string, ModelPricing>> = {\n  \"anthropic.claude-sonnet-5-5\": claude(2.2, 11, 0.11),\n  \"anthropic.claude-opus-5-5\": claude(4.4, 22, 0.22),\n  \"anthropic.claude-fable-5-1\": claude(11, 55, 0.275),\n  \"anthropic.claude-opus-5\": claude(5.5, 27.5, 0.55),\n  \"anthropic.claude-sonnet-5\": claude(2.2, 11, 0.22),\n  \"anthropic.claude-fable-5\": claude(11, 55, 1.1),\n  \"anthropic.claude-opus-4-8\": claude(5.5, 27.5, 0.55),\n  \"anthropic.claude-opus-4-7\": claude(5.5, 27.5, 0.55),\n  \"anthropic.claude-opus-4-6-v1\": claude(5.5, 27.5, 0.55),\n  \"anthropic.claude-sonnet-4-6\": claude(3.3, 16.5, 0.33),\n  \"anthropic.claude-opus-4-5-20251101-v1:0\": claude(5.5, 27.5, 0.55),\n  \"anthropic.claude-sonnet-4-5-20250929-v1:0\": claude(3.3, 16.5, 0.33),\n  \"anthropic.claude-haiku-4-5-20251001-v1:0\": claude(1.1, 5.5, 0.11),\n};\n\n/**\n * Look up the built-in price for a Bedrock model id or inference-profile\n * id: `global.<model>` reads {@link BEDROCK_GLOBAL_PRICING}, `us.<model>`\n * reads {@link BEDROCK_US_PRICING}; anything else is `undefined`.\n *\n * @example\n * bedrockPricingFor(\"global.anthropic.claude-sonnet-4-6\"); // { input: 3, output: 15, … }\n * bedrockPricingFor(\"anthropic.claude-sonnet-4-6\"); // undefined — in-Region rates vary\n */\nexport function bedrockPricingFor(modelId: string): ModelPricing | undefined {\n  if (modelId.startsWith(\"global.\")) {\n    return BEDROCK_GLOBAL_PRICING[modelId.slice(\"global.\".length)];\n  }\n\n  if (modelId.startsWith(\"us.\")) {\n    return BEDROCK_US_PRICING[modelId.slice(\"us.\".length)];\n  }\n\n  return undefined;\n}\n\n/**\n * Fill the Claude cache-write rates (5-minute 1.25x, 1-hour 2x the input\n * rate — the ratio of every Claude row in the tables above) into a\n * caller-supplied entry for a Claude model that omits them. Non-Claude\n * models are returned unchanged.\n */\nexport function withClaudeCacheWriteRates(\n  modelId: string,\n  pricing: ModelPricing | undefined,\n): ModelPricing | undefined {\n  if (!pricing || !modelId.toLowerCase().includes(\"anthropic.claude\")) {\n    return pricing;\n  }\n\n  if (pricing.cacheWrite !== undefined && pricing.cacheWrite1h !== undefined) {\n    return pricing;\n  }\n\n  return {\n    ...pricing,\n    cacheWrite: pricing.cacheWrite ?? pricing.cachedOutput ?? round(pricing.input * 1.25),\n    cacheWrite1h: pricing.cacheWrite1h ?? round(pricing.input * 2),\n  };\n}\n\nfunction claude(input: number, output: number, cachedInput: number): ModelPricing {\n  return {\n    input,\n    output,\n    cachedInput,\n    cacheWrite: round(input * 1.25),\n    cacheWrite1h: round(input * 2),\n  };\n}\n\n/** Trim binary floating-point noise (2.2 * 1.25 = 2.7500000000000004). */\nfunction round(value: number): number {\n  return Math.round(value * 1e9) / 1e9;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,yBAAiE;CAC5E,+BAA+B,OAAO,GAAG,IAAI,EAAG;CAChD,6BAA6B,OAAO,GAAG,IAAI,EAAG;CAC9C,8BAA8B,OAAO,IAAI,IAAI,GAAI;CACjD,2BAA2B,OAAO,GAAG,IAAI,EAAG;CAC5C,6BAA6B,OAAO,GAAG,IAAI,EAAG;CAC9C,4BAA4B,OAAO,IAAI,IAAI,CAAC;CAC5C,6BAA6B,OAAO,GAAG,IAAI,EAAG;CAC9C,6BAA6B,OAAO,GAAG,IAAI,EAAG;CAC9C,gCAAgC,OAAO,GAAG,IAAI,EAAG;CACjD,+BAA+B,OAAO,GAAG,IAAI,EAAG;CAChD,2CAA2C,OAAO,GAAG,IAAI,EAAG;CAC5D,6CAA6C,OAAO,GAAG,IAAI,EAAG;CAC9D,4CAA4C,OAAO,GAAG,GAAG,EAAG;AAC9D;;AAGA,MAAa,qBAA6D;CACxE,+BAA+B,OAAO,KAAK,IAAI,GAAI;CACnD,6BAA6B,OAAO,KAAK,IAAI,GAAI;CACjD,8BAA8B,OAAO,IAAI,IAAI,IAAK;CAClD,2BAA2B,OAAO,KAAK,MAAM,GAAI;CACjD,6BAA6B,OAAO,KAAK,IAAI,GAAI;CACjD,4BAA4B,OAAO,IAAI,IAAI,GAAG;CAC9C,6BAA6B,OAAO,KAAK,MAAM,GAAI;CACnD,6BAA6B,OAAO,KAAK,MAAM,GAAI;CACnD,gCAAgC,OAAO,KAAK,MAAM,GAAI;CACtD,+BAA+B,OAAO,KAAK,MAAM,GAAI;CACrD,2CAA2C,OAAO,KAAK,MAAM,GAAI;CACjE,6CAA6C,OAAO,KAAK,MAAM,GAAI;CACnE,4CAA4C,OAAO,KAAK,KAAK,GAAI;AACnE;;;;;;;;;;AAWA,SAAgB,kBAAkB,SAA2C;CAC3E,IAAI,QAAQ,WAAW,SAAS,GAC9B,OAAO,uBAAuB,QAAQ,MAAM,CAAgB;CAG9D,IAAI,QAAQ,WAAW,KAAK,GAC1B,OAAO,mBAAmB,QAAQ,MAAM,CAAY;AAIxD;;;;;;;AAQA,SAAgB,0BACd,SACA,SAC0B;CAC1B,IAAI,CAAC,WAAW,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,kBAAkB,GAChE,OAAO;CAGT,IAAI,QAAQ,eAAe,UAAa,QAAQ,iBAAiB,QAC/D,OAAO;CAGT,OAAO;EACL,GAAG;EACH,YAAY,QAAQ,cAAc,QAAQ,gBAAgB,MAAM,QAAQ,QAAQ,IAAI;EACpF,cAAc,QAAQ,gBAAgB,MAAM,QAAQ,QAAQ,CAAC;CAC/D;AACF;AAEA,SAAS,OAAO,OAAe,QAAgB,aAAmC;CAChF,OAAO;EACL;EACA;EACA;EACA,YAAY,MAAM,QAAQ,IAAI;EAC9B,cAAc,MAAM,QAAQ,CAAC;CAC/B;AACF;;AAGA,SAAS,MAAM,OAAuB;CACpC,OAAO,KAAK,MAAM,QAAQ,GAAG,IAAI;AACnC"}

package/esm/known-vision-models.mjs

@@ -1,4 +1,4 @@
-//#region ../ai-bedrock/src/known-vision-models.ts
+//#region ../../packages/ai-bedrock/src/known-vision-models.ts
 /**
 * Substrings that identify Bedrock model ids whose family accepts image
 * input on the Converse API.

package/esm/known-vision-models.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"known-vision-models.mjs","names":[],"sources":["../../../../../../ai-bedrock/src/known-vision-models.ts"],"sourcesContent":["/**\n * Substrings that identify Bedrock model ids whose family accepts image\n * input on the Converse API.\n *\n * Bedrock model ids are provider-prefixed and version-suffixed\n * (`anthropic.claude-3-5-sonnet-20240620-v1:0`, `us.amazon.nova-pro-v1:0`,\n * `meta.llama3-2-90b-instruct-v1:0`), so a substring match is the only\n * robust check across the cross-region inference-profile prefixes\n * (`us.`, `eu.`, `apac.`) and date/version tags.\n *\n * Multimodal families covered: Anthropic Claude 3 / 3.5 / 3.7 / 4,\n * Amazon Nova Lite/Pro/Premier, Meta Llama 3.2 (11B/90B) and Llama 4.\n * Text-only families (Llama 3/3.1, Titan Text, Mistral 7B, Cohere\n * Command) are intentionally absent. Override per-model via\n * `bedrock.model({ name, vision: true | false })`.\n */\nconst VISION_CAPABLE_SUBSTRINGS = [\n  \"claude-3\",\n  \"claude-sonnet-4\",\n  \"claude-opus-4\",\n  \"claude-haiku-4\",\n  \"nova-lite\",\n  \"nova-pro\",\n  \"nova-premier\",\n  \"llama3-2-11b\",\n  \"llama3-2-90b\",\n  \"llama4\",\n];\n\n/**\n * Infer whether a Bedrock model id supports vision based on the known\n * multimodal-family substrings. Unknown ids default to `false` so that\n * passing an image attachment to an unsupported model surfaces a clear,\n * agent-side capability error instead of an opaque Bedrock validation\n * fault.\n *\n * @example\n * inferVisionCapability(\"anthropic.claude-3-5-sonnet-20240620-v1:0\"); // → true\n * inferVisionCapability(\"us.amazon.nova-pro-v1:0\");                    // → true\n * inferVisionCapability(\"meta.llama3-1-8b-instruct-v1:0\");             // → false\n * inferVisionCapability(\"amazon.titan-text-express-v1\");               // → false\n */\nexport function inferVisionCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAM,4BAA4B;CAChC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,SAAgB,sBAAsB,SAA0B;CAC9D,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF"}
+{"version":3,"file":"known-vision-models.mjs","names":[],"sources":["../../../../../../../packages/ai-bedrock/src/known-vision-models.ts"],"sourcesContent":["/**\n * Substrings that identify Bedrock model ids whose family accepts image\n * input on the Converse API.\n *\n * Bedrock model ids are provider-prefixed and version-suffixed\n * (`anthropic.claude-3-5-sonnet-20240620-v1:0`, `us.amazon.nova-pro-v1:0`,\n * `meta.llama3-2-90b-instruct-v1:0`), so a substring match is the only\n * robust check across the cross-region inference-profile prefixes\n * (`us.`, `eu.`, `apac.`) and date/version tags.\n *\n * Multimodal families covered: Anthropic Claude 3 / 3.5 / 3.7 / 4,\n * Amazon Nova Lite/Pro/Premier, Meta Llama 3.2 (11B/90B) and Llama 4.\n * Text-only families (Llama 3/3.1, Titan Text, Mistral 7B, Cohere\n * Command) are intentionally absent. Override per-model via\n * `bedrock.model({ name, vision: true | false })`.\n */\nconst VISION_CAPABLE_SUBSTRINGS = [\n  \"claude-3\",\n  \"claude-sonnet-4\",\n  \"claude-opus-4\",\n  \"claude-haiku-4\",\n  \"nova-lite\",\n  \"nova-pro\",\n  \"nova-premier\",\n  \"llama3-2-11b\",\n  \"llama3-2-90b\",\n  \"llama4\",\n];\n\n/**\n * Infer whether a Bedrock model id supports vision based on the known\n * multimodal-family substrings. Unknown ids default to `false` so that\n * passing an image attachment to an unsupported model surfaces a clear,\n * agent-side capability error instead of an opaque Bedrock validation\n * fault.\n *\n * @example\n * inferVisionCapability(\"anthropic.claude-3-5-sonnet-20240620-v1:0\"); // → true\n * inferVisionCapability(\"us.amazon.nova-pro-v1:0\");                    // → true\n * inferVisionCapability(\"meta.llama3-1-8b-instruct-v1:0\");             // → false\n * inferVisionCapability(\"amazon.titan-text-express-v1\");               // → false\n */\nexport function inferVisionCapability(modelId: string): boolean {\n  const normalized = modelId.toLowerCase();\n\n  return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAM,4BAA4B;CAChC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,SAAgB,sBAAsB,SAA0B;CAC9D,MAAM,aAAa,QAAQ,YAAY;CAEvC,OAAO,0BAA0B,MAAM,aAAa,WAAW,SAAS,QAAQ,CAAC;AACnF"}

package/esm/model.mjs

@@ -4,14 +4,20 @@ import { toBedrockMessages } from "./utils/to-bedrock-messages.mjs";
 import { toBedrockToolConfig } from "./utils/to-bedrock-tools.mjs";
 import { wrapBedrockError } from "./utils/wrap-bedrock-error.mjs";
 import "./utils/index.mjs";
-import { inferPdfCapability, inferPromptCachingCapability, inferReasoningCapability } from "./known-capabilities.mjs";
+import { mergeProviderBody } from "./provider-options.mjs";
+import { inferPdfCapability, inferPromptCachingCapability, inferReasoningCapability, supportsOneHourCacheTtl, supportsToolCachePoint } from "./known-capabilities.mjs";
+import { bedrockPricingFor, withClaudeCacheWriteRates } from "./known-pricing.mjs";
 import { inferVisionCapability } from "./known-vision-models.mjs";
-import { ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
-import { safeJsonParse } from "@warlock.js/ai";
+import { ConverseCommand, ConverseStreamCommand, CountTokensCommand } from "@aws-sdk/client-bedrock-runtime";
+import { InvalidRequestError, attachCost, resolveStreamChunks, safeJsonParse, selectProviderTools } from "@warlock.js/ai";
 import { log } from "@warlock.js/logger";
 
-//#region ../ai-bedrock/src/model.ts
+//#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;
@@ -72,7 +78,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),
@@ -103,7 +109,7 @@ var BedrockModel = class {
 		}
 		const blocks = response.output?.message?.content ?? [];
 		const finishReason = mapStopReason(response.stopReason);
-		const usage = this.extractUsage(response.usage);
+		const usage = attachCost(this.extractUsage(response.usage), this.pricing);
 		const toolCalls = this.extractToolCalls(blocks);
 		this.logger.debug(LOG_MODULE, "response", "Converse call succeeded", {
 			finishReason,
@@ -116,11 +122,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 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 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", {
@@ -136,11 +167,12 @@ var BedrockModel = class {
 			throw this.logAndWrap(thrown);
 		}
 		let rawStopReason;
-		const usage = {
+		let usage = {
 			input: 0,
 			output: 0,
 			total: 0
 		};
+		const want = resolveStreamChunks(options);
 		const toolBlocks = /* @__PURE__ */ new Map();
 		const reasoningBlocks = /* @__PURE__ */ new Map();
 		const completedReasoningBlocks = [];
@@ -148,6 +180,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 ?? "",
@@ -163,11 +196,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);
@@ -196,19 +243,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);
+		attachCost(usage, this.pricing);
 		this.logger.debug(LOG_MODULE, "response", "ConverseStream call succeeded", {
 			finishReason,
 			usage
@@ -231,44 +272,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 }]
 		}];
 	}
 	/**
@@ -304,11 +359,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 } = 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
@@ -346,7 +416,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 ?? {},
@@ -366,10 +436,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 {
@@ -381,12 +454,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) } : {}
 		};
 	}
 	/**