@code-yeongyu/senpi 2026.7.9 → 2026.7.10

package/dist/core/agent-session.js

@@ -89,6 +89,7 @@ export class AgentSession {
     constructor(config) {
         this._eventListeners = [];
         this._agentEventQueue = Promise.resolve();
+        this._isAgentRunActive = false;
         /** Tracks pending steering messages for UI display. Removed when delivered. */
         this._steeringMessages = [];
         /** Tracks pending follow-up messages for UI display. Removed when delivered. */
@@ -217,11 +218,11 @@ export class AgentSession {
         };
     }
     async _emitBeforeToolCallHooks(toolCall, args) {
+        await this._agentEventQueue;
         const runner = this._extensionRunner;
         if (!runner.hasHandlers("tool_call")) {
             return undefined;
         }
-        await this._agentEventQueue;
         try {
             return await runner.emitToolCall({
                 type: "tool_call",
@@ -323,6 +324,47 @@ export class AgentSession {
         this.abortBranchSummary();
         this._incrementMessageRevision();
     }
+    _getIdleWaitPromise() {
+        if (!this._idleWaitPromise) {
+            this._idleWaitPromise = new Promise((resolve) => {
+                this._resolveIdleWait = resolve;
+            });
+        }
+        return this._idleWaitPromise;
+    }
+    _resolveIdleWaitIfIdle() {
+        if (this._isAgentRunActive || !this._resolveIdleWait) {
+            return;
+        }
+        const resolve = this._resolveIdleWait;
+        this._idleWaitPromise = undefined;
+        this._resolveIdleWait = undefined;
+        resolve();
+    }
+    async _emitAgentSettled() {
+        if (!this._isAgentRunActive) {
+            this._resolveIdleWaitIfIdle();
+            return;
+        }
+        this._isAgentRunActive = false;
+        try {
+            await this._extensionRunner.emit({ type: "agent_settled" });
+            this._emit({ type: "agent_settled" });
+        }
+        finally {
+            this._resolveIdleWaitIfIdle();
+        }
+    }
+    async _promptAgent(messages) {
+        this._isAgentRunActive = true;
+        try {
+            await this.agent.prompt(messages);
+        }
+        catch (error) {
+            await this._emitAgentSettled();
+            throw error;
+        }
+    }
     _createRetryPromiseForAgentEnd(event) {
         if (event.type !== "agent_end" || this._retryPromise) {
             return;
@@ -348,6 +390,34 @@ export class AgentSession {
         }
         return undefined;
     }
+    _agentEndAllowsQueuedContinuation(messages) {
+        let lastAssistantIndex = -1;
+        for (let index = messages.length - 1; index >= 0; index--) {
+            if (messages[index]?.role === "assistant") {
+                lastAssistantIndex = index;
+                break;
+            }
+        }
+        if (lastAssistantIndex === -1) {
+            return false;
+        }
+        const lastAssistant = messages[lastAssistantIndex];
+        if (lastAssistant?.role !== "assistant") {
+            return false;
+        }
+        if (lastAssistant.stopReason === "aborted" || lastAssistant.stopReason === "error") {
+            return false;
+        }
+        for (let index = lastAssistantIndex + 1; index < messages.length; index++) {
+            const message = messages[index];
+            if (message?.role === "toolResult" &&
+                message.isError &&
+                message.content.some((content) => content.type === "text" && /\babort(?:ed)?\b/i.test(content.text))) {
+                return false;
+            }
+        }
+        return true;
+    }
     _willRetryAfterAgentEnd(messages) {
         const settings = this.settingsManager.getRetrySettings();
         if (!settings.enabled) {
@@ -430,6 +500,8 @@ export class AgentSession {
             }
         }
         // Check auto-retry and auto-compaction after agent completes
+        let launchedContinuation = false;
+        const allowsQueuedContinuation = event.type === "agent_end" ? this._agentEndAllowsQueuedContinuation(event.messages) : false;
         if (event.type === "agent_end" && this._lastAssistantMessage) {
             const msg = this._lastAssistantMessage;
             this._lastAssistantMessage = undefined;
@@ -440,10 +512,16 @@ export class AgentSession {
                     return; // Retry was initiated, don't proceed to compaction
             }
             this._resolveRetry();
-            await this._checkCompaction(msg);
+            launchedContinuation = await this._checkCompaction(msg);
         }
         if (event.type === "agent_end") {
             this._flushPendingBashMessages();
+            if (!launchedContinuation && allowsQueuedContinuation && this.agent.hasQueuedMessages()) {
+                launchedContinuation = await this._continueAgentAfterCurrentRun();
+            }
+            if (!launchedContinuation) {
+                await this._emitAgentSettled();
+            }
         }
     }
     /** Resolve the pending retry promise */
@@ -537,7 +615,16 @@ export class AgentSession {
             };
             const replacement = await this._extensionRunner.emitMessageEnd(extensionEvent);
             if (replacement) {
-                this._replaceMessageInPlace(event.message, replacement);
+                // Untyped extension handlers can return messages with null/missing content;
+                // normalize so it never enters agent state or session history.
+                const normalized = (replacement.role === "user" ||
+                    replacement.role === "assistant" ||
+                    replacement.role === "toolResult" ||
+                    replacement.role === "custom") &&
+                    replacement.content == null
+                    ? { ...replacement, content: [] }
+                    : replacement;
+                this._replaceMessageInPlace(event.message, normalized);
             }
         }
         else if (event.type === "tool_execution_start") {
@@ -644,9 +731,13 @@ export class AgentSession {
     get serviceTier() {
         return this._currentServiceTier;
     }
-    /** Whether agent is currently streaming a response */
+    /** Whether the session is currently processing an agent run or post-run continuation. */
     get isStreaming() {
-        return this.agent.state.isStreaming;
+        return this._isAgentRunActive;
+    }
+    /** Whether the session has no active agent run, retry, auto-compaction, or queued continuation. */
+    get isIdle() {
+        return !this._isAgentRunActive;
     }
     /** Current effective system prompt (includes any per-turn extension modifications) */
     get systemPrompt() {
@@ -987,7 +1078,8 @@ export class AgentSession {
                     messages.push({
                         role: "custom",
                         customType: msg.customType,
-                        content: msg.content,
+                        // Untyped extensions can pass null/missing content; normalize at ingestion.
+                        content: msg.content ?? [],
                         display: msg.display,
                         details: msg.details,
                         timestamp: Date.now(),
@@ -1013,8 +1105,9 @@ export class AgentSession {
             return;
         }
         preflightResult?.(true);
-        await this.agent.prompt(messages);
+        await this._promptAgent(messages);
         await this.waitForRetry();
+        await this.waitForIdle();
         if (shouldWaitForSessionWork) {
             await this._waitForSettledSessionWork();
         }
@@ -1244,7 +1337,8 @@ export class AgentSession {
         const appMessage = {
             role: "custom",
             customType: message.customType,
-            content: message.content,
+            // Untyped extensions can pass null/missing content; normalize at ingestion.
+            content: message.content ?? [],
             display: message.display,
             details: message.details,
             timestamp: Date.now(),
@@ -1261,7 +1355,7 @@ export class AgentSession {
             }
         }
         else if (options?.triggerTurn) {
-            await this.agent.prompt(appMessage);
+            await this._promptAgent(appMessage);
         }
         else {
             this.agent.state.messages.push(appMessage);
@@ -1352,7 +1446,7 @@ export class AgentSession {
         }
         const abortPromise = (async () => {
             this.agent.abort();
-            await this.agent.waitForIdle();
+            await this.waitForIdle();
         })();
         this._userAbortPromise = abortPromise;
         try {
@@ -1364,6 +1458,12 @@ export class AgentSession {
             }
         }
     }
+    async waitForIdle() {
+        if (this.isIdle) {
+            return;
+        }
+        await this._getIdleWaitPromise();
+    }
     // =========================================================================
     // Model Management
     // =========================================================================
@@ -1848,10 +1948,10 @@ export class AgentSession {
     async _checkCompaction(assistantMessage, skipAbortedCheck = true, requestReason) {
         const settings = this.settingsManager.getCompactionSettings();
         if (!settings.enabled)
-            return;
+            return false;
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
         if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
-            return;
+            return false;
         const contextWindow = this.model?.contextWindow ?? 0;
         // Skip overflow check if the message came from a different model.
         // This handles the case where user switched from a smaller-context model (e.g. opus)
@@ -1865,7 +1965,7 @@ export class AgentSession {
         const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
         const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
         if (assistantIsFromBeforeCompaction) {
-            return;
+            return false;
         }
         // Case 1: Overflow - LLM returned context overflow error.
         // If the saved assistant provider differs from the currently selected provider alias,
@@ -1877,8 +1977,7 @@ export class AgentSession {
         if (isContextOverflow(assistantMessage, contextWindow) && (sameModel || currentContextNeedsCompaction)) {
             const willRetry = assistantMessage.stopReason !== "stop";
             if (!willRetry) {
-                await this._runAutoCompaction("overflow", false);
-                return;
+                return await this._runAutoCompaction("overflow", false);
             }
             if (this._overflowRecoveryAttempted) {
                 const errorMessage = "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.";
@@ -1893,7 +1992,7 @@ export class AgentSession {
                 if (requestReason === "pre_prompt") {
                     throw new Error(errorMessage);
                 }
-                return;
+                return false;
             }
             this._overflowRecoveryAttempted = true;
             // Remove the error message from agent state (it IS saved to session for history,
@@ -1907,9 +2006,9 @@ export class AgentSession {
                 await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, "overflow", willRetry);
             }
             else {
-                await this._runAutoCompaction("overflow", willRetry);
+                return await this._runAutoCompaction("overflow", willRetry);
             }
-            return;
+            return false;
         }
         // Case 2: Threshold - context is getting large
         // For error messages or all-zero usage messages, estimate from the last valid response.
@@ -1921,7 +2020,7 @@ export class AgentSession {
             const messages = filterContextExcludedMessages(this.agent.state.messages);
             const estimate = estimateContextTokens(messages);
             if (estimate.lastUsageIndex === null)
-                return; // No usage data at all
+                return false; // No usage data at all
             // Verify the usage source is post-compaction. Kept pre-compaction messages
             // have stale usage reflecting the old (larger) context and would falsely
             // trigger compaction right after one just finished.
@@ -1929,7 +2028,7 @@ export class AgentSession {
             if (compactionEntry &&
                 usageMsg.role === "assistant" &&
                 usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
-                return;
+                return false;
             }
             contextTokens = estimate.tokens;
         }
@@ -1941,9 +2040,10 @@ export class AgentSession {
                 await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck);
             }
             else {
-                await this._runAutoCompaction("threshold", false);
+                return await this._runAutoCompaction("threshold", false);
             }
         }
+        return false;
     }
     async _runPrePromptCompaction(lastAssistantMessage, skipAbortedCheck, reason = "pre_prompt", willRetry = false) {
         this._emit({ type: "compaction_start", reason });
@@ -2256,7 +2356,7 @@ export class AgentSession {
         }, {
             getModel: () => this.model,
             getServiceTier: () => this.serviceTier,
-            isIdle: () => !this.isStreaming,
+            isIdle: () => this.isIdle,
             isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
             getSignal: () => this.agent.signal,
             abort: () => {
@@ -2593,6 +2693,7 @@ export class AgentSession {
             const attempt = this._retryAttempt;
             this._retryAttempt = 0;
             this._retryAbortController = undefined;
+            await this._emitAgentSettled();
             this._emit({
                 type: "auto_retry_end",
                 success: false,
@@ -2949,28 +3050,44 @@ export class AgentSession {
         return "";
     }
     /**
-     * Get session statistics.
+     * Get session statistics. Aggregates over ALL session entries (including
+     * history that was compacted away), so token/cost totals reflect what was
+     * actually billed across the session.
      */
     getSessionStats() {
-        const state = this.state;
-        const userMessages = state.messages.filter((m) => m.role === "user").length;
-        const assistantMessages = state.messages.filter((m) => m.role === "assistant").length;
-        const toolResults = state.messages.filter((m) => m.role === "toolResult").length;
+        let userMessages = 0;
+        let assistantMessages = 0;
+        let toolResults = 0;
+        let totalMessages = 0;
         let toolCalls = 0;
         let totalInput = 0;
         let totalOutput = 0;
         let totalCacheRead = 0;
         let totalCacheWrite = 0;
         let totalCost = 0;
-        for (const message of state.messages) {
-            if (message.role === "assistant") {
+        for (const entry of this.sessionManager.getEntries()) {
+            if (entry.type !== "message")
+                continue;
+            totalMessages++;
+            const message = entry.message;
+            if (message.role === "user") {
+                userMessages++;
+            }
+            else if (message.role === "toolResult") {
+                toolResults++;
+            }
+            else if (message.role === "assistant") {
+                assistantMessages++;
                 const assistantMsg = message;
-                toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length;
-                totalInput += assistantMsg.usage.input;
-                totalOutput += assistantMsg.usage.output;
-                totalCacheRead += assistantMsg.usage.cacheRead;
-                totalCacheWrite += assistantMsg.usage.cacheWrite;
-                totalCost += assistantMsg.usage.cost.total;
+                if (Array.isArray(assistantMsg.content)) {
+                    toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length;
+                }
+                const usage = assistantMsg.usage;
+                totalInput += usage.input;
+                totalOutput += usage.output;
+                totalCacheRead += usage.cacheRead;
+                totalCacheWrite += usage.cacheWrite;
+                totalCost += usage.cost.total;
             }
         }
         return {
@@ -2980,7 +3097,7 @@ export class AgentSession {
             assistantMessages,
             toolCalls,
             toolResults,
-            totalMessages: state.messages.length,
+            totalMessages,
             tokens: {
                 input: totalInput,
                 output: totalOutput,