jeo-code 0.9.16 → 0.10.0

package/src/ai/register-providers.ts

@@ -18,7 +18,9 @@ import { antigravityAdapter } from "./providers/antigravity";
 import { kimiAdapter } from "./providers/kimi";
 import { makeOpenAICompatibleAdapter } from "./providers/openai-compatible";
 import { makeAnthropicCompatibleAdapter } from "./providers/anthropic-compatible";
-import { OPENAI_COMPAT_PROVIDERS } from "./providers/openai-compatible-catalog";
+import { OPENAI_COMPAT_PROVIDERS, type OpenAICompatProviderDef } from "./providers/openai-compatible-catalog";
+import { customProviderDefs, onCustomProvidersChanged, type CustomProviderDef } from "./providers/custom-providers";
+import type { ProviderAdapter, ProviderName } from "./types";
 
 providerRegistry.register("anthropic", anthropicAdapter);
 providerRegistry.register("openai", openaiAdapter);
@@ -29,11 +31,58 @@ providerRegistry.register("lmstudio", lmstudioAdapter);
 providerRegistry.register("xai", xaiAdapter);
 providerRegistry.register("kimi", kimiAdapter);
 
+/** Build the thin factory adapter for one catalog row, selected by wire protocol. */
+function adapterFor(def: OpenAICompatProviderDef): ProviderAdapter {
+  return def.protocol === "anthropic"
+    ? makeAnthropicCompatibleAdapter({ name: def.name, baseUrl: def.baseUrl })
+    : makeOpenAICompatibleAdapter({ name: def.name, baseUrl: def.baseUrl, thinkingFormat: def.thinkingFormat });
+}
+
 // gjc-style data-driven providers: every catalog entry gets a thin factory adapter,
 // selected by wire protocol. Add a provider by adding ONE catalog row.
 for (const def of OPENAI_COMPAT_PROVIDERS) {
-  const adapter = def.protocol === "anthropic"
-    ? makeAnthropicCompatibleAdapter({ name: def.name, baseUrl: def.baseUrl })
-    : makeOpenAICompatibleAdapter({ name: def.name, baseUrl: def.baseUrl, thinkingFormat: def.thinkingFormat });
-  providerRegistry.register(def.name, adapter);
+  providerRegistry.register(def.name, adapterFor(def));
 }
+
+/** Every adapter registered above (built-ins + compiled-in catalog). Snapshotted BEFORE
+ *  any custom provider is registered so it stays a pure built-in set. */
+const BUILTIN_ADAPTER_NAMES: ReadonlySet<ProviderName> = new Set(providerRegistry.listProviders());
+
+/** Custom-provider adapters currently registered, so a removal can be un-registered
+ *  precisely (never touching a built-in that happens to share a name). */
+const registeredCustom = new Set<ProviderName>();
+
+/**
+ * (Re)register every user-defined provider from `config.customProviders`.
+ *
+ * Idempotent and diff-based: providers dropped from the config are unregistered so a
+ * removed endpoint stops resolving mid-session, and surviving ones are rebuilt so an
+ * edited base URL / protocol takes effect without restarting jeo.
+ */
+export function syncCustomProviderAdapters(defs: readonly CustomProviderDef[] = customProviderDefs()): void {
+  // A custom row whose id collides with a shipped provider is INERT: `openaiCompatDef`
+  // already prefers the built-in, so registering its adapter would silently reroute a
+  // built-in provider — and, worse, removing that row later would unregister the
+  // built-in adapter entirely. Drop collisions here so the two layers agree.
+  const usable = defs.filter(d => !BUILTIN_ADAPTER_NAMES.has(d.name));
+  const next = new Set<ProviderName>(usable.map(d => d.name));
+  for (const name of registeredCustom) {
+    if (!next.has(name)) {
+      providerRegistry.unregister(name);
+      registeredCustom.delete(name);
+    }
+  }
+  for (const def of usable) {
+    providerRegistry.register(def.name, adapterFor(def));
+    registeredCustom.add(def.name);
+  }
+}
+
+// Keep the adapter set in lockstep with the custom-provider store: any code path that
+// calls `setCustomProviders` (startup config load, `/provider add`, `/provider remove`)
+// re-registers adapters without having to remember to do it itself.
+onCustomProvidersChanged(defs => syncCustomProviderAdapters(defs));
+
+// Pick up providers registered BEFORE this module was first imported (config load
+// races module import order in short-lived commands like `jeo doctor`).
+syncCustomProviderAdapters();

