cascade-ai 0.73.0 → 0.74.0

package/dist/index.d.cts

@@ -2063,6 +2063,21 @@ declare class CascadeRouter extends EventEmitter {
      * Used to populate the desktop model pickers with the user's real models.
      */
     getAvailableModels(): ModelInfo[];
+    /**
+     * Why each configured provider failed its availability probe, kept so the
+     * surfaces can say something better than "add an API key" to a user who
+     * already has one. Cleared and refilled by each detectAvailableProviders().
+     */
+    private probeFailures;
+    /**
+     * What stopped the configured providers from being usable, if anything.
+     * Empty when every configured provider passed — or when none was configured,
+     * which is a different problem with a different answer.
+     */
+    providerProbeFailures(): Array<{
+        provider: ProviderType;
+        reason: string;
+    }>;
     /** Logs why a configured provider failed its availability probe. */
     private emitProbeFailure;
     private detectAvailableProviders;

package/dist/index.d.ts

@@ -2063,6 +2063,21 @@ declare class CascadeRouter extends EventEmitter {
      * Used to populate the desktop model pickers with the user's real models.
      */
     getAvailableModels(): ModelInfo[];
+    /**
+     * Why each configured provider failed its availability probe, kept so the
+     * surfaces can say something better than "add an API key" to a user who
+     * already has one. Cleared and refilled by each detectAvailableProviders().
+     */
+    private probeFailures;
+    /**
+     * What stopped the configured providers from being usable, if anything.
+     * Empty when every configured provider passed — or when none was configured,
+     * which is a different problem with a different answer.
+     */
+    providerProbeFailures(): Array<{
+        provider: ProviderType;
+        reason: string;
+    }>;
     /** Logs why a configured provider failed its availability probe. */
     private emitProbeFailure;
     private detectAvailableProviders;

package/dist/index.js

@@ -1871,7 +1871,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.73.0";
+var CASCADE_VERSION = "0.74.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -2377,6 +2377,13 @@ function buildTokenUsage(inputTokens, outputTokens, model) {
 }
 
 // src/providers/base.ts
+var ProviderUnreachableError = class extends Error {
+  transient = true;
+  constructor(message) {
+    super(message);
+    this.name = "ProviderUnreachableError";
+  }
+};
 var BaseProvider = class {
   config;
   model;
@@ -3097,6 +3104,18 @@ function toGeminiFunctionCalls(toolCalls) {
     }
   }));
 }
