@yemi33/minions 0.1.2045 → 0.1.2047

package/engine/runtimes/claude.js

@@ -522,6 +522,27 @@ function parseStreamChunk(line) {
 
 // ── Error Normalization ──────────────────────────────────────────────────────
 
+// Pull a model id out of an Anthropic-style invalid-model error string. Claude
+// CLI surfaces these as either plain stderr ("Unknown model: claude-x") or as
+// the API's structured error body ({"type":"error","error":{"message":
+// "model: claude-x: not a valid model"}}). Returns null when no obvious model
+// token is present — parseError falls back to "unknown" in that case.
+function _extractInvalidModelName(text) {
+  if (!text) return null;
+  const patterns = [
+    /(?:unknown|invalid)\s+model(?:\s+id)?\s*[:=]?\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?/i,
+    /model\s+['"`]([^'"`]+)['"`]\s+(?:not\s+found|is\s+invalid|is\s+unknown|invalid)/i,
+    /model\s*[:=]\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?\s*[:,]\s*(?:not\s+a\s+valid\s+model|not\s+found|invalid)/i,
+    /model\s+(?:not\s+found|invalid|unknown)\s*[:=]?\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?/i,
+    /"model"\s*:\s*"([^"]+)"/i,
+  ];
+  for (const re of patterns) {
+    const m = text.match(re);
+    if (m && m[1]) return m[1];
+  }
+  return null;
+}
+
 /**
  * Inspect raw agent output (stdout/stderr concatenated by the caller) and map
  * common Claude error patterns onto a normalized shape:
@@ -531,6 +552,11 @@ function parseStreamChunk(line) {
  *   - 'auth-failure'      — invalid API key / credit-card / org-blocked
  *   - 'context-limit'     — context window exhausted
  *   - 'budget-exceeded'   — `--max-budget-usd` ceiling hit
+ *   - 'model-unavailable' — model not available. Two flavors distinguished by
+ *                           `retriable`: retriable=true for transient upstream
+ *                           overload (503/overloaded_error — engine retries
+ *                           with `--fallback-model`); retriable=false for an
+ *                           invalid/typo'd model id (user must fix config).
  *   - 'crash'             — CLI crashed (segfault, panic, "Internal error")
  *   - null                — no recognised pattern
  *
@@ -553,6 +579,20 @@ function parseError(rawOutput) {
   if (/budget.*exceed|max.budget.usd.*reach|cost.*limit.*exceed/i.test(lower)) {
     return { message: 'Claude budget cap exceeded — check your Claude account spending limit.', code: 'budget-exceeded', retriable: false };
   }
+  // W-mpmwxni2000c25c7-a — Configured model isn't a valid Anthropic id (typo,
+  // deprecated id, invalid_request_error on `model:` field). Claude has no
+  // listModels() catalog (capabilities.modelDiscovery === false), so the
+  // message points the operator at Settings instead of enumerating ids.
+  // Match BEFORE the overload branch — the overload regex matches
+  // `model.*unavailable` and would otherwise swallow "model X is invalid".
+  if (/unknown\s+model|model\s+not\s+found|invalid\s+model|model_not_found|not\s+a\s+valid\s+model|400[^a-z]+(?:bad\s+request|invalid|model)/i.test(text)) {
+    const name = _extractInvalidModelName(text) || 'unknown';
+    return {
+      message: `Model "${name}" not available for runtime claude. Configure a valid model in Settings → Engine.`,
+      code: 'model-unavailable',
+      retriable: false,
+    };
+  }
   // W-mpg6isvy000xca4d — Anthropic overload / 503 / service-unavailable. Claude's
   // own `--fallback-model` only fires on 429 (rate-limit); these failure modes
   // hang the agent until the 5h timeout. Classify as MODEL_UNAVAILABLE so the
@@ -828,5 +868,6 @@ module.exports = {
   permissionBypassFlags: PERMISSION_BYPASS_FLAGS,
   // Exposed for unit tests — never imported by engine code
   _CLAUDE_SHORTHANDS,
+  _extractInvalidModelName,
   THINKING_BLOCK_TYPES,
 };

package/engine/runtimes/copilot.js

@@ -785,6 +785,58 @@ function parseStreamChunk(line) {
 
 // ── Error Normalization ─────────────────────────────────────────────────────
 
+// In-memory model-discovery cache used by parseError's invalid-model branch
+// (W-mpmwxni2000c25c7-a). parseError is synchronous — to enrich the error
+// message with the live model catalog without adding a per-error HTTP round
+// trip, the engine pre-warms this cache via `_warmModelCache()` (e.g. during
+// preflight or the first listModels() call from the dashboard). Concurrent
+// callers share the in-flight promise so the API is only hit once even when
+// multiple agents fail simultaneously. `_modelDiscoveryResults` stores the
+// resolved catalog (or `[]` on failure); parseError reads it synchronously.
+let _modelDiscoveryResults = null;
+let _modelDiscoveryPromise = null;
+
+async function _warmModelCache(opts = {}) {
+  if (_modelDiscoveryPromise) return _modelDiscoveryPromise;
+  if (Array.isArray(_modelDiscoveryResults)) return _modelDiscoveryResults;
+  _modelDiscoveryPromise = listModels(opts).then(
+    (models) => { _modelDiscoveryResults = Array.isArray(models) ? models : []; return _modelDiscoveryResults; },
+    () => { _modelDiscoveryResults = []; return _modelDiscoveryResults; },
+  );
+  try {
+    return await _modelDiscoveryPromise;
+  } finally {
+    _modelDiscoveryPromise = null;
+  }
+}
+
+function _resetModelCache({ models = null } = {}) {
+  _modelDiscoveryResults = Array.isArray(models) ? models : (models === null ? null : []);
+  _modelDiscoveryPromise = null;
+}
+
+// Pull a model id out of a Copilot/Anthropic-style invalid-model error string.
+// Handles the shapes observed in the wild:
+//   "Unknown model: banana"
+//   "model not found: gpt-5.4"
+//   "model 'gpt-x' is invalid"
+//   "Invalid model id: claude-sonnet"
+//   {"error":"model_not_found","model":"gpt-x"} / {"model":"gpt-x"}
+function _extractInvalidModelName(text) {
+  if (!text) return null;
+  const patterns = [
+    /(?:unknown|invalid)\s+model(?:\s+id)?\s*[:=]?\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?/i,
+    /model\s+['"`]([^'"`]+)['"`]\s+(?:not\s+found|is\s+invalid|is\s+unknown|invalid)/i,
+    /model\s+(?:not\s+found|invalid|unknown)\s*[:=]?\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?/i,
+    /"model"\s*:\s*"([^"]+)"/i,
+  ];
+  for (const re of patterns) {
+    const m = text.match(re);
+    if (m && m[1]) return m[1];
+  }
+  return null;
+}
+
 function _collectErrorSignal(rawOutput) {
   const text = rawOutput == null ? '' : String(rawOutput);
   if (!text) return '';
@@ -835,6 +887,27 @@ function _collectErrorSignal(rawOutput) {
   return sawJsonLine ? '' : text;
 }
 
+function _readModelIdsFromDiskCache() {
+  try {
+    const text = fs.readFileSync(MODELS_CACHE, 'utf8');
+    const obj = JSON.parse(text);
+    if (!obj || !Array.isArray(obj.models)) return null;
+    const ids = obj.models.map(m => m && m.id ? String(m.id) : null).filter(Boolean);
+    return ids.length > 0 ? ids : null;
+  } catch { return null; }
+}
+
+function _resolveCachedModelIds() {
+  // In-memory cache (seeded by `_warmModelCache()` or test `_resetModelCache`)
+  // wins over disk so unit tests stay hermetic. Production code that hasn't
+  // warmed the in-memory cache still gets the catalog via the disk file that
+  // `engine/model-discovery.js#getRuntimeModels` populates during preflight.
+  if (Array.isArray(_modelDiscoveryResults) && _modelDiscoveryResults.length > 0) {
+    return _modelDiscoveryResults.map(m => m && m.id ? String(m.id) : null).filter(Boolean);
+  }
+  return _readModelIdsFromDiskCache();
+}
+
 function parseError(rawOutput) {
   const text = _collectErrorSignal(rawOutput);
   if (!text) return { message: '', code: null, retriable: true };
@@ -845,6 +918,24 @@ function parseError(rawOutput) {
   if (hasExplicitAuthFailure || hasAuthStatusCode) {
     return { message: text, code: 'auth-failure', retriable: false };
   }
+  // W-mpmwxni2000c25c7-a — Configured model isn't in the Copilot catalog
+  // (typo, deprecated id, 400-style invalid-model response). Classify as
+  // MODEL_UNAVAILABLE with retriable: false so the engine surfaces an
+  // actionable error instead of looping the dispatch. Must match BEFORE the
+  // overload branch — the overload regex catches `model.*unavailable`,
+  // which would otherwise swallow legitimate "model not found" responses.
+  if (/unknown\s+model|model\s+not\s+found|invalid\s+model|model_not_found|400[^a-z]+(?:bad\s+request|invalid|model)|model.*\b400\b/i.test(text)) {
+    const name = _extractInvalidModelName(text) || 'unknown';
+    const ids = _resolveCachedModelIds();
+    const tail = (ids && ids.length > 0)
+      ? `Available models: ${ids.join(', ')}`
+      : 'Configure a valid model in Settings → Engine.';
+    return {
+      message: `Model "${name}" not available for runtime copilot. ${tail}`,
+      code: 'model-unavailable',
+      retriable: false,
+    };
+  }
   // W-mpg6isvy000xca4d — Copilot has no --fallback-model flag; classify
   // overloaded / 503 / service_unavailable as MODEL_UNAVAILABLE so the engine
   // retry can OVERRIDE --model with engine.copilotFallbackModel. Match before
@@ -856,9 +947,6 @@ function parseError(rawOutput) {
   if (/rate limit|too many requests|\b429\b/i.test(text)) {
     return { message: text, code: 'rate-limit', retriable: true };
   }
-  if (/unknown model|model not found|model.*invalid|invalid model/i.test(text)) {
-    return { message: text, code: 'unknown-model', retriable: false };
-  }
   if (/budget.*exceed|premium.*limit.*reach|quota.*exceed/i.test(lower)) {
     return { message: text, code: 'budget-exceeded', retriable: false };
   }
@@ -1198,6 +1286,12 @@ module.exports = {
   _pickStandaloneCopilotFromOutput,
   _resolveNpmCopilotJsEntry,
   _isCachedBinUsable,
+  // W-mpmwxni2000c25c7-a — invalid-model error-path helpers. `_warmModelCache`
+  // populates the in-memory model catalog so parseError can enrich its
+  // "Model X not available" message without a per-error HTTP round trip.
+  _warmModelCache,
+  _resetModelCache,
+  _extractInvalidModelName,
   CAPS_SCHEMA_VERSION,
   KNOWN_EVENT_TYPES,
 };

package/engine/shared.js

@@ -1856,7 +1856,7 @@ const ENGINE_DEFAULTS = {
   // Engine code MUST go through the resolveAgent*/resolveCc* helpers below;
   // never read these fields directly. New runtimes are added by registering
   // an adapter in engine/runtimes/index.js — these defaults stay stable.
-  defaultCli: 'claude',          // fleet-wide CLI runtime (must be a key in engine/runtimes/index.js)
+  defaultCli: 'copilot',         // fleet-wide CLI runtime (must be a key in engine/runtimes/index.js); flipped from 'claude' in W-mpmwxkk40007c995 — Copilot is now the primary runtime, Claude remains supported as an opt-in
   defaultModel: undefined,       // fleet-wide model; undefined = let the runtime adapter pick its own default
   ccCli: undefined,              // CC/doc-chat CLI override; undefined = inherit defaultCli (independent of agent path)
   ccModel: undefined,            // CC/doc-chat model override; undefined = inherit defaultModel
@@ -1879,6 +1879,7 @@ const ENGINE_DEFAULTS = {
   removeWorktreeFailureTtlMs: 24 * 60 * 60 * 1000, // stale failed paths are forgotten after a day
   removeWorktreeFailureMaxEntries: 1000, // bound failed-worktree retry suppression cache
   ccMaxTurns: 50, // max tool-use turns per CC/doc-chat call before CLI stops (per response, not per session)
+  ccTurnTimeoutMs: 300000, // W-mpmwxni2000c25c7-b: wall-clock cap per CC/doc-chat turn; on expiry the in-flight LLM call is aborted and the handler surfaces `{code:'cc-turn-timeout', retriable:true}` instead of hanging the UI
   docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity (LRU; sessions are non-expiring otherwise)
   ccLiveStreamMaxAgeMs: 30 * 60 * 1000, // hard cap reconnect buffers if abort/cleanup stalls
   metricsFlushIntervalMs: 10000, // batch trackEngineUsage writes to metrics.json — flushed every 10s instead of per-call to cut lock contention and dashboard mtime churn
@@ -2084,7 +2085,7 @@ function _isMeaningful(v) {
  * Resolve the CLI runtime for a per-agent spawn. Priority:
  *   1. `agent.cli`              — per-agent override
  *   2. `engine.defaultCli`      — fleet default
- *   3. `ENGINE_DEFAULTS.defaultCli` ('claude') — hardcoded fallback
+ *   3. `ENGINE_DEFAULTS.defaultCli` ('copilot') — hardcoded fallback
  *
  * Does NOT fall through to `engine.ccCli`. CC and agents are independent paths.
  */
@@ -2098,7 +2099,7 @@ function resolveAgentCli(agent, engine) {
  * Resolve the CLI runtime for the Command Center / doc-chat. Priority:
  *   1. `engine.ccCli`           — CC-only override
  *   2. `engine.defaultCli`      — fleet default
- *   3. `ENGINE_DEFAULTS.defaultCli` ('claude') — hardcoded fallback
+ *   3. `ENGINE_DEFAULTS.defaultCli` ('copilot') — hardcoded fallback
  *
  * Does NOT inspect any agent overrides. CC has no notion of "which agent" —
  * it's a fleet-wide singleton.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2045",
+  "version": "0.1.2047",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"