@oh-my-pi/pi-ai 13.13.0 → 13.13.2

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [13.13.2] - 2026-03-18
+### Changed
+
+- Modified tool result handling for aborted assistant messages to preserve existing tool results when already recorded, instead of always replacing them with synthetic 'aborted' results
+
 ## [13.13.0] - 2026-03-18
 ### Changed
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "13.13.0",
+	"version": "13.13.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,7 +41,7 @@
 		"@aws-sdk/client-bedrock-runtime": "^3",
 		"@bufbuild/protobuf": "^2.11",
 		"@google/genai": "^1.43",
-		"@oh-my-pi/pi-utils": "13.13.0",
+		"@oh-my-pi/pi-utils": "13.13.2",
 		"@sinclair/typebox": "^0.34",
 		"@smithy/node-http-handler": "^4.4",
 		"ajv": "^8.18",

package/src/providers/openai-codex-responses.ts

@@ -2134,7 +2134,7 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 					} satisfies ResponseOutputMessage);
 					continue;
 				}
-				if (block.type === "toolCall" && msg.stopReason !== "error") {
+				if (block.type === "toolCall") {
 					const toolCall = block as ToolCall;
 					const normalized = normalizeResponsesToolCallId(toolCall.id);
 					outputItems.push({

package/src/providers/openai-responses-shared.ts

@@ -134,7 +134,7 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 			continue;
 		}
 
-		if (block.type !== "toolCall" || assistantMsg.stopReason === "error") {
+		if (block.type !== "toolCall") {
 			continue;
 		}
 

package/src/providers/transform-messages.ts

@@ -124,101 +124,105 @@ export function transformMessages<TApi extends Api>(
 	});
 
 	// Second pass: insert synthetic empty tool results for orphaned tool calls
-	// This preserves thinking signatures and satisfies API requirements
+	// and preserve aborted/errored tool results when they were already persisted.
 	const result: Message[] = [];
 	let pendingToolCalls: ToolCall[] = [];
-	// Track tool call status: whether resolved (has result) or aborted (skip real results)
+	let pendingAbortedToolCalls = new Map<string, ToolCall>();
+	let pendingAbortedTimestamp: number | undefined;
+	// Track tool call status: whether resolved (has result) or aborted (synthetic result injected, skip later real results)
 	const toolCallStatus = new Map<string, ToolCallStatus>();
 
+	const flushPendingToolCalls = (timestamp: number): void => {
+		if (pendingToolCalls.length === 0) return;
+		for (const tc of pendingToolCalls) {
+			if (!toolCallStatus.has(tc.id)) {
+				result.push({
+					role: "toolResult",
+					toolCallId: tc.id,
+					toolName: tc.name,
+					content: [{ type: "text", text: "No result provided" }],
+					isError: true,
+					timestamp,
+				} as ToolResultMessage);
+				toolCallStatus.set(tc.id, ToolCallStatus.Resolved);
+			}
+		}
+		pendingToolCalls = [];
+	};
+
+	const flushPendingAbortedToolCalls = (): void => {
+		if (pendingAbortedTimestamp === undefined) return;
+		for (const tc of pendingAbortedToolCalls.values()) {
+			if (!toolCallStatus.has(tc.id)) {
+				result.push({
+					role: "toolResult",
+					toolCallId: tc.id,
+					toolName: tc.name,
+					content: [{ type: "text", text: "aborted" }],
+					isError: true,
+					timestamp: pendingAbortedTimestamp,
+				} as ToolResultMessage);
+				toolCallStatus.set(tc.id, ToolCallStatus.Aborted);
+			}
+		}
+		result.push({
+			role: "developer",
+			content: turnAbortedGuidance,
+			timestamp: pendingAbortedTimestamp + 1,
+		} as DeveloperMessage);
+		pendingAbortedToolCalls = new Map();
+		pendingAbortedTimestamp = undefined;
+	};
+
 	for (let i = 0; i < transformed.length; i++) {
 		const msg = transformed[i];
+		const messageTimestamp = "timestamp" in msg && typeof msg.timestamp === "number" ? msg.timestamp : Date.now();
 
 		if (msg.role === "assistant") {
-			// If we have pending orphaned tool calls from a previous assistant, insert synthetic results now
-			if (pendingToolCalls.length > 0) {
-				for (const tc of pendingToolCalls) {
-					if (!toolCallStatus.has(tc.id)) {
-						result.push({
-							role: "toolResult",
-							toolCallId: tc.id,
-							toolName: tc.name,
-							content: [{ type: "text", text: "No result provided" }],
-							isError: true,
-							timestamp: Date.now(),
-						} as ToolResultMessage);
-						toolCallStatus.set(tc.id, ToolCallStatus.Resolved);
-					}
-				}
-				pendingToolCalls = [];
-			}
+			flushPendingToolCalls(messageTimestamp);
+			flushPendingAbortedToolCalls();
 
-			// For errored/aborted assistant messages: keep tool calls intact,
-			// inject synthetic "aborted" results, and add guidance marker.
-			// This preserves structure so the model knows what was attempted.
 			const assistantMsg = msg as AssistantMessage;
 			const toolCalls = assistantMsg.content.filter(b => b.type === "toolCall") as ToolCall[];
 
 			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
-				// Push the assistant message with tool calls intact
+				// Keep the assistant message with tool calls intact. If real tool results follow, preserve them;
+				// otherwise synthesize aborted results before the next turn boundary.
 				result.push(msg);
-
-				// Inject synthetic "aborted" results for each tool call
-				for (const tc of toolCalls) {
-					toolCallStatus.set(tc.id, ToolCallStatus.Aborted);
-					result.push({
-						role: "toolResult",
-						toolCallId: tc.id,
-						toolName: tc.name,
-						content: [{ type: "text", text: "aborted" }],
-						isError: true,
-						timestamp: assistantMsg.timestamp,
-					} as ToolResultMessage);
-				}
-
-				// Inject turn-aborted guidance marker as developer message
-				result.push({
-					role: "developer",
-					content: turnAbortedGuidance,
-					timestamp: assistantMsg.timestamp + 1,
-				} as DeveloperMessage);
-
+				pendingAbortedToolCalls = new Map(toolCalls.map(toolCall => [toolCall.id, toolCall] as const));
+				pendingAbortedTimestamp = assistantMsg.timestamp;
 				continue;
 			}
 
-			// Track tool calls from this normal assistant message
 			if (toolCalls.length > 0) {
 				pendingToolCalls = toolCalls;
 			}
 
 			result.push(msg);
 		} else if (msg.role === "toolResult") {
-			// Skip tool results for aborted tool calls (we already injected synthetic ones)
+			if (pendingAbortedToolCalls.has(msg.toolCallId)) {
+				pendingAbortedToolCalls.delete(msg.toolCallId);
+				toolCallStatus.set(msg.toolCallId, ToolCallStatus.Resolved);
+				result.push(msg);
+				continue;
+			}
+
 			if (toolCallStatus.get(msg.toolCallId) === ToolCallStatus.Aborted) continue;
 			toolCallStatus.set(msg.toolCallId, ToolCallStatus.Resolved);
 			result.push(msg);
 		} else if (msg.role === "user" || msg.role === "developer") {
-			// User/developer message interrupts tool flow - insert synthetic results for orphaned calls
-			if (pendingToolCalls.length > 0) {
-				for (const tc of pendingToolCalls) {
-					if (!toolCallStatus.has(tc.id)) {
-						result.push({
-							role: "toolResult",
-							toolCallId: tc.id,
-							toolName: tc.name,
-							content: [{ type: "text", text: "No result provided" }],
-							isError: true,
-							timestamp: Date.now(),
-						} as ToolResultMessage);
-						toolCallStatus.set(tc.id, ToolCallStatus.Resolved);
-					}
-				}
-				pendingToolCalls = [];
-			}
+			flushPendingToolCalls(messageTimestamp);
+			flushPendingAbortedToolCalls();
 			result.push(msg);
 		} else {
+			flushPendingToolCalls(messageTimestamp);
+			flushPendingAbortedToolCalls();
 			result.push(msg);
 		}
 	}
 
+	flushPendingToolCalls(Date.now());
+	flushPendingAbortedToolCalls();
+
 	return result;
 }