+function isGeminiAuthStatus(status) {
+  return status === 400 || status === 401 || status === 403;
+}
+async function describeGeminiError(resp) {
+  try {
+    const body = await resp.json();
+    const detail = body?.error?.message ?? body?.error?.status;
+    return detail ? ` \u2014 ${detail}` : "";
+  } catch {
+    return "";
+  }
+}
 var GeminiProvider = class extends BaseProvider {
   client;
   constructor(config, model) {
@@ -3180,9 +3199,7 @@ var GeminiProvider = class extends BaseProvider {
   }
   async listModels() {
     try {
-      const resp = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models?key=${this.config.apiKey}`
-      );
+      const resp = await this.fetchModelList();
       if (!resp.ok) {
         return Object.values(MODELS).filter((m) => m.provider === "gemini");
       }
@@ -3213,18 +3230,61 @@ var GeminiProvider = class extends BaseProvider {
       return Object.values(MODELS).filter((m) => m.provider === "gemini");
     }
   }
+  /**
+   * Is this KEY usable — not "does one particular model answer".
+   *
+   * This used to call countTokens() against `this.model.id`, which the router
+   * fills from the first Gemini entry in the bundled catalogue. That made the
+   * whole provider's fate depend on one hard-coded model id: a key that cannot
+   * reach that one model — retired, not enabled for the key's project, served
+   * on a different API version — failed the probe, and because every later step
+   * is gated on the result (`validateCloudProviderModels` and
+   * `discoverProviderModels` both return early for an unavailable provider) the
+   * real model list was never fetched. Gemini vanished entirely, and the CLI
+   * reported "add a provider API key first" about a key that was present and
+   * working.
+   *
+   * Listing models asks the account-level question instead, the same one
+   * OpenAI's probe asks, and it is the same request `listModels()` already
+   * makes for discovery.
+   *
+   * Throws rather than returning false. The router logs the reason it catches,
+   * and "bad key, wrong endpoint/deployment, or unreachable" — three guesses,
+   * no answer — is what made this take a user report to find. A swallowed probe
+   * error is the same defect that once hid a misconfigured Azure deployment.
+   */
   async isAvailable() {
+    if (!this.config.apiKey) throw new Error("no Gemini API key configured");
+    let resp;
     try {
-      await this.client.models.countTokens({
-        model: this.model.id,
-        contents: [{ role: "user", parts: [{ text: "ping" }] }]
-      });
-      return true;
-    } catch {
-      return false;
+      resp = await this.fetchModelList();
+    } catch (err) {
+      throw new ProviderUnreachableError(
+        `could not reach the Gemini API: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
+    if (resp.ok) return true;
+    const status = `HTTP ${resp.status} ${resp.statusText}`.trim();
+    const detail = await describeGeminiError(resp);
+    if (isGeminiAuthStatus(resp.status)) {
+      throw new Error(`Gemini rejected the API key: ${status}${detail}`);
+    }
+    throw new ProviderUnreachableError(`Gemini model list failed: ${status}${detail}`);
   }
   // ── Private ──────────────────────────────────
+  /**
+   * The account's model list. One place so the availability probe and
+   * discovery cannot ask different questions of the same endpoint.
+   *
+   * The key goes in a header, not the query string: a URL carries into proxy
+   * logs, error reports and shell history, and this one would carry the key
+   * with it.
+   */
+  fetchModelList() {
+    return fetch("https://generativelanguage.googleapis.com/v1beta/models", {
+      headers: { "x-goog-api-key": this.config.apiKey ?? "" }
+    });
+  }
   buildContents(messages, extraImages) {
     const contents = [];
     for (const m of messages) {
@@ -5949,12 +6009,28 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
     return this.selector?.getAllAvailableModels() ?? [];
   }
   // ── Private ──────────────────────────────────
+  /**
+   * Why each configured provider failed its availability probe, kept so the
+   * surfaces can say something better than "add an API key" to a user who
+   * already has one. Cleared and refilled by each detectAvailableProviders().
+   */
+  probeFailures = /* @__PURE__ */ new Map();
+  /**
+   * What stopped the configured providers from being usable, if anything.
+   * Empty when every configured provider passed — or when none was configured,
+   * which is a different problem with a different answer.
+   */
+  providerProbeFailures() {
+    return [...this.probeFailures].map(([provider, reason]) => ({ provider, reason }));
+  }
   /** Logs why a configured provider failed its availability probe. */
   emitProbeFailure(type, reason) {
+    this.probeFailures.set(type, reason);
     console.warn(`[router] provider "${type}" is not available: ${reason}`);
   }
   async detectAvailableProviders(configs) {
     const available = /* @__PURE__ */ new Set();
+    this.probeFailures.clear();
     const checks = configs.map(async (cfg) => {
       try {
         const testModel = this.getAnyModelForProvider(cfg.type);
@@ -5964,7 +6040,13 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
         if (ok) available.add(cfg.type);
         else this.emitProbeFailure(cfg.type, "availability check returned false (bad key, wrong endpoint/deployment, or unreachable)");
       } catch (err) {
-        this.emitProbeFailure(cfg.type, err instanceof Error ? err.message : String(err));
+        const reason = err instanceof Error ? err.message : String(err);
+        if (err instanceof ProviderUnreachableError) {
+          available.add(cfg.type);
+          console.warn(`[router] provider "${cfg.type}" probe did not complete: ${reason} \u2014 continuing with it enabled`);
+          return;
+        }
+        this.emitProbeFailure(cfg.type, reason);
       }
     });
     await Promise.allSettled(checks);
@@ -18653,7 +18735,16 @@ ${finalOutput}` : ""
     const selector = this.router.getSelector();
     const model = options.fastAnswerModel ? selector.selectForTier(tier, options.fastAnswerModel) : selector.getCandidatesForTier(tier)[0] ?? selector.selectForTier(tier);
     if (!model) {
-      throw new Error("No model is available for a fast answer \u2014 add a provider API key first.");
+      const failures2 = this.router.providerProbeFailures();
+      const context = failures2.length ? ` Configured providers: ${failures2.map((f) => `${f.provider}: ${f.reason}`).join("; ")}` : "";
+      if (options.fastAnswerModel) {
+        throw new Error(
+          `No model is available for a fast answer: the pinned model "${options.fastAnswerModel}" could not be resolved \u2014 check it is spelled correctly and served by a configured provider.${context}`
+        );
+      }
+      throw new Error(
+        failures2.length ? `No model is available for a fast answer.${context}` : "No model is available for a fast answer \u2014 add a provider API key first."
+      );
     }
     this.recordDecision(
       "model",