@mmmbuto/nexuscrew 0.9.74 → 0.9.76

package/frontend/dist/index.html

@@ -11,8 +11,8 @@
   <meta name="apple-mobile-web-app-title" content="NexusCrew" />
   <link rel="manifest" href="/manifest.json" />
   <title>NexusCrew</title>
-  <script type="module" crossorigin src="/assets/index-DRXfJssx.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-C_z6r985.css">
+  <script type="module" crossorigin src="/assets/index-BURtPwUi.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-B9GW2LHm.css">
 </head>
 <body>
   <div id="root"></div>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.74"}
+{"version":"0.9.76"}

package/lib/fleet/builtin.js

@@ -41,8 +41,10 @@ const {
   CATALOG, CLIENT_LABELS, CLIENT_ORDER, engineClient, ordinaEngine, isStandardClient,
   credential: resolveProfileCredential, extraModelsFrom, knownMcpServerNames, profileFor,
   normalizeManagedSpec, codexSurfaceNames,
+  engineModelDiscoveryPlan, ollamaCloudCatalogModels, declaredModelsFor, ALIBABA_PI_MODELS,
 } = require('./managed.js');
 const { probeModel, probeCustomEndpoint } = require('./model-probe.js');
+const { createModelDiscovery, DISCOVERY_PROPOSAL_CAP } = require('./model-discovery.js');
 const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
 const { validEnvKey } = require('./env-key.js');
 const { isReservedLiveName } = require('../live-host/reserved.js');
