@kenkaiiii/ggcoder 5.81.0 → 5.83.0

package/dist/core/agent-session.js

@@ -1,5 +1,5 @@
 import { agentLoop, isAbortError, isUsageLimitError, repairToolPairingAdjacent, } from "@kenkaiiii/gg-agent";
-import { ProviderError, stream, } from "@kenkaiiii/gg-ai";
+import { ProviderError, resolveToolSchema, stream, } from "@kenkaiiii/gg-ai";
 import { EventBus } from "./event-bus.js";
 import { flagUntrustedToolResult } from "./injection-detect.js";
 import { COMPLETION_REVIEW_STATE_KIND, } from "./completion-review.js";
@@ -53,7 +53,7 @@ import { buildLoopBreakMessage } from "./loop-breaker.js";
 import { buildRegroundingMessage, requestTextForRegrounding } from "./regrounding.js";
 import { buildSemanticLoopJudgePrompt, buildSemanticLoopMessage, parseSemanticLoopVerdict, SEMANTIC_LOOP_JUDGE_TIMEOUT_MS, withJudgeTimeout, } from "./semantic-loop-check.js";
 import { buildEnvDeltaMessage, buildLanguageUpdateMessage } from "./env-delta.js";
-import { wrapSteeringText, buildNotificationSteeringText, STEERING_PREFIX } from "./steering.js";
+import { wrapSteeringText, buildNotificationSteeringText, buildIdleWakeNotificationText, STEERING_PREFIX, } from "./steering.js";
 import { AgentNotificationQueue } from "./agent-notifications.js";
 import { VerificationGate, VERIFICATION_STATE_KIND } from "./verification-gate.js";
 import { findUserSessionPrompt, getUserSessionPrompt } from "./session-preview.js";
@@ -68,6 +68,54 @@ import { RunLoopMonitor } from "./agent-session/run-loop-monitor.js";
 import { VerificationTracker } from "./agent-session/verification-tracker.js";
 import { McpToolRegistry } from "./agent-session/mcp-tools.js";
 import { TranscriptMarkers } from "./agent-session/transcript-markers.js";
