@code-yeongyu/senpi-agent-core 2026.10.16 → 2026.10.18

package/dist/agent-loop.js

@@ -452,10 +452,14 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
         }
     }
     try {
-        const llmContext = await buildProviderContext(context, config, signal);
+        // The start bound (or, without one, the idle bound) runs from here, not from the first stream read: the
+        // context transform, the key lookup and the stream function can each hang, and a hung step must end the
+        // turn with a provider failure like a provider that never answers (senpi#3471).
+        const preStream = createPreStreamBound(normalizeTimeoutMs(config.streamStartTimeoutMs), normalizeTimeoutMs(streamIdleTimeoutMs), requestAbortController);
+        const llmContext = await preStream.run(buildProviderContext(context, config, requestAbortController.signal));
         // Resolve API key (important for expiring tokens)
-        const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
-        const response = await streamFunction(config.model, llmContext, {
+        const resolvedApiKey = (config.getApiKey ? await preStream.run(config.getApiKey(config.model.provider)) : undefined) || config.apiKey;
+        const response = await preStream.run(streamFunction(config.model, llmContext, {
             ...config,
             streamKind: "main",
             apiKey: resolvedApiKey,
@@ -472,11 +476,17 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                     },
                 }
                 : {}),
+        }), 
+        // A stream that arrives after the bound ended the turn is closed here, not left to the provider.
+        // A custom stream function may resolve to something that is not a stream; there is nothing to close then.
+        (late) => {
+            if (typeof late?.[Symbol.asyncIterator] === "function")
+                closeAssistantIterator(late[Symbol.asyncIterator]());
         });
         // Record the requested level, whichever stream function answered.
         const result = async () => Object.assign(await response.result(), { thinkingLevel: config.reasoning ?? "off" });
         const iterator = response[Symbol.asyncIterator]();
-        const eventReader = createAssistantEventReader(iterator, streamIdleTimeoutMs, requestAbortController.signal, (error) => requestAbortController.abort(error), config.streamStartTimeoutMs, response);
+        const eventReader = createAssistantEventReader(iterator, streamIdleTimeoutMs, requestAbortController.signal, (error) => requestAbortController.abort(error), preStream.remainingStartMs(), response, normalizeTimeoutMs(config.streamStartTimeoutMs));
         try {
             while (true) {
                 const next = await eventReader.next();
@@ -599,7 +609,13 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
             await emit({ type: "message_end", message: finalMessage });
             return { message: finalMessage, providerToolResults };
         }
-        const finalMessage = createTerminalFailureAssistantMessage(config.model, signal?.aborted ? "aborted" : "error", error, partialMessage);
+        // A caller abort is the reason a turn ended even when the bound fired first on a step that never finished:
+        // the user gets the abort's own message, not a timeout and advice to raise it (#3481).
+        // A step that rethrows the caller's own reason (`throwIfAborted()`, a fetch rejected with it) shows that reason
+        // through the same shaping and cap (#3510).
+        const callerAbortedPastBound = signal?.aborted === true &&
+            (error instanceof StreamStartTimeoutError || isStreamIdleTimeoutError(error) || error === signal.reason);
+        const finalMessage = createTerminalFailureAssistantMessage(config.model, signal?.aborted ? "aborted" : "error", callerAbortedPastBound ? abortError(signal.reason) : error, partialMessage);
         propagateThinkingTiming(finalMessage);
         if (addedPartial) {
             context.messages[context.messages.length - 1] = finalMessage;
@@ -617,18 +633,94 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
     }
 }
 const ABORTED = Symbol("aborted");
+const MAX_ABORT_REASON_CHARS = 500;
 function abortError(reason) {
-    return reason instanceof Error ? reason : new Error("Request was aborted");
+    if (reason instanceof Error)
+        return reason;
+    // A caller's own words are its abort reason: a plain string, or an object carrying a `message` (#3510).
+    const text = abortReasonText(reason);
+    if (text === undefined)
+        return new Error("Request was aborted");
+    const characters = Array.from(text);
+    return new Error(characters.length > MAX_ABORT_REASON_CHARS ? `${characters.slice(0, MAX_ABORT_REASON_CHARS).join("")}…` : text);
+}
+function abortReasonText(reason) {
+    const text = typeof reason === "string"
+        ? reason
+        : typeof reason === "object" && reason !== null && "message" in reason && typeof reason.message === "string"
+            ? reason.message
+            : undefined;
+    return text !== undefined && text.trim() !== "" ? text : undefined;
 }
 function closeAssistantIterator(iterator) {
     void Promise.resolve(iterator.return?.()).catch(() => undefined);
 }
