pi-web-ui 0.60.0 → 0.61.0

package/dist/server/agent-service.js

@@ -733,6 +733,8 @@ export class ClientSession {
             }
         }
         await cs.bindSession();
+        await cs.restoreProjectProviderKeysForCwd(cwd);
+        await cs.restoreProjectModelForCwd(cwd);
         return cs;
     }
     /**
@@ -928,6 +930,9 @@ export class ClientSession {
         // Reconnect: push the background-task list — it must survive reconnects
         // and outlive the conversation that started the tasks.
         this.bg.push();
+        // Reconnect: push the built-in provider key list (multi-key grouping in the
+        // model picker needs it even before the client asks).
+        this.modelAdmin.listProviderKeys();
         // PTYs are conversation-owned and survive a socket reconnect.
         this.pushTerminals();
     }
@@ -1813,6 +1818,120 @@ export class ClientSession {
     deleteModelConfig(providerId) {
         return this.modelAdmin.deleteModelConfig(providerId);
     }
+    listProviderKeys() {
+        return this.modelAdmin.listProviderKeys();
+    }
+    async addProviderKey(provider, apiKey, name) {
+        await this.modelAdmin.addProviderKey(provider, apiKey, name);
+        const active = this.modelAdmin.getActiveKeyName(provider);
+        if (active)
+            this.stateStore.saveProjectProviderKey(this.clientId, this.cwd, provider, active);
+    }
+    async activateProviderKey(provider, keyName) {
+        await this.modelAdmin.activateProviderKey(provider, keyName);
+        this.stateStore.saveProjectProviderKey(this.clientId, this.cwd, provider, keyName);
+    }
+    async removeProviderKey(provider, keyName) {
+        await this.modelAdmin.removeProviderKey(provider, keyName);
+        const saved = this.stateStore.getProjectProviderKey(this.clientId, this.cwd, provider);
+        if (saved === keyName) {
+            const active = this.modelAdmin.getActiveKeyName(provider);
+            if (active)
+                this.stateStore.saveProjectProviderKey(this.clientId, this.cwd, provider, active);
+            else
+                this.stateStore.deleteProjectProviderKey(this.clientId, this.cwd, provider);
+        }
+    }
+    /** Restore per-project provider keys when entering a project. For each
+     *  provider that has a saved key for `cwd`, activate it if it differs from
+     *  the current global active. Silent — no notice spam on project switch. */
+    async restoreProjectProviderKeysForCwd(cwd) {
+        const saved = this.stateStore.getProjectProviderKeys(this.clientId, cwd);
+        if (!saved)
+            return;
+        for (const [provider, keyName] of Object.entries(saved)) {
+            const cur = this.modelAdmin.getActiveKeyName(provider);
+            if (cur === keyName)
+                continue;
+            try {
+                await this.modelAdmin.activateProviderKey(provider, keyName);
+            }
+            catch {
+                // saved key may have been deleted — ignore
+            }
+        }
+    }
+    /** When a model is set, ensure its provider's per-project key is restored. */
+    async restoreKeyForModel(modelId, cwd) {
+        const slash = modelId.indexOf("/");
+        if (slash <= 0)
+            return;
+        const provider = modelId.slice(0, slash);
+        const saved = this.stateStore.getProjectProviderKey(this.clientId, cwd, provider);
+        if (!saved)
+            return;
+        const cur = this.modelAdmin.getActiveKeyName(provider);
+        if (cur === saved)
+            return;
+        try {
+            await this.modelAdmin.activateProviderKey(provider, saved);
+        }
+        catch { }
+    }
+    /** Remember the just-selected model (and the key that was active for its
+     *  provider) for the current project. Called IMMEDIATELY on model selection —
+     *  not only after a turn — so switching back to the project restores the exact
+     *  {model, key} left behind, even for a fresh conversation with no assistant
+     *  message yet (the SDK only flushes a model_change to disk once one exists). */
+    rememberProjectModel(modelId) {
+        const cwd = this.cwd;
+        this.stateStore.saveProjectModel(this.clientId, cwd, modelId);
+        const slash = modelId.indexOf("/");
+        if (slash <= 0)
+            return;
+        const provider = modelId.slice(0, slash);
+        const active = this.modelAdmin.getActiveKeyName(provider);
+        if (active)
+            this.stateStore.saveProjectProviderKey(this.clientId, cwd, provider, active);
+    }
+    /** Restore the project's remembered model (and its provider's key) onto the
+     *  ACTIVE conversation — but ONLY for a conversation the user hasn't really
+     *  started (no messages yet). A conversation that already has content keeps its
+     *  own per-session model: switching back to a RUNNING / completed chat must not
+     *  silently overwrite its model with the project default. So a fresh chat in the
+     *  project gets the remembered model; an in-progress one keeps what it had and
+     *  the user switches via the picker. Silent on failure (model no longer in catalog). */
+    async restoreProjectModelForCwd(cwd) {
+        const savedModel = this.stateStore.getProjectModel(this.clientId, cwd);
+        if (!savedModel)
+            return;
+        try {
+            if (this.conv.session.getSessionStats().totalMessages > 0)
+                return;
+        }
+        catch {
+            return;
+        }
+        try {
+            const mr = this.runtime.services.modelRuntime;
+            const slash = savedModel.indexOf("/");
+            if (slash <= 0 || slash === savedModel.length - 1)
+                return;
+            const model = mr.getModel(savedModel.slice(0, slash), savedModel.slice(slash + 1));
+            if (!model)
+                return;
+            const cur = this.session.model;
+            const curId = cur ? `${cur.provider}/${cur.id}` : null;
+            // Restore the model's provider key first so setModel's auth check passes.
+            await this.restoreKeyForModel(savedModel, cwd);
+            if (curId === savedModel)
+                return;
+            await this.session.setModel(model);
+        }
+        catch {
+            // model no longer resolvable / key gone — keep the conversation default
+        }
+    }
     // ---------------------------------------------------------------------------
     // Settings (system prompt / skills / extensions / presets)
     // ---------------------------------------------------------------------------
