@code-yeongyu/senpi 2026.9.12-3 → 2026.9.12

package/dist/core/agent-session.js

@@ -18,9 +18,8 @@ import { rm } from "node:fs/promises";
 import { basename, dirname } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { ProviderRetryWatchdogAbortError, prepareAgentToolCall } from "@earendil-works/pi-agent-core";
-import { contentText, providerNotConfiguredMessage, SERVER_FALLBACK_ABORTED_DIAGNOSTIC, } from "@earendil-works/pi-ai";
+import { contentText, measureCursorHistorySerializedBytes, providerNotConfiguredMessage, SERVER_FALLBACK_ABORTED_DIAGNOSTIC, } from "@earendil-works/pi-ai";
 import { cleanupSessionResources, cursorOverflowCompactionSettings, isClassifierRefusal, isContextOverflow, isCursorPayloadResourceExhausted, isCursorQuotaResourceExhausted, isCursorZeroTokenResourceExhausted, isProviderStreamStallError, isProviderTimeoutError, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, shouldRetryOverflowWithoutCompact, streamSimple, } from "@earendil-works/pi-ai/compat";
-import { getCursorContextLimit } from "@earendil-works/pi-ai/utils/cursor-context-limit";
 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";
@@ -38,7 +37,6 @@ import { calculateContextTokens, collectEntriesForBranchSummary, compact, estima
 import { CompactionLifecycleCoordinator } from "./compaction/lifecycle.js";
 import { isTurnStuckOnContextOverflow } from "./compaction/stuck-overflow.js";
 import { isWarmSummaryAnchorValid } from "./compaction/warm-anchor.js";
-import { admitCursorHistory, cursorAdmissionBudgetBytes } from "./cursor-history-admission.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
 import { AssistantEditError, assertExpectedLeaf, assistantTextEquals, buildEditedAssistantMessage, SessionStreamingError, } from "./edited-assistant-message.js";
@@ -59,7 +57,7 @@ import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { normalizeToolExposure, RUNTIME_EXTENSION_PATH } from "./extensions/types.js";
 import { shouldWarnHighReasoning } from "./high-reasoning-warning.js";
 import { isManualContinueSubmission, MANUAL_CONTINUE_CUSTOM_TYPE, MANUAL_CONTINUE_DIRECTIVE, } from "./manual-continue.js";
-import { filterContextExcludedMessages } from "./messages.js";
+import { convertToLlm, filterContextExcludedMessages, } from "./messages.js";
 import { ModelRegistry } from "./model-registry.js";
 import { getModelNarrowingPatterns, resolveModelScope } from "./model-resolver.js";
 import { PROMPT_CACHE_SAFE_WAIT_ENV, resolvePromptCacheSafeWaitSeconds } from "./prompt-cache-budget.js";
@@ -337,11 +335,121 @@ function isSameOverflowSource(message, model, upstreamModelId) {
 const THINKING_LEVELS_WITH_MAX = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 /** Caps explicit skill expansion so one prompt cannot consume unbounded context. */
 export const MAX_SKILL_EXPANSIONS_PER_PROMPT = 5;
-/**
- * Cursor admission lives in its own module; the names stay exported here so
- * existing importers keep resolving them.
- */
-export { CURSOR_TOOL_RESULT_MAX_CHARS, truncateToolResultBodies } from "./cursor-history-admission.js";
+/** Cursor ingest rejects large verbatim tool payloads. The bound is UTF-8 bytes. */
+export const CURSOR_TOOL_RESULT_MAX_CHARS = 2000;
+export const CURSOR_TOOL_RESULT_MAX_BYTES = 50_000;
+const CURSOR_TRUNCATION_MARKER = "\n...[truncated]";
+export function truncateToolResultBodies(messages, maxChars = CURSOR_TOOL_RESULT_MAX_CHARS, maxBytes = CURSOR_TOOL_RESULT_MAX_BYTES, convert = (candidate) => convertToLlm(candidate)) {
+    if (!Array.isArray(messages) || messages.length === 0)
+        return { messages, changed: false };
+    const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+    const markerChars = [...segmenter.segment(CURSOR_TRUNCATION_MARKER)].length;
+    const result = messages.slice();
+    let changed = false;
+    // Apply the per-result character cap first, independent of the aggregate wire cap.
+    for (let messageIndex = result.length - 1; messageIndex >= 0; messageIndex--) {
+        const message = result[messageIndex];
+        if (message.role !== "toolResult" || !Array.isArray(message.content))
+            continue;
+        let content = message.content;
+        for (let partIndex = content.length - 1; partIndex >= 0; partIndex--) {
+            const part = content[partIndex];
+            if (part.type === "image" && typeof part.data === "string")
+                continue;
+            if (part.type !== "text" || typeof part.text !== "string")
+                continue;
+            const graphemes = [...segmenter.segment(part.text)].map((item) => item.segment);
+            if (graphemes.length <= maxChars)
+                continue;
+            const kept = graphemes.slice(0, Math.max(0, maxChars - markerChars)).join("");
+            const nextText = kept + CURSOR_TRUNCATION_MARKER;
+            content = content === message.content ? content.slice() : content;
+            content[partIndex] = { ...part, text: nextText };
+            result[messageIndex] = { ...message, content };
+            changed = true;
+        }
+    }
+    const measure = (candidate) => {
+        const converted = convert(candidate);
+        const activeUserMessageIndex = converted.at(-1)?.role === "user" ? converted.length - 1 : -1;
+        return measureCursorHistorySerializedBytes(converted, activeUserMessageIndex);
+    };
+    const fits = (candidate = result) => measure(candidate) <= maxBytes;
+    if (fits())
+        return { messages: changed ? result : messages, changed };
+    // Empty the oldest result bodies. Search the monotonic prefix of candidates
+    // rather than serializing once for every result (admission must stay bounded).
+    const emptyToolResult = (message) => {
+        if (message.role !== "toolResult" || !Array.isArray(message.content))
+            return message;
+        const emptiedContent = message.content.map((part) => part.type === "text" ? { ...part, text: "" } : part.type === "image" ? { ...part, data: "" } : part);
+        const content = emptiedContent.filter((part, index) => {
+            if (index === 0)
+                return true;
+            const previous = emptiedContent[index - 1];
+            const empty = part.type === "text" ? part.text === "" : part.type === "image" && part.data === "";
+            const previousEmpty = previous.type === "text" ? previous.text === "" : previous.type === "image" && previous.data === "";
+            return !empty || !previousEmpty;
+        });
+        return { ...message, content };
+    };
+    const toolResultIndexes = result.flatMap((message, index) => message.role === "toolResult" && Array.isArray(message.content) ? [index] : []);
+    const withEmptyPrefix = (count) => {
+        const candidate = result.slice();
+        for (let i = 0; i < count; i++)
+            candidate[toolResultIndexes[i]] = emptyToolResult(candidate[toolResultIndexes[i]]);
+        return candidate;
+    };
+    let low = 0;
+    let high = toolResultIndexes.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (fits(withEmptyPrefix(middle + 1)))
+            high = middle;
+        else
+            low = middle + 1;
+    }
+    const emptyCount = Math.min(low + 1, toolResultIndexes.length);
+    if (emptyCount > 0) {
+        result.splice(0, result.length, ...withEmptyPrefix(emptyCount));
+        changed = true;
+    }
+    if (fits())
+        return { messages: changed ? result : messages, changed };
+    // If metadata alone exceeds the cap, discard the oldest complete turns. This
+    // search is also monotonic and avoids quadratic whole-history reserialization.
+    const turnRanges = [];
+    const isConvertedUser = (message) => convert([message])[0]?.role === "user";
+    for (let index = 0; index < result.length; index++) {
+        if (!isConvertedUser(result[index]))
+            continue;
+        const nextUser = result.findIndex((message, nextIndex) => nextIndex > index && isConvertedUser(message));
+        turnRanges.push([index, nextUser < 0 ? result.length : nextUser]);
+    }
+    const withoutTurns = (count) => {
+        if (count === 0)
+            return result;
+        const start = turnRanges[0]?.[0] ?? 0;
+        const end = turnRanges[count - 1]?.[1] ?? start;
+        return [...result.slice(0, start), ...result.slice(end)];
+    };
+    low = 0;
+    high = turnRanges.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (fits(withoutTurns(middle + 1)))
+            high = middle;
+        else
+            low = middle + 1;
+    }
+    const turnCount = Math.min(low + 1, turnRanges.length);
+    if (turnCount > 0) {
+        const next = withoutTurns(turnCount);
+        result.splice(0, result.length, ...next);
+        changed = true;
+    }
+    return { messages: changed ? result : messages, changed };
+}
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -797,20 +905,6 @@ export class AgentSession {
             usage: hookResult?.usage,
         };
     }
