@dreb/coding-agent 2.47.0 → 2.48.0

package/dist/core/agent-session.js

@@ -29,6 +29,7 @@ import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { checkScriptContent, extractScriptPaths, isForbiddenCommand } from "./forbidden-commands.js";
 import { getGitRepoState, getGitStatusMetadata } from "./git-repo-state.js";
 import { findGitRoot } from "./git-root.js";
+import { deriveK3ContextTierModel, isK3256kTier, K3_1M_CONTEXT_WINDOW, K3_256K_CONTEXT_WINDOW, K3_UPGRADE_CUTOFF_TOKENS, shouldUpgradeK3Tier, } from "./k3-context-tier.js";
 import { log } from "./logger.js";
 import { computeNestedContextBlock } from "./nested-context.js";
 import { PerformanceTracker } from "./performance-tracker.js";
@@ -1697,7 +1698,7 @@ export class AgentSession {
         }
         const previousModel = this.model;
         const thinkingLevel = this._getThinkingLevelForModelSwitch();
-        this.agent.setModel(model);
+        this.agent.setModel(this._applyContextTier(model));
         this._refreshThinkingDisplay(model);
         this.sessionManager.appendModelChange(model.provider, model.id);
         this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
@@ -1760,7 +1761,7 @@ export class AgentSession {
         const next = scopedModels[nextIndex];
         const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
         // Apply model
-        this.agent.setModel(next.model);
+        this.agent.setModel(this._applyContextTier(next.model));
         this._refreshThinkingDisplay(next.model);
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
         this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
@@ -1790,7 +1791,7 @@ export class AgentSession {
             throw new Error(`No API key for ${nextModel.provider}/${nextModel.id}`);
         }
         const thinkingLevel = this._getThinkingLevelForModelSwitch();
-        this.agent.setModel(nextModel);
+        this.agent.setModel(this._applyContextTier(nextModel));
         this._refreshThinkingDisplay(nextModel);
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
         this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
@@ -1979,6 +1980,11 @@ export class AgentSession {
             const newEntries = this.sessionManager.getEntries();
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.replaceMessages(sessionContext.messages);
+            // Re-derive the K3 context tier: the compacted context is small again,
+            // so the session returns to the cheaper 256k wire tier.
+            if (this.model) {
+                this.agent.setModel(this._applyContextTier(this.model));
+            }
             // Get the saved compaction entry for the extension event
             const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
             if (this._extensionRunner && savedCompactionEntry) {
@@ -2026,12 +2032,10 @@ export class AgentSession {
      */
     async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
         const settings = this.settingsManager.getCompactionSettings();
-        if (!settings.enabled)
-            return;
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
         if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
             return;
-        const contextWindow = this.model?.contextWindow ?? 0;
+        let contextWindow = this.model?.contextWindow ?? 0;
         // Skip overflow check if the message came from a different model.
         // This handles the case where user switched from a smaller-context model (e.g. opus)
         // to a larger-context model (e.g. codex) - the overflow error from the old model
@@ -2047,6 +2051,23 @@ export class AgentSession {
         }
         // Case 1: Overflow - LLM returned context overflow error
         if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
+            // K3 auto context tier: an overflow in the 256k tier upgrades to the
+            // 1M tier instead of compacting — the Kimi backend grows the prompt
+            // cache seamlessly. This runs even when compaction is disabled since
+            // no context reduction is involved.
+            if (this._tryUpgradeK3ContextTier()) {
+                // Remove the error message from agent state (it IS saved to session
+                // for history, but we don't want it in context for the retry)
+                this._removeLastAssistantMessage();
+                setTimeout(() => {
+                    this.agent.continue().catch((err) => {
+                        this.warnInSession(`Agent failed to continue after context window upgrade: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                }, 100);
+                return;
+            }
+            if (!settings.enabled)
+                return;
             if (this._overflowRecoveryAttempted) {
                 this._emit({
                     type: "auto_compaction_end",
@@ -2060,10 +2081,7 @@ export class AgentSession {
             this._overflowRecoveryAttempted = true;
             // Remove the error message from agent state (it IS saved to session for history,
             // but we don't want it in context for the retry)
-            const messages = this.agent.state.messages;
-            if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
-                this.agent.replaceMessages(messages.slice(0, -1));
-            }
+            this._removeLastAssistantMessage();
             await this._runAutoCompaction("overflow", true);
             return;
         }
@@ -2090,10 +2108,65 @@ export class AgentSession {
         else {
             contextTokens = calculateContextTokens(assistantMessage.usage);
         }
+        // K3 auto context tier: reaching the 256k cutoff upgrades to the 1M tier
+        // instead of compacting. This is model-capability management, not context
+        // reduction, so it applies even when compaction is disabled. The cutoff is
+        // fixed at the default compaction threshold of the 256k window; a
+        // user-lowered compaction threshold takes precedence and effectively
+        // disables the upgrade.
+        if (shouldUpgradeK3Tier(this.model, contextTokens)) {
+            // A user-lowered compaction threshold takes precedence over the
+            // upgrade: if the user's compact point for the 256k window sits below
+            // the default cutoff and is already exceeded, compact instead.
+            const userCompactPoint = K3_256K_CONTEXT_WINDOW - settings.reserveTokens;
+            const userThresholdPreempts = settings.enabled && userCompactPoint < K3_UPGRADE_CUTOFF_TOKENS && contextTokens > userCompactPoint;
+            if (!userThresholdPreempts) {
+                this._tryUpgradeK3ContextTier();
+                contextWindow = this.model?.contextWindow ?? contextWindow;
+            }
+        }
+        if (!settings.enabled)
+            return;
         if (shouldCompact(contextTokens, contextWindow, settings)) {
             await this._runAutoCompaction("threshold", false);
         }
     }
+    /**
+     * Apply the K3 auto context tier to a model being set on the agent. The
+     * user-facing `k3` model runs on the cheaper `k3-256k` wire model ID until
+     * the session context grows past the 256k cutoff; no-op for other models.
+     * See k3-context-tier.ts.
+     */
+    _applyContextTier(model) {
+        return deriveK3ContextTierModel(model, estimateContextTokens(this.agent.state.messages).tokens);
+    }
+    /** Remove the last message from agent state when it is an assistant message. */
+    _removeLastAssistantMessage() {
+        const messages = this.agent.state.messages;
+        if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
+            this.agent.replaceMessages(messages.slice(0, -1));
+        }
+    }
+    /**
+     * Upgrade the K3 auto context tier from 256k to 1M. The Kimi backend
+     * upgrades the prompt cache seamlessly, so no context is lost or
+     * compacted. Returns true when the upgrade was applied.
+     */
+    _tryUpgradeK3ContextTier() {
+        const model = this.model;
+        if (!model || !isK3256kTier(model))
+            return false;
+        const upgraded = deriveK3ContextTierModel(model, K3_UPGRADE_CUTOFF_TOKENS + 1);
+        this.agent.setModel(upgraded);
+        this._emit({
+            type: "context_window_upgrade",
+            provider: upgraded.provider,
+            modelId: upgraded.id,
+            fromContextWindow: K3_256K_CONTEXT_WINDOW,
+            toContextWindow: K3_1M_CONTEXT_WINDOW,
+        });
+        return true;
+    }
     /**
      * Internal: Run auto-compaction with events.
      */
@@ -2163,6 +2236,11 @@ export class AgentSession {
             const newEntries = this.sessionManager.getEntries();
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.replaceMessages(sessionContext.messages);
+            // Re-derive the K3 context tier: the compacted context is small again,
+            // so the session returns to the cheaper 256k wire tier.
+            if (this.model) {
+                this.agent.setModel(this._applyContextTier(this.model));
+            }
             // Get the saved compaction entry for the extension event
             const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
             if (this._extensionRunner && savedCompactionEntry) {
@@ -2305,7 +2383,7 @@ export class AgentSession {
         if (!refreshedModel || refreshedModel === currentModel) {
             return;
         }
-        this.agent.setModel(refreshedModel);
+        this.agent.setModel(this._applyContextTier(refreshedModel));
         this._refreshThinkingDisplay(refreshedModel);
     }
     _bindExtensionCore(runner) {
@@ -2875,7 +2953,7 @@ export class AgentSession {
             const availableModels = await this._modelRegistry.getAvailable();
             const match = availableModels.find((m) => m.provider === sessionContext.model.provider && m.id === sessionContext.model.modelId);
             if (match) {
-                this.agent.setModel(match);
+                this.agent.setModel(this._applyContextTier(match));
                 this._refreshThinkingDisplay(match);
                 await this._emitModelSelect(match, previousModel, "restore");
             }