diff --git a/docs/architecture.md b/docs/architecture.md
index 92e921d..f5b1e34 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -57,7 +57,7 @@ JSON request bodies are limited to 32 MiB. Oversized requests receive a JSON `41
 
 ## Model IDs and routes
 
-Provider model IDs are generated by `src/lib/providers/index.js`. A direct model resolves to one enabled provider/model pair.
+Provider model IDs are generated by `src/lib/providers/index.js`. Custom OpenAI-compatible connections use the readable form `<connection name>/custom/<upstream model>` while legacy hash-qualified IDs remain resolvable. A direct model resolves to one enabled provider/model pair.
 
 A route is a persisted virtual model with members shaped like:
 
@@ -73,7 +73,7 @@ The router supports:
 - `fallback`: members are attempted in their configured order.
 - `round-robin`: each request rotates the starting member, then retains fallback behavior through the remaining members.
 
-Timeouts, `408`, `429`, and `5xx` responses are retryable. The per-member timeout defaults to 60 seconds. An explicit route stops immediately when any account or member returns a non-retryable failure; a later account lock cannot replace that terminal response.
+Timeouts, `408`, `429`, `5xx`, and provider/model capability incompatibilities such as an unsupported model can advance fallback. Capability failures do not create account cooldown locks. The per-member timeout defaults to 60 seconds. An explicit route stops immediately on other non-retryable failures; a later account lock cannot replace that terminal response.
 
 OAuth providers add an account-pool layer beneath model routing. Accounts receive monotonic, never-reused aliases (`oauth1`, `oauth2`, ...). Model discovery advertises one canonical pooled id such as `chatgpt/gpt-5.4`; account-qualified ids such as `chatgpt/oauth2/gpt-5.4` and legacy stored-account ids remain resolvable but are not advertised. Quota failures create an account-wide lock using provider reset hints when available; authentication and transient failures use shorter model-scoped cooldowns. Early streaming quota events are inspected before the client stream starts so fallback can still occur. Selection, failure, fallback, locked-account skips, and terminal exhaustion are written as structured logs.
 
@@ -82,6 +82,7 @@ OAuth providers add an account-pool layer beneath model routing. Accounts receiv
 `src/lib/providers/index.js` selects an adapter by provider type.
 
 - `openai-compat.js` handles OpenAI-shaped keyed services.
+- `cloudflare.js` discovers runnable Workers AI models through the paginated `/ai/models/search` API and delegates requests to Cloudflare's OpenAI-compatible chat endpoint.
 - `chatgpt.js` translates chat-completion requests to the ChatGPT Codex Responses surface and normalizes Responses SSE.
 - `claude.js` translates OpenAI messages and tools to Anthropic Messages, applies the current OAuth client contract, and converts JSON/SSE back to OpenAI shapes.
 - `antigravity.js` translates Gemini-style upstream requests and SSE.
diff --git a/package-lock.json b/package-lock.json
index 57ef4a5..b2afe98 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "rerouted",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "rerouted",
-      "version": "0.4.7",
+      "version": "0.4.8",
       "license": "MIT",
       "devDependencies": {
         "@electron/osx-sign": "1.3.3",
diff --git a/package.json b/package.json
index 6f1ed4d..850db43 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "rerouted",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "A macOS menu-bar router for accounts, models, and automatic fallback.",
   "author": "gitcommit90",
   "license": "MIT",
diff --git a/scripts/capture-ui.js b/scripts/capture-ui.js
index 5a3fbeb..0997697 100644
--- a/scripts/capture-ui.js
+++ b/scripts/capture-ui.js
@@ -12,7 +12,7 @@ const { app, BrowserWindow, ipcMain } = require("electron");
 const { createStore } = require("../src/lib/store");
 const { generateApiKey } = require("../src/lib/password");
 const { KEYED_PRESETS, ONBOARDING_STEPS, DEFAULT_PORT, OAUTH } = require("../src/lib/constants");
-const { defaultModelsForType } = require("../src/lib/providers");
+const { defaultModelsForType, listProviderModels } = require("../src/lib/providers");
 const { publicCombo } = require("../src/lib/combos");
 const packageInfo = require("../package.json");
 
@@ -204,18 +204,26 @@ function seedOnboarded() {
 function registerIpc() {
   ipcMain.handle("app:get-state", async () => {
     const cfg = store.load();
-    const publicProviders = (cfg.providers || []).map((p) => ({
-      id: p.id,
-      type: p.type,
-      name: p.name,
-      accountAlias: p.accountAlias || null,
-      email: p.email,
-      profileName: p.profileName,
-      enabled: p.enabled !== false,
-      hasToken: !!(p.accessToken || p.apiKey),
-      models: p.models || defaultModelsForType(p.type),
-      baseUrl: p.baseUrl,
-    }));
+    const publicProviders = (cfg.providers || []).map((p) => {
+      const models = listProviderModels(p, { includeDisabled: true }).map((model) => ({
+        id: model.upstreamModel,
+        gatewayId: model.id,
+        name: model.name,
+        enabled: model.enabled !== false,
+      }));
+      return {
+        id: p.id,
+        type: p.type,
+        name: p.name,
+        accountAlias: p.accountAlias || null,
+        email: p.email,
+        profileName: p.profileName,
+        enabled: p.enabled !== false,
+        hasToken: !!(p.accessToken || p.apiKey),
+        models: models.length ? models : defaultModelsForType(p.type),
+        baseUrl: p.baseUrl,
+      };
+    });
     return {
       onboardingComplete: !!cfg.onboardingComplete,
       appVersion: packageInfo.version,
@@ -644,6 +652,53 @@ app.whenReady().then(async () => {
     }
   }
 
+  if (process.env.CAPTURE_ROUTE_PICKER_ONLY === "1") {
+    await win.webContents.executeJavaScript(`
+      (async () => {
+        window.__rr_goto_page("combos");
+        document.querySelector("button[data-edit]")?.click();
+        await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+        let account = document.getElementById("c-add-account");
+        let model = document.getElementById("c-add-model");
+        let add = document.getElementById("btn-add-member");
+        if (!account || !model?.disabled || !add?.disabled) {
+          throw new Error("Route picker did not start with Model and Add disabled");
+        }
+        account.value = "prov_chatgpt_demo";
+        account.dispatchEvent(new Event("change", { bubbles: true }));
+        await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+        account = document.getElementById("c-add-account");
+        model = document.getElementById("c-add-model");
+        add = document.getElementById("btn-add-member");
+        const modelOptions = [...model.options].filter((option) => option.value);
+        if (account.value !== "prov_chatgpt_demo" || model.disabled || !modelOptions.length) {
+          throw new Error("Selecting an account did not enable and populate its models");
+        }
+        model.value = modelOptions[1]?.value || modelOptions[0].value;
+        model.dispatchEvent(new Event("change", { bubbles: true }));
+        if (add.disabled) throw new Error("Selecting a model did not enable Add to route");
+        return true;
+      })()
+    `);
+    await capture("app-combos-editor.png", ".route-editor", ".route-editor");
+    await win.webContents.executeJavaScript(`
+      (() => {
+        const before = document.querySelectorAll(".member-row").length;
+        document.getElementById("btn-add-member")?.click();
+        const after = document.querySelectorAll(".member-row").length;
+        const account = document.getElementById("c-add-account");
+        const model = document.getElementById("c-add-model");
+        if (after !== before + 1 || account.value || !model.disabled) {
+          throw new Error("Adding a route member did not reset the dependent picker");
+        }
+        return true;
+      })()
+    `);
+    console.log("done", outDir);
+    app.exit(0);
+    return;
+  }
+
   await win.webContents.executeJavaScript(`
     (() => {
       window.__rr_goto_page("home");
diff --git a/src/lib/combos.js b/src/lib/combos.js
index 4018039..78d5095 100644
--- a/src/lib/combos.js
+++ b/src/lib/combos.js
@@ -1,5 +1,7 @@
 "use strict";
 
+const { isCustomProviderType, customProviderModelId } = require("./model-ids");
+
 function publicComboId(combo) {
   const name = String(combo?.name || "").trim();
   return name || String(combo?.id || "");
@@ -31,6 +33,9 @@ function providerRouteIds(providers) {
       ids.add(modelId.toLowerCase());
       ids.add(`${type}/${modelId}`.toLowerCase());
       ids.add(`${family}/${modelId}`.toLowerCase());
+      if (isCustomProviderType(type)) {
+        ids.add(customProviderModelId(provider, modelId).toLowerCase());
+      }
       if (account) {
         ids.add(`${type}/${account}/${modelId}`.toLowerCase());
         ids.add(`${family}/${account}/${modelId}`.toLowerCase());
diff --git a/src/lib/keyed-provider-test.js b/src/lib/keyed-provider-test.js
index 67181c0..5ff658e 100644
--- a/src/lib/keyed-provider-test.js
+++ b/src/lib/keyed-provider-test.js
@@ -2,21 +2,23 @@
 
 const { runProviderModelTest } = require("./model-test");
 const openaiCompat = require("./providers/openai-compat");
+const { getAdapter } = require("./providers");
 
 async function testKeyedProvider(
-  { baseUrl, apiKey, modelId } = {},
-  { adapter = openaiCompat, logger } = {}
+  { baseUrl, apiKey, modelId, providerType } = {},
+  { adapter, logger } = {}
 ) {
   const finalBaseUrl = String(baseUrl || "").trim().replace(/\/+$/, "");
   const finalApiKey = String(apiKey || "").trim();
   const exactModelId = String(modelId || "").trim();
+  const selectedAdapter = adapter || getAdapter(providerType) || openaiCompat;
 
   if (!finalBaseUrl || !finalApiKey) {
     return { ok: false, error: "Base URL and API key required" };
   }
 
   const provider = {
-    type: "openai-compat",
+    type: providerType || "openai-compat",
     name: "Custom",
     baseUrl: finalBaseUrl,
     apiKey: finalApiKey,
@@ -24,7 +26,7 @@ async function testKeyedProvider(
 
   if (exactModelId) {
     const result = await runProviderModelTest({
-      adapter,
+      adapter: selectedAdapter,
       provider,
       model: exactModelId,
       logger,
@@ -38,7 +40,7 @@ async function testKeyedProvider(
   }
 
   try {
-    const models = await adapter.listModels(provider);
+    const models = await selectedAdapter.listModels(provider);
     return { ok: true, models, validation: "models" };
   } catch (error) {
     return { ok: false, error: error.message };
diff --git a/src/lib/model-ids.js b/src/lib/model-ids.js
new file mode 100644
index 0000000..81697ab
--- /dev/null
+++ b/src/lib/model-ids.js
@@ -0,0 +1,71 @@
+"use strict";
+
+function isCustomProviderType(type) {
+  const value = String(type || "").toLowerCase();
+  return value === "openai-compat" || value === "custom";
+}
+
+function customConnectionName(provider) {
+  return String(provider?.name || "").trim() || "Custom";
+}
+
+function customProviderModelId(provider, model) {
+  const modelId = typeof model === "string" ? model : model?.id;
+  return `${customConnectionName(provider)}/custom/${modelId}`;
+}
+
+function customModelRouteConflict(name, models = [], combos = []) {
+  const routeIds = new Set(
+    combos
+      .map((combo) => String(combo?.name || combo?.id || "").trim().toLowerCase())
+      .filter(Boolean)
+  );
+  const provider = { type: "openai-compat", name };
+  return (
+    models.find((model) => {
+      const modelId = typeof model === "string" ? model : model?.id;
+      return modelId && routeIds.has(customProviderModelId(provider, modelId).toLowerCase());
+    }) || null
+  );
+}
+
+function ensureUniqueCustomConnectionNames(providers = [], combos = []) {
+  const used = new Set();
+  for (const provider of providers) {
+    if (!isCustomProviderType(provider?.type)) continue;
+    const base = customConnectionName(provider);
+    let candidate = base;
+    let suffix = 2;
+    while (
+      used.has(candidate.toLowerCase()) ||
+      customModelRouteConflict(candidate, provider.models, combos)
+    ) {
+      candidate = `${base} ${suffix}`;
+      suffix += 1;
+    }
+    provider.name = candidate;
+    used.add(candidate.toLowerCase());
+  }
+  return providers;
+}
+
+function customConnectionNameError(name, providers = []) {
+  const candidate = String(name || "").trim();
+  if (!candidate) return "Custom connection name required";
+  if (candidate.includes("/")) return "Custom connection names cannot contain /";
+  const duplicate = providers.some(
+    (provider) =>
+      isCustomProviderType(provider?.type) &&
+      customConnectionName(provider).toLowerCase() === candidate.toLowerCase()
+  );
+  return duplicate ? `A custom connection named ${candidate} already exists` : null;
+}
+
+module.exports = {
+  isCustomProviderType,
+  customConnectionNameError,
+  customConnectionName,
+  customModelRouteConflict,
+  customProviderModelId,
+  ensureUniqueCustomConnectionNames,
+};
diff --git a/src/lib/providers/cloudflare.js b/src/lib/providers/cloudflare.js
new file mode 100644
index 0000000..28944fb
--- /dev/null
+++ b/src/lib/providers/cloudflare.js
@@ -0,0 +1,97 @@
+"use strict";
+
+const openaiCompat = require("./openai-compat");
+
+const MODELS_TIMEOUT_MS = 15_000;
+const MODELS_PAGE_SIZE = 100;
+const MAX_MODEL_PAGES = 10;
+
+function modelsSearchUrl(baseUrl, page = 1) {
+  const base = String(baseUrl || "").trim().replace(/\/+$/, "");
+  const url = new URL(`${base.replace(/\/v1$/, "")}/models/search`);
+  url.searchParams.set("page", String(page));
+  url.searchParams.set("per_page", String(MODELS_PAGE_SIZE));
+  return url.toString();
+}
+
+function taskName(model) {
+  const task = model?.task;
+  return String(typeof task === "string" ? task : task?.name || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[_-]+/g, " ");
+}
+
+function isChatModel(model) {
+  const task = taskName(model);
+  return task === "text generation" || task === "text to text" || task.includes("chat");
+}
+
+function cloudflareError(data) {
+  const messages = (data?.errors || [])
+    .map((error) => [error?.code, error?.message].filter(Boolean).join(": "))
+    .filter(Boolean);
+  return messages.join("; ") || "invalid Cloudflare models response";
+}
+
+async function listModels(provider, { fetchImpl = fetch, timeoutMs = MODELS_TIMEOUT_MS } = {}) {
+  const controller = new AbortController();
+  let timer;
+  const timeoutError = new Error(`models fetch timed out after ${timeoutMs}ms`);
+  timeoutError.name = "TimeoutError";
+  timeoutError.code = "ETIMEDOUT";
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(timeoutError);
+      controller.abort(timeoutError);
+    }, timeoutMs);
+  });
+  const request = (async () => {
+    const catalog = [];
+    let reachedEnd = false;
+    for (let page = 1; page <= MAX_MODEL_PAGES; page += 1) {
+      const res = await fetchImpl(modelsSearchUrl(provider.baseUrl, page), {
+        headers: {
+          Authorization: `Bearer ${provider.apiKey}`,
+          "Content-Type": "application/json",
+        },
+        signal: controller.signal,
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        const error = new Error(`models fetch failed: ${res.status} ${text}`);
+        error.status = res.status;
+        throw error;
+      }
+      const data = await res.json();
+      if (data?.success === false || !Array.isArray(data?.result)) {
+        throw new Error(`models fetch failed: ${cloudflareError(data)}`);
+      }
+      if (!data.result.length) {
+        reachedEnd = true;
+        break;
+      }
+      catalog.push(...data.result);
+    }
+    if (!reachedEnd) throw new Error("models fetch failed: Cloudflare catalog exceeded 10 pages");
+
+    const seen = new Set();
+    return catalog
+      .filter(isChatModel)
+      .map((model) => String(model?.name || "").trim())
+      .filter((id) => id && !seen.has(id) && seen.add(id))
+      .map((id) => ({ id, name: id }));
+  })();
+
+  try {
+    return await Promise.race([request, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function chat(provider, options) {
+  return openaiCompat.chat(provider, options);
+}
+
+module.exports = { chat, listModels, modelsSearchUrl };
diff --git a/src/lib/providers/index.js b/src/lib/providers/index.js
index e190042..395c10d 100644
--- a/src/lib/providers/index.js
+++ b/src/lib/providers/index.js
@@ -1,18 +1,20 @@
 "use strict";
 
 const openaiCompat = require("./openai-compat");
+const cloudflare = require("./cloudflare");
 const claude = require("./claude");
 const chatgpt = require("./chatgpt");
 const antigravity = require("./antigravity");
 const xai = require("./xai");
 const { OAUTH } = require("../constants");
 const { canonicalProviderType, isOAuthProvider } = require("../store");
+const { isCustomProviderType, customProviderModelId } = require("../model-ids");
 
 const TYPE_ADAPTER = {
   "openai-compat": openaiCompat,
   openrouter: openaiCompat,
   nvidia: openaiCompat,
-  cloudflare: openaiCompat,
+  cloudflare,
   glm: openaiCompat,
   custom: openaiCompat,
   claude,
@@ -26,19 +28,17 @@ function getAdapter(type) {
   return TYPE_ADAPTER[type] || null;
 }
 
-/**
- * Resolve models exposed for a provider account (prefix with provider id for uniqueness
- * when multiple accounts exist — unless single-account simple id is enough).
- * Model ids in the gateway are: for combos = combo id; for providers =
- *   `<type>/<model>` or if label set `<type>:<label>/<model>`.
- */
+/** Build the public gateway model id while retaining provider-specific disambiguation. */
 function modelIdFor(provider, model) {
   const mid = typeof model === "string" ? model : model.id;
   const base = canonicalProviderType(provider.type);
   if (isOAuthProvider(provider) && provider.accountAlias) {
     return `${base}/${provider.accountAlias}/${mid}`;
   }
-  // Keyed/custom providers retain their stable provider-id disambiguator.
+  if (isCustomProviderType(provider.type)) {
+    return customProviderModelId(provider, mid);
+  }
+  // Named keyed presets retain their stable provider-id disambiguator.
   const acc = (provider.id || "").replace(/^prov_/, "").slice(0, 8);
   if (acc) return `${base}/${acc}/${mid}`;
   return `${base}/${mid}`;
diff --git a/src/lib/router.js b/src/lib/router.js
index 8682e9f..55018fa 100644
--- a/src/lib/router.js
+++ b/src/lib/router.js
@@ -200,7 +200,14 @@ function errorMessageFromText(text, fallback = "") {
   try {
     const parsed = JSON.parse(text);
     const error = parsed?.error && typeof parsed.error === "object" ? parsed.error : parsed;
-    const parts = [error?.message, error?.type, error?.code, parsed?.message]
+    const parts = [
+      error?.message,
+      error?.detail,
+      error?.type,
+      error?.code,
+      parsed?.message,
+      parsed?.detail,
+    ]
       .filter((part) => typeof part === "string" && part.trim());
     if (parts.length) return [...new Set(parts)].join(" ");
     if (typeof parsed?.error === "string") return parsed.error;
@@ -216,6 +223,18 @@ function classifyFailure(status, errorText) {
     status === 429 ||
     /rate[ _-]?limit|too many requests|quota|usage[ _-]?limit|resource[ _-]?exhaust|capacity|overload/.test(text);
   if (quota) return { eligible: true, kind: "quota", defaultCooldownMs: COOLDOWN_MS.quota };
+  const capability =
+    (status === 400 || status === 404 || status === 422) &&
+    (/(?:unsupported|invalid|unknown)[ _-]?model|model[ _-]?(?:not[ _-]?found|unsupported|unavailable)/.test(
+      text
+    ) ||
+      /\bmodel\b.{0,160}\b(?:is |are )?(?:not supported|not available|unavailable|not found|unknown|does not exist)\b/.test(
+        text
+      ) ||
+      /\b(?:does not|doesn't|cannot|can't) support\b.{0,160}\bmodel\b/.test(text));
+  if (capability) {
+    return { eligible: true, kind: "capability", defaultCooldownMs: 0 };
+  }
   if (status === 401 || status === 403) {
     return { eligible: true, kind: "auth", defaultCooldownMs: COOLDOWN_MS.auth };
   }
@@ -623,7 +642,14 @@ function createRouter({ store, fetchImpl = fetch, requestLog, timeoutMs, usage,
   }
 
   function persistModelLock(provider, upstreamModel, result) {
-    if (!provider?.id || !isOAuthProvider(provider) || !result?.fallbackEligible) return null;
+    if (
+      !provider?.id ||
+      !isOAuthProvider(provider) ||
+      !result?.fallbackEligible ||
+      result.failureKind === "capability"
+    ) {
+      return null;
+    }
     const now = Date.now();
     const until = result.resetAt || now + result.defaultCooldownMs;
     const lock = {
@@ -1128,6 +1154,7 @@ module.exports = {
   orderMembers,
   isRetryableStatus,
   classifyFailure,
+  errorMessageFromText,
   attemptLabel,
   parseResetHint,
   hasProductiveResponsesEvent,
diff --git a/src/lib/store.js b/src/lib/store.js
index a57a1bf..81d56fc 100644
--- a/src/lib/store.js
+++ b/src/lib/store.js
@@ -10,11 +10,13 @@ const {
   OAUTH_MODEL_RENAMES,
 } = require("./constants");
 const { ensureUniqueComboNames, providerRouteIds } = require("./combos");
+const { ensureUniqueCustomConnectionNames } = require("./model-ids");
 const { backfillTokenIdentity } = require("./oauth-identity");
 
-const CONFIG_VERSION = 7;
+const CONFIG_VERSION = 8;
 const COMBO_NAME_MIGRATION_VERSION = 5;
 const XAI_LOCK_RESET_VERSION = 6;
+const RETIRED_OAUTH_CLEANUP_VERSION = 8;
 const OAUTH_ALIAS_RE = /^oauth([1-9]\d*)$/;
 
 class ConfigLoadError extends Error {
@@ -106,7 +108,7 @@ function getActiveModelLock(provider, model, now = Date.now()) {
   return locks[0] || null;
 }
 
-function mergeOAuthCatalog(provider) {
+function mergeOAuthCatalog(provider, { removeRetired = false } = {}) {
   if (!isOAuthProvider(provider)) return;
   const family = canonicalProviderType(provider.type);
   const catalog = OAUTH[family]?.models || [];
@@ -136,7 +138,8 @@ function mergeOAuthCatalog(provider) {
       enabled: existing.get(model.id)?.enabled !== false,
     })),
     ...(provider.models || []).filter(
-      (model) => !catalogIds.has(model.id) && !retiredIds.has(model.id)
+      (model) =>
+        !catalogIds.has(model.id) && (!removeRetired || !retiredIds.has(model.id))
     ),
   ];
 }
@@ -173,6 +176,7 @@ function migrate(cfg) {
   const sourceVersion = Number(cfg.version) || 1;
   const needsComboNameMigration = sourceVersion < COMBO_NAME_MIGRATION_VERSION;
   const needsXaiLockReset = sourceVersion < XAI_LOCK_RESET_VERSION;
+  const needsRetiredOAuthCleanup = sourceVersion < RETIRED_OAUTH_CLEANUP_VERSION;
 
   if (!Array.isArray(cfg.providers)) cfg.providers = [];
 
@@ -217,12 +221,12 @@ function migrate(cfg) {
         enabled: m.enabled !== false,
       };
     });
-    mergeOAuthCatalog(p);
+    mergeOAuthCatalog(p, { removeRetired: needsRetiredOAuthCleanup });
   }
 
   ensureOAuthAliases(cfg.providers, cfg.providerAliasCounters);
-
   if (!Array.isArray(cfg.combos)) cfg.combos = [];
+  ensureUniqueCustomConnectionNames(cfg.providers, cfg.combos);
   const providerById = new Map((cfg.providers || []).map((provider) => [provider.id, provider]));
   for (const combo of cfg.combos) {
     for (const member of combo.members || []) {
diff --git a/src/main.js b/src/main.js
index 83fc9f2..ceab23b 100644
--- a/src/main.js
+++ b/src/main.js
@@ -45,6 +45,12 @@ const { createUpdateService } = require("./lib/updater");
 const { acquireSingleInstance } = require("./lib/single-instance");
 const { KEYED_PRESETS, ONBOARDING_STEPS, DEFAULT_PORT, OAUTH } = require("./lib/constants");
 const { defaultModelsForType, listProviderModels, getAdapter } = require("./lib/providers");
+const {
+  customConnectionNameError,
+  customModelRouteConflict,
+  customProviderModelId,
+  isCustomProviderType,
+} = require("./lib/model-ids");
 const {
   publicCombo,
   comboMatchesId,
@@ -608,6 +614,20 @@ function registerIpc() {
       type = preset;
     }
     if (!finalBase || !apiKey) return { ok: false, error: "Base URL and API key required" };
+    if (type === "custom") {
+      const current = store.load();
+      const nameError = customConnectionNameError(finalName, current.providers);
+      if (nameError) return { ok: false, error: nameError };
+      finalName = String(finalName).trim();
+      const conflict = customModelRouteConflict(finalName, models, current.combos);
+      if (conflict) {
+        const modelId = typeof conflict === "string" ? conflict : conflict.id;
+        return {
+          ok: false,
+          error: `A route named ${customProviderModelId({ name: finalName }, modelId)} already exists`,
+        };
+      }
+    }
     const prov = {
       id: generateId("prov"),
       type: type === "custom" ? "openai-compat" : type,
@@ -625,7 +645,8 @@ function registerIpc() {
   });
 
   handle("app:test-keyed-provider", async (_e, payload) => {
-    return testKeyedProvider(payload, { logger });
+    const adapter = getAdapter(payload?.providerType);
+    return testKeyedProvider(payload, { adapter: adapter || undefined, logger });
   });
 
   handle("app:remove-provider", async (_e, id) => {
@@ -795,6 +816,15 @@ function registerIpc() {
     const prov = (cfg.providers || []).find((p) => p.id === providerId);
     if (!prov) return { ok: false, error: "Provider not found" };
     if (prov.enabled === false) return { ok: false, error: "Provider is disabled" };
+    if (isCustomProviderType(prov.type)) {
+      const conflict = customModelRouteConflict(prov.name, [mid], cfg.combos);
+      if (conflict) {
+        return {
+          ok: false,
+          error: `A route named ${customProviderModelId(prov, mid)} already exists`,
+        };
+      }
+    }
 
     // Verify with a minimal non-stream chat request through the real adapter
     const adapter = getAdapter(prov.type);
@@ -826,6 +856,13 @@ function registerIpc() {
         if (m && typeof m !== "string") m.enabled = true;
       }
     });
+    const savedModel = store
+      .load()
+      .providers.find((provider) => provider.id === providerId)
+      ?.models?.find((model) => (typeof model === "string" ? model : model.id) === mid);
+    if (!savedModel || (typeof savedModel !== "string" && savedModel.enabled === false)) {
+      return { ok: false, error: "Model passed its test but could not be saved" };
+    }
     return { ok: true, modelId: mid };
   });
 
diff --git a/src/renderer/app.js b/src/renderer/app.js
index 9e39377..6bfb0d0 100644
--- a/src/renderer/app.js
+++ b/src/renderer/app.js
@@ -6,6 +6,7 @@ const { accountDisplayName, accountIdentityLabel, maskAccountEmail } =
 const { compactNumber: fmtNum } = window.ReroutedNumberFormat;
 const { createLatestRequestGate, guardSensitiveRender } = window.ReroutedRendererLockState;
 const { buildProviderCatalog } = window.ReroutedProviderCatalog;
+const { buildRouteAccountOptions, modelsForRouteAccount } = window.ReroutedRoutePicker;
 const { oauthPrompt } = window.ReroutedOAuthPrompt;
 const $ = (sel, el = document) => el.querySelector(sel);
 const view = $("#view");
@@ -606,6 +607,7 @@ function bindKeyedProviderPicker(
         let result;
         try {
           result = await api.invoke("app:test-keyed-provider", {
+            providerType: isCustom ? "openai-compat" : presetId,
             baseUrl: baseUrl(),
             apiKey: field("key").value.trim(),
             modelId: field("model")?.value?.trim() || "",
@@ -652,7 +654,7 @@ function bindKeyedProviderPicker(
             baseUrl: baseUrl(),
             apiKey: field("key").value.trim(),
             accountId: accountId(),
-            models: models.slice(0, 50).map((model) =>
+            models: models.map((model) =>
               typeof model === "string"
                 ? { id: model, name: model, enabled: true }
                 : { ...model, enabled: true }
@@ -1512,6 +1514,8 @@ function beginComboEdit(combo) {
     id: combo?.storageId || combo?.id || null,
     name: combo?.name || "",
     strategy: combo?.strategy || "fallback",
+    pickerAccountId: null,
+    pickerModelId: null,
     members: (combo?.members || []).map((member) => ({
       providerId: member.providerId,
       model: member.model || member.upstreamModel,
@@ -1532,11 +1536,31 @@ function comboMemberInfo(member, models) {
   );
 }
 
+function routeAccountLabel(account) {
+  if (account.accountAlias) return `${account.name} · ${aliasLabel(account.accountAlias)}`;
+  if (account.connectionCount > 1) return `${account.name} · Connection ${account.connectionIndex}`;
+  return account.name;
+}
+
 function renderCombos() {
   if (blockSensitiveRenderIfLocked()) return;
   const combos = state.combos || [];
   const models = flatModels();
+  const accounts = buildRouteAccountOptions(state.providers || []);
   const editor = comboDraft;
+  if (editor && !accounts.some((account) => account.id === editor.pickerAccountId)) {
+    editor.pickerAccountId = null;
+    editor.pickerModelId = null;
+  }
+  const pickerModels = editor
+    ? modelsForRouteAccount(accounts, editor.pickerAccountId)
+    : [];
+  if (
+    editor?.pickerModelId &&
+    !pickerModels.some((model) => model.upstreamModel === editor.pickerModelId)
+  ) {
+    editor.pickerModelId = null;
+  }
 
   view.innerHTML = `
     ${pageHeader("Routing", "Routes", "Give clients one memorable model ID while ReRouted handles account and provider failover.", '<button type="button" class="btn btn-primary btn-sm" id="btn-new-route">New route</button>')}
@@ -1591,7 +1615,11 @@ function renderCombos() {
             : `<div class="empty" style="margin:0;border:0">Add at least one model to this route.</div>`
         }
       </div>
-      <div class="copy-field"><select class="select" id="c-add-model"><option value="">Choose an account and model…</option>${models.map((model, index) => `<option value="${index}">${esc(model.name)} · ${esc(model.upstreamModel)}</option>`).join("")}</select><button type="button" class="btn btn-secondary btn-sm" id="btn-add-member">Add</button></div>
+      <div class="route-member-picker">
+        <label class="route-picker-field" for="c-add-account"><span class="label">Account</span><select class="select" id="c-add-account"><option value="">Choose an account…</option>${accounts.map((account) => `<option value="${esc(account.id)}" ${account.id === editor.pickerAccountId ? "selected" : ""}>${esc(routeAccountLabel(account))}</option>`).join("")}</select></label>
+        <label class="route-picker-field" for="c-add-model"><span class="label">Model</span><select class="select" id="c-add-model" ${editor.pickerAccountId ? "" : "disabled"}><option value="">${editor.pickerAccountId ? "Choose a model…" : "Choose an account first…"}</option>${pickerModels.map((model) => `<option value="${esc(model.upstreamModel)}" ${model.upstreamModel === editor.pickerModelId ? "selected" : ""}>${esc(model.name)} · ${esc(model.upstreamModel)}</option>`).join("")}</select></label>
+        <button type="button" class="btn btn-secondary btn-sm route-picker-add" id="btn-add-member" ${editor.pickerAccountId && editor.pickerModelId ? "" : "disabled"}>Add to route</button>
+      </div>
       <div class="btn-row"><button type="button" class="btn btn-secondary" id="btn-cancel-edit">Cancel</button><button type="button" class="btn btn-primary" id="btn-create">${editor.id ? "Save route" : "Create route"}</button></div>
     </section>`
         : ""
@@ -1649,18 +1677,31 @@ function renderCombos() {
       renderCombos();
     };
   });
+  $("#c-add-account").onchange = () => {
+    syncComboDraft();
+    editor.pickerAccountId = $("#c-add-account").value || null;
+    editor.pickerModelId = null;
+    renderCombos();
+  };
+  $("#c-add-model").onchange = () => {
+    editor.pickerModelId = $("#c-add-model").value || null;
+    $("#btn-add-member").disabled = !editor.pickerAccountId || !editor.pickerModelId;
+  };
   $("#btn-add-member").onclick = () => {
     syncComboDraft();
-    const value = $("#c-add-model").value;
-    if (value === "") return toast("Choose a model");
-    const index = Number(value);
-    const model = models[index];
+    if (!editor.pickerAccountId) return toast("Choose an account");
+    if (!editor.pickerModelId) return toast("Choose a model");
+    const model = pickerModels.find(
+      (item) => item.upstreamModel === editor.pickerModelId
+    );
     if (!model) return toast("Choose a model");
     const member = { providerId: model.providerId, model: model.upstreamModel };
     if (editor.members.some((item) => memberKey(item) === memberKey(member))) {
       return toast("That model is already in the route");
     }
     editor.members.push(member);
+    editor.pickerAccountId = null;
+    editor.pickerModelId = null;
     renderCombos();
   };
   $("#btn-cancel-edit").onclick = () => {
diff --git a/src/renderer/index.html b/src/renderer/index.html
index 66be6dd..f649756 100644
--- a/src/renderer/index.html
+++ b/src/renderer/index.html
@@ -62,6 +62,7 @@
     <script src="number-format.js"></script>
     <script src="lock-state.js"></script>
     <script src="provider-catalog.js"></script>
+    <script src="route-picker.js"></script>
     <script src="oauth-prompt.js"></script>
     <script src="app.js"></script>
   </body>
diff --git a/src/renderer/route-picker.js b/src/renderer/route-picker.js
new file mode 100644
index 0000000..f47e3e3
--- /dev/null
+++ b/src/renderer/route-picker.js
@@ -0,0 +1,59 @@
+"use strict";
+
+(function exposeRoutePicker(root) {
+  function enabledModelOptions(provider) {
+    const models = [];
+    for (const model of provider?.models || []) {
+      if (typeof model !== "string" && model?.enabled === false) continue;
+      const id = typeof model === "string" ? model : model?.id;
+      if (!id) continue;
+      models.push({
+        id,
+        name: typeof model === "string" ? model : model.name || id,
+        gatewayId: typeof model === "string" ? null : model.gatewayId || null,
+        providerId: provider.id,
+        upstreamModel: id,
+      });
+    }
+    return models;
+  }
+
+  function buildRouteAccountOptions(providers) {
+    const accounts = [];
+    for (const provider of providers || []) {
+      if (!provider?.id || provider.enabled === false) continue;
+      const models = enabledModelOptions(provider);
+      if (!models.length) continue;
+      accounts.push({
+        id: provider.id,
+        name: String(provider.name || provider.type || "Account").trim() || "Account",
+        accountAlias: provider.accountAlias || null,
+        providerType: provider.type || "",
+        models,
+      });
+    }
+    const duplicateGroups = new Map();
+    for (const account of accounts) {
+      if (account.accountAlias) continue;
+      const key = `${account.providerType}:${account.name}`.toLowerCase();
+      if (!duplicateGroups.has(key)) duplicateGroups.set(key, []);
+      duplicateGroups.get(key).push(account);
+    }
+    for (const group of duplicateGroups.values()) {
+      if (group.length < 2) continue;
+      group.forEach((account, index) => {
+        account.connectionIndex = index + 1;
+        account.connectionCount = group.length;
+      });
+    }
+    return accounts;
+  }
+
+  function modelsForRouteAccount(accounts, accountId) {
+    return (accounts || []).find((account) => account.id === accountId)?.models || [];
+  }
+
+  const api = { buildRouteAccountOptions, modelsForRouteAccount };
+  if (typeof module !== "undefined" && module.exports) module.exports = api;
+  if (root) root.ReroutedRoutePicker = api;
+})(typeof window !== "undefined" ? window : null);
diff --git a/src/renderer/styles.css b/src/renderer/styles.css
index a9fd93d..44f1f1c 100644
--- a/src/renderer/styles.css
+++ b/src/renderer/styles.css
@@ -1382,6 +1382,34 @@ summary:focus-visible,
   background: var(--paper-strong);
 }
 
+.route-member-picker {
+  display: grid;
+  gap: 9px;
+  margin-top: 2px;
+  padding: 11px;
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  background: var(--mono-bg);
+}
+
+.route-picker-field {
+  display: block;
+}
+
+.route-picker-field .select {
+  margin: 0;
+}
+
+.route-picker-field .select:disabled {
+  color: var(--faint);
+  background: #e4dfd4;
+  cursor: not-allowed;
+}
+
+.route-picker-add {
+  width: 100%;
+}
+
 .member-row {
   display: grid;
   grid-template-columns: 24px minmax(0, 1fr) auto;
diff --git a/tests/catalog-migration.test.js b/tests/catalog-migration.test.js
index 151d129..d83362e 100644
--- a/tests/catalog-migration.test.js
+++ b/tests/catalog-migration.test.js
@@ -2,8 +2,12 @@
 
 const assert = require("node:assert/strict");
 const { describe, it } = require("node:test");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
 const { OAUTH } = require("../src/lib/constants");
-const { migrate } = require("../src/lib/store");
+const { createRouter } = require("../src/lib/router");
+const { createStore, migrate } = require("../src/lib/store");
 
 function migrateProvider(provider) {
   return migrate({ providers: [provider], combos: [] }).providers[0];
@@ -57,6 +61,79 @@ describe("OAuth catalog migration", () => {
     }
   });
 
+  it("allows a retired catalog ID to be explicitly re-added after cleanup", () => {
+    const cfg = migrate({
+      version: 7,
+      providers: [
+        {
+          id: "prov_claude",
+          type: "claude",
+          models: ["claude-sonnet-4-6"],
+        },
+      ],
+      combos: [],
+    });
+
+    assert.equal(cfg.version, 8);
+    assert.equal(
+      cfg.providers[0].models.some((model) => model.id === "claude-sonnet-4-6"),
+      false
+    );
+
+    cfg.providers[0].models.push({
+      id: "claude-sonnet-4-6",
+      name: "claude-sonnet-4-6",
+      enabled: true,
+    });
+    const saved = migrate(cfg);
+
+    assert.deepEqual(
+      saved.providers[0].models.find((model) => model.id === "claude-sonnet-4-6"),
+      {
+        id: "claude-sonnet-4-6",
+        name: "claude-sonnet-4-6",
+        enabled: true,
+      }
+    );
+  });
+
+  it("persists an explicitly re-added Claude model across disk reload and discovery", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rerouted-claude-model-"));
+    const configPath = path.join(dir, "config.json");
+    try {
+      const store = createStore(configPath);
+      store.seed({
+        version: 7,
+        providers: [{ id: "prov_claude", type: "claude", enabled: true, models: [] }],
+        combos: [],
+      });
+      store.update((cfg) => {
+        cfg.providers[0].models.push({
+          id: "claude-sonnet-4-6",
+          name: "claude-sonnet-4-6",
+          enabled: true,
+        });
+      });
+
+      const reloaded = createStore(configPath);
+      const saved = reloaded
+        .load()
+        .providers[0].models.find((model) => model.id === "claude-sonnet-4-6");
+      assert.deepEqual(saved, {
+        id: "claude-sonnet-4-6",
+        name: "claude-sonnet-4-6",
+        enabled: true,
+      });
+      assert.ok(
+        createRouter({ store: reloaded })
+          .listModels()
+          .data.some((model) => model.id === "claude/claude-sonnet-4-6")
+      );
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("does not apply OAuth cleanup to keyed providers", () => {
     const provider = migrateProvider({
       id: "prov_custom",
@@ -70,6 +147,24 @@ describe("OAuth catalog migration", () => {
     );
   });
 
+  it("normalizes legacy custom names without stealing an existing route id", () => {
+    const cfg = migrate({
+      version: 7,
+      providers: [
+        { id: "prov_a", type: "openai-compat", name: "", models: ["model-a"] },
+        { id: "prov_b", type: "openai-compat", name: "Custom", models: ["model-a"] },
+        { id: "prov_c", type: "openai-compat", name: "Lab", models: ["model-a"] },
+      ],
+      combos: [{ id: "combo_lab", name: "Lab/custom/model-a", members: [] }],
+    });
+
+    assert.deepEqual(
+      cfg.providers.map((provider) => provider.name),
+      ["Custom", "Custom 2", "Lab 2"]
+    );
+    assert.equal(cfg.combos[0].name, "Lab/custom/model-a");
+  });
+
   it("clears pre-fix xAI locks once without clearing other providers or future xAI locks", () => {
     const oldLock = {
       until: Date.now() + 60_000,
@@ -86,7 +181,7 @@ describe("OAuth catalog migration", () => {
       combos: [],
     });
 
-    assert.equal(migrated.version, 7);
+    assert.equal(migrated.version, 8);
     assert.deepEqual(migrated.providers[0].modelLocks, {});
     assert.deepEqual(migrated.providers[1].modelLocks, { "*": oldLock });
 
diff --git a/tests/cloudflare.test.js b/tests/cloudflare.test.js
new file mode 100644
index 0000000..45fdbd0
--- /dev/null
+++ b/tests/cloudflare.test.js
@@ -0,0 +1,143 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const { it } = require("node:test");
+const cloudflare = require("../src/lib/providers/cloudflare");
+
+const provider = {
+  type: "cloudflare",
+  baseUrl: "https://api.cloudflare.test/client/v4/accounts/account-id/ai/v1/",
+  apiKey: "test-key",
+};
+
+it("discovers runnable chat models through the Cloudflare models search endpoint", async () => {
+  const requests = [];
+  const models = await cloudflare.listModels(provider, {
+    fetchImpl: async (url, options) => {
+      requests.push({ url, options });
+      return {
+        ok: true,
+        json: async () => ({
+          success: true,
+          result:
+            new URL(url).searchParams.get("page") === "1"
+              ? [
+                  {
+                    id: "catalog-uuid",
+                    name: "@cf/meta/llama-chat",
+                    task: { name: "Text Generation" },
+                  },
+                  {
+                    id: "image-uuid",
+                    name: "@cf/image/model",
+                    task: { name: "Image Classification" },
+                  },
+                  {
+                    id: "chat-uuid",
+                    name: "@cf/openai/gpt-chat",
+                    task: { name: "Chat" },
+                  },
+                  {
+                    id: "duplicate-catalog-uuid",
+                    name: "@cf/meta/llama-chat",
+                    task: { name: "Text Generation" },
+                  },
+                ]
+              : [],
+        }),
+      };
+    },
+  });
+
+  assert.equal(
+    requests[0].url,
+    "https://api.cloudflare.test/client/v4/accounts/account-id/ai/models/search?page=1&per_page=100"
+  );
+  assert.equal(requests[0].options.headers.Authorization, "Bearer test-key");
+  assert.equal(new URL(requests[1].url).searchParams.get("page"), "2");
+  assert.deepEqual(models, [
+    { id: "@cf/meta/llama-chat", name: "@cf/meta/llama-chat" },
+    { id: "@cf/openai/gpt-chat", name: "@cf/openai/gpt-chat" },
+  ]);
+});
+
+it("continues Cloudflare discovery until the final short page", async () => {
+  const pages = [];
+  const models = await cloudflare.listModels(provider, {
+    fetchImpl: async (url) => {
+      const page = Number(new URL(url).searchParams.get("page"));
+      pages.push(page);
+      const result =
+        page === 1
+          ? Array.from({ length: 100 }, (_, index) => ({
+              name: `@cf/test/model-${index}`,
+              task: "Text Generation",
+            }))
+          : page === 2
+            ? [{ name: "@cf/test/final-model", task: "Text Generation" }]
+            : [];
+      return { ok: true, json: async () => ({ success: true, result }) };
+    },
+  });
+
+  assert.deepEqual(pages, [1, 2, 3]);
+  assert.equal(models.length, 101);
+  assert.equal(models.at(-1).id, "@cf/test/final-model");
+});
+
+it("reports Cloudflare envelope errors instead of accepting an empty model list", async () => {
+  await assert.rejects(
+    () =>
+      cloudflare.listModels(provider, {
+        fetchImpl: async () => ({
+          ok: true,
+          json: async () => ({
+            success: false,
+            result: null,
+            errors: [{ code: 7001, message: "GET not supported for requested URI." }],
+          }),
+        }),
+      }),
+    /7001: GET not supported for requested URI\./
+  );
+});
+
+it("bounds Cloudflare model discovery when fetch ignores cancellation", async () => {
+  let signal;
+  await assert.rejects(
+    () =>
+      cloudflare.listModels(provider, {
+        timeoutMs: 20,
+        fetchImpl: (_url, options) => {
+          signal = options.signal;
+          return new Promise(() => {});
+        },
+      }),
+    { name: "TimeoutError", code: "ETIMEDOUT" }
+  );
+
+  assert.equal(signal.aborted, true);
+  assert.equal(signal.reason.name, "TimeoutError");
+});
+
+it("keeps Cloudflare chat on the OpenAI-compatible endpoint", async () => {
+  let request;
+  const response = await cloudflare.chat(provider, {
+    model: "@cf/meta/llama-chat",
+    body: { messages: [{ role: "user", content: "hello" }] },
+    stream: false,
+    fetchImpl: async (url, options) => {
+      request = { url, options };
+      return new Response(JSON.stringify({ choices: [] }), { status: 200 });
+    },
+  });
+
+  assert.equal(
+    request.url,
+    "https://api.cloudflare.test/client/v4/accounts/account-id/ai/v1/chat/completions"
+  );
+  assert.equal(request.options.method, "POST");
+  assert.equal(request.options.headers.Authorization, "Bearer test-key");
+  assert.equal(JSON.parse(request.options.body).model, "@cf/meta/llama-chat");
+  assert.equal(response.ok, true);
+});
diff --git a/tests/combos.test.js b/tests/combos.test.js
index c8d64dd..fa1bea4 100644
--- a/tests/combos.test.js
+++ b/tests/combos.test.js
@@ -70,11 +70,19 @@ describe("public combo identity", () => {
         accountAlias: "oauth1",
         models: [{ id: "gpt-5", enabled: true }],
       },
+      {
+        id: "prov_abcdef1234",
+        type: "openai-compat",
+        name: "  Local Lab  ",
+        models: [{ id: "private-model", enabled: true }],
+      },
     ]);
     assert.equal(providerIds.has("gpt-5"), true);
     assert.equal(providerIds.has("chatgpt/gpt-5"), true);
     assert.equal(providerIds.has("chatgpt/oauth1/gpt-5"), true);
     assert.equal(providerIds.has("chatgpt/12345678/gpt-5"), true);
+    assert.equal(providerIds.has("local lab/custom/private-model"), true);
+    assert.equal(providerIds.has("openai-compat/abcdef12/private-model"), true);
     assert.equal(comboStorageIdConflict([{ id: "combo_a", name: "Coding" }], "combo_a")?.id, "combo_a");
   });
 
diff --git a/tests/gateway.test.js b/tests/gateway.test.js
index 6d9c80c..3ebff63 100644
--- a/tests/gateway.test.js
+++ b/tests/gateway.test.js
@@ -241,7 +241,9 @@ describe("gateway auth + models + chat", () => {
     assert.ok(ids.includes("rr-combo"));
     assert.ok(!ids.includes("combo_fb"));
     assert.ok(!ids.includes("combo_rr"));
-    assert.ok(ids.some((i) => i.includes("mock-model")));
+    assert.ok(ids.includes("Mock A/custom/mock-model"));
+    assert.ok(ids.includes("Mock B/custom/mock-model"));
+    assert.ok(!ids.includes("openai-compat/mock_a/mock-model"));
   });
 
   it("non-streaming chat completion", async () => {
@@ -263,6 +265,19 @@ describe("gateway auth + models + chat", () => {
     assert.equal(r.json.choices[0].message.content, "Hello from mock");
   });
 
+  it("keeps a legacy hash-qualified custom model id routable", async () => {
+    const r = await req("POST", "/v1/chat/completions", {
+      key: apiKey,
+      body: {
+        model: "openai-compat/mock_a/mock-model",
+        messages: [{ role: "user", content: "hi" }],
+        stream: false,
+      },
+    });
+    assert.equal(r.status, 200, JSON.stringify(r.json));
+    assert.equal(r.json.choices[0].message.content, "Hello from mock");
+  });
+
   it("streaming chat completion SSE", async () => {
     const models = (await req("GET", "/v1/models", { key: apiKey })).json.data;
     const id = models.find((m) => m.owned_by === "openai-compat")?.id;
diff --git a/tests/keyed-provider-test.test.js b/tests/keyed-provider-test.test.js
index ce8bc3c..50e2644 100644
--- a/tests/keyed-provider-test.test.js
+++ b/tests/keyed-provider-test.test.js
@@ -83,3 +83,50 @@ it("does not admit an exact model when its chat-completion test fails", async ()
   assert.equal(result.ok, false);
   assert.match(result.error, /Model test failed \(404\): unknown model/);
 });
+
+it("supports Cloudflare model discovery when the preset adapter is selected", async () => {
+  const pages = [];
+  const server = http.createServer((request, response) => {
+    const url = new URL(request.url, "http://127.0.0.1");
+    assert.equal(url.pathname, "/client/v4/accounts/account-id/ai/models/search");
+    assert.equal(url.searchParams.get("per_page"), "100");
+    pages.push(Number(url.searchParams.get("page")));
+    assert.equal(request.headers.authorization, "Bearer test-key");
+    response.writeHead(200, { "Content-Type": "application/json" });
+    response.end(
+      JSON.stringify({
+        success: true,
+        result:
+          url.searchParams.get("page") === "1"
+            ? [
+                {
+                  id: "catalog-uuid",
+                  name: "@cf/meta/llama-chat",
+                  task: { name: "Text Generation" },
+                },
+              ]
+            : [],
+      })
+    );
+  });
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+
+  try {
+    const result = await testKeyedProvider(
+      {
+        baseUrl: `http://127.0.0.1:${server.address().port}/client/v4/accounts/account-id/ai/v1`,
+        apiKey: "test-key",
+        providerType: "cloudflare",
+      }
+    );
+
+    assert.deepEqual(result, {
+      ok: true,
+      validation: "models",
+      models: [{ id: "@cf/meta/llama-chat", name: "@cf/meta/llama-chat" }],
+    });
+    assert.deepEqual(pages, [1, 2]);
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+});
diff --git a/tests/provider-model-ids.test.js b/tests/provider-model-ids.test.js
new file mode 100644
index 0000000..50300df
--- /dev/null
+++ b/tests/provider-model-ids.test.js
@@ -0,0 +1,106 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const { describe, it } = require("node:test");
+
+const { listProviderModels, modelIdFor } = require("../src/lib/providers");
+const {
+  customConnectionNameError,
+  customModelRouteConflict,
+  ensureUniqueCustomConnectionNames,
+} = require("../src/lib/model-ids");
+const { resolveSingle } = require("../src/lib/router");
+
+describe("custom provider model ids", () => {
+  it("advertises the trimmed connection name and custom namespace", () => {
+    const provider = {
+      id: "prov_1234567890",
+      type: "openai-compat",
+      name: "  Local Lab  ",
+      enabled: true,
+      models: [{ id: "team/model-a", name: "Model A", enabled: true }],
+    };
+
+    assert.equal(modelIdFor(provider, "team/model-a"), "Local Lab/custom/team/model-a");
+    assert.equal(listProviderModels(provider)[0].id, "Local Lab/custom/team/model-a");
+  });
+
+  it("falls back to Custom for legacy blank names", () => {
+    assert.equal(
+      modelIdFor(
+        { id: "prov_abcdef1234", type: "custom", name: "   " },
+        "legacy-model"
+      ),
+      "Custom/custom/legacy-model"
+    );
+  });
+
+  it("keeps old hash-qualified custom ids resolvable", () => {
+    const provider = {
+      id: "prov_1234567890",
+      type: "openai-compat",
+      name: "Local Lab",
+      enabled: true,
+      models: [{ id: "model-a", name: "Model A", enabled: true }],
+    };
+    const cfg = { providers: [provider], combos: [] };
+
+    assert.equal(resolveSingle(cfg, "Local Lab/custom/model-a")?.provider.id, provider.id);
+    assert.equal(resolveSingle(cfg, "openai-compat/12345678/model-a")?.provider.id, provider.id);
+  });
+
+  it("retains hash-qualified ids for named keyed presets", () => {
+    assert.equal(
+      modelIdFor(
+        { id: "prov_1234567890", type: "openrouter", name: "OpenRouter" },
+        "model-a"
+      ),
+      "openrouter/12345678/model-a"
+    );
+  });
+
+  it("requires an unambiguous custom connection path segment", () => {
+    const providers = [{ type: "openai-compat", name: "Local Lab" }];
+    assert.equal(customConnectionNameError("", providers), "Custom connection name required");
+    assert.equal(
+      customConnectionNameError("lab/primary", providers),
+      "Custom connection names cannot contain /"
+    );
+    assert.equal(
+      customConnectionNameError(" local lab ", providers),
+      "A custom connection named local lab already exists"
+    );
+    assert.equal(customConnectionNameError("Backup Lab", providers), null);
+  });
+
+  it("disambiguates legacy blank, duplicate, and route-colliding connection names", () => {
+    const providers = [
+      { type: "openai-compat", name: "", models: ["model-a"] },
+      { type: "openai-compat", name: "Custom", models: ["model-a"] },
+      { type: "openai-compat", name: "Local Lab", models: ["model-a"] },
+    ];
+    ensureUniqueCustomConnectionNames(providers, [
+      { id: "combo_route", name: "Local Lab/custom/model-a" },
+    ]);
+    assert.deepEqual(
+      providers.map((provider) => provider.name),
+      ["Custom", "Custom 2", "Local Lab 2"]
+    );
+    ensureUniqueCustomConnectionNames(providers, []);
+    assert.deepEqual(
+      providers.map((provider) => provider.name),
+      ["Custom", "Custom 2", "Local Lab 2"]
+    );
+  });
+
+  it("detects a readable custom model id that is already owned by a route", () => {
+    assert.deepEqual(
+      customModelRouteConflict(
+        "Local Lab",
+        [{ id: "model-a" }, { id: "model-b" }],
+        [{ id: "combo_a", name: "Local Lab/custom/model-b" }]
+      ),
+      { id: "model-b" }
+    );
+  });
+});
diff --git a/tests/route-picker.test.js b/tests/route-picker.test.js
new file mode 100644
index 0000000..d34e2b2
--- /dev/null
+++ b/tests/route-picker.test.js
@@ -0,0 +1,100 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const { describe, it } = require("node:test");
+
+const {
+  buildRouteAccountOptions,
+  modelsForRouteAccount,
+} = require("../src/renderer/route-picker");
+
+describe("route member picker", () => {
+  it("exposes only enabled accounts with enabled models", () => {
+    const accounts = buildRouteAccountOptions([
+      {
+        id: "prov_a",
+        type: "chatgpt",
+        name: "ChatGPT",
+        accountAlias: "oauth1",
+        enabled: true,
+        models: [
+          { id: "gpt-a", name: "GPT A", gatewayId: "chatgpt/gpt-a", enabled: true },
+          { id: "gpt-off", name: "GPT Off", enabled: false },
+        ],
+      },
+      {
+        id: "prov_b",
+        type: "claude",
+        name: "Claude",
+        enabled: false,
+        models: [{ id: "claude-a", enabled: true }],
+      },
+      {
+        id: "prov_empty",
+        type: "xai",
+        name: "xAI",
+        enabled: true,
+        models: [{ id: "grok-off", enabled: false }],
+      },
+      {
+        id: "prov_custom",
+        type: "openai-compat",
+        name: "Local Lab",
+        enabled: true,
+        models: ["local-model"],
+      },
+    ]);
+
+    assert.deepEqual(
+      accounts.map((account) => account.id),
+      ["prov_a", "prov_custom"]
+    );
+    assert.deepEqual(accounts[0], {
+      id: "prov_a",
+      name: "ChatGPT",
+      accountAlias: "oauth1",
+      providerType: "chatgpt",
+      models: [
+        {
+          id: "gpt-a",
+          name: "GPT A",
+          gatewayId: "chatgpt/gpt-a",
+          providerId: "prov_a",
+          upstreamModel: "gpt-a",
+        },
+      ],
+    });
+  });
+
+  it("returns models only for the selected account", () => {
+    const accounts = buildRouteAccountOptions([
+      { id: "prov_a", name: "A", models: ["model-a"] },
+      { id: "prov_b", name: "B", models: ["model-b"] },
+    ]);
+
+    assert.deepEqual(
+      modelsForRouteAccount(accounts, "prov_b").map((model) => model.upstreamModel),
+      ["model-b"]
+    );
+    assert.deepEqual(modelsForRouteAccount(accounts, "missing"), []);
+    assert.deepEqual(modelsForRouteAccount(accounts, null), []);
+  });
+
+  it("numbers duplicate keyed connections without exposing internal ids", () => {
+    const accounts = buildRouteAccountOptions([
+      { id: "prov_private_a", type: "openrouter", name: "OpenRouter", models: ["a"] },
+      { id: "prov_private_b", type: "openrouter", name: "OpenRouter", models: ["b"] },
+    ]);
+
+    assert.deepEqual(
+      accounts.map(({ connectionIndex, connectionCount }) => ({
+        connectionIndex,
+        connectionCount,
+      })),
+      [
+        { connectionIndex: 1, connectionCount: 2 },
+        { connectionIndex: 2, connectionCount: 2 },
+      ]
+    );
+  });
+});
diff --git a/tests/router-fallback.test.js b/tests/router-fallback.test.js
index 14568f7..eebe755 100644
--- a/tests/router-fallback.test.js
+++ b/tests/router-fallback.test.js
@@ -7,7 +7,13 @@ const http = require("node:http");
 const os = require("node:os");
 const path = require("node:path");
 
-const { createRouter, parseResetHint, resolveSingle } = require("../src/lib/router");
+const {
+  classifyFailure,
+  createRouter,
+  errorMessageFromText,
+  parseResetHint,
+  resolveSingle,
+} = require("../src/lib/router");
 const { createStore } = require("../src/lib/store");
 const { createGateway } = require("../src/lib/gateway");
 
@@ -90,6 +96,39 @@ async function withGateway(store, router, callback) {
   }
 }
 
+describe("provider failure classification", () => {
+  it("extracts top-level detail messages", () => {
+    assert.equal(
+      errorMessageFromText(
+        JSON.stringify({
+          detail: "The 'gpt-5.6-sol' model is not supported when using Codex with a ChatGPT account.",
+        })
+      ),
+      "The 'gpt-5.6-sol' model is not supported when using Codex with a ChatGPT account."
+    );
+  });
+
+  it("allows model capability failures to advance fallback without widening generic errors", () => {
+    assert.deepEqual(
+      classifyFailure(
+        400,
+        "The 'gpt-5.6-sol' model is not supported when using Codex with a ChatGPT account."
+      ),
+      { eligible: true, kind: "capability", defaultCooldownMs: 0 }
+    );
+    assert.deepEqual(classifyFailure(400, "invalid request body"), {
+      eligible: false,
+      kind: "request",
+      defaultCooldownMs: 0,
+    });
+    assert.deepEqual(classifyFailure(404, "not-found"), {
+      eligible: false,
+      kind: "request",
+      defaultCooldownMs: 0,
+    });
+  });
+});
+
 describe("same-provider OAuth account fallback", () => {
   it("assigns monotonic oauth aliases and advertises only shared model ids", () => {
     const configPath = tmpConfig();
@@ -412,6 +451,117 @@ describe("same-provider OAuth account fallback", () => {
     assert.deepEqual(calls, ["token-a", "token-b"]);
   });
 
+  it("advances a three-target route after a locked account and unsupported model", async () => {
+    const unsupported =
+      "The 'gpt-5.6-sol' model is not supported when using Codex with a ChatGPT account.";
+    const store = createStore(tmpConfig());
+    store.seed({
+      providers: [
+        chatgptAccount("prov_a", "token-a", 100, {
+          models: [{ id: "gpt-5.6-sol", name: "GPT 5.6 Sol", enabled: true }],
+          modelLocks: {
+            "*": {
+              until: Date.now() + 5 * 60_000,
+              status: 429,
+              kind: "quota",
+              reason: "usage_limit_reached",
+            },
+          },
+        }),
+        chatgptAccount("prov_b", "token-b", 200, {
+          models: [{ id: "gpt-5.6-sol", name: "GPT 5.6 Sol", enabled: true }],
+        }),
+        {
+          id: "prov_backup",
+          type: "openai-compat",
+          name: "Backup",
+          baseUrl: "https://backup.test/v1",
+          apiKey: "backup-key",
+          enabled: true,
+          models: [{ id: "backup-model", name: "Backup model", enabled: true }],
+        },
+      ],
+      combos: [
+        {
+          id: "combo_sol",
+          name: "5.6-sol",
+          strategy: "fallback",
+          members: [
+            { providerId: "prov_a", model: "gpt-5.6-sol" },
+            { providerId: "prov_b", model: "gpt-5.6-sol" },
+            { providerId: "prov_backup", model: "backup-model" },
+          ],
+        },
+      ],
+    });
+    const calls = [];
+    const logger = captureLogger();
+    const router = createRouter({
+      store,
+      logger,
+      fetchImpl: async (_url, options) => {
+        const token = authToken(options);
+        calls.push(token);
+        if (token === "token-b") {
+          return new Response(JSON.stringify({ detail: unsupported }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" },
+          });
+        }
+        if (token === "backup-key") {
+          const request = JSON.parse(options.body);
+          if (request.stream) {
+            return new Response(
+              [
+                `data: ${JSON.stringify({ choices: [{ index: 0, delta: { content: "third target worked" }, finish_reason: null }] })}`,
+                `data: ${JSON.stringify({ choices: [{ index: 0, delta: {}, finish_reason: "stop" }] })}`,
+                "data: [DONE]",
+                "",
+              ].join("\n\n"),
+              { status: 200, headers: { "Content-Type": "text/event-stream" } }
+            );
+          }
+          return successResponse("third target worked");
+        }
+        throw new Error(`Unexpected upstream token: ${token}`);
+      },
+    });
+
+    const result = await router.chatCompletions({
+      body: {
+        model: "5.6-sol",
+        messages: [{ role: "user", content: "hello" }],
+        stream: false,
+      },
+    });
+
+    assert.equal(result.ok, true, JSON.stringify(result.error));
+    assert.equal(result.openAiJson.choices[0].message.content, "third target worked");
+    assert.deepEqual(calls, ["token-b", "backup-key"]);
+    assert.deepEqual(store.load().providers.find((provider) => provider.id === "prov_b").modelLocks, {});
+    assert.ok(logger.entries.some((entry) => entry.meta?.event === "account_locked_skip"));
+    assert.ok(logger.entries.some((entry) => entry.meta?.event === "route_fallback"));
+
+    calls.length = 0;
+    await withGateway(store, router, async (port) => {
+      const response = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${store.load().apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          model: "5.6-sol",
+          messages: [{ role: "user", content: "hello" }],
+          stream: true,
+        }),
+      });
+      assert.equal(response.status, 200);
+      assert.match(await response.text(), /third target worked/);
+    });
+    assert.deepEqual(calls, ["token-b", "backup-key"]);
+  });
+
   it("does not fall back or lock accounts after caller cancellation", async () => {
     const store = createStore(tmpConfig());
     store.seed({