claudish 7.50.0 → 7.51.0

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.50.0";
+var VERSION = "7.51.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -27509,6 +27509,9 @@ function loadConfig() {
     if (config2.customEndpoints !== undefined) {
       merged.customEndpoints = config2.customEndpoints;
     }
+    if (config2.predefinedEndpoints !== undefined) {
+      merged.predefinedEndpoints = config2.predefinedEndpoints;
+    }
     if (config2.behavior !== undefined) {
       merged.behavior = config2.behavior;
     }
@@ -27933,24 +27936,44 @@ function getApiKeyInfo(providerName) {
     oauthFallback: def.oauthFallback
   };
 }
+function describeMissingCredential(providerName) {
+  const info = getApiKeyInfo(providerName);
+  const keyNames = info?.envVar ? [info.envVar, ...info.aliases ?? []].join(" or ") : undefined;
+  const signup = info?.url ? ` Get one at ${info.url}.` : "";
+  const def = getProviderByName(providerName);
+  if (isLocalTransport(providerName)) {
+    const where = def ? ` Claudish will use ${getEffectiveBaseUrl(def)}.` : "";
+    const keyClause = keyNames ? ` (Only set ${keyNames} if your local server requires a bearer token.)` : "";
+    return `Provider "${providerName}" is a LOCAL server and is not enabled. ` + "Enable it in `claudish config` (Providers tab), or add " + `"localProviders": ["${providerName}"] to ~/.claudish/config.json.${where}${keyClause}`;
+  }
+  if (def?.oauthFallback) {
+    const keyClause = keyNames ? ` Or set ${keyNames} (env, config, or 1Password import) to use a metered API key instead.${signup}` : "";
+    return `No credential for provider "${providerName}". Sign in with ` + `\`claudish login ${providerName}\` to use your existing subscription.${keyClause}`;
+  }
+  return keyNames ? `No API key for provider "${providerName}". Set ${keyNames} (env, config, or 1Password import).${signup}` : `No API key for provider "${providerName}".`;
+}
 function getDisplayName(providerName) {
   const def = getProviderByName(providerName);
   return def?.displayName || providerName.charAt(0).toUpperCase() + providerName.slice(1);
 }
