@mmmbuto/nexuscrew 0.9.75 → 0.9.77

package/frontend/dist/index.html

@@ -11,7 +11,7 @@
   <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-DMfpKI3n.js"></script>
+  <script type="module" crossorigin src="/assets/index-Cgd3OQws.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-B9GW2LHm.css">
 </head>
 <body>

package/frontend/dist/version.json

@@ -1 +1 @@
-{"version":"0.9.75"}
+{"version":"0.9.77"}

package/lib/fleet/builtin.js

@@ -41,7 +41,7 @@ const {
   CATALOG, CLIENT_LABELS, CLIENT_ORDER, engineClient, ordinaEngine, isStandardClient,
   credential: resolveProfileCredential, extraModelsFrom, knownMcpServerNames, profileFor,
   normalizeManagedSpec, codexSurfaceNames,
-  engineModelDiscoveryPlan, ollamaCloudCatalogModels, declaredModelsFor, ALIBABA_PI_MODELS,
+  engineModelDiscoveryPlan, modelListingCredential, ollamaCloudCatalogModels, declaredModelsFor, ALIBABA_PI_MODELS,
 } = require('./managed.js');
 const { probeModel, probeCustomEndpoint } = require('./model-probe.js');
 const { createModelDiscovery, DISCOVERY_PROPOSAL_CAP } = require('./model-discovery.js');
