@caupulican/pi-adaptative 0.81.26 → 0.81.29

package/dist/core/agent-session.js

@@ -3,12 +3,13 @@ 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";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { buildForegroundEnvelope, formatForegroundEnvelopeObservation } from "./autonomy/foreground-envelope.js";
+import { evaluateToolGate } from "./autonomy/gates.js";
 import { AutonomyTelemetry } from "./autonomy-telemetry.js";
 import { BackgroundLaneController } from "./background-lane-controller.js";
 import { BashExecutionController } from "./bash-execution-controller.js";
@@ -23,6 +24,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";
@@ -48,6 +50,8 @@ import { TOOL_RECOVERY_EVENT_LOG_FILE } from "./tool-recovery-log-records.js";
 import { ToolRecoveryLogger } from "./tool-recovery-logger.js";
 import { formatToolRepairHealthReport } from "./tool-repair-health.js";
 import { resolveCurrentToolRepairSettings } from "./tool-repair-settings.js";
+import { ToolPerformanceStore } from "./tool-selection/tool-performance-store.js";
+import { ToolSelectionController } from "./tool-selection/tool-selection-controller.js";
 // ============================================================================
 // Stream-idle watchdog wiring
 // ============================================================================
@@ -153,6 +157,7 @@ export class AgentSession {
     _bash;
     _profileFilter;
     _toolGate;
+    _toolSelection;
     _extensionRunner;
     _turnIndex = 0;
     _currentForegroundEnvelope;
@@ -201,7 +206,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 +255,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 +277,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 +335,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 +362,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 +385,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,
@@ -391,6 +406,7 @@ export class AgentSession {
             getSessionManager: () => this.sessionManager,
             getSettingsManager: () => this.settingsManager,
             getModelRegistry: () => this._modelRegistry,
+            getModel: () => this.model,
             getAgentDir: () => this._agentDir,
             getCwd: () => this._cwd,
             getActiveToolNames: () => this.getActiveToolNames(),
@@ -454,6 +470,7 @@ export class AgentSession {
             getReflectionSignal: () => this._reflectionAbort.signal,
             archivePromotedSkill: (name) => this.archivePromotedSkill(name),
             emitAutonomyTelemetry: (event) => this._emitAutonomyTelemetry(event),
+            ensureModelReady: (model) => this._localRuntimeController.ensureIsolatedModelReady(model),
             addSpawnedUsage: (usage, opts) => this.addSpawnedUsage(usage, opts),
             saveLearningDecisionSnapshot: (decision) => this.saveLearningDecisionSnapshot(decision),
         });
@@ -511,6 +528,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,10 +544,15 @@ 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),
             getContextGcReport: (messages) => this.getContextGcReport(messages),
+            startWorkerDelegation: (request) => this._backgroundLanes.startWorkerDelegation(request),
+            getWorkerLaneRecords: () => this._backgroundLanes.getLaneRecords(),
+            getWorkerResultSnapshots: () => this.getWorkerResultSnapshots(),
             runWorkerDelegationOnce: (request) => this.runWorkerDelegationOnce(request),
             runModelFitness: (args) => this.runModelFitness(args),
             resolveCurationModelIfFit: () => this._resolveCurationModelIfFit(),
