cascade-ai 0.53.0 → 0.54.0

package/dist/index.d.cts

@@ -904,6 +904,16 @@ declare class ModelSelector {
      */
     private discovered;
     constructor(availableProviders: Set<ProviderType>);
+    /**
+     * 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.
+     */
+    private deadModels?;
+    setDeadModelStore(store: {
+        isDead(provider: string, modelId: string): boolean;
+    }): void;
     addDynamicModel(model: ModelInfo): void;
     /** Record the ids a provider's API actually serves (discovery). Empty ⇒ ignored. */
     setValidatedModels(provider: ProviderType, ids: string[]): void;
@@ -1077,6 +1087,60 @@ declare class TaskAnalyzer {
     static clearCache(): void;
 }
 
+interface DeadModelRecord {
+    /** `provider:modelId` — the same key shape the failover event reports. */
+    key: string;
+    provider: string;
+    modelId: string;
+    /** Provider's own words, kept verbatim so the user can act on them. */
+    reason: string;
+    firstSeenAt: number;
+    lastSeenAt: number;
+    /** How many times this model has been found dead. */
+    hits: number;
+}
+/**
+ * Where records live between runs. Desktop/CLI back this with a JSON file,
+ * the cloud server with a per-user table. Both are synchronous-optional: a
+ * store that fails to load must never stop a run.
+ */
+interface DeadModelPersistence {
+    load(): DeadModelRecord[];
+    save(records: DeadModelRecord[]): void;
+}
+declare class DeadModelStore {
+    private persistence?;
+    private records;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(persistence?: DeadModelPersistence | undefined, opts?: {
+        ttlMs?: number;
+        now?: () => number;
+    });
+    private restore;
+    private isExpired;
+    private flush;
+    /**
+     * 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: string, modelId: string, reason: string): boolean;
+    /** True when this model is known dead and the verdict has not expired. */
+    isDead(provider: string, modelId: string): boolean;
+    /** Why a model is considered dead, for /why and the models command. */
+    reasonFor(provider: string, modelId: string): string | null;
+    /** Live records, expired ones filtered out. */
+    list(): DeadModelRecord[];
+    /**
+     * 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: string, modelId: string): boolean;
+    clear(): void;
+}
+
 declare class MemoryStore {
     private db;
     constructor(dbPath: string);
@@ -1509,6 +1573,19 @@ declare class CascadeRouter extends EventEmitter {
     private localQueue;
     private taskAnalyzer?;
     private pendingFeedbackSource?;
+    /** Models known dead for this account (404 / retired / not enabled). */
+    private deadModels;
+    /**
+     * 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: DeadModelStore): void;
+    /** Models known dead for this account, for `cascade models` and /why. */
+    listDeadModels(): ReturnType<DeadModelStore['list']>;
+    /** Retry a model the user has since fixed, without waiting out the TTL. */
+    forgetDeadModel(provider: string, modelId: string): boolean;
     private worldStateDB?;
     private privacyPaths?;
     private guidanceQueue?;

package/dist/index.d.ts

@@ -904,6 +904,16 @@ declare class ModelSelector {
      */
     private discovered;
     constructor(availableProviders: Set<ProviderType>);
+    /**
+     * 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.
+     */
+    private deadModels?;
+    setDeadModelStore(store: {
+        isDead(provider: string, modelId: string): boolean;
+    }): void;
     addDynamicModel(model: ModelInfo): void;
     /** Record the ids a provider's API actually serves (discovery). Empty ⇒ ignored. */
     setValidatedModels(provider: ProviderType, ids: string[]): void;
@@ -1077,6 +1087,60 @@ declare class TaskAnalyzer {
     static clearCache(): void;
 }
 
+interface DeadModelRecord {
+    /** `provider:modelId` — the same key shape the failover event reports. */
+    key: string;
+    provider: string;
+    modelId: string;
+    /** Provider's own words, kept verbatim so the user can act on them. */
+    reason: string;
+    firstSeenAt: number;
+    lastSeenAt: number;
+    /** How many times this model has been found dead. */
+    hits: number;
+}
+/**
+ * Where records live between runs. Desktop/CLI back this with a JSON file,
+ * the cloud server with a per-user table. Both are synchronous-optional: a
+ * store that fails to load must never stop a run.
+ */
+interface DeadModelPersistence {
+    load(): DeadModelRecord[];
+    save(records: DeadModelRecord[]): void;
+}
+declare class DeadModelStore {
+    private persistence?;
+    private records;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(persistence?: DeadModelPersistence | undefined, opts?: {
+        ttlMs?: number;
+        now?: () => number;
+    });
+    private restore;
+    private isExpired;
+    private flush;
+    /**
+     * 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: string, modelId: string, reason: string): boolean;
+    /** True when this model is known dead and the verdict has not expired. */
+    isDead(provider: string, modelId: string): boolean;
+    /** Why a model is considered dead, for /why and the models command. */
+    reasonFor(provider: string, modelId: string): string | null;
+    /** Live records, expired ones filtered out. */
+    list(): DeadModelRecord[];
+    /**
+     * 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: string, modelId: string): boolean;
+    clear(): void;
+}
+
 declare class MemoryStore {
     private db;
     constructor(dbPath: string);
@@ -1509,6 +1573,19 @@ declare class CascadeRouter extends EventEmitter {
     private localQueue;
     private taskAnalyzer?;
     private pendingFeedbackSource?;
+    /** Models known dead for this account (404 / retired / not enabled). */
+    private deadModels;
+    /**
+     * 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: DeadModelStore): void;
+    /** Models known dead for this account, for `cascade models` and /why. */
+    listDeadModels(): ReturnType<DeadModelStore['list']>;
+    /** Retry a model the user has since fixed, without waiting out the TTL. */
+    forgetDeadModel(provider: string, modelId: string): boolean;
     private worldStateDB?;
     private privacyPaths?;
     private guidanceQueue?;

package/dist/index.js

@@ -41,6 +41,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;
 };
@@ -1845,7 +1851,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.53.0";
+var CASCADE_VERSION = "0.54.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -3658,7 +3664,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));
   }
@@ -4065,6 +4085,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 fs25 = __require("fs");
+      if (!fs25.existsSync(filePath)) return [];
+      const raw = JSON.parse(fs25.readFileSync(filePath, "utf-8"));
+      return Array.isArray(raw) ? raw : [];
+    },
+    save(records) {
+      const fs25 = __require("fs");
+      const path26 = __require("path");
+      fs25.mkdirSync(path26.dirname(filePath), { recursive: true });
+      fs25.writeFileSync(filePath, JSON.stringify(records, null, 2));
+    }
+  };
+}
+
 // src/utils/retry.ts
 var CascadeCancelledError = class extends Error {
   constructor(reason) {
@@ -4658,6 +4793,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;
@@ -5022,6 +5177,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) {
@@ -8817,9 +8974,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) ──
@@ -14391,6 +14555,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)
     );