cascade-ai 0.70.0 → 0.71.0

package/dist/cli.cjs

@@ -1806,11 +1806,11 @@ var init_pricing = __esm({
 });
 
 // src/constants.ts
-var CASCADE_VERSION, CASCADE_CONFIG_FILE, CASCADE_DB_FILE, CASCADE_DASHBOARD_SECRET_FILE, GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_CREDENTIALS_FILE, GLOBAL_RUNTIME_DB_FILE, DEFAULT_DASHBOARD_PORT, DEFAULT_CONTEXT_LIMIT, DEFAULT_AUTO_SUMMARIZE_AT, MODELS, T1_MODEL_PRIORITY, T2_MODEL_PRIORITY, T3_MODEL_PRIORITY, VISION_MODEL_PRIORITY, COMPLEXITY_T2_COUNT, THEME_NAMES, DEFAULT_THEME, OLLAMA_BASE_URL, LM_STUDIO_BASE_URL, AZURE_BASE_URL_TEMPLATE, GITHUB_MODELS_INFERENCE_URL, GITHUB_MODELS_CATALOG_URL, GITHUB_MODELS_API_VERSION, TOOL_NAMES, DEFAULT_APPROVAL_REQUIRED;
+var CASCADE_VERSION, CASCADE_CONFIG_FILE, CASCADE_DB_FILE, CASCADE_DASHBOARD_SECRET_FILE, GLOBAL_CONFIG_DIR, GLOBAL_DB_FILE, GLOBAL_KEYSTORE_FILE, GLOBAL_CREDENTIALS_FILE, GLOBAL_RUNTIME_DB_FILE, DEFAULT_DASHBOARD_PORT, DEFAULT_CONTEXT_LIMIT, DEFAULT_AUTO_SUMMARIZE_AT, MODELS, T1_MODEL_PRIORITY, T2_MODEL_PRIORITY, T3_MODEL_PRIORITY, VISION_MODEL_PRIORITY, COMPLEXITY_T2_COUNT, THEME_NAMES, DEFAULT_THEME, OLLAMA_BASE_URL, LM_STUDIO_BASE_URL, AZURE_BASE_URL_TEMPLATE, TOOL_NAMES, DEFAULT_APPROVAL_REQUIRED;
 var init_constants = __esm({
   "src/constants.ts"() {
     init_pricing();
-    CASCADE_VERSION = "0.70.0";
+    CASCADE_VERSION = "0.71.0";
     CASCADE_CONFIG_FILE = ".cascade/config.json";
     CASCADE_DB_FILE = ".cascade/memory.db";
     CASCADE_DASHBOARD_SECRET_FILE = ".cascade/dashboard-secret";
@@ -2209,9 +2209,6 @@ var init_constants = __esm({
     OLLAMA_BASE_URL = "http://localhost:11434";
     LM_STUDIO_BASE_URL = "http://localhost:1234";
     AZURE_BASE_URL_TEMPLATE = "https://{resource}.openai.azure.com";
-    GITHUB_MODELS_INFERENCE_URL = "https://models.github.ai/inference";
-    GITHUB_MODELS_CATALOG_URL = "https://models.github.ai/catalog/models";
-    GITHUB_MODELS_API_VERSION = "2026-03-10";
     TOOL_NAMES = {
       SHELL: "shell",
       FILE_READ: "file_read",
@@ -3369,222 +3366,6 @@ var init_net = __esm({
   }
 });
 
-// src/providers/github-models.ts
-var github_models_exports = {};
-__export(github_models_exports, {
-  GITHUB_MODELS_MAX_INPUT_TOKENS: () => GITHUB_MODELS_MAX_INPUT_TOKENS,
-  GITHUB_MODELS_MAX_OUTPUT_TOKENS: () => GITHUB_MODELS_MAX_OUTPUT_TOKENS,
-  GitHubModelsProvider: () => GitHubModelsProvider,
-  stripModelOwnerPrefix: () => stripModelOwnerPrefix
-});
-function stripModelOwnerPrefix(id) {
-  const slash = (id || "").indexOf("/");
-  return slash === -1 ? id : id.slice(slash + 1);
-}
-function pickString(o, keys) {
-  for (const k of keys) {
-    const v = o[k];
-    if (typeof v === "string" && v.length > 0) return v;
-  }
-  return void 0;
-}
-function pickNumber(o, keys) {
-  for (const k of keys) {
-    const v = k.includes(".") ? o[k.split(".")[0]]?.[k.split(".")[1]] : o[k];
-    if (typeof v === "number" && Number.isFinite(v) && v > 0) return v;
-  }
-  return void 0;
-}
-function looksVisionCapable(o) {
-  for (const k of ["supported_input_modalities", "input_modalities", "modalities", "capabilities"]) {
-    const v = o[k];
-    if (Array.isArray(v) && v.some((x) => typeof x === "string" && /image|vision/i.test(x))) return true;
-  }
-  return false;
-}
-function looksToolCapable(o) {
-  const params = o["supported_parameters"];
-  if (Array.isArray(params) && params.some((x) => typeof x === "string" && /^tools?$|function.?call/i.test(x))) {
-    return true;
-  }
-  for (const k of ["capabilities", "supported_output_modalities"]) {
-    const v = o[k];
-    if (Array.isArray(v) && v.some((x) => typeof x === "string" && /tool|function.?call/i.test(x))) return true;
-  }
-  const caps = o["capabilities"];
-  if (caps && typeof caps === "object" && !Array.isArray(caps)) {
-    const c = caps;
-    if (c["function_calling"] === true || c["tool_calling"] === true || c["tools"] === true) return true;
-  }
-  return false;
-}
-function parseNextLink(linkHeader) {
-  if (!linkHeader) return null;
-  for (const part of linkHeader.split(",")) {
-    const match = part.match(/<([^>]+)>\s*;\s*rel="next"/);
-    if (match) return match[1];
-  }
-  return null;
-}
-var GITHUB_MODELS_MAX_OUTPUT_TOKENS, GITHUB_MODELS_MAX_INPUT_TOKENS, DEFAULT_CONTEXT_WINDOW, GITHUB_MODELS_MAX_CATALOG_PAGES, GITHUB_MODELS_CATALOG_ORIGIN, GitHubModelsProvider;
-var init_github_models = __esm({
-  "src/providers/github-models.ts"() {
-    init_constants();
-    init_openai();
-    init_model_filter();
-    init_net();
-    GITHUB_MODELS_MAX_OUTPUT_TOKENS = 4e3;
-    GITHUB_MODELS_MAX_INPUT_TOKENS = 8e3;
-    DEFAULT_CONTEXT_WINDOW = 128e3;
-    GITHUB_MODELS_MAX_CATALOG_PAGES = 20;
-    GITHUB_MODELS_CATALOG_ORIGIN = new URL(GITHUB_MODELS_CATALOG_URL).origin;
-    GitHubModelsProvider = class extends OpenAIProvider {
-      constructor(config, model) {
-        super({ ...config, apiKey: config.apiKey ?? "" }, model);
-        this.useMaxCompletionTokens = isReasoningModel(stripModelOwnerPrefix(model.id));
-        this.client = new OpenAI__default.default({
-          apiKey: config.apiKey ?? "",
-          baseURL: GITHUB_MODELS_INFERENCE_URL,
-          defaultHeaders: { "X-GitHub-Api-Version": GITHUB_MODELS_API_VERSION, "User-Agent": "Cascade-AI" }
-        });
-      }
-      /**
-       * `OpenAIProvider.generateStream()` builds its request budget as
-       * `options.maxTokens ?? this.model.maxOutputTokens` — an explicit per-call
-       * `maxTokens` (T1Administrator's final compilation asks for 8,000, well
-       * above GitHub's real ~4K hard cap) wins outright and is sent unclamped.
-       * GitHub then rejects the request instead of answering, so a run routed to
-       * this provider for that step fails outright rather than getting a
-       * (perfectly serviceable, just shorter) completion. Clamp here, once, right
-       * before delegating to the inherited implementation, rather than teaching
-       * every caller GitHub's specific cap.
-       */
-      async generateStream(options, onChunk) {
-        const clamped = options.maxTokens !== void 0 && options.maxTokens > GITHUB_MODELS_MAX_OUTPUT_TOKENS ? { ...options, maxTokens: GITHUB_MODELS_MAX_OUTPUT_TOKENS } : options;
-        return super.generateStream(clamped, onChunk);
-      }
-      /**
-       * The catalog is a GitHub REST resource, not an OpenAI `/models` list, and
-       * wants GitHub's own header trio — the plain `Accept: application/json` the
-       * openai-compatible provider sends is not the same request.
-       */
-      catalogHeaders() {
-        return {
-          Accept: "application/vnd.github+json",
-          Authorization: `Bearer ${this.config.apiKey ?? ""}`,
-          "X-GitHub-Api-Version": GITHUB_MODELS_API_VERSION,
-          // GitHub's REST API rejects any request with no User-Agent — a plain 403
-          // regardless of how valid the PAT is. nodeHttpFetch is a thin wrapper
-          // over node:http/https, neither of which sets one the way a browser's
-          // fetch or a full HTTP client library would, so this has to be explicit.
-          "User-Agent": "Cascade-AI"
-        };
-      }
-      async listModels() {
-        const raw = [];
-        let url = GITHUB_MODELS_CATALOG_URL;
-        let pages = 0;
-        const visited = /* @__PURE__ */ new Set();
-        while (url && pages < GITHUB_MODELS_MAX_CATALOG_PAGES) {
-          if (visited.has(url)) break;
-          visited.add(url);
-          const res = await nodeHttpFetch(url, { headers: this.catalogHeaders() }, 0, {
-            allowedRedirectOrigin: GITHUB_MODELS_CATALOG_ORIGIN
-          });
-          if (!res.ok) throw new Error(`GitHub Models catalog ${url} returned HTTP ${res.status}`);
-          const body = await res.json();
-          const pageItems = Array.isArray(body) ? body : Array.isArray(body?.models) ? body.models : Array.isArray(body?.data) ? body.data : [];
-          raw.push(...pageItems);
-          const next = parseNextLink(res.headers.get("link"));
-          if (next) {
-            const resolved = new URL(next, url);
-            if (resolved.origin !== GITHUB_MODELS_CATALOG_ORIGIN) {
-              throw new Error(`Refusing cross-origin GitHub Models pagination URL: ${resolved.origin}`);
-            }
-            url = resolved.href;
-          } else {
-            url = null;
-          }
-          pages++;
-        }
-        const entries = raw.map((m) => {
-          if (typeof m === "string") {
-            return { id: m, name: m, contextWindow: DEFAULT_CONTEXT_WINDOW, vision: false, tools: false };
-          }
-          if (!m || typeof m !== "object") return void 0;
-          const o = m;
-          const id = pickString(o, ["id", "name", "model"]);
-          if (!id) return void 0;
-          return {
-            id,
-            name: pickString(o, ["friendly_name", "display_name", "name"]) ?? id,
-            contextWindow: pickNumber(o, [
-              "context_window",
-              "context_length",
-              "max_input_tokens",
-              "limits.max_input_tokens",
-              "limits.max_context_tokens"
-            ]) ?? DEFAULT_CONTEXT_WINDOW,
-            vision: looksVisionCapable(o),
-            tools: looksToolCapable(o)
-          };
-        }).filter((e) => e !== void 0);
-        if (entries.length === 0) return [];
-        const chat = entries.filter((e) => isChatModel(e.id));
-        return (chat.length ? chat : entries).map((e) => ({
-          id: e.id,
-          // full `owner/model` — what the API is addressed by
-          name: e.name,
-          provider: "github-models",
-          // GitHub's real per-request input cap, not the base model's larger one
-          // (see GITHUB_MODELS_MAX_INPUT_TOKENS above) — the same reasoning
-          // already applied to maxOutputTokens below, for the input side.
-          contextWindow: Math.min(e.contextWindow, GITHUB_MODELS_MAX_INPUT_TOKENS),
-          isVisionCapable: e.vision,
-          // A REAL $0, not a missing number — usage is bundled into the quota of
-          // the plan the PAT belongs to and is never billed per token, so
-          // `pricingUnknown: false` is the honest value (see the flag's contract in
-          // core/router/pricing.ts: 0 alone is ambiguous). Set here rather than in
-          // pricing-data.json because resolvePricing() matches exactly on
-          // provider|model|region with no wildcard: every catalog model would need
-          // a hand-curated row, and the next one GitHub adds would read as "cost
-          // unknown" — an inconsistent picture for a billing reality that is
-          // identical across the entire catalog.
-          //
-          // `isLocal` is the OTHER way to reach a real $0, and it is the wrong one:
-          // it means "runs on this machine" and carries consequences that are
-          // simply false for a hosted API — the shared concurrency-1
-          // LocalRequestQueue (serialising these calls behind actual Ollama GPU
-          // inference), the 300s local rather than 120s cloud inference timeout,
-          // and a literal "[local]" tag in `cascade models`.
-          inputCostPer1kTokens: 0,
-          outputCostPer1kTokens: 0,
-          pricingUnknown: false,
-          maxOutputTokens: GITHUB_MODELS_MAX_OUTPUT_TOKENS,
-          supportsStreaming: true,
-          // Not every catalog model supports function/tool calling — a hardcoded
-          // `true` sent `tools` to models that reject the parameter outright and
-          // never engaged t3-worker.ts's existing text-tool fallback (only an
-          // explicit `false` does). See looksToolCapable's own comment for why
-          // "not positively advertised" defaults to false rather than true here.
-          supportsToolUse: e.tools,
-          isLocal: false
-        }));
-      }
-      async isAvailable() {
-        try {
-          const res = await nodeHttpFetch(GITHUB_MODELS_CATALOG_URL, { headers: this.catalogHeaders() }, 0, {
-            allowedRedirectOrigin: GITHUB_MODELS_CATALOG_ORIGIN
-          });
-          return res.ok;
-        } catch {
-          return false;
-        }
-      }
-    };
-  }
-});
-
 // src/providers/ollama.ts
 var ollama_exports = {};
 __export(ollama_exports, {
@@ -4926,6 +4707,19 @@ Original error: ${err.message}`
     const rows = provider ? this.db.prepare("SELECT metadata FROM model_cache WHERE provider = ?").all(provider) : this.db.prepare("SELECT metadata FROM model_cache").all();
     return rows.map((r) => JSON.parse(r.metadata));
   }
+  /**
+   * Deletes cached rows for a provider type that no longer exists in
+   * `ProviderType`, so it takes a raw string rather than the union.
+   *
+   * Needed because the cache outlives the code: the REPL's loadCache() only
+   * re-discovers when the cache is EMPTY or older than 24h, so rows left
+   * behind by a removed provider read as "cache populated" and suppress
+   * discovery for the providers that replaced it — `/model` then shows a
+   * configured provider with zero models until the rows age out.
+   */
+  purgeCachedModelsForRetiredProvider(providerType) {
+    return this.db.prepare("DELETE FROM model_cache WHERE provider = ?").run(providerType).changes;
+  }
   clearModelCache(provider) {
     if (provider) {
       this.db.prepare("DELETE FROM model_cache WHERE provider = ?").run(provider);
@@ -5219,7 +5013,7 @@ Original error: ${err.message}`
   }
 };
 var ProviderConfigSchema = zod.z.object({
-  type: zod.z.enum(["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama", "github-models"]),
+  type: zod.z.enum(["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama"]),
   label: zod.z.string().optional(),
   apiKey: zod.z.string().optional(),
   baseUrl: zod.z.string().url().optional(),
@@ -5688,6 +5482,67 @@ function mergeGlobalCredentials(workspaceProviders, globalProviders) {
   }
   return merged;
 }
+
+// src/config/retired-providers.ts
+var RETIRED_PROVIDER_TYPES = {
+  "github-models": "GitHub retired GitHub Models on 30 July 2026; models.github.ai no longer responds."
+};
+function isRetiredProviderType(type) {
+  return typeof type === "string" && Object.hasOwn(RETIRED_PROVIDER_TYPES, type);
+}
+function didCleanupChangeAnything(c) {
+  return c.removed.length > 0 || c.clearedPins.length > 0;
+}
+function stripRetiredProviders(raw) {
+  const cleanup = { removed: [], clearedPins: [] };
+  if (typeof raw !== "object" || raw === null) return cleanup;
+  const cfg = raw;
+  if (Array.isArray(cfg["providers"])) {
+    const kept = cfg["providers"].filter((p) => {
+      const type = p?.type;
+      if (!isRetiredProviderType(type)) return true;
+      if (!cleanup.removed.includes(type)) cleanup.removed.push(type);
+      return false;
+    });
+    cfg["providers"] = kept;
+  }
+  cleanup.clearedPins = clearRetiredPins(cfg["models"]);
+  return cleanup;
+}
+function clearRetiredPins(models) {
+  const cleared = [];
+  if (typeof models !== "object" || models === null) return cleared;
+  const tiers = models;
+  for (const tier of ["t1", "t2", "t3"]) {
+    const pin = tiers[tier];
+    if (typeof pin !== "string") continue;
+    const prefix = pin.slice(0, pin.indexOf(":")).toLowerCase();
+    if (pin.includes(":") && isRetiredProviderType(prefix)) {
+      delete tiers[tier];
+      cleared.push(tier);
+    }
+  }
+  return cleared;
+}
+function filterRetiredCredentials(providers) {
+  const removed = [];
+  const kept = providers.filter((p) => {
+    if (!isRetiredProviderType(p.type)) return true;
+    if (!removed.includes(p.type)) removed.push(p.type);
+    return false;
+  });
+  return { kept, removed };
+}
+function describeCleanup(c) {
+  const parts = [];
+  for (const type of c.removed) {
+    parts.push(`removed the retired "${type}" provider (${RETIRED_PROVIDER_TYPES[type]})`);
+  }
+  if (c.clearedPins.length > 0) {
+    parts.push(`reset ${c.clearedPins.map((t) => t.toUpperCase()).join("/")} to Auto, since the pin named it`);
+  }
+  return `Cascade config migration: ${parts.join("; ")}.`;
+}
 var MCP_TOOL_PREFIX = "mcp__";
 var MAX_SEGMENT_LENGTH = 24;
 var SEGMENT_HASH_LENGTH = 8;
@@ -5871,7 +5726,7 @@ init_constants();
 var KEY_OPTIONAL_PROVIDER_TYPES = /* @__PURE__ */ new Set(["ollama", "openai-compatible"]);
 function hasUsableProvider(providers) {
   if (!providers?.length) return false;
-  return providers.some((p) => KEY_OPTIONAL_PROVIDER_TYPES.has(p.type) || !!p.apiKey);
+  return providers.some((p) => KEY_OPTIONAL_PROVIDER_TYPES.has(p.type) || !!p.apiKey || !!p.authToken);
 }
 var ConfigManager = class {
   config;
@@ -5881,6 +5736,29 @@ var ConfigManager = class {
   cascadeMd = null;
   workspacePath;
   globalDir;
+  /**
+   * What THIS load migrated out, if anything. Strictly per-load state: reset
+   * at the top of every `load()`, because two places read it as a statement
+   * about the load in progress — `injectEnvKeys()` asks whether an empty
+   * provider list was emptied by a retirement, and the end of `load()` warns
+   * and builds the user-facing notice from it. Left set, a second `load()` on
+   * the same instance (`startRepl()` does one after its setup wizard) would
+   * re-announce a migration that already happened and suppress the Ollama
+   * fallback for a list that is empty for some unrelated reason.
+   */
+  retiredCleanup;
+  /**
+   * Human-readable migration notice held for a UI to display. `console.warn`
+   * is not sufficient: the REPL clears the TTY immediately after load(), and
+   * the desktop emits from the main process where nothing is rendered.
+   */
+  pendingRetiredNotice;
+  /** Returns the pending migration notice once, then forgets it. */
+  takeRetiredNotice() {
+    const n = this.pendingRetiredNotice;
+    this.pendingRetiredNotice = void 0;
+    return n;
+  }
   /** `globalDirOverride` exists for tests — never point it at the real home dir there. */
   constructor(workspacePath = process.cwd(), globalDirOverride) {
     this.workspacePath = workspacePath;
@@ -5900,10 +5778,32 @@ var ConfigManager = class {
     this.cascadeMd = await loadCascadeMd(this.workspacePath);
     this.keystore = new Keystore(path34__default.default.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
     this.store = new MemoryStore(path34__default.default.join(this.workspacePath, CASCADE_DB_FILE));
+    const globalCreds = filterRetiredCredentials(loadGlobalCredentials(this.globalDir));
+    if (globalCreds.removed.length > 0) {
+      try {
+        saveGlobalCredentials(this.globalDir, globalCreds.kept);
+      } catch (err) {
+        console.warn(`Could not rewrite the global credential store: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      this.retiredCleanup = {
+        removed: [.../* @__PURE__ */ new Set([...this.retiredCleanup?.removed ?? [], ...globalCreds.removed])],
+        clearedPins: this.retiredCleanup?.clearedPins ?? []
+      };
+    }
     await this.injectEnvKeys();
-    this.config.providers = mergeGlobalCredentials(this.config.providers, loadGlobalCredentials(this.globalDir));
+    this.config.providers = mergeGlobalCredentials(this.config.providers, globalCreds.kept);
+    for (const type of Object.keys(RETIRED_PROVIDER_TYPES)) {
+      try {
+        this.store.purgeCachedModelsForRetiredProvider(type);
+      } catch {
+      }
+    }
     await this.ensureDefaultIdentity();
     if (mcpNamesChanged) await this.save();
+    if (this.retiredCleanup) {
+      console.warn(describeCleanup(this.retiredCleanup));
+      this.pendingRetiredNotice = describeCleanup(this.retiredCleanup);
+    }
   }
   getConfig() {
     return this.config;
@@ -5942,14 +5842,13 @@ var ConfigManager = class {
       anthropic: "ANTHROPIC_API_KEY",
       openai: "OPENAI_API_KEY",
       gemini: "GOOGLE_API_KEY",
-      azure: "AZURE_OPENAI_KEY",
+      azure: "AZURE_OPENAI_KEY"
       // Deliberately NOT `GITHUB_TOKEN`: that one is injected automatically by
       // GitHub Actions and is commonly exported in developer shells for `gh`
       // and git auth, and it will essentially never carry the fine-grained
       // `models: read` scope this provider needs. Adopting it would wire up a
       // provider that 403s on its first real call — a confusing failure for
       // something that is meant to be explicit opt-in BYOK.
-      "github-models": "GITHUB_MODELS_TOKEN"
     };
     const envKey = envMap[provider];
     if (envKey && process.env[envKey]) return process.env[envKey];
@@ -5961,10 +5860,21 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
+    this.retiredCleanup = void 0;
     const configPath = path34__default.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
       const raw = await fs11__default.default.readFile(configPath, "utf-8");
-      return validateConfig(JSON.parse(raw));
+      const parsed = JSON.parse(raw);
+      const cleanup = stripRetiredProviders(parsed);
+      if (didCleanupChangeAnything(cleanup)) {
+        this.retiredCleanup = cleanup;
+        try {
+          await fs11__default.default.writeFile(configPath, JSON.stringify(parsed, null, 2), "utf-8");
+        } catch (err) {
+          console.warn(`Could not persist the retired-provider migration: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      return validateConfig(parsed);
     } catch (err) {
       if (err.code === "ENOENT") {
         return validateConfig({});
@@ -5973,27 +5883,25 @@ var ConfigManager = class {
     }
   }
   async injectEnvKeys() {
-    const isFirstRun = this.config.providers.length === 0;
+    const wasEmpty = this.config.providers.length === 0;
+    const emptiedByRetirement = wasEmpty && !!this.retiredCleanup;
     const envProviders = [
       { env: "ANTHROPIC_API_KEY", type: "anthropic" },
       { env: "OPENAI_API_KEY", type: "openai" },
       { env: "GOOGLE_API_KEY", type: "gemini" },
-      { env: "AZURE_OPENAI_KEY", type: "azure" },
-      // See getApiKey() above for why this is GITHUB_MODELS_TOKEN and never
-      // the ambient GITHUB_TOKEN.
-      { env: "GITHUB_MODELS_TOKEN", type: "github-models" }
+      { env: "AZURE_OPENAI_KEY", type: "azure" }
     ];
     for (const { env, type } of envProviders) {
       const key = process.env[env];
       if (!key) continue;
       const existing = this.config.providers.find((p) => p.type === type);
-      if (!existing && isFirstRun) {
+      if (!existing && wasEmpty) {
         this.config.providers.push({ type, apiKey: key });
       } else if (existing && !existing.apiKey) {
         existing.apiKey = key;
       }
     }
-    if (isFirstRun && !this.config.providers.find((p) => p.type === "ollama")) {
+    if (wasEmpty && !emptiedByRetirement && !this.config.providers.find((p) => p.type === "ollama")) {
       this.config.providers.push({ type: "ollama" });
     }
   }
@@ -6363,7 +6271,6 @@ init_constants();
 init_anthropic();
 init_azure();
 init_gemini();
-init_github_models();
 init_ollama();
 init_openai_compatible();
 init_openai();
@@ -6371,7 +6278,6 @@ init_openai();
 // src/core/router/selector.ts
 init_constants();
 init_pricing();
-init_github_models();
 function normalizeModelId(id) {
   return id.replace(/^models\//, "").toLowerCase();
 }
@@ -6573,7 +6479,7 @@ var ModelSelector = class {
     if (overrideModelId.includes(":")) {
       const parts = overrideModelId.split(":");
       const prefix = parts[0].toLowerCase();
-      const validProviders = ["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama", "github-models"];
+      const validProviders = ["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama"];
       if (validProviders.includes(prefix)) {
         providerStr = prefix;
         actualId = parts.slice(1).join(":");
@@ -6593,31 +6499,6 @@ var ModelSelector = class {
       else if (this.availableProviders.has("openai-compatible")) providerStr = "openai-compatible";
       else if (this.availableProviders.size === 1) providerStr = Array.from(this.availableProviders)[0];
     }
-    if (providerStr === "github-models" && this.availableProviders.has("github-models")) {
-      const dynamicModel = {
-        id: actualId,
-        name: actualId,
-        provider: "github-models",
-        contextWindow: GITHUB_MODELS_MAX_INPUT_TOKENS,
-        isVisionCapable: false,
-        inputCostPer1kTokens: 0,
-        outputCostPer1kTokens: 0,
-        pricingUnknown: false,
-        maxOutputTokens: GITHUB_MODELS_MAX_OUTPUT_TOKENS,
-        supportsStreaming: true,
-        // Unconfirmed (no live catalog entry to read a real capability from)
-        // must default to false, not left undefined: t3-worker.ts's text-tool
-        // fallback only engages on a strict `=== false`, so an undefined
-        // value here sends native `tools` to an unverified multi-vendor
-        // model and any that don't support function calling reject the
-        // request outright. Same default-to-false-when-unconfirmed policy
-        // listModels() already applies for a real catalog entry.
-        supportsToolUse: false,
-        isLocal: false
-      };
-      this.addDynamicModel(dynamicModel);
-      return dynamicModel;
-    }
     if (providerStr && this.availableProviders.has(providerStr)) {
       const dynamicModel = withResolvedPricing({
         id: actualId,
@@ -6710,20 +6591,7 @@ var DEFAULT_PROVIDER_TPM = {
   gemini: 6e4,
   azure: 3e4,
   "openai-compatible": 3e4,
-  ollama: Number.POSITIVE_INFINITY,
-  // An order of magnitude below the others, on purpose. GitHub Models is
-  // rate-limited by REQUESTS (Free ≈10 RPM, Pro ≈20, plus low daily caps), and
-  // this bucket meters TOKENS — there is no request-count limiter in this
-  // codebase, and building one is not in scope. The approximation works because
-  // the router reserves `model.maxOutputTokens + 512` per call, and the
-  // provider reports GitHub's real ~4K per-request cap rather than the
-  // underlying model's larger one — so every call withdraws a near-constant
-  // ~4.5K regardless of how short the reply actually turns out to be. At 8K/min
-  // that lands around 1–2 calls per minute of headroom: comfortably inside even
-  // the Free tier, with room for the daily cap to matter more than this does.
-  // Users on a higher tier can raise it with no code change through the generic
-  // `config.rateLimits.providerTpm['github-models']` override.
-  "github-models": 8e3
+  ollama: Number.POSITIVE_INFINITY
 };
 var TpmLimiter = class {
   buckets = /* @__PURE__ */ new Map();
@@ -7070,7 +6938,6 @@ var ModelProfiler = class {
       (m) => !alreadyProfiled.has(m.id) && !SKIP_PATTERN.test(m.id) && !SKIP_PATTERN.test(m.name)
     );
     if (toProfile.length === 0) return;
-    const probesHitGithubModels = this.router?.getModelForTier("T3")?.provider === "github-models";
     const openRouterModels = await fetchOpenRouterModels();
     const orByNormalizedId = /* @__PURE__ */ new Map();
     for (const m of openRouterModels) {
@@ -7085,7 +6952,7 @@ var ModelProfiler = class {
         if (orMatch?.description) {
           specializations = extractSpecializations(orMatch.description);
         }
-        if (specializations.length === 0 && this.router && !probesHitGithubModels) {
+        if (specializations.length === 0 && this.router) {
           specializations = await queryModelDirectly(this.router);
         }
         this.store.saveModelProfile(model.id, model.provider, specializations);
@@ -7310,7 +7177,6 @@ var LiveDataProvider = class {
    */
   applyLivePricing(models) {
     return models.map((m) => {
-      if (m.provider === "github-models") return m;
       const p = this.getLivePrice(m.baseModelId ?? m.id);
       if (!p) return m;
       const reconciled = reconcilePrice(m, p);
@@ -7349,7 +7215,6 @@ var LiveDataProvider = class {
    */
   applyLiveCapabilities(models) {
     return models.map((m) => {
-      if (m.provider === "github-models") return m;
       const c = this.getCapability(m.baseModelId ?? m.id);
       if (!c) return m;
       const next = { ...m };
@@ -7653,16 +7518,13 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
       for (const model of azureDeployments) this.selector.addDynamicModel(model);
       availableProviders.add("azure");
     }
-    if (availableProviders.has("github-models")) {
-      await this.discoverGitHubModelsCatalog(config);
-    }
     await this.validateCloudProviderModels(config);
     for (const tier of ["T1", "T2", "T3"]) {
       const override = tier === "T1" ? config.models.t1 : tier === "T2" ? config.models.t2 : config.models.t3;
       if (!override || override === "auto") continue;
       const model = this.selector.selectForTier(tier, override);
       if (!model) {
-        const knownProviders = ["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama", "github-models"];
+        const knownProviders = ["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama"];
         const hasProviderPrefix = override.includes(":") && knownProviders.some((p) => override.startsWith(p + ":"));
         if (hasProviderPrefix) {
           const provider = override.split(":")[0];
@@ -7817,7 +7679,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
    * models without a package upgrade. Mirrors discoverOllamaModels.
    */
   async discoverProviderModels() {
-    const cloud = ["anthropic", "openai", "gemini", "azure", "openai-compatible", "github-models"];
+    const cloud = ["anthropic", "openai", "gemini", "azure", "openai-compatible"];
     const tasks = cloud.map(async (type) => {
       if (!this.selector.isProviderAvailable(type)) return;
       const seed = this.getAnyModelForProvider(type);
@@ -8332,26 +8194,6 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
       return false;
     }
   }
-  /**
-   * Registers GitHub Models' real catalog ids via addDynamicModel so init()'s
-   * tier-fill loop can pick one. Registration alone does not create a bound
-   * BaseProvider instance (see ensureProvider) — the tier-fill loop's own
-   * ensureProvider call does that for whichever model it actually selects,
-   * which is why this runs BEFORE that loop rather than only in the
-   * background discoverProviderModels() refresh.
-   */
-  async discoverGitHubModelsCatalog(config) {
-    const cfg = config.providers.find((p) => p.type === "github-models") ?? { type: "github-models" };
-    const seed = this.getAnyModelForProvider("github-models");
-    if (!seed) return;
-    try {
-      const provider = new GitHubModelsProvider(cfg, seed);
-      const models = await provider.listModels();
-      for (const m of models) this.selector.addDynamicModel(m);
-    } catch (err) {
-      console.warn("[router] GitHub Models catalog discovery failed:", err instanceof Error ? err.message : err);
-    }
-  }
   ensureProvider(model, configs) {
     const key = `${model.provider}:${model.id}`;
     if (this.providers.has(key)) return;
@@ -8376,8 +8218,6 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
         return new OllamaProvider(cfg, model);
       case "openai-compatible":
         return new OpenAICompatibleProvider(cfg, model);
-      case "github-models":
-        return new GitHubModelsProvider(cfg, model);
       default:
         throw new Error(`Unsupported provider type: ${String(cfg.type)}`);
     }
@@ -8385,7 +8225,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
   getAnyModelForProvider(type) {
     const fromCatalog = Object.values(MODELS).find((m) => m.provider === type);
     if (fromCatalog) return fromCatalog;
-    if (type === "openai-compatible" || type === "azure" || type === "github-models") {
+    if (type === "openai-compatible" || type === "azure") {
       return {
         id: type,
         name: type,
@@ -22263,10 +22103,7 @@ async function refreshModelCache(store, providers) {
       else if (provider.type === "anthropic") instance = new AnthropicProvider(provider, dummyModel);
       else if (provider.type === "ollama") instance = new OllamaProvider(provider, dummyModel);
       else if (provider.type === "openai-compatible") instance = new OpenAICompatibleProvider(provider, dummyModel);
-      else if (provider.type === "github-models") {
-        const { GitHubModelsProvider: GitHubModelsProvider2 } = await Promise.resolve().then(() => (init_github_models(), github_models_exports));
-        instance = new GitHubModelsProvider2(provider, dummyModel);
-      } else if (provider.type === "azure") {
+      else if (provider.type === "azure") {
         const { AzureOpenAIProvider: AzureOpenAIProvider2 } = await Promise.resolve().then(() => (init_azure(), azure_exports));
         instance = new AzureOpenAIProvider2(provider, dummyModel);
       }
@@ -22279,7 +22116,7 @@ async function refreshModelCache(store, providers) {
     }
   }
 }
-function Repl({ config, workspacePath, themeName, initialPrompt, identityName, altScreen = false }) {
+function Repl({ config, workspacePath, themeName, initialPrompt, identityName, startupNotice, altScreen = false }) {
   const { exit } = ink.useApp();
   const { stdout } = ink.useStdout();
   const [theme, setTheme] = React2.useState(() => getTheme(themeName));
@@ -22450,17 +22287,29 @@ function Repl({ config, workspacePath, themeName, initialPrompt, identityName, a
     }
     setCurrentIdentityId(initialIdentityId);
     const loadCache = async () => {
+      const toMap = (models2) => {
+        const map = /* @__PURE__ */ new Map();
+        for (const m of models2) {
+          const list = map.get(m.provider) ?? [];
+          list.push(m);
+          map.set(m.provider, list);
+        }
+        return map;
+      };
       const models = store.getCachedModels();
-      const map = /* @__PURE__ */ new Map();
-      for (const m of models) {
-        const list = map.get(m.provider) ?? [];
-        list.push(m);
-        map.set(m.provider, list);
+      setCachedModels(toMap(models));
+      if (models.length === 0 || store.getCacheAge() > 24 * 60 * 60 * 1e3) {
+        await refreshModelCache(store, config.providers);
+        setCachedModels(toMap(store.getCachedModels()));
       }
-      setCachedModels(map);
-      if (models.length === 0 || store.getCacheAge() > 24 * 60 * 60 * 1e3) await refreshModelCache(store, config.providers);
     };
     loadCache();
+    if (startupNotice) {
+      dispatch({
+        type: "ADD_MESSAGE",
+        message: { id: crypto.randomUUID(), role: "system", content: `\u26A0 ${startupNotice}`, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+      });
+    }
     store.createSession({ id: sessionIdRef.current, title: "Cascade Session", createdAt: startedAtRef.current, updatedAt: startedAtRef.current, identityId: config.defaultIdentityId ?? "default", workspacePath, messages: [], metadata: { totalTokens: 0, totalCostUsd: 0, modelsUsed: [], toolsUsed: [], taskCount: 0 } });
     persistRuntimeSession("ACTIVE");
     try {
@@ -23383,7 +23232,7 @@ async function validateConfiguredModels(config) {
 function inferProviderFromModelId(id, providers) {
   if (id.includes(":")) {
     const prefix = id.split(":")[0].toLowerCase();
-    const validProviders = ["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama", "github-models"];
+    const validProviders = ["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama"];
     if (validProviders.includes(prefix)) {
       return prefix;
     }
@@ -23680,10 +23529,9 @@ var PROVIDER_LABELS = {
   gemini: "Google Gemini",
   azure: "Azure OpenAI",
   ollama: "Ollama (local)",
-  "openai-compatible": "OpenAI-Compatible",
-  "github-models": "GitHub Models"
+  "openai-compatible": "OpenAI-Compatible"
 };
-var providerOrder = ["anthropic", "openai", "gemini", "azure", "ollama", "openai-compatible", "github-models"];
+var providerOrder = ["anthropic", "openai", "gemini", "azure", "ollama", "openai-compatible"];
 function buildInitialEntries(types) {
   return [...types].map((type) => ({
     id: crypto.randomUUID(),
@@ -23855,13 +23703,6 @@ function SetupWizard({ workspacePath, onComplete }) {
             const fetched = await p.listModels();
             fetched.forEach((m) => models.push({ id: m.id, name: m.name, providerLabel: entry.label }));
             dispatchRef.current({ type: "SET_FETCH_LOG", line: `  \u2714 ${entry.label} \u2014 ${fetched.length} models` });
-          } else if (type === "github-models") {
-            const { GitHubModelsProvider: GitHubModelsProvider2 } = await Promise.resolve().then(() => (init_github_models(), github_models_exports));
-            const dummyModel = { id: "dummy", name: "dummy", provider: type, contextWindow: 0, isVisionCapable: false, inputCostPer1kTokens: 0, outputCostPer1kTokens: 0, maxOutputTokens: 0, supportsStreaming: false, isLocal: false };
-            const p = new GitHubModelsProvider2({ type, apiKey }, dummyModel);
-            const fetched = await p.listModels();
-            fetched.forEach((m) => models.push({ id: `${type}:${m.id}`, name: m.name, providerLabel: entry.label }));
-            dispatchRef.current({ type: "SET_FETCH_LOG", line: `  \u2714 ${entry.label} \u2014 ${fetched.length} models` });
           } else if (type === "gemini") {
             const { GeminiProvider: GeminiProvider2 } = await Promise.resolve().then(() => (init_gemini(), gemini_exports));
             const dummyModel = { id: "dummy", name: "dummy", provider: type, contextWindow: 0, isVisionCapable: false, inputCostPer1kTokens: 0, outputCostPer1kTokens: 0, maxOutputTokens: 0, supportsStreaming: false, isLocal: false };
@@ -24040,8 +23881,7 @@ function SetupWizard({ workspacePath, onComplete }) {
           /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: focused ? theme.colors.primary : selected ? theme.colors.foreground : theme.colors.muted, children: PROVIDER_LABELS[p] }),
           p === "azure" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.muted, dimColor: true, children: "  \u2014 multiple deployments supported" }),
           p === "openai-compatible" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.muted, dimColor: true, children: "  \u2014 Groq, Together, custom" }),
-          p === "ollama" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.muted, dimColor: true, children: "  \u2014 no API key needed" }),
-          p === "github-models" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.muted, dimColor: true, children: "  \u2014 GitHub PAT with `models: read`" })
+          p === "ollama" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.muted, dimColor: true, children: "  \u2014 no API key needed" })
         ] }, p);
       }) }),
       /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { marginTop: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: theme.colors.muted, dimColor: true, children: "space select  \xB7  a all  \xB7  i invert  \xB7  enter continue" }) }),
@@ -24448,8 +24288,7 @@ async function doctorCommand() {
     { type: "anthropic", name: "Anthropic" },
     { type: "openai", name: "OpenAI" },
     { type: "gemini", name: "Google Gemini" },
-    { type: "azure", name: "Azure OpenAI" },
-    { type: "github-models", name: "GitHub Models" }
+    { type: "azure", name: "Azure OpenAI" }
   ];
   for (const { type, name } of providers) {
     const key = cm.getApiKey(type);
@@ -24710,7 +24549,9 @@ function gatherSyncBundle(config) {
   if (Object.keys(prefs).length) bundle.prefs = prefs;
   return bundle;
 }
-function applySyncBundle(bundle, config) {
+function applySyncBundle(bundle, config, cleanup) {
+  const dropped = stripRetiredProviders(bundle);
+  if (cleanup) cleanup.removed = dropped.removed;
   const next = { ...config, tools: { ...config.tools } };
   if (bundle.providers) next.providers = mergeByKey(config.providers, bundle.providers, providerSig) ?? [];
   if (bundle.webSearch) next.tools.webSearch = { ...config.tools?.webSearch, ...bundle.webSearch };
@@ -24726,6 +24567,14 @@ function applySyncBundle(bundle, config) {
   }
   if (bundle.models) next.models = { ...config.models, ...bundle.models };
   if (bundle.budget) next.budget = { ...config.budget, ...bundle.budget };
+  const merged = { ...next.models };
+  const clearedFromMerge = clearRetiredPins(merged);
+  if (clearedFromMerge.length > 0) next.models = merged;
+  if (cleanup) {
+    cleanup.clearedPins = ["t1", "t2", "t3"].filter(
+      (t) => (dropped.clearedPins.includes(t) || clearedFromMerge.includes(t)) && next.models?.[t] === void 0
+    );
+  }
   if (bundle.prefs) {
     const p = bundle.prefs;
     if (p.autoBias !== void 0) next.autoBias = p.autoBias;
@@ -25033,14 +24882,28 @@ async function syncPullCommand() {
     console.log(chalk7__default.default.dim("\n  Cancelled.\n"));
     return;
   }
+  let bundle;
+  try {
+    bundle = await decryptJSON(blob, pass);
+  } catch {
+    console.log(chalk7__default.default.red("\n  Could not decrypt \u2014 check your passphrase and try again.\n"));
+    process.exitCode = 1;
+    return;
+  }
   try {
-    const bundle = await decryptJSON(blob, pass);
     const cm = new ConfigManager(process.cwd());
     await cm.load();
-    await cm.updateConfig(applySyncBundle(bundle, cm.getConfig()));
+    const cleanup = { removed: [], clearedPins: [] };
+    await cm.updateConfig(applySyncBundle(bundle, cm.getConfig(), cleanup));
     console.log(chalk7__default.default.green("\n  \u2713 Applied your synced settings. Your keys are ready here.\n"));
-  } catch {
-    console.log(chalk7__default.default.red("\n  Could not decrypt \u2014 check your passphrase and try again.\n"));
+    if (didCleanupChangeAnything(cleanup)) {
+      console.log(chalk7__default.default.yellow(`  ${describeCleanup(cleanup)}
+`));
+    }
+  } catch (err) {
+    console.log(chalk7__default.default.red(`
+  Could not apply your synced settings: ${err instanceof Error ? err.message : String(err)}
+`));
     process.exitCode = 1;
   }
 }
@@ -27667,6 +27530,7 @@ async function startRepl(options) {
     process.exit(1);
   }
   let config = cm.getConfig();
+  const startupNotice = cm.takeRetiredNotice();
   const needsSetup = !hasUsableProvider(config.providers);
   if (needsSetup) {
     console.log(chalk7__default.default.magenta("  \u25C8 No providers configured \u2014 launching setup wizard\u2026"));
@@ -27689,6 +27553,7 @@ async function startRepl(options) {
       themeName: options.theme ?? config.theme ?? DEFAULT_THEME,
       initialPrompt: options.prompt,
       identityName: options.identity,
+      startupNotice,
       altScreen: useAltScreen
     }),
     { exitOnCtrlC: false }