@openclaw/amazon-bedrock-provider 2026.7.1 → 2026.7.2-beta.2

package/dist/aws-credential-refresh.js

@@ -1,4 +1,8 @@
 //#region extensions/amazon-bedrock/aws-credential-refresh.ts
+/**
+* AWS shared config cache refresh helpers for Bedrock. They nudge the AWS SDK
+* to re-read profile/SSO config when no static credentials are present.
+*/
 function hasStaticAwsCredentialEnv(env) {
 	return Boolean(env.AWS_ACCESS_KEY_ID && env.AWS_SECRET_ACCESS_KEY);
 }
@@ -7,13 +11,11 @@ function shouldRefreshAwsSharedConfigCacheForBedrock(env) {
 	if (env.AWS_BEDROCK_SKIP_AUTH === "1" || env.AWS_BEARER_TOKEN_BEDROCK) return false;
 	return !hasStaticAwsCredentialEnv(env);
 }
-async function loadSharedIniFileLoader() {
-	return await import("@smithy/shared-ini-file-loader");
-}
 /** Refresh Smithy shared config files when Bedrock needs default-chain credentials. */
 async function refreshAwsSharedConfigCacheForBedrock(env = process.env) {
 	if (!shouldRefreshAwsSharedConfigCacheForBedrock(env)) return;
-	await (await loadSharedIniFileLoader()).loadSharedConfigFiles({ ignoreCache: true });
+	const { loadSharedConfigFiles } = await import("@smithy/shared-ini-file-loader");
+	await loadSharedConfigFiles({ ignoreCache: true });
 }
 //#endregion
 export { refreshAwsSharedConfigCacheForBedrock };

package/dist/control-plane.js

@@ -0,0 +1,29 @@
+import { buildTimeoutAbortSignal } from "openclaw/plugin-sdk/extension-shared";
+//#region extensions/amazon-bedrock/control-plane.ts
+const BEDROCK_CONTROL_PLANE_REQUEST_TIMEOUT_MS = 3e4;
+async function loadBedrockControlPlaneSdk() {
+	const { BedrockClient, GetInferenceProfileCommand, ListFoundationModelsCommand, ListInferenceProfilesCommand } = await import("@aws-sdk/client-bedrock");
+	return {
+		createClient: (region) => new BedrockClient(region ? { region } : {}),
+		createGetInferenceProfileCommand: (input) => new GetInferenceProfileCommand(input),
+		createListFoundationModelsCommand: () => new ListFoundationModelsCommand({}),
+		createListInferenceProfilesCommand: (input) => new ListInferenceProfilesCommand(input)
+	};
+}
+async function runBedrockControlPlaneRequest(params) {
+	const { signal, cleanup } = buildTimeoutAbortSignal({
+		timeoutMs: BEDROCK_CONTROL_PLANE_REQUEST_TIMEOUT_MS,
+		signal: params.signal,
+		operation: params.operation
+	});
+	try {
+		signal?.throwIfAborted();
+		const response = await params.send({ abortSignal: signal });
+		signal?.throwIfAborted();
+		return response;
+	} finally {
+		cleanup();
+	}
+}
+//#endregion
+export { loadBedrockControlPlaneSdk, runBedrockControlPlaneRequest };

package/dist/discovery.js

@@ -1,4 +1,5 @@
 import { refreshAwsSharedConfigCacheForBedrock } from "./aws-credential-refresh.js";
+import { loadBedrockControlPlaneSdk, runBedrockControlPlaneRequest } from "./control-plane.js";
 import { resolveBedrockConfigApiKey } from "./discovery-shared.js";
 import { resolveBedrockNativeThinkingLevelMap } from "./thinking-policy.js";
 import { resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeSonnet5ModelIdentity, supportsClaudeAdaptiveThinking } from "openclaw/plugin-sdk/provider-model-shared";
@@ -119,33 +120,6 @@ const DEFAULT_COST = {
 	cacheRead: 0,
 	cacheWrite: 0
 };