@@ -554,6 +579,9 @@ export class AgentSession {
         const previousToolArgumentValidation = this.agent.onToolArgumentValidation;
         this.agent.onToolArgumentValidation = (event) => {
             const taggedEvent = this._tagModelAdaptationRuleTeaching(event);
+            if (taggedEvent.outcome === "repaired" || taggedEvent.outcome === "bounced") {
+                this._toolSelection.recordValidation(taggedEvent.tool, taggedEvent.outcome);
+            }
             previousToolArgumentValidation?.(taggedEvent);
             const logRecord = this._toolRecoveryLogger.recordToolArgumentValidation(taggedEvent);
             if (!logRecord)
@@ -587,6 +615,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 +639,35 @@ 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._toolSelection = new ToolSelectionController({
+            store: ToolPerformanceStore.forAgentDir(this._agentDir),
+            getModelRef: () => {
+                const model = this.model;
+                return model ? formatModelRouterModel(model) : "unknown";
+            },
+            getActiveTools: () => {
+                const activeNames = new Set(this.getActiveToolNames());
+                return this.getAllTools()
+                    .filter((tool) => activeNames.has(tool.name))
+                    .map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters,
+                }));
+            },
+            isCandidateAllowed: (toolName) => {
+                const envelope = this.capabilityEnvelope;
+                if (!envelope)
+                    return true;
+                return (evaluateToolGate({
+                    toolName,
+                    args: {},
+                    cwd: this._cwd,
+                    envelope,
+                }).outcome === "allow");
+            },
         });
         this._toolGate = new ToolGateController({
             maybeEscalateToolCall: (toolName, args) => this._modelRouter.maybeEscalateToolCall(toolName, args),
@@ -618,6 +675,7 @@ export class AgentSession {
             getCapabilityEnvelope: () => this.capabilityEnvelope,
             recordGateOutcome: (outcome) => this._recordGateOutcome(outcome),
             getExtensionRunner: () => this._extensionRunner,
+            getToolSelectionController: () => this._toolSelection,
         });
         // Always subscribe to agent events for internal handling
         // (session persistence, extensions, auto-compaction, retry logic)
@@ -825,43 +883,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. */
@@ -1735,6 +1793,7 @@ export class AgentSession {
             await this._extensionRunner.emit({ type: "agent_end", messages: event.messages });
         }
         else if (event.type === "turn_start") {
+            this._toolSelection.startTurn();
             this._refreshForegroundEnvelope();
             const extensionEvent = {
                 type: "turn_start",
@@ -2001,8 +2060,9 @@ export class AgentSession {
      * Also rebuilds the system prompt to reflect the new tool set.
      * Changes take effect on the next agent turn.
      *
-     * artifact_retrieve is auto-activated as a companion whenever grep or find ends up
-     * in the resulting active set and artifact_retrieve is registered (i.e. not excluded/
+     * artifact_retrieve is auto-activated as a companion whenever an artifact-producing tool
+     * (grep, find, or run_toolkit_script) ends up in the resulting active set and artifact_retrieve
+     * is registered (i.e. not excluded/
      * blocked/outside an allowlist -- the registry itself is built with that same filter,
      * so registry presence already tracks "allowed"). This is enforced here, not just in
      * the settings/profile refresh flow, because this method is a public, extension-
@@ -2033,9 +2093,14 @@ export class AgentSession {
         for (const name of capabilityFiltered) {
             addIfRegistered(name);
         }
-        if (validToolNames.includes("grep") || validToolNames.includes("find")) {
+        if (validToolNames.includes("grep") ||
+            validToolNames.includes("find") ||
+            validToolNames.includes("run_toolkit_script")) {
             addIfRegistered("artifact_retrieve");
         }
+        if (validToolNames.includes("delegate")) {
+            addIfRegistered("delegate_status");
+        }
         this.agent.state.tools = tools;
         // Rebuild base system prompt with new tool set
         this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
@@ -2096,6 +2161,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}).
@@ -2320,6 +2392,11 @@ export class AgentSession {
             if (!requestModel) {
                 throw new Error(formatNoModelSelectedMessage());
             }
+            // A manual/default local model has no RouteDecision, so the router readiness gate above is
+            // intentionally a no-op. It still needs the same managed-runtime boot/residency guarantee.
+            if (!resolvedRouteInfo) {
+                await this._localRuntimeController.ensureForegroundModelReady(requestModel);
+            }
             if (!this._modelRegistry.hasConfiguredAuth(requestModel)) {
                 const isOAuth = this._modelRegistry.isUsingOAuth(requestModel);
                 if (isOAuth) {
@@ -2345,7 +2422,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;
@@ -2430,6 +2507,7 @@ export class AgentSession {
                 this._memory.recordRecallOutcome(injectedRecall, recallQuery, responseText);
             }
         }
+        this._backgroundLanes.drainQueuedWorkerDelegations();
         this._backgroundLanes.scheduleGoalAutoContinueFromIdle(options);
         this._backgroundLanes.scheduleResearchLaneFromIdle();
     }
@@ -2725,6 +2803,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 +3510,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 +3571,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;