@caupulican/pi-adaptative 0.80.23 → 0.80.26

package/dist/core/agent-session.js

@@ -25,11 +25,14 @@ import { calculateContextTokens, collectEntriesForBranchSummary, compact, estima
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
+import { createCoreDiagnosticsToolDefinitions } from "./extensions/builtin.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { compactToolResultDetailsForRetention } from "./message-retention.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
+import { stripResourceProfileBlocks } from "./resource-profile-blocks.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
+import { matchesResourceProfilePattern, } from "./settings-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
@@ -99,6 +102,7 @@ export class AgentSession {
     _initialActiveToolNames;
     _allowedToolNames;
     _excludedToolNames;
+    _toolProfileFilter;
     _baseToolsOverride;
     _sessionStartEvent;
     _extensionUIContext;
@@ -131,6 +135,9 @@ export class AgentSession {
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
         this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : undefined;
+        this._toolProfileFilter = config.toolProfileFilter
+            ? { allow: config.toolProfileFilter.allow ?? [], block: config.toolProfileFilter.block ?? [] }
+            : undefined;
         this._baseToolsOverride = config.baseToolsOverride;
         this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
         // Always subscribe to agent events for internal handling
@@ -1030,7 +1037,7 @@ export class AgentSession {
             return text; // Unknown skill, pass through
         try {
             const content = readFileSync(skill.filePath, "utf-8");
-            const body = stripFrontmatter(content).trim();
+            const body = stripResourceProfileBlocks(stripFrontmatter(content)).trim();
             const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${body}\n</skill>`;
             return args ? `${skillBlock}\n\n${args}` : skillBlock;
         }
@@ -2021,7 +2028,21 @@ export class AgentSession {
         const previousActiveToolNames = this.getActiveToolNames();
         const allowedToolNames = this._allowedToolNames;
         const excludedToolNames = this._excludedToolNames;
-        const isAllowedTool = (name) => (!allowedToolNames || allowedToolNames.has(name)) && !excludedToolNames?.has(name);
+        const toolProfileFilter = this._toolProfileFilter;
+        const isAllowedTool = (name) => {
+            if (allowedToolNames && !allowedToolNames.has(name))
+                return false;
+            if (excludedToolNames?.has(name))
+                return false;
+            if (!toolProfileFilter)
+                return true;
+            if (toolProfileFilter.allow.length > 0 && !matchesResourceProfilePattern(name, toolProfileFilter.allow)) {
+                return false;
+            }
+            if (matchesResourceProfilePattern(name, toolProfileFilter.block))
+                return false;
+            return true;
+        };
         const registeredTools = this._extensionRunner.getAllRegisteredTools();
         const allCustomTools = [
             ...registeredTools,
@@ -2093,6 +2114,55 @@ export class AgentSession {
         }
         this.setActiveToolsByName([...new Set(nextActiveToolNames)]);
     }
+    _createReloadRuntimeSnapshot() {
+        return {
+            extensionRunner: this._extensionRunner,
+            baseToolDefinitions: this._baseToolDefinitions,
+            toolRegistry: this._toolRegistry,
+            toolDefinitions: this._toolDefinitions,
+            toolPromptSnippets: this._toolPromptSnippets,
+            toolPromptGuidelines: this._toolPromptGuidelines,
+            agentTools: this.agent.state.tools,
+            agentSystemPrompt: this.agent.state.systemPrompt,
+            baseSystemPrompt: this._baseSystemPrompt,
+        };
+    }
+    _restoreReloadRuntimeSnapshot(snapshot) {
+        this._extensionRunner = snapshot.extensionRunner;
+        this._baseToolDefinitions = snapshot.baseToolDefinitions;
+        this._toolRegistry = snapshot.toolRegistry;
+        this._toolDefinitions = snapshot.toolDefinitions;
+        this._toolPromptSnippets = snapshot.toolPromptSnippets;
+        this._toolPromptGuidelines = snapshot.toolPromptGuidelines;
+        this.agent.state.tools = snapshot.agentTools;
+        this.agent.state.systemPrompt = snapshot.agentSystemPrompt;
+        this._baseSystemPrompt = snapshot.baseSystemPrompt;
+        if (this._extensionRunnerRef) {
+            this._extensionRunnerRef.current = snapshot.extensionRunner;
+        }
+        this._applyExtensionBindings(snapshot.extensionRunner);
+    }
+    _doctorReloadRuntime() {
+        const extensionErrors = this._resourceLoader.getExtensions().errors;
+        if (extensionErrors.length > 0) {
+            const summary = extensionErrors
+                .slice(0, 6)
+                .map((error) => `${error.path}: ${error.error}`)
+                .join("; ");
+            throw new Error(`Extension reload failed doctor: ${summary}`);
+        }
+        const missingActiveTools = this.getActiveToolNames().filter((name) => !this._toolRegistry.has(name));
+        if (missingActiveTools.length > 0) {
+            throw new Error(`Extension reload failed doctor: active tool(s) missing after reload: ${missingActiveTools.join(", ")}`);
+        }
+        for (const tool of this.agent.state.tools) {
+            if (!this._toolDefinitions.has(tool.name)) {
+                throw new Error(`Extension reload failed doctor: tool ${tool.name} missing from definition registry`);
+            }
+        }
+        this._createAgentContextSnapshot();
+        this.getContextUsage();
+    }
     _buildRuntime(options) {
         const autoResizeImages = this.settingsManager.getImageAutoResize();
         const shellCommandPrefix = this.settingsManager.getShellCommandPrefix();
@@ -2107,6 +2177,11 @@ export class AgentSession {
                 bash: { commandPrefix: shellCommandPrefix, shellPath },
             });
         this._baseToolDefinitions = new Map(Object.entries(baseToolDefinitions).map(([name, tool]) => [name, tool]));
+        if (!this._baseToolsOverride) {
+            for (const definition of createCoreDiagnosticsToolDefinitions(() => this.getActiveToolNames(), () => this.getAllTools())) {
+                this._baseToolDefinitions.set(definition.name, definition);
+            }
+        }
         const extensionsResult = this._resourceLoader.getExtensions();
         if (options.flagValues) {
             for (const [name, value] of options.flagValues) {
@@ -2121,7 +2196,7 @@ export class AgentSession {
         this._applyExtensionBindings(this._extensionRunner);
         const defaultActiveToolNames = this._baseToolsOverride
             ? Object.keys(this._baseToolsOverride)
-            : ["read", "bash", "edit", "write"];
+            : ["read", "bash", "edit", "write", "context_audit"];
         const baseActiveToolNames = options.activeToolNames ?? defaultActiveToolNames;
         this._refreshToolRegistry({
             activeToolNames: baseActiveToolNames,
@@ -2129,23 +2204,54 @@ export class AgentSession {
         });
     }
     async reload() {
-        const previousFlagValues = this._extensionRunner.getFlagValues();
-        await emitSessionShutdownEvent(this._extensionRunner, { type: "session_shutdown", reason: "reload" });
-        await this.settingsManager.reload();
-        resetApiProviders();
-        await this._resourceLoader.reload();
-        this._buildRuntime({
-            activeToolNames: this.getActiveToolNames(),
-            flagValues: previousFlagValues,
-            includeAllExtensionTools: true,
-        });
-        const hasBindings = this._extensionUIContext ||
-            this._extensionCommandContextActions ||
-            this._extensionShutdownHandler ||
-            this._extensionErrorListener;
-        if (hasBindings) {
-            await this._extensionRunner.emit({ type: "session_start", reason: "reload" });
-            await this.extendResourcesFromExtensions("reload");
+        const previousRunner = this._extensionRunner;
+        const snapshot = this._createReloadRuntimeSnapshot();
+        const activeToolNames = this.getActiveToolNames();
+        const previousFlagValues = previousRunner.getFlagValues();
+        const reloadErrors = [];
+        let newRunner;
+        try {
+            await this.settingsManager.reload();
+            await this._resourceLoader.reload({ failOnExtensionErrors: true, deferExtensionDispose: true });
+            resetApiProviders();
+            this._buildRuntime({
+                activeToolNames,
+                flagValues: previousFlagValues,
+                includeAllExtensionTools: true,
+            });
+            newRunner = this._extensionRunner;
+            const offDoctorErrors = newRunner.onError((error) => {
+                reloadErrors.push(`${error.extensionPath} ${error.event}: ${error.error}`);
+            });
+            try {
+                this._doctorReloadRuntime();
+                const hasBindings = this._extensionUIContext ||
+                    this._extensionCommandContextActions ||
+                    this._extensionShutdownHandler ||
+                    this._extensionErrorListener;
+                if (hasBindings) {
+                    await newRunner.emit({ type: "session_start", reason: "reload" });
+                    await this.extendResourcesFromExtensions("reload");
+                    this._doctorReloadRuntime();
+                }
+            }
+            finally {
+                offDoctorErrors();
+            }
+            if (reloadErrors.length > 0) {
+                throw new Error(`Extension reload failed doctor: ${reloadErrors.slice(0, 6).join("; ")}`);
+            }
+            await emitSessionShutdownEvent(previousRunner, { type: "session_shutdown", reason: "reload" });
+            previousRunner.invalidate();
+            this._resourceLoader.commitReload?.();
+        }
+        catch (error) {
+            if (newRunner && newRunner !== previousRunner) {
+                newRunner.invalidate("This extension ctx was discarded because reload failed and Pi restored the previous valid runtime.");
+            }
+            this._resourceLoader.rollbackReload?.();
+            this._restoreReloadRuntimeSnapshot(snapshot);
+            throw error;
         }
     }
     // =========================================================================