claudish 7.49.0 → 7.51.0

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.49.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" });
+  }
+  for (const envVar of baseUrlEnvVars) {
+    const value = process.env[envVar];
+    if (value)
+      found.push({ envVar, value, source: "env" });
   }
-  return def.baseUrl;
+  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();
@@ -50087,12 +50683,132 @@ function writeStatusFile(sessionPath, manifest, status, opts) {
 var CHANNEL_LINE_BUDGET = 58;
 var init_team_stats = () => {};
 
+// src/team-stream-capture.ts
+function extractAssistantText(event) {
+  if (event.type !== "assistant")
+    return [];
+  const message = event.message;
+  const content = message?.content;
+  if (typeof content === "string") {
+    return content.length > 0 ? [content] : [];
+  }
+  if (!Array.isArray(content))
+    return [];
+  const out = [];
+  for (const raw2 of content) {
+    const block = raw2;
+    if (block?.type !== "text")
+      continue;
+    if (typeof block.text !== "string" || block.text.length === 0)
+      continue;
+    out.push(block.text);
+  }
+  return out;
+}
+function createAssistantTextCapture() {
+  let pending = "";
+  let emittedAny = false;
+  let endsWithNewline = false;
+  let dedupeTail = "";
+  let lastWasMessage = false;
+  const record4 = (text, kind) => {
+    emittedAny = true;
+    lastWasMessage = kind === "message";
+    endsWithNewline = text.endsWith(`
+`);
+    dedupeTail = (dedupeTail + text).slice(-DEDUPE_TAIL_LIMIT);
+  };
+  const messageSeparator = () => {
+    if (!emittedAny)
+      return "";
+    return endsWithNewline ? `
+` : `
+
+`;
+  };
+  const rawSeparator = () => {
+    if (!emittedAny || endsWithNewline)
+      return "";
+    return `
+`;
+  };
+  const consumeLine = (line, terminated) => {
+    if (line.trim().length === 0)
+      return "";
+    const passthrough = () => {
+      const out = `${rawSeparator()}${line}${terminated ? `
+` : ""}`;
+      record4(out, "raw");
+      return out;
+    };
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return passthrough();
+    }
+    if (typeof event.type !== "string" || !STREAM_JSON_EVENT_TYPES.has(event.type)) {
+      return passthrough();
+    }
+    const texts = extractAssistantText(event);
+    if (texts.length > 0) {
+      let out = "";
+      for (const text of texts) {
+        const piece = `${messageSeparator()}${text}`;
+        out += piece;
+        record4(piece, "message");
+      }
+      return out;
+    }
+    if (event.type === "result" && event.is_error === true) {
+      const result = typeof event.result === "string" ? event.result : "";
+      if (result.trim().length > 0 && !dedupeTail.includes(result)) {
+        const out = `${messageSeparator()}${result}`;
+        record4(out, "message");
+        return out;
+      }
+    }
+    return "";
+  };
+  return {
+    write(chunk) {
+      pending += chunk;
+      let out = "";
+      let newlineAt = pending.indexOf(`
+`);
+      while (newlineAt !== -1) {
+        const line = pending.slice(0, newlineAt);
+        pending = pending.slice(newlineAt + 1);
+        out += consumeLine(line, true);
+        newlineAt = pending.indexOf(`
+`);
+      }
+      return out;
+    },
+    end() {
+      let out = pending.length > 0 ? consumeLine(pending, false) : "";
+      pending = "";
+      if (emittedAny && !endsWithNewline && lastWasMessage) {
+        out += `
+`;
+        endsWithNewline = true;
+      }
+      return out;
+    }
+  };
+}
+var DEDUPE_TAIL_LIMIT = 4096, STREAM_JSON_EVENT_TYPES;
+var init_team_stream_capture = __esm(() => {
+  STREAM_JSON_EVENT_TYPES = new Set(["system", "assistant", "user", "result"]);
+});
+
 // src/team-orchestrator.ts
 var exports_team_orchestrator = {};
 __export(exports_team_orchestrator, {
   validateSessionPath: () => validateSessionPath,
   setupSession: () => setupSession,
   runModels: () => runModels,
+  resolveCaptureMode: () => resolveCaptureMode,
   parseJudgeVotes: () => parseJudgeVotes,
   judgeResponses: () => judgeResponses,
   getStatus: () => getStatus,
@@ -50100,6 +50816,7 @@ __export(exports_team_orchestrator, {
   classifyRunOutput: () => classifyRunOutput,
   buildJudgePrompt: () => buildJudgePrompt,
   aggregateVerdict: () => aggregateVerdict,
+  TEAM_CAPTURE_ENV_VAR: () => TEAM_CAPTURE_ENV_VAR,
   STDOUT_TAIL_LIMIT: () => STDOUT_TAIL_LIMIT,
   DEFAULT_MIN_OUTPUT_BYTES: () => DEFAULT_MIN_OUTPUT_BYTES
 });
@@ -50113,8 +50830,21 @@ import {
   writeFileSync as writeFileSync12
 } from "fs";
 import { join as join28, resolve as resolve3 } from "path";
+function resolveCaptureMode(explicit, env = process.env) {
+  if (explicit)
+    return explicit;
+  return env[TEAM_CAPTURE_ENV_VAR]?.trim().toLowerCase() === "print" ? "print" : "stream-json";
+}
 function classifyRunOutput(opts) {
-  const { outputSize, stdoutTail, stderr, minOutputBytes, requirePattern, fullOutput } = opts;
+  const {
+    outputSize,
+    stdoutTail,
+    stderr,
+    minOutputBytes,
+    requirePattern,
+    fullOutput,
+    captureMode = "print"
+  } = opts;
   const apiError = API_ERROR_RE.exec(stdoutTail);
   if (apiError) {
     return {
@@ -50151,9 +50881,10 @@ function classifyRunOutput(opts) {
       re = null;
     }
     if (re && !re.test(haystack)) {
+      const cause = captureMode === "stream-json" ? "Every assistant message this child produced was captured and concatenated, " + "so this is not the print-mode dropout: the model genuinely never emitted the " + "required shape. Re-prompt it, or relax the contract." : "This is the signature of a child that answered and then took one more turn: " + "`claude -p` prints only the FINAL assistant message, so a background task " + "completing (or any late notification) replaces the real answer with an " + "epilogue about it. The answer was generated, it just was not the last thing " + "said \u2014 re-run with the default stream-json capture to keep it.";
       return {
         reason: "shape_mismatch",
-        detail: `Child exited 0 with ${outputSize} B, but the response does not match the ` + `required pattern /${requirePattern}/. This is the signature of a child that ` + "answered and then took one more turn: `claude -p` prints only the FINAL " + "assistant message, so a background task completing (or any late notification) " + "replaces the real answer with an epilogue about it. Check the child's " + "transcript \u2014 the answer was generated, it just was not the last thing said."
+        detail: `Child exited 0 with ${outputSize} B, but the response does not match the ` + `required pattern /${requirePattern}/. ${cause}`
       };
     }
   }
@@ -50269,6 +51000,7 @@ async function runModels(sessionPath, opts = {}) {
   }
   const minOutputBytes = opts.minOutputBytes ?? DEFAULT_MIN_OUTPUT_BYTES;
   const requirePattern = opts.requirePattern;
+  const captureMode = resolveCaptureMode(opts.captureMode);
   mkdirSync12(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
   const runtimes = new Map;
@@ -50285,7 +51017,14 @@ async function runModels(sessionPath, opts = {}) {
     const outputPath = join28(sessionPath, `response-${anonId}.md`);
     const errorLogPath = join28(sessionPath, "errors", `${anonId}.log`);
     const spawnModel = spawnPlan.pinned.get(entry.model) ?? entry.model;
-    const args = ["--model", spawnModel, "-y", "--stdin", "--quiet", ...opts.claudeFlags ?? []];
+    const args = [
+      "--model",
+      spawnModel,
+      "-y",
+      "--stdin",
+      ...captureMode === "stream-json" ? ["--verbose", "--quiet", "--output-format", "stream-json"] : ["--quiet"],
+      ...opts.claudeFlags ?? []
+    ];
     updateModelStatus(anonId, {
       state: "RUNNING",
       startedAt: new Date().toISOString()
@@ -50301,12 +51040,36 @@ async function runModels(sessionPath, opts = {}) {
     });
     let byteCount = 0;
     let stdoutTail = "";
-    proc.stdout?.on("data", (chunk) => {
-      byteCount += chunk.length;
-      stdoutTail = (stdoutTail + chunk.toString()).slice(-STDOUT_TAIL_LIMIT);
-    });
     const outputStream = createWriteStream2(outputPath);
-    proc.stdout?.pipe(outputStream);
+    let flushPartial = () => {};
+    if (captureMode === "print") {
+      proc.stdout?.on("data", (chunk) => {
+        byteCount += chunk.length;
+        stdoutTail = (stdoutTail + chunk.toString()).slice(-STDOUT_TAIL_LIMIT);
+      });
+      proc.stdout?.pipe(outputStream);
+    } else {
+      const capture = createAssistantTextCapture();
+      const absorb = (text) => {
+        if (text.length === 0)
+          return;
+        byteCount += Buffer.byteLength(text);
+        stdoutTail = (stdoutTail + text).slice(-STDOUT_TAIL_LIMIT);
+        outputStream.write(text);
+      };
+      proc.stdout?.on("data", (chunk) => absorb(capture.write(chunk.toString())));
+      flushPartial = () => absorb(capture.end());
+      let captureFinalized = false;
+      const finalizeCapture = () => {
+        if (captureFinalized)
+          return;
+        captureFinalized = true;
+        absorb(capture.end());
+        outputStream.end();
+      };
+      proc.stdout?.on("end", finalizeCapture);
+      proc.stdout?.on("close", finalizeCapture);
+    }
     let stderr = "";
     proc.stderr?.on("data", (chunk) => {
       stderr += chunk.toString();
@@ -50317,7 +51080,8 @@ async function runModels(sessionPath, opts = {}) {
       errorLogPath,
       getStderr: () => stderr,
       getStdoutTail: () => stdoutTail,
-      getByteCount: () => byteCount
+      getByteCount: () => byteCount,
+      flushPartial: () => flushPartial()
     });
     proc.stdin?.write(inputContent);
     proc.stdin?.end();
@@ -50347,7 +51111,8 @@ async function runModels(sessionPath, opts = {}) {
           stderr,
           minOutputBytes,
           requirePattern,
-          fullOutput
+          fullOutput,
+          captureMode
         });
         const failed = crashed || degraded !== null;
         const state = crashed ? "FAILED" : degraded ? "EMPTY" : "COMPLETED";
@@ -50444,10 +51209,11 @@ async function runModels(sessionPath, opts = {}) {
             if (!proc.killed)
               proc.kill("SIGTERM");
             const rt = runtimes.get(id);
+            rt?.flushPartial();
             const stderr = rt?.getStderr() ?? "";
             const stdoutTail = rt?.getStdoutTail() ?? "";
             const bytes2 = rt?.getByteCount() ?? 0;
-            const detail = `Killed by the orchestrator after ${timeoutMs / 1000}s with ${bytes2} B of stdout. ` + "In --quiet print mode the child emits its answer only at the end, so 0 B means " + `"did not finish", not "produced nothing".`;
+            const detail = `Killed by the orchestrator after ${timeoutMs / 1000}s with ${bytes2} B of stdout. ` + "That figure counts the ANSWER, not the wire format, so 0 B means the child had " + `not produced an assistant message yet \u2014 "did not finish", not "produced nothing".`;
             if (rt)
               persistErrorLog(rt.errorLogPath, `TIMEOUT: ${detail}`, stderr, stdoutTail);
             updateModelStatus(id, {
@@ -50659,11 +51425,12 @@ function formatVerdict(verdict, sessionPath) {
   }
   return output;
 }
-var STDOUT_TAIL_LIMIT = 4000, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, SENTINEL_MODELS;
+var TEAM_CAPTURE_ENV_VAR = "CLAUDISH_TEAM_CAPTURE", STDOUT_TAIL_LIMIT = 4000, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, SENTINEL_MODELS;
 var init_team_orchestrator = __esm(() => {
   init_prehydrate();
   init_redact();
   init_team_stats();
+  init_team_stream_capture();
   API_ERROR_RE = /\[API Error:\s*([^\]]{0,300})\]/i;
   BG_CEILING_RE = /Background tasks still running after (\d+)s; terminating/i;
   SENTINEL_MODELS = new Set([
@@ -51189,7 +51956,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
         timeout: { type: "number", description: "Per-model timeout in seconds (default: 300)" },
         require_pattern: {
           type: "string",
-          description: "Regex the response MUST match, or the slot is reported FAILED (state EMPTY, " + "reason 'shape_mismatch') instead of succeeded. Strongly recommended whenever " + "your prompt mandates an output shape \u2014 e.g. '```vote' for a voting panel. " + "Exit code 0 is not a success oracle: a child that answers and then takes one " + "more turn (a background Task finishing, a late notification) has its real " + "answer replaced by a short epilogue, because print mode emits only the FINAL " + "assistant message. That lands as a few hundred bytes of plausible prose with " + "exit 0 and no error, and is otherwise indistinguishable from success."
+          description: "Regex the response MUST match, or the slot is reported FAILED (state EMPTY, " + "reason 'shape_mismatch') instead of succeeded. Strongly recommended whenever " + "your prompt mandates an output shape \u2014 e.g. '```vote' for a voting panel. " + "Exit code 0 is not a success oracle: it is 0 on API errors and on a child " + "that simply never followed the format. Answers are no longer LOST to print " + "mode (every assistant message is captured), so a mismatch now means the model " + "did not produce the shape, not that the shape was discarded."
         },
         min_output_bytes: {
           type: "number",
@@ -51771,7 +52538,7 @@ var init_mcp_server = __esm(() => {
     api_error: "retry once, or route via a different provider (or@<model>)",
     background_task_ceiling: "set CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=0 for children, or forbid background work in the prompt",
     empty_output: "retry once; if it repeats, drop the model",
-    shape_mismatch: "the answer was generated but not captured \u2014 print mode keeps only the FINAL " + "assistant message, so a late background task or notification overwrote it. " + "Retry, and forbid background work in the prompt; do NOT count this slot as a vote"
+    shape_mismatch: "the response does not carry the shape you required. Every assistant message the " + "child emitted was captured, so nothing was lost in transit \u2014 the model did not " + "produce it. Re-prompt with the required format restated; do NOT count this slot " + "as a vote"
   };
   sanitize = sanitizeForReport;
   EVENT_TO_TASK_STATUS = new Map([
@@ -51863,6 +52630,7 @@ async function serveCommand(args) {
     console.error("[claudish serve] --models <path> is required");
     process.exit(1);
   }
+  ensureEndpointsRegistered();
   let slotMap;
   let slotIds;
   try {
@@ -51883,6 +52651,7 @@ async function serveCommand(args) {
   await new Promise(() => {});
 }
 var init_serve_command = __esm(() => {
+  init_endpoint_registration();
   init_proxy_server();
 });
 
@@ -65179,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();
@@ -65694,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();
@@ -66454,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();
@@ -66464,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",
@@ -66492,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" },
@@ -69198,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")
@@ -69517,6 +70317,7 @@ async function parseArgs(args) {
           probeTimeoutMs = parsed * 1000;
         }
       }
+      ensureEndpointsRegistered();
       await probeModelRouting(expandedModels, hasJsonFlag, {
         live: !noProbeFlag,
         timeoutMs: probeTimeoutMs
@@ -70858,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();
@@ -76563,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);
@@ -78116,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();
@@ -78155,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
@@ -78214,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) => {
@@ -82344,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) {