@code-yeongyu/senpi 2026.5.14 → 2026.5.15-3

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 } 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";
@@ -1377,8 +1378,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 +1411,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());
@@ -1635,14 +1671,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 +1708,8 @@ export class AgentSession {
         this._autoCompactionAbortController = new AbortController();
         try {
             if (!this.model) {
+                if (reason === "overflow")
+                    this._overflowRecoveryAttempted = false;
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -1677,6 +1721,8 @@ export class AgentSession {
             }
             const authResult = await this._modelRegistry.getApiKeyAndHeaders(this.model);
             if (!authResult.ok || !authResult.apiKey) {
+                if (reason === "overflow")
+                    this._overflowRecoveryAttempted = false;
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -1688,6 +1734,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 +1747,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 +1771,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 +1995,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 +2156,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 +2229,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;