@caupulican/pi-adaptative 0.80.84 → 0.80.86

package/dist/core/agent-session.js

@@ -153,6 +153,7 @@ export class AgentSession {
     _activeModelRouterIntent;
     _modelRouterSessionBuffer;
     _modelRouterEscalationRequested = false;
+    _isModelRouterRetry = false;
     _lastModelRouterDecision;
     _lastModelRouterSkipReason;
     _lastModelRouterIntent;
@@ -295,7 +296,7 @@ export class AgentSession {
             const authoritativeMessages = this.agent.state.messages.length > 0 ? this.agent.state.messages : transformed;
             let currentMessages = authoritativeMessages;
             try {
-                const settings = this.settingsManager.getCompactionSettings();
+                const settings = this._getAdaptedCompactionSettings();
                 const contextWindow = this.model?.contextWindow ?? 0;
                 if (settings.enabled && contextWindow > 0 && !this.isCompacting) {
                     const contextTokens = this._estimateCurrentContextTokens(authoritativeMessages);
@@ -584,8 +585,13 @@ export class AgentSession {
         }
         // Emit to extensions first
         await this._emitExtensionEvent(event);
+        const suppressRetryPromptEvent = this._isModelRouterRetry &&
+            (event.type === "message_start" || event.type === "message_end") &&
+            (event.message.role === "user" || event.message.role === "custom");
         // Notify all listeners
-        this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event) } : event);
+        if (!suppressRetryPromptEvent) {
+            this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event) } : event);
+        }
         // Handle session/context retention. Tool result details are UI/log metadata,
         // not provider-visible content, and large graph/search payloads can otherwise
         // accumulate until the interactive Node process hits the V8 heap limit.
@@ -926,6 +932,7 @@ export class AgentSession {
         // Rebuild base system prompt with new tool set
         this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
         this.agent.state.systemPrompt = this._baseSystemPrompt;
+        this._checkContextWindowUsageWarning();
     }
     /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
@@ -1243,8 +1250,11 @@ export class AgentSession {
             this._modelRouterEscalationRequested = previousModelRouterEscalationRequested;
         }
         if (retryModel && !thrownError) {
+            const previousIsModelRouterRetry = this._isModelRouterRetry;
             try {
+                this._isModelRouterRetry = true;
                 await this._runAgentPromptWithModelRouter(messages, retryModel, "modify", false);
+                this._lastModelRouterDecision = completedDecision;
             }
             catch (error) {
                 thrownError = error;
@@ -1253,6 +1263,9 @@ export class AgentSession {
                     this._lastModelRouterDecision = completedDecision;
                 }
             }
+            finally {
+                this._isModelRouterRetry = previousIsModelRouterRetry;
+            }
         }
         if (persistDecision && completedDecision) {
             persistModelRouterDecision(this.sessionManager, completedDecision);
@@ -1404,6 +1417,7 @@ export class AgentSession {
                 }
                 throw new Error(formatNoApiKeyFoundMessage(requestModel.provider));
             }
+            this._checkContextWindowUsageWarning();
             // Check if we need to compact before sending (catches aborted responses).
             // Do not call agent.continue() here: the next model turn must include the
             // user's pending prompt, not an empty continuation after compaction.
@@ -1814,6 +1828,7 @@ export class AgentSession {
         // Re-clamp thinking level for new model's capabilities
         this.setThinkingLevel(thinkingLevel, { persistSettings });
         await this._emitModelSelect(model, previousModel, "set");
+        this._checkContextWindowUsageWarning();
     }
     /**
      * Cycle to next/previous model.
@@ -1849,6 +1864,7 @@ export class AgentSession {
         // setThinkingLevel clamps to model capabilities.
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(next.model, currentModel, "cycle");
+        this._checkContextWindowUsageWarning();
         return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
     }
     async _cycleAvailableModel(direction) {
@@ -1869,6 +1885,7 @@ export class AgentSession {
         // Re-clamp thinking level for new model's capabilities
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(nextModel, currentModel, "cycle");
+        this._checkContextWindowUsageWarning();
         return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
     }
     // =========================================================================
@@ -1980,7 +1997,7 @@ export class AgentSession {
             const compactionModel = this._resolveCompactionModel(this.model);
             const { apiKey, headers } = await this._getCompactionRequestAuth(compactionModel);
             const pathEntries = this.sessionManager.getBranch();
-            const settings = this.settingsManager.getCompactionSettings();
+            const settings = this._getAdaptedCompactionSettings();
             const preparation = prepareCompaction(pathEntries, settings);
             if (!preparation) {
                 // Check why we can't compact
@@ -2100,8 +2117,57 @@ export class AgentSession {
      * @param assistantMessage The assistant message to check
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
      */