-async function loadBedrockDiscoverySdk() {
-	const { BedrockClient, ListFoundationModelsCommand, ListInferenceProfilesCommand } = await import("@aws-sdk/client-bedrock");
-	return {
-		createClient: (region) => new BedrockClient({ region }),
-		createListFoundationModelsCommand: () => new ListFoundationModelsCommand({}),
-		createListInferenceProfilesCommand: (input) => new ListInferenceProfilesCommand(input)
-	};
-}
-function createInjectedClientDiscoverySdk() {
-	class ListFoundationModelsCommand {
-		constructor(input = {}) {
-			this.input = input;
-		}
-	}
-	class ListInferenceProfilesCommand {
-		constructor(input = {}) {
-			this.input = input;
-		}
-	}
-	return {
-		createClient() {
-			throw new Error("clientFactory is required for injected Bedrock discovery commands");
-		},
-		createListFoundationModelsCommand: () => new ListFoundationModelsCommand({}),
-		createListInferenceProfilesCommand: (input) => new ListInferenceProfilesCommand(input)
-	};
-}
 const discoveryCache = /* @__PURE__ */ new Map();
 let hasLoggedBedrockError = false;
 function normalizeProviderFilter(filter) {
@@ -248,7 +222,11 @@ async function fetchInferenceProfileSummaries(client, createListInferenceProfile
 		const profiles = [];
 		let nextToken;
 		do {
-			const response = await client.send(createListInferenceProfilesCommand({ nextToken }));
+			const command = createListInferenceProfilesCommand({ nextToken });
+			const response = await runBedrockControlPlaneRequest({
+				operation: "Bedrock ListInferenceProfiles",
+				send: (options) => client.send(command, options)
+			});
 			for (const summary of response.inferenceProfileSummaries ?? []) profiles.push(summary);
 			nextToken = response.nextToken;
 		} while (nextToken);
@@ -328,44 +306,51 @@ async function discoverBedrockModels(params) {
 		}
 		if (cached) discoveryCache.delete(cacheKey);
 	}
-	const sdk = params.clientFactory ? createInjectedClientDiscoverySdk() : await loadBedrockDiscoverySdk();
+	const sdk = await loadBedrockControlPlaneSdk();
 	const clientFactory = params.clientFactory ?? ((region) => sdk.createClient(region));
 	if (!params.clientFactory) await refreshAwsSharedConfigCacheForBedrock();
 	const client = clientFactory(params.region);
 	const discoveryPromise = (async () => {
-		const [rawFoundationResponse, profileSummaries] = await Promise.all([client.send(sdk.createListFoundationModelsCommand()), fetchInferenceProfileSummaries(client, (input) => sdk.createListInferenceProfilesCommand(input))]);
-		const foundationResponse = rawFoundationResponse;
-		const discovered = [];
-		const seenIds = /* @__PURE__ */ new Set();
-		const foundationModels = /* @__PURE__ */ new Map();
-		for (const summary of foundationResponse.modelSummaries ?? []) {
-			if (!shouldIncludeSummary(summary, providerFilter)) continue;
-			const def = toModelDefinition(summary, {
+		try {
+			const foundationCommand = sdk.createListFoundationModelsCommand();
+			const [foundationResponse, profileSummaries] = await Promise.all([runBedrockControlPlaneRequest({
+				operation: "Bedrock ListFoundationModels",
+				send: (options) => client.send(foundationCommand, options)
+			}), fetchInferenceProfileSummaries(client, (input) => sdk.createListInferenceProfilesCommand(input))]);
+			const discovered = [];
+			const seenIds = /* @__PURE__ */ new Set();
+			const foundationModels = /* @__PURE__ */ new Map();
+			for (const summary of foundationResponse.modelSummaries ?? []) {
+				if (!shouldIncludeSummary(summary, providerFilter)) continue;
+				const def = toModelDefinition(summary, {
+					contextWindow: defaultContextWindow,
+					maxTokens: defaultMaxTokens
+				});
+				discovered.push(def);
+				const normalizedId = normalizeLowercaseStringOrEmpty(def.id);
+				seenIds.add(normalizedId);
+				foundationModels.set(normalizedId, def);
+			}
+			const inferenceProfiles = resolveInferenceProfiles(profileSummaries, {
 				contextWindow: defaultContextWindow,
 				maxTokens: defaultMaxTokens
-			});
-			discovered.push(def);
-			const normalizedId = normalizeLowercaseStringOrEmpty(def.id);
-			seenIds.add(normalizedId);
-			foundationModels.set(normalizedId, def);
-		}
-		const inferenceProfiles = resolveInferenceProfiles(profileSummaries, {
-			contextWindow: defaultContextWindow,
-			maxTokens: defaultMaxTokens
-		}, providerFilter, foundationModels);
-		for (const profile of inferenceProfiles) {
-			const normalizedId = normalizeLowercaseStringOrEmpty(profile.id);
-			if (!seenIds.has(normalizedId)) {
-				discovered.push(profile);
-				seenIds.add(normalizedId);
+			}, providerFilter, foundationModels);
+			for (const profile of inferenceProfiles) {
+				const normalizedId = normalizeLowercaseStringOrEmpty(profile.id);
+				if (!seenIds.has(normalizedId)) {
+					discovered.push(profile);
+					seenIds.add(normalizedId);
+				}
 			}
+			return discovered.toSorted((a, b) => {
+				const aGlobal = a.id.startsWith("global.") ? 0 : 1;
+				const bGlobal = b.id.startsWith("global.") ? 0 : 1;
+				if (aGlobal !== bGlobal) return aGlobal - bGlobal;
+				return a.name.localeCompare(b.name);
+			});
+		} finally {
+			client.destroy();
 		}
-		return discovered.toSorted((a, b) => {
-			const aGlobal = a.id.startsWith("global.") ? 0 : 1;
-			const bGlobal = b.id.startsWith("global.") ? 0 : 1;
-			if (aGlobal !== bGlobal) return aGlobal - bGlobal;
-			return a.name.localeCompare(b.name);
-		});
 	})();
 	if (refreshIntervalSeconds > 0) {
 		const expiresAt = resolveExpiresAtMsFromDurationSeconds(refreshIntervalSeconds, { nowMs: now });

package/dist/embedding-provider.js

@@ -104,25 +104,18 @@ function inferFamily(modelId) {
 	if (id.startsWith("twelvelabs.")) return "twelvelabs";
 	return "titan-v1";
 }
-let sdkCache = null;
-let credentialProviderSdkCache;
+let sdkPromise = null;
+let credentialProviderPromise = null;
 async function loadSdk() {
-	if (sdkCache) return sdkCache;
 	try {
-		sdkCache = await import("@aws-sdk/client-bedrock-runtime");
-		return sdkCache;
+		return await (sdkPromise ??= import("@aws-sdk/client-bedrock-runtime"));
 	} catch {
+		sdkPromise = null;
 		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;
+function loadDefaultCredentialProvider() {
+	return credentialProviderPromise ??= import("@aws-sdk/credential-provider-node").then(({ defaultProvider }) => defaultProvider).catch(() => null);
 }
 const MODEL_PREFIX_RE = /^(?:bedrock|amazon-bedrock|aws)\//;
 const REGION_RE = /bedrock-runtime\.([a-z0-9-]+)\./;
@@ -223,6 +216,7 @@ const testing = {
 	parseSingle,
 	stripInferenceProfilePrefix
 };
+if (process.env.VITEST === "true") Reflect.set(globalThis, Symbol.for("openclaw.amazonBedrockEmbeddingTestApi"), testing);
 async function createBedrockEmbeddingProvider(options) {
 	const client = resolveBedrockEmbeddingClient(options);
 	const { BedrockRuntimeClient, InvokeModelCommand } = await loadSdk();
@@ -295,13 +289,13 @@ function resolveBedrockEmbeddingClient(options) {
 		dimensions
 	};
 }
-async function hasAwsCredentials(env = process.env, loadCredentialProvider = loadCredentialProviderSdk) {
+async function hasAwsCredentials(env = process.env, loadCredentialProvider = loadDefaultCredentialProvider) {
 	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;
+	const defaultProvider = await loadCredentialProvider();
+	if (!defaultProvider) return false;
 	try {
-		const credentials = await credentialProviderSdk.defaultProvider({
+		const credentials = await defaultProvider({
 			timeout: 1e3,
 			maxRetries: 0
 		})();
@@ -311,4 +305,4 @@ async function hasAwsCredentials(env = process.env, loadCredentialProvider = loa
 	}
 }
 //#endregion
-export { DEFAULT_BEDROCK_EMBEDDING_MODEL, testing as __testing, testing, createBedrockEmbeddingProvider, hasAwsCredentials };
+export { DEFAULT_BEDROCK_EMBEDDING_MODEL, createBedrockEmbeddingProvider, hasAwsCredentials };

package/dist/register.sync.runtime.js

@@ -1,12 +1,13 @@
 import { refreshAwsSharedConfigCacheForBedrock } from "./aws-credential-refresh.js";
 import { supportsBedrockPromptCaching } from "./bedrock-options.js";
+import { loadBedrockControlPlaneSdk, runBedrockControlPlaneRequest } from "./control-plane.js";
 import { mergeImplicitBedrockProvider, resolveBedrockConfigApiKey } from "./discovery-shared.js";
 import { bedrockMemoryEmbeddingProviderAdapter } from "./memory-embedding-adapter.js";
 import { isLatestAdaptiveBedrockModelRef, isOpus47OrNewerBedrockModelRef, resolveBedrockClaudeThinkingProfile, resolveBedrockNativeThinkingLevelMap, supportsBedrockNativeMaxEffort } from "./thinking-policy.js";
 import { streamBedrock, streamSimpleBedrock } from "./stream.runtime.js";
 import { registerApiProvider, streamSimple } from "openclaw/plugin-sdk/llm";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { ANTHROPIC_BY_MODEL_REPLAY_HOOKS, normalizeProviderId, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeSonnet5ModelIdentity } from "openclaw/plugin-sdk/provider-model-shared";
+import { buildProviderReplayFamilyHooks, normalizeProviderId, resolveClaudeFable5ModelIdentity, resolveClaudeModelIdentity, resolveClaudeMythos5ModelIdentity, resolveClaudeSonnet5ModelIdentity } from "openclaw/plugin-sdk/provider-model-shared";
 import { streamWithPayloadPatch } from "openclaw/plugin-sdk/provider-stream-shared";
 //#region extensions/amazon-bedrock/register.sync.runtime.ts
 function normalizeBedrockResolvedModel({ modelId, model }) {
@@ -129,18 +130,24 @@ function resolvedModelSupportsCaching(modelArn) {
 	return supportsBedrockPromptCaching(modelArn);
 }
 const appProfileTraitsCache = /* @__PURE__ */ new Map();
-async function createBedrockControlPlane(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) {
+async function resolveAppProfileTraits(modelId, fallbackRegion, signal) {
 	const cached = appProfileTraitsCache.get(modelId);
 	if (cached) return cached;
+	let client;
 	try {
-		const models = (await (await createBedrockControlPlane(extractRegionFromArn(modelId) ?? fallbackRegion)).getInferenceProfile({ inferenceProfileIdentifier: modelId })).models ?? [];
-		const modelArns = models.map((m) => m.modelArn ?? "");
+		signal?.throwIfAborted();
+		const region = extractRegionFromArn(modelId) ?? fallbackRegion;
+		const sdk = await loadBedrockControlPlaneSdk();
+		signal?.throwIfAborted();
+		const controlPlaneClient = sdk.createClient(region);
+		client = controlPlaneClient;
+		const command = sdk.createGetInferenceProfileCommand({ inferenceProfileIdentifier: modelId });
+		const models = (await runBedrockControlPlaneRequest({
+			operation: "Bedrock GetInferenceProfile",
+			signal,
+			send: (options) => controlPlaneClient.send(command, options)
+		})).models ?? [];
+		const modelArns = models.map((model) => model.modelArn ?? "");
 		const traits = {
 			cacheEligible: models.length > 0 && modelArns.every((modelArn) => resolvedModelSupportsCaching(modelArn)),
 			omitTemperature: modelArns.some(isOpus47OrNewerBedrockModelRef)
@@ -148,10 +155,13 @@ async function resolveAppProfileTraits(modelId, fallbackRegion) {
 		appProfileTraitsCache.set(modelId, traits);
 		return traits;
 	} catch {
+		signal?.throwIfAborted();
 		return {
 			cacheEligible: isAnthropicBedrockModel(modelId),
 			omitTemperature: isOpus47OrNewerBedrockModelRef(modelId)
 		};
+	} finally {
+		client?.destroy();
 	}
 }
 function hasCachePoint(blocks) {
@@ -173,9 +183,8 @@ function injectBedrockCachePoints(payload, 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 (Array.isArray(messages) && messages.length > 0) {
+		for (const msg of messages.toReversed()) if (msg.role === "user" && Array.isArray(msg.content)) {
 			if (!hasCachePoint(msg.content)) msg.content.push(point);
 			break;
 		}
@@ -200,7 +209,7 @@ function registerAmazonBedrockPlugin(api) {
 		/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 anthropicByModelReplayHooks = buildProviderReplayFamilyHooks({ family: "anthropic-by-model" });
 	const startupPluginConfig = api.pluginConfig ?? {};
 	registerApiProvider({
 		api: "bedrock-converse-stream",
@@ -237,7 +246,10 @@ function registerAmazonBedrockPlugin(api) {
 		return {
 			...options,
 			onPayload: async (payload, payloadModel) => {
+				const signal = options.signal;
+				signal?.throwIfAborted();
 				await refreshAwsSharedConfigCacheForBedrock();
+				signal?.throwIfAborted();
 				return originalOnPayload?.(payload, payloadModel);
 			}
 		};
@@ -351,7 +363,7 @@ function registerAmazonBedrockPlugin(api) {
 								if (shouldPatchMaxThinking) patchMaxThinkingEffort(payloadRecord);
 								if (shouldOmitTemperature) omitUnsupportedClaudePayloadTemperature(payloadRecord);
 								else if (mayNeedTemperatureTrait) {
-									if ((await resolveAppProfileTraits(modelId, region)).omitTemperature) omitUnsupportedClaudePayloadTemperature(payloadRecord);
+									if ((await resolveAppProfileTraits(modelId, region, merged.signal)).omitTemperature) omitUnsupportedClaudePayloadTemperature(payloadRecord);
 								}
 							}
 							return originalOnPayload?.(payload, payloadModel);
@@ -361,7 +373,7 @@ function registerAmazonBedrockPlugin(api) {
 				return underlying(streamModel, context, withAwsCredentialRefreshOnPayload({
 					...merged,
 					onPayload: async (payload, payloadModel) => {
-						const traits = await resolveAppProfileTraits(modelId, region);
+						const traits = await resolveAppProfileTraits(modelId, region, merged.signal);
 						if (payload && typeof payload === "object") {
 							const payloadRecord = payload;
 							if (traits.cacheEligible) injectBedrockCachePoints(payloadRecord, cacheRetention);

package/dist/stream.runtime.js

@@ -5,6 +5,8 @@ import { requiresClaudeMandatoryAdaptiveThinking, resolveClaudeFable5ModelIdenti
 import { applyAnthropicRefusal, createDeferredEventBuffer, notifyLlmRequestActivity } from "openclaw/plugin-sdk/provider-stream-shared";
 import { BedrockRuntimeClient, BedrockRuntimeServiceException, CachePointType, CacheTTL, ConversationRole, ConverseStreamCommand, ImageFormat, StopReason, ToolResultStatus } from "@aws-sdk/client-bedrock-runtime";
 import { NodeHttpHandler } from "@smithy/node-http-handler";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { describeToolResultMediaPlaceholder } from "openclaw/plugin-sdk/provider-transport-runtime";
 //#region extensions/amazon-bedrock/stream.runtime.ts
 /**
 * Amazon Bedrock Converse streaming runtime. It maps OpenClaw messages/tools,
@@ -284,7 +286,7 @@ function handleContentBlockDelta(event, blocks, output, stream) {
 			};
 			output.content.push(newBlock);
 			index = blocks.length - 1;
-			block = blocks[index];
+			block = newBlock;
 			stream.push({
 				type: "text_start",
 				contentIndex: index,
@@ -375,7 +377,6 @@ function handleContentBlockStop(event, blocks, output, stream) {
 			});
 			break;
 		case "toolCall":
-			block.arguments = parseStreamingJson(block.partialJson);
 			delete block.partialJson;
 			stream.push({
 				type: "toolcall_end",
@@ -474,11 +475,26 @@ function normalizeToolCallId(id) {
 	const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
 	return sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
 }
+function createBedrockToolResult(message) {
+	const content = [];
+	for (const block of message.content) {
+		if (block.type === "text") {
+			content.push({ text: sanitizeSurrogates(block.text) });
+			continue;
+		}
+		if (describeToolResultMediaPlaceholder([block])) content.push({ image: createImageBlock(block.mimeType, block.data) });
+	}
+	return { toolResult: {
+		toolUseId: message.toolCallId,
+		content: content.length > 0 ? content : [{ text: "(no output)" }],
+		status: message.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS
+	} };
+}
 function convertMessages(context, model, cacheRetention) {
 	const result = [];
 	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
 	for (let i = 0; i < transformedMessages.length; i++) {
-		const m = transformedMessages[i];
+		const m = expectDefined(transformedMessages[i], "message conversion index is in bounds");
 		switch (m.role) {
 			case "user": {
 				const content = [];
@@ -541,19 +557,12 @@ function convertMessages(context, model, cacheRetention) {
 			}
 			case "toolResult": {
 				const toolResults = [];
-				toolResults.push({ toolResult: {
-					toolUseId: m.toolCallId,
-					content: m.content.map((c) => c.type === "image" ? { image: createImageBlock(c.mimeType, c.data) } : { text: sanitizeSurrogates(c.text) }),
-					status: m.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS
-				} });
+				toolResults.push(createBedrockToolResult(m));
 				let j = i + 1;
-				while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-					const nextMsg = transformedMessages[j];
-					toolResults.push({ toolResult: {
-						toolUseId: nextMsg.toolCallId,
-						content: nextMsg.content.map((c) => c.type === "image" ? { image: createImageBlock(c.mimeType, c.data) } : { text: sanitizeSurrogates(c.text) }),
-						status: nextMsg.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS
-					} });
+				while (true) {
+					const nextMsg = transformedMessages.at(j);
+					if (nextMsg?.role !== "toolResult") break;
+					toolResults.push(createBedrockToolResult(nextMsg));
 					j++;
 				}
 				i = j - 1;
@@ -567,7 +576,7 @@ function convertMessages(context, model, cacheRetention) {
 		}
 	}
 	if (cacheRetention !== "none" && supportsPromptCaching(model) && result.length > 0) {
-		const lastMessage = result[result.length - 1];
+		const lastMessage = expectDefined(result.at(-1), "non-empty converted message list");
 		if (lastMessage.role === ConversationRole.USER && lastMessage.content) lastMessage.content.push({ cachePoint: {
 			type: CachePointType.DEFAULT,
 			...cacheRetention === "long" ? { ttl: CacheTTL.ONE_HOUR } : {}
@@ -703,5 +712,6 @@ const testing = {
 	resolveSimpleBedrockOptions,
 	shouldUseExplicitBedrockEndpoint
 };
+if (process.env.VITEST === "true") Reflect.set(globalThis, Symbol.for("openclaw.amazonBedrockStreamTestApi"), testing);
 //#endregion
-export { streamBedrock, streamSimpleBedrock, testing };
+export { streamBedrock, streamSimpleBedrock };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/amazon-bedrock-provider",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/amazon-bedrock-provider",
-      "version": "2026.7.1",
+      "version": "2026.7.2-beta.2",
       "dependencies": {
         "@aws-sdk/client-bedrock": "3.1078.0",
         "@aws-sdk/client-bedrock-runtime": "3.1078.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/amazon-bedrock-provider",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.2",
   "description": "OpenClaw Amazon Bedrock provider plugin with model discovery, embeddings, and guardrail support.",
   "repository": {
     "type": "git",
@@ -25,10 +25,10 @@
       "minHostVersion": ">=2026.5.12-beta.1"
     },
     "compat": {
-      "pluginApi": ">=2026.7.1"
+      "pluginApi": ">=2026.7.2-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.7.1",
+      "openclawVersion": "2026.7.2-beta.2",
       "bundledDist": false
     },
     "release": {
@@ -46,7 +46,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.1"
+    "openclaw": ">=2026.7.2-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {