@linkshell/host 0.4.90 → 0.4.92

package/dist/host/src/drivers/codex/driver.d.ts

@@ -95,6 +95,8 @@ export declare class CodexDriver implements AgentDriver {
     private readonly goalRevision;
     private skillsRevision;
     private models?;
+    private modelsLoadedAt?;
+    private lastModels;
     private restartTimer?;
     private restartDelay;
     private stopped;
@@ -268,12 +270,14 @@ export declare class CodexDriver implements AgentDriver {
     private sideUpdate;
     private markFullAccess;
     private approvePending;
-    /** From the app-server the driver keeps running: its model list (cached) and the configuration a thread started in `cwd` reads. */
+    /** Refresh when a client opens the picker; a long-running host must pick up models added since its first session. */
     listModels(cwd?: string, model?: string): Promise<import("@linkshell/wire").MethodResult<"agents.models">>;
     /** The model config.toml (with the project's own layers, for `cwd`) gives a new thread; undefined: Codex's default. */
     private configuredSettings;
     private loadModels;
     private announceConfig;
+    private clearModels;
+    private publishConfig;
     private isNews;
     private loadSkills;
     /** What `/` offers on a device: the commands above, then the skills this project can use. */

package/dist/host/src/drivers/codex/driver.js

@@ -172,6 +172,8 @@ export class CodexDriver {
     goalRevision = new Map();
     skillsRevision = 0;
     models;
+    modelsLoadedAt;
+    lastModels = [];
     restartTimer;
     restartDelay;
     stopped = false;
@@ -257,6 +259,7 @@ export class CodexDriver {
             clearTimeout(timer);
         this.taskPolls.clear();
         this.stopped = true;
+        this.clearModels();
         if (this.restartTimer)
             clearTimeout(this.restartTimer);
         for (const timer of this.followRetries.values())
@@ -888,6 +891,10 @@ export class CodexDriver {
     watched(nativeId, open) {
         if (open) {
             this.watching.add(nativeId);
+            // The hub can keep a session attached after its last viewer leaves.
+            // Reopening it must also refresh the choices sent in ls_config.
+            if (this.attached.has(nativeId) || this.observed.has(nativeId))
+                void this.announceConfig(nativeId);
             void this.syncTasks(nativeId);
             this.cancelRelease(nativeId);
         }
@@ -1601,9 +1608,9 @@ export class CodexDriver {
             this.host?.update(this.id, threadId, { sessionUpdate: "ls_permission_resolved", requestId, optionId });
         }
     }
-    /** From the app-server the driver keeps running: its model list (cached) and the configuration a thread started in `cwd` reads. */
+    /** Refresh when a client opens the picker; a long-running host must pick up models added since its first session. */
     async listModels(cwd, model) {
-        const [models, configured] = await Promise.all([this.loadModels(true), this.configuredSettings(cwd)]);
+        const [models, configured] = await Promise.all([this.loadModels(true, true), this.configuredSettings(cwd)]);
         const listed = newThreadModels(models, configured.model);
         const selected = model && listed.models.some((entry) => entry.value === model) ? model : undefined;
         return { ...listed, config: configOptions(configured, selected ? { model: selected } : {}, models).filter((option) => option.category === "mode" || option.category === "effort") };
@@ -1620,33 +1627,66 @@ export class CodexDriver {
             return {};
         }
     }
-    loadModels(strict = false) {
-        this.models ??= (async () => {
-            const models = [];
-            const cursors = new Set();
-            let cursor;
-            do {
-                const result = await this.rpc("model/list", { includeHidden: false, ...(cursor ? { cursor } : {}) });
-                models.push(...result.data);
-                cursor = result.nextCursor ?? undefined;
-                if (cursor && cursors.has(cursor))
-                    throw new Error("Codex 返回了重复的模型分页，请重试");
-                if (cursor)
-                    cursors.add(cursor);
-            } while (cursor);
-            return models;
-        })()
-            .catch((error) => {
+    loadModels(strict = false, refresh = false) {
+        // Concurrent pickers share the same request. Internal configuration updates can
+        // reuse its result, while the next explicit listing reads the agent again.
+        if (this.modelsLoadedAt !== undefined && (refresh || Date.now() - this.modelsLoadedAt >= 60_000))
             this.models = undefined;
-            this.host?.log(`[codex] model/list failed: ${error instanceof Error ? error.message : String(error)}`);
-            if (error instanceof RpcError && error.code === RPC_METHOD_NOT_FOUND)
-                return [];
-            throw error;
-        });
-        return strict ? this.models : this.models.catch(() => []);
+        if (!this.models) {
+            this.modelsLoadedAt = undefined;
+            const loading = (async () => {
+                const models = [];
+                const cursors = new Set();
+                let cursor;
+                do {
+                    const result = await this.rpc("model/list", { includeHidden: false, ...(cursor ? { cursor } : {}) });
+                    models.push(...result.data);
+                    cursor = result.nextCursor ?? undefined;
+                    if (cursor && cursors.has(cursor))
+                        throw new Error("Codex 返回了重复的模型分页，请重试");
+                    if (cursor)
+                        cursors.add(cursor);
+                } while (cursor);
+                return models;
+            })()
+                .then((models) => {
+                if (this.models === loading) {
+                    this.modelsLoadedAt = Date.now();
+                    this.lastModels = models;
+                    // An existing composer reads ls_config, not agents.models. Keep its
+                    // current selection while publishing newly discovered choices.
+                    for (const nativeId of this.watching) {
+                        if (this.attached.has(nativeId) || this.observed.has(nativeId))
+                            this.publishConfig(nativeId, models);
+                    }
+                }
+                return models;
+            })
+                .catch((error) => {
+                if (this.models === loading)
+                    this.models = undefined;
+                this.host?.log(`[codex] model/list failed: ${error instanceof Error ? error.message : String(error)}`);
+                if (error instanceof RpcError && error.code === RPC_METHOD_NOT_FOUND)
+                    return [];
+                throw error;
+            });
+            this.models = loading;
+        }
+        return strict ? this.models : this.models.catch(() => this.lastModels);
     }
     async announceConfig(nativeId) {
+        // Permissions and Plan still come from this session when the catalogue
+        // is unavailable; keep its last model choices while publishing new settings.
         const models = await this.loadModels();
+        if (!this.stopped)
+            this.publishConfig(nativeId, models);
+    }
+    clearModels() {
+        this.models = undefined;
+        this.modelsLoadedAt = undefined;
+        this.lastModels = [];
+    }
+    publishConfig(nativeId, models) {
         const options = configOptions(this.settings.get(nativeId) ?? {}, this.overridesOf(nativeId), models);
         if (options.length > 0 && this.isNews(`config:${nativeId}`, options))
             this.host?.update(this.id, nativeId, { sessionUpdate: "ls_config", options });
@@ -1849,7 +1889,7 @@ export class CodexDriver {
         });
     }
     onDown(reason) {
-        this.models = undefined;
+        this.clearModels();
         this.skills.clear();
         if (this.stopped)
             return;