@geraldmaron/construct 1.1.0 → 1.2.0

package/lib/models/provider-poll.mjs

@@ -0,0 +1,383 @@
+/**
+ * lib/models/provider-poll.mjs — live, per-provider model enumeration for the picker.
+ *
+ * Each configured provider is queried at its own list endpoint so the picker
+ * shows the provider's actual catalog rather than a shipped guess: OpenRouter
+ * /api/v1/models, OpenAI /v1/models, Anthropic /v1/models, GitHub Copilot
+ * /models, and Ollama /api/tags. Providers without a list API (or whose poll
+ * fails) fall back to the curated tier options, flagged source:'curated' so the
+ * UI never implies a live result it could not verify. Every poller is
+ * best-effort: it resolves to [] on any error and never throws, and results are
+ * cached to ~/.cx/provider-catalog-cache.json so repeat opens are instant.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveFirstSecret } from '../providers/secret-resolver.mjs';
+import { getProviderModelCatalog } from '../model-router.mjs';
+import { listInstalledOllamaModels, toOllamaNativeModelId } from '../ollama/installed-models.mjs';
+import { getPricingForModels } from '../model-pricing.mjs';
+
+const FETCH_TIMEOUT_MS = 10_000;
+const CACHE_TTL_MS = 10 * 60 * 1000;
+const CACHE_FILENAME = 'provider-catalog-cache.json';
+
+const PROVIDER_LABELS = {
+  anthropic: 'Anthropic',
+  openai: 'OpenAI',
+  'github-copilot': 'GitHub Copilot',
+  openrouter: 'OpenRouter',
+  ollama: 'Ollama (local)',
+  local: 'Local',
+};
+
+// Render order for groups: first-party hosted, then the OpenRouter aggregator,
+// then local runtimes. Unknown providers sort after these by label.
+const PROVIDER_ORDER = ['anthropic', 'openai', 'github-copilot', 'openrouter', 'ollama', 'local'];
+
+function cachePath(homeDir = os.homedir()) {
+  return path.join(homeDir, '.cx', CACHE_FILENAME);
+}
+
+async function fetchJson(url, { headers = {}, signal } = {}) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, { headers, signal: signal || controller.signal });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function isFreePricing(pricing) {
+  return pricing?.prompt === '0' && pricing?.completion === '0';
+}
+
+// OpenRouter advertises capabilities through supported_parameters and the
+// architecture modality lists, so reasoning/tools/vision are read, not inferred.
+function openRouterCapabilities(model) {
+  const params = Array.isArray(model.supported_parameters) ? model.supported_parameters : [];
+  const inputs = model.architecture?.input_modalities || [];
+  return {
+    reasoning: params.includes('reasoning') || params.includes('include_reasoning'),
+    tools: params.includes('tools') || params.includes('tool_choice'),
+    vision: Array.isArray(inputs) && inputs.includes('image'),
+  };
+}
+
+export async function pollOpenRouter({ env = process.env } = {}) {
+  const apiKey = resolveFirstSecret(['OPENROUTER_API_KEY', 'OPEN_ROUTER_API_KEY'], { env });
+  const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+  const data = await fetchJson('https://openrouter.ai/api/v1/models', { headers });
+  if (!data) return null;
+  const list = Array.isArray(data?.data) ? data.data : [];
+  const models = [];
+  for (const m of list) {
+    if (!m?.id) continue;
+    const free = isFreePricing(m.pricing);
+    const input = Number(m.pricing?.prompt);
+    const output = Number(m.pricing?.completion);
+    const caps = openRouterCapabilities(m);
+    models.push({
+      id: `openrouter/${m.id}`,
+      label: m.name || m.id,
+      provider: 'openrouter',
+      free,
+      pricing: Number.isFinite(input) && Number.isFinite(output)
+        ? { input: input * 1_000_000, output: output * 1_000_000 }
+        : null,
+      context: Number(m.context_length) || null,
+      reasoning: caps.reasoning,
+      tools: caps.tools,
+      toolsKnown: true,
+      vision: caps.vision,
+      source: 'live',
+    });
+  }
+  return models;
+}
+
+// The OpenAI list endpoint returns every artifact id (embeddings, audio, image,
+// moderation) with no capability or pricing metadata. Keep only chat-capable
+// families and mark the o-series as reasoning, which is definitional rather than
+// guessed.
+const OPENAI_NON_CHAT = /(embedding|whisper|tts|audio|realtime|image|dall-e|moderation|search|babbage|davinci|transcribe|sora)/i;
+
+export async function pollOpenAI({ env = process.env } = {}) {
+  const apiKey = resolveFirstSecret(['OPENAI_API_KEY'], { env });
+  if (!apiKey) return null;
+  const data = await fetchJson('https://api.openai.com/v1/models', {
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+  if (!data) return null;
+  const list = Array.isArray(data?.data) ? data.data : [];
+  const models = [];
+  for (const m of list) {
+    const nativeId = m?.id;
+    if (!nativeId) continue;
+    if (OPENAI_NON_CHAT.test(nativeId)) continue;
+    if (!/^(gpt-|o\d|chatgpt)/i.test(nativeId)) continue;
+    models.push({
+      id: `openai/${nativeId}`,
+      label: nativeId,
+      provider: 'openai',
+      free: false,
+      pricing: null,
+      context: null,
+      reasoning: /^o\d/i.test(nativeId),
+      tools: !/instruct/i.test(nativeId),
+      toolsKnown: true,
+      vision: false,
+      source: 'live',
+    });
+  }
+  return models;
+}
+
+export async function pollAnthropic({ env = process.env } = {}) {
+  const apiKey = resolveFirstSecret(['ANTHROPIC_API_KEY'], { env });
+  if (!apiKey) return null;
+  const data = await fetchJson('https://api.anthropic.com/v1/models?limit=100', {
+    headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
+  });
+  if (!data) return null;
+  const list = Array.isArray(data?.data) ? data.data : [];
+  const models = [];
+  for (const m of list) {
+    const nativeId = m?.id;
+    if (!nativeId) continue;
+    models.push({
+      id: `anthropic/${nativeId}`,
+      label: m.display_name || nativeId,
+      provider: 'anthropic',
+      free: false,
+      pricing: null,
+      context: null,
+      reasoning: false,
+      tools: true,
+      toolsKnown: true,
+      vision: false,
+      source: 'live',
+    });
+  }
+  return models;
+}
+
+// Copilot tags reasoning support with a reasoning_effort list; a list that is
+// only ['none'] is not a reasoning model. adaptive_thinking is the Claude-family
+// equivalent.
+function copilotReasoning(supports) {
+  const effort = supports.reasoning_effort;
+  if (Array.isArray(effort) && effort.some((e) => e && e !== 'none')) return true;
+  return Boolean(supports.adaptive_thinking);
+}
+
+export async function pollCopilot() {
+  try {
+    const { getCopilotToken, copilotApiHeaders, COPILOT_API_BASE } = await import('../providers/copilot-auth.mjs');
+    const token = await getCopilotToken();
+    const data = await fetchJson(`${COPILOT_API_BASE}/models`, {
+      headers: { Accept: 'application/json', Authorization: `Bearer ${token}`, ...copilotApiHeaders() },
+    });
+    if (!data) return null;
+    const list = Array.isArray(data?.data) ? data.data : (Array.isArray(data) ? data : []);
+    const seen = new Set();
+    const models = [];
+    for (const m of list) {
+      const nativeId = m?.id || m?.model;
+      if (!nativeId || seen.has(nativeId)) continue;
+      if (m?.model_picker_enabled === false) continue;
+      if (m?.capabilities?.type && m.capabilities.type !== 'chat') continue;
+      seen.add(nativeId);
+      const caps = m?.capabilities || {};
+      const supports = caps.supports || {};
+      models.push({
+        id: `github-copilot/${nativeId}`,
+        label: m?.name || nativeId,
+        provider: 'github-copilot',
+        free: false,
+        pricing: null,
+        context: Number(caps.limits?.max_prompt_tokens || caps.limits?.max_context_window_tokens) || null,
+        reasoning: copilotReasoning(supports),
+        tools: Boolean(supports.tool_calls),
+        toolsKnown: true,
+        vision: Boolean(supports.vision) || Boolean(caps.limits?.vision),
+        source: 'live',
+      });
+    }
+    return models;
+  } catch {
+    return null;
+  }
+}
+
+export function pollOllama({ env = process.env } = {}) {
+  const { models: installed, listable } = listInstalledOllamaModels({ env });
+  if (!listable || !installed) return null;
+  const models = [];
+  for (const native of installed) {
+    models.push({
+      id: `ollama/${native}`,
+      label: native,
+      provider: 'ollama',
+      free: true,
+      pricing: { input: 0, output: 0 },
+      context: null,
+      reasoning: false,
+      tools: false,
+      toolsKnown: false,
+      vision: false,
+      source: 'live',
+    });
+  }
+  return models;
+}
+
+// When a configured provider can't be reached (or exposes no list endpoint), say
+// so plainly instead of inventing a model list. The hint renders as a disabled,
+// unselectable row so the group is never silently empty and never fabricated.
+const UNREACHABLE_HINTS = {
+  ollama: 'Ollama server not reachable — start it with `ollama serve`',
+};
+
+function unreachableHint(groupId, label) {
+  return {
+    id: `__unreachable__/${groupId}`,
+    label: UNREACHABLE_HINTS[groupId] || `${label} unreachable — check credentials or connection`,
+    provider: groupId,
+    free: false,
+    pricing: null,
+    context: null,
+    reasoning: false,
+    tools: false,
+    vision: false,
+    disabled: true,
+    source: 'hint',
+  };
+}
+
+function providerGroupId(familyId) {
+  return familyId.startsWith('openrouter') ? 'openrouter' : familyId;
+}
+
+// Returns the provider's live model list, or null when the provider could not be
+// reached or has no list endpoint (the 'local' runtime). null is distinct from an
+// empty array, which means "reached, but the account exposes no models".
+async function pollLiveFor(groupId, env) {
+  if (groupId === 'openrouter') return pollOpenRouter({ env });
+  if (groupId === 'openai') return pollOpenAI({ env });
+  if (groupId === 'anthropic') return pollAnthropic({ env });
+  if (groupId === 'github-copilot') return pollCopilot();
+  if (groupId === 'ollama') return pollOllama({ env });
+  return null;
+}
+
+async function enrichPricing(models, { env }) {
+  const needPricing = models.filter((m) => !m.pricing && m.provider !== 'ollama' && m.provider !== 'local').map((m) => m.id);
+  if (!needPricing.length) return models;
+  let priceMap = {};
+  try {
+    priceMap = await getPricingForModels(needPricing);
+  } catch { /* pricing is best-effort */ }
+  return models.map((m) => {
+    if (m.pricing || !priceMap[m.id]) return m;
+    const hit = priceMap[m.id];
+    return { ...m, pricing: { input: hit.input, output: hit.output } };
+  });
+}
+
+/**
+ * Poll every configured provider in parallel and return one group per provider,
+ * in render order, each with its live model list. A provider that can't be
+ * reached falls back to its last-good cached list (flagged source:'cached'), or
+ * to a disabled unreachable hint when there is no cache — never to an invented
+ * list. Successful live polls refresh the on-disk cache.
+ */
+export async function pollConfiguredProviders({ env = process.env, cwd = process.cwd(), homeDir = os.homedir() } = {}) {
+  const { providers } = getProviderModelCatalog({ env, cwd });
+  const configured = providers.filter((p) => p.configured);
+
+  const groupIds = [];
+  const groupForId = new Map();
+  for (const provider of configured) {
+    const gid = providerGroupId(provider.id);
+    if (!groupForId.has(gid)) {
+      groupForId.set(gid, { id: gid, label: PROVIDER_LABELS[gid] || provider.label });
+      groupIds.push(gid);
+    }
+  }
+
+  const cached = readProviderCatalogCache({ homeDir, maxAgeMs: Infinity }) || [];
+  const cachedById = new Map(cached.map((g) => [g.id, g]));
+
+  // A single provider's credential resolution can throw (e.g. an op:// ref on a
+  // machine without the 1Password CLI). Isolate each poll so that failure
+  // degrades only its own group to cached/unreachable, never the whole picker.
+  const polled = await Promise.all(groupIds.map(async (gid) => {
+    let live = null;
+    try {
+      live = await pollLiveFor(gid, env);
+    } catch {
+      live = null;
+    }
+    return { gid, live };
+  }));
+
+  const groups = [];
+  const liveGroupsToCache = [];
+  for (const { gid, live } of polled) {
+    const group = groupForId.get(gid);
+    if (Array.isArray(live)) {
+      const enriched = await enrichPricing(live, { env });
+      groups.push({ id: gid, label: group.label, models: enriched, live: true });
+      liveGroupsToCache.push({ id: gid, label: group.label, models: enriched });
+      continue;
+    }
+    const cachedGroup = cachedById.get(gid);
+    if (cachedGroup?.models?.length) {
+      groups.push({
+        id: gid,
+        label: group.label,
+        models: cachedGroup.models.map((m) => ({ ...m, source: 'cached' })),
+        live: false,
+      });
+      liveGroupsToCache.push(cachedGroup);
+      continue;
+    }
+    groups.push({ id: gid, label: group.label, models: [unreachableHint(gid, group.label)], live: false });
+  }
+
+  groups.sort((a, b) => {
+    const ai = PROVIDER_ORDER.indexOf(a.id);
+    const bi = PROVIDER_ORDER.indexOf(b.id);
+    return (ai < 0 ? 99 : ai) - (bi < 0 ? 99 : bi) || a.label.localeCompare(b.label);
+  });
+
+  if (liveGroupsToCache.length) writeProviderCatalogCache(liveGroupsToCache, { homeDir });
+
+  return groups;
+}
+
+export function readProviderCatalogCache({ homeDir = os.homedir(), maxAgeMs = CACHE_TTL_MS, now = Date.now() } = {}) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(cachePath(homeDir), 'utf8'));
+    if (!parsed?.fetchedAt || !Array.isArray(parsed.groups)) return null;
+    if (now - parsed.fetchedAt > maxAgeMs) return null;
+    return parsed.groups;
+  } catch {
+    return null;
+  }
+}
+
+export function writeProviderCatalogCache(groups, { homeDir = os.homedir(), now = Date.now() } = {}) {
+  try {
+    const file = cachePath(homeDir);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ fetchedAt: now, groups }, null, 2));
+  } catch { /* cache write is best-effort */ }
+}

