myapikey 0.46.1 → 0.47.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myapikey",
-  "version": "0.46.1",
+  "version": "0.47.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 /openai/v1 + /anthropic/v1
+  apiKey?: string; // Bearer token for /openai-chat/v1 + /openai-responses/v1 + /anthropic/v1
 }
 
 interface Opts {
@@ -34,11 +34,11 @@ export async function api<T = unknown>(
   path: string,
   body?: unknown,
 ): Promise<T> {
-  // 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/");
+  // The agent surfaces (/openai-chat/v1, /openai-responses/v1, /anthropic/v1)
+  // take the API key (Bearer); everything else (/admin) takes account Basic.
+  const isProxy = path.startsWith("/openai-chat/") || path.startsWith("/openai-responses/") || 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.");
+    throw new Error("No API key for /openai-chat/v1, /openai-responses/v1 or /anthropic/v1. Run `myapikey serve`, set MYAPIKEY_API_KEY, or pass --api-key.");
   }
   if (!isProxy && !ctx.auth) {
     throw new Error("No account credentials for /admin. Run `myapikey serve`, set MYAPIKEY_USER/MYAPIKEY_PASS, or pass --user/--pass.");

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 /openai/v1 + /anthropic/v1 (agent calls)")
+  .option("--api-key <key>", "api key for /openai-chat/v1 + /openai-responses/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}/openai/v1/chat/completions   (OpenAI)`);
-      console.log(`           ${url}/openai/v1/responses           (OpenAI Responses)`);
-      console.log(`           ${url}/anthropic/v1/messages         (Anthropic)`);
+      console.log(`  proxy:   ${url}/openai-chat/v1/chat/completions   (OpenAI chat)`);
+      console.log(`           ${url}/openai-responses/v1/responses     (OpenAI Responses)`);
+      console.log(`           ${url}/anthropic/v1/messages             (Anthropic)`);
       console.log(`  data:    ${dataDir}  (override with --data-dir or MYAPIKEY_DATA_DIR)`);
       console.log(`  log:     ${store.getPaths().serverLogFile}  (errors + failover/cooldown events; level via MYAPIKEY_LOG_LEVEL)\n`);
       store.getLogger().info(`gateway started on port ${info.port}, data=${dataDir}`);
@@ -95,7 +95,7 @@ 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}/openai/v1 OPENAI_API_KEY=${apiKey}`);
+      console.log(`  OPENAI_BASE_URL=${profile.url}/openai-chat/v1 OPENAI_API_KEY=${apiKey}`);
       console.log("\nExample (Claude Code / Anthropic):");
       console.log(`  ANTHROPIC_BASE_URL=${profile.url}/anthropic ANTHROPIC_API_KEY=${apiKey}`);
     }
@@ -378,7 +378,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", "/openai/v1/chat/completions", {
+    const r = (await api(ctx(), "POST", "/openai-chat/v1/chat/completions", {
       model: modelName,
       messages: [{ role: "user", content: input }],
     })) as any;

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

@@ -194,7 +194,7 @@ function projectModel(name: string, e: ModelEntry, byId: Map<string, Provider>)
   };
 }
 
-export function adminApi(store: Store, auth: MiddlewareHandler, openai: Hono, anthropic: Hono): Hono {
+export function adminApi(store: Store, auth: MiddlewareHandler, chat: Hono, responses: Hono, anthropic: Hono): Hono {
   const app = new Hono();
   app.use("*", auth);
 
@@ -927,10 +927,10 @@ app.delete("/models/:name/debug/fails", (c) => {
     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;
+    // Route the loopback to the matching surface sub-app: each protocol has
+    // its own surface now (anthropic → /messages, responses → /responses,
+    // openai → /chat/completions).
+    const sub = format === "anthropic" ? anthropic : format === "responses" ? responses : chat;
     const path = format === "anthropic" ? "/messages" : format === "responses" ? "/responses" : "/chat/completions";
     // /responses is the OpenAI Responses API — it takes `input`, not `messages`.
     const body =
@@ -989,7 +989,7 @@ app.delete("/models/:name/debug/fails", (c) => {
     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 sub = format === "anthropic" ? anthropic : format === "responses" ? responses : chat;
     const path = format === "anthropic" ? "/messages" : format === "responses" ? "/responses" : "/chat/completions";
     // /responses is the OpenAI Responses API — it takes `input`, not `messages`.
     const body =

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

@@ -34,12 +34,14 @@ export function createApp(store: Store, opts: AppOptions = {}): Hono {
   const apiKeyAuth = apiKeyMiddleware(() => store.get().apiKey, logger);
 
   // Both sub-apps require auth, applied inside each sub-app (before routes).
-  // 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);
+  // Three agent surfaces — one per protocol, each with its own /models:
+  // /openai-chat/v1 (openai chat/completions), /openai-responses/v1 (openai
+  // responses), /anthropic/v1 (anthropic messages). All gate on the same API key.
+  const { chat, responses, anthropic } = proxyApi(store, apiKeyAuth);
+  const admin = adminApi(store, accountAuth, chat, responses, anthropic);
 
-  app.route("/openai/v1", openai);
+  app.route("/openai-chat/v1", chat);
+  app.route("/openai-responses/v1", responses);
   app.route("/anthropic/v1", anthropic);
   app.route("/admin", admin);
 
@@ -49,13 +51,18 @@ export function createApp(store: Store, opts: AppOptions = {}): Hono {
   // as "Unexpected token '<'" (this bit pi's model refresh once).
   const apiMiss = (c: Context) =>
     c.json({ error: { message: `no such endpoint: ${c.req.method} ${c.req.path}`, type: "invalid_request_error" } }, 404);
-  app.all("/openai/*", apiMiss);
+  app.all("/openai-chat/*", apiMiss);
+  app.all("/openai-responses/*", apiMiss);
   app.all("/anthropic/*", apiMiss);
   app.all("/admin/*", apiMiss);
-  // Legacy pre-0.12 surface: gone since the split — point the caller at the two
+  // Legacy pre-0.47 openai surface: the two openai families now have their own
+  // prefixes — point the caller there instead of a bare 404.
+  app.all("/openai/*", (c) =>
+    c.json({ error: { message: "the /openai/v1 surface was split — use /openai-chat/v1 or /openai-responses/v1", type: "invalid_request_error" } }, 404));
+  // Legacy pre-0.12 surface: gone since the split — point the caller at the
   // current surfaces instead of a bare 404.
   app.all("/v1/*", (c) =>
-    c.json({ error: { message: "the /v1 surface was split in v0.12.0 — use /openai/v1 or /anthropic/v1", type: "invalid_request_error" } }, 404));
+    c.json({ error: { message: "the /v1 surface was split in v0.12.0 — use /openai-chat/v1, /openai-responses/v1 or /anthropic/v1", type: "invalid_request_error" } }, 404));
 
   // Web UI: serve built SPA when available.
   if (opts.webDir && existsSync(opts.webDir)) {
@@ -83,7 +90,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 /openai/v1 + /anthropic/v1 (proxy) and /admin (config).",
+        "MyAPIKey is running. Web UI not built — run `npm run build:web`. API at /openai-chat/v1 + /openai-responses/v1 + /anthropic/v1 (proxy) and /admin (config).",
         404,
       ),
     );

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

@@ -1,6 +1,6 @@
 import { Hono, type Context, type MiddlewareHandler } from "hono";
 import { trimBase } from "../shared/config";
-import type { DebugCapture, Format, Provider, RouteKey, Usage } from "../shared/types";
+import type { DebugCapture, Format, FormatEntry, Provider, RouteKey, Usage } from "../shared/types";
 import { CAPTURE_BODY_MAX, type Store } from "./store";
 import { UsageCollector } from "./tokens";
 
@@ -494,44 +494,58 @@ function observedBody(
 /** 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 — and each answers in its own
- *  ecosystem's list shape: openai `{object:"list", data:[{id, owned_by}]}` vs
- *  anthropic `{data:[{id, display_name}], first_id, last_id, has_more}`. We
- *  can't know real created_at / capabilities, so the anthropic shape carries
- *  only the honest minimal fields rather than fabricating them. */
-function modelsList(c: Context, store: Store, fmt: "openai" | "anthropic") {
+ *  ecosystem's list shape: the two openai-family surfaces `{object:"list",
+ *  data:[{id, owned_by}]}` vs anthropic `{data:[{id, display_name}],
+ *  first_id, last_id, has_more}`. We can't know real created_at / capabilities,
+ *  so the anthropic shape carries only the honest minimal fields rather than
+ *  fabricating them. Each surface lists exactly what dispatch would route on
+ *  it: the entry's chain for that RouteKey must be enabled (and, for
+ *  responses, keep at least one slot on a supportsResponses source). */
+function modelsList(c: Context, store: Store, key: RouteKey) {
   const d = store.get();
   const byId = new Map(d.providers.map((p) => [p.id, p]));
-  const enabled = Object.entries(d.models).filter(([, e]) => e[fmt].enabled);
-  if (fmt === "anthropic") {
+  const enabled = Object.entries(d.models).filter(([, e]) => e[key]?.enabled);
+  if (key === "anthropic") {
     const data = enabled.map(([id]) => ({ id, display_name: id, created_at: "1970-01-01T00:00:00Z", type: "model" }));
     return c.json({ data, first_id: data[0]?.id ?? null, last_id: data.at(-1)?.id ?? null, has_more: false });
   }
-  const data = enabled.map(([id, e]) => ({
-    id,
-    object: "model",
-    created: 0,
-    owned_by: byId.get(e.openai.providers[0]?.id ?? "")?.name || "MyAPIKey",
-  }));
+  const routable = (e: FormatEntry) =>
+    key === "responses" ? e.providers.some((s) => byId.get(s.id)?.supportsResponses) : true;
+  // owned_by follows the first slot dispatch would actually use on this surface.
+  const firstSlot = (e: FormatEntry) =>
+    key === "responses" ? e.providers.find((s) => byId.get(s.id)?.supportsResponses) : e.providers[0];
+  const data = enabled
+    .filter(([, e]) => e[key] && routable(e[key]))
+    .map(([id, e]) => ({
+      id,
+      object: "model",
+      created: 0,
+      owned_by: byId.get(firstSlot(e[key])?.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. */
+/** The three agent surfaces as separate sub-apps (one per protocol family:
+ *  openai chat/completions, openai responses, anthropic messages), so each
+ *  carries its own `/models` 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();
+): { chat: Hono; responses: Hono; anthropic: Hono } {
+  const chat = new Hono();
+  const responses = new Hono();
   const anthropic = new Hono();
   // GET /models is a PUBLIC discovery read — no api key required. It returns only
   // the enabled model names (like /health), so an agent or a quick curl can see
   // what each surface offers before wiring up auth. Registered BEFORE the auth
   // middleware so it isn't gated: Hono only runs middleware on routes registered
   // after it.
-  openai.get("/models", (c) => modelsList(c, store, "openai"));
+  chat.get("/models", (c) => modelsList(c, store, "openai"));
+  responses.get("/models", (c) => modelsList(c, store, "responses"));
   anthropic.get("/models", (c) => modelsList(c, store, "anthropic"));
-  openai.use("*", auth);
+  chat.use("*", auth);
+  responses.use("*", auth);
   anthropic.use("*", auth);
 
   /** Shared dispatch with failover. `key` selects the routing slot (and thus the
@@ -581,7 +595,7 @@ export function proxyApi(
         return c.json(
           {
             error: {
-              message: `model '${model}' is not enabled for /responses — enable it on a source marked "supports responses"`,
+              message: `model '${model}' is not enabled for /openai-responses/v1/responses — enable it on a source marked "supports responses"`,
               type: "invalid_request_error",
               code: "model_not_found",
             },
@@ -865,14 +879,14 @@ export function proxyApi(
     }
   };
 
-  // OpenAI surface: chat/completions + responses (/models is registered above,
-  // before the auth middleware, so it stays public).
-  openai.post("/chat/completions", (c) => dispatch(c, "openai"));
+  // One call endpoint per surface (/models is registered above, before the
+  // auth middleware, so it stays public).
+  chat.post("/chat/completions", (c) => dispatch(c, "openai"));
   // OpenAI Responses API — its own routing slot (sources must be supportsResponses).
-  openai.post("/responses", (c) => dispatch(c, "responses"));
+  responses.post("/responses", (c) => dispatch(c, "responses"));
 
-  // Anthropic surface: messages (/models likewise registered above, public).
+  // Anthropic surface: messages.
   anthropic.post("/messages", (c) => dispatch(c, "anthropic"));
 
-  return { openai, anthropic };
+  return { chat, responses, anthropic };
 }