@code-yeongyu/senpi 2026.8.24 → 2026.8.26-2

package/dist/core/agent-session.js

@@ -16,10 +16,11 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import { prepareAgentToolCall } from "@earendil-works/pi-agent-core";
+import { ProviderRetryWatchdogAbortError, prepareAgentToolCall } from "@earendil-works/pi-agent-core";
 import { contentText, SERVER_FALLBACK_ABORTED_DIAGNOSTIC } from "@earendil-works/pi-ai";
-import { cleanupSessionResources, cursorOverflowCompactionSettings, isClassifierRefusal, isContextOverflow, isCursorPayloadResourceExhausted, isCursorZeroTokenResourceExhausted, isProviderStreamStallError, isProviderTimeoutError, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, shouldRetryOverflowWithoutCompact, streamSimple, } from "@earendil-works/pi-ai/compat";
+import { cleanupSessionResources, cursorOverflowCompactionSettings, isClassifierRefusal, isContextOverflow, isCursorPayloadResourceExhausted, isCursorQuotaResourceExhausted, isCursorZeroTokenResourceExhausted, isProviderStreamStallError, isProviderTimeoutError, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, shouldRetryOverflowWithoutCompact, streamSimple, } from "@earendil-works/pi-ai/compat";
 import { extract429RetryAfterMs, parseRetryAfterMsMarker } from "@earendil-works/pi-ai/utils/retry-hint";