+/**
+ * The bound on everything before a provider stream's first event. With a start bound the budget is shared:
+ * whatever the steps before the stream used, the first read only gets the rest. Without one the idle bound
+ * covers each step, as it covers each wait between events.
+ */
+function createPreStreamBound(startTimeoutMs, idleTimeoutMs, request) {
+    const startedAt = Date.now();
+    const remaining = () => startTimeoutMs === undefined ? idleTimeoutMs : Math.max(0, startTimeoutMs - (Date.now() - startedAt));
+    const timeoutError = () => startTimeoutMs === undefined
+        ? new StreamIdleTimeoutError(idleTimeoutMs ?? 0)
+        : new StreamStartTimeoutError(startTimeoutMs);
+    return {
+        run(work, discardLate) {
+            const budget = remaining();
+            // Only the bound ends a step here. A caller abort is not raced: the step sees it through the request
+            // signal and ends the way it did before this bound existed (the turn then reads aborted), so an abort
+            // and a timeout never compete for the same step.
+            if (budget === undefined)
+                return Promise.resolve(work);
+            return new Promise((resolve, reject) => {
+                let timer;
+                let settled = false;
+                const finish = (complete) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                    complete();
+                };
+                // Handle the work's outcome first, so work that settles after the turn ended neither goes unhandled
+                // nor leaks: a late value is handed to discardLate, a late rejection is dropped.
+                Promise.resolve(work).then((value) => {
+                    if (settled) {
+                        // The turn already ended; the value is only cleaned up. A cleanup that throws must not
+                        // become an unhandled rejection of a request nobody waits for any more.
+                        try {
+                            discardLate?.(value);
+                        }
+                        catch { }
+                        return;
+                    }
+                    finish(() => resolve(value));
+                }, (error) => finish(() => reject(error)));
+                timer = setTimeout(() => {
+                    const error = timeoutError();
+                    finish(() => reject(error));
+                    // Abort after rejecting so the failure reads as the timeout, and the hung step is told to stop.
+                    request.abort(error);
+                }, budget);
+            });
+        },
+        // A start bound already spent before the stream answered still ends the first read at once.
+        remainingStartMs: () => (startTimeoutMs === undefined ? undefined : Math.max(1, remaining() ?? 1)),
+    };
+}
 function normalizeTimeoutMs(timeoutMs) {
     return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
 }
-function createAssistantEventReader(iterator, timeoutMs, signal, onIdleTimeout, streamStartTimeoutMs, stream) {
+function createAssistantEventReader(iterator, timeoutMs, signal, onIdleTimeout, streamStartTimeoutMs, stream, 
+// The bound the error names, when the timer only gets what is left of it (the steps before the stream used
+// the rest); the error must name the configured bound, which users raise.
+configuredStartTimeoutMs) {
     const idleTimeoutMs = normalizeTimeoutMs(timeoutMs);
     const startTimeoutMs = normalizeTimeoutMs(streamStartTimeoutMs);
+    const reportedStartTimeoutMs = configuredStartTimeoutMs ?? startTimeoutMs;
     let sawFirstEvent = false;
     let removeAbortListener;
     let abortPromise;
@@ -655,7 +747,7 @@ function createAssistantEventReader(iterator, timeoutMs, signal, onIdleTimeout,
             const useStartBound = !sawFirstEvent && startTimeoutMs !== undefined;
             const readTimeoutMs = useStartBound ? startTimeoutMs : idleTimeoutMs;
             const makeTimeoutError = useStartBound
-                ? (ms) => new StreamStartTimeoutError(ms)
+                ? (ms) => new StreamStartTimeoutError(reportedStartTimeoutMs ?? ms)
                 : (ms) => new StreamIdleTimeoutError(ms);
             const result = await readNextAssistantEvent(iterator, readTimeoutMs, makeTimeoutError, abortPromise, onIdleTimeout, stream, signal);
             if (!result.done)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-agent-core",
-	"version": "2026.10.16",
+	"version": "2026.10.18",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -62,8 +62,8 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.16",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.16",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.18",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.18",
 		"diff": "9.0.0",
 		"ignore": "7.0.9",
 		"typebox": "1.3.34",