package/lib/npm-spawn-env.mjs

@@ -0,0 +1,17 @@
+/**
+ * lib/npm-spawn-env.mjs — sanitize env before npm/npx child spawns.
+ *
+ * npm 11.2+ warns on unknown npm_config_* keys. Cursor sandbox injects
+ * npm_config_devdir for node-gyp cache routing; strip it before Construct
+ * spawns nested npm/npx so build chains do not duplicate the warning.
+ */
+
+export function sanitizeNpmSpawnEnv(baseEnv = process.env) {
+  const env = { ...baseEnv };
+  for (const key of Object.keys(env)) {
+    if (/^npm_config_devdir$/i.test(key) || key === 'NPM_CONFIG_DEVDIR') {
+      delete env[key];
+    }
+  }
+  return env;
+}

package/lib/ollama/installed-models.mjs

@@ -0,0 +1,129 @@
+/**
+ * lib/ollama/installed-models.mjs — detect which Ollama model tags are installed locally.
+ *
+ * Construct model ids use the `ollama/<native>` form; Ollama's OpenAI-compatible API
+ * expects the native tag (e.g. `llama3.2:3b`). This module lists `/api/tags` (or falls
+ * back to `ollama list`) so availability checks and chat errors can distinguish "server
+ * up but model not pulled" from auth or routing problems. Results are cached briefly
+ * because the picker and router may call this many times per session.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { resolveFirstSecret } from '../providers/secret-resolver.mjs';
+
+const CACHE_MS = 2500;
+let cache = { at: 0, models: null, listable: false };
+
+function ollamaBaseUrl(env = process.env) {
+  const fromEnv = resolveFirstSecret(['OLLAMA_BASE_URL', 'OLLAMA_HOST'], { env, allowAmbient: true });
+  const base = (fromEnv || 'http://localhost:11434').replace(/\/+$/, '');
+  return base.endsWith('/v1') ? base.slice(0, -3) : base;
+}
+
+function parseTagsResponse(body) {
+  const data = typeof body === 'string' ? JSON.parse(body) : body;
+  const names = (data?.models || [])
+    .map((entry) => entry?.name || entry?.model)
+    .filter(Boolean);
+  return new Set(names);
+}
+
+function listViaTagsApi(baseUrl) {
+  const url = `${baseUrl}/api/tags`;
+  const r = spawnSync('curl', ['-s', '--connect-timeout', '2', url], { encoding: 'utf8', timeout: 4000 });
+  if (r.status !== 0 || !r.stdout?.trim()) return null;
+  try {
+    return parseTagsResponse(r.stdout);
+  } catch {
+    return null;
+  }
+}
+
+function listViaCli() {
+  const r = spawnSync('ollama', ['list'], { encoding: 'utf8', timeout: 5000 });
+  if (r.status !== 0) return null;
+  const names = r.stdout.trim().split('\n').slice(1)
+    .map((line) => line.split(/\s+/).filter(Boolean)[0])
+    .filter(Boolean);
+  return new Set(names);
+}
+
+export function toOllamaNativeModelId(modelId) {
+  if (!modelId || typeof modelId !== 'string') return null;
+  return modelId.replace(/^ollama\//, '');
+}
+
+export function listInstalledOllamaModels({ env = process.env, now = Date.now(), refresh = false } = {}) {
+  if (cache.pinned) {
+    return { models: cache.models, listable: cache.listable };
+  }
+  if (!refresh && cache.models && (now - cache.at) < CACHE_MS) {
+    return { models: cache.models, listable: cache.listable };
+  }
+
+  const baseUrl = ollamaBaseUrl(env);
+  let models = listViaTagsApi(baseUrl);
+  if (!models) models = listViaCli();
+
+  if (!models) {
+    cache = { at: now, models: null, listable: false };
+    return { models: null, listable: false };
+  }
+
+  cache = { at: now, models, listable: true };
+  return { models, listable: true };
+}
+
+/**
+ * @returns {boolean|null} true when installed, false when listable and missing, null when unknown
+ */
+export function isOllamaModelInstalled(modelId, opts = {}) {
+  const native = toOllamaNativeModelId(modelId);
+  if (!native) return null;
+  const { models, listable } = listInstalledOllamaModels(opts);
+  if (!listable || !models) return null;
+  return models.has(native);
+}
+
+export function formatOllamaModelMissingMessage(nativeModel, { constructId = null } = {}) {
+  const id = nativeModel || toOllamaNativeModelId(constructId) || 'the model';
+  return `Ollama model '${id}' is not installed locally. Pull it with: ollama pull ${id} (or: construct ollama pull ${id})`;
+}
+
+export function resetInstalledOllamaModelsCacheForTests() {
+  cache = { at: 0, models: null, listable: false, pinned: false };
+}
+
+// Serializes cache injection across parallel test files so a neighbor's reset/probe
+// cannot stomp a pinned list mid-assertion (ubuntu-latest CI flakes).
+let cacheTestTail = Promise.resolve();
+
+export function runWithInstalledOllamaCacheForTests(models, fn) {
+  const run = cacheTestTail.then(async () => {
+    cache = {
+      at: Date.now(),
+      models: models instanceof Set ? models : new Set(models),
+      listable: true,
+      pinned: true,
+    };
+    try {
+      return await fn();
+    } finally {
+      cache = { at: 0, models: null, listable: false, pinned: false };
+    }
+  });
+  cacheTestTail = run.catch(() => {});
+  return run;
+}
+
+// pinned bypasses the TTL so an injected cache survives slow provider probes that
+// run between injection and read; without it the entry can age out mid-test and
+// trigger a real (server-down) probe, flaking availability assertions.
+export function setInstalledOllamaModelsCacheForTests(models, { listable = true, now = Date.now() } = {}) {
+  cache = {
+    at: now,
+    models: models instanceof Set ? models : new Set(models),
+    listable,
+    pinned: true,
+  };
+}