@caupulican/pi-adaptative 0.81.26 → 0.81.27

package/dist/core/agent-session.js

@@ -3,7 +3,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { classifyFailure, compactToolResultDetailsForRetention, computeRetryDelayMs, createCustomMessage, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE, RetryController, sleepAbortable, withStreamIdleWatchdog, } from "@caupulican/pi-agent-core";
 import { calculateContextTokens, compact, createDeterministicCompaction, estimateContextTokens, getLatestCompactionEntry, prepareCompaction, runCompactionLoop, shouldCompact, } from "@caupulican/pi-agent-core/node";
-import { cleanupSessionResources, formatToolRepairStandingRule, generateTextToolProtocolPrimer, isContextOverflow, parseTextToolCalls, streamSimple, } from "@caupulican/pi-ai";
+import { cleanupSessionResources, formatToolRepairStandingRule, generateTextToolProtocolPrimer, getSupportedThinkingLevels, isContextOverflow, modelsAreEqual, parseTextToolCalls, streamSimple, } from "@caupulican/pi-ai";
 import { Type } from "typebox";
 import { getAgentDir } from "../config.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
@@ -23,6 +23,7 @@ import { GatewayRegistry } from "./gateways/channel-provider.js";
 import { GoalLoopController } from "./goal-loop-controller.js";
 import { buildGoalRuntimeSnapshot, } from "./goals/goal-runtime-snapshot.js";
 import { appendGoalStateSnapshot, getLatestGoalStateSnapshot } from "./goals/session-goal-state.js";
+import { constrainStreamIdleToHttpTimeout } from "./http-dispatcher.js";
 import { appendLearningDecisionSnapshot, getLearningDecisionSnapshots } from "./learning/session-learning-decision.js";
 import { isPromotedFrontmatter, SkillCurator } from "./learning/skill-curator.js";
 import { LocalRuntimeController } from "./local-runtime-controller.js";