+// ── Output cap ─────────────────────────────────────────────
+/**
+ * The output cap to send on a request. A model's output ceiling can equal its
+ * whole window (Kimi K2.7 Code: 262,144 of 262,144), and providers that count
+ * prompt + max_tokens against the window reject every request with a real
+ * prompt. Cap it at the room the model's TOTAL window leaves once the context
+ * reaches this session's compaction trigger — the largest prompt it lets build
+ * up. The total window, not the route's: the ChatGPT/Codex route's 272K
+ * window is an input budget, and GPT-6's 128K output sits outside it.
+ */
+export function outputCapForRequest(options) {
+    const totalWindow = getContextWindow(options.model, { provider: options.provider });
+    const { targetTokens } = resolveCompactionPolicy({
+        provider: options.provider,
+        model: options.model,
+        contextWindow: getContextWindow(options.model, {
+            provider: options.provider,
+            accountId: options.accountId,
+        }),
+        threshold: options.threshold,
+        accountId: options.accountId,
+    });
+    const room = totalWindow - targetTokens;
+    return room > 0 ? Math.min(options.maxTokens, room) : options.maxTokens;
+}
+// ── Paid models ────────────────────────────────────────────
+/**
+ * Reply for chat bridges (Telegram, agent home) that have no confirmation step.
+ * Generic on purpose: every paid model (Claude fast mode, MiMo UltraSpeed) is
+ * refused here, so the reason must not name one of them.
+ */
+export function paidModelRefusal(modelName) {
+    return `${modelName} spends real money, so it can't be switched to from chat. Switch to it in the GG Coder app or CLI, where you confirm it.`;
+}
+/**
+ * Thrown by {@link AgentSession.switchModel} when the target model spends real
+ * money and the caller didn't pass the user's explicit confirmation.
+ */
+export class PaidModelConfirmationError extends Error {
+    modelName;
+    detail;
+    constructor(modelName, detail) {
+        super(`${modelName} spends real money. ${detail} Confirm before switching to it.`);
+        this.name = "PaidModelConfirmationError";
+        this.modelName = modelName;
+        this.detail = detail;
+    }
+}
 export { resolveSessionToolResultCharLimit, resolveSessionTurnToolResultCharLimit, } from "./agent-session/helpers.js";
 // ── Agent Session ──────────────────────────────────────────
 export class AgentSession {
@@ -156,6 +204,8 @@ export class AgentSession {
     deferredCompactionPending = false;
     /** Latest provider count, anchored to the assistant response it measured. */
     providerContext = null;
+    /** See {@link toolDefinitionChars}. */
+    toolCharsCache = null;
     originalRequest = "";
     // Messages queued by the user while a run is in flight. Drained at the
     // mid-loop steering boundary (user steering wins over the hooks), mirroring
@@ -167,6 +217,8 @@ export class AgentSession {
     // different message (or past the end) by the time the cancel arrives.
     userQueue = [];
     queueSeq = 0;
+    /** Monotonic count of human-originated prompts; idle-wake budgets reset on it. */
+    humanPromptSeq = 0;
     /** Instant interrupt: the running loop's preempt listeners, fired on queueMessage. */
     steeringListeners = new Set();
     processManager;
@@ -296,6 +348,16 @@ export class AgentSession {
         }
         return modelInfo?.maxOutputTokens ?? 16384;
     }
+    /** {@link outputCapForRequest} for this session's live model and settings. */
+    requestMaxTokens(accountId) {
+        return outputCapForRequest({
+            provider: this.provider,
+            model: this.model,
+            maxTokens: this.maxTokens,
+            threshold: this.settingsManager.get("compactThreshold"),
+            accountId,
+        });
+    }
     async initialize() {
         // Set model for accurate token estimation
         setEstimatorModel(this.model);
@@ -812,6 +874,8 @@ export class AgentSession {
         visibility: "transcript",
     }, options = {}) {
         this.prewarmController?.abort();
+        if (provenance.source === "human")
+            this.humanPromptSeq += 1;
         await this.settlePostTurnCompaction();
         await this.adoptDeferredCheckpointBeforePrompt();
         const slash = await this.resolveSlashInput(content);
@@ -850,6 +914,7 @@ export class AgentSession {
      */
     async promptWithAttachments(text, attachments) {
         this.prewarmController?.abort();
+        this.humanPromptSeq += 1;
         await this.settlePostTurnCompaction();
         await this.adoptDeferredCheckpointBeforePrompt();
         const parts = this.buildAttachmentParts(text, attachments);
@@ -1499,7 +1564,10 @@ export class AgentSession {
         }
         // Reset self-correction hook state for this run; pin the latest user message
         // as the verbatim original request for post-compaction re-grounding.
-        const lastUser = [...this.messages].reverse().find((m) => m.role === "user");
+        // A status update that started an idle-wake run is not the user's request.
+        const lastUser = [...this.messages]
+            .reverse()
+            .find((m) => m.role === "user" && m.provenance?.kind !== "notification");
         this.resetHookState(requestTextForRegrounding(lastUser));
         // Resolve OAuth credentials and run agent loop.
         // On 401, force-refresh the token and retry once — the provider may have
@@ -1591,7 +1659,7 @@ export class AgentSession {
                 model: this.model,
                 tools: options.disableTools ? [] : this.tools,
                 webSearch: !options.disableTools,
-                maxTokens: this.maxTokens,
+                maxTokens: this.requestMaxTokens(accountId),
                 maxTurns: this.opts.maxTurns,
                 maxTurnExtensions: this.opts.maxTurnExtensions,
                 // Plan mode caps effort at medium (Codex `plan_mode_reasoning_effort`
@@ -1697,8 +1765,12 @@ export class AgentSession {
                         if (anchor?.role === "assistant") {
                             this.providerContext = { usage: { ...transformOpts.usage }, anchor };
                             // Feed the authoritative usage back into the token estimator so
-                            // char-based estimates track this session's real tokenizer.
-                            calibrateEstimatorFromUsage(messages.slice(0, anchorIndex), transformOpts.usage);
+                            // char-based estimates track this session's real tokenizer. The
+                            // provider's count includes the tool definitions sent with the
+                            // request, so their characters must be counted too — without
+                            // them a short history reads as ~2 chars/token and drags the
+                            // shared ratio down for every session in the process.
+                            calibrateEstimatorFromUsage(messages.slice(0, anchorIndex), transformOpts.usage, options.disableTools ? 0 : this.toolDefinitionChars());
                         }
                     }
                     const force = transformOpts.force === true;
@@ -1749,12 +1821,13 @@ export class AgentSession {
                                     compactedToolCalls: String(pruneResult.compactedToolCalls),
                                     freedTokens: String(pruneResult.freedTokens),
                                 });
-                                // The turn's own usage also counted the pruned content — estimate
-                                // the (now smaller) history so the freed tokens actually defer
-                                // the LLM compaction.
-                                activeTokens = calculateActiveContextTokens(messages, {
-                                    pendingMessages: transformOpts.pendingMessages,
-                                });
+                                // The measured size counted the pruned content, so take the
+                                // freed tokens off it. Never swap the provider's count for a
+                                // whole-history estimate here: that estimate rides a shared
+                                // chars-per-token ratio, and it once read a 234K-token MiMo
+                                // context (23% of 1M) as ~400K and compacted it against a 340K
+                                // trigger.
+                                activeTokens = Math.max(0, activeTokens - pruneResult.freedTokens);
                             }
                         }
                         if (Date.now() < this.compactionRetryAfter)
@@ -1926,7 +1999,17 @@ export class AgentSession {
         // prompt. Detached by design; the pre-run path above remains the backstop.
         this.maybeCompactPostTurn(creds);
     }
-    async switchModel(provider, model) {
+    /**
+     * Switch the session's model. A model that spends real money (Claude fast
+     * mode bills usage credits) is refused unless `confirmPaid` carries the
+     * user's explicit yes, so no caller can switch onto one by accident: every
+     * path (app, CLI, editors, chat bridges, RPC) fails closed by default.
+     */
+    async switchModel(provider, model, options = {}) {
+        const target = getModel(model);
+        if (target?.billing?.paid && options.confirmPaid !== true && model !== this.model) {
+            throw new PaidModelConfirmationError(target.name, target.billing.detail);
+        }
         // The model-switch note is appended to `this.messages`; settle any
         // background compaction first so the note cannot be swapped out.
         await this.settlePostTurnCompaction();
@@ -2713,6 +2796,74 @@ export class AgentSession {
     notify(id, text) {
         this.notifications.enqueue("goal", id, text, { terminal: true });
     }
+    /**
+     * Observe urgent background alerts — a background task failed or exited
+     * non-zero, or a child agent finished — as they are queued. Hosts use this to
+     * wake an idle session (see {@link continueFromNotifications}); a live run
+     * already receives them at its next steering boundary. Returns unsubscribe.
+     */
+    onBackgroundAlert(listener) {
+        return this.notifications.onUrgent(() => listener());
+    }
+    /**
+     * Characters of the tool definitions sent with every request (name,
+     * description, JSON schema), for estimator calibration. Cached by tool count:
+     * the tool array is append-only.
+     */
+    toolDefinitionChars() {
+        if (this.toolCharsCache?.count === this.tools.length)
+            return this.toolCharsCache.chars;
+        let chars = 0;
+        for (const tool of this.tools) {
+            chars += tool.name.length + tool.description.length;
+            try {
+                chars += JSON.stringify(resolveToolSchema(tool)).length;
+            }
+            catch {
+                // A schema that cannot be serialized is not sent either.
+            }
+        }
+        this.toolCharsCache = { count: this.tools.length, chars };
+        return chars;
+    }
+    /** True while an urgent background alert is waiting to be delivered. */
+    hasPendingBackgroundAlert() {
+        return this.notifications.hasUrgent();
+    }
+    /** Monotonic count of human-originated prompts this session has run. */
+    getHumanPromptSeq() {
+        return this.humanPromptSeq;
+    }
+    /**
+     * Start a run from pending background notifications, for a session that had
+     * already finished its turn. The notifications become one hidden runtime
+     * message (never shown as something the user typed), and the agent decides
+     * whether they need action. Returns false, starting nothing, when no urgent
+     * alert is pending — a live run may have delivered it in the meantime.
+     */
+    async continueFromNotifications() {
+        if (!this.notifications.hasUrgent())
+            return false;
+        this.prewarmController?.abort();
+        await this.settlePostTurnCompaction();
+        await this.adoptDeferredCheckpointBeforePrompt();
+        const notified = this.notifications.drain();
+        if (notified.length === 0)
+            return false;
+        const message = {
+            role: "user",
+            content: buildIdleWakeNotificationText(notified.map((entry) => entry.text)),
+            provenance: { source: "runtime", kind: "notification", visibility: "hidden" },
+        };
+        log("INFO", "notifications", "Starting a run from background alerts", {
+            count: String(notified.length),
+        });
+        this.messages.push(message);
+        await this.persistMessage(message);
+        this.lastPersistedIndex = this.messages.length;
+        await this.runLoop();
+        return true;
+    }
     /** This session's sub-agents (workers), newest-state, including ones restored after a restart. */
     listSubAgents() {
         return this.subAgentManager?.list() ?? [];
@@ -3242,10 +3393,18 @@ export class AgentSession {
             return { enhanced: text, segments: [{ kind: "text", text }] };
         // Keep credentials and settings on the model selected at click time, even
         // if the user switches models while credential resolution is pending.
-        const { provider, model, thinkingLevel, maxTokens, baseUrl } = this;
+        const { provider, model, thinkingLevel, baseUrl } = this;
+        const threshold = this.settingsManager.get("compactThreshold");
         const creds = await this.authStorage.resolveCredentials(provider, {
             storageKeys: this.currentAuthStorageKeys(),
         });
+        const maxTokens = outputCapForRequest({
+            provider,
+            model,
+            maxTokens: this.maxTokens,
+            threshold,
+            accountId: creds.accountId,
+        });
         // Cheap, best-effort stack detection from the project root so terminology is
         // idiomatic to the user's stack. Never throws (returns "" on any failure).
         let stack = "";
@@ -3363,7 +3522,7 @@ export class AgentSession {
                 messages,
                 tools: this.tools,
                 webSearch: true,
-                maxTokens: this.maxTokens,
+                maxTokens: this.requestMaxTokens(creds.accountId),
                 thinking: this.planModeRef.current
                     ? clampThinkingForPlanMode(this.thinkingLevel)
                     : this.thinkingLevel,
@@ -3675,7 +3834,7 @@ export class AgentSession {
     }
     createSlashCommandContext() {
         return {
-            switchModel: (provider, model) => this.switchModel(provider, model),
+            switchModel: (provider, model, options) => this.switchModel(provider, model, options),
             compact: (focus) => this.compact(undefined, "manual", focus),
             newSession: () => this.newSession(),
             listSessions: async () => {