myapikey 0.11.1 → 0.12.1

package/README.md

@@ -124,7 +124,7 @@ myapikey model prioritize gpt-4o-mini openai-direct backup --format openai   # l
 myapikey model list        # see the routing table
 ```
 
-> `--format` selects the routing **slot**: `openai` (for `/v1/chat/completions`), `anthropic` (for `/v1/messages`), or `responses` (for `/v1/responses`). The `responses` slot only accepts backends you've marked **supportsResponses** — set that toggle in the web UI (the CLI doesn't expose it yet).
+> `--format` selects the routing **slot**: `openai` (for `/openai/v1/chat/completions`), `anthropic` (for `/anthropic/v1/messages`), or `responses` (for `/openai/v1/responses`). The `responses` slot only accepts backends you've marked **supportsResponses** — set that toggle in the web UI (the CLI doesn't expose it yet).
 
 ---
 
@@ -139,14 +139,14 @@ myapikey whoami      # prints base url + api key + ready-to-paste env lines
 For an **OpenAI-compatible** tool (covers `/chat/completions` *and* `/responses`):
 
 ```bash
-export OPENAI_BASE_URL=http://localhost:7800/v1
+export OPENAI_BASE_URL=http://localhost:7800/openai/v1
 export OPENAI_API_KEY=<gateway api key>
 ```
 
 For **Anthropic / Claude Code**:
 
 ```bash
-export ANTHROPIC_BASE_URL=http://localhost:7800
+export ANTHROPIC_BASE_URL=http://localhost:7800/anthropic
 export ANTHROPIC_API_KEY=<gateway api key>
 ```
 
@@ -158,6 +158,22 @@ Quick smoke test without any tool:
 myapikey call gpt-4o-mini "Say hello in one sentence."
 ```
 