@@ -963,7 +965,7 @@ async function createBuiltinFleet(cfg = {}) {
   // I campi non-identita' che `parseModel` ammette per una dichiarazione:
   // id ed engine SONO l'identita' (il chiaro per cui esiste edit-model e' non
   // doverla ritoccare), tutto il resto e' patchabile con la stessa validazione.
-  const EDIT_MODEL_FIELDS = new Set(['label', 'contextWindow', 'maxTokens', 'reasoning']);
+  const EDIT_MODEL_FIELDS = new Set(['label', 'contextWindow', 'maxTokens', 'tools', 'vision', 'reasoning']);
 
   async function editModel(id, engine, patch) {
     if (readonly()) throw httpError(403, 'READONLY: edit-model bloccato');
@@ -982,12 +984,18 @@ async function createBuiltinFleet(cfg = {}) {
       }
     }
     for (const key of ['contextWindow', 'maxTokens']) {
-      if (patch[key] !== undefined && (!Number.isSafeInteger(patch[key]) || patch[key] < 1)) {
-        throw httpError(400, `${key} non valido: intero >= 1`);
+      // Stessa scala del parser: un valore che il dialogo accetta e il file
+      // rifiuta farebbe fallire l'intero salvataggio, non il solo campo.
+      if (patch[key] !== undefined && (!Number.isSafeInteger(patch[key]) || patch[key] < 1024 || patch[key] > 100000000)) {
+        throw httpError(400, `${key} non valido: intero fra 1024 e 100000000`);
       }
     }
-    if (patch.reasoning !== undefined && typeof patch.reasoning !== 'boolean') {
-      throw httpError(400, 'reasoning non valido: booleano');
+    // `tools` e `vision` sono booleani tipizzati come `reasoning`: `false` e'
+    // una risposta, quindi non si rifiuta e non si scambia per assenza.
+    for (const key of ['tools', 'vision', 'reasoning']) {
+      if (patch[key] !== undefined && typeof patch[key] !== 'boolean') {
+        throw httpError(400, `${key} non valido: booleano`);
+      }
     }
     const defs = reloadDefs();
     if (!(defs.models || []).some((m) => m.id === wantedId && m.engine === wantedEngine)) {
@@ -1603,6 +1611,8 @@ async function createBuiltinFleet(cfg = {}) {
         // arriverebbe al client come comportamento inspiegabile.
         contextWindow: { type: 'integer', required: false, min: 1024, max: 100000000 },
         maxTokens: { type: 'integer', required: false, min: 1024, max: 100000000 },
+        tools: { type: 'boolean', required: false },
+        vision: { type: 'boolean', required: false },
         reasoning: { type: 'boolean', required: false },
       },
       cell: {
@@ -1648,7 +1658,7 @@ async function createBuiltinFleet(cfg = {}) {
   }
 
   function capabilities() {
-    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'restore', 'schema', 'definitions', 'credentials', 'model-test', 'edit-model'];
+    return ['status', 'up', 'down', 'restart', 'engine', 'boot', 'define', 'edit', 'remove', 'import', 'restore', 'schema', 'definitions', 'credentials', 'model-test', 'model-discovery', 'edit-model'];
   }
 
   // Un engine del documento con un `baseUrl` dichiarato a mano: indirizzo e
@@ -1714,6 +1724,200 @@ async function createBuiltinFleet(cfg = {}) {
     return { engine: profile.id, model: wanted, ...out };
   }
 
+  // Model discovery for the engine editor: the «you can use these» list with
+  // per-field provenance (user > api > public catalog > backup). The engine's
+  // endpoint and credential are resolved on the SAME road the launcher and
+  // testModel use, live in memory only, and never enter the response: the
+  // return shape is curated field by field below and the discovery module's
+  // errors are fixed strings by construction (no key, no URL, ever).
+  const engineModelDiscovery = createModelDiscovery();
+  function backupModelsFor(profile) {
+    if (!profile) return [];
+    // ollama-cloud carries real measured descriptors: context window and
+    // capabilities from the wired catalog, not bare ids.
+    if (profile.provider === 'ollama-cloud') {
+      return ollamaCloudCatalogModels().map((m) => ({
+        id: m.id,
+        ...(Number.isFinite(m.contextWindow) ? { contextWindow: m.contextWindow } : {}),
+        ...(Array.isArray(m.input) && m.input.includes('image') ? { vision: true } : {}),
+        ...(m.reasoning === true ? { reasoning: true } : {}),
+      }));
+    }
+    return (Array.isArray(profile.models) ? profile.models : [])
+      .filter((id) => typeof id === 'string' && id).map((id) => ({ id }));
+  }
+  // Internal-catalog PROPOSALS for the missing-data dialog (lot 3b): what the
+  // wired database knows about a model id, for fields the discovery layers
+  // could NOT fill. These are PROPOSALS only — they never join the merge, so
+  // precedence and discovery stay untouched; the dialog shows them pre-filled
+  // and whatever the operator confirms becomes a user value in fleet.json.
+  // Lookup mirrors the wired ollama rule: exact key first, then the base name
+  // without the ':tag' suffix ('deepseek-v4-flash:0731' -> 'deepseek-v4-flash').
+  function internalModelIndex(profile) {
+    const index = new Map();
+    const add = (id, values) => {
+      if (!id || !values) return;
+      const known = index.get(id) || {};
+      for (const field of ['contextWindow', 'maxTokens']) {
+        if (values[field] !== undefined) known[field] = values[field];
+      }
+      if (Object.keys(known).length) index.set(id, known);
+    };
+    if (profile?.provider === 'ollama-cloud') {
+      for (const m of ollamaCloudCatalogModels()) add(m.id, { contextWindow: m.contextWindow });
+    }
+    if (profile?.provider === 'alibaba-token-plan') {
+      // ALIBABA_PI_MODELS carries the full descriptors (context, output) of
+      // the wired database; the profile's own `models` list is bare ids.
+      for (const m of ALIBABA_PI_MODELS) add(m.id, { contextWindow: m.contextWindow, maxTokens: m.maxTokens });
+    }
+    return index;
+  }
+  function internalValueFor(index, id) {
+    if (!index.size || typeof id !== 'string') return null;
+    if (index.has(id)) return index.get(id);
+    const base = id.replace(/:[^:/]+$/, '');
+    return base !== id && index.has(base) ? index.get(base) : null;
+  }
+  // Curated authentication diagnosis of the LISTING attempt. The route sees
+  // only this block: the credential state, the env NAME (already public in
+  // the editor), whether an attempt happened, whether it carried the
+  // credential, and a fixed cause. Never the key value, its provenance, the
+  // endpoint, or any transport exception text. Config (state) and transport
+  // (attempt) stay separate: a present key is not a sent key, and a cached
+  // answer is neither. A fresh cache makes no claim at all about the key
+  // (attempted=false, no cause), and a SUCCESS never claims the endpoint does
+  // not need a key — it only says the listing came back without one.
+  function modelListingAuthDiagnosis(plan, result) {
+    const credentialState = plan && ['none', 'configured', 'missing', 'unavailable'].includes(plan.credentialState)
+      ? plan.credentialState : 'none';
+    const envKey = typeof plan?.envKey === 'string' && plan.envKey ? plan.envKey : '';
+    const attempt = result && result.attempt && typeof result.attempt === 'object' ? result.attempt : null;
+    const attempted = !!attempt;
+    const credentialSent = !!(attempt && attempt.credentialSent === true);
+    let cause = '';
+    if (attempt) {
+      if (result.status === 'api') {
+        // Success: the only outcome worth a line is the anonymous one, stated
+        // as a fact about THIS listing, never about the endpoint in general.
+        if (!credentialSent) cause = 'anonymous-success';
+      } else if (attempt.category === 'network' || attempt.category === 'timeout') {
+        cause = 'endpoint-unreachable';
+      } else if (attempt.category === 'invalid-response') {
+        cause = 'invalid-response';
+      } else if (attempt.category === 'http') {
+        const status = Number.isSafeInteger(attempt.status) ? attempt.status : 0;
+        if (status === 403) cause = 'access-denied'; // with OR without the key: permissions or policy
+        else if (status === 401) {
+          if (credentialSent) cause = 'key-rejected';
+          else if (credentialState === 'unavailable') cause = 'credential-unavailable';
+          else cause = 'missing-key';
+        } else cause = 'provider-error';
+      }
+    }
+    return {
+      credentialState,
+      ...(envKey ? { envKey } : {}),
+      attempted,
+      credentialSent,
+      ...(cause ? { cause } : {}),
+    };
+  }
+  async function discoverEngineModels(engineId, opts = {}) {
+    const id = String(engineId || '');
+    if (!id || id.length > 64 || !/^[A-Za-z0-9._-]+$/.test(id)) {
+      const e = new Error('engine non valido'); e.status = 400; throw e;
+    }
+    const defs = reloadDefs();
+    const declared = findEngine(defs, id);
+    let profile = null;
+    let spec = null;
+    if (declared && declared.managed) {
+      spec = normalizeManagedSpec(declared.managed, { extraModels: extraModelsFrom(defs), engineId: declared.id });
+      profile = spec ? profileFor(spec.client, spec.provider, spec.credentialProfile || '') : null;
+    }
+    if (!profile) {
+      // Not declared (or not resolvable): the catalog profile alone still
+      // knows client, provider, endpoint and credential key.
+      profile = CATALOG.find((p) => p.id === id) || null;
+      spec = profile ? { client: profile.client, provider: profile.provider, ...(profile.credentialProfile ? { credentialProfile: profile.credentialProfile } : {}) } : null;
+    }
+    if (!profile) { const e = new Error(`engine sconosciuto: ${id}`); e.status = 404; throw e; }
+    const plan = engineModelDiscoveryPlan(profile, spec, cfg, home, id);
+    if (!plan) {
+      // No HTTP listing to interrogate (login/native flows, local providers
+      // without a base URL): an honest empty answer, never an error, so the
+      // editor stays usable. The UI hides the section on `supported: false`.
+      return { engine: id, supported: false, source: 'unsupported', models: [] };
+    }
+    // User layer: models declared in fleet.json for this engine (or its
+    // profile) — the values the operator chose, always on top and never
+    // rewritten by discovery.
+    const extraModels = extraModelsFrom(defs);
+    const userModels = [];
+    const seenUser = new Set();
+    for (const key of (id !== profile.id ? [id, profile.id] : [id])) {
+      for (const m of declaredModelsFor(extraModels, key)) {
+        if (seenUser.has(m.id)) continue;
+        seenUser.add(m.id);
+        userModels.push({
+          id: m.id,
+          ...(Number.isFinite(m.contextWindow) ? { contextWindow: m.contextWindow } : {}),
+          ...(Number.isFinite(m.maxTokens) ? { maxTokens: m.maxTokens } : {}),
+          // definitions.js parses the three flags as typed booleans: `false`
+          // is an explicit operator answer, not an absence. Keep it exactly
+          // like that, or a provider's `true` would override the user layer
+          // here (the merge itself already handles booleans correctly).
+          ...(typeof m.tools === 'boolean' ? { tools: m.tools } : {}),
+          ...(typeof m.vision === 'boolean' ? { vision: m.vision } : {}),
+          ...(typeof m.reasoning === 'boolean' ? { reasoning: m.reasoning } : {}),
+        });
+      }
+    }
+    const backupModels = backupModelsFor(profile);
+    const wanted = [...new Set([...userModels, ...backupModels].map((m) => m.id))].slice(0, 32);
+    const result = await engineModelDiscovery.discoverEngine({
+      ...plan,
+      home,
+      userModels, backupModels,
+      ...(wanted.length ? { detailIds: wanted } : {}),
+      publicCatalog: { provider: profile.provider, baseUrl: plan.baseUrl, ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}) },
+      ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
+      ...(opts.refresh === true ? { noCache: true } : {}),
+    });
+    // Curated response: `plan` (baseUrl, apiKey) stays out; apiModels is
+    // already merged (with provenance) into `models`.
+    // `backupValues` rides along only for fields NO layer could fill: the
+    // internal catalog's proposal for the missing-data dialog. A field any
+    // layer answered carries no proposal — the dialog asks for what nobody
+    // knows, and the operator's confirmation is what turns a proposal into a
+    // user value.
+    const internalIndex = internalModelIndex(profile);
+    const models = result.models.map((m) => {
+      const backupValues = {};
+      for (const field of ['contextWindow', 'maxTokens']) {
+        if (m[field] === undefined) {
+          const known = internalValueFor(internalIndex, m.id);
+          if (known && known[field] !== undefined) backupValues[field] = known[field];
+        }
+      }
+      return Object.keys(backupValues).length ? { ...m, backupValues } : m;
+    });
+    return {
+      engine: id,
+      supported: true,
+      source: result.source,
+      status: result.status,
+      stale: result.stale === true,
+      error: result.error || '',
+      auth: modelListingAuthDiagnosis(plan, result),
+      ...(result.fetchedAt ? { fetchedAt: result.fetchedAt } : {}),
+      ...(result.publicCatalog ? { publicCatalog: result.publicCatalog } : {}),
+      models,
+      cap: DISCOVERY_PROPOSAL_CAP,
+    };
+  }
+
   async function close() { await launchBroker.close(); if (leaseManager) leaseManager.close(); }
 
   return {
@@ -1723,7 +1927,7 @@ async function createBuiltinFleet(cfg = {}) {
     defineEngine, editEngine, removeEngine,
     defineCell, editCell, removeCell, importCell, restoreCells, restoreEngines,
     schema, definitions, capabilities,
-    credentialStatus, setLocalCredential, removeLocalCredential, testModel,
+    credentialStatus, setLocalCredential, removeLocalCredential, testModel, discoverEngineModels,
     defineModel, editModel, removeModel, close,
     // Fetta 2b: il lease Live esposto alle route /api/lease, che il bridge
     // MCP delle celle consuma per register/refresh/recovery. Assente se il

package/lib/fleet/definitions.js

@@ -196,7 +196,7 @@ const MODEL_ID_MAX = 128;
 
 function parseModel(m) {
   if (!m || typeof m !== 'object' || Array.isArray(m)) return null;
-  const allowed = new Set(['id', 'engine', 'label', 'contextWindow', 'maxTokens', 'reasoning']);
+  const allowed = new Set(['id', 'engine', 'label', 'contextWindow', 'maxTokens', 'tools', 'vision', 'reasoning']);
   if (Object.keys(m).some((k) => !allowed.has(k))) return null;
   const id = typeof m.id === 'string' ? m.id.trim() : '';
   // Stessa forma accettata dal gate dei modelli: nessun byte di controllo, un
@@ -221,6 +221,15 @@ function parseModel(m) {
     if (typeof m.reasoning !== 'boolean') return null;
     out.reasoning = m.reasoning;
   }
+  // `tools` e `vision`: stessi booleani tipizzati di `reasoning`. `false` e'
+  // una RISPOSTA dell'operatore, non un'assenza: si conserva tale, cosi' la
+  // scoperta (user > api > public) non lascia salire il `true` di un catalogo
+  // sopra la parola esplicita di chi dichiara.
+  for (const key of ['tools', 'vision']) {
+    if (m[key] === undefined) continue;
+    if (typeof m[key] !== 'boolean') return null;
+    out[key] = m[key];
+  }
   return out;
 }
 

package/lib/fleet/managed.js

@@ -10,6 +10,7 @@ const { execFile } = require('node:child_process');
 const { ENV_KEY_RE } = require('./env-key.js');
 const { termuxRuntimePaths } = require('../runtime/env.js');
 const { readCredentialStore, safePrivateDir } = require('./credentials.js');
+const { createModelDiscovery } = require('./model-discovery.js');
 const { argomentiHookCodex, gateVersione, gatePiattaforma, EVENTI_CODEX } = require('./codex-hooks.js');
 
 const OLLAMA_CLOUD_MODELS = Object.freeze([
@@ -1295,6 +1296,70 @@ function applyStoreNeutralization(env, spec, profile) {
 }
 
 let ollamaCache = { at: 0, models: [] };
+// Shared model-discovery instance: per-engine HTTP collectors + disk cache.
+// The engine's key is resolved HERE (credentialSources/credential, the same
+// path the launcher uses) and handed to the module in memory only.
+const sharedModelDiscovery = createModelDiscovery();
+// Map a managed profile (+ normalized spec) to its model-discovery plan:
+// collector kind, endpoint base URL and the engine's own credential. This is
+// the per-engine wiring point for the discovery lots: same endpoint and same
+// key the launcher would use, never a parallel configuration. Returns null
+// when the profile has no HTTP listing to interrogate (login/native/local
+// runtimes without an HTTP endpoint, or a custom base URL that is not set).
+// `engineId` is the DECLARED engine id and becomes the cache key: two custom
+// engines of the same client resolve to one shared profile, and keying their
+// model cache by profile id would hand the second engine the first one's
+// listing without ever interrogating its endpoint. Without a declared id
+// (catalog engines) the profile id IS the engine id.
+function engineModelDiscoveryPlan(profile, spec, cfg, home, engineId) {
+  if (!profile) return null;
+  const specBase = spec && typeof spec.baseUrl === 'string' && /^https?:\/\//i.test(spec.baseUrl) ? spec.baseUrl : '';
+  const profileBase = typeof profile.endpoint === 'string' && /^https?:\/\//i.test(profile.endpoint) ? profile.endpoint : '';
+  let collector = null;
+  let baseUrl = '';
+  if (profile.provider === 'ollama' || profile.provider === 'ollama-cloud') {
+    collector = 'ollama';
+    baseUrl = specBase || profileBase || 'http://127.0.0.1:11434';
+  } else if (profile.provider === 'lmstudio') {
+    collector = 'lmstudio';
+    baseUrl = specBase || 'http://127.0.0.1:1234';
+  } else if (profile.protocol === 'anthropic_messages') {
+    collector = 'anthropic';
+    baseUrl = specBase || profileBase;
+  } else if (profile.protocol === 'openai_responses' || profile.protocol === 'openai_completions') {
+    collector = 'openai-compat';
+    baseUrl = specBase || profileBase;
+  } else {
+    return null;
+  }
+  if (!baseUrl) return null;
+  const plan = { engine: engineId || profile.id, collector, baseUrl };
+  // The credential STATE travels with the plan, from the same resolution the
+  // launcher uses (the caller never re-reads the credential sources):
+  // none / configured / missing / unavailable, plus the env NAME when one
+  // exists and the editor already shows it. A file that exists but cannot be
+  // read is "unavailable", not "missing" — the same distinction describeManaged
+  // makes for launching. The value, its provenance paths/hashes and any
+  // exception text stay here: the plan hands the key to the collector in
+  // memory and nothing else leaves.
+  try {
+    const cred = credential(profile, spec || {}, cfg, home, { blocked: [] });
+    plan.credentialState = !cred ? 'unavailable'
+      : cred.value ? 'configured'
+        : cred.source === 'unreadable' ? 'unavailable'
+          : cred.source === 'missing' ? 'missing'
+            : 'none';
+    if (cred && cred.value) plan.apiKey = cred.value;
+    const envKey = cred && typeof cred.envKey === 'string' ? cred.envKey : '';
+    // 'login'/'none' resolve to a pseudo key name: never invent one for them.
+    if (plan.credentialState !== 'none' && ENV_KEY_RE.test(envKey || '')) plan.envKey = envKey;
+  } catch (_) {
+    // Resolution itself failed: the key is not known to be missing — it is
+    // unavailable, and an anonymous rejection will say exactly that.
+    plan.credentialState = 'unavailable';
+  }
+  return plan;
+}
 async function discoverOllamaModels(opts = {}) {
   const now = Date.now(); const ttl = opts.ttlMs === undefined ? 30000 : opts.ttlMs;
   if (!opts.noCache && ollamaCache.models.length && now - ollamaCache.at < ttl) return [...ollamaCache.models];
@@ -1307,13 +1372,22 @@ async function discoverOllamaModels(opts = {}) {
       || sources.local.OLLAMA_API_KEY || sources.shell.OLLAMA_API_KEY || sources.keys.OLLAMA_API_KEY
       || sources.legacy.OLLAMA_API_KEY;
     if (!apiKey) throw new Error('OLLAMA_API_KEY missing');
-    const response = await fetchImpl('https://ollama.com/api/tags', { headers: { authorization: `Bearer ${apiKey}` }, signal: AbortSignal.timeout?.(2500) });
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    const body = await response.json(); const available = new Set();
-    for (const item of Array.isArray(body.models) ? body.models : []) {
-      const name = typeof item?.name === 'string' ? item.name : '';
-      if (/^[A-Za-z0-9._-]+(?::[A-Za-z0-9._-]+)?$/.test(name) && name.length <= 128) available.add(name);
-    }
+    // Generalized on the model-discovery module (ollama collector): the HTTP
+    // call, the sanitized errors and the last-good-on-disk cache live there.
+    // The EXTERNAL behavior stays: the wired list filtered by what the API
+    // declares live, and the full wired list when nothing is known.
+    const layer = await sharedModelDiscovery.fetchEngineModels({
+      engine: 'ollama-cloud', collector: 'ollama', baseUrl: 'https://ollama.com',
+      apiKey, home, fetchImpl, timeoutMs: 2500, ttlMs: ttl, ...(opts.noCache ? { noCache: true } : {}),
+    });
+    // IL CONTRATTO ESTERNO NON CAMBIA (mandato L1: generalizzare «senza
+    // cambiarne il comportamento esterno»). Un valore buono di ieri servito al
+    // posto dell'API non e' una risposta di oggi: vale come "non si sa niente",
+    // e allora si torna alla shortlist cablata intera. Solo `api` (o un valore
+    // fresco, non stantio) dice cosa e' vivo adesso.
+    const conosciuto = layer.status === 'api' || (layer.status === 'cache' && layer.stale === false);
+    if (!conosciuto) throw new Error(layer.error || 'ollama-cloud discovery unavailable');
+    const available = new Set(layer.apiModels.map((m) => m.id));
     const models = OLLAMA_CLOUD_MODELS.filter((name) => available.has(name));
     if (!models.length) throw new Error('no cloud models');
     ollamaCache = { at: now, models }; return [...models];
@@ -3091,7 +3165,7 @@ module.exports = {
   OPENCODE_GO_MESSAGES_MODELS, OPENCODE_GO_RESPONSES_MODELS, OPENCODE_GO_CHAT_MODELS, OPENCODE_GO_LIMITS,
   OPENCODE_GO_ANTHROPIC_ROOT, OPENCODE_GO_API_BASE,
   CLIENT_LABELS, CLIENT_ORDER, engineClient, ordinaEngine, isStandardClient, normalizeManagedSpec, profileFor,
-  defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, resolveManagedEngine, needsExplicitNode,
+  defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, engineModelDiscoveryPlan, resolveManagedEngine, needsExplicitNode,
   discoverPiModels, EXTERNAL_DISCOVERY_TIMEOUT_MS, parseEnvFile, parseProviderShellFile, findBinary, publicCatalog, writePiProviderExtension, customCatalogFor,
   codexSurfaceNames, writeCellCodexProfile,
   writeVlCellPrompt, vlSystemAppendGate,