subconscious-cli 6.0.0 → 6.1.0

package/bin/feedback.js

@@ -9,14 +9,25 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import readline from 'node:readline';
 import { createInterface } from 'node:readline/promises';
-import { c } from './colors.js';
 import { getApiKey, getPlatformUrl } from './auth.js';
 import { imageContentType, readClipboardImage } from './clipboard-image.js';
+import { c } from './colors.js';
 import { DEFAULT_PROFILE } from './profiles.js';
 
 export const FEEDBACK_API_PATH = '/api/cli/feedback';
 export const SUPPORT_EMAIL = 'support@subconscious.dev';
 
+function feedbackOptionValue(argv, index) {
+  const value = argv[index + 1];
+  if (
+    value === undefined ||
+    /^(?:--[A-Za-z][\w-]*|-[A-Za-z])(?:=|$)/.test(value)
+  ) {
+    throw new Error(`${argv[index]} requires a value`);
+  }
+  return value;
+}
+
 /**
  * Parses feedback command arguments. Shared with tests.
  *
@@ -31,15 +42,15 @@ export function parseFeedbackArgs(argv = []) {
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === '-s' || arg === '--subject') {
-      subject = argv[++i] ?? '';
+      subject = feedbackOptionValue(argv, i++);
     } else if (arg.startsWith('--subject=')) {
       subject = arg.slice('--subject='.length);
     } else if (arg === '-m' || arg === '--message') {
-      message = argv[++i] ?? '';
+      message = feedbackOptionValue(argv, i++);
     } else if (arg.startsWith('--message=')) {
       message = arg.slice('--message='.length);
     } else if (arg === '--image') {
-      images.push(argv[++i] ?? '');
+      images.push(feedbackOptionValue(argv, i++));
     } else if (arg.startsWith('--image=')) {
       images.push(arg.slice('--image='.length));
     } else if (arg !== '') {
@@ -64,12 +75,19 @@ export async function collectFeedbackContext(options = {}) {
   };
 }
 
-export function buildFeedbackPayload({ subject, message, context, attachments }) {
+export function buildFeedbackPayload({
+  subject,
+  message,
+  context,
+  attachments,
+}) {
   const payload = {
     subject: subject || 'CLI feedback',
     message,
     context: Object.fromEntries(
-      Object.entries(context ?? {}).filter(([, value]) => Boolean(String(value).trim())),
+      Object.entries(context ?? {}).filter(([, value]) =>
+        Boolean(String(value).trim()),
+      ),
     ),
   };
   if (attachments?.length) payload.attachments = attachments;
@@ -79,7 +97,8 @@ export function buildFeedbackPayload({ subject, message, context, attachments })
 export async function loadFeedbackImages(paths) {
   const attachments = [];
   for (const filePath of paths) {
-    if (!filePath?.trim()) throw new Error('An image path is required after --image');
+    if (!filePath?.trim())
+      throw new Error('An image path is required after --image');
     const buffer = await fs.readFile(filePath);
     const contentType = imageContentType(buffer);
     if (!contentType) throw new Error(`${filePath} is not a JPEG or PNG`);
@@ -88,7 +107,12 @@ export async function loadFeedbackImages(paths) {
   return attachments;
 }
 
-export async function submitFeedback(apiKey, platformUrl, payload, fetchImpl = fetch) {
+export async function submitFeedback(
+  apiKey,
+  platformUrl,
+  payload,
+  fetchImpl = fetch,
+) {
   const res = await fetchImpl(
     `${platformUrl.replace(/\/$/, '')}${FEEDBACK_API_PATH}`,
     {
@@ -164,7 +188,9 @@ function readAttachmentLine(onPaste) {
 async function promptForAttachments(already = 0) {
   if (process.stdin.isTTY !== true || already >= MAX_FEEDBACK_IMAGES) return [];
   const attachments = [];
-  console.log(`\n  Attachments (optional). Ctrl+V pastes a screenshot from the clipboard.`);
+  console.log(
+    `\n  Attachments (optional). Ctrl+V pastes a screenshot from the clipboard.`,
+  );
   console.log(`  ${c.dim}Press Enter when you are done.${c.reset}`);
   while (already + attachments.length < MAX_FEEDBACK_IMAGES) {
     const line = await readAttachmentLine(async () => {
@@ -172,11 +198,15 @@ async function promptForAttachments(already = 0) {
       const buffer = await readClipboardImage();
       const contentType = buffer ? imageContentType(buffer) : null;
       if (!contentType || !buffer) {
-        console.log(`\n  ${c.yellow}No JPEG or PNG image on the clipboard.${c.reset}`);
+        console.log(
+          `\n  ${c.yellow}No JPEG or PNG image on the clipboard.${c.reset}`,
+        );
         return;
       }
       attachments.push({ contentType, data: buffer.toString('base64') });
-      console.log(`  ${c.green}Added screenshot ${already + attachments.length}.${c.reset}`);
+      console.log(
+        `  ${c.green}Added screenshot ${already + attachments.length}.${c.reset}`,
+      );
     });
     if (line == null || !line.trim()) break;
   }
@@ -186,7 +216,8 @@ async function promptForAttachments(already = 0) {
 async function promptForFeedback(argv) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
-    const subject = argv.subject || (await rl.question(`\n  Subject (optional): `)).trim();
+    const subject =
+      argv.subject || (await rl.question(`\n  Subject (optional): `)).trim();
     let message = '';
     while (!message) {
       message = (await rl.question(`  Message: `)).trim();
@@ -208,7 +239,9 @@ export async function feedbackCommand(argv = [], options = {}) {
   const auth = await getApiKey(options.profile);
   if (!auth) {
     console.log(`\n  ${c.dim}Not logged in.${c.reset}`);
-    console.log(`  Run ${c.cyan}subc ${profileFlag}login${c.reset} to get started.\n`);
+    console.log(
+      `  Run ${c.cyan}subc ${profileFlag}login${c.reset} to get started.\n`,
+    );
     return;
   }
 
@@ -216,7 +249,9 @@ export async function feedbackCommand(argv = [], options = {}) {
   if (!feedback.message) {
     if (process.stdin.isTTY !== true) {
       console.error(`\n  ${c.red}A message is required.${c.reset}`);
-      console.error(`  Pass one with ${c.cyan}subc feedback --message "..."${c.reset}\n`);
+      console.error(
+        `  Pass one with ${c.cyan}subc feedback --message "..."${c.reset}\n`,
+      );
       process.exitCode = 1;
       return;
     }
@@ -224,7 +259,10 @@ export async function feedbackCommand(argv = [], options = {}) {
   }
 
   const fromFlags = await loadFeedbackImages(parsed.images);
-  const fromPrompt = feedback.message && parsed.message ? [] : await promptForAttachments(fromFlags.length);
+  const fromPrompt =
+    feedback.message && parsed.message
+      ? []
+      : await promptForAttachments(fromFlags.length);
   const platformUrl = getPlatformUrl(options.profile);
   const payload = buildFeedbackPayload({
     subject: feedback.subject,
@@ -237,9 +275,13 @@ export async function feedbackCommand(argv = [], options = {}) {
     const res = await submitFeedback(auth.key, platformUrl, payload);
 
     if (res.status === 404) {
-      console.error(`\n  ${c.yellow}This platform has no feedback endpoint (404).${c.reset}`);
+      console.error(
+        `\n  ${c.yellow}This platform has no feedback endpoint (404).${c.reset}`,
+      );
       console.error(`  ${c.dim}Host: ${platformUrl}${c.reset}`);
-      console.error(`  ${c.dim}Point PLATFORM_URL at a platform that includes /api/cli/feedback.${c.reset}\n`);
+      console.error(
+        `  ${c.dim}Point PLATFORM_URL at a platform that includes /api/cli/feedback.${c.reset}\n`,
+      );
       process.exitCode = 1;
       return;
     }
@@ -253,14 +295,18 @@ export async function feedbackCommand(argv = [], options = {}) {
 
     if (!res.ok) {
       const detail = typeof data?.error === 'string' ? data.error : '';
-      const invalidKey = detail === 'Invalid or revoked API key' || detail === 'No API key provided';
+      const invalidKey =
+        detail === 'Invalid or revoked API key' ||
+        detail === 'No API key provided';
       console.log(`\n  ${c.red}✗ Couldn't send your message.${c.reset}`);
       if (invalidKey) {
         console.log(
           `  Run ${c.cyan}subc ${profileFlag}logout${c.reset} then ${c.cyan}subc ${profileFlag}login${c.reset} to re-authenticate.`,
         );
       }
-      console.log(`  Please email ${c.cyan}${SUPPORT_EMAIL}${c.reset} directly.\n`);
+      console.log(
+        `  Please email ${c.cyan}${SUPPORT_EMAIL}${c.reset} directly.\n`,
+      );
       process.exitCode = 1;
       return;
     }
@@ -269,12 +315,16 @@ export async function feedbackCommand(argv = [], options = {}) {
     console.log(`  ${c.dim}Our support team will get back to you.\n`);
   } catch (error) {
     if (error.name === 'TimeoutError' || error.name === 'AbortError') {
-      console.log(`\n  ${c.yellow}Could not reach the platform (timed out).${c.reset}`);
+      console.log(
+        `\n  ${c.yellow}Could not reach the platform (timed out).${c.reset}`,
+      );
       console.log(`  ${c.dim}Host: ${platformUrl}${c.reset}`);
     } else {
       console.log(`\n  ${c.red}✗ Couldn't send your message.${c.reset}`);
     }
-    console.log(`  Please email ${c.cyan}${SUPPORT_EMAIL}${c.reset} directly.\n`);
+    console.log(
+      `  Please email ${c.cyan}${SUPPORT_EMAIL}${c.reset} directly.\n`,
+    );
     process.exitCode = 1;
   }
 }

package/bin/harness-manifest.js

@@ -0,0 +1,286 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import {
+  AGENTS,
+  agentBinary,
+  agentCommandName,
+  agentInputs,
+  installCommands,
+  RUNBOOK_DIR,
+  resolveRefs,
+  staticLookup,
+} from './agent-data.js';
+import { RUNBOOK_ENV_DESCRIPTION } from './agents.js';
+import { CLAUDE_PICKER_ENV_DESCRIPTION } from './claude-picker.js';
+import { c } from './colors.js';
+import { buildOpenCodeConfig } from './opencode-provider.js';
+
+// Bump on any change that can break a reader: a renamed or removed field, or a
+// changed meaning. Adding a field does not need a bump.
+export const HARNESS_MANIFEST_SCHEMA_VERSION = 1;
+
+export const MANIFEST_TOKENS = {
+  '{baseUrl}': 'Gateway origin, without a trailing slash.',
+  '{baseUrlV1}': 'Gateway origin followed by /v1.',
+  '{apiKey}': "The agent's API key input when set, otherwise API_KEY.",
+  '{model}': 'Launch model ID.',
+  '${NAME}':
+    'Value of env var NAME at launch. The manifest replaces it with the default when NAME is an input or env entry; a reference followed by / drops trailing slashes.',
+  '{catalog}': 'Every live catalog model ID, newline-separated.',
+  '{catalog[N]}':
+    'Catalog model at index N, clamped to the last entry; {model} when the catalog is empty.',
+  '{args}': 'Arguments passed through from subc, after its own flags.',
+  '{config}':
+    'config_flag NAME=VALUE for each cli-config entry whose condition holds.',
+  '{prompt}': 'The task given to subc <agent> headless PROMPT.',
+  '{sessionId}': 'A local session ID, for launch.resume.',
+  '{sessionFile}': "A local session's file, or its ID when it has none.",
+  '{tempFile}':
+    'Temporary file the runbook writes; the matching config entry says whether it is removed.',
+  '{tmp}': 'System temporary directory.',
+  '{opencodeConfig}':
+    'The OpenCode config document shown in the env-json config entry.',
+  '{claudeSettings}': 'JSON document described by the --settings config entry.',
+  '{target}':
+    'Release target triple, one of install.targets or install.windows_targets.',
+  '{binDir}': "Directory the agent's binary was found in.",
+  '{PATH}': "The caller's PATH.",
+  '<install dirs>': 'Common install directories subc adds to PATH.',
+  '<agent key>': 'The agent-specific API key input, for example CODEX_API_KEY.',
+  '<id>': 'Any model ID in the catalog; the field repeats for each model.',
+  'models[]': 'Every element of the models array.',
+  '<runbook>': 'Absolute path of the installed bin/runbook directory.',
+  '<VS Code user dir>':
+    'The VS Code user settings directory, for example ~/Library/Application Support/Code/User.',
+};
+
+const PACKAGE_URL = new URL('../package.json', import.meta.url);
+
+function conditionText(when) {
+  return Object.entries(when)
+    .map(([name, test]) =>
+      test === 'set'
+        ? `${name} non-empty`
+        : test === 'empty'
+          ? `${name} empty`
+          : `${name} != ${test.not}`,
+    )
+    .join(' and ');
+}
+
+/** The OpenCode config with placeholders, built by the launch code itself. */
+function openCodeConfigDocument(lookup) {
+  const document = buildOpenCodeConfig({
+    baseUrl: '{baseUrl}',
+    model: '{model}',
+    modelIds: ['<id>'],
+    context: lookup('OPENCODE_CONTEXT_LIMIT'),
+    output: lookup('OPENCODE_OUTPUT_LIMIT'),
+  });
+  // The manifest is the same on every platform, so a Windows path keeps `/`.
+  const portable = (file) =>
+    file.startsWith(RUNBOOK_DIR)
+      ? `<runbook>/${path.relative(RUNBOOK_DIR, file).split(path.sep).join('/')}`
+      : file;
+  return { ...document, plugin: document.plugin.map(portable) };
+}
+
+function resolver(agent) {
+  const lookup = staticLookup(agent);
+  return (value) =>
+    value === '{opencodeConfig}'
+      ? openCodeConfigDocument(lookup)
+      : resolveRefs(value, lookup);
+}
+
+function inputEntry(input, resolve) {
+  return input.default === undefined
+    ? input
+    : { ...input, default: resolve(input.default) };
+}
+
+function exportedEnv(input, resolve) {
+  return {
+    name: input.name,
+    value: String(resolve(input.default)),
+    override: [input.name, ...(input.aliases || [])],
+    description: input.description,
+  };
+}
+
+function envEntries(agent, resolve) {
+  const inputs = agentInputs(agent).filter((input) => input.export);
+  const own = agent.env.map((entry) => ({
+    ...entry,
+    value:
+      entry.value === '{opencodeConfig}'
+        ? entry.value
+        : String(resolve(entry.value)),
+    override: entry.override || [],
+  }));
+  const launcher =
+    agent.id === 'claude-code' ? CLAUDE_PICKER_ENV_DESCRIPTION : [];
+  return [
+    ...inputs.map((input) => exportedEnv(input, resolve)),
+    ...own,
+    ...launcher,
+  ];
+}
+
+function inputBehindRef(agent, value) {
+  const name = /^\$\{([A-Z_][A-Z0-9_]*)\}$/.exec(value ?? '')?.[1];
+  return name && agentInputs(agent).find((input) => input.name === name);
+}
+
+/** Where a value that reads an input can be changed: its env names and flag. */
+function overrideFor(input) {
+  return [
+    input.name,
+    ...(input.aliases || []),
+    ...(input.flag ? [input.flag] : []),
+  ];
+}
+
+function configEntry(agent, entry, resolve) {
+  const { when, ...rest } = entry;
+  const out = { ...rest };
+  if ('value' in entry) out.value = resolve(entry.value);
+  const input = inputBehindRef(agent, entry.value);
+  if (input) out.override = overrideFor(input);
+  if (when) out.condition = conditionText(when);
+  return out;
+}
+
+/** A knob that reads an input says where the value comes from and its bounds. */
+function knob(agent, setting, resolve) {
+  const input = inputBehindRef(agent, setting.value);
+  const value = resolve(setting.value);
+  const out = {
+    ...setting,
+    value: setting.kind === 'env' ? String(value) : value,
+  };
+  if (input && !setting.override) out.override = overrideFor(input);
+  if (input && setting.range)
+    out.range = { min: input.min, max: input.max, ...setting.range };
+  return out;
+}
+
+function capabilities(agent, resolve) {
+  const { compaction, ...rest } = agent.capabilities;
+  const knobs = Object.fromEntries(
+    ['on', 'off', 'threshold'].map((mode) => [
+      mode,
+      knob(agent, compaction[mode], resolve),
+    ]),
+  );
+  return { ...resolve(rest), compaction: { ...compaction, ...knobs } };
+}
+
+function harnessEntry(agent) {
+  const resolve = resolver(agent);
+  const { runbook } = agent;
+  const script = (name) => (name ? `${agent.id}/${name}` : null);
+  return {
+    id: agent.id,
+    name: agent.name,
+    command: `subc ${agentCommandName(agent)}`,
+    aliases: agent.aliases,
+    mode: runbook.mode,
+    protocol: agent.protocol,
+    runbook: {
+      dir: agent.id,
+      launch: script(runbook.script),
+      setup: script(runbook.setup_script),
+      setup_actions: runbook.setup_actions || [],
+    },
+    binary: agentBinary(agent),
+    install: { ...agent.install, commands: installCommands(agent) },
+    prerequisites: agent.prerequisites,
+    launch: agent.launch ?? null,
+    inputs: agentInputs(agent).map((input) => inputEntry(input, resolve)),
+    env: envEntries(agent, resolve),
+    config: agent.config.map((entry) => configEntry(agent, entry, resolve)),
+    capabilities: capabilities(agent, resolve),
+  };
+}
+
+/** The manifest, computed from the agent files this subc ships. */
+export function loadHarnessManifest() {
+  return {
+    schema_version: HARNESS_MANIFEST_SCHEMA_VERSION,
+    cli_version: JSON.parse(readFileSync(PACKAGE_URL, 'utf-8')).version,
+    cli_package: 'subconscious-cli',
+    tokens: MANIFEST_TOKENS,
+    runbook_env: RUNBOOK_ENV_DESCRIPTION,
+    harnesses: Object.fromEntries(
+      AGENTS.map((agent) => [agent.id, harnessEntry(agent)]),
+    ),
+  };
+}
+
+export function printHarnessManifestHelp() {
+  console.log(`
+Usage:
+  subc harness-manifest [--json]
+  subc harness-manifest help
+
+Print how this subc version installs, configures, and launches each coding
+harness: install source, binary, env vars, config files, compaction knobs,
+MCP, headers, and hooks.
+
+  --json   Print the full manifest as JSON. This is the default when stdout
+           is not a terminal; in a terminal, a summary table is printed.
+`);
+}
+
+function compactionSummary(compaction) {
+  const supported = ['on', 'off', 'threshold'].filter(
+    (mode) => compaction[mode]?.set_by_subc,
+  );
+  return supported.length ? supported.join(',') : '-';
+}
+
+function tableRows(manifest) {
+  return Object.values(manifest.harnesses).map((harness) => [
+    harness.id,
+    harness.binary || '-',
+    harness.install.package || harness.install.repository || '-',
+    String(harness.env.length),
+    compactionSummary(harness.capabilities.compaction),
+    String(harness.capabilities.hooks.length),
+  ]);
+}
+
+function printTable(manifest) {
+  const header = ['harness', 'binary', 'install', 'env', 'compaction', 'hooks'];
+  const rows = tableRows(manifest);
+  const widths = header.map((title, index) =>
+    Math.max(title.length, ...rows.map((row) => row[index].length)),
+  );
+  const line = (cells) =>
+    `  ${cells.map((cell, index) => cell.padEnd(widths[index])).join('  ')}`;
+  console.log(
+    `\n  ${c.bold}Harness manifest${c.reset} ${c.dim}schema ${manifest.schema_version}, subc ${manifest.cli_version}${c.reset}\n`,
+  );
+  console.log(`${c.dim}${line(header)}${c.reset}`);
+  for (const row of rows) console.log(line(row));
+  console.log(
+    `\n  ${c.dim}compaction lists the modes subc sets. Use --json for every field.${c.reset}\n`,
+  );
+}
+
+export function harnessManifestCommand(args = [], options = {}) {
+  const unknown = args.filter((arg) => arg !== '--json');
+  if (unknown.length) {
+    throw new Error(
+      `Unknown argument: ${unknown[0]}. Try subc harness-manifest help.`,
+    );
+  }
+  const isTTY = options.isTTY ?? process.stdout.isTTY === true;
+  const manifest = loadHarnessManifest();
+  if (args.includes('--json') || !isTTY) {
+    process.stdout.write(`${JSON.stringify(manifest, null, 2)}\n`);
+    return;
+  }
+  printTable(manifest);
+}

package/bin/headless-args.js

@@ -0,0 +1,35 @@
+const SUBC_PROFILE_FLAGS = new Set(['-p', '--profile']);
+const SUBC_INLINE_FLAGS = ['--model=', '--profile='];
+
+/** Whether `--model` consumes the word after it. An empty word is a value. */
+export function takesModelValue(value) {
+  return value !== undefined && !value.startsWith('-');
+}
+
+/**
+ * Index of the headless prompt when `argv` (the words after the agent name)
+ * asks for a headless run, otherwise -1. Only subc's own flags may come
+ * before "headless"; later on it is an ordinary agent argument.
+ */
+export function headlessPromptIndex(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (SUBC_PROFILE_FLAGS.has(arg)) {
+      i++;
+      continue;
+    }
+    if (arg === '--model') {
+      if (takesModelValue(argv[i + 1])) i++;
+      continue;
+    }
+    if (SUBC_INLINE_FLAGS.some((prefix) => arg.startsWith(prefix))) continue;
+    return arg === 'headless' ? i + 1 : -1;
+  }
+  return -1;
+}
+
+/** Index of the first "--" separator; a headless prompt of "--" is not one. */
+export function separatorIndex(argv) {
+  const prompt = headlessPromptIndex(argv);
+  return argv.findIndex((arg, index) => arg === '--' && index !== prompt);
+}

package/bin/launch-values.js

@@ -0,0 +1,25 @@
+import { DEFAULTS, PACKAGED_MODELS } from './agent-data.js';
+
+const MODEL_ID = /^[-A-Za-z0-9._:/+]+$/;
+
+/** The launch model first, then the catalog, deduplicated and validated. */
+export function modelIds(env) {
+  const catalog = (
+    env.SUBCONSCIOUS_MODELS?.trim() || PACKAGED_MODELS.join('\n')
+  ).split(/\r?\n/);
+  const models = [
+    ...new Set([env.MODEL?.trim() || DEFAULTS.model, ...catalog]),
+  ].filter(Boolean);
+  for (const model of models)
+    if (!MODEL_ID.test(model)) throw new Error(`Invalid model id: ${model}`);
+  return models;
+}
+
+export function positiveInteger(input, name) {
+  if (
+    !/^[1-9][0-9]*$/.test(String(input)) ||
+    !Number.isSafeInteger(Number(input))
+  )
+    throw new Error(`${name} must be a positive integer`);
+  return Number(input);
+}

package/bin/model-capabilities.js

@@ -1,11 +1,15 @@
-import { readFileSync } from 'node:fs';
-
-// The models endpoint currently supplies IDs, not modality metadata. Keep
-// explicit capabilities in the same registry used to generate the Unix lookup.
-const { modelCapabilities = {} } = JSON.parse(
-  readFileSync(new URL('./registry.generated.json', import.meta.url), 'utf8'),
-);
+import { MODEL_CAPABILITIES } from './agent-data.js';
 
+// The models endpoint supplies IDs, not modality metadata, so capabilities
+// are listed by exact model ID: similarly named models inherit nothing.
 export function modelSupportsVision(modelId) {
-  return Object.hasOwn(modelCapabilities, modelId) && modelCapabilities[modelId].vision === true;
+  return (
+    Object.hasOwn(MODEL_CAPABILITIES, modelId) &&
+    MODEL_CAPABILITIES[modelId].vision === true
+  );
+}
+
+/** Vision model IDs, newline-separated, for the runbooks' shell lookup. */
+export function visionModelList() {
+  return Object.keys(MODEL_CAPABILITIES).filter(modelSupportsVision).join('\n');
 }

package/bin/models.js

@@ -99,31 +99,33 @@ export async function fetchGatewayModels({
     if (signal?.aborted) throw abortError('Model discovery was cancelled');
     const aborted = new Promise((_, reject) => {
       const fail = () => {
-        if (signal?.aborted) reject(abortError('Model discovery was cancelled'));
-        else reject(new Error(`Model discovery timed out after ${timeoutMs}ms`));
+        if (signal?.aborted)
+          reject(abortError('Model discovery was cancelled'));
+        else
+          reject(new Error(`Model discovery timed out after ${timeoutMs}ms`));
       };
       controller.signal.addEventListener('abort', fail, { once: true });
     });
-    const response = await Promise.race([
-      fetchImpl(endpoint, {
+    const discover = async () => {
+      const response = await fetchImpl(endpoint, {
         method: 'GET',
         headers,
         cache: 'no-store',
         signal: controller.signal,
-      }),
-      aborted,
-    ]);
+      });
 
-    if (!response.ok) {
-      throw new Error(`Model discovery returned HTTP ${response.status}`);
-    }
+      if (!response.ok) {
+        throw new Error(`Model discovery returned HTTP ${response.status}`);
+      }
 
-    const payload = await response.json();
-    if (!Array.isArray(payload?.data)) {
-      throw new Error('Model discovery returned an invalid response');
-    }
+      const payload = await response.json();
+      if (!Array.isArray(payload?.data)) {
+        throw new Error('Model discovery returned an invalid response');
+      }
 
-    return normalizeModelIds(payload.data.map((model) => model?.id));
+      return normalizeModelIds(payload.data.map((model) => model?.id));
+    };
+    return await Promise.race([discover(), aborted]);
   } catch (error) {
     if (signal?.aborted) throw abortError('Model discovery was cancelled');
     if (controller.signal.aborted) {
@@ -144,13 +146,17 @@ async function fetchPublicModels({ baseUrl, fetchImpl, timeoutMs, signal }) {
     timeoutMs,
     signal,
   });
-  if (!models.length) throw new Error('Model discovery returned no usable model IDs');
+  if (!models.length)
+    throw new Error('Model discovery returned no usable model IDs');
   return models;
 }
 
 function packagedCatalog(selectedModel, fallbackModels, error) {
   return {
-    models: normalizeModelIds([selectedModel, ...fallbackModels], selectedModel),
+    models: normalizeModelIds(
+      [selectedModel, ...fallbackModels],
+      selectedModel,
+    ),
     source: 'packaged',
     error,
   };
@@ -189,7 +195,12 @@ export async function resolveModelCatalog({
     } catch (availableError) {
       if (isAbortError(availableError) || signal?.aborted) throw availableError;
       try {
-        const discovered = await fetchPublicModels({ baseUrl, fetchImpl, timeoutMs, signal });
+        const discovered = await fetchPublicModels({
+          baseUrl,
+          fetchImpl,
+          timeoutMs,
+          signal,
+        });
         return liveCatalog(discovered, selectedModel, 'public');
       } catch (publicError) {
         if (isAbortError(publicError) || signal?.aborted) throw publicError;
@@ -199,7 +210,12 @@ export async function resolveModelCatalog({
   }
 
   try {
-    const discovered = await fetchPublicModels({ baseUrl, fetchImpl, timeoutMs, signal });
+    const discovered = await fetchPublicModels({
+      baseUrl,
+      fetchImpl,
+      timeoutMs,
+      signal,
+    });
     return liveCatalog(discovered, selectedModel, 'public');
   } catch (error) {
     if (isAbortError(error) || signal?.aborted) throw error;