@caupulican/pi-adaptative 0.80.75 → 0.80.76

package/dist/core/agent-session.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 { downgradeReasoning, estimateTurnCostUsd, evaluateCostGuard } from "./cost-guard.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
@@ -130,6 +131,10 @@ export class AgentSession {
     _gatewayRegistry = new GatewayRegistry();
     /** Cache for getSpawnedUsage(), keyed by session entry count (Bug #22 — avoid O(N) per render frame). */
     _spawnedUsageCache;
+    /** 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;
     /** Set on dispose so in-flight background reflection bails instead of writing to a dead session (Bug #21). */
     _disposed = false;
     /** Aborts in-flight background reflection completions on dispose (Bug #21). */
@@ -288,9 +293,50 @@ export class AgentSession {
             if (this._extensionRunner.hasHandlers("context")) {
                 finalMessages = await this._extensionRunner.emitContext(currentMessages);
             }
-            return this._applyContextGc(finalMessages, true).messages;
+            const gcMessages = this._applyContextGc(finalMessages, true).messages;
+            this._applyCostGuard(gcMessages);
+            return gcMessages;
         };
     }
+    /**
+     * Proactive per-turn cost guard (#34): estimate the USD cost of the about-to-be-submitted turn and,
+     * when it exceeds the user's ceiling, record a warning decision (for the host UI to surface) and —
+     * if configured to `downgrade` — step reasoning effort down ONCE per over-threshold episode to curb a
+     * runaway billing spike. Disabled by default (`maxTurnUsd<=0`), so it never alters behavior unless the
+     * user opts in. Best-effort: never throws into the turn.
+     */
+    _applyCostGuard(messages) {
+        try {
+            const guard = this.settingsManager.getCostGuardSettings();
+            if (guard.maxTurnUsd <= 0 || !this.model?.cost) {
+                this._lastCostGuardDecision = undefined;
+                return;
+            }
+            const inputTokens = this._estimateCurrentContextTokens(messages);
+            const maxOutputTokens = this.model.maxTokens ?? 4096;
+            const estUsd = estimateTurnCostUsd({ inputTokens, maxOutputTokens, cost: this.model.cost });
+            const decision = evaluateCostGuard(estUsd, { maxTurnUsd: guard.maxTurnUsd, action: guard.action });
+            this._lastCostGuardDecision = decision;
+            if (!decision.over) {
+                this._costGuardDowngraded = false; // back under the ceiling — re-arm the one-shot downgrade
+                return;
+            }
+            if (guard.action === "downgrade" && !this._costGuardDowngraded && this.supportsThinking()) {
+                const next = downgradeReasoning(this.thinkingLevel);
+                if (next !== this.thinkingLevel) {
+                    this.setThinkingLevel(next);
+                    this._costGuardDowngraded = true;
+                }
+            }
+        }
+        catch {
+            // cost guard must never disrupt a turn
+        }
+    }
+    /** Latest cost-guard decision (for the host footer/UI to surface a warning). Undefined if disabled. */
+    getLastCostGuardDecision() {
+        return this._lastCostGuardDecision;
+    }
     _installAgentTurnRefresh() {
         const previousPrepareNextTurn = this.agent.prepareNextTurn?.bind(this.agent);
         this.agent.prepareNextTurn = async (signal) => {
@@ -3405,7 +3451,7 @@ export class AgentSession {
         const options = {
             maxTokens: opts.maxTokens,
             signal: opts.signal,
-            cacheRetention: "none",
+            cacheRetention: opts.cacheRetention ?? "none",
         };
         // pi-ai's `reasoning` option does not include "off" (that's the provider default already).
         if (thinkingLevel !== "off") {
@@ -3465,6 +3511,9 @@ export class AgentSession {
             thinkingLevel: input.thinkingLevel ?? "low",
             maxTokens: plan.tokenBudget,
             signal,
+            // The reflection system prompt is static (#33) — let the provider cache the prefix so
+            // repeated passes only pay for the variable tail.
+            cacheRetention: "short",
         });
         const result = await new ReflectionEngine().reflect({
             recentTurnText: input.recentTurnText,
@@ -3555,7 +3604,9 @@ export class AgentSession {
                 return; // do not overwrite an existing skill
             mkdirSync(dir, { recursive: true });
             const safeDescription = description.replace(/[\r\n]+/g, " ").trim();
-            const content = `---\nname: ${name}\ndescription: ${safeDescription}\n---\n\n<!-- Auto-generated by the reflection engine (R7 memory-to-behavior). Review and refine. -->\n\n${body.trim()}\n`;
+            // `promoted: true` marks this as reflection-generated so the curator (#32) can lifecycle-manage
+            // it (archive/consolidate) WITHOUT ever touching hand-authored user skills.
+            const content = `---\nname: ${name}\ndescription: ${safeDescription}\npromoted: true\n---\n\n<!-- Auto-generated by the reflection engine (R7 memory-to-behavior). Review and refine. -->\n\n${body.trim()}\n`;
             writeFileSync(file, content, "utf-8");
         }
         catch {