pi-sap-aicore 0.3.4 → 0.3.5

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.5] - 2026-07-01
+
+### Fixed
+
+- Direct AWS Bedrock (Anthropic/Claude) foundation route now batches all
+  corresponding `toolResult` blocks immediately after assistant `toolUse` blocks
+  before appending screenshot/image content. This fixes Anthropic HTTP 400
+  failures from Opus 4.8 such as "`tool_use` ids were found without
+  `tool_result` blocks immediately after" on tool-heavy coding-agent turns.
+
+### Added
+
+- Added `scripts/test-bedrock-tool-results.mjs`, a credential-free regression
+  test for Bedrock/Anthropic tool-result ordering, and wired it into `npm test`.
+
 ## [0.3.4] - 2026-07-01
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sap-aicore",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "SAP AI Core (orchestration + foundation) provider for the pi coding agent",
   "license": "MIT",
   "author": "Tim Pearson (https://github.com/ttiimmaahh)",
@@ -31,7 +31,7 @@
   },
   "scripts": {
     "update-models": "node scripts/update-models.mjs",
-    "test": "node scripts/test-vertex-tool-schema.mjs",
+    "test": "node scripts/test-vertex-tool-schema.mjs && node scripts/test-bedrock-tool-results.mjs",
     "validate:foundation": "node scripts/validate-foundation-executables.mjs",
     "prepublishOnly": "tsc --noEmit && npm test"
   },

package/scripts/test-bedrock-tool-results.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// Offline regression test for Bedrock/Anthropic tool_result ordering.
+//
+// Anthropic models behind Bedrock require the user message immediately after an
+// assistant tool_use turn to begin with one tool_result block per tool_use id.
+// Pi stores each tool result as a separate top-level message, and screenshot
+// tool results can include images. A naive role coalesce produces:
+//   assistant(tool_use a,b), user(tool_result a, image, tool_result b)
+// which Anthropic rejects because tool_result b is not in the required prefix.
+// This test makes no network calls.
+
+import { pathToFileURL } from "node:url";
+import { join } from "node:path";
+
+const ROOT = new URL("..", import.meta.url).pathname;
+
+const { piContextToBedrockConverse } = await import(
+	pathToFileURL(join(ROOT, "src/translate-foundation-bedrock.ts")).href
+);
+
+let failures = 0;
+function check(condition, message) {
+	if (condition) {
+		console.log(`  ✓ ${message}`);
+		return;
+	}
+	console.error(`  ❌ ${message}`);
+	failures++;
+}
+
+const context = {
+	messages: [
+		{
+			role: "assistant",
+			content: [
+				{
+					type: "toolCall",
+					id: "tooluse_a",
+					name: "screenshot",
+					arguments: {},
+				},
+				{ type: "toolCall", id: "tooluse_b", name: "bash", arguments: {} },
+			],
+			api: "test",
+			provider: "test",
+			model: "test",
+			usage: {},
+			stopReason: "toolUse",
+			timestamp: 1,
+		},
+		{
+			role: "toolResult",
+			toolCallId: "tooluse_a",
+			toolName: "screenshot",
+			content: [
+				{ type: "text", text: "screenshot captured" },
+				{ type: "image", data: "iVBORw0KGgo=", mimeType: "image/png" },
+			],
+			isError: false,
+			timestamp: 2,
+		},
+		{
+			role: "toolResult",
+			toolCallId: "tooluse_b",
+			toolName: "bash",
+			content: [{ type: "text", text: "command output" }],
+			isError: false,
+			timestamp: 3,
+		},
+	],
+	tools: [],
+};
+
+const out = piContextToBedrockConverse(context);
+const [assistant, user] = out.messages;
+
+check(
+	out.messages.length === 2,
+	"assistant turn and batched user result turn are emitted",
+);
+check(
+	assistant?.content?.map((block) => block.toolUse?.toolUseId).join(",") ===
+		"tooluse_a,tooluse_b",
+	"assistant contains both toolUse blocks in order",
+);
+check(user?.role === "user", "next message after assistant toolUse is user");
+
+const kinds = user?.content?.map((block) => Object.keys(block)[0]) ?? [];
+check(
+	kinds.slice(0, 2).join(",") === "toolResult,toolResult",
+	"all expected toolResult blocks are the first blocks in the immediate user message",
+);
+check(
+	kinds[2] === "image",
+	"image content is preserved after the required toolResult prefix",
+);
+check(
+	user?.content?.[0]?.toolResult?.toolUseId === "tooluse_a" &&
+		user?.content?.[1]?.toolResult?.toolUseId === "tooluse_b",
+	"toolResult ids match the assistant toolUse ids in order",
+);
+
+if (failures > 0) {
+	console.error(
+		`\n❌ bedrock tool-result ordering test: ${failures} check(s) failed`,
+	);
+	process.exit(1);
+}
+console.log("\n✅ bedrock tool-result ordering test passed");

