@dreb/coding-agent 2.46.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";
@@ -883,7 +884,12 @@ export class AgentSession {
     }
     /** Emit extension events based on agent events */
     async _emitExtensionEvent(event) {
-        if (!this._extensionRunner)
+        // The runner is created unconditionally (so built-in tools like ask_user
+        // always have a UI context). When no extensions are loaded there are no
+        // handlers to invoke — return synchronously to avoid inserting an extra
+        // await tick per event, which would otherwise delay the final agent_end
+        // emission past when prompt() resolves.
+        if (!this._extensionRunner || !this._extensionRunner.hasExtensions)
             return;
         if (event.type === "agent_start") {
             this._turnIndex = 0;
@@ -1692,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);
@@ -1755,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);
@@ -1785,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);
@@ -1974,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) {
@@ -2021,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
@@ -2042,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",
@@ -2055,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;
         }
@@ -2085,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.
      */
@@ -2158,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) {
@@ -2300,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) {
@@ -2443,9 +2526,15 @@ export class AgentSession {
         const wrappedExtensionTools = this._extensionRunner
             ? wrapRegisteredTools(allCustomTools, this._extensionRunner)
             : [];
+        // Give base tools a per-execution extension context so built-ins like
+        // ask_user can reach ctx.ui. createContext() snapshots hasUI at call time,
+        // so print/RPC-without-host modes degrade to the no-op UI (hasUI === false).
+        const baseToolCtxFactory = this._extensionRunner
+            ? () => this._extensionRunner.createContext()
+            : undefined;
         const toolRegistry = new Map(Array.from(this._baseToolDefinitions.values()).map((definition) => [
             definition.name,
-            wrapToolDefinition(definition),
+            wrapToolDefinition(definition, baseToolCtxFactory),
         ]));
         for (const tool of wrappedExtensionTools) {
             toolRegistry.set(tool.name, tool);
@@ -2544,12 +2633,11 @@ export class AgentSession {
                 extensionsResult.runtime.flagValues.set(name, value);
             }
         }
-        const hasExtensions = extensionsResult.extensions.length > 0;
-        const hasCustomTools = this._customTools.length > 0;
-        this._extensionRunner =
-            hasExtensions || hasCustomTools
-                ? new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, this._modelRegistry)
-                : undefined;
+        // The runner also owns the cross-surface UI context used by built-in
+        // tools such as ask_user. Create it even when no third-party extensions
+        // are loaded; otherwise ordinary TUI/Dashboard sessions give base tools
+        // no ctx.ui and ask_user can never open its dialog.
+        this._extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, this._modelRegistry);
         if (this._extensionRunnerRef) {
             this._extensionRunnerRef.current = this._extensionRunner;
         }
@@ -2572,6 +2660,7 @@ export class AgentSession {
                 "subagent",
                 "wait",
                 "search",
+                "ask_user",
                 "skill",
                 "tasks_update",
                 "suggest_next",
@@ -2864,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");
             }