cascade-ai 0.52.0 → 0.54.0

package/dist/cli.js

@@ -51,6 +51,12 @@ import cron from 'node-cron';
 // Cascade AI — Multi-tier AI Orchestration System
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -1740,7 +1746,7 @@ var CASCADE_VERSION, CASCADE_CONFIG_FILE, CASCADE_DB_FILE, CASCADE_DASHBOARD_SEC
 var init_constants = __esm({
   "src/constants.ts"() {
     init_pricing();
-    CASCADE_VERSION = "0.52.0";
+    CASCADE_VERSION = "0.54.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -2739,26 +2745,14 @@ var init_openai = __esm({
 // src/providers/azure.ts
 var azure_exports = {};
 __export(azure_exports, {
+  AZURE_BASE_MODELS: () => AZURE_BASE_MODELS,
   AzureOpenAIProvider: () => AzureOpenAIProvider,
   azureModelForDeployment: () => azureModelForDeployment,
   inferAzureBaseModel: () => inferAzureBaseModel
 });
 function inferAzureBaseModel(deploymentName) {
   const n = deploymentName.toLowerCase();
-  const rules = [
-    [/gpt-?5\.5/, "gpt-5.5"],
-    [/gpt-?5\.4.*mini/, "gpt-5.4-mini"],
-    [/gpt-?5\.4/, "gpt-5.4"],
-    [/gpt-?5.*nano/, "gpt-5-nano"],
-    [/gpt-?5.*mini/, "gpt-5-mini"],
-    [/gpt-?5/, "gpt-5"],
-    [/gpt-?4\.1-nano/, "gpt-4.1-nano"],
-    [/gpt-?4\.1-mini/, "gpt-4.1-mini"],
-    [/gpt-?4\.1/, "gpt-4.1"],
-    [/gpt-?4o-mini/, "gpt-4o-mini"],
-    [/gpt-?4o/, "gpt-4o"]
-  ];
-  for (const [re, base] of rules) if (re.test(n)) return base;
+  for (const [re, base] of AZURE_BASE_MODEL_RULES) if (re.test(n)) return base;
   return null;
 }
 function azureModelForDeployment(cfg) {
@@ -2803,13 +2797,27 @@ function azureModelForDeployment(cfg) {
     supportsToolUse: true
   };
 }
-var DEFAULT_AZURE_API_VERSION, AzureOpenAIProvider;
+var DEFAULT_AZURE_API_VERSION, AZURE_BASE_MODEL_RULES, AZURE_BASE_MODELS, AzureOpenAIProvider;
 var init_azure = __esm({
   "src/providers/azure.ts"() {
     init_constants();
     init_openai();
     init_pricing();
     DEFAULT_AZURE_API_VERSION = "2024-12-01-preview";
+    AZURE_BASE_MODEL_RULES = [
+      [/gpt-?5\.5/, "gpt-5.5"],
+      [/gpt-?5\.4.*mini/, "gpt-5.4-mini"],
+      [/gpt-?5\.4/, "gpt-5.4"],
+      [/gpt-?5.*nano/, "gpt-5-nano"],
+      [/gpt-?5.*mini/, "gpt-5-mini"],
+      [/gpt-?5/, "gpt-5"],
+      [/gpt-?4\.1-nano/, "gpt-4.1-nano"],
+      [/gpt-?4\.1-mini/, "gpt-4.1-mini"],
+      [/gpt-?4\.1/, "gpt-4.1"],
+      [/gpt-?4o-mini/, "gpt-4o-mini"],
+      [/gpt-?4o/, "gpt-4o"]
+    ];
+    AZURE_BASE_MODELS = AZURE_BASE_MODEL_RULES.map(([, id]) => id);
     AzureOpenAIProvider = class extends OpenAIProvider {
       constructor(config, model) {
         const rawUrl = config.baseUrl ?? AZURE_BASE_URL_TEMPLATE.replace("{resource}", "YOUR_RESOURCE");
@@ -5510,6 +5518,26 @@ var ConfigManager = class {
   }
 };
 
+// src/tools/tool-name.ts
+var MCP_TOOL_PREFIX = "mcp__";
+function sanitizeToolNameSegment(segment) {
+  const cleaned = segment.replace(/[^a-zA-Z0-9-]+/g, "_");
+  let start = 0;
+  let end = cleaned.length;
+  while (start < end && cleaned[start] === "_") start++;
+  while (end > start && cleaned[end - 1] === "_") end--;
+  return cleaned.slice(start, end) || "_";
+}
+function mcpToolName(serverName, toolName) {
+  return `${MCP_TOOL_PREFIX}${sanitizeToolNameSegment(serverName)}__${sanitizeToolNameSegment(toolName)}`;
+}
+function isMcpToolName(name) {
+  return name.startsWith(MCP_TOOL_PREFIX);
+}
+function mcpServerPrefix(serverName) {
+  return `${MCP_TOOL_PREFIX}${sanitizeToolNameSegment(serverName)}__`;
+}
+
 // src/cli/utils/terminal-input.ts
 var PASTE_START = "\x1B[200~";
 var PASTE_END = "\x1B[201~";
@@ -5834,7 +5862,21 @@ var ModelSelector = class {
     this.availableProviders = availableProviders;
     this.availableModels = new Map(Object.entries(MODELS));
   }
+  /**
+   * Verdicts from earlier runs about ids that 404 on this account. Consulted
+   * BEFORE a model enters the pool, which is the only placement that helps: a
+   * T3 wave runs concurrently, so filtering after the first failure still lets
+   * every other worker in the wave call the dead id.
+   */
+  deadModels;
+  setDeadModelStore(store) {
+    this.deadModels = store;
+    for (const [id, m] of [...this.availableModels]) {
+      if (this.deadModels.isDead(m.provider, m.id)) this.availableModels.delete(id);
+    }
+  }
   addDynamicModel(model) {
+    if (this.deadModels?.isDead(model.provider, model.id)) return;
     this.availableModels.set(model.id, model);
     if (!(model.id in MODELS)) this.discovered.add(normalizeModelId(model.id));
   }
@@ -6241,6 +6283,121 @@ var LocalRequestQueue = class {
   }
 };
 
+// src/core/router/dead-models.ts
+var DEAD_MODEL_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function deadModelKey(provider, modelId) {
+  return `${provider}:${modelId}`;
+}
+var DeadModelStore = class {
+  constructor(persistence, opts = {}) {
+    this.persistence = persistence;
+    this.ttlMs = opts.ttlMs ?? DEAD_MODEL_TTL_MS;
+    this.now = opts.now ?? (() => Date.now());
+    this.restore();
+  }
+  persistence;
+  records = /* @__PURE__ */ new Map();
+  ttlMs;
+  now;
+  restore() {
+    if (!this.persistence) return;
+    try {
+      for (const r of this.persistence.load()) {
+        if (!this.isExpired(r)) this.records.set(r.key, r);
+      }
+    } catch {
+    }
+  }
+  isExpired(r) {
+    return this.now() - r.lastSeenAt > this.ttlMs;
+  }
+  flush() {
+    if (!this.persistence) return;
+    try {
+      this.persistence.save([...this.records.values()]);
+    } catch {
+    }
+  }
+  /**
+   * Record that a model was found dead. Returns true when this is the first
+   * time (so the caller can log it once rather than once per concurrent
+   * worker in the wave that discovered it).
+   */
+  record(provider, modelId, reason) {
+    const key = deadModelKey(provider, modelId);
+    const now = this.now();
+    const existing = this.records.get(key);
+    if (existing && !this.isExpired(existing)) {
+      existing.lastSeenAt = now;
+      existing.hits += 1;
+      this.flush();
+      return false;
+    }
+    this.records.set(key, {
+      key,
+      provider,
+      modelId,
+      reason,
+      firstSeenAt: now,
+      lastSeenAt: now,
+      hits: 1
+    });
+    this.flush();
+    return true;
+  }
+  /** True when this model is known dead and the verdict has not expired. */
+  isDead(provider, modelId) {
+    const r = this.records.get(deadModelKey(provider, modelId));
+    if (!r) return false;
+    if (this.isExpired(r)) {
+      this.records.delete(r.key);
+      this.flush();
+      return false;
+    }
+    return true;
+  }
+  /** Why a model is considered dead, for /why and the models command. */
+  reasonFor(provider, modelId) {
+    const r = this.records.get(deadModelKey(provider, modelId));
+    return r && !this.isExpired(r) ? r.reason : null;
+  }
+  /** Live records, expired ones filtered out. */
+  list() {
+    const live = [...this.records.values()].filter((r) => !this.isExpired(r));
+    return live.sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+  }
+  /**
+   * Forget a verdict — used when the user fixes the underlying problem (adds
+   * the model to their project, gets quota) and wants it retried now rather
+   * than after the TTL.
+   */
+  forget(provider, modelId) {
+    const removed = this.records.delete(deadModelKey(provider, modelId));
+    if (removed) this.flush();
+    return removed;
+  }
+  clear() {
+    this.records.clear();
+    this.flush();
+  }
+};
+function fileDeadModelPersistence(filePath) {
+  return {
+    load() {
+      const fs32 = __require("fs");
+      if (!fs32.existsSync(filePath)) return [];
+      const raw = JSON.parse(fs32.readFileSync(filePath, "utf-8"));
+      return Array.isArray(raw) ? raw : [];
+    },
+    save(records) {
+      const fs32 = __require("fs");
+      const path37 = __require("path");
+      fs32.mkdirSync(path37.dirname(filePath), { recursive: true });
+      fs32.writeFileSync(filePath, JSON.stringify(records, null, 2));
+    }
+  };
+}
+
 // src/core/router/index.ts
 init_constants();
 init_cost();
@@ -6830,6 +6987,26 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   localQueue;
   taskAnalyzer;
   pendingFeedbackSource;
+  /** Models known dead for this account (404 / retired / not enabled). */
+  deadModels = new DeadModelStore();
+  /**
+   * Back the dead-model memory with durable storage (a JSON file on desktop, a
+   * per-user table in the cloud). Without one the verdicts still work, but only
+   * for the life of the process — so tomorrow's run pays the same wave of 404s
+   * to learn the same fact.
+   */
+  setDeadModelStore(store) {
+    this.deadModels = store;
+    this.selector.setDeadModelStore(store);
+  }
+  /** Models known dead for this account, for `cascade models` and /why. */
+  listDeadModels() {
+    return this.deadModels.list();
+  }
+  /** Retry a model the user has since fixed, without waiting out the TTL. */
+  forgetDeadModel(provider, modelId) {
+    return this.deadModels.forget(provider, modelId);
+  }
   worldStateDB;
   privacyPaths;
   guidanceQueue;
@@ -7194,6 +7371,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       }
       if (isModelNotFoundError(errMsg)) {
         this.selector.removeModel(model.id);
+        const firstSighting = this.deadModels.record(model.provider, model.id, errMsg);
+        if (firstSighting) this.emit("model:dead", { provider: model.provider, modelId: model.id, reason: errMsg });
         const depth = (options._notFoundDepth ?? 0) + 1;
         const next = depth <= 3 ? this.selector.selectForTier(tier) : null;
         if (next && next.id !== model.id) {
@@ -10997,9 +11176,16 @@ var CAPABILITIES = [
     api: "openai-images"
   },
   {
+    // Imagen, not `gemini-3-pro-image`. That id appears on Google's PRICING
+    // page but 404s on `:predict` ("not found for API version v1beta, or is not
+    // supported for predict") — the Gemini image models are called through
+    // generateContent with an image response modality, while `:predict` is the
+    // Imagen shape this executor implements. A billing line item is not proof
+    // of a callable endpoint, which is the assumption that put the wrong id
+    // here in the first place.
     modality: "image",
     provider: "gemini",
-    modelId: "gemini-3-pro-image",
+    modelId: "imagen-4.0-generate-001",
     api: "gemini-predict"
   },
   // ── Speech (text → audio) ──
@@ -13144,7 +13330,7 @@ var McpToolWrapper = class extends BaseTool {
     this.mcpClient = mcpClient;
     this.serverName = serverName;
     this.toolName = toolName;
-    this.name = `mcp::${serverName}::${toolName}`;
+    this.name = mcpToolName(serverName, toolName);
     this.description = `[MCP:${serverName}] ${description}`;
     this.inputSchema = inputSchema;
   }
@@ -16102,6 +16288,13 @@ var Cascade = class _Cascade extends EventEmitter {
       }
     });
     this.toolRegistry = new ToolRegistry(this.config.tools, workspacePath);
+    try {
+      const nodePath = __require("path");
+      this.router.setDeadModelStore(new DeadModelStore(
+        fileDeadModelPersistence(nodePath.join(workspacePath, ".cascade", "dead-models.json"))
+      ));
+    } catch {
+    }
     this.multimodal = new MultimodalRegistry(
       (this.config.providers ?? []).map((p) => p.type)
     );
@@ -19505,13 +19698,13 @@ ${msg.content}`).join("\n\n");
         const cascade = cascadeRef.current;
         if (!cascade) return "Cascade not initialized.";
         const toolRegistry = cascade.getToolRegistry();
-        const tools = toolRegistry.getToolDefinitions().filter((t) => t.name.startsWith("mcp::"));
+        const tools = toolRegistry.getToolDefinitions().filter((t) => isMcpToolName(t.name));
         if (tools.length === 0) return "No MCP tools connected.";
         const servers = /* @__PURE__ */ new Set();
         tools.forEach((t) => servers.add(t.name.split("::")[1]));
         const lines = [`Connected MCP Servers (${servers.size}):`];
         for (const server of servers) {
-          const serverTools = tools.filter((t) => t.name.startsWith(`mcp::${server}::`));
+          const serverTools = tools.filter((t) => t.name.startsWith(mcpServerPrefix(server)));
           lines.push(`
 \u25CF ${server} (${serverTools.length} tools)`);
           serverTools.forEach((t) => lines.push(`  - ${t.name.split("::")[2]} \u2014 ${t.description.replace(`[MCP:${server}] `, "")}`));