@code-yeongyu/senpi 2026.5.24 → 2026.5.29

package/dist/core/agent-session.js

@@ -33,6 +33,7 @@ import { filterContextExcludedMessages } from "./messages.js";
 import { getModelNarrowingPatterns, resolveModelScope } from "./model-resolver.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { buildSessionContext, CURRENT_SESSION_VERSION, getLatestCompactionEntry, } from "./session-manager.js";
+import { SessionWorkBarrier } from "./session-work-barrier.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { getSupportedThinkingLevels, supportsMax, supportsXhigh } from "./thinking-levels.js";
 import { createLocalBashOperations } from "./tools/bash.js";
@@ -88,6 +89,7 @@ export class AgentSession {
     // Compaction state
     _compactionAbortController = undefined;
     _autoCompactionAbortController = undefined;
+    _sessionWorkBarrier = new SessionWorkBarrier();
     _overflowRecoveryAttempted = false;
     _messageRevision = 0;
     // Branch summarization state
@@ -275,6 +277,9 @@ export class AgentSession {
     getMessageRevision() {
         return this._messageRevision;
     }
+    async _waitForSettledSessionWork() {
+        await this._sessionWorkBarrier.waitForSettled(() => this._agentEventQueue);
+    }
     _modelSelectionChangesContext(previousModel, nextModel) {
         if (!modelsAreEqual(previousModel, nextModel))
             return true;
@@ -807,6 +812,11 @@ export class AgentSession {
         if (userAbortPromise) {
             await userAbortPromise;
         }
+        const shouldWaitForSessionWork = options?.source !== "extension";
+        if (shouldWaitForSessionWork &&
+            (!this.isStreaming || this.isCompacting || this._sessionWorkBarrier.hasActiveWork)) {
+            await this._waitForSettledSessionWork();
+        }
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const preflightResult = options?.preflightResult;
         let messages;
@@ -926,7 +936,12 @@ export class AgentSession {
         preflightResult?.(true);
         await this.agent.prompt(messages);
         await this.waitForRetry();
-        await this._agentEventQueue;
+        if (shouldWaitForSessionWork) {
+            await this._waitForSettledSessionWork();
+        }
+        else {
+            await this.agent.waitForIdle();
+        }
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -1532,83 +1547,89 @@ export class AgentSession {
         this._compactionAbortController = undefined;
     }
     async _executeCompaction(request) {
-        if (!this.model) {
-            throw new Error(formatNoModelSelectedMessage());
-        }
-        const requestId = randomUUID();
-        const pathEntries = this.sessionManager.getBranch();
-        const settings = this.settingsManager.getCompactionSettings();
-        const signal = this._compactionAbortController?.signal ?? this._autoCompactionAbortController?.signal;
-        if (!signal) {
-            throw new Error("Compaction abort controller unavailable");
-        }
-        let compactionResult = request.precomputed;
-        let fromExtension = request.precomputed !== undefined;
-        if (!compactionResult) {
-            const preparation = prepareCompaction(pathEntries, settings);
-            if (!preparation) {
-                const lastEntry = pathEntries[pathEntries.length - 1];
-                if (lastEntry?.type === "compaction") {
-                    throw new Error("Already compacted");
+        const finishCompactionWork = this._sessionWorkBarrier.begin();
+        try {
+            if (!this.model) {
+                throw new Error(formatNoModelSelectedMessage());
+            }
+            const requestId = randomUUID();
+            const pathEntries = this.sessionManager.getBranch();
+            const settings = this.settingsManager.getCompactionSettings();
+            const signal = this._compactionAbortController?.signal ?? this._autoCompactionAbortController?.signal;
+            if (!signal) {
+                throw new Error("Compaction abort controller unavailable");
+            }
+            let compactionResult = request.precomputed;
+            let fromExtension = request.precomputed !== undefined;
+            if (!compactionResult) {
+                const preparation = prepareCompaction(pathEntries, settings);
+                if (!preparation) {
+                    const lastEntry = pathEntries[pathEntries.length - 1];
+                    if (lastEntry?.type === "compaction") {
+                        throw new Error("Already compacted");
+                    }
+                    throw new Error("Nothing to compact (session too small)");
                 }
-                throw new Error("Nothing to compact (session too small)");
-            }
-            if (this._extensionRunner.hasHandlers("session_before_compact")) {
-                const extensionResult = (await this._extensionRunner.emit({
-                    type: "session_before_compact",
-                    reason: request.reason,
-                    willRetry: request.willRetry,
-                    requestId,
-                    preparation,
-                    branchEntries: pathEntries,
-                    customInstructions: request.customInstructions,
-                    signal,
-                }));
-                if (extensionResult?.cancel) {
-                    return await this._rejectCompaction(request, requestId, "cancelled-by-extension", true);
+                if (this._extensionRunner.hasHandlers("session_before_compact")) {
+                    const extensionResult = (await this._extensionRunner.emit({
+                        type: "session_before_compact",
+                        reason: request.reason,
+                        willRetry: request.willRetry,
+                        requestId,
+                        preparation,
+                        branchEntries: pathEntries,
+                        customInstructions: request.customInstructions,
+                        signal,
+                    }));
+                    if (extensionResult?.cancel) {
+                        return await this._rejectCompaction(request, requestId, "cancelled-by-extension", true);
+                    }
+                    if (extensionResult?.compaction) {
+                        compactionResult = extensionResult.compaction;
+                        fromExtension = true;
+                    }
                 }
-                if (extensionResult?.compaction) {
-                    compactionResult = extensionResult.compaction;
-                    fromExtension = true;
+                if (!compactionResult) {
+                    const { apiKey, headers, extraBody } = await this._getCompactionRequestAuth(this.model);
+                    compactionResult = await compact(preparation, this.model, apiKey, headers, request.customInstructions, signal, extraBody, this.thinkingLevel, this.agent.streamFn);
                 }
             }
-            if (!compactionResult) {
-                const { apiKey, headers, extraBody } = await this._getCompactionRequestAuth(this.model);
-                compactionResult = await compact(preparation, this.model, apiKey, headers, request.customInstructions, signal, extraBody, this.thinkingLevel, this.agent.streamFn);
+            if (signal.aborted) {
+                throw new Error("Compaction cancelled");
             }
+            if (this._wouldCompactionOverflow(pathEntries, compactionResult, fromExtension)) {
+                return await this._rejectCompaction(request, requestId, "would-overflow", false);
+            }
+            const compactionEntryId = this.sessionManager.appendCompaction(compactionResult.summary, compactionResult.firstKeptEntryId, compactionResult.tokensBefore, compactionResult.details, fromExtension);
+            const savedEntry = this.sessionManager.getEntry(compactionEntryId);
+            if (!savedEntry || savedEntry.type !== "compaction") {
+                throw new Error("Compaction entry was not saved");
+            }
+            const sessionContext = this.sessionManager.buildSessionContext();
+            this.agent.state.messages = sessionContext.messages;
+            this._incrementMessageRevision();
+            await this._extensionRunner.emit({
+                type: "session_compact",
+                reason: request.reason,
+                requestId,
+                accepted: true,
+                compactionEntry: savedEntry,
+                fromExtension,
+            });
+            this._emit({
+                type: "compaction_end",
+                reason: request.reason,
+                result: compactionResult,
+                aborted: false,
+                willRetry: request.willRetry,
+                requestId,
+                accepted: true,
+            });
+            return { accepted: true, requestId, result: compactionResult, compactionEntry: savedEntry, fromExtension };
         }
-        if (signal.aborted) {
-            throw new Error("Compaction cancelled");
-        }
-        if (this._wouldCompactionOverflow(pathEntries, compactionResult, fromExtension)) {
-            return await this._rejectCompaction(request, requestId, "would-overflow", false);
-        }
-        const compactionEntryId = this.sessionManager.appendCompaction(compactionResult.summary, compactionResult.firstKeptEntryId, compactionResult.tokensBefore, compactionResult.details, fromExtension);
-        const savedEntry = this.sessionManager.getEntry(compactionEntryId);
-        if (!savedEntry || savedEntry.type !== "compaction") {
-            throw new Error("Compaction entry was not saved");
+        finally {
+            finishCompactionWork();
         }
-        const sessionContext = this.sessionManager.buildSessionContext();
-        this.agent.state.messages = sessionContext.messages;
-        this._incrementMessageRevision();
-        await this._extensionRunner.emit({
-            type: "session_compact",
-            reason: request.reason,
-            requestId,
-            accepted: true,
-            compactionEntry: savedEntry,
-            fromExtension,
-        });
-        this._emit({
-            type: "compaction_end",
-            reason: request.reason,
-            result: compactionResult,
-            aborted: false,
-            willRetry: request.willRetry,
-            requestId,
-            accepted: true,
-        });
-        return { accepted: true, requestId, result: compactionResult, compactionEntry: savedEntry, fromExtension };
     }
     _wouldCompactionOverflow(pathEntries, compactionResult, fromExtension) {
         const currentLeaf = pathEntries[pathEntries.length - 1];
@@ -1792,10 +1813,24 @@ export class AgentSession {
             this._compactionAbortController = undefined;
         }
     }
+    async _continueAgentAfterCurrentRun() {
+        await this.agent.waitForIdle();
+        try {
+            await this.agent.continue();
+            return true;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return false;
+            }
+            throw error;
+        }
+    }
     /**
      * Internal: Run auto-compaction with events.
      */
     async _runAutoCompaction(reason, willRetry) {
+        const finishCompactionWork = this._sessionWorkBarrier.begin();
         this._emit({ type: "compaction_start", reason });
         this._autoCompactionAbortController = new AbortController();
         try {
@@ -1850,17 +1885,12 @@ export class AgentSession {
                     this.agent.state.messages = messages.slice(0, -1);
                     this._incrementMessageRevision();
                 }
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
-                return true;
+                return await this._continueAgentAfterCurrentRun();
+            }
+            else if (this.pendingMessageCount > 0) {
+                return await this._continueAgentAfterCurrentRun();
             }
             else if (this.agent.hasQueuedMessages()) {
-                // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-                // Kick the loop so queued messages are actually delivered.
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
                 return true;
             }
             return false;
@@ -1886,6 +1916,7 @@ export class AgentSession {
         }
         finally {
             this._autoCompactionAbortController = undefined;
+            finishCompactionWork();
         }
     }
     /**
@@ -2250,6 +2281,9 @@ export class AgentSession {
     // =========================================================================
     // Auto-Retry
     // =========================================================================
+    _isNonRetryableProviderLimitError(errorMessage) {
+        return /GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|insufficient_quota|out of budget|quota exceeded|billing/i.test(errorMessage);
+    }
     /**
      * Check if an error is retryable (overloaded, rate limit, server errors).
      * Context overflow errors are NOT retryable (handled by compaction instead).
@@ -2267,6 +2301,8 @@ export class AgentSession {
         }
         if (message.stopReason !== "error")
             return false;
+        if (this._isNonRetryableProviderLimitError(err))
+            return false;
         // Match: overloaded_error, provider returned error, rate limit, 429, 500, 502, 503, 504, service unavailable, network/connection errors (including connection lost), WebSocket transport closes/errors, fetch failed, premature stream endings, HTTP/2 closed before response, terminated, retry delay exceeded
         return /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|websocket.?closed|websocket.?error|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|stream ended before message_stop|http2 request did not get a response|timed? out|timeout|terminated|retry delay/i.test(err);
     }