@caupulican/pi-adaptative 0.80.53 → 0.80.55

package/dist/core/agent-session.js

@@ -32,6 +32,7 @@ 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 { resolveProfileModelSettings } from "./model-resolver.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { stripResourceProfileBlocks } from "./resource-profile-blocks.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
@@ -109,6 +110,8 @@ export class AgentSession {
     _allowedToolNames;
     _excludedToolNames;
     _toolProfileFilter;
+    _isExplicitModel;
+    _isExplicitThinking;
     _baseToolsOverride;
     _sessionStartEvent;
     _extensionUIContext;
@@ -145,6 +148,8 @@ export class AgentSession {
         this._toolProfileFilter = config.toolProfileFilter
             ? { allow: config.toolProfileFilter.allow ?? [], block: config.toolProfileFilter.block ?? [] }
             : undefined;
+        this._isExplicitModel = config.isExplicitModel ?? false;
+        this._isExplicitThinking = config.isExplicitThinking ?? false;
         this._baseToolsOverride = config.baseToolsOverride;
         this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
         // Always subscribe to agent events for internal handling
@@ -2123,6 +2128,41 @@ export class AgentSession {
         const filter = this.settingsManager.getResourceProfileFilter("tools");
         return { allow: filter.allow ?? [], block: filter.block ?? [] };
     }
+    /**
+     * 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
+     * explicit launch flag — so live profile edits apply on reload without clobbering an explicit
+     * --model/--thinking. A no-op for profiles that don't bind a model.
+     */
+    async _reapplyActiveProfileModelSettings() {
+        if (this._isExplicitModel && this._isExplicitThinking)
+            return;
+        const activeProfileNames = this.settingsManager.getActiveResourceProfileNames();
+        if (activeProfileNames.length === 0)
+            return;
+        const profileSettings = resolveProfileModelSettings({
+            activeProfileNames,
+            registry: this.settingsManager.getProfileRegistry(),
+            modelRegistry: this._modelRegistry,
+            cwd: this._cwd,
+        });
+        if (!this._isExplicitModel && profileSettings.model) {
+            const current = this.agent.state.model;
+            const next = profileSettings.model;
+            if (!current || current.provider !== next.provider || current.id !== next.id) {
+                // Mirror the startup/cycle path: set the model directly (no auth gate, no settings
+                // persist) so re-applying the profile model behaves like initial resolution rather
+                // than a runtime model switch. No model_select emit here — reload rebuilds the
+                // extension runtime and emits session_start("reload") right after, and the UI
+                // re-renders from session.model.
+                this.agent.state.model = next;
+                this.sessionManager.appendModelChange(next.provider, next.id);
+            }
+        }
+        if (!this._isExplicitThinking && profileSettings.thinkingLevel) {
+            this.setThinkingLevel(profileSettings.thinkingLevel);
+        }
+    }
     _refreshToolRegistry(options) {
         const previousRegistryNames = new Set(this._toolRegistry.keys());
         const previousActiveToolNames = this.getActiveToolNames();
@@ -2324,6 +2364,10 @@ export class AgentSession {
             // active profile's tools allow/block — or switching the active profile — would not
             // apply on /reload and allowed tools would stay missing.
             this._toolProfileFilter = this._deriveToolProfileFilter();
+            // Re-apply the active profile's model/thinking from the freshly reloaded settings, so a live
+            // profile edit (or switch) takes effect on /reload. Skipped when the launch used an explicit
+            // --model/--thinking flag, which must win over the profile across reloads.
+            await this._reapplyActiveProfileModelSettings();
             await this._resourceLoader.reload({ failOnExtensionErrors: true, deferExtensionDispose: true });
             resetApiProviders();
             this._buildRuntime({