pi-sap-aicore 0.3.4 → 0.3.6

package/CHANGELOG.md

@@ -7,6 +7,40 @@ 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
+
+- 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.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",
+    "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-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/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

@@ -1,7 +1,6 @@
 import type {
 	AssistantMessage,
 	Context,
-	Message,
 	TextContent,
 	Tool,
 	ToolResultMessage,
@@ -52,58 +51,149 @@ 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);
+			// 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] : [],
+			);
+			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;
+		}
+
+		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),
+		...(context.systemPrompt
+			? { system: [{ text: context.systemPrompt }] }
+			: {}),
+		// 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 piMessageToBedrockConverse(
-	msg: Message,
+// 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 {
-	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") {
+		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({
@@ -116,31 +206,66 @@ function piAssistantToBedrockConverse(
 		}
 	}
 
+	return content.length > 0 ? { role: "assistant", content } : undefined;
+}
+
+type BedrockToolResultParts = {
+	toolResult: BedrockConverseContentBlock;
+	images: BedrockConverseContentBlock[];
+};
+
+function piToolResultToBedrockContentParts(
+	msg: ToolResultMessage,
+): BedrockToolResultParts {
 	return {
-		role: "assistant",
-		content: content.length > 0 ? content : [{ text: " " }],
+		toolResult: bedrockToolResultBlock(
+			msg.toolCallId,
+			// Non-whitespace fallback: Anthropic's text-block validation applies
+			// inside tool_result content too.
+			toolResultText(msg).trim() || "(empty result)",
+			msg.isError,
+		),
+		images: toolResultImagesAsUserContent(msg),
 	};
 }
 
-function piToolResultToBedrockConverse(
-	msg: ToolResultMessage,
-): BedrockConverseMessage {
-	const text = toolResultText(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 {
-		role: "user",
-		content: [
-			{
-				toolResult: {
-					toolUseId: msg.toolCallId,
-					content: [{ text }],
-					status: msg.isError ? "error" : "success",
-				},
-			},
-			...toolResultImagesAsUserContent(msg),
-		],
+		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 +292,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,

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 {