pi-sap-aicore 0.3.5 → 0.3.6

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.6] - 2026-07-04
+
+### Fixed
+
+- Bedrock (Anthropic/Claude) and Vertex AI (Gemini) foundation routes no
+  longer emit empty or whitespace-only text blocks. Pi contexts legitimately
+  contain them — errored assistant turns persist with `content: []`,
+  thinking-only turns carry no text — and the old `{ text: " " }` placeholder
+  was itself whitespace-only, so Anthropic rejected every subsequent request
+  in the conversation with HTTP 400 "messages: text content blocks must
+  contain non-whitespace text". Empty messages are now dropped (role
+  coalescing re-merges the neighbours), empty text parts are filtered, and
+  empty tool-result text gets a non-whitespace fallback.
+
+### Added
+
+- Added `scripts/test-empty-content-blocks.mjs`, a credential-free regression
+  test covering both translators, and wired it into `npm test`.
+
 ## [0.3.5] - 2026-07-01
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sap-aicore",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "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 && node scripts/test-bedrock-tool-results.mjs",
+    "test": "node scripts/test-vertex-tool-schema.mjs && node scripts/test-bedrock-tool-results.mjs && node scripts/test-empty-content-blocks.mjs",
     "validate:foundation": "node scripts/validate-foundation-executables.mjs",
     "prepublishOnly": "tsc --noEmit && npm test"
   },
@@ -45,8 +45,8 @@
     "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.79.2",
