@caupulican/pi-adaptative 0.81.16 → 0.81.17

package/dist/core/agent-session.js

@@ -1,7 +1,7 @@
 import { readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
-import { classifyFailure, compactToolResultDetailsForRetention, computeRetryDelayMs, createCustomMessage, DEFAULT_RETRY_POLICY, RetryController, sleepAbortable, withStreamIdleWatchdog, } from "@caupulican/pi-agent-core";
+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 { Type } from "typebox";
@@ -31,6 +31,7 @@ import { deriveModelCapabilityProfile, filterToolNamesForCapability, } from "./m
 import { formatModelRouterModel, ModelRouterController } from "./model-router-controller.js";
 import { ModelSelectionController } from "./model-selection-controller.js";
 import { ModelAdaptationStore } from "./models/adaptation-store.js";
+import { DEFAULT_ADAPTIVE_STREAM_IDLE_CEILING_MS, estimateContextPromptTokens, resolveAdaptiveStreamIdleOptions, withModelPerfProfile, } from "./models/perf-profile.js";
 import { ProfileFilterController } from "./profile-filter-controller.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { ReflectionController } from "./reflection-controller.js";
@@ -159,6 +160,8 @@ export class AgentSession {
     _collectWorkspaceSources;
     _localRuntimeController;
     _modelAdaptationStore;
+    _prefixWarmer;
+    _completedPrefixWarms = new Set();
     _repairModeSessionCounts = new Map();
     _textProtocolParseFailures = new Map();
     _textProtocolParseObservedThisTurn = false;
@@ -240,14 +243,35 @@ export class AgentSession {
         // withStreamIdleWatchdog's contract), so no extra drain is added at this wiring site.
         // Wrapping also breaks the `streamFn === streamSimple` identity the auth-injection checks
         // use, so the wrapper carries a rawness marker that _isRawStreamSimple reads.
+        const agentDir = config.agentDir ?? getAgentDir();
+        const modelAdaptationStore = ModelAdaptationStore.forAgentDir(agentDir);
         const baseStreamFn = this.agent.streamFn;
+        const profiledStreamFn = withModelPerfProfile(baseStreamFn, {
+            modelKey: (model) => formatModelRouterModel(model),
+            recordSample: (modelKey, sample) => {
+                modelAdaptationStore.recordPerfSample(modelKey, sample);
+            },
+        });
         // `this.settingsManager` is assigned below; the resolver closes over the config reference
         // because the wrapper must be installed before that assignment runs.
         const stallSettingsSource = config.settingsManager;
-        this.agent.streamFn = tagRawness(withStreamIdleWatchdog(baseStreamFn, () => ({
-            ...stallSettingsSource.getStreamStallSettings(),
-            ...streamIdleOptionsOverride,
-        })), baseStreamFn === streamSimple);
+        this.agent.streamFn = tagRawness(withStreamIdleWatchdog(profiledStreamFn, (model, context) => {
+            const configured = {
+                ...stallSettingsSource.getStreamStallSettings(),
+                ...streamIdleOptionsOverride,
+            };
+            const httpIdleTimeoutMs = stallSettingsSource.getHttpIdleTimeoutMs();
+            const profile = modelAdaptationStore.get(formatModelRouterModel(model)).perf;
+            const adaptive = resolveAdaptiveStreamIdleOptions({
+                base: { ...DEFAULT_STREAM_IDLE, ...configured },
+                profile,
+                promptTokens: estimateContextPromptTokens(context),
+                ceilingMs: httpIdleTimeoutMs === 0
+                    ? DEFAULT_ADAPTIVE_STREAM_IDLE_CEILING_MS
+                    : Math.max(DEFAULT_STREAM_IDLE.quietIdleMs, httpIdleTimeoutMs - 60_000),
+            });
+            return { ...configured, ...adaptive };
+        }), baseStreamFn === streamSimple);
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
         // Auto-retry rides the reliability kernel: the controller owns the attempt counter and the
@@ -271,8 +295,8 @@ export class AgentSession {
         this._resourceLoader = config.resourceLoader;
         this._customTools = config.customTools ?? [];
         this._cwd = config.cwd;
-        this._agentDir = config.agentDir ?? getAgentDir();
-        this._modelAdaptationStore = ModelAdaptationStore.forAgentDir(this._agentDir);
+        this._agentDir = agentDir;
+        this._modelAdaptationStore = modelAdaptationStore;
         this.agent.onTextToolProtocolParse = (event) => this._handleTextToolProtocolParse(event);
         this._applyToolRepairLayerSettings();
         this._collectWorkspaceSources = config.collectWorkspaceSources ?? collectWorkspaceSources;
@@ -589,11 +613,82 @@ export class AgentSession {
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
         });
+        this._scheduleLocalPrefixWarm(this.agent.state.model, "session-start");
     }
     /** Model registry for API key resolution and model discovery */
     get modelRegistry() {
         return this._modelRegistry;
     }
+    _scheduleLocalPrefixWarm(model, _reason) {
+        if (!model || !this._isWarmableLocalModel(model))
+            return;
+        const modelKey = formatModelRouterModel(model);
+        if (this._completedPrefixWarms.has(modelKey) || this._prefixWarmer?.modelKey === modelKey)
+            return;
+        this._cancelPrefixWarm();
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            const warmer = this._prefixWarmer;
+            if (!warmer || warmer.controller !== controller || controller.signal.aborted)
+                return;
+            warmer.timer = undefined;
+            void this._runLocalPrefixWarm(model, modelKey, controller);
+        }, 0);
+        timer.unref?.();
+        this._prefixWarmer = { modelKey, controller, timer };
+    }
+    _cancelPrefixWarm() {
+        const warmer = this._prefixWarmer;
+        if (!warmer)
+            return;
+        if (warmer.timer)
+            clearTimeout(warmer.timer);
+        warmer.controller.abort(new Error("prefix warmer preempted"));
+        this._prefixWarmer = undefined;
+    }
+    async _runLocalPrefixWarm(model, modelKey, controller) {
+        try {
+            const options = {
+                maxTokens: 1,
+                signal: controller.signal,
+                onPayload: this.agent.onPayload,
+                onResponse: this.agent.onResponse,
+            };
+            if (this._isRawStreamSimple(this.agent.streamFn)) {
+                const auth = await this._getRequiredRequestAuth(model);
+                options.apiKey = auth.apiKey;
+                options.headers = auth.headers;
+            }
+            if (controller.signal.aborted)
+                return;
+            const stream = await this.agent.streamFn(model, {
+                systemPrompt: this._baseSystemPrompt,
+                tools: this.agent.state.tools,
+                messages: [],
+            }, options);
+            await stream.result();
+            if (!controller.signal.aborted)
+                this._completedPrefixWarms.add(modelKey);
+        }
+        catch {
+            // Best-effort cache warm only; a miss must never affect the real turn.
+        }
+        finally {
+            if (this._prefixWarmer?.controller === controller)
+                this._prefixWarmer = undefined;
+        }
+    }
+    _isWarmableLocalModel(model) {
+        if (model.api !== "openai-completions")
+            return false;
+        try {
+            const hostname = new URL(model.baseUrl).hostname.toLowerCase();
+            return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * True when the session's stream fn is the raw `streamSimple` provider entry (directly, or as the
      * base wrapped by the idle watchdog at construction). Callers use this to decide whether request
@@ -1760,6 +1855,7 @@ export class AgentSession {
             this.abortCompaction();
             this.abortBranchSummary();
             this.abortBash();
+            this._cancelPrefixWarm();
             this.agent.abort();
             // R8: stop any deployment-registered gateway channels / schedulers.
             void this._gatewayRegistry.stop().catch(() => { });
@@ -2086,6 +2182,7 @@ export class AgentSession {
     }
     async _promptUnserialized(text, options) {
         this._applyToolRepairLayerSettings();
+        this._cancelPrefixWarm();
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const processSlashCommands = options?.processSlashCommands ?? expandPromptTemplates;
         const preflightResult = options?.preflightResult;
@@ -2597,10 +2694,13 @@ export class AgentSession {
     // Model Management
     // =========================================================================
     async setModel(model, options = {}) {
-        return this._modelSelection.setModel(model, options);
+        await this._modelSelection.setModel(model, options);
+        this._scheduleLocalPrefixWarm(this.agent.state.model, "selection");
     }
     async cycleModel(direction = "forward") {
-        return this._modelSelection.cycleModel(direction);
+        const result = await this._modelSelection.cycleModel(direction);
+        this._scheduleLocalPrefixWarm(result?.model, "selection");
+        return result;
     }
     // =========================================================================
     // Thinking Level Management