@code-yeongyu/senpi 2026.8.21 → 2026.8.22-2

package/dist/core/agent-session.js

@@ -27,7 +27,7 @@ import { resolvePath } from "../utils/paths.js";
 import { sleep } from "../utils/sleep.js";
 import { normalizeToolResultImages } from "../utils/tool-result-images.js";
 import { AgentAbortProvenance } from "./agent-abort-provenance.js";
-import { AgentSettledDelivery } from "./agent-settled-delivery.js";
+import { AgentSettledDelivery, } from "./agent-settled-delivery.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { envValue } from "./brand.js";
@@ -327,6 +327,7 @@ export class AgentSession {
         this._toolExecutionDepth = 0;
         this._promptStartPending = false;
         this._nextInputId = 0;
+        this._settlementEpoch = 0;
         /** Tracks pending steering messages for UI display. Removed when delivered. */
         this._steeringMessages = [];
         /** Tracks pending follow-up messages for UI display. Removed when delivered. */
@@ -992,13 +993,15 @@ export class AgentSession {
         }
         this._isAgentRunActive = false;
         let deferredActions = [];
+        let deferredTurnClaims = [];
         this._agentSettledDelivery.begin(this._userAbortGeneration);
+        const settlementEpoch = ++this._settlementEpoch;
         try {
             await this._extensionRunner.emit({ type: "agent_settled" });
             this._emit({ type: "agent_settled" });
             if (this._abortProvenance.takeLateUserJoin())
                 await this._emitSessionAbort();
-            deferredActions = this._agentSettledDelivery.finish(this._userAbortGeneration);
+            ({ actions: deferredActions, turnClaims: deferredTurnClaims } = this._agentSettledDelivery.finish(this._userAbortGeneration));
         }
         finally {
             this._agentSettledDelivery.cancel();
@@ -1007,8 +1010,25 @@ export class AgentSession {
         }
         for (const action of deferredActions)
             action();
+        queueMicrotask(() => {
+            void this._emitAgentIdleAfterDeferredTurns(settlementEpoch, deferredTurnClaims);
+        });
+    }
+    async _emitAgentIdleAfterDeferredTurns(settlementEpoch, deferredTurnClaims) {
+        const dispositions = await Promise.all(deferredTurnClaims.map((claim) => claim.disposition));
+        if (dispositions.includes("started"))
+            return;
+        if (dispositions.includes("delegated") || this._sessionWorkBarrier.hasActiveWork) {
+            await this._waitForSettledSessionWork();
+        }
+        if (settlementEpoch !== this._settlementEpoch)
+            return;
+        if (this._isAgentRunActive || this._sessionWorkBarrier.hasActiveWork)
+            return;
+        this._emit({ type: "agent_idle" });
     }
-    async _promptAgent(messages) {
+    async _promptAgent(messages, deferredTurnClaim) {
+        deferredTurnClaim?.resolve("started");
         this._isAgentRunActive = true;
         this._requiredCompactionAdmissionError = undefined;
         this.agent.abortServerSideFallback =
@@ -2908,7 +2928,7 @@ export class AgentSession {
      * @param options.triggerTurn If true and not streaming, triggers a new LLM turn
      * @param options.deliverAs Delivery mode: "steer", "followUp", or "nextTurn"
      */
-    async sendCustomMessage(message, options) {
+    async sendCustomMessage(message, options, deferredTurnClaim) {
         const userAbortGeneration = this._userAbortGeneration;
         const appMessage = {
             role: "custom",
@@ -2941,6 +2961,7 @@ export class AgentSession {
                 this._pendingNextTurnMessages.push(appMessage);
             }
             else if (this.isStreaming && options?.triggerTurn !== false) {
+                deferredTurnClaim?.resolve("delegated");
                 if (options?.deliverAs === "followUp") {
                     this.agent.followUp(appMessage);
                 }
@@ -2953,6 +2974,7 @@ export class AgentSession {
                     (activeCompactionGeneration !== undefined &&
                         this._compactionLifecycle.state.generation === activeCompactionGeneration &&
                         this._compactionLifecycle.state.status !== "completed"))) {
+                deferredTurnClaim?.resolve("delegated");
                 if (options?.deliverAs === "followUp") {
                     this.agent.followUp(appMessage);
                 }
@@ -2978,7 +3000,7 @@ export class AgentSession {
                     }
                     throw error;
                 }
-                await this._promptAgent(appMessage);
+                await this._promptAgent(appMessage, deferredTurnClaim);
             }
             else {
                 this.agent.state.messages.push(appMessage);
@@ -2989,6 +3011,7 @@ export class AgentSession {
             }
         }
         finally {
+            deferredTurnClaim?.resolve("finished-without-start");
             finishSessionWork?.();
         }
     }
@@ -3003,7 +3026,7 @@ export class AgentSession {
      * @param options.deliverAs Delivery mode when streaming: "steer" or "followUp"
      * @param options.expandPromptTemplates Whether to dispatch extension commands and expand skill commands and prompt templates. Default: false.
      */
-    async sendUserMessage(content, options) {
+    async sendUserMessage(content, options, deferredTurnClaim) {
         const bindingPromptReadiness = this._extensionBindingPromptReadiness;
         let resolveBindingPromptReadiness;
         if (bindingPromptReadiness) {
@@ -3012,26 +3035,35 @@ export class AgentSession {
             });
             bindingPromptReadiness.add(readiness);
         }
-        // Normalize content to text string + optional images
+        // Normalize content to text string + optional images. A throw here (null or a
+        // content array whose iterator/part getter throws) happens before the guarded
+        // try below, so resolve the deferred-turn claim first to keep agent_idle reachable.
         let text;
         let images;
-        if (typeof content === "string") {
-            text = content;
-        }
-        else {
-            const textParts = [];
-            images = [];
-            for (const part of content) {
-                if (part.type === "text") {
-                    textParts.push(part.text);
-                }
-                else {
-                    images.push(part);
+        try {
+            if (typeof content === "string") {
+                text = content;
+            }
+            else {
+                const textParts = [];
+                images = [];
+                for (const part of content) {
+                    if (part.type === "text") {
+                        textParts.push(part.text);
+                    }
+                    else {
+                        images.push(part);
+                    }
                 }
+                text = textParts.join("\n");
+                if (images.length === 0)
+                    images = undefined;
             }
-            text = textParts.join("\n");
-            if (images.length === 0)
-                images = undefined;
+        }
+        catch (error) {
+            deferredTurnClaim?.resolve("finished-without-start");
+            resolveBindingPromptReadiness?.();
+            throw error;
         }
         // An extension binding invokes this method fire-and-forget. When it
         // arrives during session work, retain a barrier token after the prior work
@@ -3047,6 +3079,10 @@ export class AgentSession {
                 source: "extension",
                 promptDisposition: (nextDisposition) => {
                     disposition = nextDisposition;
+                    if (nextDisposition === "started")
+                        deferredTurnClaim?.resolve("started");
+                    else if (nextDisposition === "queued")
+                        deferredTurnClaim?.resolve("delegated");
                     resolveBindingPromptReadiness?.();
                 },
                 onSessionWorkReady: waitForExistingSessionWork
@@ -3071,6 +3107,9 @@ export class AgentSession {
             throw error;
         }
         finally {
+            // A path that neither started nor delegated a turn (handled, rejected,
+            // admission failure, cancellation) resolves as finished-without-start.
+            deferredTurnClaim?.resolve("finished-without-start");
             resolveBindingPromptReadiness?.();
             finishSessionWork?.();
         }
@@ -4902,25 +4941,41 @@ export class AgentSession {
         };
         runner.bindCore({
             sendMessage: (message, options) => {
-                const send = () => this.sendCustomMessage(message, options).catch((err) => {
+                const reportError = (err) => {
                     runner.emitError({
                         extensionPath: RUNTIME_EXTENSION_PATH,
                         event: "send_message",
                         error: err instanceof Error ? err.message : String(err),
                     });
-                });
+                };
+                if (options?.triggerTurn === true) {
+                    if (this._agentSettledDelivery.deferTriggerTurn((claim) => {
+                        this.sendCustomMessage(message, options, claim).catch(reportError);
+                    })) {
+                        return;
+                    }
+                }
+                const send = () => this.sendCustomMessage(message, options).catch(reportError);
                 if (this._agentSettledDelivery.defer(send))
                     return;
                 send();
             },
             sendUserMessage: (content, options) => {
-                this.sendUserMessage(content, options).catch((err) => {
+                const reportError = (err) => {
                     runner.emitError({
                         extensionPath: RUNTIME_EXTENSION_PATH,
                         event: "send_user_message",
                         error: err instanceof Error ? err.message : String(err),
                     });
-                });
+                };
+                // sendUserMessage always triggers a turn; register a settlement-deferred
+                // turn claim so agent_idle is not emitted before its deferred agent_start.
+                if (this._agentSettledDelivery.deferTriggerTurn((claim) => {
+                    this.sendUserMessage(content, options, claim).catch(reportError);
+                })) {
+                    return;
+                }
+                this.sendUserMessage(content, options).catch(reportError);
             },
             appendEntry: (customType, data) => {
                 const entryId = this.sessionManager.appendCustomEntry(customType, data);