jeo-code 0.9.17 → 0.10.0

package/src/commands/launch.ts

@@ -67,6 +67,16 @@ import { isRateLimitError, isUsageLimitError, isConnectionError } from "../util/
 
 import { listAliases } from "../ai/model-registry";
 import { openaiCompatDef, SUBSCRIPTION_PROVIDER_NAMES } from "../ai/providers/openai-compatible-catalog";
+import {
+  applyCustomProviderPatch,
+  formatCustomProviderList,
+  formatPresetsCommand,
+  looksLikePreset,
+  parseProviderAddArgs,
+  planProviderAdd,
+  planProviderRemove,
+  providerAddUsage,
+} from "./launch/provider-slash";
 
 import { allSubagentRoles, getSubagentRole, resolveSubagentModel, resolveSubagentMaxSteps, resolveSubagentThinking, parseMaxSteps, withSubagentSetting, clearSubagentSetting, applyTargetChoices } from "../agent/subagents";
 import { SelectList, renderSelectList, type SelectItem } from "../tui/components/select-list";
@@ -4640,8 +4650,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           "  OAuth / subscription : /provider login [anthropic|openai|gemini|antigravity|<subscription>]   (alias: /login)",
           "                         subscriptions (token): alibaba-coding-plan, qwen-portal, xiaomi-token-plan-*, minimax-code*",
           "  API key (cloud)      : /provider key [provider] [key]   (groq, deepseek, mistral, openrouter, …)",
-          "  API-compatible       : /provider add --base-url <url> [--model <model>] [--compat openai]   (reads OPENAI_API_KEY)",
-          "                         show current / clear: /provider add   ·   /provider add clear",
+          "  API-compatible       : /provider add --id <id> --base-url <url> [--compat openai|anthropic] [--model a,b]",
+          "                         presets: /provider add --preset <id> [--base-url <url>]   ·   list: /provider presets",
+          "                         manage: /provider list   ·   /provider remove <id>",
+          "                         legacy (rebinds openai/): /provider add --base-url <url>   ·   clear: /provider add clear",
           "  Logout               : /logout <provider>",
           "  Headless OAuth        : paste the redirect URL or code when the login prompt asks.",
           "Switch the active model or provider with /model.",
@@ -4656,8 +4668,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           else if (action === "api-key") name = "key";
           else if (action === "api-add") {
             console.log("Add an API-compatible endpoint:");
-            console.log("  /provider add --base-url <url> [--model <model>] [--compat openai]");
-            console.log("  reads OPENAI_API_KEY · show current / clear: /provider add   ·   /provider add clear");
+            for (const line of providerAddUsage()) console.log(line);
             continue;
           }
           // action === undefined (cancelled) → fall through to the readiness panel.
@@ -4810,56 +4821,63 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           }
           continue;
         }