@@ -2266,6 +2385,9 @@ export class ClientSession {
             if (prevModel && this.sharedModelRuntime) {
                 try {
                     await this.session.setModel(prevModel);
+                    const p = prevModel.provider;
+                    const mid = `${p}/${prevModel.id}`;
+                    await this.restoreKeyForModel(mid, this.cwd);
                 }
                 catch {
                     // model no longer resolvable — keep the default
@@ -2363,6 +2485,8 @@ export class ClientSession {
         void this.pushSlashCommands();
         if (cwdChanged) {
             this.cwd = newCwd;
+            await this.restoreProjectProviderKeysForCwd(newCwd);
+            await this.restoreProjectModelForCwd(newCwd);
             // Mirror set_cwd's project-switch side-effects so the whole UI follows
             // the new workspace, not just the chat pane.
             try {
@@ -2645,6 +2769,8 @@ export class ClientSession {
                 this.removeConversation(displaced.id);
             await this.bindSession();
             this.cwd = targetCwd;
+            await this.restoreProjectProviderKeysForCwd(targetCwd);
+            await this.restoreProjectModelForCwd(targetCwd);
             this.conv.lastActiveAt = Date.now();
             this.webUi.refresh();
             this.emitConversations();
@@ -2746,6 +2872,8 @@ export class ClientSession {
             if (prevModel && this.sharedModelRuntime) {
                 try {
                     await this.session.setModel(prevModel);
+                    const pm = prevModel;
+                    await this.restoreKeyForModel(`${pm.provider}/${pm.id}`, this.cwd);
                 }
                 catch {
                     // model no longer resolvable — keep the default
@@ -2861,7 +2989,13 @@ export class ClientSession {
     }
     async cycleModel() {
         try {
-            await this.session.cycleModel();
+            const result = await this.session.cycleModel();
+            if (result?.model) {
+                const mid = `${result.model.provider}/${result.model.id}`;
+                await this.restoreKeyForModel(mid, this.cwd);
+                // Remember per-project like setModel — cycling is also a model switch.
+                this.rememberProjectModel(mid);
+            }
         }
         catch (err) {
             this.emit({
@@ -2942,6 +3076,8 @@ export class ClientSession {
             this.conv.promptedSinceActive = false;
             this.conv.lastActiveAt = Date.now();
             this.cwd = abs;
+            await this.restoreProjectProviderKeysForCwd(abs);
+            await this.restoreProjectModelForCwd(abs);
             // 工作区跟随型插件（编辑器文件树等）同步切根。
             try {
                 this.onCwdChanged?.(abs);
@@ -3041,6 +3177,11 @@ export class ClientSession {
             if (!model)
                 throw new Error(`模型不存在：${modelId}`);
             await this.session.setModel(model);
+            await this.restoreKeyForModel(modelId, this.cwd);
+            // Immediately remember the model + the key it uses for the current
+            // project (not only after a turn). This is what makes project switching
+            // restore both the model and the provider key.
+            this.rememberProjectModel(modelId);
         }
         catch (err) {
             this.emit({

package/dist/server/client-state.js

@@ -231,4 +231,56 @@ export class ClientStateStore {
         state.presets = presets;
         this.save();
     }
+    /** Get per-project provider keys for a cwd, or undefined. */
+    getProjectProviderKeys(clientId, cwd) {
+        return this.load()[clientId]?.projectProviderKeys?.[cwd];
+    }
+    /** Get a single provider's saved key for a project. */
+    getProjectProviderKey(clientId, cwd, provider) {
+        return this.load()[clientId]?.projectProviderKeys?.[cwd]?.[provider];
+    }
+    /** Remember which key was last used for a provider in a project. */
+    saveProjectProviderKey(clientId, cwd, provider, keyName) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        const map = (state.projectProviderKeys ??= {});
+        const inner = (map[cwd] ??= {});
+        inner[provider] = keyName;
+        this.save();
+    }
+    /** Delete a per-project provider key (e.g. when the key is removed). */
+    deleteProjectProviderKey(clientId, cwd, provider) {
+        const all = this.load();
+        const inner = all[clientId]?.projectProviderKeys?.[cwd];
+        if (!inner || !(provider in inner))
+            return;
+        delete inner[provider];
+        if (Object.keys(inner).length === 0) {
+            delete all[clientId].projectProviderKeys[cwd];
+        }
+        this.save();
+    }
+    /** Get the model the user last selected in a project, or undefined. */
+    getProjectModel(clientId, cwd) {
+        return this.load()[clientId]?.projectModels?.[cwd];
+    }
+    /** Remember the model last selected in a project (immediate, not after a turn). */
+    saveProjectModel(clientId, cwd, modelId) {
+        const all = this.load();
+        const state = (all[clientId] ??= { projects: [] });
+        (state.projectModels ??= {})[cwd] = modelId;
+        this.save();
+    }
+    /** Drop the per-project model memory for a project (e.g. when the model is
+     *  removed from the catalog). */
+    deleteProjectModel(clientId, cwd) {
+        const all = this.load();
+        const map = all[clientId]?.projectModels;
+        if (!map || !(cwd in map))
+            return;
+        delete map[cwd];
+        if (Object.keys(map).length === 0)
+            delete all[clientId].projectModels;
+        this.save();
+    }
 }

package/dist/server/dsh/dsh-agent-service.js

@@ -2526,6 +2526,18 @@ export class DshClientSession {
             ],
         });
     }
+    listProviderKeys() {
+        this.emit({ type: "provider_keys", keys: {} });
+    }
+    async addProviderKey(provider, apiKey, name) {
+        this.emit({ type: "notice", level: "warning", text: "DSH 引擎不支持多密钥" });
+    }
+    async activateProviderKey(provider, keyName) {
+        this.emit({ type: "notice", level: "warning", text: "DSH 引擎不支持多密钥" });
+    }
+    async removeProviderKey(provider, keyName) {
+        this.emit({ type: "notice", level: "warning", text: "DSH 引擎不支持多密钥" });
+    }
     async fetchModelsList(reqId, baseUrl, apiKey, authHeader, api) {
         this.emit({ type: "fetch_models_result", reqId, ok: false, error: "DSH 引擎不支持自定义 provider 探测" });
     }
@@ -2533,7 +2545,9 @@ export class DshClientSession {
         this.emit({ type: "refresh_provider_result", reqId, ok: false, error: "DSH 引擎不支持自定义 provider" });
     }
     async cloneProvider(provider, reqId) {
-        this.emit({ type: "clone_provider_result", reqId, ok: false, error: "DSH 引擎不支持自定义 provider" });
+        const error = "DSH 引擎不支持自定义 provider";
+        this.emit({ type: "notice", level: "error", text: error });
+        this.emit({ type: "clone_provider_result", reqId, ok: false, error });
     }
     // -----------------------------------------------------------------------
     // 其他

package/dist/server/index.js

@@ -694,6 +694,18 @@ wss.on("connection", (ws) => {
             case "clone_provider":
                 void cs.cloneProvider(msg.provider, msg.reqId);
                 break;
+            case "list_provider_keys":
+                cs.listProviderKeys();
+                break;
+            case "add_provider_key":
+                void cs.addProviderKey(msg.provider, msg.apiKey, msg.name);
+                break;
+            case "activate_provider_key":
+                void cs.activateProviderKey(msg.provider, msg.keyName);
+                break;
+            case "remove_provider_key":
+                void cs.removeProviderKey(msg.provider, msg.keyName);
+                break;
             case "terminal_create": {
                 const tm = cs.getTerminalManager(msg.conversationId);
                 if (tm)