cascade-ai 0.70.0 → 0.71.0

package/dist/desktop-core.cjs

@@ -291781,7 +291781,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.70.0";
+var CASCADE_VERSION = "0.71.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -292188,9 +292188,6 @@ var DEFAULT_THEME = "cascade";
 var OLLAMA_BASE_URL = "http://localhost:11434";
 var LM_STUDIO_BASE_URL = "http://localhost:1234";
 var AZURE_BASE_URL_TEMPLATE = "https://{resource}.openai.azure.com";
-var GITHUB_MODELS_INFERENCE_URL = "https://models.github.ai/inference";
-var GITHUB_MODELS_CATALOG_URL = "https://models.github.ai/catalog/models";
-var GITHUB_MODELS_API_VERSION = "2026-03-10";
 var TOOL_NAMES = {
   SHELL: "shell",
   FILE_READ: "file_read",
@@ -292225,8 +292222,7 @@ var PROVIDER_DISPLAY_NAMES = {
   gemini: "Google Gemini",
   azure: "Azure OpenAI",
   "openai-compatible": "OpenAI-Compatible",
-  ollama: "Ollama (Local)",
-  "github-models": "GitHub Models"
+  ollama: "Ollama (Local)"
 };
 
 // src/utils/cost.ts
@@ -319170,206 +319166,6 @@ async function nodeHttpFetch(input, init2 = {}, redirectCount = 0, opts = {}) {
   });
 }
 