-        // `/provider add --base-url <url> [--model <m>] [--compat openai]` → register an
-        // OpenAI-compatible endpoint (sets openaiBaseUrl). gjc flag style; bare positional
-        // URL/model still accepted for leniency. `/provider add clear` removes it.
-        if (name === "add") {
-          const rest = tokens.slice(1);
-          if ((rest[0] ?? "").toLowerCase() === "clear") {
-            await saveConfigPatch(() => ({ openaiBaseUrl: undefined }));
+        // `/provider presets` → the preset catalog (fixed + parameterized gateways).
+        if (name === "presets" || name === "preset") {
+          logLines(formatPresetsCommand());
+          continue;
+        }
+        // `/provider list` → registered custom providers (built-ins stay in the panel).
+        if (name === "list" || name === "ls") {
+          logLines(formatCustomProviderList(await readGlobalConfig()));
+          continue;
+        }
+        // `/provider remove <id>` → unregister a custom provider.
+        if (name === "remove" || name === "rm" || name === "delete") {
+          const decision = planProviderRemove(tokens[1], await readGlobalConfig());
+          logLines(decision.lines);
+          if (decision.removeId) {
+            await saveConfigPatch(raw => ({
+              customProviders: applyCustomProviderPatch(raw.customProviders, { removeId: decision.removeId }),
+            }));
+            // Re-read so `withEnvOverlay` republishes the surviving set into the runtime
+            // registry (the listener in register-providers unregisters the dropped adapter).
+            await readGlobalConfig();
             await refreshLiveModelsCache();
-            console.log("OpenAI-compatible base URL cleared — saved to ~/.jeo/config.json.");
-            continue;
           }
-          let baseUrl: string | undefined;
-          let modelArg: string | undefined;
-          let compat: string | undefined;
-          for (let i = 0; i < rest.length; i++) {
-            const t = rest[i]!;
-            if (t === "--base-url" || t === "--url") baseUrl = rest[++i];
-            else if (t === "--model") modelArg = rest[++i];
-            else if (t === "--compat") compat = (rest[++i] ?? "").toLowerCase();
-            else if (t === "--api-key-env" || t === "--provider") { i++; /* gjc-only: jeo has no named-provider registry — ignored */ }
-            else if (!t.startsWith("--") && baseUrl === undefined) baseUrl = t; // positional url
-            else if (!t.startsWith("--") && modelArg === undefined) modelArg = t; // positional model
-          }
-          if (compat && compat !== "openai") {
-            console.log(`Only --compat openai is supported (got '${compat}') — jeo registers a single OpenAI-compatible endpoint.`);
-            continue;
-          }
-          if (!baseUrl) {
-            const cur = (await readGlobalConfig()).openaiBaseUrl;
-            console.log(cur ? `OpenAI-compatible base URL: ${cur}` : "No OpenAI-compatible base URL set.");
-            console.log("Set one with: /provider add --base-url <url> [--model <model>]   ·   clear with: /provider add clear");
-            continue;
+          continue;
+        }
+        // `/provider add …` → register a NAMED custom provider (--id / --preset), or, in the
+        // legacy no-id spelling, rebind the built-in openai endpoint. All parsing/validation
+        // lives in provider-slash.ts so it is unit-testable without a TUI.
+        if (name === "add") {
+          const parsedAdd = parseProviderAddArgs(tokens.slice(1));
+          // `/provider add litellm --base-url …` — a bare preset name is accepted as --preset.
+          if (!parsedAdd.preset && looksLikePreset(tokens[1])) parsedAdd.preset = tokens[1];
+          const cfgNow = await readGlobalConfig();
+          const plan = planProviderAdd(parsedAdd, cfgNow);
+          logLines(plan.lines);
+          if (plan.noop) continue;
+          if (plan.legacyOpenaiBaseUrl !== undefined) {
+            const url = plan.legacyOpenaiBaseUrl;
+            await saveConfigPatch(() => ({ openaiBaseUrl: url ?? undefined }));
           }
-          const url = normalizeBaseUrl(baseUrl, "");
-          if (!url) {
-            console.log("Provide a base URL, e.g. /provider add --base-url http://localhost:1234/v1");
-            continue;
+          if (plan.id && plan.config) {
+            await saveConfigPatch(raw => ({
+              customProviders: applyCustomProviderPatch(raw.customProviders, { addId: plan.id, addConfig: plan.config }),
+            }));
+            // Republish into the runtime registry before discovery runs, so the very next
+            // /models probe already targets the new endpoint.
+            await readGlobalConfig();
           }
-          await saveConfigPatch(() => ({ openaiBaseUrl: url }));
-          if (modelArg) {
-            const qualified = qualifyModelId(modelArg, "openai");
-            sessionModel = qualified;
-            await saveConfigPatch(raw => rememberModelPatch(raw, qualified));
+          if (plan.selectModel) {
+            sessionModel = plan.selectModel;
+            await saveConfigPatch(raw => rememberModelPatch(raw, plan.selectModel!));
             await persistSessionModel();
-            console.log(`OpenAI-compatible endpoint set: ${url} · default model ${qualified} — saved to ~/.jeo/config.json.`);
-          } else {
-            console.log(`OpenAI-compatible endpoint set: ${url} — saved to ~/.jeo/config.json.`);
+            console.log(`Active model → ${plan.selectModel}`);
           }
+          const probeProvider = plan.id ?? "openai";
           const live = await refreshLiveModelsCache();
-          const forProvider = live.filter(r => r.provider === "openai");
+          const forProvider = live.filter(r => r.provider === probeProvider);
           const pick = flattenModels(forProvider);
           if (pick.length) {
             lastPickIndex = pick;
@@ -4867,7 +4885,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             logLines(formatPickListWithCapabilities(pick, { cap: 12 }));
           } else {
             const failed = forProvider.find(r => !r.ok);
-            console.log(failed?.error ? `  could not list models: ${failed.error}` : "  no models discovered yet — the endpoint may need a key (set OPENAI_API_KEY).");
+            const envHint = plan.id
+              ? `set ${plan.config?.apiKeyEnv ?? `${plan.id.replace(/[.\-]/g, "_").toUpperCase()}_API_KEY`}`
+              : "set OPENAI_API_KEY";
+            console.log(failed?.error ? `  could not list models: ${failed.error}` : `  no models discovered yet — the endpoint may need a key (${envHint}).`);
           }
           continue;
         }

package/src/commands/provider.ts

@@ -0,0 +1,199 @@
+/**
+ * `jeo provider …` — manage providers from the shell, not just from inside the REPL.
+ *
+ * The slash command (`/provider add …`) already existed, but it is only reachable from
+ * an interactive session. Provisioning a machine, a CI runner, or a devcontainer means
+ * scripting it, so the same registry is exposed as a real subcommand with the SAME
+ * flags and the SAME planners (`provider-slash.ts`) — one implementation, two surfaces,
+ * so they can never drift.
+ *
+ * Beyond parity this adds `jeo provider test <id>`, a live endpoint probe. Registering a
+ * provider is cheap and silent; discovering at the first real inference call that the
+ * base URL was wrong (or the key env var is not exported in THIS shell) is not. `add`
+ * runs the probe automatically and reports the result without refusing the write — a
+ * user may legitimately register an endpoint before the key exists.
+ */
+import { readGlobalConfig, saveConfigPatch } from "../agent/state";
+import {
+  applyCustomProviderPatch,
+  formatCustomProviderList,
+  formatPresetsCommand,
+  looksLikePreset,
+  parseProviderAddArgs,
+  planProviderAdd,
+  planProviderRemove,
+  providerAddUsage,
+} from "./launch/provider-slash";
+import {
+  credentialSourceOf,
+  customProviderDef,
+  customProviderDefs,
+  normalizeProviderId,
+} from "../ai/providers/custom-providers";
+import { listProviderModels } from "../ai/model-discovery";
+import { describeProvider } from "../ai/provider-status";
+
+const USAGE = [
+  "Usage: jeo provider <command>",
+  "",
+  "  list                                   Show registered custom providers",
+  "  add --id <id> --base-url <url> [...]   Register an OpenAI/Anthropic-compatible provider",
+  "  add --preset <preset> [--base-url <url>]",
+  "  remove <id>                            Unregister a custom provider",
+  "  presets                                List the built-in provider presets",
+  "  test <id>                              Probe a provider's endpoint and credential",
+  "",
+  "Flags for add:",
+  "  --id <id>            Routing prefix + config key (e.g. my-proxy → my-proxy/<model>)",
+  "  --base-url <url>     API base URL (https://… or http://…)",
+  "  --compat <protocol>  openai (default) | anthropic",
+  "  --api-key-env <ENV>  Env var holding the key (default: <ID>_API_KEY)",
+  "  --api-key <key>      Literal key, stored in ~/.jeo/config.json (prefer --api-key-env)",
+  "  --model a,b          Known model ids for the offline pick-list",
+  "  --label <name>       Display name",
+  "  --force              Overwrite an existing provider with the same id",
+].join("\n");
+
+export async function runProviderCommand(args: string[]): Promise<void> {
+  const sub = (args[0] ?? "").toLowerCase();
+  switch (sub) {
+    case "":
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(USAGE);
+      return;
+    case "list":
+    case "ls":
+      return runList();
+    case "presets":
+    case "preset":
+      console.log(formatPresetsCommand().join("\n"));
+      return;
+    case "add":
+      return runAdd(args.slice(1));
+    case "remove":
+    case "rm":
+    case "delete":
+      return runRemove(args[1]);
+    case "test":
+    case "probe":
+    case "check":
+      return runTest(args[1]);
+    default:
+      console.log(`Unknown provider subcommand: ${sub}\n\n${USAGE}`);
+      process.exitCode = 1;
+  }
+}
+
+async function runList(): Promise<void> {
+  console.log(formatCustomProviderList(await readGlobalConfig()).join("\n"));
+}
+
+async function runAdd(rest: string[]): Promise<void> {
+  const parsed = parseProviderAddArgs(rest);
+  if (!parsed.preset && looksLikePreset(rest[0])) parsed.preset = rest[0];
+
+  const plan = planProviderAdd(parsed, await readGlobalConfig());
+  console.log(plan.lines.join("\n"));
+  if (plan.noop) {
+    // A usage dump is informational; a rejected registration is a scripting failure and
+    // must be visible to `set -e`. `--base-url`-less bare invocations print usage only.
+    if (rest.length > 0) process.exitCode = 1;
+    return;
+  }
+
+  if (plan.legacyOpenaiBaseUrl !== undefined) {
+    const url = plan.legacyOpenaiBaseUrl;
+    await saveConfigPatch(() => ({ openaiBaseUrl: url ?? undefined }));
+  }
+  if (plan.id && plan.config) {
+    await saveConfigPatch(raw => ({
+      customProviders: applyCustomProviderPatch(raw.customProviders, { addId: plan.id, addConfig: plan.config }),
+    }));
+    // Re-read so `withEnvOverlay` republishes the new provider into the runtime registry
+    // before the probe below resolves its credential.
+    await readGlobalConfig();
+    console.log("");
+    await probe(plan.id, { failOnError: false });
+  }
+}
+
+async function runRemove(rawId: string | undefined): Promise<void> {
+  const decision = planProviderRemove(rawId, await readGlobalConfig());
+  console.log(decision.lines.join("\n"));
+  if (!decision.removeId) {
+    if (rawId) process.exitCode = 1;
+    return;
+  }
+  await saveConfigPatch(raw => ({
+    customProviders: applyCustomProviderPatch(raw.customProviders, { removeId: decision.removeId }),
+  }));
+  await readGlobalConfig();
+}
+
+async function runTest(rawId: string | undefined): Promise<void> {
+  if (!rawId) {
+    const ids = customProviderDefs().map(d => d.name);
+    console.log(
+      ids.length
+        ? `Usage: jeo provider test <id>\nRegistered: ${ids.join(", ")}`
+        : "No custom providers registered. Add one with 'jeo provider add --id <id> --base-url <url>'.",
+    );
+    process.exitCode = 1;
+    return;
+  }
+  await probe(normalizeProviderId(rawId), { failOnError: true });
+}
+
+/**
+ * Probe one provider: report its credential source, then try to list models at its
+ * endpoint. Separating the two matters — "no key" and "wrong URL" need different fixes,
+ * and a single "failed" line sends users down the wrong path.
+ */
+async function probe(id: string, opts: { failOnError: boolean }): Promise<void> {
+  // A fresh config read republishes the custom set, so a provider added moments ago in
+  // this same process is resolvable here.
+  const cfg = await readGlobalConfig();
+  const def = customProviderDef(id);
+  if (!def) {
+    const status = await describeProvider(id, cfg);
+    if (!status.ready && status.kind === "none") {
+      console.log(`No provider '${id}'. Run 'jeo provider list' or 'jeo provider add --id ${id} --base-url <url>'.`);
+      if (opts.failOnError) process.exitCode = 1;
+      return;
+    }
+    console.log(`'${id}' is a built-in provider — check it with 'jeo doctor'.`);
+    if (opts.failOnError) process.exitCode = 1;
+    return;
+  }
+
+  const source = credentialSourceOf(def);
+  console.log(`Probing ${id} → ${def.baseUrl} (${def.protocol ?? "openai"})`);
+  if (source === "none") {
+    console.log(`  credential: MISSING — export ${def.apiKeyEnv}, or re-add with --api-key <key>.`);
+  } else {
+    console.log(`  credential: ${source === "env" ? `env ${def.apiKeyEnv}` : "stored in config"}`);
+  }
+
+  const result = await listProviderModels(id, { timeoutMs: 8000 });
+  if (result.ok) {
+    // Discovery already returns ids the router accepts; `qualify` only guards the case
+    // where an endpoint echoes bare ids so the printed command is copy-pasteable.
+    const qualify = (m: string) => (m.startsWith(`${id}/`) ? m : `${id}/${m}`);
+    const shown = result.models.slice(0, 8).map(qualify);
+    console.log(`  models    : ${result.models.length} discovered${result.fallback ? " (from the static catalog — the live list endpoint was unusable)" : ""}`);
+    if (shown.length) console.log(`              ${shown.join(", ")}${result.models.length > shown.length ? ", …" : ""}`);
+    const first = result.models[0];
+    console.log(`  status    : OK — use it with 'jeo launch --model ${first ? qualify(first) : `${id}/<model>`}'`);
+    return;
+  }
+
+  console.log(`  status    : FAILED — ${result.error ?? "no models returned"}`);
+  console.log(
+    source === "none"
+      ? `  next      : set ${def.apiKeyEnv} and re-run 'jeo provider test ${id}'.`
+      : `  next      : verify the base URL (a ${def.protocol === "anthropic" ? "/v1/models" : "/models"} route must exist under it) and that the key is valid for this endpoint.`,
+  );
+  if (opts.failOnError) process.exitCode = 1;
+}

package/src/tui/components/autocomplete.ts

@@ -15,7 +15,9 @@
  */
 import { SLASH_COMMANDS, SLASH_COMMAND_DESCRIPTIONS } from "./slash";
 import { catalogIds } from "../../ai/model-catalog-compat";
-import { PROVIDER_NAMES } from "../../ai/provider-status";
+import { PROVIDER_NAMES, allProviderNames } from "../../ai/provider-status";
+import { PROVIDER_PRESET_IDS } from "../../ai/providers/provider-presets";
+import { customProviderNames } from "../../ai/providers/custom-providers";
 import { SUBAGENT_ROLES } from "../../agent/subagents";
 import { skillNames } from "../../skills/catalog";
 import { listThemes } from "./themes";
@@ -35,6 +37,10 @@ export interface CompletionContext {
   skillNames?: string[];
   /** Live model ids for a given provider (for `/provider <p> <model>`). */
   modelsForProvider: (provider: string) => string[];
+  /** Preset ids offered after `/provider add --preset`. */
+  providerPresets: string[];
+  /** Ids of the user's registered custom providers (for `/provider remove <id>`). */
+  customProviders: string[];
   /** Sync path suggestions for free-text `@path` mentions (relative to cwd). */
   mentionPaths?: (prefix: string) => string[];
 }
@@ -66,9 +72,13 @@ export function staticCompletionContext(): Omit<CompletionContext, "liveModels"
   return {
     slashCommands: [...SLASH_COMMANDS],
     catalogModels: catalogIds(),
-    providers: [...PROVIDER_NAMES],
+    // Custom providers are runtime state, so list from `allProviderNames()` — a user's
+    // own endpoint must be completable the same as a shipped one.
+    providers: [...allProviderNames()],
     roleIds: SUBAGENT_ROLES.map(r => r.id),
     thinkingLevels: [...THINKING_LEVELS],
+    providerPresets: [...PROVIDER_PRESET_IDS],
+    customProviders: [...customProviderNames()],
   };
 }
 
@@ -271,13 +281,25 @@ export function complete(line: string, ctx: CompletionContext): CompletionResult
     case "/fast":
       return argIndex === 0 ? finish(["on", "off", "status"], "subcommand") : { completions: [], token, kind: "none" };
     case "/provider": {
-      // /provider is onboarding-only (gjc parity): login + add. Model/provider
-      // switching completes under /model, not here.
+      // /provider is onboarding-only (gjc parity): login, key, and the custom-provider
+      // registry (add/list/remove/presets). Model switching completes under /model.
       const cloud = ["anthropic", "openai", "gemini", "antigravity"];
-      if (argIndex === 0) return finish(["login", "add", "help"], "subcommand");
+      if (argIndex === 0) return finish(["login", "key", "add", "list", "remove", "presets", "help"], "subcommand");
       const sub = tokens[1]?.toLowerCase();
       if (sub === "login" || sub === "auth") return argIndex === 1 ? finish(cloud, "provider") : { completions: [], token, kind: "none" };
-      if (sub === "add") return finish(["--base-url", "--model", "--compat", "clear"], "subcommand");
+      // Removal only ever targets a CUSTOM provider, so completing built-ins here would
+      // just offer choices the command refuses.
+      if (sub === "remove" || sub === "rm" || sub === "delete") {
+        return argIndex === 1 ? finish([...ctx.customProviders], "provider") : { completions: [], token, kind: "none" };
+      }
+      if (sub === "add") {
+        // Right after `--preset`, offer preset ids; otherwise the flag set.
+        if (tokens[argIndex]?.toLowerCase() === "--preset") return finish([...ctx.providerPresets], "subcommand");
+        return finish(
+          ["--id", "--base-url", "--compat", "--api-key-env", "--api-key", "--model", "--label", "--preset", "--force", "clear"],
+          "subcommand",
+        );
+      }
       return { completions: [], token, kind: "none" };
     }
     case "/logout":

package/src/tui/components/model-picker.ts

@@ -7,7 +7,8 @@
 import { SelectList, renderSelectList, type SelectItem, type RenderSelectOptions } from "./select-list";
 import { catalogForProvider, type ModelCatalogEntry } from "../../ai/model-catalog-compat";
 import { companyLabel } from "../../ai/model-catalog";
-import { PROVIDER_NAMES, type ProviderStatus } from "../../ai/provider-status";
+import { PROVIDER_NAMES, allProviderNames, type ProviderStatus } from "../../ai/provider-status";
+import { authStateFor, sortRankedProviders } from "../../ai/provider-ranking";
 import type { ProviderName } from "../../ai/types";
 
 /** Human context-window size: 200000 → "200k", 1000000 → "1M", 0 → "". */
@@ -46,14 +47,23 @@ export function buildModelChoices(statuses: ProviderStatus[], opts: ModelPickerO
   const unicode = opts.unicode !== false;
   const includeUnready = opts.includeUnready !== false;
   const readyOf = new Map<ProviderName, boolean>(statuses.map(s => [s.name, s.ready]));
+  const statusOf = new Map<ProviderName, ProviderStatus>(statuses.map(s => [s.name, s]));
 
-  // Provider order: ready first, then the canonical order.
-  const providers = [...PROVIDER_NAMES].sort((a, b) => {
-    const ra = readyOf.get(a) ? 0 : 1;
-    const rb = readyOf.get(b) ? 0 : 1;
-    if (ra !== rb) return ra - rb;
-    return PROVIDER_NAMES.indexOf(a) - PROVIDER_NAMES.indexOf(b);
-  });
+  // Provider order comes from the SHARED ranking (usable → broken → famous → rest), not
+  // this component's own list-index sort. That old sort ranked by `PROVIDER_NAMES.indexOf`,
+  // which returns -1 for a user-registered custom provider — floating it above the
+  // provider the user is actually logged into.
+  const providers = sortRankedProviders(
+    [...allProviderNames()].map(name => {
+      const status = statusOf.get(name);
+      return {
+        id: name,
+        label: companyLabel(name),
+        authState: status ? authStateFor(status) : ("none" as const),
+        custom: status?.custom,
+      };
+    }),
+  ).map(p => p.id as ProviderName);
 
   const items: SelectItem<string>[] = [];
   for (const provider of providers) {