@@ -201,7 +202,6 @@ export class AgentSession {
     _analytics;
     _treeNavigator;
     _lastCostGuardDecision;
-    _costGuardDowngraded = false;
     /** Per-turn model-router subsystem (see model-router-controller.ts); owns the transient route/intent,
      * the cheap-turn session buffer, the escalation/retry flags, and the sticky last-decision/skip-reason
      * used by the status report. Its parallel routed drive path delegates every turn back to
@@ -251,6 +251,13 @@ export class AgentSession {
         const agentDir = config.agentDir ?? getAgentDir();
         const modelAdaptationStore = ModelAdaptationStore.forAgentDir(agentDir);
         const baseStreamFn = this.agent.streamFn;
+        const previousResolveRequestReasoning = this.agent.resolveRequestReasoning?.bind(this.agent);
+        this.agent.resolveRequestReasoning = (reasoning, request) => {
+            const resolvedReasoning = previousResolveRequestReasoning
+                ? previousResolveRequestReasoning(reasoning, request)
+                : reasoning;
+            return this._resolveCostGuardRequestReasoning(request.model, request.context, resolvedReasoning, request.maxTokens);
+        };
         const profiledStreamFn = withModelPerfProfile(baseStreamFn, {
             modelKey: (model) => formatModelRouterModel(model),
             recordSample: (modelKey, sample) => {
@@ -266,17 +273,16 @@ export class AgentSession {
                 ...streamIdleOptionsOverride,
             };
             const httpIdleTimeoutMs = stallSettingsSource.getHttpIdleTimeoutMs();
+            const httpBounded = constrainStreamIdleToHttpTimeout({ ...DEFAULT_STREAM_IDLE, ...configured }, httpIdleTimeoutMs);
             const profile = modelAdaptationStore.get(formatModelRouterModel(model)).perf;
             const adaptive = resolveAdaptiveStreamIdleOptions({
-                base: { ...DEFAULT_STREAM_IDLE, ...configured },
+                base: httpBounded.options,
                 profile,
                 promptTokens: estimateContextPromptTokens(context),
                 localClass: this._isWarmableLocalModel(model),
-                ceilingMs: httpIdleTimeoutMs === 0
-                    ? DEFAULT_ADAPTIVE_STREAM_IDLE_CEILING_MS
-                    : Math.max(DEFAULT_STREAM_IDLE.quietIdleMs, httpIdleTimeoutMs - 60_000),
+                ceilingMs: httpBounded.adaptiveCeilingMs ?? DEFAULT_ADAPTIVE_STREAM_IDLE_CEILING_MS,
             });
-            return { ...configured, ...adaptive };
+            return { ...httpBounded.options, ...adaptive };
         }), baseStreamFn === streamSimple);
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
@@ -325,6 +331,8 @@ export class AgentSession {
             getToolPromptGuidelines: (name) => this._runtimeBuilder.getToolPromptGuidelines(name),
             getModelAdaptationRules: () => this._getModelAdaptationRulesForPrompt(),
             getActiveExtensions: () => this._extensionRunner.activeExtensions,
+            getContextWindow: () => this.model?.contextWindow,
+            getThinkingLevel: () => this.thinkingLevel,
         });
         this._autonomyTelemetry = new AutonomyTelemetry({
             getSessionManager: () => this.sessionManager,
@@ -350,6 +358,7 @@ export class AgentSession {
             getModelRegistry: () => this._modelRegistry,
             isModelExhausted: (model) => this._billingFailover.isExhausted(`${model.provider}/${model.id}`),
             getModel: () => this.model ?? undefined,
+            isDelegateToolActive: () => this.getActiveToolNames().includes("delegate"),
             getCapabilityEnvelope: () => this.capabilityEnvelope,
             getModelCapabilityProfile: () => this.getModelCapabilityProfile(),
             emit: (event) => this._emit(event),
@@ -372,6 +381,8 @@ export class AgentSession {
             getSessionId: () => this.sessionManager.getSessionId(),
             isChildSession: () => this._isChildSession,
             refreshToolRegistry: () => this._refreshToolRegistry(),
+            getContextWindow: () => this.model?.contextWindow,
+            getGoalState: () => this.getGoalStateSnapshot(),
         });
         this._compactionSupport = new CompactionSupport({
             getModel: () => this.model,
@@ -511,6 +522,9 @@ export class AgentSession {
             setUnboundToolGrantWarnings: (warnings) => {
                 this._unboundToolGrantWarnings = warnings;
             },
+            getUnboundToolGrantWarnings: () => this._unboundToolGrantWarnings,
+            createProfileFilterReloadSnapshot: () => this._profileFilter.createReloadSnapshot(),
+            restoreProfileFilterReloadSnapshot: (snapshot) => this._profileFilter.restoreReloadSnapshot(snapshot),
             getActiveToolNames: () => this.getActiveToolNames(),
             setActiveToolsByName: (toolNames) => this.setActiveToolsByName(toolNames),
             normalizePromptSnippet: (text) => this._normalizePromptSnippet(text),
@@ -524,6 +538,8 @@ export class AgentSession {
             getMemoryManager: () => this._memory.getMemoryManager(),
             getMemoryAuditDiagnostics: () => this._memory.getMemoryAuditDiagnostics(),
             clearPendingMemoryProviders: () => this._memory.clearPendingProviders(),
+            createMemoryReloadSnapshot: () => this._memory.createReloadSnapshot(),
+            restoreMemoryReloadSnapshot: (snapshot) => this._memory.restoreReloadSnapshot(snapshot),
             initializeMemory: () => this._memory.initialize(),
             getGoalStateSnapshot: () => this.getGoalStateSnapshot(),
             saveGoalStateSnapshot: (state) => this.saveGoalStateSnapshot(state),
@@ -587,6 +603,7 @@ export class AgentSession {
             getActiveToolNames: () => this.getActiveToolNames(),
             setActiveToolsByName: (names) => this.setActiveToolsByName(names),
             getModelCapabilityProfile: () => this.getModelCapabilityProfile(),
+            refreshBaseSystemPrompt: () => this._refreshBaseSystemPrompt(),
             emit: (event) => this._emit(event),
             checkContextWindowUsageWarning: () => this._checkContextWindowUsageWarning(),
             deriveOllamaServerUrl: (baseUrl) => this._deriveOllamaServerUrl(baseUrl),
@@ -610,7 +627,7 @@ export class AgentSession {
             getToolProfileFilter: () => this._toolProfileFilter,
             isExplicitModel: () => this._isExplicitModel,
             isExplicitThinking: () => this._isExplicitThinking,
-            setThinkingLevel: (level) => this.setThinkingLevel(level),
+            setThinkingLevel: (level) => this.setThinkingLevel(level, { persistSettings: false }),
         });
         this._toolGate = new ToolGateController({
             maybeEscalateToolCall: (toolName, args) => this._modelRouter.maybeEscalateToolCall(toolName, args),
@@ -825,43 +842,43 @@ export class AgentSession {
             // character caps are the only budget protection for this block -- load-bearing,
             // not merely defensive.
             const gcMessages = this._maybeAppendMemoryEvidenceBlock(enforcementResult.messages, memoryReport);
-            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.
+     * Resolve the foreground request's cost policy after routing/context conversion, when the actual
+     * model, full system prompt, converted messages, and tool schemas are known. The guard is a
+     * projection threshold rather than a hard output cap: warning mode never reduces capability, while
+     * opt-in downgrade changes only this request's reasoning effort. Best-effort: never throws.
      */
-    _applyCostGuard(messages) {
+    _resolveCostGuardRequestReasoning(model, context, reasoning, requestMaxTokens) {
         try {
             const guard = this.settingsManager.getCostGuardSettings();
-            if (guard.maxTurnUsd <= 0 || !this.model?.cost) {
+            const isChatGptSubscription = model.provider === "openai-codex" && this._modelRegistry.isUsingOAuth(model);
+            if (guard.maxTurnUsd <= 0 || !model.cost || isChatGptSubscription) {
                 this._lastCostGuardDecision = undefined;
-                return;
-            }
-            const inputTokens = this._estimateCurrentContextTokens(messages);
-            const maxOutputTokens = this.model.maxTokens ?? 4096;
-            const estUsd = estimateTurnCostUsd({ inputTokens, maxOutputTokens, cost: this.model.cost });
+                return reasoning;
+            }
+            const inputTokens = estimateContextPromptTokens(context);
+            // Use an explicit request cap when present; otherwise project against the session response
+            // reserve instead of a frontier model's theoretical 128K output maximum.
+            const maxOutputTokens = Math.min(model.maxTokens ?? 4096, requestMaxTokens ?? this.settingsManager.getCompactionReserveTokens());
+            const estUsd = estimateTurnCostUsd({
+                inputTokens,
+                maxOutputTokens,
+                cost: model.cost,
+                longContextPricing: model.longContextPricing,
+            });
             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;
-                }
-            }
+            if (!decision.over || guard.action !== "downgrade" || reasoning === undefined)
+                return reasoning;
+            const next = downgradeReasoning(reasoning, getSupportedThinkingLevels(model), model.thinkingLevelMap);
+            return next;
         }
         catch {
             // cost guard must never disrupt a turn
+            return reasoning;
         }
     }
     /** Latest cost-guard decision (for the host footer/UI to surface a warning). Undefined if disabled. */
