@pencil-agent/nano-pencil 1.14.5 → 1.14.6

package/dist/build-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.14.5",
-  "commitHash": "5845e2c",
+  "version": "1.14.6",
+  "commitHash": "111a12b",
   "branch": "main",
-  "builtAt": "2026-05-28T06:36:42.739Z"
+  "builtAt": "2026-05-28T14:39:06.773Z"
 }

package/dist/node_modules/@pencil-agent/agent-core/agent-loop-stream-events.d.ts

@@ -0,0 +1,18 @@
+/**
+ * [WHO]: Provides waitForAbortableOperation(), waitForAssistantStream(), waitForAssistantStreamEvent()
+ * [FROM]: Depends on @pencil-agent/ai AssistantMessageEvent/AssistantMessageEventStream contracts.
+ * [TO]: Consumed by standard and structured-adaptive agent loops.
+ * [HERE]: packages/agent-core/src/agent-loop-stream-events.ts within agent-core; shared abortable operation and assistant-stream iterator utilities.
+ */
+import type { AssistantMessageEvent, AssistantMessageEventStream } from "@pencil-agent/ai";
+export type AssistantStreamNext = IteratorResult<AssistantMessageEvent> | "aborted";
+export type AssistantStreamStart = AssistantMessageEventStream | "aborted";
+export type AbortableOperationResult<T> = {
+    type: "resolved";
+    value: T;
+} | {
+    type: "aborted";
+};
+export declare function waitForAbortableOperation<T>(valueOrPromise: T | Promise<T>, signal?: AbortSignal): Promise<AbortableOperationResult<T>>;
+export declare function waitForAssistantStream(streamOrPromise: AssistantMessageEventStream | Promise<AssistantMessageEventStream>, signal?: AbortSignal): Promise<AssistantStreamStart>;
+export declare function waitForAssistantStreamEvent(iterator: AsyncIterator<AssistantMessageEvent>, signal?: AbortSignal): Promise<AssistantStreamNext>;

package/dist/node_modules/@pencil-agent/agent-core/agent-loop-stream-events.js

