@caupulican/pi-adaptative 0.80.81 → 0.80.83

package/dist/modes/interactive/interactive-mode.js

@@ -5150,6 +5150,7 @@ export class InteractiveMode {
                 autonomy: this.settingsManager.getAutonomySettings(),
                 autonomyScope: projectSettings.autonomy ? "project" : "global",
                 modelRouter: this.settingsManager.getModelRouterSettings(),
+                modelRouterScope: projectSettings.modelRouter ? "project" : "global",
                 autoLearn: this.settingsManager.getAutoLearnSettings(),
                 autoLearnScope: projectSettings.autoLearn ? "project" : "global",
                 autoLearnModelOptions: this.getAutoLearnModelOptions(),
@@ -5293,6 +5294,17 @@ export class InteractiveMode {
                     this.applyAutonomyMode(settings.mode ?? "off", scope);
                     this.showStatus(`Autonomy mode ${settings.mode ?? "off"} saved to ${scope}. Use /autonomy status.`);
                 },
+                onModelRouterChange: (settings, scope) => {
+                    this.settingsManager.setModelRouterSettings(settings, scope);
+                    for (const value of [settings.cheapModel, settings.expensiveModel, settings.learningModel]) {
+                        const validationMessage = this.validateAutoLearnModelValue(value);
+                        if (validationMessage) {
+                            this.showWarning(validationMessage.replace("Auto Learn model", "Model router model"));
+                        }
+                    }
+                    this.updateAutoLearnFooter();
+                    this.showStatus(`Model Router settings saved to ${scope}. Use /session or /usage to inspect routing.`);
+                },
                 onAutoLearnChange: (settings, scope) => {
                     this.settingsManager.setAutoLearnSettings(settings, scope);
                     const validationMessage = this.validateAutoLearnModelValue(settings.model);
@@ -5556,8 +5568,14 @@ export class InteractiveMode {
             return;
         }
         try {
+            const profileModel = await this.selectProfileModelForCreate();
+            if (profileModel === undefined) {
+                void this.openLibraryManagerFlow();
+                return;
+            }
             this.settingsManager.setProfileDefinition(trimmed, {
                 name: trimmed,
+                model: profileModel ?? undefined,
                 resources: {},
             }, "directory");
             await this.applyProfile(trimmed);
@@ -5932,10 +5950,37 @@ export class InteractiveMode {
             this.showError(`Profile/situation "${trimmed}" already exists`);
             return this.createProfileFlow();
         }
+        const profileModel = await this.selectProfileModelForCreate();
+        if (profileModel === undefined) {
+            this.ui.requestRender();
+            return;
+        }
         // Open the resource editor on the NEW profile
-        void this.openNewProfileEditor(trimmed);
+        void this.openNewProfileEditor(trimmed, profileModel ?? undefined);
+    }
+    async selectProfileModelForCreate() {
+        const modelOptions = [
+            {
+                value: "(none)",
+                label: "(none)",
+                description: "Do not pin a foreground profile model; use the session/default model",
+            },
+            ...this.getAutoLearnModelOptions(),
+        ];
+        return await new Promise((resolve) => {
+            this.showSelector((done) => {
+                const selector = new SelectSubmenu("Profile Model", "Pick the foreground model for this profile from authenticated/configured providers.", modelOptions, "(none)", (value) => {
+                    done();
+                    resolve(value === "(none)" ? null : value);
+                }, () => {
+                    done();
+                    resolve(undefined);
+                });
+                return { component: selector, focus: selector.getSelectList() };
+            });
+        });
     }
-    async openNewProfileEditor(profileName) {
+    async openNewProfileEditor(profileName, profileModel) {
         const scope = "reusable-file";
         const kinds = await this.getProfileResourceKinds();
         this.showSelector((done) => {
@@ -5952,6 +5997,7 @@ export class InteractiveMode {
                     try {
                         this.settingsManager.setProfileDefinition(profileName, {
                             name: profileName,
+                            model: profileModel,
                             resources,
                         }, scope);
                         this.showStatus(`Saved profile "${profileName}" to ${scope}.`);
@@ -5970,17 +6016,17 @@ export class InteractiveMode {
                     const resolvedEditPath = resolveResourceEditPath(id, pathValue, kind);
                     if (!resolvedEditPath) {
                         this.showWarning(`Resource "${id}" of kind "${kind}" has no editable file path.`);
-                        void this.openNewProfileEditor(profileName);
+                        void this.openNewProfileEditor(profileName, profileModel);
                         return;
                     }
                     if (!fs.existsSync(resolvedEditPath)) {
                         this.showError(`Resolved path for "${id}" does not exist: ${resolvedEditPath}`);
-                        void this.openNewProfileEditor(profileName);
+                        void this.openNewProfileEditor(profileName, profileModel);
                         return;
                     }
                     await this.openEditorForPath(resolvedEditPath);
                     await this.handleReloadCommand();
-                    void this.openNewProfileEditor(profileName);
+                    void this.openNewProfileEditor(profileName, profileModel);
                 },
             });
             return { component: editor, focus: editor };