@code-yeongyu/senpi 2026.8.19 → 2026.8.20

package/dist/core/agent-session.js

@@ -18,7 +18,7 @@ import { basename, dirname } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { prepareAgentToolCall } from "@earendil-works/pi-agent-core";
 import { contentText, SERVER_FALLBACK_ABORTED_DIAGNOSTIC } from "@earendil-works/pi-ai";
-import { cleanupSessionResources, isClassifierRefusal, isContextOverflow, isProviderStreamStallError, isProviderTimeoutError, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, } from "@earendil-works/pi-ai/compat";
+import { cleanupSessionResources, cursorOverflowCompactionSettings, isClassifierRefusal, isContextOverflow, isCursorPayloadResourceExhausted, 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 { getAgentDir } from "../config.js";
 import { getThemeByName, theme } from "../modes/interactive/theme/theme.js";
@@ -31,7 +31,7 @@ import { AgentSettledDelivery } from "./agent-settled-delivery.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { envValue } from "./brand.js";
-import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
+import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, resolveThresholdContextTokens, shouldCompact, } from "./compaction/index.js";
 import { CompactionLifecycleCoordinator } from "./compaction/lifecycle.js";
 import { isWarmSummaryAnchorValid } from "./compaction/warm-anchor.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
@@ -349,6 +349,7 @@ export class AgentSession {
         this._compactionLifecycle = new CompactionLifecycleCoordinator();
         this._sessionWorkBarrier = new SessionWorkBarrier();
         this._overflowRecoveryAttempted = false;
+        this._compactionSkippedTooSmall = false;
         // A retry continuation immediately follows an accepted compaction. Its first
         // response must not retrigger threshold compaction from stale provider usage.
         this._skipNextPostRetryCompactionCheck = false;
@@ -719,6 +720,12 @@ export class AgentSession {
             // completed turn with no continuation keeps pre-PR timing, while the
             // prior prepare callback and context refresh below still run every turn.
             const compactBeforeNextAdmission = async () => {
+                const provider = this.model?.provider;
+                // Cursor rebuilds the full conversation each hop. Compacting here
+                // mutates rootPrompt mid-run and poisons conversationId.
+                if (provider === "cursor" || provider === "cursor-cli-oauth") {
+                    return false;
+                }
                 if (turn.toolResults.length === 0 && !this.agent.hasQueuedMessages()) {
                     return false;
                 }
@@ -1061,7 +1068,9 @@ export class AgentSession {
         }
         const lastAssistant = this._findLastAssistantInMessages(event.messages);
         if (!lastAssistant ||
-            (!this._isRetryableError(lastAssistant) && !this._isHardErrorFallbackEligible(lastAssistant))) {
+            (!this._isRetryableError(lastAssistant) &&
+                !this._isHardErrorFallbackEligible(lastAssistant) &&
+                !isCursorZeroTokenResourceExhausted(lastAssistant))) {
             return;
         }
         this._retryPromise = new Promise((resolve) => {
@@ -1119,7 +1128,7 @@ export class AgentSession {
      */
     _resolveThresholdContextTokens(directContextTokens) {
         const messages = filterContextExcludedMessages(this.agent.state.messages);
-        return Math.max(directContextTokens, estimateMessagesTokens(messages));
+        return resolveThresholdContextTokens(directContextTokens, estimateMessagesTokens(messages));
     }
     _getAutoCompactionReason(message) {
         const settings = this.settingsManager.getCompactionSettings();
@@ -1138,6 +1147,9 @@ export class AgentSession {
         if (isContextOverflow(message, model.contextWindow) && (sameModel || currentContextNeedsCompaction)) {
             return "overflow";
         }
+        if (this._isCursorPayloadOverflow(message)) {
+            return "overflow";
+        }
         let contextTokens;
         const directContextTokens = message.usage ? calculateContextTokens(message.usage) : 0;
         if (message.stopReason !== "error" && directContextTokens !== 0) {
@@ -1225,6 +1237,9 @@ export class AgentSession {
             return false;
         }
         const retryableError = this._isRetryableError(lastAssistant);
+        if (isCursorZeroTokenResourceExhausted(lastAssistant)) {
+            return true;
+        }
         if (!retryableError && this._isHardErrorFallbackEligible(lastAssistant)) {
             return true;
         }
@@ -1369,22 +1384,26 @@ export class AgentSession {
             // Retry transient failures normally and eligible hard errors only through a fallback.
             const retryableError = this._isRetryableError(msg);
             const hardErrorFallbackEligible = this._isHardErrorFallbackEligible(msg);
+            const cursorZeroTokenRe = isCursorZeroTokenResourceExhausted(msg);
             const retryCanAdmitProvider = !userAbortSuppressedQueuedContinuation &&
                 this.settingsManager.getRetrySettings().enabled &&
-                (retryableError || hardErrorFallbackEligible);
+                (retryableError || hardErrorFallbackEligible || cursorZeroTokenRe);
             let compactedBeforeRetry = false;
             if (retryCanAdmitProvider &&
                 requiredAutoCompaction &&
                 !(requiredAutoCompaction === "threshold" && this._hasPendingPostCompactionUsageExemption(msg))) {
                 this._retireFailedRetryAssistant(msg);
-                compactedBeforeRetry = await this._runPrePromptCompaction(msg, true, "threshold", true);
+                compactedBeforeRetry = await this._runPrePromptCompaction(msg, true, requiredAutoCompaction, true);
                 retryContinuationBlocked = !compactedBeforeRetry && !this._isCompactionDelegated();
             }
             let retryOutcome = "not-handled";
             const retryOwnedDeferredQueue = DEFERRED_RETRY_QUEUE_OWNERS.has(this);
             DEFERRED_RETRY_QUEUE_OWNERS.delete(this);
             if (!retryContinuationBlocked && !userAbortSuppressedQueuedContinuation) {
-                if (retryableError) {
+                if (cursorZeroTokenRe) {
+                    retryOutcome = await this._handleRetryableError(msg, { sameModelRemint: true });
+                }
+                else if (retryableError) {
                     retryOutcome = await this._handleRetryableError(msg);
                 }
                 else if (hardErrorFallbackEligible) {
@@ -2014,6 +2033,15 @@ export class AgentSession {
     getRegisteredTool(name) {
         return this._toolRegistry.get(name);
     }
+    /** Cursor exec already ran the tool; still emit tool_result so plan-touch trackers see .omo/plans writes. */
+    async emitExecBridgeToolResult(toolName, toolCallId, args, result, isError) {
+        await this._emitAfterToolCallHooks({
+            type: "toolCall",
+            id: toolCallId,
+            name: toolName,
+            arguments: args && typeof args === "object" && !Array.isArray(args) ? args : {},
+        }, args, result, isError);
+    }
     setActiveToolsByName(toolNames) {
         const tools = [];
         const validToolNames = [];
@@ -2743,7 +2771,7 @@ export class AgentSession {
     }
     async _generateSessionTitle(firstPrompt, model, abortController) {
         try {
-            const auth = await this._getCompactionRequestAuth(model);
+            const auth = await this._getSummarizationRequestAuth(model);
             const title = await generateSessionTitle({
                 firstPrompt,
                 model,
@@ -3885,7 +3913,7 @@ export class AgentSession {
                 throw new CompactionCancelledError();
             }
             const pathEntries = this.sessionManager.getBranch();
-            const settings = this.settingsManager.getCompactionSettings();
+            const settings = cursorOverflowCompactionSettings(this.settingsManager.getCompactionSettings(), this.model?.provider, request.reason);
             let compactionResult = request.precomputed;
             let fromExtension = request.precomputed !== undefined;
             if (!compactionResult) {
@@ -4284,7 +4312,8 @@ export class AgentSession {
             shouldCompact(contextUsage.tokens, contextUsage.contextWindow, settings);
         const recoverableLength = sameModel && isRecoverableLength(assistantMessage, this.model?.maxTokens ?? 0);
         const isOverflow = (isContextOverflow(assistantMessage, contextWindow) && (sameModel || currentContextNeedsCompaction)) ||
-            recoverableLength;
+            recoverableLength ||
+            this._isCursorPayloadOverflow(assistantMessage);
         if (isOverflow &&
             assistantMessage.stopReason === "stop" &&
             this._consumePostCompactionUsageExemption(assistantMessage)) {
@@ -4343,6 +4372,14 @@ export class AgentSession {
                 this._incrementMessageRevision();
             }
             if (!compacted && inlineReason && !this._isCompactionDelegated() && !this._hasSupersedingCompactionClaim()) {
+                if (this._compactionSkippedTooSmall) {
+                    this._compactionSkippedTooSmall = false;
+                    const provider = this.model?.provider;
+                    if (provider === "cursor" || provider === "cursor-cli-oauth") {
+                        this._truncateAgentMessagesToLastUserTurn();
+                    }
+                    return true;
+                }
                 throw new RequiredCompactionError();
             }
             return compacted;
@@ -4462,6 +4499,7 @@ export class AgentSession {
                 this._overflowRecoveryAttempted = false;
             }
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            this._compactionSkippedTooSmall = shouldRetryOverflowWithoutCompact(false, errorMessage);
             const aborted = isCompactionExecutionAborted(error);
             this._emit({
                 type: "compaction_end",
@@ -4645,7 +4683,7 @@ export class AgentSession {
             }
             if (!this._ownsCompactionController(autoCompactionController, "auto"))
                 return false;
-            const preparation = prepareCompaction(this.sessionManager.getBranch(), this.settingsManager.getCompactionSettings(), reason === "overflow");
+            const preparation = prepareCompaction(this.sessionManager.getBranch(), cursorOverflowCompactionSettings(this.settingsManager.getCompactionSettings(), this.model?.provider, reason), reason === "overflow");
             if (!preparation) {
                 return endBeforeExecution();
             }
@@ -5388,10 +5426,31 @@ export class AgentSession {
         }
         return isRetryableAssistantError(message);
     }
+    _isCursorPayloadOverflow(message) {
+        return isCursorPayloadResourceExhausted(message, 0);
+    }
+    _truncateAgentMessagesToLastUserTurn() {
+        const messages = this.agent?.state?.messages;
+        if (!Array.isArray(messages) || messages.length === 0)
+            return false;
+        let lastUser = -1;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i]?.role === "user") {
+                lastUser = i;
+                break;
+            }
+        }
+        if (lastUser <= 0)
+            return false;
+        this.agent.state.messages = messages.slice(lastUser);
+        return true;
+    }
     _isHardErrorFallbackEligible(message) {
         return (!message.errorMessage?.startsWith(TURN_RETRY_SUPPRESSION_PREFIX) &&
             message.stopReason === "error" &&
             !isContextOverflow(message, this.model?.contextWindow ?? 0) &&
+            !this._isCursorPayloadOverflow(message) &&
+            !isCursorZeroTokenResourceExhausted(message) &&
             !isClassifierRefusal(message) &&
             !message.content.some((content) => content.type === "toolCall") &&
             this._retryFallback.canTryFallback());
@@ -5495,10 +5554,28 @@ export class AgentSession {
         const errorMessage = message.errorMessage || "Unknown error";
         const isRefusal = isClassifierRefusal(message);
         const hardErrorFallback = options.hardErrorFallback === true;
+        const sameModelRemint = options.sameModelRemint === true;
         let switchedFallback = false;
         let is429TierRouted = false;
         let hintTierDelayMs;
-        if (hardErrorFallback) {
+        if (sameModelRemint) {
+            this._retryAttempt++;
+            if (this._retryAttempt > settings.maxRetries) {
+                if (this._retryAttempt > 1) {
+                    this._emit({
+                        type: "auto_retry_end",
+                        success: false,
+                        attempt: this._retryAttempt,
+                        finalError: message.errorMessage,
+                    });
+                }
+                this._retryAttempt = 0;
+                this._resetHintTierState();
+                this._resolveRetry();
+                return "not-handled";
+            }
+        }
+        else if (hardErrorFallback) {
             // A non-retryable provider failure must never replay on the same model.
             // Billing-class failures never recover on this account, so the fallback
             // switch pins as the session model instead of reverting after the cooldown.
@@ -5563,6 +5640,9 @@ export class AgentSession {
             // because a stall carries no rate-limit markers or retry-after hint.
             const stallError = isProviderStreamStallError(message);
             // 429-class detection: retryable AND message carries rate-limit markers.
+            // Every same-model wait derived below is floored by the exponential schedule
+            // inside the pure hint policy, so repeated tiny retry-after hints cannot pin
+            // 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) {
@@ -5753,6 +5833,8 @@ export class AgentSession {
         // reach this point with a fallback already applied (hard-error, refusal) set
         // switchedFallback first and force providerDelayMs undefined, so no branch may
         // be reordered to fall through here expecting an implicit switch.
+        // 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;
         const delayMs = switchedFallback
             ? 0