@prestyj/agent 4.4.0 → 4.5.0

package/dist/index.cjs

@@ -194,23 +194,51 @@ function isTransportFailure(err) {
   }
   return false;
 }
+function createAbortError() {
+  return new DOMException("Aborted", "AbortError");
+}
+function abortablePromise(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(createAbortError());
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const resolveOnce = (value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const rejectOnce = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err instanceof Error ? err : new Error(String(err)));
+    };
+    const onAbort = () => rejectOnce(createAbortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolveOnce, rejectOnce);
+  });
+}
 function abortableSleep(ms, signal) {
-  if (signal?.aborted) {
-    return Promise.reject(new DOMException("Aborted", "AbortError"));
-  }
+  if (signal?.aborted) return Promise.reject(createAbortError());
   return new Promise((resolve, reject) => {
-    let onAbort = null;
     const timer = setTimeout(() => {
-      if (onAbort) signal?.removeEventListener("abort", onAbort);
+      signal?.removeEventListener("abort", onAbort);
       resolve();
     }, ms);
-    onAbort = () => {
+    const onAbort = () => {
       clearTimeout(timer);
-      reject(new DOMException("Aborted", "AbortError"));
+      reject(createAbortError());
     };
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
+function closeIterator(iterator) {
+  if (!iterator?.return) return;
+  Promise.resolve(iterator.return()).catch(() => {
+  });
+}
 async function* agentLoop(messages, options) {
   const maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS;
   const maxContinuations = options.maxContinuations ?? 5;
@@ -335,6 +363,7 @@ async function* agentLoop(messages, options) {
         idleTimedOut = true;
         streamController.abort();
       }, hardTimeoutMs);
+      let streamIterator = null;
       try {
         diag("stream_call", { nonStreaming: useNonStreamingFallback });
         streamCallStart = Date.now();
@@ -374,7 +403,11 @@ async function* agentLoop(messages, options) {
         streamCallStart = Date.now();
         lastYieldEndTime = Date.now();
         resetIdleTimer();
-        for await (const event of result) {
+        streamIterator = result[Symbol.asyncIterator]();
+        while (true) {
+          const next = await abortablePromise(streamIterator.next(), streamController.signal);
+          if (next.done) break;
+          const event = next.value;
           const pullTime = Date.now();
           const consumerLag = pullTime - lastYieldEndTime;
           if (streamEventCount > 0 && consumerLag > maxConsumerLagMs) {
@@ -471,8 +504,9 @@ async function* agentLoop(messages, options) {
           maxConsumerLagMs,
           eventTypes: eventTypeCounts
         });
-        response = await result.response;
+        response = await abortablePromise(result.response, streamController.signal);
       } catch (err) {
+        if (streamController.signal.aborted) closeIterator(streamIterator);
         const errMsg = err instanceof Error ? err.message : String(err);
         diag("stream_error", {
           error: errMsg.slice(0, 200),
@@ -872,7 +906,10 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
           });
         }
       };
-      const raw = await tool.execute(parsed, ctx);
+      const raw = await abortablePromise(
+        Promise.resolve().then(() => tool.execute(parsed, ctx)),
+        ctx.signal
+      );
       const normalized = normalizeToolResult(raw);
       resultContent = normalized.content;
       details = normalized.details;