@oh-my-pi/pi-agent-core 14.7.2 → 14.7.4

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "14.7.2",
+	"version": "14.7.4",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -35,9 +35,9 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "14.7.2",
-		"@oh-my-pi/pi-natives": "14.7.2",
-		"@oh-my-pi/pi-utils": "14.7.2"
+		"@oh-my-pi/pi-ai": "14.7.4",
+		"@oh-my-pi/pi-natives": "14.7.4",
+		"@oh-my-pi/pi-utils": "14.7.4"
 	},
 	"devDependencies": {
 		"@sinclair/typebox": "^0.34.49",

package/src/agent-loop.ts

@@ -22,6 +22,49 @@ import type {
 	StreamFn,
 } from "./types";
 
+/** Sentinel returned by the abort race in `streamAssistantResponse`. */
+const ABORTED: unique symbol = Symbol("agent-loop-aborted");
+
+/**
+ * Normalize a value coming back from `tool.execute()` (or its streaming partial-update callback)
+ * into a structurally valid {@link AgentToolResult}.
+ *
+ * The tool interface is typed, but third-party tools (MCP, extensions, user-authored AgentTools)
+ * can violate the contract at runtime. Persisting a malformed result corrupts the session file
+ * (missing `content` array → crash on reload). We coerce at the single boundary where untyped
+ * results enter the agent loop, so every downstream consumer can rely on the type.
+ */
+function coerceToolResult(raw: unknown): { result: AgentToolResult<any>; malformed: boolean } {
+	const rawObj = raw && typeof raw === "object" ? (raw as Record<string, unknown>) : null;
+	const rawContent = rawObj?.content;
+	const details = rawObj && "details" in rawObj ? rawObj.details : {};
+
+	if (!Array.isArray(rawContent)) {
+		return {
+			result: {
+				content: [{ type: "text", text: "Tool returned an invalid result: missing content array." }],
+				details,
+			},
+			malformed: true,
+		};
+	}
+
+	const content: AgentToolResult["content"] = [];
+	for (const block of rawContent) {
+		if (!block || typeof block !== "object" || !("type" in block)) continue;
+		if (block.type === "text" && typeof (block as { text?: unknown }).text === "string") {
+			content.push({ type: "text", text: sanitizeText((block as { text: string }).text) });
+		} else if (
+			block.type === "image" &&
+			typeof (block as { data?: unknown }).data === "string" &&
+			typeof (block as { mimeType?: unknown }).mimeType === "string"
+		) {
+			content.push(block as { type: "image"; data: string; mimeType: string });
+		}
+	}
+	return { result: { content, details }, malformed: false };
+}
+
 /**
  * Start an agent loop with a new prompt message.
  * The prompt is added to the context and events are emitted for it.
@@ -360,115 +403,97 @@ async function streamAssistantResponse(
 	let addedPartial = false;
 
 	const responseIterator = response[Symbol.asyncIterator]();
-	while (true) {
-		const read = await readResponseEvent(responseIterator, signal);
-		if (read.type === "aborted") {
+	// Set up a single abort race: register the abort listener once for the whole
+	// stream and reuse the same race promise for every iterator.next() instead of
+	// allocating Promise.withResolvers and add/removeEventListener per event.
+	let abortRacePromise: Promise<typeof ABORTED> | undefined;
+	let detachAbortListener: (() => void) | undefined;
+	if (signal) {
+		if (signal.aborted) {
 			return emitAbortedAssistantMessage(partialMessage, addedPartial, context, config, stream);
 		}
-		if (read.type === "error") {
-			throw read.error;
-		}
-		if (read.result.done) {
-			break;
-		}
+		const { promise, resolve } = Promise.withResolvers<typeof ABORTED>();
+		const onAbort = () => resolve(ABORTED);
+		signal.addEventListener("abort", onAbort, { once: true });
+		abortRacePromise = promise;
+		detachAbortListener = () => signal.removeEventListener("abort", onAbort);
+	}
 
-		const event = read.result.value;
-		// Check for abort signal before processing each event
-		if (signal?.aborted) {
-			return emitAbortedAssistantMessage(partialMessage, addedPartial, context, config, stream);
-		}
+	try {
+		while (true) {
+			let next: IteratorResult<AssistantMessageEvent>;
+			if (abortRacePromise) {
+				const result = await Promise.race([responseIterator.next(), abortRacePromise]);
+				if (result === ABORTED) {
+					responseIterator.return?.()?.catch(() => {});
+					return emitAbortedAssistantMessage(partialMessage, addedPartial, context, config, stream);
+				}
+				next = result;
+			} else {
+				next = await responseIterator.next();
+			}
+			if (signal?.aborted) {
+				return emitAbortedAssistantMessage(partialMessage, addedPartial, context, config, stream);
+			}
+			if (next.done) break;
 
-		switch (event.type) {
-			case "start":
-				partialMessage = event.partial;
-				context.messages.push(partialMessage);
-				addedPartial = true;
-				stream.push({ type: "message_start", message: { ...partialMessage } });
-				break;
-
-			case "text_start":
-			case "text_delta":
-			case "text_end":
-			case "thinking_start":
-			case "thinking_delta":
-			case "thinking_end":
-			case "toolcall_start":
-			case "toolcall_delta":
-			case "toolcall_end":
-				if (partialMessage) {
+			const event = next.value;
+
+			switch (event.type) {
+				case "start":
 					partialMessage = event.partial;
-					context.messages[context.messages.length - 1] = partialMessage;
-					config.onAssistantMessageEvent?.(partialMessage, event);
-					if (signal?.aborted) {
-						continue;
+					context.messages.push(partialMessage);
+					addedPartial = true;
+					stream.push({ type: "message_start", message: { ...partialMessage } });
+					break;
+
+				case "text_start":
+				case "text_delta":
+				case "text_end":
+				case "thinking_start":
+				case "thinking_delta":
+				case "thinking_end":
+				case "toolcall_start":
+				case "toolcall_delta":
+				case "toolcall_end":
+					if (partialMessage) {
+						partialMessage = event.partial;
+						context.messages[context.messages.length - 1] = partialMessage;
+						config.onAssistantMessageEvent?.(partialMessage, event);
+						if (signal?.aborted) {
+							continue;
+						}
+						stream.push({
+							type: "message_update",
+							assistantMessageEvent: event,
+							message: { ...partialMessage },
+						});
 					}
-					stream.push({
-						type: "message_update",
-						assistantMessageEvent: event,
-						message: { ...partialMessage },
-					});
-				}
-				break;
-
-			case "done":
-			case "error": {
-				const finalMessage = await response.result();
-				if (addedPartial) {
-					context.messages[context.messages.length - 1] = finalMessage;
-				} else {
-					context.messages.push(finalMessage);
-				}
-				if (!addedPartial) {
-					stream.push({ type: "message_start", message: { ...finalMessage } });
+					break;
+
+				case "done":
+				case "error": {
+					const finalMessage = await response.result();
+					if (addedPartial) {
+						context.messages[context.messages.length - 1] = finalMessage;
+					} else {
+						context.messages.push(finalMessage);
+					}
+					if (!addedPartial) {
+						stream.push({ type: "message_start", message: { ...finalMessage } });
+					}
+					stream.push({ type: "message_end", message: finalMessage });
+					return finalMessage;
 				}
-				stream.push({ type: "message_end", message: finalMessage });
-				return finalMessage;
 			}
 		}
+	} finally {
+		detachAbortListener?.();
 	}
 
 	return await response.result();
 }
 
-type ResponseEventRead =
-	| { type: "event"; result: IteratorResult<AssistantMessageEvent> }
-	| { type: "error"; error: unknown }
-	| { type: "aborted" };
-
-async function readResponseEvent(
-	iterator: AsyncIterator<AssistantMessageEvent>,
-	signal: AbortSignal | undefined,
-): Promise<ResponseEventRead> {
-	if (!signal) {
-		return { type: "event", result: await iterator.next() };
-	}
-	if (signal.aborted) {
-		const returnPromise = iterator.return?.();
-		if (returnPromise) void returnPromise.catch(() => {});
-		return { type: "aborted" };
-	}
-
-	const { promise: abortPromise, resolve: resolveAbort } = Promise.withResolvers<ResponseEventRead>();
-	const onAbort = () => resolveAbort({ type: "aborted" });
-	signal.addEventListener("abort", onAbort, { once: true });
-
-	const eventPromise = iterator.next().then(
-		result => ({ type: "event" as const, result }),
-		error => ({ type: "error" as const, error }),
-	);
-
-	try {
-		const read = await Promise.race([eventPromise, abortPromise]);
-		if (read.type === "aborted") {
-			const returnPromise = iterator.return?.();
-			if (returnPromise) void returnPromise.catch(() => {});
-		}
-		return read;
-	} finally {
-		signal.removeEventListener("abort", onAbort);
-	}
-}
-
 function emitAbortedAssistantMessage(
 	partialMessage: AssistantMessage | null,
 	addedPartial: boolean,
@@ -671,7 +696,7 @@ async function executeToolCalls(
 						toolCalls: toolCallInfos,
 					})
 				: undefined;
-			result = await tool.execute(
+			const rawResult = await tool.execute(
 				toolCall.id,
 				transformToolCallArguments ? transformToolCallArguments(effectiveArgs, toolCall.name) : effectiveArgs,
 				tool.nonAbortable ? undefined : toolSignal,
@@ -681,16 +706,14 @@ async function executeToolCalls(
 						toolCallId: toolCall.id,
 						toolName: toolCall.name,
 						args: argsForExecution,
-						partialResult: {
-							...partialResult,
-							content: partialResult.content.map(c =>
-								c.type === "text" ? { ...c, text: sanitizeText(c.text) } : c,
-							),
-						},
+						partialResult: coerceToolResult(partialResult).result,
 					});
 				},
 				toolContext,
 			);
+			const coerced = coerceToolResult(rawResult);
+			result = coerced.result;
+			if (coerced.malformed) isError = true;
 		} catch (e) {
 			result = {
 				content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }],