loom-agent 1.2.0

package/src/providers/nvidia.js

@@ -0,0 +1,85 @@
+const { createOpenAICompatProvider } = require('./openai-compat');
+const { getApiKey } = require('../config/settings');
+
+function getKey() {
+  return getApiKey('nvidia') || process.env.NVIDIA_API_KEY || process.env.NVIDIA_NIM_API_KEY;
+}
+
+// Model IDs below are a curated subset of NVIDIA's live GET /v1/models registry
+// (fetched 2026-08-13). Stale IDs — e.g. meta/llama-3.1-405b-instruct,
+// deepseek-ai/deepseek-v4-flash, minimax-ai/minimax-m2.7 — return 404/410 and
+// were deliberately removed. Re-verify against /v1/models before adding any ID.
+const provider = {
+  ...createOpenAICompatProvider({
+    getKey,
+    providerId: 'nvidia',
+    envKeyHint: 'NVIDIA',
+  }),
+  models: [
+  // ── DeepSeek ──
+  { id: 'deepseek-ai/deepseek-v4-flash-0731', name: 'DeepSeek V4 Flash', provider: 'nvidia', tags: ['free', 'fast'], context: 200000, priceIn: 0, priceOut: 0 },
+  { id: 'deepseek-ai/deepseek-coder-6.7b-instruct', name: 'DeepSeek Coder 6.7B', provider: 'nvidia', tags: ['coding'], context: 16384, priceIn: 0.10, priceOut: 0.10 },
+
+  // ── Meta Llama ──
+  { id: 'meta/llama-3.1-8b-instruct', name: 'Llama 3.1 8B Instruct', provider: 'nvidia', tags: ['fast'], context: 128000, priceIn: 0.05, priceOut: 0.08 },
+  { id: 'meta/llama-3.1-70b-instruct', name: 'Llama 3.1 70B Instruct', provider: 'nvidia', tags: ['general'], context: 128000, priceIn: 0.35, priceOut: 0.40 },
+  { id: 'meta/llama-3.2-3b-instruct', name: 'Llama 3.2 3B Instruct', provider: 'nvidia', tags: ['fast'], context: 128000, priceIn: 0.02, priceOut: 0.02 },
+  { id: 'meta/llama-3.2-11b-vision-instruct', name: 'Llama 3.2 11B Vision', provider: 'nvidia', tags: ['vision', 'fast'], context: 128000, priceIn: 0.055, priceOut: 0.055 },
+  { id: 'meta/llama-3.2-90b-vision-instruct', name: 'Llama 3.2 90B Vision', provider: 'nvidia', tags: ['vision'], context: 128000, priceIn: 0.35, priceOut: 0.40 },
+  { id: 'meta/llama-3.3-70b-instruct', name: 'Llama 3.3 70B Instruct', provider: 'nvidia', tags: ['general'], context: 128000, priceIn: 0.35, priceOut: 0.40 },
+  { id: 'meta/codellama-70b', name: 'CodeLlama 70B', provider: 'nvidia', tags: ['coding'], context: 16384, priceIn: 0.30, priceOut: 0.30 },
+  { id: 'meta/muse-glimmer-30b', name: 'Llama Muse Glimmer 30B', provider: 'nvidia', tags: ['creative'], context: 32768, priceIn: 0.20, priceOut: 0.20 },
+
+  // ── NVIDIA Nemotron ──
+  { id: 'nvidia/llama-3.1-nemotron-70b-instruct', name: 'Llama 3.1 Nemotron 70B', provider: 'nvidia', tags: ['general'], context: 128000, priceIn: 0.35, priceOut: 0.40 },
+  { id: 'nvidia/llama-3.1-nemotron-ultra-253b-v1', name: 'Nemotron Ultra 253B', provider: 'nvidia', tags: ['frontier'], context: 128000, priceIn: 1.50, priceOut: 6.00 },
+  { id: 'nvidia/llama-3.3-nemotron-super-49b-v1', name: 'Nemotron Super 49B', provider: 'nvidia', tags: ['reasoning'], context: 128000, priceIn: 0.25, priceOut: 0.90 },
+  { id: 'nvidia/llama-3.3-nemotron-super-49b-v1.5', name: 'Nemotron Super 49B v1.5', provider: 'nvidia', tags: ['reasoning'], context: 128000, priceIn: 0.25, priceOut: 0.90 },
+  { id: 'nvidia/nemotron-3-ultra-550b-a55b', name: 'Nemotron 3 Ultra 550B', provider: 'nvidia', tags: ['frontier'], context: 256000, priceIn: 2.00, priceOut: 8.00 },
+  { id: 'nvidia/nemotron-3-super-120b-a12b', name: 'Nemotron 3 Super 120B', provider: 'nvidia', tags: ['frontier'], context: 256000, priceIn: 1.00, priceOut: 4.00 },
+  { id: 'nvidia/nemotron-3-nano-30b-a3b', name: 'Nemotron 3 Nano 30B', provider: 'nvidia', tags: ['fast'], context: 128000, priceIn: 0.10, priceOut: 0.40 },
+  { id: 'nvidia/nemotron-3-nano-omni-30b-a3b-reasoning', name: 'Nemotron 3 Nano Omni (Reasoning)', provider: 'nvidia', tags: ['reasoning', 'small'], context: 128000, priceIn: 0.10, priceOut: 0.40 },
+  { id: 'nvidia/nemotron-4-340b-instruct', name: 'Nemotron-4 340B Instruct', provider: 'nvidia', tags: ['frontier'], context: 4096, priceIn: 1.00, priceOut: 3.00 },
+  { id: 'nvidia/nemotron-mini-4b-instruct', name: 'Nemotron Mini 4B', provider: 'nvidia', tags: ['fast'], context: 32768, priceIn: 0.03, priceOut: 0.03 },
+  { id: 'nvidia/nemotron-nano-3-30b-a3b', name: 'Nemotron Nano 3 30B', provider: 'nvidia', tags: ['fast'], context: 128000, priceIn: 0.10, priceOut: 0.40 },
+  { id: 'nvidia/nemotron-nano-12b-v2-vl', name: 'Nemotron Nano 12B V2 VL', provider: 'nvidia', tags: ['vision'], context: 128000, priceIn: 0.10, priceOut: 0.40 },
+  { id: 'nvidia/nvidia-nemotron-nano-9b-v2', name: 'Nemotron Nano 9B V2', provider: 'nvidia', tags: ['fast'], context: 128000, priceIn: 0.05, priceOut: 0.20 },
+
+  // ── Mistral ──
+  { id: 'mistralai/mistral-7b-instruct-v0.3', name: 'Mistral 7B Instruct', provider: 'nvidia', tags: ['fast'], context: 32768, priceIn: 0.05, priceOut: 0.05 },
+  { id: 'mistralai/mistral-large', name: 'Mistral Large', provider: 'nvidia', tags: ['frontier'], context: 128000, priceIn: 2.00, priceOut: 6.00 },
+  { id: 'mistralai/mistral-large-2-instruct', name: 'Mistral Large 2 Instruct', provider: 'nvidia', tags: ['frontier'], context: 128000, priceIn: 2.00, priceOut: 6.00 },
+  { id: 'mistralai/codestral-22b-instruct-v0.1', name: 'Codestral 22B', provider: 'nvidia', tags: ['coding'], context: 32768, priceIn: 0.30, priceOut: 0.60 },
+  { id: 'mistralai/mixtral-8x22b-v0.1', name: 'Mixtral 8x22B', provider: 'nvidia', tags: [], context: 65536, priceIn: 0.60, priceOut: 0.60 },
+  { id: 'nv-mistralai/mistral-nemo-12b-instruct', name: 'Mistral NeMo 12B', provider: 'nvidia', tags: ['fast'], context: 128000, priceIn: 0.05, priceOut: 0.05 },
+
+  // ── Microsoft ──
+  { id: 'microsoft/phi-3.5-moe-instruct', name: 'Phi 3.5 MoE', provider: 'nvidia', tags: ['fast'], context: 128000, priceIn: 0.05, priceOut: 0.05 },
+  { id: 'microsoft/phi-3-vision-128k-instruct', name: 'Phi 3 Vision 128K', provider: 'nvidia', tags: ['vision'], context: 128000, priceIn: 0.05, priceOut: 0.05 },
+
+  // ── Google ──
+  { id: 'google/gemma-3-4b-it', name: 'Gemma 3 4B IT', provider: 'nvidia', tags: ['fast'], context: 32768, priceIn: 0.03, priceOut: 0.03 },
+  { id: 'google/gemma-3-12b-it', name: 'Gemma 3 12B IT', provider: 'nvidia', tags: ['general'], context: 128000, priceIn: 0.10, priceOut: 0.10 },
+  { id: 'google/gemma-4-31b-it', name: 'Gemma 4 31B IT', provider: 'nvidia', tags: ['general'], context: 32768, priceIn: 0.20, priceOut: 0.80 },
+  { id: 'google/codegemma-1.1-7b', name: 'CodeGemma 1.1 7B', provider: 'nvidia', tags: ['coding', 'fast'], context: 16384, priceIn: 0.05, priceOut: 0.05 },
+
+  // ── OpenAI ──
+  { id: 'openai/gpt-oss-120b', name: 'GPT-OSS 120B', provider: 'nvidia', tags: ['openai', 'general'], context: 131072, priceIn: 0.25, priceOut: 1.00 },
+  { id: 'openai/gpt-oss-20b', name: 'GPT-OSS 20B', provider: 'nvidia', tags: ['openai', 'fast'], context: 131072, priceIn: 0.10, priceOut: 0.30 },
+
+  // ── Other ──
+  { id: 'z-ai/glm-5.2', name: 'GLM-5.2', provider: 'nvidia', tags: [], context: 131072, priceIn: 0.30, priceOut: 1.20 },
+  { id: 'moonshotai/kimi-k2.6', name: 'Kimi K2.6', provider: 'nvidia', tags: [], context: 128000, priceIn: 0.20, priceOut: 0.80 },
+  { id: 'minimaxai/minimax-m3', name: 'MiniMax M3', provider: 'nvidia', tags: [], context: 200000, priceIn: 0.40, priceOut: 1.60 },
+  { id: 'poolside/laguna-xs-2.1', name: 'Laguna XS 2.1', provider: 'nvidia', tags: ['free', 'coding'], context: 131072, priceIn: 0, priceOut: 0 },
+  { id: 'stepfun-ai/step-3.7-flash', name: 'Step 3.7 Flash', provider: 'nvidia', tags: ['fast'], context: 128000, priceIn: 0.15, priceOut: 0.40 },
+  { id: '01-ai/yi-large', name: 'Yi Large', provider: 'nvidia', tags: [], context: 32768, priceIn: 0.30, priceOut: 0.90 },
+  { id: 'ai21labs/jamba-1.5-large-instruct', name: 'Jamba 1.5 Large', provider: 'nvidia', tags: [], context: 256000, priceIn: 0.20, priceOut: 0.80 },
+  { id: 'databricks/dbrx-instruct', name: 'DBRX Instruct', provider: 'nvidia', tags: [], context: 32768, priceIn: 0.60, priceOut: 0.60 },
+  { id: 'ibm/granite-3.0-8b-instruct', name: 'Granite 3.0 8B', provider: 'nvidia', tags: ['fast'], context: 32768, priceIn: 0.05, priceOut: 0.05 },
+  { id: 'ibm/granite-34b-code-instruct', name: 'Granite 34B Code', provider: 'nvidia', tags: ['coding'], context: 16384, priceIn: 0.20, priceOut: 0.20 },
+  { id: 'zyphra/zamba2-7b-instruct', name: 'Zamba2 7B', provider: 'nvidia', tags: ['fast'], context: 32768, priceIn: 0.05, priceOut: 0.05 },
+],
+};
+
+module.exports = provider;

package/src/providers/openai-compat.js

@@ -0,0 +1,269 @@
+/** @type {typeof import('openai').default} */
+const OpenAI = /** @type {any} */ (require('openai'));
+const { getBaseUrl } = require('../config/settings');
+
+function formatMessages(messages, options) {
+  const out = [];
+  // System prompt comes from options.system (session.systemPrompt).
+  if (options?.system) out.push({ role: 'system', content: options.system });
+  for (const m of messages) {
+    if (m.role === 'system') continue;
+    if (m.role === 'tool') {
+      out.push({ role: 'tool', tool_call_id: m.toolCallId, content: String(m.content) });
+      continue;
+    }
+    const msg = { role: m.role, content: m.content || '' };
+    if (m.toolCalls && m.toolCalls.length) {
+      msg.tool_calls = m.toolCalls.map(tc => ({
+        id: tc.id,
+        type: 'function',
+        function: { name: tc.name, arguments: typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input || {}) },
+      }));
+    }
+    out.push(msg);
+  }
+  return out;
+}
+
+function parseToolCalls(message) {
+  const toolCalls = [];
+  for (const tc of message.tool_calls || []) {
+    let input = {};
+    try { input = JSON.parse(tc.function.arguments || '{}'); } catch {}
+    toolCalls.push({ id: tc.id, name: tc.function.name, input });
+  }
+  return toolCalls;
+}
+
+function formatTools(tools) {
+  if (!tools || !tools.length) return undefined;
+  return tools.map(t => ({
+    type: 'function',
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.input_schema || { type: 'object', properties: {} },
+    },
+  }));
+}
+
+function buildRequest(messages, options) {
+  const body = {
+    model: options.model,
+    messages: formatMessages(messages, options),
+    tools: formatTools(options.tools),
+    max_tokens: options.maxTokens || 8192,
+    temperature: options.temperature ?? 0.7,
+  };
+  // Reasoning models (o1/o3/o4/gpt-5, tagged 'reasoning' by the session):
+  // push the effort to "high" so the model reasons deeply on every step —
+  // opencode-style multi-pass thinking. Other reasoning families (DeepSeek
+  // R1, Qwen QwQ, Kimi K2) emit reasoning_content on their own and don't
+  // accept the param, so only the OpenAI effort-capable ids get it. OpenAI
+  // effort models also reject a temperature != 1, so drop it.
+  if (options.reasoning && /^(o1|o3|o4|gpt-5)/.test(String(options.model || ''))) {
+    body.reasoning_effort = 'high';
+    // Reasoning models reject max_tokens; the limit moves to
+    // max_completion_tokens unchanged.
+    body.max_completion_tokens = body.max_tokens;
+    delete body.max_tokens;
+    delete body.temperature;
+  }
+  return body;
+}
+
+function normalize(resp) {
+  const choice = resp.choices?.[0];
+  const message = choice?.message || {};
+  const toolCalls = parseToolCalls(message);
+  return {
+    content: message.content || '',
+    toolCalls,
+    usage: resp.usage,
+  };
+}
+
+// Some providers (NVIDIA NIM, Akamai) return an HTML error page for bad model
+// IDs. Strip the tags so the TUI shows a readable line instead of raw markup.
+function sanitizeErrBody(msg) {
+  if (!msg || !/<\/?\w+[^>]*>/.test(msg)) return msg;
+  const stripped = String(msg)
+    .replace(/<title[^>]*>[\s\S]*?<\/title>/gi, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&#x27;|&#39;/g, "'")
+    .replace(/&quot;/g, '"')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return stripped || msg;
+}
+
+function wrapErr(err, modelId, envKeyHint, baseURL) {
+  const raw = err.message || 'Unknown error';
+  const msg = sanitizeErrBody(raw);
+  if (!err.status) return new Error(`${envKeyHint || 'API'} error: ${msg}`);
+  const status = Number(err.status);
+  const hint = String(envKeyHint || 'api').toLowerCase();
+  if (status === 401) {
+    return new Error(`${envKeyHint || 'API'} 401 Unauthorized: the API key is invalid or expired. Run /connect ${hint} and paste a new key.`);
+  }
+  if (status === 403) {
+    return new Error(`${envKeyHint || 'API'} 403 Forbidden: the API key is not authorized for ${modelId || 'this model'}. You may need to accept the model's terms on the provider site or use a key with access. Run /connect ${hint} to change the key.`);
+  }
+  if (status === 402) return new Error(`${envKeyHint || 'API'} quota exceeded (${err.status}). The model may not be available on your billing tier for model ${(modelId || '?')}.`);
+  if (status === 404) {
+    const modelHint = modelId ? ` ${modelId}` : '';
+    return new Error(`${envKeyHint || 'API'} 404: model${modelHint} does not exist (or was removed) on this provider. Try /models and pick a listed model, or /model ${modelId ? 'to switch' : ''}.`);
+  }
+  if (err.error && err.error.message) return new Error(`${envKeyHint || 'API'} error ${status}: ${sanitizeErrBody(err.error.message)}`);
+  if (err.body && err.body.message) return new Error(`${envKeyHint || 'API'} error ${status}: ${sanitizeErrBody(err.body.message)}`);
+  if (!msg || msg.indexOf('no body') >= 0) {
+    const modelHint = modelId ? ` (model: ${modelId})` : '';
+    return new Error(`${envKeyHint || 'API'} error ${status}${modelHint}. Check model name or URL:\n${baseURL || '(default)'}`);
+  }
+  return new Error(`${envKeyHint || 'API'} error ${status}: ${msg}`);
+}
+
+async function retryWithBackoff(fn, maxTries, envKeyHint) {
+  let lastErr;
+  for (let attempt = 0; attempt < maxTries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (isAbortError(err)) throw err;
+      const status = err.status || err.code;
+      if (status !== 429 && status !== 503 && status !== 502) throw lastErr;
+      if (attempt > 0) {
+        const delay = Math.min(1000 * Math.pow(3, attempt - 1), 30000);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+// Aborts surface as AbortError, APIUserAbortError (openai SDK), or wrapped
+// messages containing "aborted". Never let an interrupt be retried or wrapped.
+function isAbortError(err) {
+  if (!err) return false;
+  const name = String(err.name || err.error?.name || '');
+  if (name === 'AbortError' || name === 'APIUserAbortError') return true;
+  return /aborted|cancel(led|ed)/i.test(String(err.message || ''));
+}
+
+/**
+ * @typedef {Object} ProviderModel
+ * @property {string} id
+ * @property {string} name
+ * @property {string} provider
+ * @property {Array<string>=} tags
+ * @property {number} context
+ * @property {number} priceIn
+ * @property {number} priceOut
+ */
+
+/**
+ * @typedef {Object} Provider
+ * @property {(messages: Array<Object>, options: Object) => Promise<Object>} chat
+ * @property {(messages: Array<Object>, options: Object, onDelta?: (text: string) => void) => Promise<Object>} stream
+ * @property {Array<ProviderModel>} models
+ */
+
+/**
+ * @param {{ getKey: () => string|undefined, providerId: string, envKeyHint: string, clientFactory?: () => any, defaultBaseUrl?: string }} config
+ * @returns {Provider}
+ */
+function createOpenAICompatProvider({ getKey, providerId, envKeyHint, clientFactory, defaultBaseUrl }) {
+  function getClient() {
+    if (clientFactory) return clientFactory();
+    const key = getKey();
+    if (!key) throw new Error(`${envKeyHint || 'API'} key not set. Use /connect or set the ${envKeyHint || 'API'}_API_KEY env var.`);
+    const baseURL = getBaseUrl(providerId) || defaultBaseUrl || getDefaultBaseUrl(providerId);
+    return new OpenAI({ apiKey: key, baseURL });
+  }
+
+  async function chat(messages, options = {}) {
+    const client = getClient();
+    const req = buildRequest(messages, options);
+    const requestOpts = { signal: options.signal };
+    try {
+      const resp = await retryWithBackoff(() => client.chat.completions.create(req, requestOpts), 4, envKeyHint);
+      return normalize(resp);
+    } catch (err) {
+      if (isAbortError(err)) throw err;
+      throw wrapErr(err, options.model || '?', envKeyHint, getBaseUrl(providerId));
+    }
+  }
+
+  async function stream(messages, options = {}, onDelta, onReasoning) {
+    const client = getClient();
+    const req = { ...buildRequest(messages, options), stream: true, stream_options: { include_usage: true } };
+    const requestOpts = { signal: options.signal };
+    try {
+      const s = await retryWithBackoff(() => client.chat.completions.create(req, requestOpts), 4, envKeyHint);
+      let content = '';
+      let reasoning = '';
+      let usage = null;
+      const toolAcc = new Map();
+
+      for await (const chunk of s) {
+        if (chunk.usage) usage = chunk.usage;
+        const delta = chunk.choices?.[0]?.delta || {};
+        // DeepSeek-style reasoning_content / OpenRouter reasoning deltas.
+        const rt = delta.reasoning_content || delta.reasoning;
+        if (typeof rt === 'string' && rt) {
+          reasoning += rt;
+          if (onReasoning) onReasoning(rt);
+          continue;
+        }
+        if (delta.content) {
+          content += delta.content;
+          if (onDelta) onDelta(delta.content);
+          continue;
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (!toolAcc.has(tc.index)) toolAcc.set(tc.index, { id: '', name: '', args: '' });
+            const acc = toolAcc.get(tc.index);
+            if (tc.id) acc.id = tc.id;
+            if (tc.function?.name) acc.name += tc.function.name;
+            if (tc.function?.arguments) acc.args += tc.function.arguments;
+          }
+        }
+      }
+
+      const toolCalls = [];
+      for (const acc of toolAcc.values()) {
+        let input = {};
+        try { input = JSON.parse(acc.args || '{}'); } catch {}
+        toolCalls.push({ id: acc.id, name: acc.name, input });
+      }
+
+      return { content, reasoning, toolCalls, usage };
+    } catch (err) {
+      if (isAbortError(err)) throw err;
+      throw wrapErr(err, options.model || '?', envKeyHint, getBaseUrl(providerId));
+    }
+  }
+
+  return { chat, stream, models: /** @type {Array<ProviderModel>} */ ([]) };
+}
+
+function getDefaultBaseUrl(providerId) {
+  const defaults = {
+    anthropic: 'https://api.anthropic.com',
+    openai: 'https://api.openai.com/v1',
+    nvidia: 'https://integrate.api.nvidia.com/v1',
+    google: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+    openrouter: 'https://openrouter.ai/api/v1',
+    tokenrouter: 'https://api.tokenrouter.com/v1',
+    local: 'http://localhost:11434/v1',
+  };
+  return defaults[providerId] || undefined;
+}
+
+module.exports = { createOpenAICompatProvider, wrapErr, buildRequest, formatMessages, formatTools, parseToolCalls, normalize, retryWithBackoff, sanitizeErrBody };

package/src/providers/openai.js

@@ -0,0 +1,35 @@
+const { createOpenAICompatProvider } = require('./openai-compat');
+
+function getKey() {
+  return process.env.OPENAI_API_KEY;
+}
+
+const provider = {
+  ...createOpenAICompatProvider({
+    getKey,
+    providerId: 'openai',
+    envKeyHint: 'OPENAI',
+  }),
+  models: [
+  // Flagship / GPT-5 Series
+  { id: 'gpt-5', name: 'GPT-5', provider: 'openai', tags: ['frontier'], context: 400000, priceIn: 1.25, priceOut: 10 },
+  { id: 'gpt-5-mini', name: 'GPT-5 Mini', provider: 'openai', tags: ['fast'], context: 400000, priceIn: 0.25, priceOut: 2.00 },
+  { id: 'gpt-5-nano', name: 'GPT-5 Nano', provider: 'openai', tags: ['cheap', 'fast'], context: 400000, priceIn: 0.10, priceOut: 0.40 },
+  { id: 'gpt-5-chat-latest', name: 'GPT-5 Chat (Latest)', provider: 'openai', tags: ['frontier'], context: 400000, priceIn: 5.00, priceOut: 30.00 },
+
+  // GPT-4 Series & Omni Models
+  { id: 'gpt-4o', name: 'GPT-4o', provider: 'openai', tags: ['legacy', 'multimodal'], context: 128000, priceIn: 2.50, priceOut: 10.00 },
+  { id: 'gpt-4o-mini', name: 'GPT-4o Mini', provider: 'openai', tags: ['fast', 'multimodal'], context: 128000, priceIn: 0.15, priceOut: 0.60 },
+  { id: 'gpt-4.1', name: 'GPT-4.1', provider: 'openai', tags: ['frontier'], context: 1048576, priceIn: 2.00, priceOut: 8.00 },
+
+  // O-Series (Reasoning) Models
+  { id: 'o3', name: 'o3', provider: 'openai', tags: ['reasoning', 'frontier'], context: 200000, priceIn: 2.00, priceOut: 8.00 },
+  { id: 'o3-mini', name: 'o3 Mini', provider: 'openai', tags: ['reasoning', 'fast'], context: 200000, priceIn: 1.10, priceOut: 4.40 },
+  { id: 'o4-mini', name: 'o4 Mini', provider: 'openai', tags: ['reasoning', 'fast'], context: 200000, priceIn: 1.10, priceOut: 4.40 },
+  { id: 'o1', name: 'o1', provider: 'openai', tags: ['reasoning'], context: 200000, priceIn: 15.00, priceOut: 60.00 },
+  { id: 'o1-pro', name: 'o1 Pro', provider: 'openai', tags: ['reasoning', 'pro'], context: 200000, priceIn: 150.00, priceOut: 600.00 },
+  { id: 'o1-mini', name: 'o1 Mini', provider: 'openai', tags: ['reasoning', 'cheap'], context: 128000, priceIn: 1.10, priceOut: 4.40 },
+],
+};
+
+module.exports = provider;

package/src/providers/openrouter.js

@@ -0,0 +1,43 @@
+const { createOpenAICompatProvider } = require('./openai-compat');
+const { getApiKey } = require('../config/settings');
+
+function getKey() {
+  return getApiKey('openrouter') || process.env.OPENROUTER_API_KEY;
+}
+
+const provider = {
+  ...createOpenAICompatProvider({
+    getKey,
+    providerId: 'openrouter',
+    envKeyHint: 'OPENROUTER',
+  }),
+  models: [
+  // Anthropic Models
+  { id: 'anthropic/claude-3-opus', name: 'Claude 3 Opus (via OpenRouter)', provider: 'openrouter', context: 200000, priceIn: 15, priceOut: 75 },
+  
+  // OpenAI Models
+  { id: 'openai/gpt-4o-mini', name: 'GPT-4o Mini (via OpenRouter)', provider: 'openrouter', context: 128000, priceIn: 0.15, priceOut: 0.60 },
+  { id: 'openai/gpt-4o', name: 'GPT-4o (via OpenRouter)', provider: 'openrouter', context: 128000, priceIn: 2.50, priceOut: 10.00 },
+  { id: 'openai/o3-mini-high', name: 'O3 Mini High (via OpenRouter)', provider: 'openrouter', context: 200000, priceIn: 1.10, priceOut: 4.40 },
+  { id: 'openai/o1', name: 'O1 (via OpenRouter)', provider: 'openrouter', context: 200000, priceIn: 15, priceOut: 60 },
+  
+  // Google Models
+  { id: 'google/gemini-2.5-pro', name: 'Gemini 2.5 Pro (via OpenRouter)', provider: 'openrouter', context: 1048576, priceIn: 1.25, priceOut: 10 },
+  { id: 'google/gemini-2.5-flash', name: 'Gemini 2.5 Flash (via OpenRouter)', provider: 'openrouter', context: 1048576, priceIn: 0.15, priceOut: 1.25 },
+  
+  // DeepSeek
+  { id: 'deepseek/deepseek-v4-flash', name: 'DeepSeek V4 Flash (via OpenRouter)', provider: 'openrouter', context: 1048576, priceIn: 0.07, priceOut: 0.18 },
+  
+  // NVIDIA free-tier variants (the :free slugs are genuinely free on
+  // OpenRouter; the un-suffixed Nemotron IDs are paid and must not be tagged free)
+  { id: 'nvidia/nemotron-3-super-120b-a12b:free', name: 'Nemotron 3 Super (free, via OpenRouter)', provider: 'openrouter', tags: ['free'], context: 262144, priceIn: 0, priceOut: 0 },
+  { id: 'nvidia/nemotron-3-ultra-550b-a55b:free', name: 'Nemotron 3 Ultra (free, via OpenRouter)', provider: 'openrouter', tags: ['free'], context: 1048576, priceIn: 0, priceOut: 0 },
+  
+  // Other Top-Tier Alternatives
+  { id: 'zhipuai/glm-4-plus', name: 'GLM-4 Plus (via OpenRouter)', provider: 'openrouter', context: 128000, priceIn: 1.5, priceOut: 1.5 },
+  { id: 'minimax/minimax-01', name: 'MiniMax-01 (via OpenRouter)', provider: 'openrouter', context: 1000000, priceIn: 0.14, priceOut: 1.4 },
+  { id: 'mistralai/mistral-large-2411', name: 'Mistral Large 2411 (via OpenRouter)', provider: 'openrouter', context: 128000, priceIn: 2, priceOut: 6 }
+]
+};
+
+module.exports = provider;

package/src/providers/registry.js

@@ -0,0 +1,196 @@
+// models.dev provider/model registry — the same open-source dataset opencode
+// uses for its provider + model lists (https://models.dev/api.json). Loom
+// fetches it once, caches it at ~/.loom/models-dev.json, and merges every
+// provider into the runtime registry. Everything degrades gracefully offline:
+// no cache, no network -> the 7 built-in providers keep working.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const REGISTRY_URL = 'https://models.dev/api.json';
+const REGISTRY_FILE = path.join(path.join(os.homedir(), '.loom'), 'models-dev.json');
+const MAX_AGE_MS = 7 * 24 * 3600 * 1000;
+
+// Re-evaluated on every call (like the other stores) so tests/CI can isolate
+// with LOOM_CONFIG_DIR; REGISTRY_FILE keeps the default for display.
+function registryFile() {
+  return path.join(process.env.LOOM_CONFIG_DIR || path.join(os.homedir(), '.loom'), 'models-dev.json');
+}
+
+/**
+ * @typedef {Object} RegistryModel
+ * @property {string} id
+ * @property {string} name
+ * @property {number} context
+ * @property {number} priceIn  $/1M input tokens
+ * @property {number} priceOut $/1M output tokens
+ * @property {Array<string>} tags
+ */
+
+/**
+ * @typedef {Object} RegistryProvider
+ * @property {string} id
+ * @property {string} name
+ * @property {Array<string>} env  accepted API-key env var names
+ * @property {string} npm  SDK the provider expects (info only)
+ * @property {string=} baseURL  OpenAI-compatible endpoint, when known
+ * @property {Array<RegistryModel>} models
+ */
+
+/**
+ * @param {string} id
+ * @param {*} raw
+ * @returns {RegistryProvider}
+ */
+function normalizeProvider(id, raw) {
+  /** @type {Array<RegistryModel>} */
+  const models = [];
+  for (const [mid, m] of Object.entries(raw.models || {})) {
+    if (!m || typeof m !== 'object') continue;
+    /** @type {Array<string>} */
+    const tags = [];
+    if (m.reasoning) tags.push('reasoning');
+    models.push({
+      id: mid,
+      name: m.name || mid,
+      context: (m.limit && m.limit.context) || 0,
+      priceIn: (m.cost && Number(m.cost.input)) || 0,
+      priceOut: (m.cost && Number(m.cost.output)) || 0,
+      tags,
+    });
+  }
+  models.sort((a, b) => a.id.localeCompare(b.id));
+  return {
+    id,
+    name: raw.name || id,
+    env: Array.isArray(raw.env) && raw.env.length ? raw.env : [id.toUpperCase() + '_API_KEY'],
+    npm: raw.npm || '',
+    baseURL: typeof raw.api === 'string' ? raw.api : undefined,
+    models,
+  };
+}
+
+// Well-known OpenAI-compatible base URLs for npm SDKs that models.dev lists
+// without an `api` field (their SDKs embed the endpoint). A registry `api`
+// field always wins over this map.
+const SDK_BASE_URLS = {
+  '@ai-sdk/openai': 'https://api.openai.com/v1',
+  '@ai-sdk/anthropic': 'https://api.anthropic.com',
+  '@ai-sdk/google': 'https://generativelanguage.googleapis.com/v1beta/openai/',
+  '@ai-sdk/mistral': 'https://api.mistral.ai/v1',
+  '@ai-sdk/xai': 'https://api.x.ai/v1',
+  '@ai-sdk/groq': 'https://api.groq.com/openai/v1',
+  '@ai-sdk/perplexity': 'https://api.perplexity.ai',
+  '@ai-sdk/cerebras': 'https://api.cerebras.ai/v1',
+  '@ai-sdk/cohere': 'https://api.cohere.com/v2',
+  '@openrouter/ai-sdk-provider': 'https://openrouter.ai/api/v1',
+};
+
+// Load the cached registry (if any) into normalized providers.
+// @returns {Object<string, RegistryProvider> | null}  null when no cache exists
+//
+// Memoized: the cache file is static within a process, and callers (hasApiKey
+// -> envNamesFor, once per provider) would otherwise re-parse the multi-MB
+// file hundreds of times — the #1 source of UI stalls (e.g. a 4s /models).
+// fetchRegistry() invalidates the memo after writing a fresh cache; tests use
+// cache-busted imports, so each fixture gets its own memo.
+let registryCache = null;
+let registryCacheKey = "";
+let registryCacheMtime = 0;
+function invalidateRegistryCache() {
+  registryCache = null;
+  registryCacheKey = "";
+  registryCacheMtime = 0;
+}
+function loadRegistry() {
+  const file = registryFile();
+  if (!fs.existsSync(file)) return null;
+  try {
+    const mtime = fs.statSync(file).mtimeMs;
+    if (registryCache && registryCacheKey === file && registryCacheMtime === mtime) {
+      return registryCache;
+    }
+    const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!raw || typeof raw !== 'object') return null;
+    /** @type {Object<string, RegistryProvider>} */
+    const out = {};
+    for (const [id, p] of Object.entries(raw)) {
+      if (!p || typeof p !== 'object' || !p.models) continue;
+      out[id] = normalizeProvider(id, p);
+    }
+    registryCache = out;
+    registryCacheKey = file;
+    registryCacheMtime = mtime;
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Whether the cached registry is fresh enough to skip a re-fetch.
+ * @returns {boolean}
+ */
+function isRegistryFresh() {
+  const file = registryFile();
+  if (!fs.existsSync(file)) return false;
+  try {
+    const age = Date.now() - fs.statSync(file).mtimeMs;
+    return age < MAX_AGE_MS;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Fetch the registry from models.dev and cache it. Returns the number of
+ * providers cached, or 0 on any failure (offline — the previous cache or the
+ * built-in providers keep working).
+ * @param {number=} timeoutMs
+ * @returns {Promise<number>}
+ */
+async function fetchRegistry(timeoutMs = 30000) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(REGISTRY_URL, { signal: ctrl.signal });
+    if (!res.ok) return 0;
+    const parsed = JSON.parse(await res.text());
+    if (!parsed || typeof parsed !== 'object') return 0;
+    const count = Object.keys(parsed).length;
+    if (!count) return 0;
+    const file = registryFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(parsed));
+    invalidateRegistryCache();
+    return count;
+  } catch {
+    return 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Env var names that hold a provider's API key. Built-ins keep their legacy
+// names; registry providers use the env names models.dev publishes for them.
+const BUILTIN_ENV = {
+  anthropic: ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
+  openai: ['OPENAI_API_KEY'],
+  nvidia: ['NVIDIA_API_KEY', 'NVIDIA_NIM_API_KEY'],
+  google: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+  openrouter: ['OPENROUTER_API_KEY'],
+  tokenrouter: ['TOKENROUTER_API_KEY'],
+};
+
+/**
+ * @param {string} id
+ * @returns {Array<string>}
+ */
+function envNamesFor(id) {
+  if (BUILTIN_ENV[id]) return BUILTIN_ENV[id];
+  const reg = loadRegistry();
+  if (reg && reg[id] && reg[id].env.length) return reg[id].env;
+  return [id.toUpperCase() + '_API_KEY'];
+}
+
+module.exports = { REGISTRY_URL, REGISTRY_FILE, loadRegistry, fetchRegistry, isRegistryFresh, envNamesFor, normalizeProvider, SDK_BASE_URLS, invalidateRegistryCache };

package/src/providers/tokenrouter.js

@@ -0,0 +1,19 @@
+const { createOpenAICompatProvider } = require('./openai-compat');
+const { getApiKey } = require('../config/settings');
+
+function getKey() {
+  return getApiKey('tokenrouter') || process.env.TOKENROUTER_API_KEY;
+}
+
+const provider = {
+  ...createOpenAICompatProvider({
+    getKey,
+    providerId: 'tokenrouter',
+    envKeyHint: 'TOKENROUTER',
+  }),
+  models: [
+  { id: 'moonshotai/kimi-k3-free', name: 'Kimi K3 Free', provider: 'tokenrouter', tags: ['free'], context: 128000, priceIn: 0, priceOut: 0 },
+  ],
+};
+
+module.exports = provider;