cascade-ai 0.73.0 → 0.74.0

package/dist/cli.cjs

@@ -1819,7 +1819,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.73.0";
+    CASCADE_VERSION = "0.74.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -2317,10 +2317,17 @@ var init_cost = __esm({
 });
 
 // src/providers/base.ts
-var BaseProvider;
+var ProviderUnreachableError, BaseProvider;
 var init_base = __esm({
   "src/providers/base.ts"() {
     init_cost();
+    ProviderUnreachableError = class extends Error {
+      transient = true;
+      constructor(message) {
+        super(message);
+        this.name = "ProviderUnreachableError";
+      }
+    };
     BaseProvider = class {
       config;
       model;
@@ -3108,6 +3115,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;
 var init_gemini = __esm({
   "src/providers/gemini.ts"() {
@@ -3199,9 +3218,7 @@ var init_gemini = __esm({
       }
       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");
           }
@@ -3232,18 +3249,61 @@ var init_gemini = __esm({
           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) {
@@ -6323,6 +6383,7 @@ init_gemini();
 init_ollama();
 init_openai_compatible();
 init_openai();
+init_base();
 
 // src/core/router/selector.ts
 init_constants();
@@ -8582,12 +8643,28 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     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);
@@ -8597,7 +8674,13 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
         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);
@@ -20645,7 +20728,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",