-    "@earendil-works/pi-coding-agent": "^0.79.2",
+    "@earendil-works/pi-ai": "^0.80.3",
+    "@earendil-works/pi-coding-agent": "^0.80.3",
     "typescript": "^6.0.3"
   },
   "engines": {

package/scripts/test-empty-content-blocks.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+// Offline regression test for empty/whitespace-only content blocks.
+//
+// Anthropic (via Bedrock Converse) rejects any text content block that is
+// empty or whitespace-only: "messages: text content blocks must contain
+// non-whitespace text". Pi contexts legitimately contain such shapes —
+// errored assistant turns persist with content: [], thinking-only turns
+// carry no text — and the translators used to emit a `{ text: " " }`
+// placeholder for them, which is itself whitespace-only and poisoned every
+// subsequent request in the conversation. The translators must drop those
+// messages (coalescing re-merges the neighbours) and never emit a text block
+// without non-whitespace text. 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
+);
+const { piContextToVertexGenerateContent } = await import(
+	pathToFileURL(join(ROOT, "src/translate-foundation-vertexai.ts")).href
+);
+
+let failures = 0;
+function check(condition, message) {
+	if (condition) {
+		console.log(`  ✓ ${message}`);
+		return;
+	}
+	console.error(`  ❌ ${message}`);
+	failures++;
+}
+
+function bedrockTextBlocks(payload) {
+	return payload.messages.flatMap((message) =>
+		message.content.flatMap((block) => {
+			const texts = [];
+			if ("text" in block) texts.push(block.text);
+			if ("toolResult" in block) {
+				for (const part of block.toolResult.content) {
+					if ("text" in part) texts.push(part.text);
+				}
+			}
+			return texts;
+		}),
+	);
+}
+
+function vertexTextParts(payload) {
+	return payload.contents.flatMap((content) =>
+		content.parts.flatMap((part) => ("text" in part ? [part.text] : [])),
+	);
+}
+
+const erroredAssistant = {
+	role: "assistant",
+	content: [],
+	stopReason: "error",
+	errorMessage: "Model error: 400",
+};
+const thinkingOnlyAssistant = {
+	role: "assistant",
+	content: [{ type: "thinking", thinking: "planning..." }],
+	stopReason: "stop",
+};
+
+console.log("Bedrock: history with an errored assistant turn (content: [])");
+{
+	const payload = piContextToBedrockConverse({
+		systemPrompt: "system",
+		messages: [
+			{ role: "user", content: "hello" },
+			erroredAssistant,
+			{ role: "user", content: "hello again" },
+		],
+	});
+	check(
+		bedrockTextBlocks(payload).every((text) => text.trim().length > 0),
+		"no empty/whitespace-only text blocks",
+	);
+	check(
+		payload.messages.length === 1 && payload.messages[0].role === "user",
+		"dropped turn's neighbours coalesce into one user message",
+	);
+	check(
+		payload.messages[0].content.length === 2,
+		"both user texts survive the coalesce",
+	);
+}
+
+console.log("Bedrock: thinking-only assistant turn is dropped");
+{
+	const payload = piContextToBedrockConverse({
+		messages: [
+			{ role: "user", content: "hello" },
+			thinkingOnlyAssistant,
+			{ role: "user", content: "again" },
+		],
+	});
+	check(
+		payload.messages.every((message) =>
+			message.content.every(
+				(block) => !("text" in block) || block.text.trim().length > 0,
+			),
+		),
+		"no whitespace placeholder emitted",
+	);
+}
+
+console.log("Bedrock: empty user text parts are filtered, images survive");
+{
+	const payload = piContextToBedrockConverse({
+		messages: [
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: "" },
+					{ type: "image", mimeType: "image/png", data: "aGk=" },
+				],
+			},
+		],
+	});
+	check(payload.messages.length === 1, "image-only user message survives");
+	check(
+		payload.messages[0].content.every((block) => !("text" in block)),
+		"empty text part removed",
+	);
+}
+
+console.log("Bedrock: whitespace-only turns leave a valid degenerate payload");
+{
+	const payload = piContextToBedrockConverse({
+		messages: [{ role: "user", content: "   " }, erroredAssistant],
+	});
+	check(payload.messages.length === 1, "one fallback message");
+	check(
+		payload.messages[0].content[0].text.trim().length > 0,
+		"fallback text is non-whitespace",
+	);
+}
+
+console.log("Bedrock: empty tool-result text gets a non-whitespace fallback");
+{
+	const payload = piContextToBedrockConverse({
+		messages: [
+			{ role: "user", content: "run it" },
+			{
+				role: "assistant",
+				content: [
+					{ type: "toolCall", id: "call_1", name: "tool", arguments: {} },
+				],
+				stopReason: "toolUse",
+			},
+			{ role: "toolResult", toolCallId: "call_1", content: [], isError: false },
+		],
+	});
+	check(
+		bedrockTextBlocks(payload).every((text) => text.trim().length > 0),
+		"tool_result content text is non-whitespace",
+	);
+}
+
+console.log("Bedrock: a plain conversation is unchanged");
+{
+	const payload = piContextToBedrockConverse({
+		systemPrompt: "system",
+		messages: [
+			{ role: "user", content: "hello" },
+			{
+				role: "assistant",
+				content: [{ type: "text", text: "hi there" }],
+				stopReason: "stop",
+			},
+			{ role: "user", content: "how are you?" },
+		],
+	});
+	check(payload.messages.length === 3, "three messages, none dropped");
+	check(
+		payload.messages.map((message) => message.role).join(",") ===
+			"user,assistant,user",
+		"role alternation preserved",
+	);
+}
+
+console.log("Vertex: mirrors the drop behaviour");
+{
+	const payload = piContextToVertexGenerateContent({
+		systemPrompt: "system",
+		messages: [
+			{ role: "user", content: "hello" },
+			erroredAssistant,
+			{ role: "user", content: "hello again" },
+		],
+	});
+	check(
+		vertexTextParts(payload).every((text) => text.trim().length > 0),
+		"no empty/whitespace-only text parts",
+	);
+	check(
+		payload.contents.length === 1 && payload.contents[0].role === "user",
+		"dropped turn's neighbours coalesce into one user content",
+	);
+}
+
+console.log("Vertex: whitespace-only turns leave a valid degenerate payload");
+{
+	const payload = piContextToVertexGenerateContent({
+		messages: [{ role: "user", content: "   " }],
+	});
+	check(payload.contents.length === 1, "one fallback content entry");
+	check(
+		payload.contents[0].parts[0].text.trim().length > 0,
+		"fallback text is non-whitespace",
+	);
+}
+
+if (failures > 0) {
+	console.error(`\n${failures} check(s) failed`);
+	process.exit(1);
+}
+console.log("\nAll checks passed");