@@ -2096,6 +2113,13 @@ export class AgentSession {
     _rebuildSystemPrompt(toolNames) {
         return this._systemPromptBuilder.rebuildSystemPrompt(toolNames);
     }
+    _refreshBaseSystemPrompt() {
+        const previousBaseSystemPrompt = this._baseSystemPrompt;
+        this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
+        if (this.agent.state.systemPrompt === previousBaseSystemPrompt) {
+            this.agent.state.systemPrompt = this._baseSystemPrompt;
+        }
+    }
     /**
      * Build a system prompt for a specific tool surface WITHOUT touching the session's base prompt
      * state (G4 router-swap; see {@link SystemPromptBuilder.buildSystemPromptForToolNames}).
@@ -2345,7 +2369,7 @@ export class AgentSession {
             // (no page) when nothing is relevant — so it stays net-negative and the GC packs stale pages.
             if (this._memory.shouldAttemptRecall(expandedText)) {
                 try {
-                    const recall = await this._memory.getMemoryManager().prefetch(expandedText);
+                    const recall = await this._memory.prefetchRecall(expandedText);
                     if (recall) {
                         injectedRecall = recall;
                         recallQuery = expandedText;
@@ -2725,6 +2749,16 @@ export class AgentSession {
         await this._modelSelection.setModel(model, options);
         this._scheduleLocalPrefixWarm(this.agent.state.model, "selection");
     }
+    /** Re-resolve startup profile model/thinking after allowed extension providers are bound. */
+    async reapplyActiveProfileModelSettings() {
+        const previousModel = this.model;
+        await this._profileFilter.reapplyActiveProfileModelSettings();
+        const activeToolNames = this._requestedActiveToolNames ?? this.getActiveToolNames();
+        this._refreshToolRegistry({ activeToolNames, includeAllExtensionTools: true });
+        if (!modelsAreEqual(previousModel, this.model)) {
+            this._scheduleLocalPrefixWarm(this.model, "selection");
+        }
+    }
     async cycleModel(direction = "forward") {
         const result = await this._modelSelection.cycleModel(direction);
         this._scheduleLocalPrefixWarm(result?.model, "selection");
@@ -3422,6 +3456,7 @@ export class AgentSession {
             setThinkingLevel: (level) => this.setThinkingLevel(level),
             getExternalResourceRoots: () => this.settingsManager.getEffectiveExternalResourceRoots(),
             registerMemoryProvider: (provider) => this.registerMemoryProvider(provider),
+            registerContextMemoryProvider: (provider) => this.registerContextMemoryProvider(provider),
             reportSpawnedUsage: (usage, opts) => {
                 this.addSpawnedUsage(usage, opts);
             },
@@ -3482,6 +3517,9 @@ export class AgentSession {
     registerMemoryProvider(provider) {
         this._memory.registerMemoryProvider(provider);
     }
+    registerContextMemoryProvider(provider) {
+        this._memory.registerContextMemoryProvider(provider);
+    }
     /** R8: the gateway/scheduler registry. A deployment runner registers providers and drives start/stop. */
     get gateways() {
         return this._gatewayRegistry;