-function getEffectiveBaseUrl(def) {
-  if (def.baseUrlEnvVars) {
-    for (const envVar of def.baseUrlEnvVars) {
-      const fromConfig = getEndpoint(envVar);
-      if (fromConfig)
-        return fromConfig;
-    }
-    for (const envVar of def.baseUrlEnvVars) {
-      const value = process.env[envVar];
-      if (value)
-        return value;
-    }
+function baseUrlOverrideCandidates(baseUrlEnvVars) {
+  const found = [];
+  if (!baseUrlEnvVars || baseUrlEnvVars.length === 0)
+    return found;
+  for (const envVar of baseUrlEnvVars) {
+    const fromConfig = getEndpoint(envVar);
+    if (fromConfig)
+      found.push({ envVar, value: fromConfig, source: "config" });
   }
-  return def.baseUrl;
+  for (const envVar of baseUrlEnvVars) {
+    const value = process.env[envVar];
+    if (value)
+      found.push({ envVar, value, source: "env" });
+  }
+  return found;
+}
+function getEffectiveBaseUrl(def) {
+  return baseUrlOverrideCandidates(def.baseUrlEnvVars)[0]?.value ?? def.baseUrl;
 }
 function isLocalTransport(providerName) {
   if (!_localProvidersCache) {
@@ -30850,6 +30873,22 @@ var init_antigravity_credential = __esm(() => {
   init_antigravity_user();
 });
 
+// src/auth/credentials/local-api-key.ts
+function resolveLocalApiKey(q) {
+  return realValue(process.env[q.envVar]) || (q.aliases ?? []).map((a) => realValue(process.env[a])).find((v) => !!v) || realValue(getApiKey(q.envVar));
+}
+function hasLocalApiKey(q) {
+  try {
+    return !!resolveLocalApiKey(q);
+  } catch {
+    return false;
+  }
+}
+var init_local_api_key = __esm(() => {
+  init_env_placeholder();
+  init_profile_config();
+});
+
 // src/auth/credentials/api-key-credential.ts
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir10 } from "os";
@@ -30877,7 +30916,7 @@ class ApiKeyCredentialProvider {
     this.declaredKey = descriptor.declaredKey;
   }
   resolveFromEnvConfig() {
-    return realValue(process.env[this.envVar]) || this.aliases.map((a) => realValue(process.env[a])).find((v) => !!v) || realValue(getApiKey(this.envVar)) || realValue(this.resolveDeclared());
+    return resolveLocalApiKey({ envVar: this.envVar, aliases: this.aliases }) || realValue(this.resolveDeclared());
   }
   resolveDeclared() {
     try {
@@ -30958,7 +30997,7 @@ class ApiKeyCredentialProvider {
 }
 var init_api_key_credential = __esm(() => {
   init_env_placeholder();
-  init_profile_config();
+  init_local_api_key();
   init_op_source();
 });
 
@@ -32359,7 +32398,7 @@ var init_authority = __esm(() => {
 });
 
 // src/config-schema.ts
-var BuiltinDefaultProviderSchema, CustomEndpointSimpleSchema, CustomEndpointComplexSchema, CustomEndpointSchema, DefaultProviderSchema;
+var BuiltinDefaultProviderSchema, CustomEndpointSimpleSchema, CustomEndpointComplexSchema, CustomEndpointSchema, PredefinedEndpointsConfigSchema, DefaultProviderSchema;
 var init_config_schema = __esm(() => {
   init_zod();
   BuiltinDefaultProviderSchema = exports_external.enum([
@@ -32394,6 +32433,11 @@ var init_config_schema = __esm(() => {
     CustomEndpointSimpleSchema,
     CustomEndpointComplexSchema
   ]);
+  PredefinedEndpointsConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().optional(),
+    disable: exports_external.array(exports_external.string()).optional(),
+    enable: exports_external.array(exports_external.string()).optional()
+  });
   DefaultProviderSchema = exports_external.union([BuiltinDefaultProviderSchema, exports_external.string().min(1)]);
 });
 
@@ -36581,7 +36625,14 @@ class OpenAIProviderTransport {
   async getHeaders() {
     const headers = {};
     if (this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`;
+      if (this.provider.authScheme === "x-api-key") {
+        headers["x-api-key"] = this.apiKey;
+      } else {
+        headers.Authorization = `Bearer ${this.apiKey}`;
+      }
+    }
+    if (this.provider.headers) {
+      Object.assign(headers, this.provider.headers);
     }
     return headers;
   }
@@ -41383,6 +41434,21 @@ var init_composed_handler = __esm(() => {
   STREAM_RETRY_DELAYS_MS = [3000, 15000, 30000];
 });
 
+// src/providers/endpoint-diagnostics.ts
+function recordEndpointUnavailable(name, reason) {
+  reasons.set(name, reason);
+}
+function clearEndpointUnavailable(name) {
+  reasons.delete(name);
+}
+function getEndpointUnavailableReason(name) {
+  return reasons.get(name);
+}
+var reasons;
+var init_endpoint_diagnostics = __esm(() => {
+  reasons = new Map;
+});
+
 // src/providers/devin/devin-request.ts
 import { randomUUID as randomUUID3 } from "crypto";
 function encodeChatMetadata(meta3) {
@@ -42645,6 +42711,21 @@ var init_litellm = __esm(() => {
 });
 
 // src/providers/custom-endpoints-loader.ts
+function registerEndpoint(name, entry, ovr) {
+  const validated = CustomEndpointSchema.parse(entry);
+  const def = buildProviderDefinition(name, validated, ovr);
+  const profile = buildProviderProfile(validated, ovr);
+  registerRuntimeProvider(def);
+  registerRuntimeProfile(name, profile);
+  credentials.registerApiKeyProvider({
+    name: def.name,
+    envVar: def.apiKeyEnvVar,
+    aliases: def.apiKeyAliases,
+    authScheme: def.authScheme === "x-api-key" ? "x-api-key" : "bearer",
+    declaredKey: () => resolveDeclaredEndpointKey(validated)
+  });
+  clearEndpointUnavailable(name);
+}
 function loadCustomEndpoints(config2) {
   const result = { registered: 0, errors: [] };
   const raw = config2.customEndpoints;
@@ -42652,17 +42733,7 @@ function loadCustomEndpoints(config2) {
     return result;
   for (const [name, entry] of Object.entries(raw)) {
     try {
-      const validated = CustomEndpointSchema.parse(entry);
-      const def = buildProviderDefinition(name, validated);
-      const profile = buildProviderProfile(validated);
-      registerRuntimeProvider(def);
-      registerRuntimeProfile(name, profile);
-      credentials.registerApiKeyProvider({
-        name: def.name,
-        envVar: def.apiKeyEnvVar,
-        authScheme: def.authScheme === "x-api-key" ? "x-api-key" : "bearer",
-        declaredKey: () => resolveDeclaredEndpointKey(validated)
-      });
+      registerEndpoint(name, entry);
       result.registered++;
     } catch (err) {
       const message = err instanceof exports_external.ZodError ? err.issues.map((i) => i.message).join(", ") : err instanceof Error ? err.message : String(err);
@@ -42671,22 +42742,28 @@ function loadCustomEndpoints(config2) {
   }
   return result;
 }
-function buildProviderDefinition(name, ep) {
+function buildProviderDefinition(name, ep, ovr) {
+  const apiKeyEnvVar = ovr?.apiKeyEnvVar ?? customEndpointKeyEnvVar(name);
+  const apiKeyAliases = ovr?.apiKeyAliases;
+  const baseUrlEnvVars = ovr?.baseUrlEnvVars;
+  const apiKeyUrl = ovr?.apiKeyUrl ?? "";
   if (ep.kind === "simple") {
     return {
       name,
       displayName: name,
       transport: ep.format,
       baseUrl: stripTrailingSlash(ep.url),
+      baseUrlEnvVars,
       apiPath: "/chat/completions",
-      apiKeyEnvVar: `CUSTOM_${sanitizeEnvName(name)}_KEY`,
-      apiKeyDescription: `${name} (custom endpoint)`,
-      apiKeyUrl: "",
+      apiKeyEnvVar,
+      apiKeyAliases,
+      apiKeyDescription: ovr?.apiKeyDescription ?? `${name} (custom endpoint)`,
+      apiKeyUrl,
       shortcuts: [name],
       legacyPrefixes: [],
       isDirectApi: true,
       shortestPrefix: name,
-      description: `Custom endpoint: ${name}`,
+      description: ovr?.description ?? `Custom endpoint: ${name}`,
       authScheme: "bearer"
     };
   }
@@ -42695,33 +42772,68 @@ function buildProviderDefinition(name, ep) {
     displayName: ep.displayName,
     transport: ep.transport,
     baseUrl: stripTrailingSlash(ep.baseUrl),
+    baseUrlEnvVars,
     apiPath: ep.apiPath ?? "/v1/chat/completions",
-    apiKeyEnvVar: `CUSTOM_${sanitizeEnvName(name)}_KEY`,
-    apiKeyDescription: `${ep.displayName} (custom endpoint)`,
-    apiKeyUrl: "",
+    apiKeyEnvVar,
+    apiKeyAliases,
+    apiKeyDescription: ovr?.apiKeyDescription ?? `${ep.displayName} (custom endpoint)`,
+    apiKeyUrl,
     shortcuts: [name],
     legacyPrefixes: [],
     isDirectApi: true,
     shortestPrefix: name,
-    description: `Custom endpoint: ${ep.displayName}`,
+    description: ovr?.description ?? `Custom endpoint: ${ep.displayName}`,
     headers: ep.headers,
     authScheme: ep.authScheme ?? "bearer"
   };
 }
-function buildProviderProfile(ep) {
+function buildProviderProfile(ep, ovr) {
   return {
     createHandler(ctx) {
       const apiKey = ctx.apiKey || resolveCustomEndpointApiKey(ep);
+      const declaredBaseUrl = ep.kind === "simple" ? ep.url : ep.baseUrl;
+      const resolved = classifyEndpointBaseUrl(declaredBaseUrl, ovr?.baseUrlEnvVars);
+      if (!resolved.ok) {
+        const reason = describeBadBaseUrlOverride(resolved, declaredBaseUrl);
+        console.error(`[claudish] ${reason}`);
+        recordEndpointUnavailable(ctx.provider.name, `its ${reason}`);
+        return null;
+      }
+      const baseUrl = resolved.url;
       if (ep.kind === "simple") {
-        return buildSimpleHandler(ep, ctx, apiKey);
+        return buildSimpleHandler(ep, ctx, apiKey, baseUrl);
       }
-      return buildComplexHandler(ep, ctx, apiKey);
+      return buildComplexHandler(ep, ctx, apiKey, baseUrl);
     }
   };
 }
-function buildSimpleHandler(ep, ctx, apiKey) {
+function classifyEndpointBaseUrl(declared, baseUrlEnvVars) {
+  for (const candidate of baseUrlOverrideCandidates(baseUrlEnvVars)) {
+    const value = realValue(candidate.value)?.trim();
+    if (!value)
+      continue;
+    if (!isHttpUrl(value)) {
+      return { ok: false, envVar: candidate.envVar, value, source: candidate.source };
+    }
+    return { ok: true, url: stripTrailingSlash(value) };
+  }
+  return { ok: true, url: stripTrailingSlash(declared) };
+}
+function describeBadBaseUrlOverride(bad, declared) {
+  const where = bad.source === "config" ? `config.endpoints["${bad.envVar}"] is set to '${bad.value}'` : `${bad.envVar} is set to '${bad.value}'`;
+  const remedy = bad.source === "config" ? "Fix or remove it (claudish config -> Providers)." : "Fix or unset it.";
+  return `${where}, which is not a valid http(s) URL. ` + `${remedy} (Not falling back to ${declared} \u2014 the override was set on purpose.)`;
+}
+function isHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function buildSimpleHandler(ep, ctx, apiKey, baseUrl) {
   const finalModel = ep.modelPrefix ? `${ep.modelPrefix}${ctx.modelName}` : ctx.modelName;
-  const baseUrl = stripTrailingSlash(ep.url);
   if (ep.format === "openai") {
     const remoteProvider2 = {
       name: ctx.provider.name,
@@ -42756,9 +42868,8 @@ function buildSimpleHandler(ep, ctx, apiKey) {
     ...ctx.sharedOpts
   });
 }
-function buildComplexHandler(ep, ctx, apiKey) {
+function buildComplexHandler(ep, ctx, apiKey, baseUrl) {
   const finalModel = ep.modelPrefix ? `${ep.modelPrefix}${ctx.modelName}` : ctx.modelName;
-  const baseUrl = stripTrailingSlash(ep.baseUrl);
   const apiPath = ep.apiPath ?? "/v1/chat/completions";
   switch (ep.transport) {
     case "litellm": {
@@ -42830,6 +42941,9 @@ function resolveDeclaredEndpointKey(ep) {
 function stripTrailingSlash(url2) {
   return url2.replace(/\/+$/, "");
 }
+function customEndpointKeyEnvVar(name) {
+  return `CUSTOM_${sanitizeEnvName(name)}_KEY`;
+}
 function sanitizeEnvName(name) {
   return name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
 }
@@ -42840,13 +42954,518 @@ var init_custom_endpoints_loader = __esm(() => {
   init_openai_api_format();
   init_authority();
   init_config_schema();
+  init_env_placeholder();
   init_composed_handler();
+  init_endpoint_diagnostics();
+  init_provider_definitions();
   init_runtime_providers();
   init_anthropic_compat();
   init_litellm();
   init_openai();
 });
 
+// src/providers/picker-alias-extra.ts
+var PROVIDER_FILTER_ALIAS_EXTRA;
+var init_picker_alias_extra = __esm(() => {
+  PROVIDER_FILTER_ALIAS_EXTRA = {
+    gem: "google",
+    zen: "opencode-zen"
+  };
+});
+
+// src/providers/predefined-catalog.ts
+var PREDEFINED_ENDPOINTS;
+var init_predefined_catalog = __esm(() => {
+  PREDEFINED_ENDPOINTS = [
+    {
+      name: "groq",
+      displayName: "Groq",
+      baseUrl: "https://api.groq.com/openai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "GROQ_API_KEY",
+      apiKeyUrl: "https://console.groq.com/keys",
+      description: "Groq LPU inference (groq@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "cerebras",
+      displayName: "Cerebras",
+      baseUrl: "https://api.cerebras.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "CEREBRAS_API_KEY",
+      apiKeyUrl: "https://cloud.cerebras.ai",
+      description: "Cerebras Inference wafer-scale hosting (cerebras@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "together",
+      displayName: "Together AI",
+      baseUrl: "https://api.together.xyz",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "TOGETHER_API_KEY",
+      apiKeyUrl: "https://api.together.xyz/settings/api-keys",
+      description: "Together AI direct inference API (together@) \u2014 distinct from the 'together-ai' vendor id models-index uses as an aggregator label",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "fireworks",
+      displayName: "Fireworks AI",
+      baseUrl: "https://api.fireworks.ai/inference",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "FIREWORKS_API_KEY",
+      apiKeyUrl: "https://fireworks.ai/account/api-keys",
+      description: "Fireworks AI serverless inference (fireworks@)",
+      evidence: {
+        tier: "probe",
+        verdict: "model-gate",
+        status: 404,
+        measuredAt: "2026-08-14",
+        note: "404 rejecting the fake model ('Model not found, inaccessible, and/or not deployed'); the bogus sibling path answered 'Path not found', so the route resolved"
+      }
+    },
+    {
+      name: "deepinfra",
+      displayName: "DeepInfra",
+      baseUrl: "https://api.deepinfra.com/v1/openai",
+      apiPath: "/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "DEEPINFRA_API_KEY",
+      apiKeyUrl: "https://deepinfra.com/dash/api_keys",
+      description: "DeepInfra hosted open models (deepinfra@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "nebius",
+      displayName: "Nebius AI Studio",
+      baseUrl: "https://api.studio.nebius.com",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "NEBIUS_API_KEY",
+      apiKeyUrl: "https://studio.nebius.com",
+      description: "Nebius AI Studio hosted open models (nebius@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "hyperbolic",
+      displayName: "Hyperbolic",
+      baseUrl: "https://api.hyperbolic.xyz",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "HYPERBOLIC_API_KEY",
+      apiKeyUrl: "https://app.hyperbolic.xyz",
+      description: "Hyperbolic decentralized GPU inference (hyperbolic@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "sambanova",
+      displayName: "SambaNova Cloud",
+      baseUrl: "https://api.sambanova.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "SAMBANOVA_API_KEY",
+      apiKeyUrl: "https://cloud.sambanova.ai",
+      description: "SambaNova Cloud RDU inference (sambanova@)",
+      evidence: {
+        tier: "probe",
+        verdict: "model-gate",
+        status: 404,
+        measuredAt: "2026-08-14",
+        note: "404 naming our fake model ('The model `probe-nonexistent-model-zzz` does not exist'), i.e. the route resolved and the model was rejected before auth"
+      }
+    },
+    {
+      name: "novita",
+      displayName: "Novita AI",
+      baseUrl: "https://api.novita.ai/v3/openai",
+      apiPath: "/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "NOVITA_API_KEY",
+      apiKeyUrl: "https://novita.ai/settings",
+      description: "Novita AI hosted open models (novita@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "baseten",
+      displayName: "Baseten",
+      baseUrl: "https://inference.baseten.co",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "BASETEN_API_KEY",
+      apiKeyUrl: "https://app.baseten.co",
+      description: "Baseten model APIs (baseten@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 403, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "perplexity",
+      displayName: "Perplexity",
+      baseUrl: "https://api.perplexity.ai",
+      apiPath: "/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "PERPLEXITY_API_KEY",
+      apiKeyUrl: "https://www.perplexity.ai/settings/api",
+      description: "Perplexity Sonar search-grounded models (perplexity@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "venice",
+      displayName: "Venice AI",
+      baseUrl: "https://api.venice.ai/api",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "VENICE_API_KEY",
+      apiKeyUrl: "https://venice.ai/settings/api",
+      description: "Venice AI privacy-focused open models (venice@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "chutes",
+      displayName: "Chutes",
+      baseUrl: "https://llm.chutes.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "CHUTES_API_KEY",
+      description: "Chutes decentralized inference on Bittensor (chutes@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "featherless",
+      displayName: "Featherless AI",
+      baseUrl: "https://api.featherless.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "FEATHERLESS_API_KEY",
+      description: "Featherless AI serverless HuggingFace model hosting (featherless@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "parasail",
+      displayName: "Parasail",
+      baseUrl: "https://api.parasail.io",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "PARASAIL_API_KEY",
+      description: "Parasail on-demand GPU inference (parasail@)",
+      evidence: {
+        tier: "probe",
+        verdict: "auth-realm",
+        status: 401,
+        measuredAt: "2026-08-14",
+        note: "non-OpenAI error shape: plain text 'Unauthorized. Invalid token.' under content-type application/json;charset=ISO-8859-1. Classified terminal on the 401 status, so no retry is burned; see validation/error-shape-probe.md"
+      }
+    },
+    {
+      name: "inference-net",
+      displayName: "Inference.net",
+      baseUrl: "https://api.inference.net",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "INFERENCE_NET_API_KEY",
+      description: "Inference.net distributed open-model inference (inference-net@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "aimlapi",
+      displayName: "AI/ML API",
+      baseUrl: "https://api.aimlapi.com",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "AIMLAPI_API_KEY",
+      description: "AI/ML API multi-vendor aggregator (aimlapi@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "requesty",
+      displayName: "Requesty",
+      baseUrl: "https://router.requesty.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "REQUESTY_API_KEY",
+      description: "Requesty LLM router (requesty@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 403, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "nanogpt",
+      displayName: "NanoGPT",
+      baseUrl: "https://nano-gpt.com/api",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "NANOGPT_API_KEY",
+      description: "NanoGPT pay-per-prompt multi-vendor aggregator (nanogpt@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "cohere",
+      displayName: "Cohere",
+      baseUrl: "https://api.cohere.ai/compatibility",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "COHERE_API_KEY",
+      apiKeyUrl: "https://dashboard.cohere.com/api-keys",
+      description: "Cohere Command models via their OpenAI-compatibility layer (cohere@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "scaleway",
+      displayName: "Scaleway Generative APIs",
+      baseUrl: "https://api.scaleway.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "SCALEWAY_API_KEY",
+      apiKeyUrl: "https://console.scaleway.com",
+      description: "Scaleway Generative APIs, EU-hosted open models (scaleway@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 403, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "upstage",
+      displayName: "Upstage",
+      baseUrl: "https://api.upstage.ai",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "UPSTAGE_API_KEY",
+      apiKeyUrl: "https://console.upstage.ai",
+      description: "Upstage Solar models (upstage@)",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "writer",
+      displayName: "Writer",
+      baseUrl: "https://api.writer.com",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "WRITER_API_KEY",
+      description: "Writer Palmyra models (writer@)",
+      evidence: {
+        tier: "probe",
+        verdict: "auth-realm",
+        status: 401,
+        measuredAt: "2026-08-14",
+        note: 'non-OpenAI error shape: {"tpe":"fail.auth","errors":[{"description":\u2026}]} with no top-level `error` object. Classified terminal on the 401 status, so no retry is burned; see validation/error-shape-probe.md'
+      }
+    },
+    {
+      name: "moonshot-cn",
+      displayName: "Moonshot AI (China)",
+      baseUrl: "https://api.moonshot.cn",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "MOONSHOT_CN_API_KEY",
+      apiKeyUrl: "https://platform.moonshot.cn",
+      description: "Moonshot AI China-region endpoint (moonshot-cn@) \u2014 a separate product from the builtin Kimi provider reached by moonshot@/kimi@",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    },
+    {
+      name: "tuningengines",
+      displayName: "Tuning Engines",
+      baseUrl: "https://api.tuningengines.com",
+      apiPath: "/v1/chat/completions",
+      format: "openai",
+      apiKeyEnvVar: "TUNING_ENGINES_API_KEY",
+      baseUrlEnvVars: ["TUNING_ENGINES_BASE_URL"],
+      description: "Tuning Engines enterprise LLM gateway (tuningengines@); self-hosted instances point TUNING_ENGINES_BASE_URL at their own host",
+      evidence: { tier: "probe", verdict: "auth-realm", status: 401, measuredAt: "2026-08-14" }
+    }
+  ];
+});
+
+// src/providers/predefined-endpoints.ts
+function warnOnce2(message) {
+  if (warnedMessages2.has(message))
+    return;
+  warnedMessages2.add(message);
+  console.error(message);
+}
+function activeCatalog() {
+  return catalogOverride ?? PREDEFINED_ENDPOINTS;
+}
+function reservedNamespace() {
+  const reserved = new Map;
+  for (const def of BUILTIN_PROVIDERS) {
+    reserved.set(def.name.toLowerCase(), def.name);
+    for (const shortcut of def.shortcuts) {
+      reserved.set(shortcut.toLowerCase(), def.name);
+    }
+    for (const legacy of def.legacyPrefixes) {
+      reserved.set(legacy.prefix.replace(/[/:]+$/, "").toLowerCase(), def.name);
+    }
+  }
+  for (const [alias, owner] of Object.entries(PROVIDER_FILTER_ALIAS_EXTRA)) {
+    reserved.set(alias.toLowerCase(), owner);
+  }
+  return reserved;
+}
+function readOptOut(config2) {
+  const off = { disabled: true, disable: new Set, enable: new Set };
+  if (process.env[KILL_SWITCH_ENV] === "1")
+    return off;
+  const raw = config2?.predefinedEndpoints;
+  let parsed = {};
+  if (raw !== undefined) {
+    const result = PredefinedEndpointsConfigSchema.safeParse(raw);
+    if (result.success) {
+      parsed = result.data;
+    } else {
+      warnOnce2("[claudish] config 'predefinedEndpoints' is not valid and was ignored: " + result.error.issues.map((i) => `${i.path.join(".") || "(root)"} ${i.message}`).join(", "));
+    }
+  }
+  return {
+    disabled: parsed.enabled === false,
+    disable: new Set((parsed.disable ?? []).map((n) => n.trim().toLowerCase())),
+    enable: new Set((parsed.enable ?? []).map((n) => n.trim().toLowerCase()))
+  };
+}
+function compileToCustomEndpoint(entry) {
+  return {
+    kind: "complex",
+    displayName: entry.displayName,
+    transport: entry.format,
+    baseUrl: entry.baseUrl,
+    apiPath: entry.apiPath,
+    apiKey: `\${${entry.apiKeyEnvVar}}`,
+    authScheme: entry.authScheme,
+    headers: entry.headers,
+    modelPrefix: entry.modelPrefix
+  };
+}
+function credentialEnvVars(entry) {
+  return {
+    envVar: entry.apiKeyEnvVar,
+    aliases: [...entry.apiKeyAliases ?? [], customEndpointKeyEnvVar(entry.name)]
+  };
+}
+function overridesFor(entry) {
+  const { envVar, aliases } = credentialEnvVars(entry);
+  return {
+    apiKeyEnvVar: envVar,
+    apiKeyAliases: aliases,
+    baseUrlEnvVars: entry.baseUrlEnvVars,
+    apiKeyUrl: entry.apiKeyUrl ?? "",
+    apiKeyDescription: `${entry.displayName} (${envVar})`,
+    description: entry.description ?? `${entry.displayName} (bundled endpoint)`
+  };
+}
+function loadPredefinedEndpoints(config2, opts = {}) {
+  const result = { registered: [], skipped: [] };
+  const optOut = readOptOut(config2);
+  const catalog = opts.catalog ?? activeCatalog();
+  const runtime = getRuntimeProviders();
+  const noteStale = (entry, name, reason) => {
+    if (!ownRegistrations.has(name) || !runtime.has(entry.name))
+      return;
+    warnOnce2(`[claudish] predefined endpoint '${entry.name}' is no longer eligible (${reason}) but stays ` + "registered for the rest of this process \u2014 runtime provider registration cannot be " + "undone. Restart claudish to apply the change.");
+  };
+  if (optOut.disabled) {
+    for (const entry of catalog) {
+      result.skipped.push({ name: entry.name, reason: "catalog off" });
+      noteStale(entry, entry.name.toLowerCase(), "catalog off");
+    }
+    return result;
+  }
+  const reserved = reservedNamespace();
+  const userEndpoints = new Set(Object.keys(config2?.customEndpoints ?? {}).map((n) => n.toLowerCase()));
+  const seen = new Set;
+  for (const entry of catalog) {
+    const name = entry.name.toLowerCase();
+    const skip = (reason) => result.skipped.push({ name: entry.name, reason });
+    const skipStale = (reason) => {
+      skip(reason);
+      noteStale(entry, name, reason);
+    };
+    if (seen.has(name)) {
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' appears more than once in the bundled ` + "catalog. The first row wins; the later one is ignored.");
+      skip("duplicate row");
+      continue;
+    }
+    seen.add(name);
+    const owner = reserved.get(name);
+    if (owner) {
+      const reason = `'${entry.name}' is already claimed by builtin provider '${owner}' ` + "(as its name, a shortcut, or a legacy prefix)";
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' skipped: ${reason}. ` + "The builtin wins; the bundled entry is inactive.");
+      recordEndpointUnavailable(entry.name, `bundled endpoint was skipped because ${reason}`);
+      skip("collides with builtin");
+      continue;
+    }
+    if (runtime.has(entry.name) && !ownRegistrations.has(name)) {
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' skipped: a provider named ` + `'${entry.name}' is already registered for this process.`);
+      skip("already registered");
+      continue;
+    }
+    if (userEndpoints.has(name)) {
+      if (hasLocalApiKey({ envVar: entry.apiKeyEnvVar })) {
+        warnOnce2(`[claudish] customEndpoints['${entry.name}'] replaces the bundled entry entirely; ` + `${entry.apiKeyEnvVar} no longer applies to it. Add ` + `"apiKey": "\${${entry.apiKeyEnvVar}}" to that entry to keep using it.`);
+      }
+      skipStale("replaced by customEndpoints");
+      continue;
+    }
+    if (optOut.disable.has(name)) {
+      skipStale("disabled in config");
+      continue;
+    }
+    const { envVar, aliases } = credentialEnvVars(entry);
+    const permitted = optOut.enable.has(name) || hasLocalApiKey({ envVar, aliases });
+    if (!permitted) {
+      skipStale("no local credential");
+      continue;
+    }
+    const resolvedUrl = classifyEndpointBaseUrl(entry.baseUrl, entry.baseUrlEnvVars);
+    if (!resolvedUrl.ok) {
+      const detail = describeBadBaseUrlOverride(resolvedUrl, entry.baseUrl);
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' skipped: ${detail}`);
+      recordEndpointUnavailable(entry.name, detail);
+      skipStale("invalid base URL override");
+      continue;
+    }
+    try {
+      registerEndpoint(entry.name, compileToCustomEndpoint(entry), overridesFor(entry));
+      ownRegistrations.add(name);
+      result.registered.push(entry.name);
+    } catch (err) {
+      warnOnce2(`[claudish] predefined endpoint '${entry.name}' skipped: ` + `${err instanceof Error ? err.message : String(err)}`);
+      skip("invalid catalog row");
+    }
+  }
+  return result;
+}
+var KILL_SWITCH_ENV = "CLAUDISH_NO_PREDEFINED_ENDPOINTS", warnedMessages2, ownRegistrations, catalogOverride = null;
+var init_predefined_endpoints = __esm(() => {
+  init_local_api_key();
+  init_config_schema();
+  init_custom_endpoints_loader();
+  init_endpoint_diagnostics();
+  init_picker_alias_extra();
+  init_predefined_catalog();
+  init_provider_definitions();
+  init_runtime_providers();
+  warnedMessages2 = new Set;
+  ownRegistrations = new Set;
+});
+
+// src/providers/endpoint-registration.ts
+var exports_endpoint_registration = {};
+__export(exports_endpoint_registration, {
+  invalidateEndpointRegistration: () => invalidateEndpointRegistration,
+  ensureEndpointsRegistered: () => ensureEndpointsRegistered
+});
+function ensureEndpointsRegistered(opts = {}) {
+  if (registered && !opts.force)
+    return;
+  registered = true;
+  try {
+    loadPredefinedEndpoints(opts.config ?? loadConfig());
+  } catch {}
+}
+function invalidateEndpointRegistration() {
+  registered = false;
+}
+var registered = false;
+var init_endpoint_registration = __esm(() => {
+  init_profile_config();
+  init_predefined_endpoints();
+});
+
 // src/providers/provider-registry.ts
 function resolveBaseUrl2(envVar, fallbackEnvVars, staticDefault) {
   for (const v of [envVar, ...fallbackEnvVars]) {
@@ -43715,7 +44334,9 @@ async function prepareParentRoutingContext() {
   if (!parentRoutingContextReady) {
     parentRoutingContextReady = true;
     try {
-      loadCustomEndpoints(loadConfig());
+      const config2 = loadConfig();
+      ensureEndpointsRegistered({ config: config2 });
+      loadCustomEndpoints(config2);
     } catch {}
   }
   try {
@@ -43765,6 +44386,7 @@ var init_prehydrate = __esm(() => {
   init_auto_route();
   init_catalog_client();
   init_custom_endpoints_loader();
+  init_endpoint_registration();
   init_model_parser();
   init_onepassword();
   init_provider_resolver();
@@ -47534,38 +48156,6 @@ var init_native_handler = __esm(() => {
   init_anthropic_error();
 });
 
-// src/providers/api-key-map.ts
-var API_KEY_MAP;
-var init_api_key_map = __esm(() => {
-  API_KEY_MAP = {
-    litellm: { envVar: "LITELLM_API_KEY" },
-    openrouter: { envVar: "OPENROUTER_API_KEY" },
-    google: { envVar: "GEMINI_API_KEY" },
-    openai: { envVar: "OPENAI_API_KEY" },
-    minimax: { envVar: "MINIMAX_API_KEY" },
-    "minimax-coding": { envVar: "MINIMAX_CODING_API_KEY" },
-    kimi: { envVar: "MOONSHOT_API_KEY", aliases: ["KIMI_API_KEY"] },
-    "kimi-coding": { envVar: "KIMI_CODING_API_KEY" },
-    glm: { envVar: "ZHIPU_API_KEY", aliases: ["GLM_API_KEY"] },
-    "glm-coding": { envVar: "GLM_CODING_API_KEY", aliases: ["ZAI_CODING_API_KEY"] },
-    "z-ai": { envVar: "ZAI_API_KEY" },
-    deepseek: { envVar: "DEEPSEEK_API_KEY" },
-    mistralai: { envVar: "MISTRAL_API_KEY" },
-    sakana: { envVar: "SAKANA_API_KEY" },
-    "sakana-subscription": {
-      envVar: "SAKANA_SUBSCRIPTION_API_KEY",
-      aliases: ["SAKANA_CODING_API_KEY"]
-    },
-    "qwen-cloud": { envVar: "QWEN_CLOUD_PLAN_API_KEY" },
-    "qwen-payg": { envVar: "DASHSCOPE_API_KEY", aliases: ["QWEN_API_KEY"] },
-    ollamacloud: { envVar: "OLLAMA_API_KEY" },
-    "opencode-zen": { envVar: "OPENCODE_API_KEY" },
-    "opencode-zen-go": { envVar: "OPENCODE_GO_API_KEY", aliases: ["OPENCODE_API_KEY"] },
-    vertex: { envVar: "VERTEX_API_KEY", aliases: ["VERTEX_PROJECT"] },
-    poe: { envVar: "POE_API_KEY" }
-  };
-});
-
 // src/providers/devin/tool-descriptions.ts
 function currentMonthAndYear(now = new Date) {
   return `${MONTHS[now.getMonth()]} ${now.getFullYear()}`;
@@ -49411,7 +50001,9 @@ __export(exports_proxy_server, {
 });
 async function createProxyServer(port, _openrouterApiKey, model, monitorMode = false, anthropicApiKey, modelMap, options = {}) {
   try {
-    const customEpResult = loadCustomEndpoints(loadConfig());
+    const config2 = loadConfig();
+    ensureEndpointsRegistered({ config: config2 });
+    const customEpResult = loadCustomEndpoints(config2);
     if (customEpResult.registered > 0) {
       log(`[Proxy] Registered ${customEpResult.registered} custom endpoint(s) from config`);
     }
@@ -49704,9 +50296,11 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
     if (hasExplicitProvider) {
       const parsedExplicit = parseModelSpec(target);
       if (parsedExplicit.provider !== "openrouter") {
-        const keyInfo = API_KEY_MAP[parsedExplicit.provider];
-        const keyNames = keyInfo ? [keyInfo.envVar, ...keyInfo.aliases ?? []].join(" or ") : undefined;
-        const hint = keyNames ? `No API key for provider "${parsedExplicit.provider}". Set ${keyNames} (env, config, or 1Password import).` : `No API key for provider "${parsedExplicit.provider}".`;
+        const recorded = getEndpointUnavailableReason(parsedExplicit.provider);
+        if (recorded) {
+          throw new RoutingError(`Explicit model "${target}" could not be routed \u2014 ${recorded}`);
+        }
+        const hint = describeMissingCredential(parsedExplicit.provider);
         throw new RoutingError(`Explicit model "${target}" could not be routed \u2014 its provider has no credential. ${hint}`);
       }
     }
@@ -49858,11 +50452,13 @@ var init_proxy_server = __esm(() => {
   init_logger();
   init_model_loader();
   init_profile_config();
-  init_api_key_map();
   init_auto_route();
   init_catalog_client();
   init_custom_endpoints_loader();
+  init_endpoint_diagnostics();
+  init_endpoint_registration();
   init_model_parser();
+  init_provider_definitions();
   init_provider_profiles();
   init_provider_registry();
   init_provider_resolver();
@@ -52034,6 +52630,7 @@ async function serveCommand(args) {
     console.error("[claudish serve] --models <path> is required");
     process.exit(1);
   }
+  ensureEndpointsRegistered();
   let slotMap;
   let slotIds;
   try {
@@ -52054,6 +52651,7 @@ async function serveCommand(args) {
   await new Promise(() => {});
 }
 var init_serve_command = __esm(() => {
+  init_endpoint_registration();
   init_proxy_server();
 });
 
@@ -65350,7 +65948,8 @@ var init_antigravity_oauth = __esm(() => {
 var exports_auth_commands = {};
 __export(exports_auth_commands, {
   logoutCommand: () => logoutCommand,
-  loginCommand: () => loginCommand
+  loginCommand: () => loginCommand,
+  findProvider: () => findProvider
 });
 function getAuthStatus(provider) {
   const hasCredentials = provider.registryKeys.some((k) => hasOAuthCredentials(k)) || provider.name === "antigravity" && hasSharedAntigravityToken();
@@ -65865,7 +66464,7 @@ __export(exports_model_selector, {
   buildDiscoveredModelRows: () => buildDiscoveredModelRows
 });
 function isUserDeployedProvider(value) {
-  return LOCAL_OR_USER_DEPLOYED.has(value);
+  return LOCAL_OR_USER_DEPLOYED.has(value) || getRuntimeProviders().has(value);
 }
 function firebaseSlugToProviderName(slug) {
   const lower = slug.toLowerCase();
@@ -66625,7 +67224,7 @@ async function selectProfile(profiles) {
 async function confirmAction(message) {
   return dist_default4({ message, default: false });
 }
-var pickerProviderToFirebaseSlug, LOCAL_OR_USER_DEPLOYED, SUBSCRIPTION_PRICING, PROVIDER_FILTER_ALIAS_EXTRA, PICKER_COPY, PICKER_ORDER, PROVIDER_MODEL_PREFIX_OVERRIDE;
+var pickerProviderToFirebaseSlug, LOCAL_OR_USER_DEPLOYED, SUBSCRIPTION_PRICING, PICKER_COPY, PICKER_ORDER, PROVIDER_MODEL_PREFIX_OVERRIDE;
 var init_model_selector = __esm(() => {
   init_dist16();
   init_model_catalog();
@@ -66635,7 +67234,9 @@ var init_model_selector = __esm(() => {
   init_model_catalog2();
   init_model_discovery();
   init_registry2();
+  init_picker_alias_extra();
   init_provider_definitions();
+  init_runtime_providers();
   init_probe_discovery();
   pickerProviderToFirebaseSlug = {
     openrouter: "openrouter",
@@ -66663,10 +67264,6 @@ var init_model_selector = __esm(() => {
     output: "SUB",
     average: "SUB"
   };
-  PROVIDER_FILTER_ALIAS_EXTRA = {
-    gem: "google",
-    zen: "opencode-zen"
-  };
   PICKER_COPY = {
     openrouter: { description: "580+ models via unified API" },
     "opencode-zen": { name: "OpenCode Zen", description: "Free models, no API key needed" },
@@ -69369,6 +69966,38 @@ var init_probe_tui_runtime = __esm(() => {
   init_probe_tui_app();
 });
 
+// src/providers/api-key-map.ts
+var API_KEY_MAP;
+var init_api_key_map = __esm(() => {
+  API_KEY_MAP = {
+    litellm: { envVar: "LITELLM_API_KEY" },
+    openrouter: { envVar: "OPENROUTER_API_KEY" },
+    google: { envVar: "GEMINI_API_KEY" },
+    openai: { envVar: "OPENAI_API_KEY" },
+    minimax: { envVar: "MINIMAX_API_KEY" },
+    "minimax-coding": { envVar: "MINIMAX_CODING_API_KEY" },
+    kimi: { envVar: "MOONSHOT_API_KEY", aliases: ["KIMI_API_KEY"] },
+    "kimi-coding": { envVar: "KIMI_CODING_API_KEY" },
+    glm: { envVar: "ZHIPU_API_KEY", aliases: ["GLM_API_KEY"] },
+    "glm-coding": { envVar: "GLM_CODING_API_KEY", aliases: ["ZAI_CODING_API_KEY"] },
+    "z-ai": { envVar: "ZAI_API_KEY" },
+    deepseek: { envVar: "DEEPSEEK_API_KEY" },
+    mistralai: { envVar: "MISTRAL_API_KEY" },
+    sakana: { envVar: "SAKANA_API_KEY" },
+    "sakana-subscription": {
+      envVar: "SAKANA_SUBSCRIPTION_API_KEY",
+      aliases: ["SAKANA_CODING_API_KEY"]
+    },
+    "qwen-cloud": { envVar: "QWEN_CLOUD_PLAN_API_KEY" },
+    "qwen-payg": { envVar: "DASHSCOPE_API_KEY", aliases: ["QWEN_API_KEY"] },
+    ollamacloud: { envVar: "OLLAMA_API_KEY" },
+    "opencode-zen": { envVar: "OPENCODE_API_KEY" },
+    "opencode-zen-go": { envVar: "OPENCODE_GO_API_KEY", aliases: ["OPENCODE_API_KEY"] },
+    vertex: { envVar: "VERTEX_API_KEY", aliases: ["VERTEX_PROJECT"] },
+    poe: { envVar: "POE_API_KEY" }
+  };
+});
+
 // src/providers/probe-runner.ts
 function pinProbeModelSpec(link) {
   if (link.provider === "native-anthropic")
@@ -69688,6 +70317,7 @@ async function parseArgs(args) {
           probeTimeoutMs = parsed * 1000;
         }
       }
+      ensureEndpointsRegistered();
       await probeModelRouting(expandedModels, hasJsonFlag, {
         live: !noProbeFlag,
         timeoutMs: probeTimeoutMs
@@ -71029,6 +71659,7 @@ var init_cli = __esm(() => {
   init_profile_config();
   init_api_key_map();
   init_api_key_provenance();
+  init_endpoint_registration();
   init_model_parser();
   init_probe_live();
   init_probe_runner();
@@ -76734,6 +77365,7 @@ function App({ requestLogin } = {}) {
   const selectedProviderIsLocal = !!(selectedProvider.isLocal || selectedProviderDef?.isLocal);
   const selectedLocalEnabled = selectedProviderIsLocal && isLocalProviderEnabled(selectedProvider.catalogName, config3);
   const refreshConfig = useCallback3(() => {
+    ensureEndpointsRegistered({ force: true });
     setConfig(loadConfig());
     setBufStats(getBufferStats());
     setOpTick((t) => t + 1);
@@ -78287,6 +78919,7 @@ var init_App = __esm(() => {
   init_op_source();
   init_profile_config();
   init_default_routing_rules();
+  init_endpoint_registration();
   init_local_liveness();
   init_onepassword_config();
   init_onepassword();
@@ -78326,6 +78959,7 @@ import { createCliRenderer as createCliRenderer2 } from "@opentui/core";
 import { createRoot as createRoot2 } from "@opentui/react";
 import { jsxDEV as jsxDEV17 } from "@opentui/react/jsx-dev-runtime";
 async function startConfigTui() {
+  ensureEndpointsRegistered();
   setStderrQuiet(true);
   const loginRequest = {
     slug: null
@@ -78385,6 +79019,7 @@ var init_tui = __esm(() => {
   init_codex_oauth();
   init_kimi_oauth();
   init_logger();
+  init_endpoint_registration();
   init_App();
   if (isDirectRun) {
     startConfigTui().catch((err) => {
@@ -82515,6 +83150,10 @@ async function runCli() {
   }
   try {
     const cliConfig = await traceSpan("startup:parse-args", () => parseArgs2(process.argv.slice(2)));
+    await traceSpan("startup:endpoint-registration", async () => {
+      const { ensureEndpointsRegistered: ensureEndpointsRegistered2 } = await Promise.resolve().then(() => (init_endpoint_registration(), exports_endpoint_registration));
+      ensureEndpointsRegistered2();
+    });
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "7.50.0",
+  "version": "7.51.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,10 +60,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "7.50.0",
-    "@claudish/magmux-darwin-x64": "7.50.0",
-    "@claudish/magmux-linux-arm64": "7.50.0",
-    "@claudish/magmux-linux-x64": "7.50.0"
+    "@claudish/magmux-darwin-arm64": "7.51.0",
+    "@claudish/magmux-darwin-x64": "7.51.0",
+    "@claudish/magmux-linux-arm64": "7.51.0",
+    "@claudish/magmux-linux-x64": "7.51.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",