-// src/providers/github-models.ts
-var GITHUB_MODELS_MAX_OUTPUT_TOKENS = 4e3;
-var GITHUB_MODELS_MAX_INPUT_TOKENS = 8e3;
-var DEFAULT_CONTEXT_WINDOW = 128e3;
-var GITHUB_MODELS_MAX_CATALOG_PAGES = 20;
-var GITHUB_MODELS_CATALOG_ORIGIN = new URL(GITHUB_MODELS_CATALOG_URL).origin;
-function stripModelOwnerPrefix(id) {
-  const slash = (id || "").indexOf("/");
-  return slash === -1 ? id : id.slice(slash + 1);
-}
-function pickString(o3, keys2) {
-  for (const k4 of keys2) {
-    const v6 = o3[k4];
-    if (typeof v6 === "string" && v6.length > 0) return v6;
-  }
-  return void 0;
-}
-function pickNumber(o3, keys2) {
-  for (const k4 of keys2) {
-    const v6 = k4.includes(".") ? o3[k4.split(".")[0]]?.[k4.split(".")[1]] : o3[k4];
-    if (typeof v6 === "number" && Number.isFinite(v6) && v6 > 0) return v6;
-  }
-  return void 0;
-}
-function looksVisionCapable(o3) {
-  for (const k4 of ["supported_input_modalities", "input_modalities", "modalities", "capabilities"]) {
-    const v6 = o3[k4];
-    if (Array.isArray(v6) && v6.some((x5) => typeof x5 === "string" && /image|vision/i.test(x5))) return true;
-  }
-  return false;
-}
-function looksToolCapable(o3) {
-  const params = o3["supported_parameters"];
-  if (Array.isArray(params) && params.some((x5) => typeof x5 === "string" && /^tools?$|function.?call/i.test(x5))) {
-    return true;
-  }
-  for (const k4 of ["capabilities", "supported_output_modalities"]) {
-    const v6 = o3[k4];
-    if (Array.isArray(v6) && v6.some((x5) => typeof x5 === "string" && /tool|function.?call/i.test(x5))) return true;
-  }
-  const caps = o3["capabilities"];
-  if (caps && typeof caps === "object" && !Array.isArray(caps)) {
-    const c4 = caps;
-    if (c4["function_calling"] === true || c4["tool_calling"] === true || c4["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 GitHubModelsProvider = class extends OpenAIProvider {
-  constructor(config2, model) {
-    super({ ...config2, apiKey: config2.apiKey ?? "" }, model);
-    this.useMaxCompletionTokens = isReasoningModel(stripModelOwnerPrefix(model.id));
-    this.client = new openai_default({
-      apiKey: config2.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 url2 = GITHUB_MODELS_CATALOG_URL;
-    let pages = 0;
-    const visited = /* @__PURE__ */ new Set();
-    while (url2 && pages < GITHUB_MODELS_MAX_CATALOG_PAGES) {
-      if (visited.has(url2)) break;
-      visited.add(url2);
-      const res = await nodeHttpFetch(url2, { headers: this.catalogHeaders() }, 0, {
-        allowedRedirectOrigin: GITHUB_MODELS_CATALOG_ORIGIN
-      });
-      if (!res.ok) throw new Error(`GitHub Models catalog ${url2} 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, url2);
-        if (resolved.origin !== GITHUB_MODELS_CATALOG_ORIGIN) {
-          throw new Error(`Refusing cross-origin GitHub Models pagination URL: ${resolved.origin}`);
-        }
-        url2 = resolved.href;
-      } else {
-        url2 = null;
-      }
-      pages++;
-    }
-    const entries = raw.map((m3) => {
-      if (typeof m3 === "string") {
-        return { id: m3, name: m3, contextWindow: DEFAULT_CONTEXT_WINDOW, vision: false, tools: false };
-      }
-      if (!m3 || typeof m3 !== "object") return void 0;
-      const o3 = m3;
-      const id = pickString(o3, ["id", "name", "model"]);
-      if (!id) return void 0;
-      return {
-        id,
-        name: pickString(o3, ["friendly_name", "display_name", "name"]) ?? id,
-        contextWindow: pickNumber(o3, [
-          "context_window",
-          "context_length",
-          "max_input_tokens",
-          "limits.max_input_tokens",
-          "limits.max_context_tokens"
-        ]) ?? DEFAULT_CONTEXT_WINDOW,
-        vision: looksVisionCapable(o3),
-        tools: looksToolCapable(o3)
-      };
-    }).filter((e3) => e3 !== void 0);
-    if (entries.length === 0) return [];
-    const chat = entries.filter((e3) => isChatModel(e3.id));
-    return (chat.length ? chat : entries).map((e3) => ({
-      id: e3.id,
-      // full `owner/model` — what the API is addressed by
-      name: e3.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(e3.contextWindow, GITHUB_MODELS_MAX_INPUT_TOKENS),
-      isVisionCapable: e3.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: e3.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 TOOL_CAPABLE_FAMILIES = [
   "llama3.1",
@@ -319880,7 +319676,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(":");
@@ -319900,31 +319696,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,
@@ -320017,20 +319788,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();
@@ -320386,7 +320144,6 @@ var ModelProfiler = class {
       (m3) => !alreadyProfiled.has(m3.id) && !SKIP_PATTERN.test(m3.id) && !SKIP_PATTERN.test(m3.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 m3 of openRouterModels) {
@@ -320401,7 +320158,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);
@@ -320621,7 +320378,6 @@ var LiveDataProvider = class {
    */
   applyLivePricing(models) {
     return models.map((m3) => {
-      if (m3.provider === "github-models") return m3;
       const p3 = this.getLivePrice(m3.baseModelId ?? m3.id);
       if (!p3) return m3;
       const reconciled = reconcilePrice(m3, p3);
@@ -320660,7 +320416,6 @@ var LiveDataProvider = class {
    */
   applyLiveCapabilities(models) {
     return models.map((m3) => {
-      if (m3.provider === "github-models") return m3;
       const c4 = this.getCapability(m3.baseModelId ?? m3.id);
       if (!c4) return m3;
       const next = { ...m3 };
@@ -320964,16 +320719,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(config2);
-    }
     await this.validateCloudProviderModels(config2);
     for (const tier of ["T1", "T2", "T3"]) {
       const override = tier === "T1" ? config2.models.t1 : tier === "T2" ? config2.models.t2 : config2.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((p3) => override.startsWith(p3 + ":"));
         if (hasProviderPrefix) {
           const provider = override.split(":")[0];
@@ -321128,7 +320880,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);
@@ -321643,26 +321395,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(config2) {
-    const cfg = config2.providers.find((p3) => p3.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 m3 of models) this.selector.addDynamicModel(m3);
-    } 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;
@@ -321687,8 +321419,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)}`);
     }
@@ -321696,7 +321426,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
   getAnyModelForProvider(type) {
     const fromCatalog = Object.values(MODELS).find((m3) => m3.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,
@@ -370123,7 +369853,7 @@ var PermissionEscalator = class extends EventEmitter__default.default {
 
 // src/config/schema.ts
 var ProviderConfigSchema = external_exports.object({
-  type: external_exports.enum(["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama", "github-models"]),
+  type: external_exports.enum(["anthropic", "openai", "gemini", "azure", "openai-compatible", "ollama"]),
   label: external_exports.string().optional(),
   apiKey: external_exports.string().optional(),
   baseUrl: external_exports.string().url().optional(),
@@ -375409,6 +375139,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((r4) => JSON.parse(r4.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);
@@ -375756,7 +375499,73 @@ 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(c4) {
+  return c4.removed.length > 0 || c4.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((p3) => {
+      const type = p3?.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((p3) => {
+    if (!isRetiredProviderType(p3.type)) return true;
+    if (!removed.includes(p3.type)) removed.push(p3.type);
+    return false;
+  });
+  return { kept, removed };
+}
+function describeCleanup(c4) {
+  const parts = [];
+  for (const type of c4.removed) {
+    parts.push(`removed the retired "${type}" provider (${RETIRED_PROVIDER_TYPES[type]})`);
+  }
+  if (c4.clearedPins.length > 0) {
+    parts.push(`reset ${c4.clearedPins.map((t4) => t4.toUpperCase()).join("/")} to Auto, since the pin named it`);
+  }
+  return `Cascade config migration: ${parts.join("; ")}.`;
+}
+
 // src/config/index.ts
+var KEY_OPTIONAL_PROVIDER_TYPES = /* @__PURE__ */ new Set(["ollama", "openai-compatible"]);
+function hasUsableProvider(providers) {
+  if (!providers?.length) return false;
+  return providers.some((p3) => KEY_OPTIONAL_PROVIDER_TYPES.has(p3.type) || !!p3.apiKey || !!p3.authToken);
+}
 var ConfigManager = class {
   config;
   keystore;
@@ -375765,6 +375574,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 n8 = this.pendingRetiredNotice;
+    this.pendingRetiredNotice = void 0;
+    return n8;
+  }
   /** `globalDirOverride` exists for tests — never point it at the real home dir there. */
   constructor(workspacePath = process.cwd(), globalDirOverride) {
     this.workspacePath = workspacePath;
@@ -375784,10 +375616,32 @@ var ConfigManager = class {
     this.cascadeMd = await loadCascadeMd(this.workspacePath);
     this.keystore = new Keystore(path28__namespace.default.join(this.globalDir, GLOBAL_KEYSTORE_FILE));
     this.store = new MemoryStore(path28__namespace.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;
@@ -375826,14 +375680,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];
@@ -375845,10 +375698,21 @@ var ConfigManager = class {
     return configProvider?.apiKey;
   }
   async loadConfig() {
+    this.retiredCleanup = void 0;
     const configPath = path28__namespace.default.join(this.workspacePath, CASCADE_CONFIG_FILE);
     try {
       const raw = await fs9__namespace.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 fs9__namespace.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({});
@@ -375857,27 +375721,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((p3) => p3.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((p3) => p3.type === "ollama")) {
+    if (wasEmpty && !emptiedByRetirement && !this.config.providers.find((p3) => p3.type === "ollama")) {
       this.config.providers.push({ type: "ollama" });
     }
   }
@@ -379298,7 +379160,9 @@ function gatherSyncBundle(config2) {
   if (Object.keys(prefs).length) bundle.prefs = prefs;
   return bundle;
 }
-function applySyncBundle(bundle, config2) {
+function applySyncBundle(bundle, config2, cleanup) {
+  const dropped = stripRetiredProviders(bundle);
+  if (cleanup) cleanup.removed = dropped.removed;
   const next = { ...config2, tools: { ...config2.tools } };
   if (bundle.providers) next.providers = mergeByKey(config2.providers, bundle.providers, providerSig) ?? [];
   if (bundle.webSearch) next.tools.webSearch = { ...config2.tools?.webSearch, ...bundle.webSearch };
@@ -379314,6 +379178,14 @@ function applySyncBundle(bundle, config2) {
   }
   if (bundle.models) next.models = { ...config2.models, ...bundle.models };
   if (bundle.budget) next.budget = { ...config2.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(
+      (t4) => (dropped.clearedPins.includes(t4) || clearedFromMerge.includes(t4)) && next.models?.[t4] === void 0
+    );
+  }
   if (bundle.prefs) {
     const p3 = bundle.prefs;
     if (p3.autoBias !== void 0) next.autoBias = p3.autoBias;
@@ -379785,9 +379657,6 @@ exports.DOCUMENT_MIME = DOCUMENT_MIME;
 exports.DashboardServer = DashboardServer;
 exports.DependencyScheduler = DependencyScheduler;
 exports.FileMcpOAuthStore = FileMcpOAuthStore;
-exports.GITHUB_MODELS_API_VERSION = GITHUB_MODELS_API_VERSION;
-exports.GITHUB_MODELS_CATALOG_URL = GITHUB_MODELS_CATALOG_URL;
-exports.GITHUB_MODELS_INFERENCE_URL = GITHUB_MODELS_INFERENCE_URL;
 exports.GLOBAL_CONFIG_DIR = GLOBAL_CONFIG_DIR;
 exports.GLOBAL_CREDENTIALS_FILE = GLOBAL_CREDENTIALS_FILE;
 exports.GLOBAL_DB_FILE = GLOBAL_DB_FILE;
@@ -379860,6 +379729,7 @@ exports.failures = failures;
 exports.fileExt = fileExt;
 exports.fileOAuthProvider = fileOAuthProvider;
 exports.gatherSyncBundle = gatherSyncBundle;
+exports.hasUsableProvider = hasUsableProvider;
 exports.hashContent = hashContent;
 exports.heuristicCodeChunker = heuristicCodeChunker;
 exports.inferAzureBaseModel = inferAzureBaseModel;