@ordewell/core 0.10.3 → 0.10.4

package/dist/index.mjs

@@ -6406,7 +6406,7 @@ var CODEX_MANIFEST = {
     }
   },
   modelDiscovery: {
-    // Codex has no `codex models` subcommand (see docs/adr/0004). Discovery
+    // Codex has no `codex models` subcommand (see ADR-0004). Discovery
     // tries three sources in order, each falling through to the next:
     //
     // 1. `codex app-server` stdio JSON-RPC (`initialize` → `model/list`) —
@@ -6508,9 +6508,11 @@ function parseOpenCodeModelsVerbose(stdout, manifest) {
       variants: variantIds.map((id) => ({ id, label: id.charAt(0).toUpperCase() + id.slice(1) }))
     });
   }
-  if (models.length === 0) return [];
-  const prefOrder = preferred?.map((p) => p.id) ?? [];
-  models.sort((a, b) => {
+  return preferredFirst(models, manifest);
+}
+function preferredFirst(models, manifest) {
+  const prefOrder = manifest.modelDiscovery.preferredPatterns?.map((p) => p.id) ?? [];
+  return [...models].sort((a, b) => {
     const ai = prefOrder.indexOf(a.modelId);
     const bi = prefOrder.indexOf(b.modelId);
     if (ai >= 0 && bi >= 0) return ai - bi;
@@ -6518,7 +6520,36 @@ function parseOpenCodeModelsVerbose(stdout, manifest) {
     if (bi >= 0) return 1;
     return a.modelId.localeCompare(b.modelId);
   });
-  return models;
+}
+function parseOpenCodeModelsApi(stdout, manifest) {
+  let data;
+  try {
+    data = JSON.parse(stdout)?.data;
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(data)) return [];
+  const prefLabels = new Map((manifest.modelDiscovery.preferredPatterns ?? []).map((p) => [p.id, p.label]));
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  for (const entry of data) {
+    if (!entry || typeof entry.providerID !== "string" || typeof entry.modelID !== "string") continue;
+    if (entry.enabled === false) continue;
+    const fullId = `${entry.providerID}/${entry.modelID}`;
+    if (seen.has(fullId)) continue;
+    seen.add(fullId);
+    const variantIds = Array.isArray(entry.variants) ? entry.variants.flatMap((v) => {
+      const id = v?.id;
+      return typeof id === "string" && id ? [id] : [];
+    }) : [];
+    models.push({
+      modelId: fullId,
+      modelLabel: prefLabels.get(fullId) || typeof entry.name === "string" && entry.name || entry.modelID,
+      runnerProvider: entry.providerID,
+      variants: variantIds.map((id) => ({ id, label: id.charAt(0).toUpperCase() + id.slice(1) }))
+    });
+  }
+  return preferredFirst(models, manifest);
 }
 
 // src/plugins/builtin/opencode.manifest.ts
@@ -6534,13 +6565,17 @@ var OPENCODE_MANIFEST = {
   modelDiscovery: {
     method: "command",
     discoveryCommands: [
+      // v1 prints per-model variants under --verbose; v2 rejects the flag (a
+      // fast non-zero exit) and serves the same catalog, variants included, over
+      // `api model.list`. v1 is asked first so it never reaches the `api` form.
       { command: "opencode", args: ["models", "--verbose"], parser: parseOpenCodeModelsVerbose },
+      { command: "opencode", args: ["api", "model.list"], parser: parseOpenCodeModelsApi },
       { command: "opencode", args: ["models"], parser: parseOpenCodeModels }
     ],
     // No fallbackModels: the list must always reflect what `opencode models`
     // actually reports for THIS user (their configured providers only). A
     // hardcoded fallback previously leaked models the user didn't have.
-    // No static variants — per-model variants are fetched from opencode models --verbose
+    // No static variants — per-model variants come from the first two commands above
     providerQualifiedIds: true
   },
   contextFile: "AGENTS.md",
@@ -14059,6 +14094,7 @@ function parseCodexModelsCache(content) {
   }
 }
 var GEMINI_MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var NEGATIVE_TTL_MS = 6e4;
 function geminiDiscoveryCacheKey(apiKey) {
   const dir = globalDataDir();
   const hash = apiKey.slice(-8);
@@ -14188,26 +14224,33 @@ async function discoverFromApi(manifest, config, fetchImpl) {
     return null;
   }
 }
+function wasKilled(err) {
+  return !!err && typeof err === "object" && err.killed === true;
+}
 async function discoverFromCommand(manifest, execImpl) {
   const discovery = manifest.modelDiscovery;
   const commands = discovery.discoveryCommands ?? [
     { command: discovery.command, args: discovery.args || [], parser: discovery.parser }
   ];
   const runCommands = async () => {
+    let timedOut2 = false;
     for (const cmd of commands) {
       try {
         const { stdout } = await execImpl(`${cmd.command} ${cmd.args.join(" ")}`, { timeout: 45e3 });
         const models = parseModelOutput(stdout, cmd.parser, manifest);
-        if (models.length > 0) return applyVariants(mergeCanonicalAliases(models, manifest), manifest);
-      } catch {
+        if (models.length > 0) return { models: applyVariants(mergeCanonicalAliases(models, manifest), manifest), timedOut: timedOut2 };
+      } catch (err) {
+        if (wasKilled(err)) timedOut2 = true;
       }
     }
-    return null;
+    return { models: null, timedOut: timedOut2 };
   };
   const first = await runCommands();
-  if (first) return { models: first, fromFallback: false };
-  const second = await runCommands();
-  if (second) return { models: second, fromFallback: false };
+  if (first.models) return { models: first.models, fromFallback: false };
+  if (first.timedOut) {
+    const second = await runCommands();
+    if (second.models) return { models: second.models, fromFallback: false };
+  }
   return { models: applyVariants(buildFallbackModels(manifest), manifest), fromFallback: true };
 }
 function mergeCanonicalAliases(discovered, manifest) {
@@ -14244,16 +14287,33 @@ function parseLineByLine(stdout) {
 }
 var ModelDiscovery = class {
   cache = /* @__PURE__ */ new Map();
+  /**
+   * Degraded results (a fallback list, or empty) remembered for
+   * {@link NEGATIVE_TTL_MS}. They are deliberately not cached — a transient
+   * failure must heal — but re-running a failing CLI on every lookup is the
+   * other extreme.
+   */
+  misses = /* @__PURE__ */ new Map();
+  /**
+   * Discoveries still running, so a second lookup of the same runner joins the
+   * first instead of spawning the CLI again. A slow CLI is the case this
+   * exists for: a planner switch and a runner-list refresh land inside one
+   * another's wait, and two `opencode models` calls race each other for the
+   * same background service.
+   */
+  inflight = /* @__PURE__ */ new Map();
   registry;
   execImpl;
   fetchImpl;
   appServerClient;
   readFileImpl;
-  constructor(registry, execImpl = defaultExec2, fetchImpl, appServerClient = defaultAppServerClient, readFileImpl) {
+  now;
+  constructor(registry, execImpl = defaultExec2, fetchImpl, appServerClient = defaultAppServerClient, readFileImpl, now = Date.now) {
     this.registry = registry;
     this.execImpl = execImpl;
     this.fetchImpl = fetchImpl;
     this.appServerClient = appServerClient;
+    this.now = now;
     this.readFileImpl = readFileImpl ?? ((filePath) => {
       try {
         return fsSync3.readFileSync(filePath.replace(/^~/, osMod.homedir()), "utf8");
@@ -14297,10 +14357,20 @@ var ModelDiscovery = class {
     const runnerLabel = manifest.displayName || runner;
     return models.map((m) => ({ ...m, runnerId: runner, runnerLabel }));
   }
-  async discoverRaw(runner) {
-    if (this.cache.has(runner)) {
-      return this.cache.get(runner);
-    }
+  discoverRaw(runner) {
+    const cached2 = this.cache.get(runner);
+    if (cached2) return Promise.resolve(cached2);
+    const remembered = this.misses.get(runner);
+    if (remembered && this.now() - remembered.at < NEGATIVE_TTL_MS) return Promise.resolve(remembered.models);
+    const running = this.inflight.get(runner);
+    if (running) return running;
+    const started = this.discoverUncached(runner).finally(() => {
+      if (this.inflight.get(runner) === started) this.inflight.delete(runner);
+    });
+    this.inflight.set(runner, started);
+    return started;
+  }
+  async discoverUncached(runner) {
     const manifest = this.registry.getManifest(runner);
     if (!manifest) {
       return [];
@@ -14332,10 +14402,13 @@ var ModelDiscovery = class {
       models = buildFallbackModels(manifest);
     }
     if (cacheable && models.length > 0) this.cache.set(runner, models);
+    else this.misses.set(runner, { models, at: this.now() });
     return models;
   }
   clear() {
     this.cache.clear();
+    this.misses.clear();
+    this.inflight.clear();
   }
   /** Whatever `discover()` has already cached for `runner` — never triggers discovery. */
   getCached(runner) {
@@ -25021,15 +25094,15 @@ var ModelResolver = class {
     return toOrchestratorOptions({}, ORCHESTRATOR_SHORTCUTS);
   }
   async modelsForRunners(runners) {
-    const out = {};
-    for (const runner of runners) {
+    const unique = [...new Set(runners)];
+    const discovered = await Promise.all(unique.map(async (runner) => {
       try {
-        out[runner] = await this.discovery.discover(runner);
+        return [runner, await this.discovery.discover(runner)];
       } catch {
-        out[runner] = [];
+        return [runner, []];
       }
-    }
-    return out;
+    }));
+    return Object.fromEntries(discovered);
   }
   async pickerOptions() {
     if (this.cachedPickerOptions) return this.cachedPickerOptions;
@@ -25116,24 +25189,28 @@ var defaultExec3 = async (command, options) => {
   return { stdout: String(stdout) };
 };
 var CHECK_TIMEOUT_MS = 8e3;
+var NEGATIVE_TTL_MS2 = 6e4;
 var RunnerInstallation = class {
   cache = /* @__PURE__ */ new Map();
   inflight = /* @__PURE__ */ new Map();
   registry;
   execImpl;
-  constructor(registry, execImpl = defaultExec3) {
+  now;
+  constructor(registry, execImpl = defaultExec3, now = Date.now) {
     this.registry = registry;
     this.execImpl = execImpl;
+    this.now = now;
   }
   /** True if the runner's CLI responds to `--version`. Cached per process. */
   async isInstalled(runner) {
-    if (this.cache.has(runner)) return this.cache.get(runner);
+    const cached2 = this.cache.get(runner);
+    if (cached2 && (cached2.installed || this.now() - cached2.at < NEGATIVE_TTL_MS2)) return cached2.installed;
     const existing = this.inflight.get(runner);
     if (existing) return existing;
     const manifest = this.registry.getManifest(runner);
     const command = manifest?.runner.command;
     if (!command) {
-      this.cache.set(runner, false);
+      this.cache.set(runner, { installed: false, at: this.now() });
       return false;
     }
     const probe = (async () => {
@@ -25144,13 +25221,22 @@ var RunnerInstallation = class {
         return false;
       }
     })().then((installed) => {
-      this.cache.set(runner, installed);
+      this.cache.set(runner, { installed, at: this.now() });
       this.inflight.delete(runner);
       return installed;
     });
     this.inflight.set(runner, probe);
     return probe;
   }
+  /**
+   * Forget cached "not installed" verdicts so the next probe re-runs them. A
+   * runner-list refresh calls this, so a CLI installed while the host runs is
+   * offered without a restart. An installed verdict stays: it cannot have
+   * changed without the binary going away, and re-probing one costs a spawn.
+   */
+  refresh() {
+    for (const [runner, probe] of this.cache) if (!probe.installed) this.cache.delete(runner);
+  }
   /**
    * Whether this runner can serve as a harness planner (ADR-0009, T9), and why
    * not when it cannot. Surfaces call this to grey out an unusable agent in the