@@ -965,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');
@@ -984,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)) {
@@ -1605,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: {
@@ -1771,6 +1779,67 @@ async function createBuiltinFleet(cfg = {}) {
     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 } : {}),
+    };
+  }
+  // Backup proposals for fields no layer could fill: the missing-data dialog
+  // offers what the internal catalog knows, and the operator's confirmation
+  // is what turns a proposal into a user value.
+  function withBackupDefaults(records, profile) {
+    const internalIndex = internalModelIndex(profile);
+    return (Array.isArray(records) ? records : []).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;
+    });
+  }
+
   async function discoverEngineModels(engineId, opts = {}) {
     const id = String(engineId || '');
     if (!id || id.length > 64 || !/^[A-Za-z0-9._-]+$/.test(id)) {
@@ -1791,16 +1860,10 @@ async function createBuiltinFleet(cfg = {}) {
       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.
+    // rewritten by discovery. Built BEFORE the plan: an engine without a
+    // listing still has ids worth enriching.
     const extraModels = extraModelsFrom(defs);
     const userModels = [];
     const seenUser = new Set();
@@ -1812,43 +1875,69 @@ async function createBuiltinFleet(cfg = {}) {
           id: m.id,
           ...(Number.isFinite(m.contextWindow) ? { contextWindow: m.contextWindow } : {}),
           ...(Number.isFinite(m.maxTokens) ? { maxTokens: m.maxTokens } : {}),
-          // definitions.js parses `reasoning` as a boolean: `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).
+          // 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);
+    // The plan is the HTTP listing, when the profile has one. When it does
+    // not, the same composition still runs with the API layer explicitly
+    // unavailable: known ids are enriched from the public snapshot, with no
+    // invented collector, request or auth attempt.
+    const plan = engineModelDiscoveryPlan(profile, spec, cfg, home, id);
+    // The active model is configuration the operator already chose. It counts
+    // as a known id only when it is the ONLY one: with a declared model or a
+    // profile backup the proposal already has its ids, and adding it would
+    // duplicate a row or change the order.
+    const activeModel = spec && typeof spec.model === 'string' ? spec.model.trim() : '';
+    const knownIds = !userModels.length && !backupModels.length && activeModel ? [activeModel] : [];
     const result = await engineModelDiscovery.discoverEngine({
-      ...plan,
+      ...(plan || {}),
+      engine: id,
       home,
       userModels, backupModels,
+      knownIds,
       ...(wanted.length ? { detailIds: wanted } : {}),
-      publicCatalog: { provider: profile.provider, baseUrl: plan.baseUrl, ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}) },
+      publicCatalog: {
+        provider: profile.provider,
+        ...(plan && plan.baseUrl ? { baseUrl: plan.baseUrl } : {}),
+        ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
+      },
       ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
       ...(opts.refresh === true ? { noCache: true } : {}),
+      ...(plan ? {} : { apiAvailable: false }),
     });
     // 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;
-    });
+    // already merged (with provenance) into `models`. `backupValues` rides
+    // along only for fields NO layer could fill.
+    const models = withBackupDefaults(result.models, profile);
+    if (!plan) {
+      const cred = modelListingCredential(profile, spec, cfg, home);
+      return {
+        engine: id,
+        supported: false,
+        source: 'unsupported',
+        status: result.status,
+        stale: false,
+        error: '',
+        auth: {
+          credentialState: cred.credentialState,
+          ...(cred.envKey ? { envKey: cred.envKey } : {}),
+          attempted: false,
+          credentialSent: false,
+        },
+        ...(result.publicCatalog ? { publicCatalog: result.publicCatalog } : {}),
+        models,
+        cap: DISCOVERY_PROPOSAL_CAP,
+      };
+    }
     return {
       engine: id,
       supported: true,
@@ -1856,6 +1945,7 @@ async function createBuiltinFleet(cfg = {}) {
       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,

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

@@ -1313,32 +1313,72 @@ const sharedModelDiscovery = createModelDiscovery();
 // (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 : '';
+  const httpUrl = (value) => (typeof value === 'string' && /^https?:\/\//i.test(value) ? value : '');
+  // Endpoint precedence follows the launcher: the normalized spec, the
+  // generated provider extension, then the profile's own endpoint. A native
+  // provider has no explicit endpoint here, and is never pointed at another
+  // client's profile.
+  const specBase = httpUrl(spec && spec.baseUrl);
+  const extensionBase = httpUrl(profile.piExtension && profile.piExtension.baseUrl);
+  const profileBase = httpUrl(profile.endpoint);
+  // The wire name may come hyphenated (`openai-completions`, the Pi form) or
+  // underscored (the normalized form). It is the same transport.
+  const rawWire = spec && typeof spec.protocol === 'string' && spec.protocol
+    ? spec.protocol : (typeof profile.protocol === 'string' ? profile.protocol : '');
+  const wire = rawWire.replace(/-/g, '_');
   let collector = null;
   let baseUrl = '';
   if (profile.provider === 'ollama' || profile.provider === 'ollama-cloud') {
+    // Ollama speaks its own listing API, whatever wire a client uses for chat.
     collector = 'ollama';
-    baseUrl = specBase || profileBase || 'http://127.0.0.1:11434';
+    baseUrl = specBase || extensionBase || 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') {
+    baseUrl = specBase || extensionBase || 'http://127.0.0.1:1234';
+  } else if (wire === 'anthropic_messages') {
     collector = 'anthropic';
-    baseUrl = specBase || profileBase;
-  } else if (profile.protocol === 'openai_responses' || profile.protocol === 'openai_completions') {
+    baseUrl = specBase || extensionBase || profileBase;
+  } else if (wire === 'openai_responses' || wire === 'openai_completions') {
     collector = 'openai-compat';
-    baseUrl = specBase || profileBase;
+    baseUrl = specBase || extensionBase || profileBase;
   } else {
+    // `pi_native`, login flows and any other client-owned wire: no explicit
+    // listing contract, so no collector. An explicit endpoint alone is not
+    // proof of a listing API.
     return null;
   }
   if (!baseUrl) return null;
-  const plan = { engine: engineId || profile.id, collector, baseUrl };
+  return { engine: engineId || profile.id, collector, baseUrl, ...modelListingCredential(profile, spec, cfg, home) };
+}
+
+// Credential resolution for a model listing, from the same path 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 value is handed to a collector in memory and nothing else leaves. An
+// engine with no listing still gets the STATE: the diagnosis refers to the
+// listing only, never to the client's own login.
+function modelListingCredential(profile, spec, cfg, home) {
+  const out = { credentialState: 'unavailable' };
   try {
-    const cred = credential(profile, spec || {}, cfg, home);
-    if (cred && cred.value) plan.apiKey = cred.value;
-  } catch (_) { /* discovery without a key: key-less local endpoints still list */ }
-  return plan;
+    const cred = credential(profile, spec || {}, cfg, home, { blocked: [] });
+    out.credentialState = !cred ? 'unavailable'
+      : cred.value ? 'configured'
+        : cred.source === 'unreadable' ? 'unavailable'
+          : cred.source === 'missing' ? 'missing'
+            : 'none';
+    if (cred && cred.value) out.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 (out.credentialState !== 'none' && ENV_KEY_RE.test(envKey || '')) out.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.
+    out.credentialState = 'unavailable';
+  }
+  return out;
 }
 async function discoverOllamaModels(opts = {}) {
   const now = Date.now(); const ttl = opts.ttlMs === undefined ? 30000 : opts.ttlMs;
@@ -3145,7 +3185,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, engineModelDiscoveryPlan, resolveManagedEngine, needsExplicitNode,
+  defaultDefinitions, defaultShellEngine, defaultAgyEngine, defaultKimiEngine, defaultGrokEngine, defaultVlEngine, describeManaged, describeCatalogCredential, discoverOllamaModels, engineModelDiscoveryPlan, modelListingCredential, resolveManagedEngine, needsExplicitNode,
   discoverPiModels, EXTERNAL_DISCOVERY_TIMEOUT_MS, parseEnvFile, parseProviderShellFile, findBinary, publicCatalog, writePiProviderExtension, customCatalogFor,
   codexSurfaceNames, writeCellCodexProfile,
   writeVlCellPrompt, vlSystemAppendGate,