package/src/translate-foundation-bedrock.ts

@@ -1,7 +1,6 @@
 import type {
 	AssistantMessage,
 	Context,
-	Message,
 	TextContent,
 	Tool,
 	ToolResultMessage,
@@ -52,33 +51,96 @@ export function piContextToBedrockConverse(context: Context): {
 	toolConfig?: BedrockToolConfig;
 } {
 	const messages: BedrockConverseMessage[] = [];
+	const pi = context.messages;
 
-	for (const msg of context.messages) {
-		const translated = piMessageToBedrockConverse(msg);
-		if (translated) messages.push(translated);
+	for (let i = 0; i < pi.length; i++) {
+		const msg = pi[i];
+
+		if (msg.role === "assistant") {
+			const assistant = piAssistantToBedrockConverse(msg);
+			const toolUseIds = assistant.content.flatMap((block) =>
+				"toolUse" in block ? [block.toolUse.toolUseId] : [],
+			);
+			if (toolUseIds.length === 0) {
+				messages.push(assistant);
+				continue;
+			}
+
+			messages.push(assistant);
+
+			// Bedrock/Anthropic require the next user message after assistant
+			// toolUse blocks to begin with the corresponding toolResult blocks,
+			// one per toolUseId. Pi stores tool results as separate top-level
+			// messages, and screenshot tool results may contain images. If those
+			// image blocks are interleaved between toolResult blocks after role
+			// coalescing, Anthropic rejects the request with:
+			// "tool_use ids were found without tool_result blocks immediately after".
+			// Batch all contiguous expected tool results first, then append any
+			// images/orphaned result transcript content after the required prefix.
+			const expected = new Set(toolUseIds);
+			const byId = new Map<string, BedrockToolResultParts>();
+			const orphaned: BedrockConverseContentBlock[] = [];
+
+			let j = i + 1;
+			while (j < pi.length) {
+				const toolResult = pi[j];
+				if (toolResult.role !== "toolResult") break;
+				if (
+					expected.has(toolResult.toolCallId) &&
+					!byId.has(toolResult.toolCallId)
+				) {
+					byId.set(
+						toolResult.toolCallId,
+						piToolResultToBedrockContentParts(toolResult),
+					);
+				} else {
+					orphaned.push(...piToolResultToSyntheticUserContent(toolResult));
+				}
+				j++;
+			}
+
+			const content: BedrockConverseContentBlock[] = [];
+			const images: BedrockConverseContentBlock[] = [];
+			for (const id of toolUseIds) {
+				const translated = byId.get(id);
+				if (translated) {
+					content.push(translated.toolResult);
+					images.push(...translated.images);
+				} else {
+					content.push(missingToolResultBlock(id));
+				}
+			}
+			messages.push({
+				role: "user",
+				content: [...content, ...images, ...orphaned],
+			});
+			i = j - 1;
+			continue;
+		}
+
+		if (msg.role === "toolResult") {
+			// A standalone toolResult block is invalid in Bedrock/Anthropic. Keep
+			// the information available to the model as normal user-visible text.
+			messages.push({
+				role: "user",
+				content: piToolResultToSyntheticUserContent(msg),
+			});
+			continue;
+		}
+
+		messages.push(piUserToBedrockConverse(msg));
 	}
 
 	const tools = (context.tools ?? []).map(piToolToBedrockToolSpec);
 	return {
-		...(context.systemPrompt ? { system: [{ text: context.systemPrompt }] } : {}),
+		...(context.systemPrompt
+			? { system: [{ text: context.systemPrompt }] }
+			: {}),
 		messages: coalesceAdjacentMessages(messages),
 		...(tools.length > 0 ? { toolConfig: { tools } } : {}),
 	};
 }
 
-function piMessageToBedrockConverse(
-	msg: Message,
-): BedrockConverseMessage | undefined {
-	switch (msg.role) {
-		case "user":
-			return piUserToBedrockConverse(msg);
-		case "assistant":
-			return piAssistantToBedrockConverse(msg);
-		case "toolResult":
-			return piToolResultToBedrockConverse(msg);
-	}
-}
-
 function piUserToBedrockConverse(msg: UserMessage): BedrockConverseMessage {
 	if (typeof msg.content === "string") {
 		return { role: "user", content: [{ text: msg.content }] };
@@ -94,7 +156,10 @@ function piUserToBedrockConverse(msg: UserMessage): BedrockConverseMessage {
 		};
 	});
 
-	return { role: "user", content: content.length > 0 ? content : [{ text: " " }] };
+	return {
+		role: "user",
+		content: content.length > 0 ? content : [{ text: " " }],
+	};
 }
 
 function piAssistantToBedrockConverse(
@@ -122,25 +187,61 @@ function piAssistantToBedrockConverse(
 	};
 }
 
-function piToolResultToBedrockConverse(
+type BedrockToolResultParts = {
+	toolResult: BedrockConverseContentBlock;
+	images: BedrockConverseContentBlock[];
+};
+
+function piToolResultToBedrockContentParts(
 	msg: ToolResultMessage,
-): BedrockConverseMessage {
-	const text = toolResultText(msg) || " ";
+): BedrockToolResultParts {
 	return {
-		role: "user",
-		content: [
-			{
-				toolResult: {
-					toolUseId: msg.toolCallId,
-					content: [{ text }],
-					status: msg.isError ? "error" : "success",
-				},
-			},
-			...toolResultImagesAsUserContent(msg),
-		],
+		toolResult: bedrockToolResultBlock(
+			msg.toolCallId,
+			toolResultText(msg) || " ",
+			msg.isError,
+		),
+		images: toolResultImagesAsUserContent(msg),
+	};
+}
+
+function missingToolResultBlock(
+	toolUseId: string,
+): BedrockConverseContentBlock {
+	return bedrockToolResultBlock(
+		toolUseId,
+		`Tool result missing for ${toolUseId}.`,
+		true,
+	);
+}
+
+function bedrockToolResultBlock(
+	toolUseId: string,
+	text: string,
+	isError: boolean,
+): BedrockConverseContentBlock {
+	return {
+		toolResult: {
+			toolUseId,
+			content: [{ text }],
+			status: isError ? "error" : "success",
+		},
 	};
 }
 
+function piToolResultToSyntheticUserContent(
+	msg: ToolResultMessage,
+): BedrockConverseContentBlock[] {
+	return [
+		{
+			text:
+				`Tool result for ${msg.toolName} (${msg.toolCallId})` +
+				`${msg.isError ? " failed" : ""}:\n${toolResultText(msg) || " "}`,
+		},
+		...toolResultImagesAsUserContent(msg),
+	];
+}
+
 function toolResultText(msg: ToolResultMessage): string {
 	return msg.content
 		.filter((part): part is TextContent => part.type === "text")
@@ -167,13 +268,20 @@ function toolResultImagesAsUserContent(
 function imageFormatFromMimeType(mimeType: string): string {
 	const format = mimeType.split("/")[1]?.toLowerCase();
 	if (format === "jpg") return "jpeg";
-	if (format === "jpeg" || format === "png" || format === "gif" || format === "webp") {
+	if (
+		format === "jpeg" ||
+		format === "png" ||
+		format === "gif" ||
+		format === "webp"
+	) {
 		return format;
 	}
 	return "png";
 }
 
-function piToolToBedrockToolSpec(tool: Tool): BedrockToolConfig["tools"][number] {
+function piToolToBedrockToolSpec(
+	tool: Tool,
+): BedrockToolConfig["tools"][number] {
 	return {
 		toolSpec: {
 			name: tool.name,