@bastani/atomic 0.8.30 → 0.8.31-alpha.2

package/dist/core/agent-session.js

@@ -23,6 +23,8 @@ import { ATOMIC_GUIDE_COMMAND_NAME, ATOMIC_GUIDE_HELP_CHOICES, atomicGuideModeFo
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage, formatUnresolvedModelMessage, } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, contextCompact as runContextCompact, estimateContextTokens, generateBranchSummary, prepareContextCompaction, shouldCompact, validateContextDeletionRequest, } from "./compaction/index.js";
+import { getModelDefaultContextWindow, getSupportedContextWindows, selectContextWindow } from "./context-window.js";
+import { formatCopilotProviderError, parseCopilotPromptLimitError } from "./copilot-errors.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
@@ -82,6 +84,7 @@ export function parseSkillBlock(text) {
         userMessage: afterClosing ? afterClosing.slice(2).trim() || undefined : undefined,
     };
 }
+const COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS = { allowCopilotLongContextFallback: true };
 function drainAgentMessageQueue(queue) {
     if (!queue)
         return [];
@@ -370,6 +373,7 @@ export class AgentSession {
             }
         }
         this._applyInterruptAbortMessage(event);
+        this._applyProviderErrorGuidance(event);
         // Emit to extensions first
         await this._emitExtensionEvent(event);
         // Notify all listeners
@@ -442,6 +446,16 @@ export class AgentSession {
             }
         }
     }
