@caupulican/pi-adaptative 0.81.0 → 0.81.2

package/dist/core/agent-session.js

@@ -14,7 +14,7 @@
  */
 import { readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { classifyFailure, compactToolResultDetailsForRetention, createCustomMessage, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE, RetryController, withStreamIdleWatchdog, } from "@caupulican/pi-agent-core";
+import { classifyFailure, compactToolResultDetailsForRetention, computeRetryDelayMs, createCustomMessage, DEFAULT_RETRY_POLICY, RetryController, sleepAbortable, withStreamIdleWatchdog, } from "@caupulican/pi-agent-core";
 import { calculateContextTokens, compact, estimateContextTokens, getLatestCompactionEntry, prepareCompaction, shouldCompact, } from "@caupulican/pi-agent-core/node";
 import { cleanupSessionResources, isContextOverflow, streamSimple } from "@caupulican/pi-ai";
 import { getAgentDir } from "../config.js";
@@ -64,12 +64,13 @@ import { ToolGateController } from "./tool-gate-controller.js";
  * key stable regardless of how many times this module is evaluated.
  */
 const RAW_STREAM_MARKER = Symbol.for("pi.rawStreamSimple");
-/** Test-only override of the stream-idle bounds. Read once per session, at construction. */
+/** Test-only override of the stream-idle bounds. Read per-request by the wiring's resolver. */
 let streamIdleOptionsOverride;
 /**
  * Test hook: override the stream-idle bounds so a stall can be provoked in-suite without a
- * 30s wait. Pass `undefined` to restore the user-locked default (30s idle / 120s connect).
- * Must be set BEFORE the session is constructed — the wiring reads it in the constructor.
+ * multi-minute wait. Pass `undefined` to restore the user-locked defaults (connect 120s /
+ * active 180s / quiet 600s, or the user's retry.stall settings). Applies per request — it
+ * may be set or changed at any time before the request that should observe it.
  */
 export function setStreamIdleOptionsForTests(opts) {
     streamIdleOptionsOverride = opts;
@@ -248,7 +249,13 @@ export class AgentSession {
         // Wrapping also breaks the `streamFn === streamSimple` identity the auth-injection checks
         // use, so the wrapper carries a rawness marker that _isRawStreamSimple reads.
         const baseStreamFn = this.agent.streamFn;
-        this.agent.streamFn = tagRawness(withStreamIdleWatchdog(baseStreamFn, streamIdleOptionsOverride ?? DEFAULT_STREAM_IDLE), baseStreamFn === streamSimple);
+        // `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.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
         // Auto-retry rides the reliability kernel: the controller owns the attempt counter and the
@@ -587,8 +594,8 @@ export class AgentSession {
         }
         throw new Error(formatNoApiKeyFoundMessage(model.provider));
     }
-    // Summarizer model selection, request auth (with session-model fallback), and window-adapted
-    // settings live in CompactionSupport (see compaction-support.ts). Same-signature delegations.
+    // Summarizer model/thinking selection, request auth (with session-model fallback), and
+    // window-adapted settings live in CompactionSupport (see compaction-support.ts).
     _getCompactionRequestAuth(model) {
         return this._compactionSupport.getRequestAuth(model);
     }
@@ -598,6 +605,9 @@ export class AgentSession {
     _resolveCompactionModel(sessionModel) {
         return this._compactionSupport.resolveModel(sessionModel);
     }
+    _resolveCompactionThinkingLevel(compactionModel, sessionModel) {
+        return this._compactionSupport.resolveThinkingLevel(this.thinkingLevel, compactionModel, sessionModel);
+    }
     /**
      * Install tool hooks once on the Agent instance.
      *
@@ -2135,6 +2145,7 @@ export class AgentSession {
                 throw new Error(formatNoModelSelectedMessage());
             }
             const compactionModel = this._resolveCompactionModel(this.model);
+            const compactionThinkingLevel = this._resolveCompactionThinkingLevel(compactionModel, this.model);
             const { apiKey, headers } = await this._getCompactionRequestAuth(compactionModel);
             const pathEntries = this.sessionManager.getBranch();
             const settings = this._getAdaptedCompactionSettings();
@@ -2178,7 +2189,8 @@ export class AgentSession {
             }
             else {
                 // Generate compaction result
-                const result = await compact(preparation, compactionModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest());
+                const compactionSignal = this._compactionAbortController.signal;
+                const result = await this._compactWithRetry(() => compact(preparation, compactionModel, apiKey, headers, customInstructions, compactionSignal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest()), compactionSignal);
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
@@ -2390,9 +2402,9 @@ export class AgentSession {
                 });
                 return false;
             }
-            // Summarize with the cheap auxiliary model when available (cost guard, #30). If its auth
-            // turns out unusable at request time (e.g. expired token), fall back to the session model —
-            // the one manual /compact demonstrably works with — before giving up.
+            // Summarize with the configured/default compaction model. If its auth turns out unusable at
+            // request time (e.g. expired token), fall back to the session model — the one manual /compact
+            // demonstrably works with — before giving up.
             const resolvedCompaction = await this._resolveCompactionModelAndAuth(this._resolveCompactionModel(this.model), this.model);
             if (resolvedCompaction.failure) {
                 this._emit({
@@ -2406,6 +2418,7 @@ export class AgentSession {
                 return false;
             }
             const compactionModel = resolvedCompaction.model;
+            const compactionThinkingLevel = this._resolveCompactionThinkingLevel(compactionModel, this.model);
             const apiKey = resolvedCompaction.apiKey;
             const headers = resolvedCompaction.headers;
             const pathEntries = this.sessionManager.getBranch();
@@ -2460,7 +2473,8 @@ export class AgentSession {
             }
             else {
                 // Generate compaction result
-                const compactResult = await compact(preparation, compactionModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest());
+                const autoCompactionSignal = this._autoCompactionAbortController.signal;
+                const compactResult = await this._compactWithRetry(() => compact(preparation, compactionModel, apiKey, headers, undefined, autoCompactionSignal, compactionThinkingLevel, this.agent.streamFn, this._buildCompactionPreDigest()), autoCompactionSignal);
                 summary = compactResult.summary;
                 firstKeptEntryId = compactResult.firstKeptEntryId;
                 tokensBefore = compactResult.tokensBefore;
@@ -2526,6 +2540,38 @@ export class AgentSession {
             this._autoCompactionAbortController = undefined;
         }
     }
+    /**
+     * Run one compaction attempt, retrying retryable provider failures (stream stalls,
+     * 429/5xx, network drops) with the session's retry policy. The reliability kernel
+     * classifies a stall as retryable by design (see withStreamIdleWatchdog); without this
+     * loop a single transient killed the whole compaction while ordinary turns survived the
+     * same failure via auto-retry. Caller aborts are never retried; sleepAbortable rejects
+     * with the abort reason if the signal fires mid-backoff.
+     */
+    async _compactWithRetry(run, signal) {
+        const retrySettings = this.settingsManager.getRetrySettings();
+        const maxAttempts = retrySettings.enabled ? Math.max(1, retrySettings.maxRetries + 1) : 1;
+        const policy = {
+            maxAttempts,
+            baseDelayMs: retrySettings.baseDelayMs,
+            maxDelayMs: DEFAULT_RETRY_POLICY.maxDelayMs,
+            jitterRatio: 0,
+        };
+        for (let attempt = 1;; attempt++) {
+            try {
+                return await run();
+            }
+            catch (error) {
+                if (signal.aborted || attempt >= maxAttempts)
+                    throw error;
+                const message = error instanceof Error ? error.message : String(error);
+                const classified = classifyFailure({ message });
+                if (!classified.retryable)
+                    throw error;
+                await sleepAbortable(computeRetryDelayMs(policy, attempt, { retryAfterMs: classified.retryAfterMs }), signal);
+            }
+        }
+    }
     /**
      * Toggle auto-compaction setting.
      */