+import { retryBackoffDelayMs } from "@earendil-works/pi-ai/utils/retry-profile/backoff";
 import { getAgentDir } from "../config.js";
 import { getThemeByName, theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
@@ -313,6 +314,15 @@ export const MAX_SKILL_EXPANSIONS_PER_PROMPT = 5;
 // AgentSession Class
 // ============================================================================
 export class AgentSession {
+    /**
+     * Resolve the effective retry profile for the current model's provider.
+     * Falls back to the senpi-default profile when the provider declares none.
+     */
+    _resolveRetryProfile() {
+        const providerId = this.model?.provider;
+        const declared = providerId !== undefined ? this._modelRuntime.getProvider(providerId)?.retryPolicy : undefined;
+        return this.settingsManager.resolveRetryProfile(providerId !== undefined ? { id: providerId, retryPolicy: declared } : undefined);
+    }
     constructor(config) {
         this._eventListeners = [];
         this._agentEventQueue = Promise.resolve();
@@ -338,6 +348,7 @@ export class AgentSession {
         this._supersededCompactionLogAttemptIds = new Set();
         /** Messages queued to be included with the next user prompt as context ("asides"). */
         this._pendingNextTurnMessages = [];
+        this._pendingCustomMessages = [];
         // Queues held while the first post-compaction response is classified. Agent
         // core otherwise drains steering immediately before AgentSession can consume
         // the stale-usage exemption and schedule the continuation itself.
@@ -478,6 +489,7 @@ export class AgentSession {
         }
         this._selectorCooldowns = new SelectorCooldowns(config.fallbackNow ?? (() => Date.now()));
         this._fallbackNow = config.fallbackNow ?? (() => Date.now());
+        this._retryRandom = config.retryRandom ?? Math.random;
         this._retryFallback = new RetryFallbackController({
             getSettings: () => this.settingsManager.getRetryFallbackSettings(),
             registry: this._modelRegistry,
@@ -1090,7 +1102,8 @@ export class AgentSession {
         if (!lastAssistant ||
             (!this._isRetryableError(lastAssistant) &&
                 !this._isHardErrorFallbackEligible(lastAssistant) &&
-                !isCursorZeroTokenResourceExhausted(lastAssistant))) {
+                !isCursorZeroTokenResourceExhausted(lastAssistant) &&
+                !isCursorQuotaResourceExhausted(lastAssistant, this.model?.contextWindow ?? 0))) {
             return;
         }
         this._retryPromise = new Promise((resolve) => {
@@ -1256,10 +1269,17 @@ export class AgentSession {
         if (!settings.enabled) {
             return false;
         }
+        // The same-model budget comes from the resolved profile so a provider-declared
+        // budget (e.g. kimi-code's 9) is honoured; identical to settings.maxRetries for
+        // providers without a profile.
+        const turnMaxRetries = this._resolveRetryProfile().turn.maxRetries;
         const retryableError = this._isRetryableError(lastAssistant);
         if (isCursorZeroTokenResourceExhausted(lastAssistant)) {
             return true;
         }
+        if (isCursorQuotaResourceExhausted(lastAssistant, this.model?.contextWindow ?? 0)) {
+            return this._retryFallback.canTryFallback();
+        }
         if (!retryableError && this._isHardErrorFallbackEligible(lastAssistant)) {
             return true;
         }
@@ -1267,9 +1287,9 @@ export class AgentSession {
             return false;
         }
         if (isClassifierRefusal(lastAssistant)) {
-            return this._retryAttempt + 1 <= settings.maxRetries && this._retryFallback.canTryFallback();
+            return this._retryAttempt + 1 <= turnMaxRetries && this._retryFallback.canTryFallback();
         }
-        if (this._retryAttempt + 1 > settings.maxRetries) {
+        if (this._retryAttempt + 1 > turnMaxRetries) {
             return this._retryFallback.canTryFallback();
         }
         const errorMessage = lastAssistant.errorMessage || "Unknown error";
@@ -1405,16 +1425,18 @@ export class AgentSession {
             const retryableError = this._isRetryableError(msg);
             const hardErrorFallbackEligible = this._isHardErrorFallbackEligible(msg);
             const cursorZeroTokenRe = isCursorZeroTokenResourceExhausted(msg);
+            const cursorQuotaRe = isCursorQuotaResourceExhausted(msg, this.model?.contextWindow ?? 0);
             const retryCanAdmitProvider = !userAbortSuppressedQueuedContinuation &&
                 this.settingsManager.getRetrySettings().enabled &&
-                (retryableError || hardErrorFallbackEligible || cursorZeroTokenRe);
+                (retryableError || hardErrorFallbackEligible || cursorZeroTokenRe || cursorQuotaRe);
             let compactedBeforeRetry = false;
             if (retryCanAdmitProvider &&
                 requiredAutoCompaction &&
                 !(requiredAutoCompaction === "threshold" && this._hasPendingPostCompactionUsageExemption(msg))) {
                 this._retireFailedRetryAssistant(msg);
                 compactedBeforeRetry = await this._runPrePromptCompaction(msg, true, requiredAutoCompaction, true);
-                retryContinuationBlocked = !compactedBeforeRetry && !this._isCompactionDelegated();
+                retryContinuationBlocked =
+                    !compactedBeforeRetry && !this._isCompactionDelegated() && !cursorQuotaRe && !hardErrorFallbackEligible;
             }
             let retryOutcome = "not-handled";
             const retryOwnedDeferredQueue = DEFERRED_RETRY_QUEUE_OWNERS.has(this);
@@ -1423,6 +1445,12 @@ export class AgentSession {
                 if (cursorZeroTokenRe) {
                     retryOutcome = await this._handleRetryableError(msg, { sameModelRemint: true });
                 }
+                else if (cursorQuotaRe) {
+                    // Mid-turn Cursor errors may retain unpaired tool calls. Remove the
+                    // failed assistant before provider fallback so replay stays valid.
+                    this._retireFailedRetryAssistant(msg);
+                    retryOutcome = await this._handleRetryableError(msg, { hardErrorFallback: true });
+                }
                 else if (retryableError) {
                     retryOutcome = await this._handleRetryableError(msg);
                 }
@@ -1446,6 +1474,9 @@ export class AgentSession {
                     retryOwnedDeferredQueue &&
                     retryOutcome === "not-handled" &&
                     (msg.stopReason === "error" || msg.stopReason === "aborted");
+            if (retryOutcome === "not-handled" && cursorQuotaRe && msg.errorMessage) {
+                msg.errorMessage = `${msg.errorMessage} (likely provider usage/quota exhaustion: conversation is well below the model context window)`;
+            }
             if (retryOutcome === "not-handled" && this._retryAttempt > 0 && msg.errorMessage) {
                 const attempt = this._retryAttempt;
                 this._retryAttempt = 0;
@@ -1700,6 +1731,7 @@ export class AgentSession {
             };
             await this._extensionRunner.emit(extensionEvent);
             this._turnIndex++;
+            this._flushPendingCustomMessages();
         }
         else if (event.type === "message_start") {
             const extensionEvent = {
@@ -3006,12 +3038,11 @@ export class AgentSession {
                 }
                 await this._promptAgent(appMessage, deferredTurnClaim);
             }
+            else if (this.isStreaming) {
+                this._pendingCustomMessages.push(appMessage);
+            }
             else {
-                this.agent.state.messages.push(appMessage);
-                this.sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details);
-                this._incrementMessageRevision();
-                this._emit({ type: "message_start", message: appMessage });
-                this._emit({ type: "message_end", message: appMessage });
+                this._appendCustomMessage(appMessage);
             }
         }
         finally {
@@ -3019,6 +3050,19 @@ export class AgentSession {
             finishSessionWork?.();
         }
     }
+    _appendCustomMessage(appMessage) {
+        this.agent.state.messages.push(appMessage);
+        this.sessionManager.appendCustomMessageEntry(appMessage.customType, appMessage.content, appMessage.display, appMessage.details);
+        this._incrementMessageRevision();
+        this._emit({ type: "message_start", message: appMessage });
+        this._emit({ type: "message_end", message: appMessage });
+    }
+    _flushPendingCustomMessages() {
+        const pending = this._pendingCustomMessages;
+        this._pendingCustomMessages = [];
+        for (const message of pending)
+            this._appendCustomMessage(message);
+    }
     /**
      * Send a user message to the agent. Always triggers a turn.
      * When the agent is streaming, use deliverAs to specify how to queue the message.
@@ -3741,6 +3785,35 @@ export class AgentSession {
      * @param customInstructions Optional instructions for the compaction summary
      */
     async compact(customInstructions) {
+        const model = this.model;
+        if (!model)
+            throw new Error(formatNoModelSelectedMessage());
+        const pathEntries = this.sessionManager.getBranch();
+        const settings = cursorOverflowCompactionSettings(this.settingsManager.getCompactionSettings(), model.provider, "manual");
+        if (!prepareCompaction(pathEntries, settings)) {
+            const requestId = randomUUID();
+            const lastEntry = pathEntries[pathEntries.length - 1];
+            const error = new Error(lastEntry?.type === "compaction" ? "Already compacted" : "Nothing to compact (session too small)");
+            const errorMessage = `Compaction failed: ${error.message}`;
+            this._emit({ type: "compaction_start", reason: "manual", requestId });
+            this._emit({
+                type: "compaction_end",
+                reason: "manual",
+                result: undefined,
+                aborted: false,
+                willRetry: false,
+                requestId,
+                errorMessage,
+            });
+            await this._emitSessionCompactFailed({
+                reason: "manual",
+                errorMessage,
+                aborted: false,
+                willRetry: false,
+                fromExtension: false,
+            });
+            throw error;
+        }
         const admission = this._claimPendingCompactionAdmission();
         const controller = admission.controller;
         const requestId = randomUUID();
@@ -4449,11 +4522,7 @@ export class AgentSession {
             else {
                 const messages = filterContextExcludedMessages(this.agent.state.messages);
                 const estimate = estimateContextTokens(messages);
-                if (estimate.lastUsageIndex === null) {
-                    if (!this._isRequiredCompactionError(assistantMessage))
-                        return false;
-                }
-                else {
+                if (estimate.lastUsageIndex !== null) {
                     // 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.
@@ -4609,7 +4678,10 @@ export class AgentSession {
                     }
                 },
                 getActiveSignal: () => this.agent.signal,
-                abortActive: () => this.agent.abort(),
+                abortActive: () => this.agent.abort(new ProviderRetryWatchdogAbortError(`Provider retry continuation watchdog timed out after ${retryTimeoutMs}ms` +
+                    (this.agent.streamStartTimeoutMs === undefined
+                        ? " (stream-start guard disabled)"
+                        : ` (stream-start guard: ${this.agent.streamStartTimeoutMs}ms)`))),
                 timeoutMs: retryTimeoutMs,
             });
             return "continued";
@@ -5560,6 +5632,9 @@ export class AgentSession {
      */
     _degradeRateLimitedWithoutFallback(tier, hintMs, message, errorMessage) {
         const settings = this.settingsManager.getRetrySettings();
+        // Budget checks use the resolved profile (same value as settings.maxRetries
+        // for providers without a declared profile).
+        const turnMaxRetries = this._resolveRetryProfile().turn.maxRetries;
         const hintSettings = this.settingsManager.getHintPolicySettings();
         const finishTurn = (attempt, finalError) => {
             const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
@@ -5587,7 +5662,7 @@ export class AgentSession {
             return undefined;
         }
         this._retryAttempt++;
-        if (this._retryAttempt > settings.maxRetries) {
+        if (this._retryAttempt > turnMaxRetries) {
             finishTurn(this._retryAttempt - 1, message.errorMessage);
             return undefined;
         }
@@ -5603,6 +5678,10 @@ export class AgentSession {
             this._resolveRetry();
             return "not-handled";
         }
+        // Resolve the effective retry profile for the current provider.
+        // Profile-driven behaviour only diverges when a provider declares one;
+        // the senpi-default profile preserves today's tier routing exactly.
+        const retryProfile = this._resolveRetryProfile();
         // Retry promise is created synchronously in _handleAgentEvent for agent_end.
         // Keep a defensive fallback here in case a future refactor bypasses that path.
         if (!this._retryPromise) {
@@ -5619,7 +5698,7 @@ export class AgentSession {
         let hintTierDelayMs;
         if (sameModelRemint) {
             this._retryAttempt++;
-            if (this._retryAttempt > settings.maxRetries) {
+            if (this._retryAttempt > retryProfile.turn.maxRetries) {
                 if (this._retryAttempt > 1) {
                     this._emit({
                         type: "auto_retry_end",
@@ -5643,6 +5722,14 @@ export class AgentSession {
                 errorMessage,
             });
             if (!switchedFallback) {
+                const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
+                if (exhaustedChainKey) {
+                    this._emit({
+                        type: "retry_fallback_exhausted",
+                        chainKey: exhaustedChainKey,
+                        lastError: errorMessage,
+                    });
+                }
                 this._resolveRetry();
                 return "not-handled";
             }
@@ -5652,7 +5739,7 @@ export class AgentSession {
         else if (isRefusal) {
             // Refusals are only retried through a new chain candidate. They never use
             // same-model retries or the transient over-budget fallback escape hatch.
-            if (this._retryAttempt + 1 > settings.maxRetries) {
+            if (this._retryAttempt + 1 > retryProfile.turn.maxRetries) {
                 if (this._retryAttempt > 0) {
                     this._emit({
                         type: "auto_retry_end",
@@ -5693,8 +5780,8 @@ export class AgentSession {
         }
         else {
             // A provider-stream stall is an ordinary transient failure: it consumes
-            // the same bounded same-model budget (`settings.maxRetries`) as every
-            // other retryable class and escalates to the fallback chain only when
+            // the same bounded same-model budget (the resolved profile's turn
+            // maxRetries) as every other retryable class and escalates to the fallback chain only when
             // that budget is exhausted. It is excluded from 429-class tier routing
             // because a stall carries no rate-limit markers or retry-after hint.
             const stallError = isProviderStreamStallError(message);
@@ -5704,7 +5791,44 @@ export class AgentSession {
             // the cadence at a few milliseconds. Do not recompute that floor here.
             const is429Class = !stallError &&
                 /rate.?limit|(?:^429(?=\s+\{)|(?:\bHTTP\/1\.[01]\s+|\bHTTP\s+|\bstatus(?:\s+code)?\s+|\berror\s+|\bcode\s+)429\b)|too many requests|resource.?exhausted/i.test(errorMessage);
-            if (is429Class) {
+            // Profile-driven routing: "after-turn-budget" (Kimi) keeps 429s on the
+            // ordinary same-model budget; "tiered" (senpi default) uses hint tiers.
+            if (is429Class && retryProfile.fallback.rateLimited === "after-turn-budget") {
+                // Kimi profile: 429s consume the same-model budget like any transient.
+                // Mark tier-routed so the generic non-429 path below does not double-count.
+                is429TierRouted = true;
+                this._retryAttempt++;
+                if (this._retryAttempt > retryProfile.turn.maxRetries) {
+                    switchedFallback = await this._retryFallback.tryFallback("transient", {
+                        errorMessage,
+                        retryAfterMs: this._getProviderRetryDelayMs(errorMessage),
+                    });
+                    if (switchedFallback) {
+                        this._retryAttempt = 1;
+                    }
+                    else {
+                        const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
+                        if (exhaustedChainKey) {
+                            this._emit({
+                                type: "retry_fallback_exhausted",
+                                chainKey: exhaustedChainKey,
+                                lastError: errorMessage,
+                            });
+                        }
+                        this._emit({
+                            type: "auto_retry_end",
+                            success: false,
+                            attempt: this._retryAttempt - 1,
+                            finalError: message.errorMessage,
+                        });
+                        this._retryAttempt = 0;
+                        this._resetHintTierState();
+                        this._resolveRetry();
+                        return "not-handled";
+                    }
+                }
+            }
+            else if (is429Class) {
                 const hintMs = this._getProviderRetryDelayMs(errorMessage);
                 const hintSettings = this.settingsManager.getHintPolicySettings();
                 const tier = classifyRateLimitedWait(hintMs, hintSettings);
@@ -5725,7 +5849,7 @@ export class AgentSession {
                 }
                 else if (tier === "tier1-in-turn") {
                     this._retryAttempt++;
-                    if (this._retryAttempt > settings.maxRetries) {
+                    if (this._retryAttempt > retryProfile.turn.maxRetries) {
                         // Budget exhausted within tier1; fall back.
                         switchedFallback = await this._retryFallback.tryFallback("transient", {
                             errorMessage,
@@ -5826,7 +5950,7 @@ export class AgentSession {
             if (!is429TierRouted) {
                 this._retryAttempt++;
             }
-            if (!is429TierRouted && this._retryAttempt > settings.maxRetries) {
+            if (!is429TierRouted && this._retryAttempt > retryProfile.turn.maxRetries) {
                 switchedFallback = await this._retryFallback.tryFallback("transient", {
                     errorMessage,
                     retryAfterMs: this._getProviderRetryDelayMs(errorMessage),
@@ -5859,8 +5983,13 @@ export class AgentSession {
         }
         const providerDelayMs = isRefusal || hardErrorFallback ? undefined : this._getProviderRetryDelayMs(errorMessage);
         const maxRetryDelayMs = this.settingsManager.getProviderRetrySettings().maxRetryDelayMs;
+        // Profile ceiling null (Kimi) bypasses the over-ceiling error path entirely.
+        const profileCeiling = retryProfile.turn.serverHint.mode === "override"
+            ? retryProfile.turn.serverHint.ceiling.maxDelayMs
+            : maxRetryDelayMs;
+        const effectiveMaxRetryDelayMs = profileCeiling ?? Number.MAX_SAFE_INTEGER;
         // For 429-class failures the tier routing replaces the over-budget gate.
-        if (!is429TierRouted && providerDelayMs !== undefined && providerDelayMs > maxRetryDelayMs) {
+        if (!is429TierRouted && providerDelayMs !== undefined && providerDelayMs > effectiveMaxRetryDelayMs) {
             // A wait this long means the model is unavailable rather than busy, so the
             // configured chain beats failing the turn. The switch is gated: the over-budget
             // branch above may have already switched on this same error, and hopping again
@@ -5895,17 +6024,22 @@ export class AgentSession {
         // 429-tier delays already carry the exponential floor from nextInTurnDelayMs /
         // degradeWithoutFallback; the non-tier branch keeps its own exponential fallback.
         const nonTierProviderDelayMs = providerDelayMs === 0 ? undefined : providerDelayMs;
+        // Locally computed exponential goes through the profile's backoff policy
+        // (cap + jitter), sampled through the injectable retryRandom seam so tests
+        // stay deterministic; provider-derived hints on the non-429 path remain
+        // authoritative and fallback switches stay exact.
+        const localExponentialMs = retryBackoffDelayMs(retryProfile.turn.backoff, this._retryAttempt, this._retryRandom());
         const delayMs = switchedFallback
             ? 0
             : is429TierRouted
-                ? (hintTierDelayMs ?? providerDelayMs ?? settings.baseDelayMs * 2 ** (this._retryAttempt - 1))
-                : (nonTierProviderDelayMs ?? settings.baseDelayMs * 2 ** (this._retryAttempt - 1));
+                ? (hintTierDelayMs ?? providerDelayMs ?? localExponentialMs)
+                : (nonTierProviderDelayMs ?? localExponentialMs);
         // Prepare before auto_retry_start so an immediate Esc can cancel the retry sleep.
         this._retryAbortController = new AbortController();
         this._emit({
             type: "auto_retry_start",
             attempt: this._retryAttempt,
-            maxAttempts: settings.maxRetries,
+            maxAttempts: retryProfile.turn.maxRetries,
             delayMs,
             errorMessage,
         });