+    _applyProviderErrorGuidance(event) {
+        if (event.type !== "message_start" && event.type !== "message_update" && event.type !== "message_end")
+            return;
+        if (event.message.role !== "assistant")
+            return;
+        const assistantMessage = event.message;
+        if (assistantMessage.stopReason !== "error" || !assistantMessage.errorMessage)
+            return;
+        assistantMessage.errorMessage = formatCopilotProviderError(assistantMessage.provider, assistantMessage.errorMessage);
+    }
     /** Resolve the pending retry promise */
     _resolveRetry() {
         if (this._retryResolve) {
@@ -1366,14 +1380,16 @@ export class AgentSession {
         }
         const previousModel = this.model;
         const thinkingLevel = this._getThinkingLevelForModelSwitch();
-        this.agent.state.model = model;
-        this.sessionManager.appendModelChange(model.provider, model.id);
-        this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        const nextModel = this._withContextWindowForModelSwitch(model);
+        this.agent.state.model = nextModel;
+        this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
+        this._appendContextWindowChangeIfChanged(previousModel, nextModel);
+        this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
         // Re-clamp thinking level for new model's capabilities
         this.setThinkingLevel(thinkingLevel);
         this._refreshBaseSystemPromptFromActiveTools();
-        this._emitModelChanged(model, previousModel, "set");
-        await this._emitModelSelect(model, previousModel, "set");
+        this._emitModelChanged(nextModel, previousModel, "set");
+        await this._emitModelSelect(nextModel, previousModel, "set");
     }
     /**
      * Cycle to next/previous model.
@@ -1399,19 +1415,21 @@ export class AgentSession {
         const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
         const next = scopedModels[nextIndex];
         const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
+        const nextModel = this._withContextWindowForModelSwitch(next.model);
         // Apply model
-        this.agent.state.model = next.model;
-        this.sessionManager.appendModelChange(next.model.provider, next.model.id);
-        this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+        this.agent.state.model = nextModel;
+        this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
+        this._appendContextWindowChangeIfChanged(currentModel, nextModel);
+        this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
         // Apply thinking level.
         // - Explicit scoped model thinking level overrides current session level
         // - Undefined scoped model thinking level inherits the current session preference
         // setThinkingLevel clamps to model capabilities.
         this.setThinkingLevel(thinkingLevel);
         this._refreshBaseSystemPromptFromActiveTools();
-        this._emitModelChanged(next.model, currentModel, "cycle");
-        await this._emitModelSelect(next.model, currentModel, "cycle");
-        return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
+        this._emitModelChanged(nextModel, currentModel, "cycle");
+        await this._emitModelSelect(nextModel, currentModel, "cycle");
+        return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: true };
     }
     async _cycleAvailableModel(direction) {
         const availableModels = await this._modelRegistry.getAvailable();
@@ -1423,17 +1441,18 @@ export class AgentSession {
             currentIndex = 0;
         const len = availableModels.length;
         const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
-        const nextModel = availableModels[nextIndex];
+        const selectedModel = this._withContextWindowForModelSwitch(availableModels[nextIndex]);
         const thinkingLevel = this._getThinkingLevelForModelSwitch();
-        this.agent.state.model = nextModel;
-        this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
-        this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
+        this.agent.state.model = selectedModel;
+        this.sessionManager.appendModelChange(selectedModel.provider, selectedModel.id);
+        this._appendContextWindowChangeIfChanged(currentModel, selectedModel);
+        this.settingsManager.setDefaultModelAndProvider(selectedModel.provider, selectedModel.id);
         // Re-clamp thinking level for new model's capabilities
         this.setThinkingLevel(thinkingLevel);
         this._refreshBaseSystemPromptFromActiveTools();
-        this._emitModelChanged(nextModel, currentModel, "cycle");
-        await this._emitModelSelect(nextModel, currentModel, "cycle");
-        return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
+        this._emitModelChanged(selectedModel, currentModel, "cycle");
+        await this._emitModelSelect(selectedModel, currentModel, "cycle");
+        return { model: selectedModel, thinkingLevel: this.thinkingLevel, isScoped: false };
     }
     // =========================================================================
     // Thinking Level Management
@@ -1506,6 +1525,133 @@ export class AgentSession {
         return this.model ? clampThinkingLevel(this.model, level) : "off";
     }
     // =========================================================================
+    // Context Window Management
+    // =========================================================================
+    getAvailableContextWindows() {
+        return this.model ? getSupportedContextWindows(this.model) : [];
+    }
+    supportsContextWindowSelection() {
+        return this.getAvailableContextWindows().length > 1;
+    }
+    setContextWindow(contextWindow, options = {}) {
+        if (!this.model) {
+            throw new Error("No model selected");
+        }
+        const selected = selectContextWindow(this.model, contextWindow, COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS);
+        if ("error" in selected) {
+            throw new Error(selected.error);
+        }
+        const previousContextWindow = this.model.contextWindow;
+        const isChanging = previousContextWindow !== selected.contextWindow;
+        this.agent.state.model = selected.model;
+        if (isChanging) {
+            this.sessionManager.appendContextWindowChange(selected.contextWindow);
+            this._emit({ type: "context_window_changed", contextWindow: selected.contextWindow });
+        }
+        if (options.persistDefault === true) {
+            this.settingsManager.setDefaultContextWindowForModel(selected.model.provider, selected.model.id, selected.contextWindow);
+        }
+    }
+    _withContextWindowForModelSwitch(model) {
+        // A source model's scalar contextWindow can be its natural default (for example a 1m-default
+        // model). Do not treat that alone as an opt-in to larger windows on a 400k-default target.
+        const settingsDefaultContextWindow = this._getSettingsContextWindowRequestForModel(model)?.contextWindow;
+        const candidates = [];
+        const targetDefaultContextWindow = getModelDefaultContextWindow(model);
+        if (model.contextWindow !== targetDefaultContextWindow) {
+            // Preserve an explicit context-window selection already applied to the target model
+            // (for example a caller passing selectContextWindow(target, 1m).model).
+            candidates.push(model.contextWindow);
+        }
+        const currentModel = this.model;
+        if (currentModel && this._shouldCarryCurrentContextWindowForModelSwitch(currentModel, settingsDefaultContextWindow)) {
+            candidates.push(currentModel.contextWindow);
+        }
+        if (settingsDefaultContextWindow !== undefined) {
+            candidates.push(settingsDefaultContextWindow);
+        }
+        candidates.push(targetDefaultContextWindow);
+        for (const candidate of candidates) {
+            const selected = selectContextWindow(model, candidate, COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS);
+            if (!("error" in selected))
+                return selected.model;
+        }
+        return model;
+    }
+    _shouldCarryCurrentContextWindowForModelSwitch(currentModel, settingsDefaultContextWindow) {
+        if (currentModel.contextWindow !== getModelDefaultContextWindow(currentModel)) {
+            return true;
+        }
+        if (this.sessionManager.getBranch().some((entry) => entry.type === "context_window_change")) {
+            return true;
+        }
+        return (settingsDefaultContextWindow !== undefined &&
+            currentModel.contextWindow === settingsDefaultContextWindow &&
+            getSupportedContextWindows(currentModel).includes(settingsDefaultContextWindow));
+    }
+    _getSettingsContextWindowRequestForModel(model) {
+        const modelContextWindow = this.settingsManager.getDefaultContextWindowForModel(model.provider, model.id);
+        if (modelContextWindow !== undefined) {
+            return { contextWindow: modelContextWindow, source: "model-settings" };
+        }
+        const globalContextWindow = this.settingsManager.getDefaultContextWindow();
+        return globalContextWindow === undefined
+            ? undefined
+            : { contextWindow: globalContextWindow, source: "global-settings" };
+    }
+    _getContextWindowReplayForModel(model, requestedContextWindow, source) {
+        if (requestedContextWindow !== undefined) {
+            const selected = selectContextWindow(model, requestedContextWindow, COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS);
+            if (!("error" in selected)) {
+                return { model: selected.model, contextWindow: selected.contextWindow, wouldWarn: false };
+            }
+            return this._getDefaultContextWindowReplayForModel(model, source !== "global-settings");
+        }
+        return this._getDefaultContextWindowReplayForModel(model, false);
+    }
+    _getDefaultContextWindowReplayForModel(model, wouldWarn) {
+        const defaultContextWindow = getModelDefaultContextWindow(model);
+        const selected = selectContextWindow(model, defaultContextWindow, COPILOT_CONTEXT_WINDOW_SELECTION_OPTIONS);
+        if (!("error" in selected)) {
+            return { model: selected.model, contextWindow: selected.contextWindow, wouldWarn };
+        }
+        return {
+            model: { ...model, contextWindow: defaultContextWindow, defaultContextWindow },
+            contextWindow: defaultContextWindow,
+            wouldWarn,
+        };
+    }
+    _getResumeContextWindowReplayForModel(model) {
+        const sessionContext = this.sessionManager.buildSessionContext();
+        if (sessionContext.contextWindow !== undefined) {
+            return this._getContextWindowReplayForModel(model, sessionContext.contextWindow, "session");
+        }
+        const settingsContextWindow = this._getSettingsContextWindowRequestForModel(model);
+        return this._getContextWindowReplayForModel(model, settingsContextWindow?.contextWindow, settingsContextWindow?.source);
+    }
+    _applyContextWindowReplay(contextWindow) {
+        if (!this.model)
+            return;
+        const previousContextWindow = this.model.contextWindow;
+        const settingsContextWindow = this._getSettingsContextWindowRequestForModel(this.model);
+        const requestedContextWindow = contextWindow ?? settingsContextWindow?.contextWindow;
+        const source = contextWindow !== undefined ? "session" : settingsContextWindow?.source;
+        const replay = this._getContextWindowReplayForModel(this.model, requestedContextWindow, source);
+        this.agent.state.model = replay.model;
+        if (previousContextWindow !== replay.contextWindow) {
+            this._emit({ type: "context_window_changed", contextWindow: replay.contextWindow });
+        }
+    }
+    _appendContextWindowChangeIfChanged(previousModel, nextModel) {
+        const replay = this._getResumeContextWindowReplayForModel(nextModel);
+        if (!replay.wouldWarn && nextModel.contextWindow === replay.contextWindow)
+            return;
+        this.sessionManager.appendContextWindowChange(nextModel.contextWindow);
+        if (previousModel?.contextWindow !== nextModel.contextWindow) {
+            this._emit({ type: "context_window_changed", contextWindow: nextModel.contextWindow });
+        }
+    }
+    // =========================================================================
     // Queue Mode Management
     // =========================================================================
     /**
@@ -1812,6 +1958,12 @@ export class AgentSession {
             return;
         }
         // Case 1: Overflow - LLM returned context overflow error
+        // When Copilot rejects a 1m client-budget prompt at a lower server cap (for example
+        // because long-context/usage-based billing entitlement is missing), leave the friendly
+        // error visible instead of auto-compacting down to a smaller server tier silently.
+        if (sameModel && this._isCopilotServerCapBelowSelectedContextWindow(assistantMessage)) {
+            return;
+        }
         if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
             if (this._overflowRecoveryAttempted) {
                 this._emit({
@@ -1861,6 +2013,12 @@ export class AgentSession {
             await this._runAutoCompaction("threshold", false);
         }
     }
+    _isCopilotServerCapBelowSelectedContextWindow(assistantMessage) {
+        if (!this.model || this.model.provider !== "github-copilot" || !assistantMessage.errorMessage)
+            return false;
+        const promptLimitError = parseCopilotPromptLimitError(assistantMessage.errorMessage);
+        return promptLimitError !== undefined && this.model.contextWindow > promptLimitError.limitTokens;
+    }
     /**
      * Internal: remove the trailing overflow error from retry context if it is still present.
      */
@@ -2053,7 +2211,11 @@ export class AgentSession {
         if (!refreshedModel || refreshedModel === currentModel) {
             return;
         }
-        this.agent.state.model = refreshedModel;
+        const replay = this._getResumeContextWindowReplayForModel(refreshedModel);
+        this.agent.state.model = replay.model;
+        if (currentModel.contextWindow !== replay.contextWindow) {
+            this._emit({ type: "context_window_changed", contextWindow: replay.contextWindow });
+        }
         this._refreshBaseSystemPromptFromActiveTools();
     }
     _bindExtensionCore(runner) {
@@ -2686,6 +2848,7 @@ export class AgentSession {
             // Update agent state
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
+            this._applyContextWindowReplay(sessionContext.contextWindow);
             // Emit session_tree event
             await this._extensionRunner.emit({
                 type: "session_tree",