@caupulican/pi-adaptative 0.80.25 → 0.80.26

package/dist/core/agent-session.js

@@ -25,6 +25,7 @@ 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";
@@ -2113,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();
@@ -2127,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) {
@@ -2141,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,
@@ -2149,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;
         }
     }
     // =========================================================================