@caupulican/pi-adaptative 0.80.80 → 0.80.81

package/dist/core/agent-session.js

@@ -15,7 +15,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, modelsAreEqual, resetApiProviders, streamSimple, } from "@caupulican/pi-ai";
-import { getAgentDir } from "../config.js";
+import { getAgentDir, getSessionsDir } from "../config.js";
 import { theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { resolvePath } from "../utils/paths.js";
@@ -24,6 +24,7 @@ import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
 import { applyContextGc } from "./context-gc.js";
+import { aggregateDailyUsageFromSessionFiles, aggregateDailyUsageFromSessionRoot, formatDailyUsageBreakdown, getLocalDayWindow, } from "./cost/daily-usage.js";
 import { downgradeReasoning, estimateTurnCostUsd, evaluateCostGuard } from "./cost-guard.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
@@ -42,6 +43,11 @@ import { TranscriptRecallProvider } from "./memory/providers/transcript-recall.j
 import { compactToolResultDetailsForRetention } from "./message-retention.js";
 import { createCustomMessage } from "./messages.js";
 import { resolveCliModel, resolveProfileModelSettings } from "./model-resolver.js";
+import { collectModelRouterConfigDiagnostics } from "./model-router/config-diagnostics.js";
+import { classifyModelRouterIntent } from "./model-router/intent-classifier.js";
+import { bufferModelRouterSessionCustomMessage, bufferModelRouterSessionMessage, createModelRouterSessionBuffer, flushModelRouterSessionBuffer, } from "./model-router/session-buffer.js";
+import { formatModelRouterStatus, getRecentModelRouterDecisions, MODEL_ROUTER_DECISION_CUSTOM_TYPE, } from "./model-router/status.js";
+import { shouldEscalateModelRouterTool } from "./model-router/tool-escalation.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { stripResourceProfileBlocks } from "./resource-profile-blocks.js";
 import { classifyToolTrust, UNTRUSTED_BOUNDARY_SYSTEM_RULE, wrapUntrustedText } from "./security/untrusted-boundary.js";
@@ -77,6 +83,12 @@ const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
 // ============================================================================
 // AgentSession Class
 // ============================================================================
+function formatModelRouterModel(model) {
+    return `${model.provider}/${model.id}`;
+}
+function persistModelRouterDecision(sessionManager, decision) {
+    sessionManager.appendCustomEntry(MODEL_ROUTER_DECISION_CUSTOM_TYPE, decision);
+}
 export class AgentSession {
     agent;
     sessionManager;
@@ -132,10 +144,18 @@ export class AgentSession {
     _gatewayRegistry = new GatewayRegistry();
     /** Cache for getSpawnedUsage(), keyed by session entry count (Bug #22 — avoid O(N) per render frame). */
     _spawnedUsageCache;
+    _dailyUsageCache;
     /** Latest proactive cost-guard decision (#34), for the host UI to surface. Undefined when disabled. */
     _lastCostGuardDecision;
     /** One-shot latch so the cost guard downgrades reasoning once per over-threshold episode, not every call. */
     _costGuardDowngraded = false;
+    /** Active model-router intent for the current transient routed turn, if any. */
+    _activeModelRouterIntent;
+    _modelRouterSessionBuffer;
+    _modelRouterEscalationRequested = false;
+    _lastModelRouterDecision;
+    _lastModelRouterSkipReason;
+    _lastModelRouterIntent;
     /** Lazily-built skill curator (#32) over `<agentDir>/skills`. */
     _skillCuratorInstance;
     /** Set on dispose so in-flight background reflection bails instead of writing to a dead session (Bug #21). */
@@ -456,6 +476,15 @@ export class AgentSession {
     }
     _installAgentToolHooks() {
         this.agent.beforeToolCall = async ({ toolCall, args }) => {
+            if (this._activeModelRouterIntent &&
+                shouldEscalateModelRouterTool({ intent: this._activeModelRouterIntent, toolName: toolCall.name, args })) {
+                this._modelRouterEscalationRequested = true;
+                this.agent.abort();
+                return {
+                    block: true,
+                    reason: "Model router escalation required: a cheap research turn attempted a mutating tool. Retry the turn on the configured expensive model.",
+                };
+            }
             const runner = this._extensionRunner;
             if (!runner.hasHandlers("tool_call")) {
                 return undefined;
@@ -562,8 +591,16 @@ export class AgentSession {
         // accumulate until the interactive Node process hits the V8 heap limit.
         if (event.type === "message_end") {
             compactToolResultDetailsForRetention(event.message);
+            const modelRouterBuffer = this._modelRouterSessionBuffer;
+            if (modelRouterBuffer && event.message.role === "custom") {
+                bufferModelRouterSessionCustomMessage(modelRouterBuffer, event.message);
+            }
+            else if (modelRouterBuffer &&
+                (event.message.role === "user" || event.message.role === "assistant" || event.message.role === "toolResult")) {
+                bufferModelRouterSessionMessage(modelRouterBuffer, event.message);
+            }
             // Check if this is a custom message from extensions
-            if (event.message.role === "custom") {
+            else if (event.message.role === "custom") {
                 // Persist as CustomMessageEntry
                 this.sessionManager.appendCustomMessageEntry(event.message.customType, event.message.content, event.message.display, event.message.details);
             }
@@ -1086,6 +1123,140 @@ export class AgentSession {
             await this._drainQueuedExtensionCommands();
         }
     }
+    _resolveModelRouterModelForIntent(intent) {
+        const settings = this.settingsManager.getModelRouterSettings();
+        const modelLabel = intent === "research" ? "cheap model" : "expensive model";
+        if (!settings.enabled) {
+            this._lastModelRouterSkipReason = "disabled";
+            return undefined;
+        }
+        const modelPattern = intent === "research" ? settings.cheapModel : settings.expensiveModel;
+        if (!modelPattern) {
+            this._lastModelRouterSkipReason = `${modelLabel} unset`;
+            return undefined;
+        }
+        const resolved = resolveCliModel({ cliModel: modelPattern, modelRegistry: this._modelRegistry });
+        if (!resolved.model) {
+            this._lastModelRouterSkipReason = `${modelLabel} unresolved: ${modelPattern}`;
+            return undefined;
+        }
+        const resolvedName = formatModelRouterModel(resolved.model);
+        if (!this._modelRegistry.hasConfiguredAuth(resolved.model)) {
+            this._lastModelRouterSkipReason = `${modelLabel} missing auth: ${resolvedName}`;
+            return undefined;
+        }
+        this._lastModelRouterSkipReason = undefined;
+        return resolved.model;
+    }
+    _resolveModelRouterTurnModel(prompt) {
+        const intent = classifyModelRouterIntent(prompt);
+        this._lastModelRouterIntent = intent;
+        return this._resolveModelRouterModelForIntent(intent);
+    }
+    getModelRouterStatus(formatLabel) {
+        const recentDecisions = getRecentModelRouterDecisions(this.sessionManager.getEntries());
+        const lastDecision = this._lastModelRouterDecision ?? recentDecisions.at(-1);
+        const historicalDecisions = this._lastModelRouterDecision ? recentDecisions : recentDecisions.slice(0, -1);
+        const settings = this.settingsManager.getModelRouterSettings();
+        const lines = [
+            formatModelRouterStatus(settings, lastDecision, formatLabel, historicalDecisions, this._lastModelRouterSkipReason, this._lastModelRouterIntent ?? lastDecision?.intent),
+        ];
+        const diagnostics = collectModelRouterConfigDiagnostics(settings, this._modelRegistry);
+        if (diagnostics.length > 0) {
+            lines.push(formatLabel ? formatLabel("Config diagnostics:") : "Config diagnostics:");
+            for (const diagnostic of diagnostics) {
+                lines.push(`- ${diagnostic}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    async _runAgentPromptWithModelRouter(messages, routedModel, routedIntent, persistDecision = true) {
+        if (!routedModel) {
+            await this._runAgentPrompt(messages);
+            return;
+        }
+        const previousModel = this.agent.state.model;
+        const previousThinkingLevel = this.agent.state.thinkingLevel;
+        const previousActiveModelRouterIntent = this._activeModelRouterIntent;
+        const previousModelRouterSessionBuffer = this._modelRouterSessionBuffer;
+        const previousModelRouterEscalationRequested = this._modelRouterEscalationRequested;
+        const bufferRoutedTurn = routedIntent === "research";
+        const originalHistoryLength = this.agent.state.messages.length;
+        let retryModel;
+        let completedDecision = routedIntent
+            ? {
+                intent: routedIntent,
+                routedModel: formatModelRouterModel(routedModel),
+                outcome: "routed",
+            }
+            : undefined;
+        let thrownError;
+        if (routedIntent) {
+            this._lastModelRouterDecision = completedDecision;
+        }
+        this._activeModelRouterIntent = routedIntent;
+        if (bufferRoutedTurn) {
+            this._modelRouterSessionBuffer = createModelRouterSessionBuffer();
+            this._modelRouterEscalationRequested = false;
+        }
+        if (!modelsAreEqual(this.model, routedModel)) {
+            this.agent.state.model = routedModel;
+            this.agent.state.thinkingLevel = clampThinkingLevel(routedModel, previousThinkingLevel);
+        }
+        try {
+            await this._runAgentPrompt(messages);
+            if (bufferRoutedTurn && this._modelRouterEscalationRequested) {
+                this.agent.state.messages.splice(originalHistoryLength);
+                retryModel = this._resolveModelRouterModelForIntent("modify") ?? previousModel;
+                completedDecision = {
+                    intent: routedIntent,
+                    routedModel: formatModelRouterModel(routedModel),
+                    outcome: "escalated",
+                    retryModel: formatModelRouterModel(retryModel),
+                };
+                this._lastModelRouterDecision = completedDecision;
+            }
+            else if (bufferRoutedTurn && this._modelRouterSessionBuffer) {
+                flushModelRouterSessionBuffer(this._modelRouterSessionBuffer, (message) => {
+                    this.sessionManager.appendMessage(message);
+                }, (customType, content, display, details) => {
+                    this.sessionManager.appendCustomMessageEntry(customType, content, display, details);
+                });
+            }
+        }
+        catch (error) {
+            thrownError = error;
+            if (completedDecision) {
+                completedDecision = { ...completedDecision, outcome: "failed" };
+                this._lastModelRouterDecision = completedDecision;
+            }
+        }
+        finally {
+            this.agent.state.model = previousModel;
+            this.agent.state.thinkingLevel = previousThinkingLevel;
+            this._activeModelRouterIntent = previousActiveModelRouterIntent;
+            this._modelRouterSessionBuffer = previousModelRouterSessionBuffer;
+            this._modelRouterEscalationRequested = previousModelRouterEscalationRequested;
+        }
+        if (retryModel && !thrownError) {
+            try {
+                await this._runAgentPromptWithModelRouter(messages, retryModel, "modify", false);
+            }
+            catch (error) {
+                thrownError = error;
+                if (completedDecision) {
+                    completedDecision = { ...completedDecision, outcome: "failed" };
+                    this._lastModelRouterDecision = completedDecision;
+                }
+            }
+        }
+        if (persistDecision && completedDecision) {
+            persistModelRouterDecision(this.sessionManager, completedDecision);
+        }
+        if (thrownError) {
+            throw thrownError;
+        }
+    }
     async _handlePostAgentRun() {
         const msg = this._lastAssistantMessage;
         this._lastAssistantMessage = undefined;
@@ -1149,6 +1320,8 @@ export class AgentSession {
         const processSlashCommands = options?.processSlashCommands ?? expandPromptTemplates;
         const preflightResult = options?.preflightResult;
         let messages;
+        let routedTurnModel;
+        let routedTurnIntent;
         // R4 effectiveness feedback: remember the recall page + the query so we can score, after the
         // response, whether the agent actually used the recalled context.
         let injectedRecall = "";
@@ -1211,18 +1384,21 @@ export class AgentSession {
             }
             // Flush any pending bash messages before the new prompt
             this._flushPendingBashMessages();
+            routedTurnModel = this._resolveModelRouterTurnModel(expandedText);
+            routedTurnIntent = routedTurnModel ? classifyModelRouterIntent(expandedText) : undefined;
+            const requestModel = routedTurnModel ?? this.model;
             // Validate model
-            if (!this.model) {
+            if (!requestModel) {
                 throw new Error(formatNoModelSelectedMessage());
             }
-            if (!this._modelRegistry.hasConfiguredAuth(this.model)) {
-                const isOAuth = this._modelRegistry.isUsingOAuth(this.model);
+            if (!this._modelRegistry.hasConfiguredAuth(requestModel)) {
+                const isOAuth = this._modelRegistry.isUsingOAuth(requestModel);
                 if (isOAuth) {
-                    throw new Error(`Authentication failed for "${this.model.provider}". ` +
+                    throw new Error(`Authentication failed for "${requestModel.provider}". ` +
                         `Credentials may have expired or network is unavailable. ` +
-                        `Run '/login ${this.model.provider}' to re-authenticate.`);
+                        `Run '/login ${requestModel.provider}' to re-authenticate.`);
                 }
-                throw new Error(formatNoApiKeyFoundMessage(this.model.provider));
+                throw new Error(formatNoApiKeyFoundMessage(requestModel.provider));
             }
             // Check if we need to compact before sending (catches aborted responses).
             // Do not call agent.continue() here: the next model turn must include the
@@ -1301,7 +1477,7 @@ export class AgentSession {
             return;
         }
         preflightResult?.(true);
-        await this._runAgentPrompt(messages);
+        await this._runAgentPromptWithModelRouter(messages, routedTurnModel, routedTurnIntent);
         // R4: score whether the agent actually used the recalled context, so the recall gate can adapt.
         if (injectedRecall) {
             const response = this._findLastAssistantMessage();
@@ -3464,6 +3640,23 @@ export class AgentSession {
         this._spawnedUsageCache = { entryCount, totals };
         return totals;
     }
+    getDailyUsageTotals(now = new Date()) {
+        const sessionDir = this.sessionManager.getSessionDir();
+        const scope = this.sessionManager.usesDefaultSessionDir() ? getSessionsDir() : sessionDir;
+        const nowMs = now.getTime();
+        if (this._dailyUsageCache?.sessionDir === scope && this._dailyUsageCache.expiresAt > nowMs) {
+            return this._dailyUsageCache.totals;
+        }
+        const window = getLocalDayWindow(now);
+        const totals = this.sessionManager.usesDefaultSessionDir()
+            ? aggregateDailyUsageFromSessionRoot(scope, window)
+            : aggregateDailyUsageFromSessionFiles(sessionDir, window);
+        this._dailyUsageCache = { sessionDir: scope, expiresAt: nowMs + 10_000, totals };
+        return totals;
+    }
+    getDailyUsageBreakdown(formatLabel, now = new Date()) {
+        return formatDailyUsageBreakdown(this.getDailyUsageTotals(now), formatLabel);
+    }
     /**
      * Run a one-shot LLM completion fully ISOLATED from the main session — the load-bearing
      * primitive for the native reflection engine (adaptive-agent design §6c/§7).