@code-yeongyu/senpi 2026.5.15 → 2026.5.18-2

package/dist/core/agent-session.js

@@ -15,7 +15,7 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
-import { cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, modelsAreEqual, resetApiProviders, supportsMax, supportsXhigh, } from "@earendil-works/pi-ai";
+import { cleanupSessionResources, isContextOverflow, modelsAreEqual, resetApiProviders, streamSimple, } from "@earendil-works/pi-ai";
 import { expandTildePath } from "../config.js";
 import { theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
@@ -34,6 +34,7 @@ import { getModelNarrowingPatterns, resolveModelScope } from "./model-resolver.j
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { buildSessionContext, CURRENT_SESSION_VERSION, getLatestCompactionEntry, } from "./session-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
+import { getSupportedThinkingLevels, supportsMax, supportsXhigh } from "./thinking-levels.js";
 import { createLocalBashOperations } from "./tools/bash.js";
 import { createAllToolDefinitions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
@@ -96,6 +97,7 @@ export class AgentSession {
     _retryAttempt = 0;
     _retryPromise = undefined;
     _retryResolve = undefined;
+    _userAbortPromise = undefined;
     // Bash execution state
     _bashAbortController = undefined;
     _pendingBashMessages = [];
@@ -149,6 +151,19 @@ export class AgentSession {
         }
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
         this._installAgentToolHooks();
+        const previousPrepareNextTurn = this.agent.prepareNextTurn;
+        this.agent.prepareNextTurn = async (signal) => {
+            const nextTurn = await previousPrepareNextTurn?.(signal);
+            const model = this.agent.state.model;
+            if (!model) {
+                return nextTurn;
+            }
+            return {
+                ...nextTurn,
+                model,
+                thinkingLevel: this.agent.state.thinkingLevel,
+            };
+        };
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
@@ -177,6 +192,13 @@ export class AgentSession {
         }
         throw new Error(formatNoApiKeyFoundMessage(model.provider));
     }
+    async _getCompactionRequestAuth(model) {
+        if (this.agent.streamFn === streamSimple) {
+            return this._getRequiredRequestAuth(model);
+        }
+        const result = await this._modelRegistry.getApiKeyAndHeaders(model);
+        return result.ok ? { apiKey: result.apiKey, headers: result.headers, extraBody: result.extraBody } : {};
+    }
     /**
      * Install tool hooks once on the Agent instance.
      *
@@ -745,6 +767,10 @@ export class AgentSession {
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     async prompt(text, options) {
+        const userAbortPromise = this._userAbortPromise;
+        if (userAbortPromise) {
+            await userAbortPromise;
+        }
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const preflightResult = options?.preflightResult;
         let messages;
@@ -1114,8 +1140,24 @@ export class AgentSession {
      */
     async abort() {
         this.abortRetry();
-        this.agent.abort();
-        await this.agent.waitForIdle();
+        if (this._userAbortPromise) {
+            this.agent.abort();
+            await this._userAbortPromise;
+            return;
+        }
+        const abortPromise = (async () => {
+            this.agent.abort();
+            await this.agent.waitForIdle();
+        })();
+        this._userAbortPromise = abortPromise;
+        try {
+            await abortPromise;
+        }
+        finally {
+            if (this._userAbortPromise === abortPromise) {
+                this._userAbortPromise = undefined;
+            }
+        }
     }
     // =========================================================================
     // Model Management
@@ -1377,8 +1419,11 @@ export class AgentSession {
         if (options.expectedRevision !== undefined && options.expectedRevision !== this._messageRevision) {
             return { applied: false, reason: "stale" };
         }
-        this._compactionAbortController = new AbortController();
-        this._emit({ type: "compaction_start", reason: options.reason });
+        const ownsController = this._compactionAbortController === undefined;
+        if (ownsController) {
+            this._compactionAbortController = new AbortController();
+            this._emit({ type: "compaction_start", reason: options.reason });
+        }
         try {
             const execution = await this._executeCompaction({
                 reason: options.reason,
@@ -1407,6 +1452,38 @@ export class AgentSession {
             this._compactionAbortController = undefined;
         }
     }
+    _beginExtensionCompactionFeedback(reason) {
+        if (!this._compactionAbortController) {
+            this._compactionAbortController = new AbortController();
+            this._emit({ type: "compaction_start", reason });
+        }
+        return this._compactionAbortController.signal;
+    }
+    _updateExtensionCompactionFeedback(options) {
+        if (!this._compactionAbortController && !this._autoCompactionAbortController)
+            return;
+        this._emit({
+            type: "compaction_progress",
+            reason: options.reason,
+            ...(options.delta !== undefined ? { delta: options.delta } : {}),
+            ...(options.text !== undefined ? { text: options.text } : {}),
+        });
+    }
+    _endExtensionCompactionFeedback(options) {
+        const controller = this._compactionAbortController;
+        if (!controller)
+            return;
+        const aborted = options.aborted ?? controller.signal.aborted;
+        this._emit({
+            type: "compaction_end",
+            reason: options.reason,
+            result: undefined,
+            aborted,
+            willRetry: false,
+            errorMessage: aborted ? undefined : options.errorMessage,
+        });
+        this._compactionAbortController = undefined;
+    }
     async _executeCompaction(request) {
         if (!this.model) {
             throw new Error(formatNoModelSelectedMessage());
@@ -1449,8 +1526,8 @@ export class AgentSession {
                 }
             }
             if (!compactionResult) {
-                const { apiKey, headers, extraBody } = await this._getRequiredRequestAuth(this.model);
-                compactionResult = await compact(preparation, this.model, apiKey, headers, request.customInstructions, signal, extraBody, this.thinkingLevel);
+                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) {
@@ -1573,14 +1650,18 @@ export class AgentSession {
             shouldCompact(contextUsage.tokens, contextUsage.contextWindow, settings);
         if (isContextOverflow(assistantMessage, contextWindow) && (sameModel || currentContextNeedsCompaction)) {
             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.";
                 this._emit({
                     type: "compaction_end",
                     reason: "overflow",
                     result: undefined,
                     aborted: false,
                     willRetry: false,
-                    errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
+                    errorMessage,
                 });
+                if (requestReason === "pre_prompt") {
+                    throw new Error(errorMessage);
+                }
                 return;
             }
             this._overflowRecoveryAttempted = true;
@@ -1635,14 +1716,20 @@ export class AgentSession {
         this._emit({ type: "compaction_start", reason: "pre_prompt" });
         this._compactionAbortController = new AbortController();
         try {
-            await this._executeCompaction({
+            const execution = await this._executeCompaction({
                 reason: "pre_prompt",
                 willRetry: false,
                 lastAssistantMessage,
                 skipAbortedCheck,
             });
+            if (!execution.accepted && isContextOverflow(lastAssistantMessage, this.model?.contextWindow ?? 0)) {
+                this._overflowRecoveryAttempted = false;
+            }
         }
         catch (error) {
+            if (isContextOverflow(lastAssistantMessage, this.model?.contextWindow ?? 0)) {
+                this._overflowRecoveryAttempted = false;
+            }
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
             const aborted = errorMessage === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
             this._emit({
@@ -1666,6 +1753,8 @@ export class AgentSession {
         this._autoCompactionAbortController = new AbortController();
         try {
             if (!this.model) {
+                if (reason === "overflow")
+                    this._overflowRecoveryAttempted = false;
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -1676,7 +1765,9 @@ export class AgentSession {
                 return;
             }
             const authResult = await this._modelRegistry.getApiKeyAndHeaders(this.model);
-            if (!authResult.ok || !authResult.apiKey) {
+            if (this.agent.streamFn === streamSimple && (!authResult.ok || !authResult.apiKey)) {
+                if (reason === "overflow")
+                    this._overflowRecoveryAttempted = false;
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -1688,6 +1779,8 @@ export class AgentSession {
             }
             const preparation = prepareCompaction(this.sessionManager.getBranch(), this.settingsManager.getCompactionSettings());
             if (!preparation) {
+                if (reason === "overflow")
+                    this._overflowRecoveryAttempted = false;
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -1699,6 +1792,8 @@ export class AgentSession {
             }
             const execution = await this._executeCompaction({ reason, willRetry });
             if (!execution.accepted) {
+                if (reason === "overflow")
+                    this._overflowRecoveryAttempted = false;
                 return;
             }
             if (willRetry) {
@@ -1721,6 +1816,8 @@ export class AgentSession {
             }
         }
         catch (error) {
+            if (reason === "overflow")
+                this._overflowRecoveryAttempted = false;
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
             const aborted = errorMessage === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
             this._emit({
@@ -1943,6 +2040,9 @@ export class AgentSession {
                     }
                 })();
             },
+            beginCompaction: (options) => this._beginExtensionCompactionFeedback(options.reason),
+            updateCompaction: (options) => this._updateExtensionCompactionFeedback(options),
+            endCompaction: (options) => this._endExtensionCompactionFeedback(options),
             getMessageRevision: () => this.getMessageRevision(),
             applyCompaction: (precomputed, options) => this.applyCompaction(precomputed, options),
             getSystemPrompt: () => this.systemPrompt,
@@ -2101,16 +2201,49 @@ export class AgentSession {
      * Context overflow errors are NOT retryable (handled by compaction instead).
      */
     _isRetryableError(message) {
-        if (message.stopReason !== "error" || !message.errorMessage)
+        if (!message.errorMessage)
             return false;
         // Context overflow is handled by compaction, not retry
         const contextWindow = this.model?.contextWindow ?? 0;
         if (isContextOverflow(message, contextWindow))
             return false;
         const err = message.errorMessage;
+        if (message.stopReason === "aborted") {
+            return /timed? out|timeout/i.test(err);
+        }
+        if (message.stopReason !== "error")
+            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);
     }
+    _getProviderRetryDelayMs(errorMessage) {
+        const retryAfterMsMatch = errorMessage.match(/\bretry[-_ ]?after[-_ ]?ms\s*[:=]\s*(\d+(?:\.\d+)?)/i);
+        if (retryAfterMsMatch) {
+            const delayMs = Math.ceil(Number(retryAfterMsMatch[1]));
+            return Number.isFinite(delayMs) && delayMs > 0 ? delayMs : undefined;
+        }
+        const retryAfterSecondsMatch = errorMessage.match(/\bretry[-_ ]?after\s*[:=]\s*(\d+(?:\.\d+)?)/i);
+        if (retryAfterSecondsMatch) {
+            const delayMs = Math.ceil(Number(retryAfterSecondsMatch[1]) * 1000);
+            return Number.isFinite(delayMs) && delayMs > 0 ? delayMs : undefined;
+        }
+        const retryInMatch = errorMessage.match(/\b(?:retry|try again|wait)\s+(?:after|in)\s*(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m)\b/i);
+        if (!retryInMatch) {
+            return undefined;
+        }
+        const value = Number(retryInMatch[1]);
+        if (!Number.isFinite(value) || value <= 0) {
+            return undefined;
+        }
+        const unit = retryInMatch[2].toLowerCase();
+        if (unit === "m" || unit.startsWith("min")) {
+            return Math.ceil(value * 60_000);
+        }
+        if (unit.startsWith("s")) {
+            return Math.ceil(value * 1000);
+        }
+        return Math.ceil(value);
+    }
     /**
      * Handle retryable errors with exponential backoff.
      * @returns true if retry was initiated, false if max retries exceeded or disabled
@@ -2141,13 +2274,27 @@ export class AgentSession {
             this._resolveRetry(); // Resolve so waitForRetry() completes
             return false;
         }
-        const delayMs = settings.baseDelayMs * 2 ** (this._retryAttempt - 1);
+        const errorMessage = message.errorMessage || "Unknown error";
+        const providerDelayMs = this._getProviderRetryDelayMs(errorMessage);
+        const maxRetryDelayMs = this.settingsManager.getProviderRetrySettings().maxRetryDelayMs;
+        if (providerDelayMs !== undefined && providerDelayMs > maxRetryDelayMs) {
+            this._emit({
+                type: "auto_retry_end",
+                success: false,
+                attempt: this._retryAttempt,
+                finalError: `Provider requested retry delay ${providerDelayMs}ms, exceeding configured maximum ${maxRetryDelayMs}ms`,
+            });
+            this._retryAttempt = 0;
+            this._resolveRetry();
+            return false;
+        }
+        const delayMs = providerDelayMs ?? settings.baseDelayMs * 2 ** (this._retryAttempt - 1);
         this._emit({
             type: "auto_retry_start",
             attempt: this._retryAttempt,
             maxAttempts: settings.maxRetries,
             delayMs,
-            errorMessage: message.errorMessage || "Unknown error",
+            errorMessage,
         });
         // Remove error message from agent state (keep in session for history)
         const messages = this.agent.state.messages;