myapikey 0.18.0 → 0.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myapikey",
-  "version": "0.18.0",
+  "version": "0.19.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/index.ts

@@ -181,7 +181,7 @@ model.command("list").action(async () => {
     console.log(m.name);
     for (const f of fmts) {
       const fe = m[f];
-      const chain = fe.providers.map((p: any) => (p.model ? `${p.name}→${p.model}` : p.name)).join(" → ") || "(none)";
+      const chain = fe.providers.map((p: any) => `${p.model ? `${p.name}→${p.model}` : p.name}${p.thinking ? ` thinking=${p.thinking}` : ""}`).join(" → ") || "(none)";
       console.log(`  ${f.padEnd(9)} ${fe.enabled ? "✓" : "·"} ${chain}`);
     }
     if (m.paceRpm) console.log(`  pace      ${m.paceRpm}/min (one every ${Math.round(60 / m.paceRpm)}s)`);
@@ -264,6 +264,20 @@ model
     console.log(r.paceRpm ? `Pacing ${name} at ${r.paceRpm}/min (one every ${Math.round(60 / r.paceRpm)}s).` : `Pacing cleared for ${name} (unlimited).`);
   });
 
+model
+  .command("thinking <name> <index> [value]")
+  .description("set/clear the default thinking level of one chain slot (effort on openai/responses, budget tokens on anthropic; overrides the request's own setting; empty = clear)")
+  .addOption(fmtOption())
+  .action(async (name: string, indexRaw: string, value: string | undefined, opts: { format: "openai" | "anthropic" | "responses" }) => {
+    const index = Number(indexRaw);
+    const r = (await api(ctx(), "PUT", `/admin/models/${encodeURIComponent(name)}/thinking`, { format: opts.format, index, thinking: value ?? "" })) as { thinking?: string };
+    console.log(
+      r.thinking
+        ? `Default thinking for ${name} [${opts.format}] slot ${index}: ${r.thinking}.`
+        : `Default thinking cleared for ${name} [${opts.format}] slot ${index}.`,
+    );
+  });
+
 model.command("remove <name>").description("remove a model entirely (both formats)").action(async (name: string) => {
   await api(ctx(), "DELETE", `/admin/models/${encodeURIComponent(name)}`);
   console.log(`Removed ${name}.`);

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

@@ -312,6 +312,8 @@ export function adminApi(store: Store, auth: MiddlewareHandler, openai: Hono, an
         // send the public model name verbatim). Carried inline on each slot so
         // a provider can appear more than once with different upstream names.
         model: s.model,
+        // Default thinking level for this slot (undefined = pure passthrough).
+        thinking: s.thinking,
       })),
     });
     const models = Object.entries(d.models).map(([name, e]) => ({
@@ -540,6 +542,52 @@ export function adminApi(store: Store, auth: MiddlewareHandler, openai: Hono, an
     return c.json({ ok: true });
   });
 
+  // Set (or clear) the default thinking level for ONE chain slot (addressed by
+  // `index`, like /map above). The value is whatever the slot's wire format
+  // takes natively: an effort token ("low"/"medium"/"high"/…) on openai/
+  // responses slots; a thinking budget in TOKENS (positive integer) on
+  // anthropic slots (Anthropic has no named levels). When set, dispatch
+  // applies it IN PLACE OF whatever thinking parameters the request carried
+  // (the gateway's level wins); an empty value clears it (pure passthrough).
+  app.put("/models/:name/thinking", async (c) => {
+    const name = c.req.param("name");
+    const body = await readJson<{ format?: RouteKey; index?: number; thinking?: string | number }>(c.req.raw);
+    if (!body?.format) return c.json({ error: { message: "format is required" } }, 400);
+    if (!Number.isInteger(body?.index) || (body?.index ?? -1) < 0)
+      return c.json({ error: { message: "index (non-negative integer) is required" } }, 400);
+    const format = body.format;
+    const index = body.index!;
+    const raw = body.thinking === undefined ? "" : String(body.thinking).trim();
+    if (raw && format === "anthropic" && (!/^\d+$/.test(raw) || Number(raw) < 1)) {
+      return c.json({ error: { message: "anthropic thinking default must be a positive integer (thinking budget tokens, e.g. 8192)" } }, 400);
+    }
+    if (raw && format !== "anthropic" && raw.length > 32) {
+      return c.json({ error: { message: "thinking default too long (max 32 chars)" } }, 400);
+    }
+    const value = raw && format === "anthropic" ? String(Number(raw)) : raw;
+    let errStatus = 0;
+    let errMsg = "";
+    await store.update((d) => {
+      const entry = d.models[name];
+      if (!entry) {
+        errStatus = 404;
+        errMsg = "model not found";
+        return;
+      }
+      const fe = entry[format];
+      if (index >= fe.providers.length) {
+        errStatus = 400;
+        errMsg = "index out of range for this model's chain";
+        return;
+      }
+      if (value) fe.providers[index].thinking = value;
+      else delete fe.providers[index].thinking;
+    });
+    if (errStatus === 404) return c.json({ error: { message: errMsg } }, 404);
+    if (errStatus === 400) return c.json({ error: { message: errMsg } }, 400);
+    return c.json({ ok: true, thinking: value || undefined });
+  });
+
   app.post("/models/:name/disable", async (c) => {
     const name = c.req.param("name");
     const body = await readJson<{ format?: RouteKey }>(c.req.raw);

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

@@ -62,12 +62,14 @@ function parseResetFromBody(text: string): number | undefined {
 }
 
 /** One resolved routing slot: the provider to forward to plus THIS slot's
- *  optional upstream model name (absent = send the public model name). The
- *  same provider may occupy several slots in a chain — each is an independent
- *  failover slot carrying its own upstream model. */
+ *  optional upstream model name (absent = send the public model name) and
+ *  default thinking level. The same provider may occupy several slots in a
+ *  chain — each is an independent failover slot carrying its own upstream
+ *  model. */
 interface CandidateSlot {
   provider: Provider;
   model?: string;
+  thinking?: string;
 }
 
 /** Resolve the ordered, compatible provider slots for a model on a routing slot. */
@@ -83,7 +85,7 @@ function candidates(store: Store, model: string, key: RouteKey): CandidateSlot[]
   return fe.providers
     .map((s): CandidateSlot | null => {
       const p = byId.get(s.id);
-      return p ? { provider: p, model: s.model } : null;
+      return p ? { provider: p, model: s.model, thinking: s.thinking } : null;
     })
     .filter((slot): slot is CandidateSlot => {
       if (!slot) return false;
@@ -104,6 +106,109 @@ function notFound(c: Context, model: string) {
   );
 }
 
+// --- per-slot default thinking level -----------------------------------------
+// Each routing slot can carry a default thinking level. When a slot HAS one it
+// takes precedence over EVERYTHING the request carried — the gateway's own
+// config is the authority, so the default replaces the request's thinking
+// parameters outright (all of them, including compat-backend switches, leaving
+// exactly one thinking instruction in the body). A slot WITHOUT a default is
+// pure passthrough: whatever the request carried goes through untouched —
+// restored verbatim if an earlier failover slot overrode it. Like the model
+// rewrite, the default is written in the wire's own dialect, never translated
+// across formats:
+//   openai /chat/completions → `reasoning_effort: "<token>"` (low/medium/high/…)
+//   /responses               → `reasoning: { effort: "<token>" }`
+//   anthropic /v1/messages   → `thinking: { type: "enabled", budget_tokens: N }`
+//     (Anthropic has no named levels — the stored default IS the budget, a
+//     positive integer. The API also demands max_tokens > budget_tokens, so an
+//     at-or-below cap is lifted to budget+1 (and restored on a passthrough
+//     slot); otherwise the call would 400 — including our own max_tokens:1
+//     probe.)
+
+/** The body fields that steer thinking on a slot. The FIRST is the wire's
+ *  canonical parameter — the one a default is written into; the rest are
+ *  compat-backend switches (`thinking`, `enable_thinking` on chat/completions)
+ *  that an override clears so the forced level is the only instruction left. */
+function thinkingFields(key: RouteKey): string[] {
+  if (key === "anthropic") return ["thinking"];
+  if (key === "responses") return ["reasoning"];
+  return ["reasoning_effort", "reasoning", "thinking", "enable_thinking"];
+}
+
+/** Best-effort display of what a body's own thinking switches ask for (for the
+ *  log row on a passthrough slot, where the request's setting is what ran). */
+function clientThinking(body: Record<string, unknown>, key: RouteKey): { set: boolean; value?: string } {
+  const show = (v: unknown): string | undefined => (typeof v === "object" && v !== null ? JSON.stringify(v) : String(v));
+  if (key === "responses") {
+    const r = body.reasoning;
+    if (r === undefined || r === null) return { set: false };
+    const effort = (r as { effort?: unknown }).effort;
+    return { set: true, value: effort === undefined ? show(r) : show(effort) };
+  }
+  if (key === "anthropic") {
+    const t = body.thinking;
+    if (t === undefined || t === null) return { set: false };
+    const budget = (t as { budget_tokens?: unknown }).budget_tokens;
+    return { set: true, value: budget === undefined ? show(t) : show(budget) };
+  }
+  const found = [
+    body.reasoning_effort,
+    (body.reasoning as { effort?: unknown } | undefined)?.effort,
+    (body.thinking as { budget_tokens?: unknown } | undefined)?.budget_tokens,
+    (body.thinking as { type?: unknown } | undefined)?.type,
+    body.enable_thinking,
+  ].find((v) => v !== undefined && v !== null);
+  return { set: found !== undefined, value: found === undefined ? undefined : show(found) };
+}
+
+/** Snapshot of the request's own thinking switches, taken once before the
+ *  failover loop — every attempt mutates the shared body, so a passthrough
+ *  slot needs the originals kept aside to restore. */
+interface ThinkingOrig {
+  fields: Record<string, unknown>;
+  /** anthropic only: the request's original max_tokens (restored alongside,
+   *  since an override may have lifted it above the forced budget). */
+  maxTokens: unknown;
+}
+
+/** Apply THIS slot's thinking level to the body (mutating it), and return the
+ *  log row's `thinking` field: the level that ran and where it came from.
+ *  Undefined = nothing applied. A slot WITH a default overrides the request's
+ *  own parameters entirely; a slot WITHOUT one restores them (undoing any
+ *  override an earlier failover slot applied — same recompute-per-attempt
+ *  discipline as the model rewrite, so slot A's level never leaks into B). */
+function applySlotThinking(
+  body: Record<string, unknown>,
+  key: RouteKey,
+  def: string | undefined,
+  orig: ThinkingOrig,
+): { value: string; from: "client" | "default" } | undefined {
+  const fields = thinkingFields(key);
+  if (!def) {
+    for (const f of fields) {
+      if (orig.fields[f] === undefined) delete body[f];
+      else body[f] = orig.fields[f];
+    }
+    if (key === "anthropic") {
+      if (orig.maxTokens === undefined) delete body.max_tokens;
+      else body.max_tokens = orig.maxTokens;
+    }
+    const own = clientThinking(orig.fields, key);
+    return own.set ? { value: own.value ?? "", from: "client" } : undefined;
+  }
+  for (const f of fields) delete body[f];
+  if (key === "anthropic") {
+    const budget = Number(def);
+    body.thinking = { type: "enabled", budget_tokens: budget };
+    if (typeof body.max_tokens === "number" && body.max_tokens <= budget) body.max_tokens = budget + 1;
+  } else if (key === "responses") {
+    body.reasoning = { effort: def };
+  } else {
+    body.reasoning_effort = def;
+  }
+  return { value: def, from: "default" };
+}
+
 /** Auth headers for the Anthropic wire format. Sends BOTH x-api-key and
  *  Authorization: Bearer (same key). Native Anthropic (api.anthropic.com)
  *  accepts either; anthropic- COMPATIBLE surfaces (sensenova, Volcengine Ark,
@@ -353,6 +458,13 @@ export function proxyApi(
     const model: string = body.model;
     const wire: Format = key === "anthropic" ? "anthropic" : "openai";
     const stream = body.stream === true;
+    // The request's own thinking switches, snapshotted BEFORE the failover
+    // loop — each attempt mutates the shared body, and a passthrough slot
+    // (no default) must restore these originals.
+    const thinkOrig: ThinkingOrig = {
+      fields: Object.fromEntries(thinkingFields(key).map((f) => [f, body[f]])),
+      maxTokens: body.max_tokens,
+    };
     // The model-page "test" button drives dispatch via an in-process loopback
     // (adminApi calls v1.request). The probe is a real call in every respect —
     // including being logged — so we only tag it to report WHICH provider
@@ -393,6 +505,9 @@ export function proxyApi(
     const start = Date.now();
     let lastStatus = 502;
     let lastErr = "";
+    // Thinking level of the most recent attempt (for the all-failed row after
+    // the rounds loop; per-attempt rows capture the loop's own `think` const).
+    let lastThink: { value: string; from: "client" | "default" } | undefined;
     // Runtime log (console + server.log). Errors and notable events only — the
     // per-call history these lines summarize goes to pushLog/logs.jsonl anyway.
     // UI-triggered probes are excluded: their outcome is shown inline already.
@@ -482,6 +597,12 @@ export function proxyApi(
         // when the public name went through verbatim — JSON.stringify drops it, so
         // identity + legacy rows stay clean.
         const upstreamModel = slot.model && slot.model !== model ? slot.model : undefined;
+        // Per-slot thinking level: re-read from the slot and re-applied every
+        // attempt. A configured default OVERRIDES whatever the request carried;
+        // a slot without one restores the request's own switches (see
+        // applySlotThinking), so slot A's level never leaks into slot B.
+        const think = applySlotThinking(body, key, slot.thinking, thinkOrig);
+        lastThink = think;
         // Count this attempt toward the source's RPM window — but not for a pinned
         // probe, which (like circuit state) takes no routing side-effects.
         if (pinIndex == null) store.recordDispatch(provider.id);
@@ -500,7 +621,7 @@ export function proxyApi(
           sayFailover(provider, "network error");
           const r = store.recordCircuitFailure(provider.id, lastStatus, lastErr);
           if (r.entered) {
-            store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: lastStatus, ms: Date.now() - start, stream, kind: "cooldown", cooldownMs: r.cooldownMs, fails: r.fails, error: lastErr });
+            store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: lastStatus, ms: Date.now() - start, stream, thinking: think, kind: "cooldown", cooldownMs: r.cooldownMs, fails: r.fails, error: lastErr });
             sayCooldown(provider, r);
           }
           continue;
@@ -526,13 +647,13 @@ export function proxyApi(
             onSettle: (info) => {
               if (info.ok) {
                 store.recordCircuitSuccess(provider.id);
-                store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: 200, ms: ttfb, stream, usage: info.usage });
+                store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: 200, ms: ttfb, stream, thinking: think, usage: info.usage });
               } else {
                 // A pinned per-source probe takes no circuit side-effects (a manual
                 // test must not trip the breaker) — mirrors the retryable branch.
                 if (pinIndex == null) store.recordCircuitFailure(provider.id, info.status, info.error || "stream failed");
                 if (!isProbe) rt.warn(`proxy stream failed: provider '${provider.name}' status=${info.status} (${info.error || "stream failed"})`);
-                store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: info.status, ms: ttfb, stream, error: info.error });
+                store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: info.status, ms: ttfb, stream, thinking: think, error: info.error });
               }
             },
           });
@@ -555,7 +676,7 @@ export function proxyApi(
           const resetInMs = retryAfterMs ? undefined : parseResetFromBody(txt);
           const r = store.recordCircuitFailure(provider.id, lastStatus, lastErr, retryAfterMs ?? resetInMs, !!resetInMs);
           if (r.entered) {
-            store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: lastStatus, ms: Date.now() - start, stream, kind: "cooldown", cooldownMs: r.cooldownMs, fails: r.fails, error: lastErr });
+            store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: lastStatus, ms: Date.now() - start, stream, thinking: think, kind: "cooldown", cooldownMs: r.cooldownMs, fails: r.fails, error: lastErr });
             sayCooldown(provider, r);
           }
           continue;
@@ -563,7 +684,7 @@ export function proxyApi(
         // Non-retryable client error: return it to the caller as-is. Read the
         // error text off a CLONE so the original body still streams back.
         const errText = await upstream.clone().text().catch(() => "");
-        store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: upstream.status, ms: Date.now() - start, stream, error: shortError(errText) || `HTTP ${upstream.status}` });
+        store.pushLog({ ts: Date.now(), model, upstreamModel, provider: provider.name, providerId: provider.id, format: wire, status: upstream.status, ms: Date.now() - start, stream, thinking: think, error: shortError(errText) || `HTTP ${upstream.status}` });
         return passThrough(upstream, isProbe ? provider.name : undefined);
       }
 
@@ -576,7 +697,7 @@ export function proxyApi(
         return new Response(null, { status: 499 });
       }
       if (!isProbe) rt.error(`proxy all providers failed model=${model} (last status ${lastStatus})`);
-      store.pushLog({ ts: Date.now(), model, upstreamModel: lastUpstreamModel, provider: last.provider.name, providerId: last.provider.id, format: wire, status: lastStatus, ms: Date.now() - start, stream, error: lastErr || `all providers failed (last status ${lastStatus})` });
+      store.pushLog({ ts: Date.now(), model, upstreamModel: lastUpstreamModel, provider: last.provider.name, providerId: last.provider.id, format: wire, status: lastStatus, ms: Date.now() - start, stream, thinking: lastThink, error: lastErr || `all providers failed (last status ${lastStatus})` });
       // A pinned (per-source) probe failed: surface the REAL upstream status the
       // one slot returned (429/500/…), not a collapsed 502, and tag it with
       // x-myapikey-provider so the source-row badge names the tested source.

package/packages/core/src/shared/types.ts

@@ -68,6 +68,14 @@ export interface ChainSlot {
   /** Upstream model name to send to this provider. Absent = forward the public
    *  model name (the key in GateConfig.models) unchanged. */
   model?: string;
+  /** Default thinking level for this slot. When set it takes PRECEDENCE over
+   *  the request's own thinking parameters — dispatch replaces them outright
+   *  (the gateway's configured level is the authority). When absent, the
+   *  request's parameters pass through untouched. The value is whatever the
+   *  slot's wire format takes natively — no translation: an effort token
+   *  ("low"/"medium"/"high"/…) on openai/responses slots, a thinking budget
+   *  in tokens (positive integer) on anthropic slots. */
+  thinking?: string;
 }
 
 /** A model's routing dimensions — one per forwarding endpoint. /chat/completions
@@ -148,6 +156,12 @@ export interface LogEntry {
   usage?: Usage;
   /** Short upstream error text on non-2xx (omitted on success). */
   error?: string;
+  /** The thinking level this call ran with, and where it came from: "client" =
+   *  the answering slot had no default, so the request's own thinking setting
+   *  ran (forwarded untouched); "default" = the slot's configured `thinking`
+   *  ran, OVERRIDING whatever the request carried. Absent when neither
+   *  applied (no default configured, request carried nothing). */
+  thinking?: { value: string; from: "client" | "default" };
   /** Row kind. Absent on legacy lines → treated as a normal call. "cooldown"
    *  marks a circuit-breaker event (a provider just entered cooldown), shown
    *  distinctly in the timeline alongside the failures that caused it. */