package/src/translate-foundation-bedrock.ts

@@ -58,6 +58,10 @@ export function piContextToBedrockConverse(context: Context): {
 
 		if (msg.role === "assistant") {
 			const assistant = piAssistantToBedrockConverse(msg);
+			// Errored turns (content: []) and thinking-only turns translate to
+			// nothing Anthropic accepts — drop them; coalescing re-merges the
+			// surrounding user messages. See piAssistantToBedrockConverse.
+			if (!assistant) continue;
 			const toolUseIds = assistant.content.flatMap((block) =>
 				"toolUse" in block ? [block.toolUse.toolUseId] : [],
 			);
@@ -128,47 +132,68 @@ export function piContextToBedrockConverse(context: Context): {
 			continue;
 		}
 
-		messages.push(piUserToBedrockConverse(msg));
+		const user = piUserToBedrockConverse(msg);
+		if (user) messages.push(user);
 	}
 
 	const tools = (context.tools ?? []).map(piToolToBedrockToolSpec);
+	const coalesced = coalesceAdjacentMessages(messages);
 	return {
 		...(context.systemPrompt
 			? { system: [{ text: context.systemPrompt }] }
 			: {}),
-		messages: coalesceAdjacentMessages(messages),
+		// Degenerate guard: if every message was dropped as empty, Bedrock still
+		// requires at least one message.
+		messages:
+			coalesced.length > 0
+				? coalesced
+				: [{ role: "user", content: [{ text: "(no conversation content)" }] }],
 		...(tools.length > 0 ? { toolConfig: { tools } } : {}),
 	};
 }
 