+**Why two base URLs?** The gateway exposes two separate agent surfaces — `/openai/v1` and `/anthropic/v1` — each with its own `GET /models` (an OpenAI client discovers only openai-enabled models, an Anthropic client only anthropic-enabled ones). Each ecosystem's SDK appends its own paths, so the OpenAI SDK points at `…/openai/v1` (it appends `/chat/completions`, `/responses`, `/models`) and the Anthropic SDK / Claude Code points at `…/anthropic` (it appends `/v1/messages`, `/v1/models`).
+
+**Raw HTTP** (no SDK) — hit either surface directly with the gateway API key as a `Bearer` token:
+
+```bash
+# OpenAI family
+curl http://localhost:7800/openai/v1/chat/completions \
+  -H "Authorization: Bearer <gateway api key>" -H "Content-Type: application/json" \
+  -d '{"model":"<model>","messages":[{"role":"user","content":"hi"}]}'
+
+# Anthropic family
+curl http://localhost:7800/anthropic/v1/messages \
+  -H "Authorization: Bearer <gateway api key>" -H "Content-Type: application/json" \
+  -d '{"model":"<model>","max_tokens":16,"messages":[{"role":"user","content":"hi"}]}'
+```
+
 Whichever endpoint you point a tool at, the gateway forwards in that format and never translates — so make sure each model you call is backed by at least one source on the matching slot ([see below](#how-routing-works)).
 
 ---
@@ -166,7 +182,7 @@ Whichever endpoint you point a tool at, the gateway forwards in that format and
 
 The gateway is a **directional forwarder, not a translator**. Four rules explain everything:
 
-1. **The endpoint picks the slot.** `/v1/chat/completions` → the **openai** slot. `/v1/responses` → the **responses** slot. `/v1/messages` → the **anthropic** slot. Each is a distinct wire format, and the body is forwarded verbatim — nothing is converted.
+1. **The endpoint picks the slot.** `/openai/v1/chat/completions` → the **openai** slot. `/openai/v1/responses` → the **responses** slot. `/anthropic/v1/messages` → the **anthropic** slot. Each is a distinct wire format, and the body is forwarded verbatim — nothing is converted.
 
 2. **Each model has three independent slots.** For one model you can enable `openai`, `responses`, and `anthropic` separately, and each has its own ordered source chain. Enable a model only on the slots its backends actually speak.
 
@@ -235,12 +251,13 @@ It's the same admin API the CLI uses — configure either way.
 
 ## API surface
 
-**Agent-facing (`/v1`, API key — `Authorization: Bearer` or `x-api-key`):**
+**Agent-facing (two surfaces, one API key — `Authorization: Bearer` or `x-api-key`):**
 
-- `POST /v1/chat/completions` — OpenAI-format proxy
-- `POST /v1/responses` — OpenAI Responses API (only sources marked `supportsResponses`)
-- `POST /v1/messages` — Anthropic-format proxy
-- `GET /v1/models` — models enabled on the **openai** slot, OpenAI list shape (Anthropic-only models aren't listed here — call them via `/v1/messages`)
+- `POST /openai/v1/chat/completions` — OpenAI-format proxy
+- `POST /openai/v1/responses` — OpenAI Responses API (only sources marked `supportsResponses`)
+- `GET /openai/v1/models` — models enabled on the **openai** slot, OpenAI list shape
+- `POST /anthropic/v1/messages` — Anthropic-format proxy
+- `GET /anthropic/v1/models` — models enabled on the **anthropic** slot, OpenAI list shape
 - `GET /health` — public liveness check
 
 **Admin (`/admin`, account password — HTTP Basic):**
@@ -279,7 +296,7 @@ npm install
 npm run build:web      # build the Vue UI into packages/web/dist (one time, and after UI changes)
 npm start              # tsx ... serve  (gateway on :7800)
 npm run dev            # gateway, with watch reload
-npm run dev:web        # vite dev server (proxies /v1 and /admin to :7800)
+npm run dev:web        # vite dev server (proxies /openai, /anthropic, and /admin to :7800)
 npm run typecheck      # tsc (core) + vue-tsc (web)
 ```
 

package/README.zh-CN.md

@@ -124,7 +124,7 @@ myapikey model prioritize gpt-4o-mini openai-direct backup --format openai   #
 myapikey model list        # 查看路由表
 ```
 
-> `--format` 选择路由**槽位**:`openai`(对应 `/v1/chat/completions`)、`anthropic`(对应 `/v1/messages`)、或 `responses`(对应 `/v1/responses`)。`responses` 槽位只接受你标记了 **supportsResponses** 的后端——在网页界面里勾选那个开关(CLI 暂未暴露它)。
+> `--format` 选择路由**槽位**:`openai`(对应 `/openai/v1/chat/completions`)、`anthropic`(对应 `/anthropic/v1/messages`)、或 `responses`(对应 `/openai/v1/responses`)。`responses` 槽位只接受你标记了 **supportsResponses** 的后端——在网页界面里勾选那个开关(CLI 暂未暴露它)。
 
 ---
 
@@ -139,14 +139,14 @@ myapikey whoami      # 打印 base url + api key + 可直接粘贴的环境变
 **兼容 OpenAI** 的工具(覆盖 `/chat/completions` *和* `/responses`):
 
 ```bash
-export OPENAI_BASE_URL=http://localhost:7800/v1
+export OPENAI_BASE_URL=http://localhost:7800/openai/v1
 export OPENAI_API_KEY=<网关 API Key>
 ```
 
 **Anthropic / Claude Code**:
 
 ```bash
-export ANTHROPIC_BASE_URL=http://localhost:7800
+export ANTHROPIC_BASE_URL=http://localhost:7800/anthropic
 export ANTHROPIC_API_KEY=<网关 API Key>
 ```
 
@@ -158,6 +158,22 @@ export ANTHROPIC_API_KEY=<网关 API Key>
 myapikey call gpt-4o-mini "用一句话打个招呼。"
 ```
 
+**为什么有两个 Base URL?** 网关暴露了两个互相独立的 agent 面——`/openai/v1` 和 `/anthropic/v1`,各自带自己的 `GET /models`(OpenAI 客户端只发现 openai 槽位启用的模型,Anthropic 客户端只发现 anthropic 槽位启用的模型)。两套生态的 SDK 各自拼接自己的路径:OpenAI SDK 指向 `…/openai/v1`(它自己补 `/chat/completions`、`/responses`、`/models`),Anthropic SDK / Claude Code 指向 `…/anthropic`(它自己补 `/v1/messages`、`/v1/models`)。
+
+**直接用 HTTP**(不走 SDK)——带上网关 API Key(`Bearer`)直接打这两个面之一:
+
+```bash
+# OpenAI 系
+curl http://localhost:7800/openai/v1/chat/completions \
+  -H "Authorization: Bearer <网关 API Key>" -H "Content-Type: application/json" \
+  -d '{"model":"<模型名>","messages":[{"role":"user","content":"hi"}]}'
+
+# Anthropic 系
+curl http://localhost:7800/anthropic/v1/messages \
+  -H "Authorization: Bearer <网关 API Key>" -H "Content-Type: application/json" \
+  -d '{"model":"<模型名>","max_tokens":16,"messages":[{"role":"user","content":"hi"}]}'
+```
+
 不管你把工具指向哪个端点,网关都按那个格式转发、绝不翻译——所以确保你调用的每个模型,在对应的槽位上至少有一个来源在服务它([见下文](#路由是怎么工作的))。
 
 ---
@@ -166,7 +182,7 @@ myapikey call gpt-4o-mini "用一句话打个招呼。"
 
 网关是一个**定向转发器,而非翻译器**。四条规则解释一切:
 
-1. **端点决定槽位。** `/v1/chat/completions` → **openai** 槽位;`/v1/responses` → **responses** 槽位;`/v1/messages` → **anthropic** 槽位。每种都是独立的线材格式,请求体原样转发,不做任何转换。
+1. **端点决定槽位。** `/openai/v1/chat/completions` → **openai** 槽位;`/openai/v1/responses` → **responses** 槽位;`/anthropic/v1/messages` → **anthropic** 槽位。每种都是独立的线材格式,请求体原样转发,不做任何转换。
 
 2. **每个模型有三个互相独立的槽位。** 对同一个模型,你可以分别启用 `openai`、`responses`、`anthropic`,每个槽位都有自己的、按优先级排序的来源链。只在它的后端真正支持的槽位上启用即可。
 
@@ -235,12 +251,13 @@ myapikey call gpt-4o-mini "用一句话打个招呼。"
 
 ## 接口一览
 
-**面向 agent(`/v1`,API Key —— `Authorization: Bearer` 或 `x-api-key`):**
+**面向 agent(两个面,共用一把 API Key —— `Authorization: Bearer` 或 `x-api-key`):**
 
-- `POST /v1/chat/completions` — OpenAI 格式代理
-- `POST /v1/responses` — OpenAI Responses API(仅限标记了 `supportsResponses` 的来源)
-- `POST /v1/messages` — Anthropic 格式代理
-- `GET /v1/models` — 启用在 **openai** 槽位的模型,OpenAI 列表格式(纯 Anthropic 模型不会出现在这里——请通过 `/v1/messages` 调用)
+- `POST /openai/v1/chat/completions` — OpenAI 格式代理
+- `POST /openai/v1/responses` — OpenAI Responses API(仅限标记了 `supportsResponses` 的来源)
+- `GET /openai/v1/models` — 启用在 **openai** 槽位的模型,OpenAI 列表格式
+- `POST /anthropic/v1/messages` — Anthropic 格式代理
+- `GET /anthropic/v1/models` — 启用在 **anthropic** 槽位的模型,OpenAI 列表格式
 - `GET /health` — 公开存活检查
 
 **管理(`/admin`,账号密码 —— HTTP Basic):**
@@ -279,7 +296,7 @@ npm install
 npm run build:web      # 把 Vue 界面构建到 packages/web/dist(首次,以及每次改完界面后)
 npm start              # tsx ... serve(网关在 :7800)
 npm run dev            # 网关,带 watch 热重载
-npm run dev:web        # vite 开发服务器(把 /v1 和 /admin 代理到 :7800)
+npm run dev:web        # vite 开发服务器(把 /openai、/anthropic、/admin 代理到 :7800)
 npm run typecheck      # tsc(core)+ vue-tsc(web)
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myapikey",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "type": "module",
   "description": "Personal LLM API gateway & proxy — one address + one API key for all your models. Forwards OpenAI & Anthropic calls to your backends with failover and a circuit breaker. Pure passthrough, no format translation. Self-hosted (CLI + web UI).",
   "keywords": [

package/packages/core/src/cli/client.ts

@@ -9,7 +9,7 @@ export class ApiError extends Error {
 export interface Ctx {
   url: string;
   auth: string; // Basic header value ("" if no account creds) — for /admin
-  apiKey?: string; // Bearer token for /v1
+  apiKey?: string; // Bearer token for /openai/v1 + /anthropic/v1
 }
 
 interface Opts {
@@ -34,18 +34,19 @@ export async function api<T = unknown>(
   path: string,
   body?: unknown,
 ): Promise<T> {
-  const isV1 = path.startsWith("/v1");
-  // /v1 takes the API key (Bearer); everything else (/admin) takes account Basic.
-  if (isV1 && !ctx.apiKey) {
-    throw new Error("No API key for /v1. Run `myapikey serve`, set MYAPIKEY_API_KEY, or pass --api-key.");
+  // The two agent surfaces (/openai/v1, /anthropic/v1) take the API key
+  // (Bearer); everything else (/admin) takes account Basic.
+  const isProxy = path.startsWith("/openai/") || path.startsWith("/anthropic/");
+  if (isProxy && !ctx.apiKey) {
+    throw new Error("No API key for /openai/v1 or /anthropic/v1. Run `myapikey serve`, set MYAPIKEY_API_KEY, or pass --api-key.");
   }
-  if (!isV1 && !ctx.auth) {
+  if (!isProxy && !ctx.auth) {
     throw new Error("No account credentials for /admin. Run `myapikey serve`, set MYAPIKEY_USER/MYAPIKEY_PASS, or pass --user/--pass.");
   }
   const res = await fetch(`${ctx.url}${path}`, {
     method,
     headers: {
-      authorization: isV1 ? `Bearer ${ctx.apiKey}` : ctx.auth,
+      authorization: isProxy ? `Bearer ${ctx.apiKey}` : ctx.auth,
       ...(body ? { "content-type": "application/json" } : {}),
     },
     body: body ? JSON.stringify(body) : undefined,

package/packages/core/src/cli/index.ts

@@ -23,7 +23,7 @@ program
   .option("-u, --url <url>", "gateway base URL")
   .option("--user <user>", "account username")
   .option("--pass <pass>", "account password")
-  .option("--api-key <key>", "api key for /v1 (agent calls)")
+  .option("--api-key <key>", "api key for /openai/v1 + /anthropic/v1 (agent calls)")
   .hook("preAction", () => undefined);
 
 const ctx = (): ReturnType<typeof makeCtx> => makeCtx(program.opts<Globals>());
@@ -51,9 +51,9 @@ program
       console.log(`\n  MyAPIKey listening on ${url}`);
       if (webDir) console.log(`  web UI:  ${url}`);
       else console.log(`  web UI:  not built (run: npm run build:web)`);
-      console.log(`  proxy:   ${url}/v1/chat/completions  (OpenAI)`);
-      console.log(`           ${url}/v1/responses           (OpenAI Responses)`);
-      console.log(`           ${url}/v1/messages            (Anthropic)`);
+      console.log(`  proxy:   ${url}/openai/v1/chat/completions   (OpenAI)`);
+      console.log(`           ${url}/openai/v1/responses           (OpenAI Responses)`);
+      console.log(`           ${url}/anthropic/v1/messages         (Anthropic)`);
       console.log(`  data:    ${dataDir}  (override with --data-dir or MYAPIKEY_DATA_DIR)\n`);
 
       if (firstRun) {
@@ -93,9 +93,9 @@ program
     console.log(`  login    : ${profile.username} / ${profile.password}   ← only for the web UI\n`);
     if (apiKey) {
       console.log("Example (OpenAI SDK):");
-      console.log(`  OPENAI_BASE_URL=${profile.url}/v1 OPENAI_API_KEY=${apiKey}`);
+      console.log(`  OPENAI_BASE_URL=${profile.url}/openai/v1 OPENAI_API_KEY=${apiKey}`);
       console.log("\nExample (Claude Code / Anthropic):");
-      console.log(`  ANTHROPIC_BASE_URL=${profile.url} ANTHROPIC_API_KEY=${apiKey}`);
+      console.log(`  ANTHROPIC_BASE_URL=${profile.url}/anthropic ANTHROPIC_API_KEY=${apiKey}`);
     }
   });
 
@@ -267,7 +267,7 @@ program
     const prompt = promptParts.join(" ").trim();
     const input = prompt || (await readStdin());
     if (!input) return console.log("Provide a prompt: myapikey call <model> hello");
-    const r = (await api(ctx(), "POST", "/v1/chat/completions", {
+    const r = (await api(ctx(), "POST", "/openai/v1/chat/completions", {
       model: modelName,
       messages: [{ role: "user", content: input }],
     })) as any;

package/packages/core/src/server/admin.ts

@@ -141,7 +141,7 @@ async function refreshDiscovery(store: Store, id: string): Promise<string[]> {
   return failed ? (store.get().providers.find((x) => x.id === id)?.discoveredModels ?? []) : models;
 }
 
-export function adminApi(store: Store, auth: MiddlewareHandler, v1: Hono): Hono {
+export function adminApi(store: Store, auth: MiddlewareHandler, openai: Hono, anthropic: Hono): Hono {
   const app = new Hono();
   app.use("*", auth);
 
@@ -526,6 +526,10 @@ export function adminApi(store: Store, auth: MiddlewareHandler, v1: Hono): Hono
     if (!format) {
       return c.json({ result: { ok: false, status: 0, format: "openai", error: "model not enabled on any routing slot" } });
     }
+    // Route the loopback to the matching surface: anthropic → the anthropic
+    // sub-app (/messages); openai/responses → the openai sub-app (the openai
+    // family lives there, including /responses).
+    const sub = format === "anthropic" ? anthropic : openai;
     const path = format === "anthropic" ? "/messages" : format === "responses" ? "/responses" : "/chat/completions";
     // /responses is the OpenAI Responses API — it takes `input`, not `messages`.
     const body =
@@ -534,7 +538,7 @@ export function adminApi(store: Store, auth: MiddlewareHandler, v1: Hono): Hono
         : { model: name, messages: [{ role: "user", content: "ping" }], max_tokens: 1, stream: false };
     let res: Response;
     try {
-      res = await v1.request(path, {
+      res = await sub.request(path, {
         method: "POST",
         headers: { "content-type": "application/json", authorization: `Bearer ${cfg.apiKey}`, "x-myapikey-probe": "1" },
         body: JSON.stringify(body),
@@ -584,6 +588,7 @@ export function adminApi(store: Store, auth: MiddlewareHandler, v1: Hono): Hono
     if (!provider || !providerSpeaks(provider, format)) {
       return c.json({ result: { ok: false, status: 0, format, error: "source does not speak this format" } });
     }
+    const sub = format === "anthropic" ? anthropic : openai;
     const path = format === "anthropic" ? "/messages" : format === "responses" ? "/responses" : "/chat/completions";
     // /responses is the OpenAI Responses API — it takes `input`, not `messages`.
     const body =
@@ -592,7 +597,7 @@ export function adminApi(store: Store, auth: MiddlewareHandler, v1: Hono): Hono
         : { model: name, messages: [{ role: "user", content: "ping" }], max_tokens: 1, stream: false };
     let res: Response;
     try {
-      res = await v1.request(path, {
+      res = await sub.request(path, {
         method: "POST",
         headers: { "content-type": "application/json", authorization: `Bearer ${cfg.apiKey}`, "x-myapikey-probe": "1", "x-myapikey-probe-slot": String(index) },
         body: JSON.stringify(body),

package/packages/core/src/server/app.ts

@@ -26,10 +26,13 @@ export function createApp(store: Store, opts: AppOptions = {}): Hono {
   const apiKeyAuth = apiKeyMiddleware(() => store.get().apiKey);
 
   // Both sub-apps require auth, applied inside each sub-app (before routes).
-  const v1 = proxyApi(store, apiKeyAuth);
-  const admin = adminApi(store, accountAuth, v1);
+  // Two agent surfaces, each with its own /models: /openai/v1 (openai family)
+  // and /anthropic/v1 (anthropic family). Both gate on the same API key.
+  const { openai, anthropic } = proxyApi(store, apiKeyAuth);
+  const admin = adminApi(store, accountAuth, openai, anthropic);
 
-  app.route("/v1", v1);
+  app.route("/openai/v1", openai);
+  app.route("/anthropic/v1", anthropic);
   app.route("/admin", admin);
 
   // Web UI: serve built SPA when available.
@@ -45,7 +48,7 @@ export function createApp(store: Store, opts: AppOptions = {}): Hono {
   } else {
     app.get("*", (c) =>
       c.text(
-        "MyAPIKey is running. Web UI not built — run `npm run build:web`. API at /v1 (proxy) and /admin (config).",
+        "MyAPIKey is running. Web UI not built — run `npm run build:web`. API at /openai/v1 + /anthropic/v1 (proxy) and /admin (config).",
         404,
       ),
     );

package/packages/core/src/server/proxy.ts

@@ -293,9 +293,35 @@ function observedBody(
   });
 }
 
-export function proxyApi(store: Store, auth: MiddlewareHandler): Hono {
-  const app = new Hono();
-  app.use("*", auth);
+/** OpenAI-style model list of the models enabled on ONE routing family's slot.
+ *  Each agent surface gets its own `/models` so a client listing models never
+ *  picks an id that 404s on that surface's call endpoint: `/openai/v1/models`
+ *  advertises the openai slot, `/anthropic/v1/models` the anthropic slot. */
+function modelsList(c: Context, store: Store, fmt: "openai" | "anthropic") {
+  const d = store.get();
+  const byId = new Map(d.providers.map((p) => [p.id, p]));
+  const data = Object.entries(d.models)
+    .filter(([, e]) => e[fmt].enabled)
+    .map(([id, e]) => ({
+      id,
+      object: "model",
+      created: 0,
+      owned_by: byId.get(e[fmt].providers[0]?.id ?? "")?.name || "MyAPIKey",
+    }));
+  return c.json({ object: "list", data });
+}
+
+/** The two agent surfaces as separate sub-apps, so each carries its own
+ *  `/models` (openai list vs anthropic list) under its own prefix. `dispatch`
+ *  is shared — it's keyed by RouteKey, surface-agnostic. */
+export function proxyApi(
+  store: Store,
+  auth: MiddlewareHandler,
+): { openai: Hono; anthropic: Hono } {
+  const openai = new Hono();
+  const anthropic = new Hono();
+  openai.use("*", auth);
+  anthropic.use("*", auth);
 
   /** Shared dispatch with failover. `key` selects the routing slot (and thus the
    *  candidate chain); `wire`/`path` derive from it for the upstream call. */
@@ -473,28 +499,18 @@ export function proxyApi(store: Store, auth: MiddlewareHandler): Hono {
     );
   };
 
-  app.post("/chat/completions", (c) => dispatch(c, "openai"));
-  app.post("/messages", (c) => dispatch(c, "anthropic"));
+  // OpenAI surface: chat/completions + responses, plus its own (openai-slot)
+  // model list.
+  openai.post("/chat/completions", (c) => dispatch(c, "openai"));
   // OpenAI Responses API — its own routing slot (sources must be supportsResponses).
-  app.post("/responses", (c) => dispatch(c, "responses"));
+  openai.post("/responses", (c) => dispatch(c, "responses"));
+  openai.get("/models", (c) => modelsList(c, store, "openai"));
 
-  // OpenAI-style model list of everything routable on the OpenAI path. This is
-  // the OpenAI list endpoint — advertise only models whose openai slot is
-  // enabled, so an agent that picks an id here can actually call it on
-  // /chat/completions. Anthropic-only models are intentionally omitted.
-  app.get("/models", (c) => {
-    const d = store.get();
-    const byId = new Map(d.providers.map((p) => [p.id, p]));
-    const data = Object.entries(d.models)
-      .filter(([, e]) => e.openai.enabled)
-      .map(([id, e]) => ({
-        id,
-        object: "model",
-        created: 0,
-        owned_by: byId.get(e.openai.providers[0]?.id ?? "")?.name || "MyAPIKey",
-      }));
-    return c.json({ object: "list", data });
-  });
+  // Anthropic surface: messages, plus its own (anthropic-slot) model list — so
+  // an Anthropic client can discover models enabled only on the anthropic slot,
+  // which the shared-/v1 design couldn't surface.
+  anthropic.post("/messages", (c) => dispatch(c, "anthropic"));
+  anthropic.get("/models", (c) => modelsList(c, store, "anthropic"));
 
-  return app;
+  return { openai, anthropic };
 }

package/packages/core/src/server/store.ts

@@ -219,7 +219,7 @@ export class Store {
       `  username: ${account.username}`,
       `  password: ${account.password}`,
       "",
-      "API key (for agents calling /v1):",
+      "API key (for agents calling /openai/v1 + /anthropic/v1):",
       `  ${apiKey}`,
       "",
       "Regenerated on each startup. If you change the password in Settings, this",