-    async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
+    _getAdaptedCompactionSettings() {
         const settings = this.settingsManager.getCompactionSettings();
+        if (!this.model)
+            return settings;
+        const contextWindow = this.model.contextWindow ?? 0;
+        if (contextWindow <= 0)
+            return settings;
+        // Adapt reserveTokens: at most 25% of context window
+        const maxReserve = Math.floor(contextWindow * 0.25);
+        const reserveTokens = Math.min(settings.reserveTokens, maxReserve);
+        // Adapt keepRecentTokens: at most 50% of context window
+        const maxKeepRecent = Math.floor(contextWindow * 0.5);
+        const keepRecentTokens = Math.min(settings.keepRecentTokens, maxKeepRecent);
+        return {
+            ...settings,
+            reserveTokens,
+            keepRecentTokens,
+        };
+    }
+    _checkContextWindowUsageWarning() {
+        if (!this.model)
+            return;
+        const contextWindow = this.model.contextWindow ?? 0;
+        if (contextWindow <= 0)
+            return;
+        const systemPromptTokens = Math.ceil((this.agent.state.systemPrompt ?? "").length / 4);
+        let toolsChars = 0;
+        for (const tool of this.agent.state.tools || []) {
+            toolsChars += tool.name.length;
+            toolsChars += tool.description?.length ?? 0;
+            if (tool.parameters) {
+                toolsChars += JSON.stringify(tool.parameters).length;
+            }
+        }
+        const toolsTokens = Math.ceil(toolsChars / 4);
+        const baseTokens = systemPromptTokens + toolsTokens;
+        if (baseTokens >= contextWindow) {
+            this._emit({
+                type: "warning",
+                message: `Base configuration (system prompt and active tools) consumes ${baseTokens} tokens, which exceeds the model's context window of ${contextWindow} tokens. The model cannot process any prompts in this state.`,
+            });
+        }
+        else if (baseTokens >= contextWindow * 0.7) {
+            this._emit({
+                type: "warning",
+                message: `Base configuration (system prompt and active tools) consumes ${baseTokens} tokens (${Math.round((baseTokens / contextWindow) * 100)}% of the ${contextWindow} context window). This leaves very little room for conversation history and may cause immediate compaction or context overflow.`,
+            });
+        }
+    }
+    async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
+        const settings = this._getAdaptedCompactionSettings();
         if (!settings.enabled)
             return false;
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
@@ -2185,7 +2251,7 @@ export class AgentSession {
      * Internal: Run auto-compaction with events.
      */
     async _runAutoCompaction(reason, willRetry) {
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this._getAdaptedCompactionSettings();
         this._emit({ type: "compaction_start", reason });
         this._autoCompactionAbortController = new AbortController();
         try {
@@ -2565,6 +2631,43 @@ export class AgentSession {
         const filter = this.settingsManager.getResourceProfileFilter("tools");
         return { allow: filter.allow ?? [], block: filter.block ?? [] };
     }
+    _isToolOrCommandAllowedByProfile(name) {
+        if (this._allowedToolNames && !this._allowedToolNames.has(name))
+            return false;
+        if (this._excludedToolNames?.has(name))
+            return false;
+        const filter = this._toolProfileFilter;
+        if (!filter)
+            return true;
+        if (filter.allow.length > 0 && !matchesResourceProfilePattern(name, filter.allow))
+            return false;
+        if (matchesResourceProfilePattern(name, filter.block))
+            return false;
+        return true;
+    }
+    _hasToolOrCommandProfileGate() {
+        return Boolean(this._allowedToolNames ||
+            this._excludedToolNames ||
+            (this._toolProfileFilter &&
+                (this._toolProfileFilter.allow.length > 0 || this._toolProfileFilter.block.length > 0)));
+    }
+    _filterExtensionsForRuntime(extensions) {
+        if (this.settingsManager.getActiveResourceProfileNames().length === 0) {
+            return this.settingsManager.hasExplicitActiveResourceProfileSelection()
+                ? []
+                : extensions.filter((extension) => extension.sourceInfo.source === "inline");
+        }
+        const hasToolOrCommandGate = this._hasToolOrCommandProfileGate();
+        return extensions
+            .filter((extension) => this.settingsManager.isResourceAllowedByProfile("extensions", extension.path, extension.sourceInfo.baseDir))
+            .map((extension) => {
+            if (!hasToolOrCommandGate)
+                return extension;
+            const tools = new Map(Array.from(extension.tools.entries()).filter(([name]) => this._isToolOrCommandAllowedByProfile(name)));
+            const commands = new Map(Array.from(extension.commands.entries()).filter(([name]) => this._isToolOrCommandAllowedByProfile(name)));
+            return { ...extension, tools, commands };
+        });
+    }
     /**
      * Re-resolve the active resource profile's model/thinking from current settings and apply it.
      * Only acts when the profile actually binds model/thinking AND that field was not set by an
@@ -2826,7 +2929,11 @@ export class AgentSession {
                 extensionsResult.runtime.flagValues.set(name, value);
             }
         }
-        this._extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, this._modelRegistry);
+        const extensions = this._filterExtensionsForRuntime(extensionsResult.extensions);
+        const runtimeExtensionPaths = new Set(extensions.map((extension) => extension.path));
+        extensionsResult.runtime.pendingProviderRegistrations =
+            extensionsResult.runtime.pendingProviderRegistrations.filter((registration) => runtimeExtensionPaths.has(registration.extensionPath));
+        this._extensionRunner = new ExtensionRunner(extensions, extensionsResult.runtime, this._cwd, this.sessionManager, this._modelRegistry);
         if (this._extensionRunnerRef) {
             this._extensionRunnerRef.current = this._extensionRunner;
         }