@caupulican/pi-adaptative 0.80.42 → 0.80.44

package/dist/core/agent-session.js

@@ -29,6 +29,7 @@ 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 { disposeExtensionEventSubscriptions } from "./extensions/loader.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { compactToolResultDetailsForRetention } from "./message-retention.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
@@ -71,6 +72,7 @@ export class AgentSession {
     // Event subscription state
     _unsubscribeAgent;
     _eventListeners = [];
+    _extensionsChangedListeners = [];
     /** Tracks pending steering messages for UI display. Removed when delivered. */
     _steeringMessages = [];
     /** Tracks pending follow-up messages for UI display. Removed when delivered. */
@@ -579,6 +581,33 @@ export class AgentSession {
             }
         };
     }
+    /**
+     * Subscribe to extensions changed events (load/unload live).
+     * Returns unsubscribe function for this listener.
+     */
+    onExtensionsChanged(cb) {
+        this._extensionsChangedListeners.push(cb);
+        return () => {
+            const index = this._extensionsChangedListeners.indexOf(cb);
+            if (index !== -1) {
+                this._extensionsChangedListeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Notify all extensions-changed listeners.
+     * Called after successful load/unload operations.
+     */
+    _notifyExtensionsChanged() {
+        for (const listener of this._extensionsChangedListeners) {
+            try {
+                listener();
+            }
+            catch {
+                // Suppress errors from listeners to avoid cascading failures
+            }
+        }
+    }
     /**
      * Temporarily disconnect from agent events.
      * User listeners are preserved and will receive events again after resubscribe().
@@ -756,9 +785,7 @@ export class AgentSession {
     _buildSelfModificationPrompt() {
         const settings = this.settingsManager.getSelfModificationSettings();
         if (!settings.enabled) {
-            return `Pi self-modification guardrails (local setting inactive):
-- Do not modify Pi core, the installed Pi runtime, or pi-adaptative harness source for self-evolution.
-- If self-modification is needed, ask the user to enable \`selfModification.enabled\` and set \`selfModification.sourcePaths\` (or legacy \`selfModification.sourcePath\`) to the pi-adaptative source checkout.`;
+            return undefined;
         }
         // Resolve from an ordered candidate list first (portable WSL/Termux switching
         // from settings alone), then fall back to the legacy single sourcePath.
@@ -796,7 +823,7 @@ export class AgentSession {
     _buildAutonomyPrompt() {
         const autoLearn = this.settingsManager.getAutoLearnSettings();
         const autonomy = this.settingsManager.getAutonomySettings();
-        if (!autoLearn.enabled && autonomy.mode === "off") {
+        if (!autoLearn.enabled && autonomy.mode !== "full") {
             return undefined;
         }
         const reflection = autoLearn.reflectionReview ?? autonomy.mode !== "off";
@@ -1339,17 +1366,20 @@ export class AgentSession {
      * Validates that auth is configured, saves to session and settings.
      * @throws Error if no auth is configured for the model
      */
-    async setModel(model) {
+    async setModel(model, options = {}) {
         if (!this._modelRegistry.hasConfiguredAuth(model)) {
             throw new Error(`No API key for ${model.provider}/${model.id}`);
         }
+        const persistSettings = options.persistSettings ?? true;
         const previousModel = this.model;
         const thinkingLevel = this._getThinkingLevelForModelSwitch();
         this.agent.state.model = model;
         this.sessionManager.appendModelChange(model.provider, model.id);
-        this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        if (persistSettings) {
+            this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        }
         // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(thinkingLevel);
+        this.setThinkingLevel(thinkingLevel, { persistSettings });
         await this._emitModelSelect(model, previousModel, "set");
     }
     /**
@@ -1416,16 +1446,17 @@ export class AgentSession {
      * Clamps to model capabilities based on available thinking levels.
      * Saves to session and settings only if the level actually changes.
      */
-    setThinkingLevel(level) {
+    setThinkingLevel(level, options = {}) {
         const availableLevels = this.getAvailableThinkingLevels();
         const effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels);
         // Only persist if actually changing
         const previousLevel = this.agent.state.thinkingLevel;
         const isChanging = effectiveLevel !== previousLevel;
+        const persistSettings = options.persistSettings ?? true;
         this.agent.state.thinkingLevel = effectiveLevel;
         if (isChanging) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-            if (this.supportsThinking() || effectiveLevel !== "off") {
+            if (persistSettings && (this.supportsThinking() || effectiveLevel !== "off")) {
                 this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
             }
             this._emit({ type: "thinking_level_changed", level: effectiveLevel });
@@ -2319,6 +2350,181 @@ export class AgentSession {
             throw error;
         }
     }
+    /**
+     * Unload a single extension without full reload.
+     * Runs the extension's session_shutdown lifecycle, unregisters its providers,
+     * disposes its event subscriptions, and rebuilds the runtime.
+     * Falls back to full reload on error.
+     */
+    async unloadExtensionLive(extensionPath) {
+        if (this.isStreaming) {
+            throw new Error("Cannot unload extension while the agent is streaming or a tool call is active");
+        }
+        if (this.isCompacting) {
+            throw new Error("Cannot unload extension while context compaction or branch summarization is active");
+        }
+        const ext = this._resourceLoader.getLoadedExtension(extensionPath);
+        if (!ext) {
+            return; // Nothing to unload
+        }
+        const previousRunner = this._extensionRunner;
+        try {
+            // Run session_shutdown lifecycle for this extension only
+            await this._extensionRunner.emitToExtension(ext, { type: "session_shutdown", reason: "unload" });
+            // Unregister its providers (keyed by the extension's own path, as registered)
+            const runtime = this._resourceLoader.getExtensions().runtime;
+            for (const name of runtime.getProvidersForExtension(ext.path)) {
+                runtime.unregisterProvider(name, ext.path);
+            }
+            // Dispose its event subscriptions and run disposers
+            await disposeExtensionEventSubscriptions([ext]);
+            // Remove from loaded extensions
+            this._resourceLoader.removeLoadedExtension(extensionPath);
+            // Rebuild runtime with new extension set
+            const activeToolNames = this.getActiveToolNames();
+            const previousFlagValues = previousRunner.getFlagValues();
+            this._buildRuntime({
+                activeToolNames,
+                flagValues: previousFlagValues,
+                includeAllExtensionTools: true,
+            });
+            previousRunner.invalidate();
+            // Notify extensions-changed listeners
+            this._notifyExtensionsChanged();
+        }
+        catch (error) {
+            // Fall back to full reload on error
+            try {
+                await this.reload();
+            }
+            catch {
+                // Suppress nested error; original error will be thrown below
+            }
+            throw error;
+        }
+    }
+    /**
+     * Load a single extension without full reload.
+     * Loads the extension with fresh import, rebuilds the runtime,
+     * and runs the extension's session_start lifecycle.
+     * Falls back to full reload on error.
+     */
+    async loadExtensionLive(extensionPath) {
+        if (this.isStreaming) {
+            throw new Error("Cannot load extension while the agent is streaming or a tool call is active");
+        }
+        if (this.isCompacting) {
+            throw new Error("Cannot load extension while context compaction or branch summarization is active");
+        }
+        const previousRunner = this._extensionRunner;
+        try {
+            // Load the extension with fresh import
+            const { extension, error } = await this._resourceLoader.loadSingleExtension(extensionPath);
+            if (error || !extension) {
+                throw new Error(error || `Failed to load extension: ${extensionPath}`);
+            }
+            // Rebuild runtime to aggregate tools/commands/handlers/providers
+            const activeToolNames = this.getActiveToolNames();
+            const previousFlagValues = previousRunner.getFlagValues();
+            this._buildRuntime({
+                activeToolNames,
+                flagValues: previousFlagValues,
+                includeAllExtensionTools: true,
+            });
+            // Run session_start lifecycle for the new extension only
+            await this._extensionRunner.emitToExtension(extension, { type: "session_start", reason: "load" });
+            // Notify extensions-changed listeners
+            this._notifyExtensionsChanged();
+        }
+        catch (error) {
+            // Fall back to full reload on error
+            try {
+                await this.reload();
+            }
+            catch {
+                // Suppress nested error; original error will be thrown below
+            }
+            throw error;
+        }
+    }
+    /**
+     * Reconcile loaded extensions with the active profile.
+     * Loads extensions that should be enabled but aren't, and unloads extensions that shouldn't be.
+     * Falls back to full reload if any individual load/unload fails.
+     */
+    async reconcileLoadedExtensions() {
+        if (this.isStreaming) {
+            throw new Error("Cannot reconcile extensions while the agent is streaming or a tool call is active");
+        }
+        if (this.isCompacting) {
+            throw new Error("Cannot reconcile extensions while context compaction or branch summarization is active");
+        }
+        try {
+            // Get all discoverable extension paths
+            const allDiscoverablePaths = await this._resourceLoader.getDiscoverableExtensionPaths();
+            // Get the target enabled set based on profile filters
+            const targetEnabledSet = new Set();
+            for (const path of allDiscoverablePaths) {
+                if (this.settingsManager.isResourceAllowedByProfile("extensions", path)) {
+                    targetEnabledSet.add(path);
+                }
+            }
+            // Get currently loaded set
+            const loadedExtensions = this._resourceLoader.getExtensions().extensions;
+            const loadedSet = new Set();
+            for (const ext of loadedExtensions) {
+                loadedSet.add(ext.path);
+            }
+            // Collect unloads and loads
+            const toUnload = [];
+            const toLoad = [];
+            for (const path of loadedSet) {
+                if (!targetEnabledSet.has(path)) {
+                    toUnload.push(path);
+                }
+            }
+            for (const path of targetEnabledSet) {
+                if (!loadedSet.has(path)) {
+                    toLoad.push(path);
+                }
+            }
+            // Apply unloads first, then loads, to minimize churn
+            // Collect errors but continue through all operations
+            const errors = [];
+            for (const path of toUnload) {
+                try {
+                    await this.unloadExtensionLive(path);
+                }
+                catch (error) {
+                    errors.push(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+            for (const path of toLoad) {
+                try {
+                    await this.loadExtensionLive(path);
+                }
+                catch (error) {
+                    errors.push(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+            // If any errors occurred, throw the first one (already fell back to full reload in load/unload)
+            if (errors.length > 0) {
+                throw errors[0];
+            }
+            // Single notification at the end
+            this._notifyExtensionsChanged();
+        }
+        catch (error) {
+            // Fall back to full reload on error
+            try {
+                await this.reload();
+            }
+            catch {
+                // Suppress nested error; original error will be thrown below
+            }
+            throw error;
+        }
+    }
     // =========================================================================
     // Auto-Retry
     // =========================================================================