@@ -0,0 +1,55 @@
+/**
+ * [WHO]: Provides waitForAbortableOperation(), waitForAssistantStream(), waitForAssistantStreamEvent()
+ * [FROM]: Depends on @pencil-agent/ai AssistantMessageEvent/AssistantMessageEventStream contracts.
+ * [TO]: Consumed by standard and structured-adaptive agent loops.
+ * [HERE]: packages/agent-core/src/agent-loop-stream-events.ts within agent-core; shared abortable operation and assistant-stream iterator utilities.
+ */
+export function waitForAbortableOperation(valueOrPromise, signal) {
+    if (signal?.aborted)
+        return Promise.resolve({ type: "aborted" });
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            signal?.removeEventListener("abort", onAbort);
+        };
+        const onAbort = () => {
+            cleanup();
+            resolve({ type: "aborted" });
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        Promise.resolve(valueOrPromise).then((value) => {
+            cleanup();
+            resolve({ type: "resolved", value });
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
+export function waitForAssistantStream(streamOrPromise, signal) {
+    return waitForAbortableOperation(streamOrPromise, signal).then((result) => {
+        if (result.type === "aborted")
+            return "aborted";
+        return result.value;
+    });
+}
+export function waitForAssistantStreamEvent(iterator, signal) {
+    if (signal?.aborted)
+        return Promise.resolve("aborted");
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            signal?.removeEventListener("abort", onAbort);
+        };
+        const onAbort = () => {
+            cleanup();
+            resolve("aborted");
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        iterator.next().then((result) => {
+            cleanup();
+            resolve(result);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}

package/dist/node_modules/@pencil-agent/agent-core/agent-loop.js

@@ -14,6 +14,7 @@ import { computeRecoveryMaxTokens, createOutputTokenRecoveryMessage, createToken
 import { createInterruptedToolResults, createSkippedToolCallLimitResults, enforceToolResultBatchSize, } from "./agent-loop-tool-results.js";
 import { flushReadyToolUseSummaries, startToolUseSummary, } from "./agent-loop-tool-summaries.js";
 import { buildAgentRunPolicy, resolveAgentRunLoopFramework } from "./agent-run-result.js";
+import { waitForAbortableOperation, waitForAssistantStream, waitForAssistantStreamEvent, } from "./agent-loop-stream-events.js";
 const DEFAULT_MAX_TURNS_PER_PROMPT = 64;
 const DEFAULT_MAX_TOOL_CALLS_PER_PROMPT = 128;
 const DEFAULT_MAX_STOP_HOOK_CONTINUATIONS = 3;
@@ -150,7 +151,21 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
     let stopHookActive = false;
     let stopHookContinuationCount = 0;
     // Check for steering messages at start (user may have typed while waiting)
-    let pendingMessages = (await config.getSteeringMessages?.()) || [];
+    const initialSteeringMessages = await waitForAbortableOperation(config.getSteeringMessages ? config.getSteeringMessages() : [], signal);
+    if (initialSteeringMessages.type === "aborted") {
+        finishStandardLoopWithAbortedTurn(stream, currentContext, newMessages, {
+            config,
+            turnCount,
+            toolCallCount,
+            startedAt,
+            usage,
+            permissionDenials,
+            transitions,
+            lastTransition,
+        });
+        return;
+    }
+    let pendingMessages = initialSteeringMessages.value || [];
     // Outer loop: continues when queued follow-up messages arrive after agent would stop
     while (true) {
         let hasMoreToolCalls = true;
@@ -341,12 +356,26 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
             }
             if (!hasMoreToolCalls && config.runStopHooks && !stopHookActive) {
                 stopHookActive = true;
-                const stopHookResult = await config.runStopHooks({
+                const stopHookResult = await waitForAbortableOperation(config.runStopHooks({
                     message,
                     messages: currentContext.messages,
-                });
+                }), signal);
                 stopHookActive = false;
-                if (stopHookResult.action === "continue" && stopHookResult.messages.length > 0) {
+                if (stopHookResult.type === "aborted") {
+                    finishStandardLoopWithAbortedTurn(stream, currentContext, newMessages, {
+                        config,
+                        turnCount,
+                        toolCallCount,
+                        startedAt,
+                        usage,
+                        permissionDenials,
+                        transitions,
+                        lastTransition,
+                    });
+                    return;
+                }
+                const resolvedStopHookResult = stopHookResult.value;
+                if (resolvedStopHookResult.action === "continue" && resolvedStopHookResult.messages.length > 0) {
                     if (stopHookContinuationCount >= maxStopHookContinuations) {
                         const limitMessage = createLoopLimitMessage(config, `stop_hook_limit_reached: stopped after ${maxStopHookContinuations} stop-hook continuation turns.`);
                         currentContext.messages.push(limitMessage);
@@ -374,7 +403,7 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
                         return;
                     }
                     stopHookContinuationCount += 1;
-                    pendingMessages = stopHookResult.messages;
+                    pendingMessages = resolvedStopHookResult.messages;
                     recordTransition({
                         reason: "stop_hook_blocking",
                         continuationCount: stopHookContinuationCount,
@@ -406,7 +435,21 @@ async function runLoop(currentContext, newMessages, config, signal, stream, stre
             }
         }
         // Agent would stop here. Check for follow-up messages.
-        const followUpMessages = (await config.getFollowUpMessages?.()) || [];
+        const followUpMessagesResult = await waitForAbortableOperation(config.getFollowUpMessages ? config.getFollowUpMessages() : [], signal);
+        if (followUpMessagesResult.type === "aborted") {
+            finishStandardLoopWithAbortedTurn(stream, currentContext, newMessages, {
+                config,
+                turnCount,
+                toolCallCount,
+                startedAt,
+                usage,
+                permissionDenials,
+                transitions,
+                lastTransition,
+            });
+            return;
+        }
+        const followUpMessages = followUpMessagesResult.value || [];
         if (followUpMessages.length > 0) {
             // Set as pending so inner loop processes them
             pendingMessages = followUpMessages;
@@ -436,10 +479,18 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
     // Apply context transform if configured (AgentMessage[] → AgentMessage[])
     let messages = context.messages;
     if (config.transformContext) {
-        messages = await config.transformContext(messages, signal);
+        const transformedMessages = await waitForAbortableOperation(config.transformContext(messages, signal), signal);
+        if (transformedMessages.type === "aborted") {
+            return pushAbortedAssistantMessage(context, stream, config);
+        }
+        messages = transformedMessages.value;
     }
     // Convert to LLM-compatible messages (AgentMessage[] → Message[])
-    const llmMessages = await config.convertToLlm(messages);
+    const convertedMessages = await waitForAbortableOperation(config.convertToLlm(messages), signal);
+    if (convertedMessages.type === "aborted") {
+        return pushAbortedAssistantMessage(context, stream, config);
+    }
+    const llmMessages = convertedMessages.value;
     // Build LLM context
     const llmContext = {
         systemPrompt: context.systemPrompt,
@@ -448,7 +499,11 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
     };
     const streamFunction = streamFn || streamSimple;
     // Resolve API key (important for expiring tokens)
-    const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
+    const apiKeyResult = await waitForAbortableOperation(config.getApiKey ? config.getApiKey(config.model.provider) : undefined, signal);
+    if (apiKeyResult.type === "aborted") {
+        return pushAbortedAssistantMessage(context, stream, config);
+    }
+    const resolvedApiKey = apiKeyResult.value || config.apiKey;
     stream.push({
         type: "stream_request_start",
         model: config.model.id,
@@ -457,15 +512,58 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
         messageCount: llmMessages.length,
         maxTokens: maxTokensOverride ?? config.maxTokens,
     });
-    const response = await streamFunction(config.model, llmContext, {
+    const response = await waitForAssistantStream(streamFunction(config.model, llmContext, {
         ...config,
         maxTokens: maxTokensOverride ?? config.maxTokens,
         apiKey: resolvedApiKey,
         signal,
-    });
+    }), signal);
+    if (response === "aborted") {
+        const finalMessage = createLoopLimitMessage(config, "Request was aborted");
+        finalMessage.stopReason = "aborted";
+        context.messages.push(finalMessage);
+        stream.push({ type: "message_start", message: { ...finalMessage } });
+        stream.push({ type: "message_end", message: finalMessage });
+        return finalMessage;
+    }
     let partialMessage = null;
     let addedPartial = false;
-    for await (const event of response) {
+    const responseIterator = response[Symbol.asyncIterator]();
+    while (true) {
+        let nextEvent;
+        try {
+            nextEvent = await waitForAssistantStreamEvent(responseIterator, signal);
+        }
+        catch (error) {
+            const finalMessage = createLoopLimitMessage(config, error instanceof Error ? error.message : String(error));
+            if (addedPartial) {
+                context.messages[context.messages.length - 1] = finalMessage;
+            }
+            else {
+                context.messages.push(finalMessage);
+                stream.push({ type: "message_start", message: { ...finalMessage } });
+            }
+            stream.push({ type: "message_end", message: finalMessage });
+            return finalMessage;
+        }
+        if (nextEvent === "aborted") {
+            void responseIterator.return?.();
+            const finalMessage = createLoopLimitMessage(config, "Request was aborted");
+            finalMessage.stopReason = "aborted";
+            if (addedPartial) {
+                context.messages[context.messages.length - 1] = finalMessage;
+            }
+            else {
+                context.messages.push(finalMessage);
+                stream.push({ type: "message_start", message: { ...finalMessage } });
+            }
+            stream.push({ type: "message_end", message: finalMessage });
+            return finalMessage;
+        }
+        if (nextEvent.done) {
+            break;
+        }
+        const event = nextEvent.value;
         switch (event.type) {
             case "start":
                 partialMessage = event.partial;
@@ -494,7 +592,7 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
                 break;
             case "done":
             case "error": {
-                const finalMessage = await response.result();
+                const finalMessage = event.type === "done" ? event.message : event.error;
                 if (addedPartial) {
                     context.messages[context.messages.length - 1] = finalMessage;
                 }
@@ -509,7 +607,8 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
             }
         }
     }
-    const finalMessage = await response.result();
+    const finalMessage = response.resultIfResolved() ??
+        createLoopLimitMessage(config, "Provider stream ended without a final assistant message");
     if (addedPartial) {
         context.messages[context.messages.length - 1] = finalMessage;
     }
@@ -520,6 +619,29 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
     stream.push({ type: "message_end", message: finalMessage });
     return finalMessage;
 }
+function pushAbortedAssistantMessage(context, stream, config) {
+    const finalMessage = createLoopLimitMessage(config, "Request was aborted");
+    finalMessage.stopReason = "aborted";
+    context.messages.push(finalMessage);
+    stream.push({ type: "message_start", message: { ...finalMessage } });
+    stream.push({ type: "message_end", message: finalMessage });
+    return finalMessage;
+}
+function finishStandardLoopWithAbortedTurn(stream, context, newMessages, options) {
+    const finalMessage = createLoopLimitMessage(options.config, "Request was aborted");
+    finalMessage.stopReason = "aborted";
+    context.messages.push(finalMessage);
+    newMessages.push(finalMessage);
+    stream.push({ type: "message_start", message: { ...finalMessage } });
+    stream.push({ type: "message_end", message: finalMessage });
+    stream.push({ type: "turn_end", message: finalMessage, toolResults: [] });
+    finishStandardLoop(stream, newMessages, {
+        ...options,
+        stopReason: "aborted",
+        errorMessage: finalMessage.errorMessage,
+        errorSubtype: "aborted",
+    });
+}
 function finishStandardLoop(stream, newMessages, options) {
     stream.push({
         type: "agent_result",

package/dist/node_modules/@pencil-agent/agent-core/structured-adaptive-agent-loop.js

@@ -17,6 +17,7 @@ import { computeRecoveryMaxTokens, createOutputTokenRecoveryMessage, createToken
 import { createInterruptedToolResults, createSkippedToolCallLimitResults, enforceToolResultBatchSize, } from "./agent-loop-tool-results.js";
 import { flushReadyToolUseSummaries, startToolUseSummary, } from "./agent-loop-tool-summaries.js";
 import { buildAgentRunPolicy, resolveAgentRunLoopFramework } from "./agent-run-result.js";
+import { waitForAbortableOperation, waitForAssistantStream, waitForAssistantStreamEvent, } from "./agent-loop-stream-events.js";
 const DEFAULT_MAX_TURNS_PER_PROMPT = 64;
 const DEFAULT_MAX_TOOL_CALLS_PER_PROMPT = 128;
 const DEFAULT_MAX_OUTPUT_TOKEN_RECOVERY_ATTEMPTS = 1;
@@ -76,13 +77,14 @@ async function runStructuredAdaptiveQueryLoop(currentContext, newMessages, confi
     const maxOutputTokenRecoveryAttempts = config.maxOutputTokenRecoveryAttempts ?? DEFAULT_MAX_OUTPUT_TOKEN_RECOVERY_ATTEMPTS;
     const maxStopHookContinuations = config.maxStopHookContinuations ?? DEFAULT_MAX_STOP_HOOK_CONTINUATIONS;
     const maxModelErrorRecoveryAttempts = config.maxModelErrorRecoveryAttempts ?? DEFAULT_MAX_MODEL_ERROR_RECOVERY_ATTEMPTS;
+    const initialSteeringMessages = await waitForAbortableOperation(config.getSteeringMessages ? config.getSteeringMessages() : [], signal);
     const state = {
         config,
         turnCount: 0,
         toolCallCount: 0,
         transition: { reason: "start" },
         transitions: [],
-        pendingMessages: (await config.getSteeringMessages?.()) || [],
+        pendingMessages: initialSteeringMessages.type === "resolved" ? initialSteeringMessages.value || [] : [],
         pendingToolUseSummaries: [],
         stopHookActive: false,
         stopHookContinuationCount: 0,
@@ -94,6 +96,10 @@ async function runStructuredAdaptiveQueryLoop(currentContext, newMessages, confi
         usage: emptyUsage(),
         permissionDenials: [],
     };
+    if (initialSteeringMessages.type === "aborted") {
+        finishStructuredAdaptiveWithAbortedTurn(stream, currentContext, newMessages, state);
+        return;
+    }
     let firstTurn = true;
     while (true) {
         if (!firstTurn) {
@@ -208,12 +214,17 @@ async function runStructuredAdaptiveQueryLoop(currentContext, newMessages, confi
             }
             if (config.runStopHooks && !state.stopHookActive) {
                 state.stopHookActive = true;
-                const stopHookResult = await config.runStopHooks({
+                const stopHookResult = await waitForAbortableOperation(config.runStopHooks({
                     message,
                     messages: currentContext.messages,
-                });
+                }), signal);
                 state.stopHookActive = false;
-                if (stopHookResult.action === "continue" && stopHookResult.messages.length > 0) {
+                if (stopHookResult.type === "aborted") {
+                    finishStructuredAdaptiveWithAbortedTurn(stream, currentContext, newMessages, state);
+                    return;
+                }
+                const resolvedStopHookResult = stopHookResult.value;
+                if (resolvedStopHookResult.action === "continue" && resolvedStopHookResult.messages.length > 0) {
                     if (state.stopHookContinuationCount >= maxStopHookContinuations) {
                         const limitMessage = createLoopLimitMessage(config, `stop_hook_limit_reached: stopped after ${maxStopHookContinuations} stop-hook continuation turns.`);
                         currentContext.messages.push(limitMessage);
@@ -233,7 +244,7 @@ async function runStructuredAdaptiveQueryLoop(currentContext, newMessages, confi
                         return;
                     }
                     state.stopHookContinuationCount += 1;
-                    state.pendingMessages = stopHookResult.messages;
+                    state.pendingMessages = resolvedStopHookResult.messages;
                     recordTransition(state, {
                         reason: "stop_hook_blocking",
                         continuationCount: state.stopHookContinuationCount,
@@ -253,7 +264,12 @@ async function runStructuredAdaptiveQueryLoop(currentContext, newMessages, confi
                 });
                 continue;
             }
-            const followUpMessages = (await config.getFollowUpMessages?.()) || [];
+            const followUpMessagesResult = await waitForAbortableOperation(config.getFollowUpMessages ? config.getFollowUpMessages() : [], signal);
+            if (followUpMessagesResult.type === "aborted") {
+                finishStructuredAdaptiveWithAbortedTurn(stream, currentContext, newMessages, state);
+                return;
+            }
+            const followUpMessages = followUpMessagesResult.value || [];
             if (followUpMessages.length === 0) {
                 break;
             }
@@ -329,16 +345,28 @@ async function runStructuredAdaptiveQueryLoop(currentContext, newMessages, confi
 async function streamAssistantResponse(context, config, signal, stream, streamFn, maxTokensOverride, streamingToolExecutor) {
     let messages = context.messages;
     if (config.transformContext) {
-        messages = await config.transformContext(messages, signal);
+        const transformedMessages = await waitForAbortableOperation(config.transformContext(messages, signal), signal);
+        if (transformedMessages.type === "aborted") {
+            return pushAbortedAssistantMessage(context, stream, config);
+        }
+        messages = transformedMessages.value;
+    }
+    const convertedMessages = await waitForAbortableOperation(config.convertToLlm(messages), signal);
+    if (convertedMessages.type === "aborted") {
+        return pushAbortedAssistantMessage(context, stream, config);
     }
-    const llmMessages = await config.convertToLlm(messages);
+    const llmMessages = convertedMessages.value;
     const llmContext = {
         systemPrompt: context.systemPrompt,
         messages: llmMessages,
         tools: context.tools,
     };
     const streamFunction = streamFn || streamSimple;
-    const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
+    const apiKeyResult = await waitForAbortableOperation(config.getApiKey ? config.getApiKey(config.model.provider) : undefined, signal);
+    if (apiKeyResult.type === "aborted") {
+        return pushAbortedAssistantMessage(context, stream, config);
+    }
+    const resolvedApiKey = apiKeyResult.value || config.apiKey;
     stream.push({
         type: "stream_request_start",
         model: config.model.id,
@@ -347,15 +375,58 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
         messageCount: llmMessages.length,
         maxTokens: maxTokensOverride ?? config.maxTokens,
     });
-    const response = await streamFunction(config.model, llmContext, {
+    const response = await waitForAssistantStream(streamFunction(config.model, llmContext, {
         ...config,
         maxTokens: maxTokensOverride ?? config.maxTokens,
         apiKey: resolvedApiKey,
         signal,
-    });
+    }), signal);
+    if (response === "aborted") {
+        const finalMessage = createLoopLimitMessage(config, "Request was aborted");
+        finalMessage.stopReason = "aborted";
+        context.messages.push(finalMessage);
+        stream.push({ type: "message_start", message: { ...finalMessage } });
+        stream.push({ type: "message_end", message: finalMessage });
+        return finalMessage;
+    }
     let partialMessage = null;
     let addedPartial = false;
-    for await (const event of response) {
+    const responseIterator = response[Symbol.asyncIterator]();
+    while (true) {
+        let nextEvent;
+        try {
+            nextEvent = await waitForAssistantStreamEvent(responseIterator, signal);
+        }
+        catch (error) {
+            const finalMessage = createLoopLimitMessage(config, error instanceof Error ? error.message : String(error));
+            if (addedPartial) {
+                context.messages[context.messages.length - 1] = finalMessage;
+            }
+            else {
+                context.messages.push(finalMessage);
+                stream.push({ type: "message_start", message: { ...finalMessage } });
+            }
+            stream.push({ type: "message_end", message: finalMessage });
+            return finalMessage;
+        }
+        if (nextEvent === "aborted") {
+            void responseIterator.return?.();
+            const finalMessage = createLoopLimitMessage(config, "Request was aborted");
+            finalMessage.stopReason = "aborted";
+            if (addedPartial) {
+                context.messages[context.messages.length - 1] = finalMessage;
+            }
+            else {
+                context.messages.push(finalMessage);
+                stream.push({ type: "message_start", message: { ...finalMessage } });
+            }
+            stream.push({ type: "message_end", message: finalMessage });
+            return finalMessage;
+        }
+        if (nextEvent.done) {
+            break;
+        }
+        const event = nextEvent.value;
         switch (event.type) {
             case "start":
                 partialMessage = event.partial;
@@ -395,7 +466,7 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
                 break;
             case "done":
             case "error": {
-                const finalMessage = await response.result();
+                const finalMessage = event.type === "done" ? event.message : event.error;
                 if (addedPartial) {
                     context.messages[context.messages.length - 1] = finalMessage;
                 }
@@ -410,7 +481,8 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
             }
         }
     }
-    const finalMessage = await response.result();
+    const finalMessage = response.resultIfResolved() ??
+        createLoopLimitMessage(config, "Provider stream ended without a final assistant message");
     if (addedPartial) {
         context.messages[context.messages.length - 1] = finalMessage;
     }
@@ -421,6 +493,27 @@ async function streamAssistantResponse(context, config, signal, stream, streamFn
     stream.push({ type: "message_end", message: finalMessage });
     return finalMessage;
 }
+function pushAbortedAssistantMessage(context, stream, config) {
+    const finalMessage = createLoopLimitMessage(config, "Request was aborted");
+    finalMessage.stopReason = "aborted";
+    context.messages.push(finalMessage);
+    stream.push({ type: "message_start", message: { ...finalMessage } });
+    stream.push({ type: "message_end", message: finalMessage });
+    return finalMessage;
+}
+function finishStructuredAdaptiveWithAbortedTurn(stream, context, newMessages, state) {
+    const finalMessage = createLoopLimitMessage(state.config, "Request was aborted");
+    finalMessage.stopReason = "aborted";
+    context.messages.push(finalMessage);
+    newMessages.push(finalMessage);
+    stream.push({ type: "message_start", message: { ...finalMessage } });
+    stream.push({ type: "message_end", message: finalMessage });
+    stream.push({ type: "turn_end", message: finalMessage, toolResults: [] });
+    state.finalStopReason = "aborted";
+    state.finalErrorMessage = finalMessage.errorMessage;
+    state.finalErrorSubtype = "aborted";
+    finish(stream, newMessages, state);
+}
 function createLoopLimitMessage(config, errorMessage) {
     return {
         role: "assistant",

package/dist/node_modules/@pencil-agent/ai/stream.js

@@ -113,6 +113,54 @@ function createStreamErrorMessage(model, error) {
 function createMissingStreamResultMessage(model) {
     return createStreamErrorMessage(model, new Error("Provider stream ended without a final assistant message"));
 }
+function createAbortMessage(model) {
+    return createStreamErrorMessage(model, new Error("Request was aborted"));
+}
+function emitAbortError(stream, model) {
+    stream.push({ type: "error", reason: "error", error: createAbortMessage(model) });
+}
+function waitForRetryDelay(delayMs, signal) {
+    if (signal?.aborted)
+        return Promise.resolve("aborted");
+    return new Promise((resolve) => {
+        let timeout;
+        const cleanup = () => {
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        const onAbort = () => {
+            cleanup();
+            resolve("aborted");
+        };
+        timeout = setTimeout(() => {
+            cleanup();
+            resolve("elapsed");
+        }, delayMs);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function waitForStreamEvent(iterator, signal) {
+    if (signal?.aborted)
+        return Promise.resolve("aborted");
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            signal?.removeEventListener("abort", onAbort);
+        };
+        const onAbort = () => {
+            cleanup();
+            resolve("aborted");
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        iterator.next().then((result) => {
+            cleanup();
+            resolve(result);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
 // =============================================================================
 // Provider Resolution
 // =============================================================================
@@ -163,18 +211,7 @@ function wrapWithRetry(model, createStream, retryOptions, signal) {
         let attempt = 0;
         while (attempt <= retryOptions.maxRetries) {
             if (signal?.aborted) {
-                const errorMessage = {
-                    role: "assistant",
-                    content: [],
-                    api: model.api,
-                    provider: model.provider,
-                    model: model.id,
-                    stopReason: "error",
-                    errorMessage: "Request was aborted",
-                    usage: emptyUsage(),
-                    timestamp: Date.now(),
-                };
-                outerStream.push({ type: "error", reason: "error", error: errorMessage });
+                emitAbortError(outerStream, model);
                 return;
             }
             let innerStream;
@@ -186,7 +223,10 @@ function wrapWithRetry(model, createStream, retryOptions, signal) {
                 const delayMs = getRetryDelayMs(errorMessage, attempt, retryOptions);
                 if (delayMs !== undefined) {
                     attempt++;
-                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                    if ((await waitForRetryDelay(delayMs, signal)) === "aborted") {
+                        emitAbortError(outerStream, model);
+                        return;
+                    }
                     continue;
                 }
                 outerStream.push({ type: "error", reason: "error", error: errorMessage });
@@ -194,7 +234,35 @@ function wrapWithRetry(model, createStream, retryOptions, signal) {
             }
             // Forward all events from inner to outer, but intercept the final result
             let lastMessage = null;
-            for await (const event of innerStream) {
+            const innerIterator = innerStream[Symbol.asyncIterator]();
+            while (true) {
+                let nextEvent;
+                try {
+                    nextEvent = await waitForStreamEvent(innerIterator, signal);
+                }
+                catch (error) {
+                    lastMessage = createStreamErrorMessage(model, error);
+                    const delayMs = getRetryDelayMs(lastMessage, attempt, retryOptions);
+                    if (delayMs !== undefined) {
+                        attempt++;
+                        if ((await waitForRetryDelay(delayMs, signal)) === "aborted") {
+                            emitAbortError(outerStream, model);
+                            return;
+                        }
+                        break;
+                    }
+                    outerStream.push({ type: "error", reason: "error", error: lastMessage });
+                    return;
+                }
+                if (nextEvent === "aborted") {
+                    void innerIterator.return?.();
+                    emitAbortError(outerStream, model);
+                    return;
+                }
+                if (nextEvent.done) {
+                    break;
+                }
+                const event = nextEvent.value;
                 if (event.type === "done") {
                     lastMessage = event.message;
                     outerStream.push(event);
@@ -206,7 +274,10 @@ function wrapWithRetry(model, createStream, retryOptions, signal) {
                     const delayMs = getRetryDelayMs(lastMessage, attempt, retryOptions);
                     if (delayMs !== undefined) {
                         attempt++;
-                        await new Promise((resolve) => setTimeout(resolve, delayMs));
+                        if ((await waitForRetryDelay(delayMs, signal)) === "aborted") {
+                            emitAbortError(outerStream, model);
+                            return;
+                        }
                         break; // Break inner loop, retry outer loop
                     }
                     // Non-retriable or max retries exhausted — forward error
@@ -226,7 +297,10 @@ function wrapWithRetry(model, createStream, retryOptions, signal) {
                 const delayMs = getRetryDelayMs(lastMessage, attempt, retryOptions);
                 if (delayMs !== undefined) {
                     attempt++;
-                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                    if ((await waitForRetryDelay(delayMs, signal)) === "aborted") {
+                        emitAbortError(outerStream, model);
+                        return;
+                    }
                     continue;
                 }
                 if (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pencil-agent/nano-pencil",
-  "version": "1.14.5",
+  "version": "1.14.6",
   "description": "CLI writing agent with read, bash, edit, write tools and session management. Supports DashScope and Ali Token Plan. Soul enabled by default for AI personality evolution.",
   "type": "module",
   "bin": {