@openclaw/amazon-bedrock-provider 2026.5.12-beta.7

package/dist/embedding-provider.js

@@ -0,0 +1,270 @@
+import { refreshAwsSharedConfigCacheForBedrock } from "./aws-credential-refresh.js";
+import { debugEmbeddingsLog, sanitizeAndNormalizeEmbedding } from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/amazon-bedrock/embedding-provider.ts
+const DEFAULT_BEDROCK_EMBEDDING_MODEL = "amazon.titan-embed-text-v2:0";
+const MODELS = {
+	"amazon.titan-embed-text-v2:0": {
+		maxTokens: 8192,
+		dims: 1024,
+		validDims: [
+			256,
+			512,
+			1024
+		],
+		family: "titan-v2"
+	},
+	"amazon.titan-embed-text-v1": {
+		maxTokens: 8e3,
+		dims: 1536,
+		family: "titan-v1"
+	},
+	"amazon.titan-embed-g1-text-02": {
+		maxTokens: 8e3,
+		dims: 1536,
+		family: "titan-v1"
+	},
+	"amazon.titan-embed-image-v1": {
+		maxTokens: 128,
+		dims: 1024,
+		family: "titan-v1"
+	},
+	"cohere.embed-english-v3": {
+		maxTokens: 512,
+		dims: 1024,
+		family: "cohere-v3"
+	},
+	"cohere.embed-multilingual-v3": {
+		maxTokens: 512,
+		dims: 1024,
+		family: "cohere-v3"
+	},
+	"cohere.embed-v4:0": {
+		maxTokens: 128e3,
+		dims: 1536,
+		validDims: [
+			256,
+			384,
+			512,
+			768,
+			1024,
+			1536
+		],
+		family: "cohere-v4"
+	},
+	"amazon.nova-2-multimodal-embeddings-v1:0": {
+		maxTokens: 8192,
+		dims: 1024,
+		validDims: [
+			256,
+			384,
+			1024,
+			3072
+		],
+		family: "nova"
+	},
+	"twelvelabs.marengo-embed-2-7-v1:0": {
+		maxTokens: 512,
+		dims: 1024,
+		family: "twelvelabs"
+	},
+	"twelvelabs.marengo-embed-3-0-v1:0": {
+		maxTokens: 512,
+		dims: 512,
+		family: "twelvelabs"
+	}
+};
+/** Resolve spec, stripping throughput suffixes like `:2:8k` or `:0:512`. */
+function resolveSpec(modelId) {
+	if (MODELS[modelId]) return MODELS[modelId];
+	const parts = modelId.split(":");
+	for (let i = parts.length - 1; i >= 1; i--) {
+		const spec = MODELS[parts.slice(0, i).join(":")];
+		if (spec) return spec;
+	}
+}
+/** Infer family from model ID prefix when not in catalog. */
+function inferFamily(modelId) {
+	const id = normalizeLowercaseStringOrEmpty(modelId);
+	if (id.startsWith("amazon.titan-embed-text-v2")) return "titan-v2";
+	if (id.startsWith("amazon.titan-embed")) return "titan-v1";
+	if (id.startsWith("amazon.nova")) return "nova";
+	if (id.startsWith("cohere.embed-v4")) return "cohere-v4";
+	if (id.startsWith("cohere.embed")) return "cohere-v3";
+	if (id.startsWith("twelvelabs.")) return "twelvelabs";
+	return "titan-v1";
+}
+let sdkCache = null;
+let credentialProviderSdkCache;
+async function loadSdk() {
+	if (sdkCache) return sdkCache;
+	try {
+		sdkCache = await import("@aws-sdk/client-bedrock-runtime");
+		return sdkCache;
+	} catch {
+		throw new Error("No API key found for provider bedrock: @aws-sdk/client-bedrock-runtime is not installed. Install it with: npm install @aws-sdk/client-bedrock-runtime");
+	}
+}
+async function loadCredentialProviderSdk() {
+	if (credentialProviderSdkCache !== void 0) return credentialProviderSdkCache;
+	try {
+		credentialProviderSdkCache = await import("@aws-sdk/credential-provider-node");
+	} catch {
+		credentialProviderSdkCache = null;
+	}
+	return credentialProviderSdkCache;
+}
+const MODEL_PREFIX_RE = /^(?:bedrock|amazon-bedrock|aws)\//;
+const REGION_RE = /bedrock-runtime\.([a-z0-9-]+)\./;
+function normalizeBedrockEmbeddingModel(model) {
+	const trimmed = model.trim();
+	return trimmed ? trimmed.replace(MODEL_PREFIX_RE, "") : DEFAULT_BEDROCK_EMBEDDING_MODEL;
+}
+function regionFromUrl(url) {
+	return url?.trim() ? REGION_RE.exec(url)?.[1] : void 0;
+}
+function buildBody(family, text, dims) {
+	switch (family) {
+		case "titan-v2": {
+			const b = { inputText: text };
+			if (dims != null) {
+				b.dimensions = dims;
+				b.normalize = true;
+			}
+			return JSON.stringify(b);
+		}
+		case "titan-v1": return JSON.stringify({ inputText: text });
+		case "nova": return JSON.stringify({
+			taskType: "SINGLE_EMBEDDING",
+			singleEmbeddingParams: {
+				embeddingPurpose: "GENERIC_INDEX",
+				embeddingDimension: dims ?? 1024,
+				text: {
+					truncationMode: "END",
+					value: text
+				}
+			}
+		});
+		case "twelvelabs": return JSON.stringify({
+			inputType: "text",
+			text: { inputText: text }
+		});
+		default: return JSON.stringify({ inputText: text });
+	}
+}
+function buildCohereBody(family, texts, inputType, dims) {
+	const body = {
+		texts,
+		input_type: inputType,
+		truncate: "END"
+	};
+	if (family === "cohere-v4") {
+		body.embedding_types = ["float"];
+		if (dims != null) body.output_dimension = dims;
+	}
+	return JSON.stringify(body);
+}
+function parseSingle(family, raw) {
+	const data = JSON.parse(raw);
+	switch (family) {
+		case "nova": return data.embeddings?.[0]?.embedding ?? [];
+		case "twelvelabs":
+			if (Array.isArray(data.data)) return data.data[0]?.embedding ?? [];
+			if (Array.isArray(data.data?.embedding)) return data.data.embedding;
+			return data.embedding ?? [];
+		default: return data.embedding ?? [];
+	}
+}
+function parseCohereBatch(family, raw) {
+	const embeddings = JSON.parse(raw).embeddings;
+	if (!embeddings) return [];
+	if (family === "cohere-v4" && !Array.isArray(embeddings)) return embeddings.float ?? [];
+	return embeddings;
+}
+async function createBedrockEmbeddingProvider(options) {
+	const client = resolveBedrockEmbeddingClient(options);
+	const { BedrockRuntimeClient, InvokeModelCommand } = await loadSdk();
+	const spec = resolveSpec(client.model);
+	const family = spec?.family ?? inferFamily(client.model);
+	debugEmbeddingsLog("memory embeddings: bedrock client", {
+		region: client.region,
+		model: client.model,
+		dimensions: client.dimensions,
+		family
+	});
+	const invoke = async (body) => {
+		await refreshAwsSharedConfigCacheForBedrock();
+		const sdk = new BedrockRuntimeClient({ region: client.region });
+		try {
+			const res = await sdk.send(new InvokeModelCommand({
+				modelId: client.model,
+				body,
+				contentType: "application/json",
+				accept: "application/json"
+			}));
+			return new TextDecoder().decode(res.body);
+		} finally {
+			sdk.destroy();
+		}
+	};
+	const isCohere = family === "cohere-v3" || family === "cohere-v4";
+	const embedSingle = async (text) => {
+		return sanitizeAndNormalizeEmbedding(parseSingle(family, await invoke(buildBody(family, text, client.dimensions))));
+	};
+	const embedCohere = async (texts, inputType) => {
+		return parseCohereBatch(family, await invoke(buildCohereBody(family, texts, inputType, client.dimensions))).map((e) => sanitizeAndNormalizeEmbedding(e));
+	};
+	const embedQuery = async (text) => {
+		if (!text.trim()) return [];
+		if (isCohere) return (await embedCohere([text], "search_query"))[0] ?? [];
+		return embedSingle(text);
+	};
+	const embedBatch = async (texts) => {
+		if (texts.length === 0) return [];
+		if (isCohere) return embedCohere(texts, "search_document");
+		return Promise.all(texts.map((t) => t.trim() ? embedSingle(t) : Promise.resolve([])));
+	};
+	return {
+		provider: {
+			id: "bedrock",
+			model: client.model,
+			maxInputTokens: spec?.maxTokens,
+			embedQuery,
+			embedBatch
+		},
+		client
+	};
+}
+function resolveBedrockEmbeddingClient(options) {
+	const model = normalizeBedrockEmbeddingModel(options.model);
+	const spec = resolveSpec(model);
+	const providerConfig = options.config.models?.providers?.["amazon-bedrock"];
+	const region = regionFromUrl(options.remote?.baseUrl) ?? regionFromUrl(providerConfig?.baseUrl) ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1";
+	let dimensions;
+	if (options.outputDimensionality != null) {
+		if (spec?.validDims && !spec.validDims.includes(options.outputDimensionality)) throw new Error(`Invalid dimensions ${options.outputDimensionality} for ${model}. Valid values: ${spec.validDims.join(", ")}`);
+		dimensions = options.outputDimensionality;
+	} else dimensions = spec?.dims;
+	return {
+		region,
+		model,
+		dimensions
+	};
+}
+async function hasAwsCredentials(env = process.env, loadCredentialProvider = loadCredentialProviderSdk) {
+	if (env.AWS_ACCESS_KEY_ID?.trim() && env.AWS_SECRET_ACCESS_KEY?.trim()) return true;
+	if (env.AWS_BEARER_TOKEN_BEDROCK?.trim()) return true;
+	const credentialProviderSdk = await loadCredentialProvider();
+	if (!credentialProviderSdk) return false;
+	try {
+		const credentials = await credentialProviderSdk.defaultProvider({
+			timeout: 1e3,
+			maxRetries: 0
+		})();
+		return typeof credentials.accessKeyId === "string" && credentials.accessKeyId.trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { DEFAULT_BEDROCK_EMBEDDING_MODEL, createBedrockEmbeddingProvider, hasAwsCredentials };

package/dist/index.js

@@ -0,0 +1,13 @@
+import { registerAmazonBedrockPlugin } from "./register.sync.runtime.js";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+//#region extensions/amazon-bedrock/index.ts
+var amazon_bedrock_default = definePluginEntry({
+	id: "amazon-bedrock",
+	name: "Amazon Bedrock Provider",
+	description: "Bundled Amazon Bedrock provider policy plugin",
+	register(api) {
+		registerAmazonBedrockPlugin(api);
+	}
+});
+//#endregion
+export { amazon_bedrock_default as default };

package/dist/memory-embedding-adapter.js

@@ -0,0 +1,34 @@
+import { DEFAULT_BEDROCK_EMBEDDING_MODEL, createBedrockEmbeddingProvider, hasAwsCredentials } from "./embedding-provider.js";
+import { isMissingEmbeddingApiKeyError } from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";
+//#region extensions/amazon-bedrock/memory-embedding-adapter.ts
+const bedrockMemoryEmbeddingProviderAdapter = {
+	id: "bedrock",
+	defaultModel: DEFAULT_BEDROCK_EMBEDDING_MODEL,
+	transport: "remote",
+	authProviderId: "amazon-bedrock",
+	autoSelectPriority: 60,
+	allowExplicitWhenConfiguredAuto: true,
+	shouldContinueAutoSelection: isMissingEmbeddingApiKeyError,
+	create: async (options) => {
+		if (!await hasAwsCredentials()) throw new Error("No API key found for provider \"bedrock\". AWS credentials are not available. Set AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY, AWS_PROFILE, or AWS_BEARER_TOKEN_BEDROCK, configure an EC2/ECS/EKS role, or set agents.defaults.memorySearch.provider to another provider.");
+		const { provider, client } = await createBedrockEmbeddingProvider({
+			...options,
+			provider: "bedrock",
+			fallback: "none"
+		});
+		return {
+			provider,
+			runtime: {
+				id: "bedrock",
+				cacheKeyData: {
+					provider: "bedrock",
+					region: client.region,
+					model: client.model,
+					dimensions: client.dimensions
+				}
+			}
+		};
+	}
+};
+//#endregion
+export { bedrockMemoryEmbeddingProviderAdapter };

package/dist/provider-policy-api.js

@@ -0,0 +1,9 @@
+import { resolveBedrockClaudeThinkingProfile } from "./thinking-policy.js";
+import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
+//#region extensions/amazon-bedrock/provider-policy-api.ts
+function resolveThinkingProfile(params) {
+	if (normalizeProviderId(params.provider) !== "amazon-bedrock") return null;
+	return resolveBedrockClaudeThinkingProfile(params.modelId);
+}
+//#endregion
+export { resolveThinkingProfile };

package/dist/register.sync.runtime.js

@@ -0,0 +1,357 @@
+import { refreshAwsSharedConfigCacheForBedrock } from "./aws-credential-refresh.js";
+import { mergeImplicitBedrockProvider, resolveBedrockConfigApiKey } from "./discovery-shared.js";
+import { bedrockMemoryEmbeddingProviderAdapter } from "./memory-embedding-adapter.js";
+import { isOpus47BedrockModelRef, resolveBedrockClaudeThinkingProfile } from "./thinking-policy.js";
+import { streamSimple } from "@earendil-works/pi-ai";
+import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { ANTHROPIC_BY_MODEL_REPLAY_HOOKS, normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
+import { streamWithPayloadPatch } from "openclaw/plugin-sdk/provider-stream-shared";
+//#region extensions/amazon-bedrock/register.sync.runtime.ts
+const BEDROCK_SERVICE_TIER_VALUES = [
+	"flex",
+	"priority",
+	"default",
+	"reserved"
+];
+function isAnthropicBedrockModel(modelId) {
+	const normalized = modelId.trim().toLowerCase();
+	if (normalized.includes("anthropic.claude") || normalized.includes("anthropic/claude")) return true;
+	if (/^arn:aws(-cn|-us-gov)?:bedrock:/.test(normalized) && normalized.includes(":application-inference-profile/")) return (normalized.split(":application-inference-profile/")[1] ?? "").includes("claude");
+	return false;
+}
+function createBedrockNoCacheWrapper(baseStreamFn) {
+	const underlying = baseStreamFn ?? streamSimple;
+	return (model, context, options) => underlying(model, context, {
+		...options,
+		cacheRetention: "none"
+	});
+}
+function isBedrockServiceTier(value) {
+	return BEDROCK_SERVICE_TIER_VALUES.some((tier) => tier === value);
+}
+function resolveBedrockServiceTier(extraParams, warn) {
+	const raw = extraParams?.serviceTier ?? extraParams?.service_tier;
+	if (typeof raw !== "string") return;
+	const normalized = raw.trim().toLowerCase();
+	if (isBedrockServiceTier(normalized)) return normalized;
+	warn(`ignoring invalid Bedrock service_tier param: ${raw}`);
+}
+function createBedrockServiceTierWrapper(underlying, serviceTier) {
+	return (model, context, options) => {
+		if (model.api !== "bedrock-converse-stream") return underlying(model, context, options);
+		return streamWithPayloadPatch(underlying, model, context, options, (payloadObj) => {
+			payloadObj.serviceTier ??= { type: serviceTier };
+		});
+	};
+}
+function createGuardrailWrapStreamFn(innerWrapStreamFn, guardrailConfig) {
+	return (ctx) => {
+		const inner = innerWrapStreamFn(ctx);
+		if (!inner) return inner;
+		return (model, context, options) => {
+			return streamWithPayloadPatch(inner, model, context, options, (payload) => {
+				const gc = {
+					guardrailIdentifier: guardrailConfig.guardrailIdentifier,
+					guardrailVersion: guardrailConfig.guardrailVersion
+				};
+				if (guardrailConfig.streamProcessingMode) gc.streamProcessingMode = guardrailConfig.streamProcessingMode;
+				if (guardrailConfig.trace) gc.trace = guardrailConfig.trace;
+				payload.guardrailConfig = gc;
+			});
+		};
+	};
+}
+/**
+* Mirrors the shipped pi-ai Bedrock `supportsPromptCaching` matcher.
+* Keep this in sync with node_modules/@earendil-works/pi-ai/dist/providers/amazon-bedrock.js.
+*/
+function matchesPiAiPromptCachingModelId(modelId) {
+	const id = modelId.toLowerCase();
+	if (!id.includes("claude")) return false;
+	if (id.includes("-4-") || id.includes("-4.")) return true;
+	if (id.includes("claude-3-7-sonnet")) return true;
+	if (id.includes("claude-3-5-haiku")) return true;
+	return false;
+}
+function piAiWouldInjectCachePoints(modelId) {
+	return matchesPiAiPromptCachingModelId(modelId);
+}
+/**
+* Detect Bedrock application inference profile ARNs — these are the only IDs
+* where pi-ai's model-name-based checks fail because the ARN is opaque.
+* System-defined profiles (us., eu., global.) and base model IDs always
+* contain the model name and are handled by pi-ai natively.
+*/
+const BEDROCK_APP_INFERENCE_PROFILE_RE = /^arn:aws(-cn|-us-gov)?:bedrock:.*:application-inference-profile\//i;
+function isBedrockAppInferenceProfile(modelId) {
+	return BEDROCK_APP_INFERENCE_PROFILE_RE.test(modelId);
+}
+/**
+* pi-ai's internal `supportsPromptCaching` checks `model.id` for specific Claude
+* model name patterns, which fails for application inference profile ARNs (opaque
+* IDs that may not contain the model name). When OpenClaw's `isAnthropicBedrockModel`
+* identifies the model but pi-ai won't inject cache points, we do it via onPayload.
+*
+* Gated to application inference profile ARNs only — regular Claude model IDs and
+* system-defined inference profiles (us.anthropic.claude-*) are left to pi-ai.
+*/
+function needsCachePointInjection(modelId) {
+	if (!isBedrockAppInferenceProfile(modelId)) return false;
+	if (piAiWouldInjectCachePoints(modelId)) return false;
+	if (isAnthropicBedrockModel(modelId)) return true;
+	return false;
+}
+/**
+* Extract the region from a Bedrock ARN.
+* e.g. "arn:aws:bedrock:us-east-1:123:application-inference-profile/abc" → "us-east-1"
+*/
+function extractRegionFromArn(arn) {
+	const parts = arn.split(":");
+	return parts.length >= 4 && parts[3] ? parts[3] : void 0;
+}
+/**
+* Check if a resolved foundation model ARN supports prompt caching using the
+* same matcher pi-ai uses for direct model IDs.
+*/
+function resolvedModelSupportsCaching(modelArn) {
+	return matchesPiAiPromptCachingModelId(modelArn);
+}
+const appProfileTraitsCache = /* @__PURE__ */ new Map();
+let bedrockControlPlaneOverride;
+function resetBedrockAppProfileCacheEligibilityForTest() {
+	appProfileTraitsCache.clear();
+}
+function setBedrockAppProfileControlPlaneForTest(controlPlane) {
+	bedrockControlPlaneOverride = controlPlane;
+	resetBedrockAppProfileCacheEligibilityForTest();
+}
+async function createBedrockControlPlane(region) {
+	if (bedrockControlPlaneOverride) return bedrockControlPlaneOverride(region);
+	await refreshAwsSharedConfigCacheForBedrock();
+	const { BedrockClient, GetInferenceProfileCommand } = await import("@aws-sdk/client-bedrock");
+	const client = new BedrockClient(region ? { region } : {});
+	return { getInferenceProfile: async (input) => await client.send(new GetInferenceProfileCommand(input)) };
+}
+async function resolveAppProfileTraits(modelId, fallbackRegion) {
+	const cached = appProfileTraitsCache.get(modelId);
+	if (cached) return cached;
+	try {
+		const models = (await (await createBedrockControlPlane(extractRegionFromArn(modelId) ?? fallbackRegion)).getInferenceProfile({ inferenceProfileIdentifier: modelId })).models ?? [];
+		const modelArns = models.map((m) => m.modelArn ?? "");
+		const traits = {
+			cacheEligible: models.length > 0 && modelArns.every((modelArn) => resolvedModelSupportsCaching(modelArn)),
+			omitTemperature: modelArns.some(isOpus47BedrockModelRef)
+		};
+		appProfileTraitsCache.set(modelId, traits);
+		return traits;
+	} catch {
+		return {
+			cacheEligible: isAnthropicBedrockModel(modelId),
+			omitTemperature: isOpus47BedrockModelRef(modelId)
+		};
+	}
+}
+function hasCachePoint(blocks) {
+	return blocks?.some((b) => b.cachePoint != null) === true;
+}
+function makeCachePoint(cacheRetention) {
+	return { cachePoint: {
+		type: "default",
+		...cacheRetention === "long" ? { ttl: "1h" } : {}
+	} };
+}
+/**
+* Inject Bedrock Converse cache points into the payload when pi-ai skipped them
+* because it didn't recognize the model ID (application inference profiles).
+*/
+function injectBedrockCachePoints(payload, cacheRetention) {
+	if (!cacheRetention || cacheRetention === "none") return;
+	const point = makeCachePoint(cacheRetention);
+	const system = payload.system;
+	if (Array.isArray(system) && system.length > 0 && !hasCachePoint(system)) system.push(point);
+	const messages = payload.messages;
+	if (Array.isArray(messages) && messages.length > 0) for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "user" && Array.isArray(msg.content)) {
+			if (!hasCachePoint(msg.content)) msg.content.push(point);
+			break;
+		}
+	}
+}
+function patchOpus47MaxThinkingEffort(payload) {
+	const fieldsValue = payload.additionalModelRequestFields;
+	const fields = fieldsValue && typeof fieldsValue === "object" && !Array.isArray(fieldsValue) ? fieldsValue : {};
+	const outputConfigValue = fields.output_config;
+	const outputConfig = outputConfigValue && typeof outputConfigValue === "object" && !Array.isArray(outputConfigValue) ? outputConfigValue : {};
+	outputConfig.effort = "max";
+	fields.output_config = outputConfig;
+	payload.additionalModelRequestFields = fields;
+}
+function registerAmazonBedrockPlugin(api) {
+	const providerId = "amazon-bedrock";
+	const bedrockRegionRe = /bedrock-runtime\.([a-z0-9-]+)\.amazonaws\./;
+	const bedrockContextOverflowPatterns = [
+		/ValidationException.*(?:input is too long|max input token|input token.*exceed)/i,
+		/ValidationException.*(?:exceeds? the (?:maximum|max) (?:number of )?(?:input )?tokens)/i,
+		/ModelStreamErrorException.*(?:Input is too long|too many input tokens)/i
+	];
+	const deprecatedTemperatureValidationRe = /ValidationException[\s\S]*(?:invalid_request_error[\s\S]*)?temperature[\s\S]*deprecated|ValidationException[\s\S]*deprecated[\s\S]*temperature/i;
+	const anthropicByModelReplayHooks = ANTHROPIC_BY_MODEL_REPLAY_HOOKS;
+	const startupPluginConfig = api.pluginConfig ?? {};
+	function resolveCurrentPluginConfig(config) {
+		return resolvePluginConfigObject(config, providerId) ?? (config ? void 0 : startupPluginConfig);
+	}
+	api.registerMemoryEmbeddingProvider(bedrockMemoryEmbeddingProviderAdapter);
+	const baseWrapStreamFn = ({ modelId, streamFn }) => {
+		if (isAnthropicBedrockModel(modelId)) return streamFn;
+		if (isBedrockAppInferenceProfile(modelId)) return streamFn;
+		return createBedrockNoCacheWrapper(streamFn);
+	};
+	function omitDeprecatedOpus47Temperature(modelId, options) {
+		if (!isOpus47BedrockModelRef(modelId) || !("temperature" in options)) return options;
+		const next = { ...options };
+		delete next.temperature;
+		return next;
+	}
+	function omitDeprecatedOpus47PayloadTemperature(payload) {
+		const inferenceConfig = payload.inferenceConfig;
+		if (!inferenceConfig || typeof inferenceConfig !== "object") return;
+		delete inferenceConfig.temperature;
+	}
+	function withAwsCredentialRefreshOnPayload(options) {
+		const originalOnPayload = options.onPayload;
+		return {
+			...options,
+			onPayload: async (payload, payloadModel) => {
+				await refreshAwsSharedConfigCacheForBedrock();
+				return originalOnPayload?.(payload, payloadModel);
+			}
+		};
+	}
+	function createAwsCredentialRefreshStreamWrapper(streamFn) {
+		if (!streamFn) return streamFn;
+		return (streamModel, context, options) => streamFn(streamModel, context, withAwsCredentialRefreshOnPayload(Object.assign({}, options)));
+	}
+	/** Extract the AWS region from a bedrock-runtime baseUrl. */
+	function extractRegionFromBaseUrl(baseUrl) {
+		if (!baseUrl) return;
+		return bedrockRegionRe.exec(baseUrl)?.[1];
+	}
+	/**
+	* Resolve the AWS region for Bedrock API calls.
+	* Provider-specific baseUrl wins over global bedrockDiscovery to avoid signing
+	* with the wrong region when discovery and provider target different regions.
+	*/
+	function resolveBedrockRegion(config) {
+		const providers = config?.models?.providers;
+		if (providers) {
+			const exact = providers[providerId]?.baseUrl;
+			if (exact) {
+				const region = extractRegionFromBaseUrl(exact);
+				if (region) return region;
+			}
+			for (const [key, value] of Object.entries(providers)) {
+				if (key === providerId || normalizeProviderId(key) !== providerId) continue;
+				const region = extractRegionFromBaseUrl(value.baseUrl);
+				if (region) return region;
+			}
+		}
+		return config?.models?.bedrockDiscovery?.region;
+	}
+	api.registerProvider({
+		id: providerId,
+		label: "Amazon Bedrock",
+		docsPath: "/providers/models",
+		auth: [],
+		catalog: {
+			order: "simple",
+			run: async (ctx) => {
+				const { resolveImplicitBedrockProvider } = await import("./discovery.js");
+				const currentPluginConfig = resolveCurrentPluginConfig(ctx.config);
+				const implicit = await resolveImplicitBedrockProvider({
+					config: ctx.config,
+					pluginConfig: currentPluginConfig,
+					env: ctx.env
+				});
+				if (!implicit) return null;
+				return { provider: mergeImplicitBedrockProvider({
+					existing: ctx.config.models?.providers?.[providerId],
+					implicit
+				}) };
+			}
+		},
+		resolveConfigApiKey: ({ env }) => resolveBedrockConfigApiKey(env),
+		...anthropicByModelReplayHooks,
+		wrapStreamFn: ({ modelId, config, model, streamFn, thinkingLevel, extraParams }) => {
+			const currentGuardrail = resolveCurrentPluginConfig(config)?.guardrail;
+			let wrapped = (currentGuardrail?.guardrailIdentifier && currentGuardrail?.guardrailVersion ? createGuardrailWrapStreamFn(baseWrapStreamFn, currentGuardrail)({
+				modelId,
+				streamFn
+			}) : baseWrapStreamFn({
+				modelId,
+				streamFn
+			})) ?? void 0;
+			const serviceTier = resolveBedrockServiceTier(extraParams, (message) => api.logger.warn(message));
+			if (serviceTier && wrapped) wrapped = createBedrockServiceTierWrapper(wrapped, serviceTier);
+			const region = resolveBedrockRegion(config) ?? extractRegionFromBaseUrl(model?.baseUrl);
+			const mayNeedCacheInjection = isBedrockAppInferenceProfile(modelId) && !piAiWouldInjectCachePoints(modelId);
+			const shouldOmitTemperature = isOpus47BedrockModelRef(modelId);
+			const shouldPatchMaxThinking = shouldOmitTemperature && thinkingLevel === "max";
+			const heuristicMatch = needsCachePointInjection(modelId);
+			if (!region && !mayNeedCacheInjection && !shouldOmitTemperature && !shouldPatchMaxThinking) return createAwsCredentialRefreshStreamWrapper(wrapped);
+			const underlying = wrapped ?? streamFn;
+			if (!underlying) return wrapped;
+			return (streamModel, context, options) => {
+				const merged = omitDeprecatedOpus47Temperature(modelId, Object.assign({}, options, region ? { region } : {}));
+				const originalOnPayload = merged.onPayload;
+				if (!mayNeedCacheInjection) return underlying(streamModel, context, withAwsCredentialRefreshOnPayload({
+					...merged,
+					...shouldPatchMaxThinking ? { onPayload: (payload, payloadModel) => {
+						if (payload && typeof payload === "object") patchOpus47MaxThinkingEffort(payload);
+						return originalOnPayload?.(payload, payloadModel);
+					} } : {}
+				}));
+				const cacheRetention = typeof merged.cacheRetention === "string" ? merged.cacheRetention : "short";
+				if (heuristicMatch) {
+					const mayNeedTemperatureTrait = "temperature" in merged;
+					return underlying(streamModel, context, withAwsCredentialRefreshOnPayload({
+						...merged,
+						onPayload: async (payload, payloadModel) => {
+							if (payload && typeof payload === "object") {
+								const payloadRecord = payload;
+								injectBedrockCachePoints(payloadRecord, cacheRetention);
+								if (shouldPatchMaxThinking) patchOpus47MaxThinkingEffort(payloadRecord);
+								if (mayNeedTemperatureTrait) {
+									if ((await resolveAppProfileTraits(modelId, region)).omitTemperature) omitDeprecatedOpus47PayloadTemperature(payloadRecord);
+								}
+							}
+							return originalOnPayload?.(payload, payloadModel);
+						}
+					}));
+				}
+				return underlying(streamModel, context, withAwsCredentialRefreshOnPayload({
+					...merged,
+					onPayload: async (payload, payloadModel) => {
+						const traits = await resolveAppProfileTraits(modelId, region);
+						if (payload && typeof payload === "object") {
+							const payloadRecord = payload;
+							if (traits.cacheEligible) injectBedrockCachePoints(payloadRecord, cacheRetention);
+							if (shouldPatchMaxThinking) patchOpus47MaxThinkingEffort(payloadRecord);
+							if (traits.omitTemperature) omitDeprecatedOpus47PayloadTemperature(payloadRecord);
+						}
+						return originalOnPayload?.(payload, payloadModel);
+					}
+				}));
+			};
+		},
+		matchesContextOverflowError: ({ errorMessage }) => bedrockContextOverflowPatterns.some((pattern) => pattern.test(errorMessage)),
+		classifyFailoverReason: ({ errorMessage }) => {
+			if (/ThrottlingException|Too many concurrent requests/i.test(errorMessage)) return "rate_limit";
+			if (/ModelNotReadyException/i.test(errorMessage)) return "overloaded";
+			if (deprecatedTemperatureValidationRe.test(errorMessage)) return "format";
+		},
+		resolveThinkingProfile: ({ modelId }) => resolveBedrockClaudeThinkingProfile(modelId)
+	});
+}
+//#endregion
+export { registerAmazonBedrockPlugin, resetBedrockAppProfileCacheEligibilityForTest, setBedrockAppProfileControlPlaneForTest };