package/src/ai/types.ts

@@ -1,6 +1,15 @@
 import type { Credential } from "../auth";
 
-export type ProviderName = "anthropic" | "openai" | "gemini" | "antigravity" | "ollama" | "lmstudio" | "xai" | "kimi" | "groq" | "deepseek" | "mistral" | "openrouter" | "together" | "cerebras" | "fireworks" | "nvidia" | "alibaba-coding-plan" | "huggingface" | "nanogpt" | "qwen-portal" | "synthetic" | "venice" | "zenmux" | "qianfan" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "minimax-code" | "minimax-code-cn" | "zai" | "minimax" | "tencent" | "deepinfra" | "litellm";
+/** Providers compiled into jeo (built-ins + the OpenAI/Anthropic-compatible catalog). */
+export type BuiltinProviderName = "anthropic" | "openai" | "gemini" | "antigravity" | "ollama" | "lmstudio" | "xai" | "kimi" | "groq" | "deepseek" | "mistral" | "openrouter" | "together" | "cerebras" | "fireworks" | "nvidia" | "alibaba-coding-plan" | "huggingface" | "nanogpt" | "qwen-portal" | "synthetic" | "venice" | "zenmux" | "qianfan" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "minimax-code" | "minimax-code-cn" | "zai" | "minimax" | "tencent" | "deepinfra" | "litellm";
+
+/**
+ * A provider id at runtime: a compiled-in name, OR a user-registered custom provider id
+ * (`config.customProviders`). The `string & {}` arm keeps editor autocomplete on the
+ * literal union while allowing the open set custom providers require — without it,
+ * every registry/lookup/record call site would need a cast to accept a user id.
+ */
+export type ProviderName = BuiltinProviderName | (string & {});
 
 
 /** An image attached to a (user) message — base64 payload + IANA media type. */

package/src/cli/runner.ts

@@ -32,6 +32,15 @@ export const COMMANDS: readonly CommandSpec[] = [
       return args => m.runAuthCommand(args);
     },
   },
+  {
+    name: "provider",
+    summary: "Register and probe OpenAI/Anthropic-compatible providers (custom endpoints + presets).",
+    usage: "provider [list|add|remove|presets|test] [--id <id>] [--base-url <url>] [--preset <name>]",
+    loader: async () => {
+      const m = await import("../commands/provider");
+      return args => m.runProviderCommand(args);
+    },
+  },
   {
     name: "export",
     summary: "Export a saved session transcript to Markdown (or --json).",

package/src/commands/auth.ts

@@ -5,7 +5,8 @@ import { type StoredOAuth } from "../agent/state";
 import { createInterface } from "node:readline/promises";
 import { readGlobalConfig } from "../agent/state";
 import { jeoEnv } from "../util/env";
-import { listProviderModels, CODEX_MODELS_URL } from "../ai/model-discovery";
+import { listProviderModels } from "../ai/model-discovery";
+
 import { writeModelCache } from "../ai/model-cache";
 import {
   OAUTH_FLOWS,
@@ -123,7 +124,7 @@ async function runAuthLogin(rest: string[]): Promise<void> {
     rl.close();
     await loginOAuth(chosen, manualToken.trim());
     console.log(`[SUCCESS] Stored manual OAuth bearer for ${chosen} (no auto-refresh).`);
-    if (chosen === "openai") await reportOpenAiCodexModels();
+    if (LIVE_MODEL_REPORT_PROVIDERS.has(chosen)) await reportLiveModels(chosen);
     return;
   }
 
@@ -131,7 +132,7 @@ async function runAuthLogin(rest: string[]): Promise<void> {
     const { email } = await interactiveOAuthLogin(chosen, rl);
     console.log(`\n[SUCCESS] OAuth login complete for ${chosen}${email ? ` (${email})` : ""}.`);
     console.log("Stored access + refresh tokens in ~/.jeo/config.json; jeo will auto-refresh on expiry.");
-    if (chosen === "openai") await reportOpenAiCodexModels();
+    if (LIVE_MODEL_REPORT_PROVIDERS.has(chosen)) await reportLiveModels(chosen);
   } catch (err) {
     console.log(`\n[FAILED] ${(err as Error).message}`);
     console.log("Tip: paste the redirect URL when prompted, or use 'jeo auth login <provider> --token <bearer>'.");
@@ -142,30 +143,35 @@ async function runAuthLogin(rest: string[]): Promise<void> {
 }
 
 /**
- * Best-effort, timeout-bounded live Codex model check run immediately after a
- * successful `jeo auth login openai`. Uses `preferOAuth` so the report reflects
- * the account that was JUST logged in — never the catalog fallback, and never
- * silently swapped to an unrelated pre-existing `providers.openai` API key.
- * A failure here is NEVER fatal: login has already succeeded and is not rolled
- * back by this check. Prints only model ids/count — no tokens/secrets.
+ * Best-effort, timeout-bounded live model check run immediately after a
+ * successful `jeo auth login <provider>` for the providers whose model set
+ * changes fastest (openai/Codex, anthropic, antigravity/Cloud Code Assist).
+ * Uses `preferOAuth` so the report reflects the account that was JUST logged
+ * in — never the catalog fallback, and never silently swapped to an
+ * unrelated pre-existing API key. A failure here is NEVER fatal: login has
+ * already succeeded and is not rolled back by this check. Prints only model
+ * ids/count — no tokens/secrets.
  */
-async function reportOpenAiCodexModels(): Promise<void> {
+const LIVE_MODEL_REPORT_PROVIDERS = new Set<AuthProvider>(["openai", "anthropic", "antigravity"]);
+
+async function reportLiveModels(provider: AuthProvider): Promise<void> {
   try {
-    const result = await listProviderModels("openai", { preferOAuth: true });
+    const result = await listProviderModels(provider, { preferOAuth: true });
     if (result.ok) {
       // Persist immediately: the very next `jeo` launch then knows this account's
       // real model set (including ids newer than the maintained static snapshot)
       // before it makes any network call.
       await writeModelCache([result]);
-      console.log(`Live Codex models (${result.models.length}): ${result.models.join(", ")}`);
+      console.log(`Live ${provider} models (${result.models.length}): ${result.models.join(", ")}`);
     } else {
-      console.log(`[WARN] Could not verify live Codex models from ${CODEX_MODELS_URL}: ${result.error ?? "unknown error"} (non-fatal — login succeeded).`);
+      console.log(`[WARN] Could not verify live ${provider} models: ${result.error ?? "unknown error"} (non-fatal — login succeeded).`);
     }
   } catch (err) {
-    console.log(`[WARN] Could not verify live Codex models from ${CODEX_MODELS_URL}: ${(err as Error).message} (non-fatal — login succeeded).`);
+    console.log(`[WARN] Could not verify live ${provider} models: ${(err as Error).message} (non-fatal — login succeeded).`);
   }
 }
 
+
 async function runAuthImport(rest: string[]): Promise<void> {
   const provider = rest.find(a => a !== "--import") as AuthProvider | undefined;
   if (!provider) {

package/src/commands/launch/provider-slash.ts

@@ -0,0 +1,413 @@
+/**
+ * `/provider add|list|remove|presets` — the custom-provider onboarding surface.
+ *
+ * Everything here is a PURE function over parsed tokens + a config snapshot, returning
+ * the lines to print and the config patch to persist. The slash handler in `launch.ts`
+ * only does the IO (read config, save patch, refresh the model cache), which is what
+ * makes this whole flow unit-testable without a TUI, a network, or a real `~/.jeo`.
+ *
+ * Backwards compatibility matters here: `/provider add --base-url <url>` (no `--id`)
+ * kept meaning "rebind the built-in openai provider" for two releases, and users have
+ * that in their notes/scripts. That spelling still does exactly what it did; the new
+ * named-provider behavior is opt-in via `--id` or `--preset`.
+ */
+import type { Config } from "../../agent/state";
+import {
+  assertValidProviderId,
+  normalizeCustomBaseUrl,
+  normalizeProviderId,
+  parseModelList,
+  parseProviderCompatibility,
+  redactSecret,
+  type CustomProviderConfig,
+  type ProviderCompatibility,
+} from "../../ai/providers/custom-providers";
+import {
+  expandProviderPreset,
+  findProviderPreset,
+  formatProviderPresetList,
+} from "../../ai/providers/provider-presets";
+import { isBuiltinCompatProvider } from "../../ai/providers/openai-compatible-catalog";
+
+/** Flags accepted by `/provider add`. */
+export interface ParsedProviderAdd {
+  id?: string;
+  baseUrl?: string;
+  compat?: string;
+  apiKeyEnv?: string;
+  apiKey?: string;
+  label?: string;
+  defaultModel?: string;
+  models: string[];
+  preset?: string;
+  force: boolean;
+  /** `/provider add clear` — legacy: drop `openaiBaseUrl`. */
+  clear: boolean;
+  /** Unrecognized `--flag`s, reported instead of silently ignored. */
+  unknown: string[];
+}
+
+/**
+ * Parse `/provider add` tokens. Bare positionals stay supported (`/provider add <url>
+ * <model>`) because the previous release accepted them; a positional that looks like a
+ * URL becomes `--base-url`, anything else becomes the default model.
+ */
+export function parseProviderAddArgs(tokens: readonly string[]): ParsedProviderAdd {
+  const out: ParsedProviderAdd = { models: [], force: false, clear: false, unknown: [] };
+  const rest = [...tokens];
+  if ((rest[0] ?? "").toLowerCase() === "clear") return { ...out, clear: true };
+  for (let i = 0; i < rest.length; i++) {
+    const t = rest[i]!;
+    const next = (): string | undefined => rest[++i];
+    switch (t) {
+      case "--id":
+      case "--name":
+        out.id = next();
+        break;
+      case "--base-url":
+      case "--url":
+        out.baseUrl = next();
+        break;
+      case "--compat":
+      case "--protocol":
+        out.compat = (next() ?? "").toLowerCase();
+        break;
+      case "--api-key-env":
+      case "--key-env":
+        out.apiKeyEnv = next();
+        break;
+      case "--api-key":
+      case "--key":
+        out.apiKey = next();
+        break;
+      case "--label":
+        out.label = next();
+        break;
+      case "--default-model":
+        out.defaultModel = next();
+        break;
+      case "--model":
+      case "--models":
+        {
+          const v = next();
+          if (v) out.models.push(v);
+        }
+        break;
+      case "--preset":
+        out.preset = next();
+        break;
+      case "--force":
+        out.force = true;
+        break;
+      default:
+        if (t.startsWith("--")) out.unknown.push(t);
+        else if (out.baseUrl === undefined && /^https?:\/\//i.test(t)) out.baseUrl = t;
+        else if (out.defaultModel === undefined) out.defaultModel = t;
+        break;
+    }
+  }
+  return out;
+}
+
+export interface ProviderAddResult {
+  /** Lines to print. */
+  lines: string[];
+  /** Provider id that was registered, when a custom provider was created. */
+  id?: string;
+  /** The entry to persist under `config.customProviders[id]`. */
+  config?: CustomProviderConfig;
+  /** Legacy path: set/clear `config.openaiBaseUrl` instead of adding a named provider. */
+  legacyOpenaiBaseUrl?: string | null;
+  /** Model id to make the active default, when the user asked for one. */
+  selectModel?: string;
+  /** True when nothing should be persisted (usage output / validation error). */
+  noop: boolean;
+}
+
+const USAGE: readonly string[] = [
+  "Usage:",
+  "  /provider add --id <id> --base-url <url> [--compat openai|anthropic]",
+  "                [--api-key-env <ENV>] [--api-key <key>] [--model a,b] [--label <name>] [--force]",
+  "  /provider add --preset <preset> [--base-url <url>] [--id <id>]      · list presets: /provider presets",
+  "  /provider list                      · show registered custom providers",
+  "  /provider remove <id>               · unregister a custom provider",
+  "  /provider add --base-url <url>      · legacy: rebind the built-in openai provider",
+  "  /provider add clear                 · legacy: clear that openai base URL",
+];
+
+export function providerAddUsage(): readonly string[] {
+  return USAGE;
+}
+
+/**
+ * Turn parsed flags + the current config into a decision. Never throws for user error —
+ * every invalid combination comes back as printable `lines` with `noop: true`, because
+ * this runs inside the REPL loop where an exception would kill the session.
+ */
+export function planProviderAdd(parsed: ParsedProviderAdd, config: Pick<Config, "customProviders" | "openaiBaseUrl">): ProviderAddResult {
+  const existing = config.customProviders ?? {};
+
+  if (parsed.unknown.length) {
+    return { lines: [`Unknown flag(s): ${parsed.unknown.join(", ")}`, ...USAGE], noop: true };
+  }
+
+  // ---- legacy: `/provider add clear` -------------------------------------
+  if (parsed.clear) {
+    return {
+      lines: ["OpenAI-compatible base URL cleared — saved to ~/.jeo/config.json.", "(custom providers are unaffected — remove one with /provider remove <id>)"],
+      legacyOpenaiBaseUrl: null,
+      noop: false,
+    };
+  }
+
+  // ---- preset path -------------------------------------------------------
+  if (parsed.preset) {
+    let expanded;
+    try {
+      expanded = expandProviderPreset({
+        preset: parsed.preset,
+        id: parsed.id,
+        baseUrl: parsed.baseUrl,
+        apiKeyEnv: parsed.apiKeyEnv,
+        apiKey: parsed.apiKey,
+        models: parsed.models.length ? parseModelList(parsed.models) : undefined,
+      });
+    } catch (err) {
+      return { lines: [(err as Error).message], noop: true };
+    }
+    const collision = checkCollision(expanded.id, existing, parsed.force);
+    if (collision) return { lines: collision, noop: true };
+    const cfg: CustomProviderConfig = {
+      ...expanded.config,
+      label: parsed.label?.trim() || expanded.config.label,
+      defaultModel: parsed.defaultModel?.trim() || expanded.config.defaultModel,
+    };
+    return {
+      lines: describeRegistration(expanded.id, cfg, `preset ${expanded.preset.id}`),
+      id: expanded.id,
+      config: cfg,
+      selectModel: selectableModel(expanded.id, cfg),
+      noop: false,
+    };
+  }
+
+  // ---- named custom provider --------------------------------------------
+  if (parsed.id) {
+    let id: string;
+    try {
+      id = assertValidProviderId(parsed.id);
+    } catch (err) {
+      return { lines: [(err as Error).message], noop: true };
+    }
+    if (isBuiltinCompatProvider(id)) {
+      return {
+        lines: [
+          `'${id}' is already a built-in provider — it does not need registering.`,
+          `Set its key with ${id.toUpperCase().replace(/[.\-]/g, "_")}_API_KEY, or pick a different --id.`,
+        ],
+        noop: true,
+      };
+    }
+    if (!parsed.baseUrl) {
+      return { lines: [`--base-url is required when adding provider '${id}'.`, ...USAGE], noop: true };
+    }
+    let baseUrl: string;
+    try {
+      baseUrl = normalizeCustomBaseUrl(parsed.baseUrl);
+    } catch (err) {
+      return { lines: [(err as Error).message], noop: true };
+    }
+    let protocol: ProviderCompatibility = "openai";
+    if (parsed.compat) {
+      try {
+        protocol = parseProviderCompatibility(parsed.compat);
+      } catch (err) {
+        return { lines: [(err as Error).message], noop: true };
+      }
+    }
+    const collision = checkCollision(id, existing, parsed.force);
+    if (collision) return { lines: collision, noop: true };
+    const models = parseModelList(parsed.models);
+    const cfg: CustomProviderConfig = {
+      label: parsed.label?.trim() || undefined,
+      baseUrl,
+      protocol,
+      apiKeyEnv: parsed.apiKeyEnv?.trim() || undefined,
+      apiKey: parsed.apiKey?.trim() || undefined,
+      models: models.length ? models : undefined,
+      defaultModel: parsed.defaultModel?.trim() || models[0],
+    };
+    return {
+      lines: describeRegistration(id, cfg, "custom"),
+      id,
+      config: cfg,
+      selectModel: selectableModel(id, cfg),
+      noop: false,
+    };
+  }
+
+  // ---- legacy: `/provider add --base-url <url>` (no id) -------------------
+  if (parsed.baseUrl) {
+    if (parsed.compat && parsed.compat !== "openai") {
+      return {
+        lines: [
+          `--compat ${parsed.compat} needs a named provider: add --id <id> so it gets its own routing prefix.`,
+          ...USAGE,
+        ],
+        noop: true,
+      };
+    }
+    let url: string;
+    try {
+      url = normalizeCustomBaseUrl(parsed.baseUrl);
+    } catch (err) {
+      return { lines: [(err as Error).message], noop: true };
+    }
+    const lines = [
+      `OpenAI-compatible endpoint set: ${url} — saved to ~/.jeo/config.json.`,
+      `Tip: '/provider add --id <name> --base-url ${url}' registers it as its own provider (own prefix + models) instead of rebinding openai/.`,
+    ];
+    return {
+      lines,
+      legacyOpenaiBaseUrl: url,
+      selectModel: parsed.defaultModel ? qualify("openai", parsed.defaultModel) : undefined,
+      noop: false,
+    };
+  }
+
+  // ---- bare `/provider add` ---------------------------------------------
+  const current = config.openaiBaseUrl;
+  return {
+    lines: [
+      current ? `OpenAI-compatible base URL: ${current}` : "No OpenAI-compatible base URL set.",
+      ...USAGE,
+    ],
+    noop: true,
+  };
+}
+
+function checkCollision(id: string, existing: Record<string, CustomProviderConfig>, force: boolean): string[] | undefined {
+  if (!existing[id] || force) return undefined;
+  return [
+    `Provider '${id}' already exists (${existing[id]!.baseUrl}).`,
+    // Surface-neutral wording: this text is printed by BOTH `/provider` (REPL) and
+    // `jeo provider` (shell), so it must not name a prefix that is wrong in one of them.
+    `Re-run with --force to overwrite it, or remove it first: provider remove ${id}`,
+  ];
+}
+
+function qualify(id: string, model: string): string {
+  const bare = model.startsWith(`${id}/`) ? model.slice(id.length + 1) : model;
+  return `${id}/${bare}`;
+}
+
+function selectableModel(id: string, cfg: CustomProviderConfig): string | undefined {
+  const bare = cfg.defaultModel ?? cfg.models?.[0];
+  return bare ? qualify(id, bare) : undefined;
+}
+
+function describeRegistration(id: string, cfg: CustomProviderConfig, origin: string): string[] {
+  const lines = [
+    `Registered provider '${id}' (${origin}) — saved to ~/.jeo/config.json.`,
+    `  endpoint : ${cfg.baseUrl}`,
+    `  protocol : ${cfg.protocol ?? "openai"}`,
+  ];
+  if (cfg.apiKey) lines.push(`  key      : ${redactSecret(cfg.apiKey)} (stored in config)`);
+  lines.push(`  key env  : ${cfg.apiKeyEnv ?? `${id.replace(/[.\-]/g, "_").toUpperCase()}_API_KEY`}`);
+  if (cfg.models?.length) lines.push(`  models   : ${cfg.models.map(m => `${id}/${m}`).join(", ")}`);
+  lines.push(`Use it with: /model ${selectableModel(id, cfg) ?? `${id}/<model>`}   (or: jeo launch --model ${selectableModel(id, cfg) ?? `${id}/<model>`})`);
+  return lines;
+}
+
+// ---------------------------------------------------------------------------
+// list / remove / presets
+// ---------------------------------------------------------------------------
+
+export interface ProviderRemoveResult {
+  lines: string[];
+  /** Id to delete from `config.customProviders`; absent when nothing should change. */
+  removeId?: string;
+}
+
+export function planProviderRemove(
+  rawId: string | undefined,
+  config: Pick<Config, "customProviders">,
+): ProviderRemoveResult {
+  const existing = config.customProviders ?? {};
+  const ids = Object.keys(existing);
+  if (!rawId) {
+    return {
+      lines: ids.length
+        ? ["Usage: provider remove <id>", `Registered: ${ids.join(", ")}`]
+        : ["No custom providers registered. Add one with 'provider add --id <id> --base-url <url>'."],
+    };
+  }
+  const id = normalizeProviderId(rawId);
+  if (!existing[id]) {
+    if (isBuiltinCompatProvider(id)) {
+      return { lines: [`'${id}' is a built-in provider and cannot be removed.`] };
+    }
+    return {
+      lines: [
+        `No custom provider '${id}'.`,
+        ids.length ? `Registered: ${ids.join(", ")}` : "Nothing registered yet.",
+      ],
+    };
+  }
+  return {
+    lines: [
+      `Removed custom provider '${id}' (${existing[id]!.baseUrl}) — saved to ~/.jeo/config.json.`,
+      `Models under '${id}/' no longer resolve; pick another with /model.`,
+    ],
+    removeId: id,
+  };
+}
+
+/** Rendered `/provider list` for the custom set (built-ins stay in the main panel). */
+export function formatCustomProviderList(
+  config: Pick<Config, "customProviders">,
+  env: NodeJS.ProcessEnv = process.env,
+): string[] {
+  const entries = Object.entries(config.customProviders ?? {});
+  if (!entries.length) {
+    return [
+      "No custom providers registered.",
+      "Add one:  provider add --id my-proxy --base-url https://api.example.com/v1",
+      "Or use a preset:  provider add --preset litellm --base-url http://localhost:4000/v1",
+    ];
+  }
+  const lines = [`Custom providers (${entries.length}):`];
+  for (const [id, cfg] of entries) {
+    const envVar = cfg.apiKeyEnv || `${id.replace(/[.\-]/g, "_").toUpperCase()}_API_KEY`;
+    const source = env[envVar] ? `env ${envVar}` : cfg.apiKey ? `config ${redactSecret(cfg.apiKey)}` : `MISSING (set ${envVar})`;
+    const models = cfg.models?.length ? ` · ${cfg.models.length} model(s)` : "";
+    const preset = cfg.preset ? ` · preset ${cfg.preset}` : "";
+    lines.push(`  ${id}  [${cfg.protocol ?? "openai"}]  ${cfg.baseUrl}`);
+    lines.push(`      key: ${source}${models}${preset}`);
+  }
+  return lines;
+}
+
+/** Rendered `/provider presets`. */
+export function formatPresetsCommand(): string[] {
+  return [
+    "Provider presets (use with: provider add --preset <id> [--base-url <url>]):",
+    ...formatProviderPresetList(),
+  ];
+}
+
+/** True when `token` names a known preset — used to accept `/provider add <preset>`. */
+export function looksLikePreset(token: string | undefined): boolean {
+  return !!token && !token.startsWith("--") && findProviderPreset(token) !== undefined;
+}
+
+/** Apply an add/remove decision to the `customProviders` map, returning a NEW map. */
+export function applyCustomProviderPatch(
+  existing: Record<string, CustomProviderConfig> | undefined,
+  change: { addId?: string; addConfig?: CustomProviderConfig; removeId?: string },
+): Record<string, CustomProviderConfig> | undefined {
+  const next: Record<string, CustomProviderConfig> = { ...(existing ?? {}) };
+  if (change.removeId) delete next[change.removeId];
+  if (change.addId && change.addConfig) next[change.addId] = change.addConfig;
+  return Object.keys(next).length ? next : undefined;
+}