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

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "14.7.2",
+	"version": "14.7.3",
 	"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.3",
+		"@oh-my-pi/pi-natives": "14.7.3",
+		"@oh-my-pi/pi-utils": "14.7.3"
 	},
 	"devDependencies": {
 		"@sinclair/typebox": "^0.34.49",

package/src/agent-loop.ts

@@ -22,6 +22,9 @@ import type {
 	StreamFn,
 } from "./types";
 
+/** Sentinel returned by the abort race in `streamAssistantResponse`. */
+const ABORTED: unique symbol = Symbol("agent-loop-aborted");
+
 /**
  * Start an agent loop with a new prompt message.
  * The prompt is added to the context and events are emitted for it.
@@ -360,115 +363,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,