-    /**
-     * Cursor states a model's real context ceiling on every conversation
-     * checkpoint. Once observed, it replaces the catalog guess on the live model
-     * so context usage, compaction thresholds and admission all size against the
-     * window the server will actually enforce.
-     */
-    _applyObservedCursorContextWindow(model) {
-        const observed = getCursorContextLimit(model.id);
-        if (observed === undefined || observed <= 0 || observed === model.contextWindow)
-            return;
-        const previous = model.contextWindow;
-        model.contextWindow = observed;
-        this._sessionLogger.info("cursor_context_window_observed", { modelId: model.id, previous, observed });
-    }
     _installAgentNextTurnRefresh() {
         const previousPrepareNextTurnWithContext = this.agent.prepareNextTurnWithContext ??
             (this.agent.prepareNextTurn
@@ -819,33 +913,10 @@ export class AgentSession {
         const previousTransformContext = this.agent.transformContext;
         this.agent.transformContext = async (messages, signal) => {
             const transformed = previousTransformContext ? await previousTransformContext(messages, signal) : messages;
-            const model = this.model;
-            if (model?.provider !== "cursor" && model?.provider !== "cursor-cli-oauth")
-                return transformed;
-            this._applyObservedCursorContextWindow(model);
-            const budgetBytes = cursorAdmissionBudgetBytes(model.contextWindow);
-            const admission = admitCursorHistory({
-                messages: transformed,
-                budgetBytes,
-                convert: (candidate) => this.agent.convertToLlm(candidate),
-            });
-            if (admission.blankedToolResults > 0) {
-                this._sessionLogger.info("cursor_admission_truncated", {
-                    blankedToolResults: admission.blankedToolResults,
-                    bytesBefore: admission.bytesBefore,
-                    bytesAfter: admission.bytesAfter,
-                    budgetBytes,
-                });
+            if (this.model?.provider === "cursor" || this.model?.provider === "cursor-cli-oauth") {
+                return ((await truncateToolResultBodies(transformed, CURSOR_TOOL_RESULT_MAX_CHARS, CURSOR_TOOL_RESULT_MAX_BYTES, (candidate) => this.agent.convertToLlm(candidate))).messages ?? transformed);
             }
-            if (admission.overBudget) {
-                // The request is still admitted: Cursor answers an oversized history
-                // with a 0-token resource_exhausted, which the session layer compacts.
-                this._sessionLogger.warn("cursor_admission_over_budget", {
-                    bytes: admission.bytesAfter,
-                    budgetBytes,
-                });
-            }
-            return admission.messages ?? transformed;
+            return transformed;
         };
         this.agent.prepareNextTurnWithContext = async (turn, signal) => {
             // Enforce compaction only when this prepare precedes an actual provider
@@ -2591,36 +2662,6 @@ export class AgentSession {
         }
         return sentences.length > 0 ? `${prompt}\n\n${sentences.join("\n\n")}` : prompt;
     }
-    /**
-     * Run `input` extension handlers for queued (steer / follow-up) input.
-     *
-     * Queued input reaches the model exactly like a prompt does, so it passes the same
-     * extension surface: a handler may consume it or rewrite it. The input keeps the
-     * session-scoped `inputId` identity, so the `input_disposition` event a handler
-     * observes correlates with the input it saw.
-     *
-     * @returns the (possibly transformed) input, or `undefined` when a handler consumed it.
-     */
-    async _runInputHandlers(text, images, source, streamingBehavior) {
-        if (!this._extensionRunner.hasHandlers("input")) {
-            return { text, images };
-        }
-        const inputId = `${this.sessionManager.getSessionId()}:${++this._nextInputId}`;
-        const inputResult = await this._extensionRunner.emitInput(text, images, source, streamingBehavior, inputId);
-        if (inputResult.action === "handled") {
-            await this._emitInputDisposition(inputId, "handled");
-            return undefined;
-        }
-        if (inputResult.action === "transform") {
-            return { text: inputResult.text, images: inputResult.images ?? images, inputId };
-        }
-        return { text, images, inputId };
-    }
-    async _emitInputDisposition(inputId, disposition) {
-        if (inputId === undefined)
-            return;
-        await this._extensionRunner.emit({ type: "input_disposition", inputId, disposition });
-    }
     /**
      * Send a prompt to the agent.
      * - Handles extension commands (registered via pi.registerCommand) immediately, even during streaming
@@ -3135,28 +3176,23 @@ export class AgentSession {
         return formatSkillInvocationPrompt(skillBlocks, userRequest);
     }
     /**
-     * Shared queueing path for `steer()` and `followUp()`: extension-command guard,
-     * `input` handlers, skill/template expansion, then the recovery-ordered enqueue.
+     * Queue a steering message while the agent is running.
+     * Delivered after the current assistant turn finishes executing its tool calls,
+     * before the next LLM call.
+     * Expands skill commands and prompt templates. Errors on extension commands.
+     * @param images Optional image attachments to include with the message
+     * @throws Error if text is an extension command
      */
-    async _queueUserInput(text, images, behavior, options) {
+    async steer(text, images, recovery) {
         // Check for extension commands (cannot be queued)
         if (text.startsWith("/")) {
             this._throwIfExtensionCommand(text);
         }
-        const processedInput = await this._runInputHandlers(text, images, options?.source ?? "interactive", this.isStreaming ? behavior : undefined);
-        if (!processedInput)
-            return;
         // Expand skill commands and prompt templates
-        let expandedText = this._expandSkillCommand(processedInput.text);
+        let expandedText = this._expandSkillCommand(text);
         const templateExpansion = expandPromptTemplateWithMetadata(expandedText, [...this.promptTemplates]);
         expandedText = templateExpansion.text;
-        if (behavior === "steer") {
-            await this._queueSteer(expandedText, processedInput.images, options?.enqueueOrder);
-        }
-        else {
-            await this._queueFollowUp(expandedText, processedInput.images, options?.enqueueOrder);
-        }
-        await this._emitInputDisposition(processedInput.inputId, "queued");
+        await this._queueSteer(expandedText, images, recovery?.enqueueOrder);
         if (templateExpansion.template) {
             this._emit({
                 type: "command_invocation",
@@ -3169,30 +3205,34 @@ export class AgentSession {
             });
         }
     }
-    /**
-     * Queue a steering message while the agent is running.
-     * Delivered after the current assistant turn finishes executing its tool calls,
-     * before the next LLM call.
-     * Runs `input` extension handlers, then expands skill commands and prompt templates.
-     * Errors on extension commands.
-     * @param images Optional image attachments to include with the message
-     * @param options Recovery enqueue order and input source; source defaults to interactive
-     * @throws Error if text is an extension command
-     */
-    async steer(text, images, options) {
-        await this._queueUserInput(text, images, "steer", options);
-    }
     /**
      * Queue a follow-up message to be processed after the agent finishes.
      * Delivered only when agent has no more tool calls or steering messages.
-     * Runs `input` extension handlers, then expands skill commands and prompt templates.
-     * Errors on extension commands.
+     * Expands skill commands and prompt templates. Errors on extension commands.
      * @param images Optional image attachments to include with the message
-     * @param options Recovery enqueue order and input source; source defaults to interactive
      * @throws Error if text is an extension command
      */
-    async followUp(text, images, options) {
-        await this._queueUserInput(text, images, "followUp", options);
+    async followUp(text, images, recovery) {
+        // Check for extension commands (cannot be queued)
+        if (text.startsWith("/")) {
+            this._throwIfExtensionCommand(text);
+        }
+        // Expand skill commands and prompt templates
+        let expandedText = this._expandSkillCommand(text);
+        const templateExpansion = expandPromptTemplateWithMetadata(expandedText, [...this.promptTemplates]);
+        expandedText = templateExpansion.text;
+        await this._queueFollowUp(expandedText, images, recovery?.enqueueOrder);
+        if (templateExpansion.template) {
+            this._emit({
+                type: "command_invocation",
+                command: {
+                    name: templateExpansion.template.name,
+                    source: "prompt",
+                    sourceInfo: templateExpansion.template.sourceInfo,
+                    syntax: "slash",
+                },
+            });
+        }
     }
     _startSessionTitleGeneration(firstPrompt) {
         if (!this._autoTitleSessions || this.sessionManager.getSessionName() || shouldSkipSessionTitle(firstPrompt)) {
@@ -4417,7 +4457,7 @@ export class AgentSession {
         // (#7921 case 6).
         this._releaseBlockedPostCompactionAdmission();
         const pathEntries = this.sessionManager.getBranch();
-        const settings = cursorOverflowCompactionSettings(this._getCompactionSettings(model), model.provider, "manual");
+        const settings = cursorOverflowCompactionSettings(this._getCompactionSettings(), model.provider, "manual");
         if (!prepareCompaction(pathEntries, settings)) {
             const requestId = randomUUID();
             const lastEntry = pathEntries[pathEntries.length - 1];
@@ -4857,11 +4897,7 @@ export class AgentSession {
         // Size the same retained context that will be admitted to Cursor. Persisted JSONL
         // remains verbatim, but the in-memory request representation is bounded first.
         if (model.provider === "cursor" || model.provider === "cursor-cli-oauth") {
-            simulatedMessages =
-                admitCursorHistory({
-                    messages: simulatedMessages,
-                    budgetBytes: cursorAdmissionBudgetBytes(model.contextWindow),
-                }).messages ?? simulatedMessages;
+            simulatedMessages = truncateToolResultBodies(simulatedMessages).messages ?? simulatedMessages;
         }
         const contextTokens = estimateMessagesTokens(filterContextExcludedMessages(simulatedMessages));
         const settings = this._getCompactionSettings();
@@ -5505,9 +5541,6 @@ export class AgentSession {
     async _runAutoCompaction(reason, willRetry) {
         if (this._isCompactionDelegated())
             return false;
-        // Model identity is captured before the auth await below: a model switch during
-        // that await must not change the token budgets this compaction was admitted with.
-        const model = this.model;
         const finishCompactionWork = this._sessionWorkBarrier.begin();
         const agentMessagesAtStart = this.agent.state.messages.slice();
         const autoCompactionController = new AbortController();
@@ -5553,7 +5586,7 @@ export class AgentSession {
             }
             if (!this._ownsCompactionController(autoCompactionController, "auto"))
                 return false;
-            const preparation = prepareCompaction(this.sessionManager.getBranch(), cursorOverflowCompactionSettings(this._getCompactionSettings(model), model?.provider, reason), reason === "overflow");
+            const preparation = prepareCompaction(this.sessionManager.getBranch(), cursorOverflowCompactionSettings(this._getCompactionSettings(), this.model?.provider, reason), reason === "overflow");
             if (!preparation) {
                 return endBeforeExecution();
             }
@@ -5646,14 +5679,8 @@ export class AgentSession {
         this._autoCompactionSessionOverride = enabled;
         this._emitSessionSettingsChanged();
     }
-    /**
-     * Compaction settings for a model, defaulting to the session model so per-model
-     * token budgets (`compaction.modelOverrides`) apply to every compaction read here.
-     * Callers that captured a model before an await pass it explicitly, so a model
-     * switch during that await cannot change the budget the operation started with.
-     */
-    _getCompactionSettings(forModel = this.model) {
-        const settings = this.settingsManager.getCompactionSettings(forModel);
+    _getCompactionSettings() {
+        const settings = this.settingsManager.getCompactionSettings();
         if (this._autoCompactionSessionOverride === undefined)
             return settings;
         return { ...settings, enabled: this._autoCompactionSessionOverride };
@@ -6904,31 +6931,11 @@ export class AgentSession {
         // 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 plannedDelayMs = switchedFallback || sameModelNativeRecovery
+        const delayMs = switchedFallback || sameModelNativeRecovery
             ? 0
             : is429TierRouted
                 ? (hintTierDelayMs ?? providerDelayMs ?? localExponentialMs)
                 : (nonTierProviderDelayMs ?? localExponentialMs);
-        // `retry.maxAgentDelayMs` is a hard ceiling on ONE agent-level wait, applied after
-        // the profile/hint/jitter planning above (the planner still owns the schedule).
-        // It bounds the worst case a provider hint or a long backoff can impose on a turn.
-        // A profile's override-mode turn hint ceiling owns this clamp instead of the
-        // settings default (fork semantics: the ceiling belongs to the profile, and an
-        // explicit profile ceiling must not be clamped by the global default): `null`
-        // (kimi-code) is explicitly uncapped, so a wait the over-ceiling gate above
-        // admitted passes through verbatim; a number is the profile's own cap. The
-        // settings cap applies only when the profile declares no ceiling of its own
-        // (the tiered senpi-default).
-        const profileTurnCeilingMs = retryProfile.turn.serverHint.mode === "override" ? retryProfile.turn.serverHint.ceiling.maxDelayMs : undefined;
-        // An explicitly user-configured retry.maxAgentDelayMs always wins; a profile's own
-        // ceiling is the next authority; the 60s default is the last resort.
-        const userConfiguredCeilingMs = this.settingsManager.isRetryMaxAgentDelayMsConfigured?.() ?? false;
-        const agentCeilingMs = userConfiguredCeilingMs
-            ? settings.maxAgentDelayMs
-            : profileTurnCeilingMs === undefined
-                ? settings.maxAgentDelayMs
-                : profileTurnCeilingMs;
-        const delayMs = Math.min(plannedDelayMs, agentCeilingMs ?? Number.MAX_SAFE_INTEGER);
         // Prepare before auto_retry_start so an immediate Esc can cancel the retry sleep.
         this._retryAbortController = new AbortController();
         this._emit({
@@ -7217,9 +7224,6 @@ export class AgentSession {
         if (this.isStreaming) {
             throw new SessionStreamingError();
         }
-        if (this.isCompacting) {
-            throw new Error("Wait for the current compaction or tree navigation to finish before navigating the session tree.");
-        }
         const oldLeafId = this.sessionManager.getLeafId();
         // Stale tokens fail even for a would-be no-op, before any extension hears about the navigation.
         assertExpectedLeaf(options.expectedLeafId, oldLeafId);