-function piUserToBedrockConverse(msg: UserMessage): BedrockConverseMessage {
+// Anthropic (via Bedrock Converse) rejects any text content block that is
+// empty or whitespace-only: "messages: text content blocks must contain
+// non-whitespace text". Pi contexts legitimately contain such blocks — errored
+// assistant turns persist with content: [], thinking-only turns carry no text,
+// and replayed histories can hold empty text parts — so both translators drop
+// them (returning undefined for messages left with no content) instead of
+// emitting the old `{ text: " " }` placeholder, which was itself
+// whitespace-only and poisoned every request in the conversation.
+function piUserToBedrockConverse(
+	msg: UserMessage,
+): BedrockConverseMessage | undefined {
 	if (typeof msg.content === "string") {
+		if (msg.content.trim().length === 0) return undefined;
 		return { role: "user", content: [{ text: msg.content }] };
 	}
 
-	const content = msg.content.map((part): BedrockConverseContentBlock => {
-		if (part.type === "text") return { text: part.text };
-		return {
-			image: {
-				format: imageFormatFromMimeType(part.mimeType),
-				source: { bytes: part.data },
-			},
-		};
-	});
+	const content = msg.content.flatMap(
+		(part): BedrockConverseContentBlock[] => {
+			if (part.type === "text") {
+				return part.text.trim().length > 0 ? [{ text: part.text }] : [];
+			}
+			return [
+				{
+					image: {
+						format: imageFormatFromMimeType(part.mimeType),
+						source: { bytes: part.data },
+					},
+				},
+			];
+		},
+	);
 
-	return {
-		role: "user",
-		content: content.length > 0 ? content : [{ text: " " }],
-	};
+	return content.length > 0 ? { role: "user", content } : undefined;
 }
 
 function piAssistantToBedrockConverse(
 	msg: AssistantMessage,
-): BedrockConverseMessage {
+): BedrockConverseMessage | undefined {
 	const content: BedrockConverseContentBlock[] = [];
 
 	for (const block of msg.content) {
-		if (block.type === "text" && block.text) {
+		if (block.type === "text" && block.text.trim().length > 0) {
 			content.push({ text: block.text });
 		} else if (block.type === "toolCall") {
 			content.push({
@@ -181,10 +206,7 @@ function piAssistantToBedrockConverse(
 		}
 	}
 
-	return {
-		role: "assistant",
-		content: content.length > 0 ? content : [{ text: " " }],
-	};
+	return content.length > 0 ? { role: "assistant", content } : undefined;
 }
 
 type BedrockToolResultParts = {
@@ -198,7 +220,9 @@ function piToolResultToBedrockContentParts(
 	return {
 		toolResult: bedrockToolResultBlock(
 			msg.toolCallId,
-			toolResultText(msg) || " ",
+			// Non-whitespace fallback: Anthropic's text-block validation applies
+			// inside tool_result content too.
+			toolResultText(msg).trim() || "(empty result)",
 			msg.isError,
 		),
 		images: toolResultImagesAsUserContent(msg),

package/src/translate-foundation-vertexai.ts

@@ -50,7 +50,12 @@ export function piContextToVertexGenerateContent(context: Context): {
 		...(context.systemPrompt
 			? { systemInstruction: { parts: [{ text: context.systemPrompt }] } }
 			: {}),
-		contents: coalesceAdjacentContents(contents),
+		// Degenerate guard: if every message was dropped as empty, Gemini still
+		// requires at least one content entry.
+		contents:
+			contents.length > 0
+				? coalesceAdjacentContents(contents)
+				: [{ role: "user", parts: [{ text: "(no conversation content)" }] }],
 		...(functionDeclarations.length > 0
 			? { tools: [{ functionDeclarations }] }
 			: {}),
@@ -68,23 +73,34 @@ function piMessageToVertexContent(msg: Message): VertexContent | undefined {
 	}
 }
 
-function piUserToVertexContent(msg: UserMessage): VertexContent {
+// Mirrors the Bedrock translator: drop empty/whitespace-only text parts and
+// messages left with no parts (errored turns persist with content: [],
+// thinking-only turns carry no text) instead of emitting a whitespace
+// placeholder. See translate-foundation-bedrock.ts for the Anthropic
+// rejection this class of payload causes; Gemini gets the same treatment for
+// symmetry and to avoid burning tokens on placeholder turns.
+function piUserToVertexContent(msg: UserMessage): VertexContent | undefined {
 	if (typeof msg.content === "string") {
+		if (msg.content.trim().length === 0) return undefined;
 		return { role: "user", parts: [{ text: msg.content }] };
 	}
 
-	const parts = msg.content.map((part): VertexPart => {
-		if (part.type === "text") return { text: part.text };
-		return { inlineData: { mimeType: part.mimeType, data: part.data } };
+	const parts = msg.content.flatMap((part): VertexPart[] => {
+		if (part.type === "text") {
+			return part.text.trim().length > 0 ? [{ text: part.text }] : [];
+		}
+		return [{ inlineData: { mimeType: part.mimeType, data: part.data } }];
 	});
 
-	return { role: "user", parts: parts.length > 0 ? parts : [{ text: " " }] };
+	return parts.length > 0 ? { role: "user", parts } : undefined;
 }
 
-function piAssistantToVertexContent(msg: AssistantMessage): VertexContent {
+function piAssistantToVertexContent(
+	msg: AssistantMessage,
+): VertexContent | undefined {
 	const parts: VertexPart[] = [];
 	for (const block of msg.content) {
-		if (block.type === "text" && block.text) {
+		if (block.type === "text" && block.text.trim().length > 0) {
 			parts.push({ text: block.text });
 		} else if (block.type === "toolCall") {
 			parts.push({
@@ -98,7 +114,7 @@ function piAssistantToVertexContent(msg: AssistantMessage): VertexContent {
 			});
 		}
 	}
-	return { role: "model", parts: parts.length > 0 ? parts : [{ text: " " }] };
+	return parts.length > 0 ? { role: "model", parts } : undefined;
 }
 
 function piToolResultToVertexContent(msg: ToolResultMessage): VertexContent {