omnigateway 0.2.0 → 0.2.1

package/gateway.js

@@ -5299,12 +5299,14 @@ function createAdminAuth(store, opts) {
 var ANTHROPIC_NATIVE_TOOLS = {
   anthropic: true,
   openai: false,
-  kimi: false
+  kimi: false,
+  custom: false
 };
 var PROVIDER_CAPABILITIES = {
   anthropic: { tools: true, images: true, reasoning: true },
   openai: { tools: true, images: true, reasoning: true },
-  kimi: { tools: true, images: false, reasoning: false }
+  kimi: { tools: true, images: false, reasoning: false },
+  custom: { tools: true, images: true, reasoning: true }
 };
 // packages/ir/src/errors.ts
 var RETRYABLE = {
@@ -5318,6 +5320,7 @@ var RETRYABLE = {
   TIMEOUT: true,
   NETWORK: true,
   BAD_REQUEST: false,
+  CONFLICT: false,
   CONTENT_FILTER: false,
   NO_CANDIDATES: false,
   ALL_CANDIDATES_FAILED: false,
@@ -5329,6 +5332,7 @@ var HTTP_STATUS = {
   QUOTA_EXHAUSTED: 429,
   OVERLOADED: 503,
   BAD_REQUEST: 400,
+  CONFLICT: 409,
   CONTENT_FILTER: 400,
   CAPABILITY_MISMATCH: 400,
   MODEL_UNAVAILABLE: 404,
@@ -5627,6 +5631,29 @@ function estimateInputTokens(request) {
     total += toolTokens(tool);
   return total;
 }
+function estimateCachedInputTokens(request) {
+  let running = 0;
+  let cached = 0;
+  for (const tool of request.tools ?? []) {
+    running += toolTokens(tool);
+    if (tool.cacheControl !== undefined)
+      cached = running;
+  }
+  for (const block of request.system ?? []) {
+    running += blockTokens(block);
+    if (cacheControlOf(block) !== undefined)
+      cached = running;
+  }
+  for (const message of request.messages) {
+    running += MESSAGE_OVERHEAD;
+    for (const block of message.content) {
+      running += blockTokens(block);
+      if (cacheControlOf(block) !== undefined)
+        cached = running;
+    }
+  }
+  return cached;
+}
 // packages/ir/src/validate.ts
 function validateRequest(req) {
   const seenToolUseIds = new Set;
@@ -5729,7 +5756,8 @@ var BODY_ORDER = {
     "parallel_tool_calls",
     "metadata"
   ],
-  kimi: ["model", "messages", "tools", "tool_choice", "max_tokens", "temperature", "stream"]
+  kimi: ["model", "messages", "tools", "tool_choice", "max_tokens", "temperature", "stream"],
+  custom: []
 };
 function orderFields(obj, order) {
   const out = {};
@@ -5830,10 +5858,20 @@ var ANTHROPIC_MODELS = {
       id: "claude-haiku-4-5",
       label: "Claude Haiku 4.5",
       pricing: { input: 1, output: 5, cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 2 },
-      limits: { contextWindow: 200000, maxOutputTokens: 64000 }
+      limits: { contextWindow: 200000, maxOutputTokens: 64000 },
+      reasoningForm: "budget"
     }
   ]
 };
+var ONE_M_SUFFIX = "[1m]";
+var DATED_SUFFIX = /-\d{8}$/;
+function anthropicReasoningForm(model) {
+  let id = model.trim();
+  if (id.toLowerCase().endsWith(ONE_M_SUFFIX))
+    id = id.slice(0, -ONE_M_SUFFIX.length).trim();
+  id = id.replace(DATED_SUFFIX, "");
+  return ANTHROPIC_MODELS.models.find((m) => m.id === id)?.reasoningForm ?? "adaptive";
+}
 
 // packages/providers/src/kimi/models.ts
 var KIMI_MODELS = {
@@ -5905,7 +5943,8 @@ var OPENAI_MODELS = {
 var PROVIDER_MODEL_CATALOG = {
   anthropic: ANTHROPIC_MODELS,
   openai: OPENAI_MODELS,
-  kimi: KIMI_MODELS
+  kimi: KIMI_MODELS,
+  custom: { defaultModel: "", models: [] }
 };
 function catalogPricing(provider, model) {
   return PROVIDER_MODEL_CATALOG[provider]?.models.find((entry) => entry.id === model)?.pricing ?? null;
@@ -6118,7 +6157,8 @@ var kimi = {
 var PROFILES = {
   anthropic: { ...anthropic, order: envOrder("OMNI_ORDER_ANTHROPIC", anthropic.order) },
   openai: { ...openai, order: envOrder("OMNI_ORDER_OPENAI", openai.order) },
-  kimi: { ...kimi, order: envOrder("OMNI_ORDER_KIMI", kimi.order) }
+  kimi: { ...kimi, order: envOrder("OMNI_ORDER_KIMI", kimi.order) },
+  custom: { headers: [], order: [] }
 };
 
 // packages/providers/src/sse.ts
@@ -6696,6 +6736,45 @@ function encodeToolChoice(c) {
       return { type: "tool", name: c.name };
   }
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function withoutEffort(vendor, note) {
+  const config = vendor.output_config;
+  if (!isRecord(config))
+    return vendor;
+  const entries = Object.entries(config);
+  const kept = entries.filter(([key]) => key !== "effort");
+  if (kept.length === entries.length)
+    return vendor;
+  note("anthropic:effort-unsupported");
+  if (kept.length === 0) {
+    return Object.fromEntries(Object.entries(vendor).filter(([key]) => key !== "output_config"));
+  }
+  return { ...vendor, output_config: Object.fromEntries(kept) };
+}
+var THINKING_ONLY_EDITS = new Set(["clear_thinking_20251015"]);
+function thinkingIsOff(thinking) {
+  if (!isRecord(thinking))
+    return thinking !== undefined;
+  return thinking.type !== "adaptive" && thinking.type !== "enabled";
+}
+function stripUnsupportedEdits(body, note) {
+  if (!thinkingIsOff(body.thinking))
+    return;
+  const config = body.context_management;
+  if (!isRecord(config) || !Array.isArray(config.edits))
+    return;
+  const kept = config.edits.filter((e) => !(isRecord(e) && THINKING_ONLY_EDITS.has(String(e.type))));
+  if (kept.length === config.edits.length)
+    return;
+  note("anthropic:clear-thinking-unsupported");
+  if (kept.length === 0 && Object.keys(config).length === 1) {
+    delete body.context_management;
+    return;
+  }
+  body.context_management = { ...config, edits: kept };
+}
 function toWire(req, model, opts) {
   const degradations = [];
   const note = (d) => {
@@ -6745,12 +6824,20 @@ function toWire(req, model, opts) {
   if (req.reasoning !== undefined) {
     switch (req.reasoning.mode) {
       case "adaptive":
+        if (anthropicReasoningForm(model) === "budget") {
+          body.thinking = { type: "disabled" };
+          note("anthropic:adaptive-thinking-unsupported");
+          break;
+        }
         body.thinking = {
           type: "adaptive",
           ...req.reasoning.display === undefined ? {} : { display: req.reasoning.display }
         };
         if (req.reasoning.effort !== undefined) {
-          body.output_config = { ...body.output_config ?? {}, effort: req.reasoning.effort };
+          body.output_config = {
+            ...isRecord(body.output_config) ? body.output_config : {},
+            effort: req.reasoning.effort
+          };
         }
         break;
       case "budget":
@@ -6761,7 +6848,9 @@ function toWire(req, model, opts) {
         break;
     }
   }
-  Object.assign(body, req.vendor?.anthropic ?? {});
+  const vendor = req.vendor?.anthropic ?? {};
+  Object.assign(body, anthropicReasoningForm(model) === "budget" ? withoutEffort(vendor, note) : vendor);
+  stripUnsupportedEdits(body, note);
   return { body, degradations };
 }
 
@@ -6825,115 +6914,6 @@ var anthropicAdapter = {
     return { events: decodeAnthropic(parseSse(res.body)), degradations: notes };
   }
 };
-// packages/providers/src/http-client.ts
-import { request as httpRequest } from "http";
-import { request as httpsRequest } from "https";
-import { Readable } from "stream";
-function nodeHttpClient(options = {}) {
-  const logger2 = options.logger ?? noopLogger;
-  const now = options.now ?? (() => Date.now());
-  return (req) => new Promise((resolve, reject) => {
-    const url = new URL(req.url);
-    const startedAt = now();
-    let traced = false;
-    const trace = (status, failed = false) => {
-      if (traced || !logger2.enabled("debug"))
-        return;
-      traced = true;
-      logger2.debug("upstream http", {
-        provider: req.provider,
-        status,
-        host: url.host,
-        path: url.pathname,
-        durationMs: now() - startedAt,
-        reason: failed ? "transport error" : undefined
-      });
-    };
-    const send = url.protocol === "https:" ? httpsRequest : httpRequest;
-    const bodyBytes = Buffer.from(req.body, "utf8");
-    const headers = {};
-    for (const [name, value] of req.headers)
-      headers[name] = value;
-    if (req.body.length > 0 && !hasHeader(req, "content-length")) {
-      headers["Content-Length"] = bodyBytes.byteLength;
-    }
-    const outgoing = send({
-      protocol: url.protocol,
-      hostname: url.hostname,
-      port: url.port || (url.protocol === "https:" ? 443 : 80),
-      path: `${url.pathname}${url.search}`,
-      method: req.method,
-      headers,
-      setHost: !hasHeader(req, "host")
-    }, (incoming) => {
-      const chunks = [];
-      let buffered = null;
-      const responseHeaders = new Headers;
-      for (const [k, v] of Object.entries(incoming.headers)) {
-        if (Array.isArray(v))
-          for (const one of v)
-            responseHeaders.append(k, one);
-        else if (typeof v === "string")
-          responseHeaders.set(k, v);
-      }
-      trace(incoming.statusCode);
-      resolve({
-        status: incoming.statusCode ?? 0,
-        headers: responseHeaders,
-        body: Readable.toWeb(incoming),
-        text: () => {
-          buffered ??= new Promise((res, rej) => {
-            incoming.on("data", (c) => chunks.push(c));
-            incoming.on("end", () => res(Buffer.concat(chunks).toString("utf8")));
-            incoming.on("error", rej);
-          });
-          return buffered;
-        }
-      });
-    });
-    const onAbort = () => outgoing.destroy(new Error("aborted"));
-    outgoing.on("error", (err) => {
-      req.signal.removeEventListener("abort", onAbort);
-      trace(undefined, true);
-      reject(err);
-    });
-    outgoing.on("close", () => req.signal.removeEventListener("abort", onAbort));
-    if (req.signal.aborted) {
-      outgoing.destroy(new Error("aborted"));
-      return;
-    }
-    req.signal.addEventListener("abort", onAbort, { once: true });
-    if (bodyBytes.byteLength > 0)
-      outgoing.write(bodyBytes);
-    outgoing.end();
-  });
-}
-function hasHeader(req, lowerName) {
-  return req.headers.some(([name]) => name.toLowerCase() === lowerName);
-}
-// packages/providers/src/kimi-device.ts
-import { randomUUID } from "crypto";
-function mintKimiDevice() {
-  return {
-    deviceId: randomUUID(),
-    deviceName: "MacBook-Pro",
-    deviceModel: "MacBookPro18,3",
-    osVersion: "15.3.1"
-  };
-}
-function kimiDeviceHeaders(providerData) {
-  const deviceId = providerData.deviceId;
-  if (typeof deviceId !== "string" || deviceId.length === 0)
-    return [];
-  const str = (v) => typeof v === "string" && v.length > 0 ? v : "unknown";
-  return [
-    ["X-Msh-Device-Id", deviceId],
-    ["X-Msh-Device-Name", str(providerData.deviceName)],
-    ["X-Msh-Device-Model", str(providerData.deviceModel)],
-    ["X-Msh-Os-Version", str(providerData.osVersion)]
-  ];
-}
-
 // packages/providers/src/kimi/decode.ts
 var FINISH = {
   stop: "endTurn",
@@ -7044,7 +7024,7 @@ function encodeToolChoice2(c) {
       return { type: "function", function: { name: c.name } };
   }
 }
-function toChatWire(req, model) {
+function toChatWire(req, model, vendor = "kimi") {
   const degradations = [];
   const note = (d) => {
     if (!degradations.includes(d))
@@ -7128,44 +7108,10 @@ function toChatWire(req, model) {
     body.tool_choice = encodeToolChoice2(req.toolChoice);
   if (req.reasoning !== undefined)
     note("kimi:reasoning-dropped");
-  Object.assign(body, req.vendor?.kimi ?? {});
+  Object.assign(body, req.vendor?.[vendor] ?? {});
   return { body, degradations };
 }
 
-// packages/providers/src/kimi/index.ts
-var BASE_URL2 = "https://api.kimi.com/coding/v1/chat/completions";
-var kimiAdapter = {
-  id: "kimi",
-  capabilities: PROVIDER_CAPABILITIES.kimi,
-  async send(req) {
-    const { body, degradations } = toChatWire(req.request, req.model);
-    const token = req.credentials.accessToken ?? req.credentials.apiKey;
-    if (token === null) {
-      throw new GatewayError("AUTH", "kimi credential has no token", { provider: "kimi" });
-    }
-    const protocol = [
-      ["Content-Type", "application/json"],
-      ["Accept", "text/event-stream"],
-      ["Authorization", `Bearer ${token}`],
-      ...kimiDeviceHeaders(req.credentials.providerData)
-    ];
-    const profile = PROFILES.kimi;
-    const headers = orderHeaders(mergeHeaders(profile.headers, protocol), profile.order);
-    const res = await req.http({
-      provider: "kimi",
-      url: BASE_URL2,
-      method: "POST",
-      headers,
-      body: JSON.stringify(orderFields({ ...body, stream: true }, BODY_ORDER.kimi)),
-      signal: req.signal
-    });
-    if (res.status < 200 || res.status >= 300)
-      throw await httpError(res, "kimi");
-    if (res.body === null)
-      throw new GatewayError("UPSTREAM", "empty response body", { provider: "kimi" });
-    return { events: decodeChat(parseSse(res.body)), degradations };
-  }
-};
 // packages/providers/src/openai/decode.ts
 var ERROR_CODE = {
   rate_limit_exceeded: "RATE_LIMIT",
@@ -7441,6 +7387,190 @@ ${block.text}
   return { body, degradations };
 }
 
+// packages/providers/src/custom/index.ts
+function metadata(data) {
+  const { origin, protocol } = data;
+  if (typeof origin !== "string" || protocol !== "chat_completions" && protocol !== "responses") {
+    throw new GatewayError("BAD_REQUEST", "custom credential has invalid endpoint metadata");
+  }
+  return { origin, protocol };
+}
+var customAdapter = {
+  id: "custom",
+  capabilities: PROVIDER_CAPABILITIES.custom,
+  async send(req) {
+    const apiKey = req.credentials.apiKey;
+    if (apiKey === null) {
+      throw new GatewayError("AUTH", "custom credential has no API key", { provider: "custom" });
+    }
+    const { origin, protocol } = metadata(req.credentials.providerData);
+    const encoded = protocol === "chat_completions" ? toChatWire(req.request, req.model, "openai") : toResponsesWire(req.request, req.model);
+    const headers = [
+      ["Content-Type", "application/json"],
+      ["Authorization", `Bearer ${apiKey}`]
+    ];
+    const res = await req.http({
+      provider: "custom",
+      url: `${origin}/v1/${protocol === "chat_completions" ? "chat/completions" : "responses"}`,
+      method: "POST",
+      headers,
+      body: JSON.stringify({ ...encoded.body, stream: true }),
+      signal: req.signal
+    });
+    if (res.status < 200 || res.status >= 300)
+      throw await httpError(res, "custom");
+    if (res.body === null) {
+      throw new GatewayError("UPSTREAM", "empty response body", { provider: "custom" });
+    }
+    return {
+      events: protocol === "chat_completions" ? decodeChat(parseSse(res.body)) : decodeResponses(parseSse(res.body)),
+      degradations: encoded.degradations.map((value) => value.replace(protocol === "chat_completions" ? /^kimi:/ : /^openai:/, "custom:"))
+    };
+  }
+};
+// packages/providers/src/http-client.ts
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+import { Readable } from "stream";
+function nodeHttpClient(options = {}) {
+  const logger2 = options.logger ?? noopLogger;
+  const now = options.now ?? (() => Date.now());
+  return (req) => new Promise((resolve, reject) => {
+    const url = new URL(req.url);
+    const startedAt = now();
+    let traced = false;
+    const trace = (status, failed = false) => {
+      if (traced || !logger2.enabled("debug"))
+        return;
+      traced = true;
+      logger2.debug("upstream http", {
+        provider: req.provider,
+        status,
+        host: url.host,
+        path: url.pathname,
+        durationMs: now() - startedAt,
+        reason: failed ? "transport error" : undefined
+      });
+    };
+    const send = url.protocol === "https:" ? httpsRequest : httpRequest;
+    const bodyBytes = Buffer.from(req.body, "utf8");
+    const headers = {};
+    for (const [name, value] of req.headers)
+      headers[name] = value;
+    if (req.body.length > 0 && !hasHeader(req, "content-length")) {
+      headers["Content-Length"] = bodyBytes.byteLength;
+    }
+    const outgoing = send({
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: `${url.pathname}${url.search}`,
+      method: req.method,
+      headers,
+      setHost: !hasHeader(req, "host")
+    }, (incoming) => {
+      const chunks = [];
+      let buffered = null;
+      const responseHeaders = new Headers;
+      for (const [k, v] of Object.entries(incoming.headers)) {
+        if (Array.isArray(v))
+          for (const one of v)
+            responseHeaders.append(k, one);
+        else if (typeof v === "string")
+          responseHeaders.set(k, v);
+      }
+      trace(incoming.statusCode);
+      resolve({
+        status: incoming.statusCode ?? 0,
+        headers: responseHeaders,
+        body: Readable.toWeb(incoming),
+        text: () => {
+          buffered ??= new Promise((res, rej) => {
+            incoming.on("data", (c) => chunks.push(c));
+            incoming.on("end", () => res(Buffer.concat(chunks).toString("utf8")));
+            incoming.on("error", rej);
+          });
+          return buffered;
+        }
+      });
+    });
+    const onAbort = () => outgoing.destroy(new Error("aborted"));
+    outgoing.on("error", (err) => {
+      req.signal.removeEventListener("abort", onAbort);
+      trace(undefined, true);
+      reject(err);
+    });
+    outgoing.on("close", () => req.signal.removeEventListener("abort", onAbort));
+    if (req.signal.aborted) {
+      outgoing.destroy(new Error("aborted"));
+      return;
+    }
+    req.signal.addEventListener("abort", onAbort, { once: true });
+    if (bodyBytes.byteLength > 0)
+      outgoing.write(bodyBytes);
+    outgoing.end();
+  });
+}
+function hasHeader(req, lowerName) {
+  return req.headers.some(([name]) => name.toLowerCase() === lowerName);
+}
+// packages/providers/src/kimi-device.ts
+import { randomUUID } from "crypto";
+function mintKimiDevice() {
+  return {
+    deviceId: randomUUID(),
+    deviceName: "MacBook-Pro",
+    deviceModel: "MacBookPro18,3",
+    osVersion: "15.3.1"
+  };
+}
+function kimiDeviceHeaders(providerData) {
+  const deviceId = providerData.deviceId;
+  if (typeof deviceId !== "string" || deviceId.length === 0)
+    return [];
+  const str = (v) => typeof v === "string" && v.length > 0 ? v : "unknown";
+  return [
+    ["X-Msh-Device-Id", deviceId],
+    ["X-Msh-Device-Name", str(providerData.deviceName)],
+    ["X-Msh-Device-Model", str(providerData.deviceModel)],
+    ["X-Msh-Os-Version", str(providerData.osVersion)]
+  ];
+}
+
+// packages/providers/src/kimi/index.ts
+var BASE_URL2 = "https://api.kimi.com/coding/v1/chat/completions";
+var kimiAdapter = {
+  id: "kimi",
+  capabilities: PROVIDER_CAPABILITIES.kimi,
+  async send(req) {
+    const { body, degradations } = toChatWire(req.request, req.model);
+    const token = req.credentials.accessToken ?? req.credentials.apiKey;
+    if (token === null) {
+      throw new GatewayError("AUTH", "kimi credential has no token", { provider: "kimi" });
+    }
+    const protocol = [
+      ["Content-Type", "application/json"],
+      ["Accept", "text/event-stream"],
+      ["Authorization", `Bearer ${token}`],
+      ...kimiDeviceHeaders(req.credentials.providerData)
+    ];
+    const profile = PROFILES.kimi;
+    const headers = orderHeaders(mergeHeaders(profile.headers, protocol), profile.order);
+    const res = await req.http({
+      provider: "kimi",
+      url: BASE_URL2,
+      method: "POST",
+      headers,
+      body: JSON.stringify(orderFields({ ...body, stream: true }, BODY_ORDER.kimi)),
+      signal: req.signal
+    });
+    if (res.status < 200 || res.status >= 300)
+      throw await httpError(res, "kimi");
+    if (res.body === null)
+      throw new GatewayError("UPSTREAM", "empty response body", { provider: "kimi" });
+    return { events: decodeChat(parseSse(res.body)), degradations };
+  }
+};
 // packages/providers/src/openai/index.ts
 var OAUTH_URL = "https://chatgpt.com/backend-api/codex/responses";
 var API_URL = "https://api.openai.com/v1/responses";
@@ -7482,7 +7612,8 @@ var openaiAdapter = {
 var ADAPTERS = {
   anthropic: anthropicAdapter,
   openai: openaiAdapter,
-  kimi: kimiAdapter
+  kimi: kimiAdapter,
+  custom: customAdapter
 };
 // packages/control/src/oauth/types.ts
 async function postJson(deps, provider, url, profile2, opts) {
@@ -7659,11 +7790,11 @@ function pendingError(code) {
   error[PENDING_MARKER] = true;
   return error;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function recordFrom(value) {
-  return isRecord(value) ? value : null;
+  return isRecord2(value) ? value : null;
 }
 function stringFrom(value, field) {
   const candidate = value[field];
@@ -7866,7 +7997,7 @@ function createPendingFlows(opts) {
 }
 
 // packages/control/src/connect.ts
-var PROVIDER_IDS = ["anthropic", "openai", "kimi"];
+var PROVIDER_IDS = ["anthropic", "openai", "kimi", "custom"];
 var FLOW_TTL_MS = 600000;
 function isProviderId(value) {
   return typeof value === "string" && PROVIDER_IDS.includes(value);
@@ -7907,6 +8038,8 @@ function createConnectFlows(deps) {
   }
   async function complete(flow, code) {
     const provider = deps.providers[flow.provider];
+    if (provider === undefined)
+      throw new GatewayError("BAD_REQUEST", "provider does not support OAuth");
     const result = await provider.exchange({ code, pending: flow.pending }, { http: deps.http, now: deps.now });
     const id = crypto.randomUUID();
     await deps.store.credentials.create({
@@ -7950,6 +8083,9 @@ function createConnectFlows(deps) {
       }
       const label = typeof labelInput === "string" && labelInput.trim().length > 0 ? labelInput.trim() : providerInput;
       const provider = deps.providers[providerInput];
+      if (provider === undefined) {
+        throw new GatewayError("BAD_REQUEST", "provider does not support OAuth");
+      }
       const redirectUri = callbackUri(providerInput);
       const start = provider.begin === undefined ? provider.start({ redirectUri }) : await (async () => {
         const initial = provider.start({ redirectUri });
@@ -19202,12 +19338,12 @@ function describe(description) {
   ch._zod.check = () => {};
   return ch;
 }
-function meta(metadata) {
+function meta(metadata2) {
   const ch = new $ZodCheck({ check: "meta" });
   ch._zod.onattach = [
     (inst) => {
       const existing = globalRegistry.get(inst) ?? {};
-      globalRegistry.add(inst, { ...existing, ...metadata });
+      globalRegistry.add(inst, { ...existing, ...metadata2 });
     }
   ];
   ch._zod.check = () => {};
@@ -22339,20 +22475,36 @@ function parseOrThrow(schema, body2) {
   const path = issue2?.path.join(".") ?? "(root)";
   throw new GatewayError("BAD_REQUEST", `${path}: ${issue2?.message ?? "invalid request"}`);
 }
-var providerIdSchema = exports_external.enum(["anthropic", "openai", "kimi"]);
+var providerIdSchema = exports_external.enum(["anthropic", "openai", "kimi", "custom"]);
 var dryRunSchema = exports_external.object({
   tools: exports_external.boolean().default(false),
   images: exports_external.boolean().default(false),
   reasoning: exports_external.boolean().default(false)
 }).strict();
-var modelSchema = exports_external.object({
-  id: exports_external.string().min(1).refine((value) => !value.toLowerCase().startsWith("claude/"), {
-    message: 'model id must not start with "claude/": that prefix is reserved for discovery mirrors'
-  }),
-  strategy: exports_external.enum(["score", "priority", "roundRobin", "weighted"]),
-  isAlias: exports_external.boolean(),
-  targets: exports_external.array(exports_external.object({
-    provider: providerIdSchema,
+var targetSchema = exports_external.discriminatedUnion("provider", [
+  exports_external.object({
+    provider: exports_external.enum(["anthropic", "openai", "kimi"]),
+    model: exports_external.string().min(1),
+    tier: exports_external.number().int().min(1),
+    weight: exports_external.number().positive(),
+    costPerMTok: exports_external.object({
+      input: exports_external.number().min(0),
+      output: exports_external.number().min(0),
+      cacheRead: exports_external.number().min(0).optional(),
+      cacheWrite5m: exports_external.number().min(0).optional(),
+      cacheWrite1h: exports_external.number().min(0).optional()
+    }),
+    contextWindow: exports_external.number().int().positive().optional(),
+    maxOutputTokens: exports_external.number().int().positive().optional(),
+    capabilities: exports_external.object({
+      tools: exports_external.boolean(),
+      images: exports_external.boolean(),
+      reasoning: exports_external.boolean()
+    })
+  }).strict(),
+  exports_external.object({
+    provider: exports_external.literal("custom"),
+    endpointId: exports_external.string().trim().min(1),
     model: exports_external.string().min(1),
     tier: exports_external.number().int().min(1),
     weight: exports_external.number().positive(),
@@ -22370,7 +22522,15 @@ var modelSchema = exports_external.object({
       images: exports_external.boolean(),
       reasoning: exports_external.boolean()
     })
-  })).min(1, "a virtual model needs at least one target")
+  }).strict()
+]);
+var modelSchema = exports_external.object({
+  id: exports_external.string().min(1).refine((value) => !value.toLowerCase().startsWith("claude/"), {
+    message: 'model id must not start with "claude/": that prefix is reserved for discovery mirrors'
+  }),
+  strategy: exports_external.enum(["score", "priority", "roundRobin", "weighted"]),
+  isAlias: exports_external.boolean(),
+  targets: exports_external.array(targetSchema).min(1, "a virtual model needs at least one target")
 });
 var keyCreateSchema = exports_external.object({
   label: exports_external.string().min(1).default("api key"),
@@ -22384,7 +22544,7 @@ var settingsSchema = exports_external.object({
     quota: exports_external.number(),
     cost: exports_external.number(),
     latency: exports_external.number(),
-    recency: exports_external.number()
+    load: exports_external.number()
   }).strict(),
   maxAttempts: exports_external.number().int().min(1).max(10),
   requestDeadlineMs: exports_external.number().int().min(0),
@@ -22443,6 +22603,70 @@ function summarizeCredential(credential) {
 async function listCredentials(store) {
   return (await store.credentials.list()).map(summarizeCredential);
 }
+function requiredString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new GatewayError("BAD_REQUEST", `${field}: must not be empty`);
+  }
+  return value.trim();
+}
+function customProviderData(input) {
+  const endpointId = requiredString(input.endpointId, "endpointId");
+  const endpointLabel = requiredString(input.endpointLabel, "endpointLabel");
+  const originInput = requiredString(input.origin, "origin");
+  if (input.protocol !== "chat_completions" && input.protocol !== "responses") {
+    throw new GatewayError("BAD_REQUEST", "protocol: unsupported protocol");
+  }
+  let url2;
+  try {
+    url2 = new URL(originInput);
+  } catch {
+    throw new GatewayError("BAD_REQUEST", "origin: must be a valid URL");
+  }
+  if (url2.protocol !== "http:" && url2.protocol !== "https:" || url2.hostname.length === 0 || url2.username.length > 0 || url2.password.length > 0 || url2.pathname !== "" && url2.pathname !== "/" || url2.search.length > 0 || url2.hash.length > 0) {
+    throw new GatewayError("BAD_REQUEST", "origin: must be an HTTP(S) server origin");
+  }
+  return { endpointId, endpointLabel, origin: url2.origin, protocol: input.protocol };
+}
+function sameCustomEndpoint(a, b) {
+  return a.endpointId === b.endpointId && a.endpointLabel === b.endpointLabel && a.origin === b.origin && a.protocol === b.protocol;
+}
+async function createApiKeyCredential(store, input, logger2 = noopLogger) {
+  const provider = parseOrThrow(providerIdSchema, input.provider);
+  const apiKey = requiredString(input.apiKey, "apiKey");
+  if (input.label !== undefined && typeof input.label !== "string") {
+    throw new GatewayError("BAD_REQUEST", "label: must be a string");
+  }
+  let providerData = {};
+  if (provider === "custom") {
+    const custom2 = customProviderData(input);
+    const existing = (await store.credentials.list()).filter((credential) => credential.provider === "custom" && credential.providerData.endpointId === custom2.endpointId);
+    if (existing.some((credential) => !sameCustomEndpoint(credential.providerData, custom2))) {
+      throw new GatewayError("CONFLICT", `endpointId: metadata conflicts with existing endpoint`);
+    }
+    providerData = custom2;
+  }
+  const label = input.label?.trim() || `${provider} api key`;
+  const created = await store.credentials.create({
+    id: crypto.randomUUID(),
+    provider,
+    label,
+    authType: "apiKey",
+    enabled: true,
+    tier: 1,
+    weight: 1,
+    expiresAt: null,
+    accountEmail: null,
+    providerData,
+    disabledReason: null,
+    disabledAt: null,
+    accessToken: null,
+    refreshToken: null,
+    apiKey,
+    idToken: null
+  });
+  logger2.info("credential added", { credentialId: created.id, provider: created.provider });
+  return summarizeCredential(created);
+}
 async function credentialHealth(store) {
   const [health, quota] = await Promise.all([
     store.credentials.listHealth(),
@@ -22537,6 +22761,9 @@ function eligible(input) {
     for (const credential of snapshot.credentials) {
       if (credential.provider !== target.provider)
         continue;
+      if (target.provider === "custom" && credential.providerData.endpointId !== target.endpointId) {
+        continue;
+      }
       const drop = (reason) => {
         excluded.push({ credentialId: credential.id, model: target.model, reason });
       };
@@ -22608,6 +22835,22 @@ function quotaHeadroom(credential, windows, now, pollIntervalMs) {
   return Math.min(...usable.map((w) => paceAdjusted(w, now)));
 }
 
+// packages/store/src/types.ts
+var READ_OVER_INPUT = 0.1;
+function cacheReadRate(prices) {
+  return prices.cacheRead ?? prices.input * READ_OVER_INPUT;
+}
+var DEFAULT_SETTINGS = {
+  weights: { tier: 10, health: 3, quota: 2, load: 2, cost: 1, latency: 1 },
+  maxAttempts: 3,
+  requestDeadlineMs: 120000,
+  breakerThreshold: 3,
+  breakerCooldownMs: 30000,
+  logRetentionDays: 30,
+  quotaPollIntervalMs: 300000,
+  rtkEnabled: false
+};
+
 // packages/router/src/score.ts
 var UNKNOWN = 0.5;
 function lowerIsBetter(value, min, max) {
@@ -22615,43 +22858,49 @@ function lowerIsBetter(value, min, max) {
     return 1;
   return (max - value) / (max - min);
 }
-function blendedCost(input, output) {
-  return input * 0.25 + output * 0.75;
+function ratio(value, min) {
+  return Math.min(1, min / value);
+}
+function bestPositive(values) {
+  const positive = values.filter((v) => v > 0);
+  return positive.length > 0 ? Math.min(...positive) : null;
+}
+var EXPECTED_OUTPUT_TOKENS = 1000;
+function requestCost(target, request2) {
+  const cachedTok = estimateCachedInputTokens(request2);
+  const freshTok = Math.max(0, estimateInputTokens(request2) - cachedTok);
+  const outTok = Math.min(request2.maxTokens ?? EXPECTED_OUTPUT_TOKENS, EXPECTED_OUTPUT_TOKENS);
+  return freshTok * target.costPerMTok.input + cachedTok * cacheReadRate(target.costPerMTok) + outTok * target.costPerMTok.output;
+}
+function healthScore(h) {
+  const base = 1 / (1 + (h?.consecutiveFailures ?? 0));
+  return h?.breakerState === "open" || h?.breakerState === "halfOpen" ? base * 0.5 : base;
 }
 function score(pairs, input) {
-  const { snapshot, now } = input;
+  const { snapshot, now, load } = input;
   const w = snapshot.settings.weights;
   const tiers = pairs.map((p) => p.target.tier);
   const minTier = Math.min(...tiers);
   const maxTier = Math.max(...tiers);
-  const costs = pairs.map((p) => blendedCost(p.target.costPerMTok.input, p.target.costPerMTok.output));
-  const minCost = Math.min(...costs);
-  const maxCost = Math.max(...costs);
-  const latencies = pairs.flatMap((p) => {
+  const costs = pairs.map((p) => requestCost(p.target, input.request));
+  const bestCost = bestPositive(costs);
+  const bestLatency = bestPositive(pairs.flatMap((p) => {
     const h = snapshot.health.get(healthKey(p.credential.id, p.target.model));
     return h?.ewmaTtftMs != null ? [h.ewmaTtftMs] : [];
-  });
-  const minLatency = latencies.length > 0 ? Math.min(...latencies) : 0;
-  const maxLatency = latencies.length > 0 ? Math.max(...latencies) : 0;
-  const idleTimes = pairs.map((p) => {
-    const h = snapshot.health.get(healthKey(p.credential.id, p.target.model));
-    return h?.lastUsedAt == null ? Number.POSITIVE_INFINITY : now - h.lastUsedAt;
-  });
-  const finiteIdle = idleTimes.filter(Number.isFinite);
-  const maxIdle = finiteIdle.length > 0 ? Math.max(...finiteIdle) : 1;
+  }));
   return pairs.map((pair, i) => {
-    const h = snapshot.health.get(healthKey(pair.credential.id, pair.target.model));
+    const key = healthKey(pair.credential.id, pair.target.model);
+    const h = snapshot.health.get(key);
     const tier = lowerIsBetter(pair.target.tier, minTier, maxTier);
-    let health = 1 / (1 + (h?.consecutiveFailures ?? 0));
-    if (h?.breakerState === "open" || h?.breakerState === "halfOpen")
-      health *= 0.5;
+    const inflight = load.get(key) ?? 0;
+    const loadTerm = 1 / (1 + inflight);
+    const health = healthScore(h);
     const quota = quotaHeadroom(pair.credential, snapshot.quota.get(pair.credential.id) ?? [], now, snapshot.settings.quotaPollIntervalMs);
-    const cost = maxCost === 0 ? UNKNOWN : lowerIsBetter(costs[i], minCost, maxCost);
-    const latency = h?.ewmaTtftMs == null ? UNKNOWN : lowerIsBetter(h.ewmaTtftMs, minLatency, maxLatency);
-    const idle = idleTimes[i];
-    const recency = Number.isFinite(idle) ? Math.min(1, idle / (maxIdle || 1)) : 1;
-    const reasons = { tier, health, quota, cost, latency, recency };
-    const base = tier * w.tier + health * w.health + quota * w.quota + cost * w.cost + latency * w.latency + recency * w.recency;
+    const ownCost = costs[i];
+    const cost = ownCost <= 0 || bestCost === null ? UNKNOWN : ratio(ownCost, bestCost);
+    const latency = h?.ewmaTtftMs == null || h.ewmaTtftMs <= 0 || bestLatency === null ? UNKNOWN : ratio(h.ewmaTtftMs, bestLatency);
+    const reasons = { tier, health, quota, cost, latency, load: loadTerm };
+    const base = tier * w.tier + health * w.health + quota * w.quota + cost * w.cost + latency * w.latency + loadTerm * w.load;
     return {
       credential: pair.credential,
       target: pair.target,
@@ -22672,6 +22921,7 @@ var PENALTY = {
   QUOTA_EXHAUSTED: "soft",
   OVERLOADED: "soft",
   BAD_REQUEST: "none",
+  CONFLICT: "none",
   CONTENT_FILTER: "none",
   CAPABILITY_MISMATCH: "none",
   NO_CANDIDATES: "none",
@@ -22764,7 +23014,7 @@ function resolveModel(name, snapshot) {
   if (sep > 0) {
     const prefix = name.slice(0, sep);
     const rest = name.slice(sep + 1);
-    if (PROVIDERS.has(prefix) && rest.length > 0) {
+    if (PROVIDERS.has(prefix) && prefix !== "custom" && rest.length > 0) {
       return synthesize(prefix, rest);
     }
     throw new GatewayError("NO_CANDIDATES", `unknown provider "${prefix}" in model "${name}"`);
@@ -22777,8 +23027,8 @@ function resolveModel(name, snapshot) {
 }
 
 // packages/router/src/index.ts
-function weightedShuffle(candidates, rand, headroom) {
-  const drawWeight = (c) => c.credential.weight * c.target.weight * headroom(c);
+function weightedShuffle(candidates, rand, headroom, health) {
+  const drawWeight = (c) => c.credential.weight * c.target.weight * headroom(c) * health(c);
   const total = candidates.reduce((sum, c) => sum + drawWeight(c), 0);
   if (total <= 0)
     return [...candidates].sort((a, b) => b.score - a.score);
@@ -22801,6 +23051,8 @@ function rank(input) {
     return { candidates: [], excluded };
   const scored = score(pairs, input);
   const headroom = (c) => quotaHeadroom(c.credential, input.snapshot.quota.get(c.credential.id) ?? [], input.now, input.snapshot.settings.quotaPollIntervalMs);
+  const health = (c) => healthScore(input.snapshot.health.get(healthKey(c.credential.id, c.target.model)));
+  const inflight = (c) => input.load.get(healthKey(c.credential.id, c.target.model)) ?? 0;
   switch (input.model.strategy) {
     case "priority":
       scored.sort((a, b) => a.target.tier - b.target.tier || b.score - a.score);
@@ -22811,11 +23063,11 @@ function rank(input) {
         return h?.lastUsedAt == null ? Number.POSITIVE_INFINITY : input.now - h.lastUsedAt;
       };
       const spent = (c) => headroom(c) < QUOTA_FLOOR ? 1 : 0;
-      scored.sort((a, b) => spent(a) - spent(b) || idle(b) - idle(a));
+      scored.sort((a, b) => spent(a) - spent(b) || inflight(a) - inflight(b) || idle(b) - idle(a));
       break;
     }
     case "weighted":
-      return { candidates: weightedShuffle(scored, input.rand, headroom), excluded };
+      return { candidates: weightedShuffle(scored, input.rand, headroom, health), excluded };
     case "score":
       scored.sort((a, b) => b.score - a.score);
       break;
@@ -22848,7 +23100,7 @@ async function dryRun(deps, modelId, input) {
     } : {},
     ...need.reasoning ? { reasoning: { mode: "adaptive" } } : {}
   };
-  const result = rank({ request: probe, model, snapshot, now, rand: 0 });
+  const result = rank({ request: probe, model, snapshot, now, rand: 0, load: new Map });
   return {
     modelId: model.id,
     strategy: model.strategy,
@@ -22905,21 +23157,24 @@ function unhex(s) {
     out[i] = Number.parseInt(s.slice(i * 2, i * 2 + 2), 16);
   return out;
 }
-// packages/store/src/types.ts
-var DEFAULT_SETTINGS = {
-  weights: { tier: 10, health: 3, quota: 2, cost: 1, latency: 1, recency: 0.5 },
-  maxAttempts: 3,
-  requestDeadlineMs: 120000,
-  breakerThreshold: 3,
-  breakerCooldownMs: 30000,
-  logRetentionDays: 30,
-  quotaPollIntervalMs: 300000,
-  rtkEnabled: false
-};
-
 // packages/store/src/sqlite/config.ts
 var SETTINGS_KEY = "settings";
 var ADMIN_HASH_KEY = "adminPasswordHash";
+function knownWeights(stored) {
+  const d = DEFAULT_SETTINGS.weights;
+  const pick2 = (key) => {
+    const value = stored?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : d[key];
+  };
+  return {
+    tier: pick2("tier"),
+    health: pick2("health"),
+    quota: pick2("quota"),
+    load: pick2("load"),
+    cost: pick2("cost"),
+    latency: pick2("latency")
+  };
+}
 function createConfigRepo(db, emit = () => {}) {
   const readRaw = (key) => db.query("SELECT value FROM settings WHERE key = ?").get(key)?.value ?? null;
   const writeRaw = (key, value) => {
@@ -22957,7 +23212,7 @@ function createConfigRepo(db, emit = () => {}) {
           ...DEFAULT_SETTINGS,
           ...stored,
           rtkEnabled: stored.rtkEnabled === true,
-          weights: { ...DEFAULT_SETTINGS.weights, ...stored.weights }
+          weights: knownWeights(stored.weights)
         };
       } catch {
         return DEFAULT_SETTINGS;
@@ -23988,6 +24243,11 @@ async function putModel(store, id, input) {
   if (model.id !== id) {
     throw new GatewayError("BAD_REQUEST", "model id in the path and body must match");
   }
+  const customEndpointIds = new Set((await store.credentials.list()).filter((credential) => credential.provider === "custom").map((credential) => credential.providerData.endpointId).filter((endpointId) => typeof endpointId === "string"));
+  const missing = model.targets.find((target) => target.provider === "custom" && (target.endpointId === undefined || !customEndpointIds.has(target.endpointId)));
+  if (missing !== undefined) {
+    throw new GatewayError("BAD_REQUEST", `custom endpoint "${missing.endpointId}" has no credential`);
+  }
   await store.config.putModel(model);
 }
 async function removeModel(store, id) {
@@ -24110,7 +24370,7 @@ var AUTHORIZE_URL2 = "https://auth.openai.com/oauth/authorize";
 var TOKEN_URL3 = "https://auth.openai.com/oauth/token";
 var SCOPES2 = "openid profile email offline_access";
 var USAGE_URL3 = "https://chatgpt.com/backend-api/wham/usage";
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function nonBlankStringOrNull(value) {
@@ -24127,19 +24387,19 @@ function decodeClaims(idToken) {
   }
   try {
     const json5 = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-    if (!isRecord2(json5))
+    if (!isRecord3(json5))
       return { email: null, accountId: null };
     const auth = json5["https://api.openai.com/auth"];
     return {
       email: typeof json5.email === "string" ? json5.email : null,
-      accountId: isRecord2(auth) ? nonBlankStringOrNull(auth.chatgpt_account_id) : null
+      accountId: isRecord3(auth) ? nonBlankStringOrNull(auth.chatgpt_account_id) : null
     };
   } catch {
     return { email: null, accountId: null };
   }
 }
 function parseTokenResponse(value) {
-  if (!isRecord2(value) || typeof value.access_token !== "string")
+  if (!isRecord3(value) || typeof value.access_token !== "string")
     return null;
   return {
     accessToken: value.access_token,
@@ -24277,6 +24537,9 @@ function createRefresher(deps) {
       throw new GatewayError("AUTH", `credential ${credential.id} has no refresh token`);
     }
     const provider = deps.providers[credential.provider];
+    if (provider === undefined) {
+      throw new GatewayError("BAD_REQUEST", "provider does not support OAuth refresh");
+    }
     logger2.debug("refreshing credential", {
       provider: credential.provider,
       credentialId: credential.id
@@ -24329,7 +24592,7 @@ async function probe(deps, credential) {
   if (credential.authType !== "oauth")
     return null;
   const provider = deps.providers[credential.provider];
-  if (provider.usage === undefined)
+  if (provider?.usage === undefined)
     return null;
   const refreshed = credential.hasRefreshToken && credential.expiresAt !== null && credential.expiresAt - SCHEDULER_REFRESH_LEAD_MS <= deps.now() ? await deps.refresh(credential) : null;
   const secrets = refreshed === null ? await credential.openForUsage() : { accessToken: refreshed.accessToken };
@@ -24357,7 +24620,7 @@ async function probe(deps, credential) {
 async function poll(deps) {
   const logger2 = deps.logger ?? noopLogger;
   const now = deps.now();
-  const credentials = (await deps.store.credentials.list()).filter((c) => c.enabled && c.authType === "oauth" && deps.providers[c.provider].usage !== undefined && (cooldowns.get(c.id) ?? 0) <= now);
+  const credentials = (await deps.store.credentials.list()).filter((c) => c.enabled && c.authType === "oauth" && deps.providers[c.provider]?.usage !== undefined && (cooldowns.get(c.id) ?? 0) <= now);
   let written = 0;
   let next = 0;
   const worker = async () => {
@@ -39077,7 +39340,7 @@ function parseOrThrow2(schema, body2) {
   const path = issue2?.path.join(".") ?? "(root)";
   throw new GatewayError("BAD_REQUEST", `${path}: ${issue2?.message ?? "invalid request"}`);
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function extraFields(body2, known) {
@@ -39136,7 +39399,7 @@ async function readJson(request2) {
 }
 async function readJsonRecord(request2) {
   const body2 = await readJson(request2);
-  return isRecord3(body2) ? body2 : null;
+  return isRecord4(body2) ? body2 : null;
 }
 function apiErrorResponse(error51) {
   const gatewayError = error51 instanceof GatewayError ? error51 : new GatewayError("INTERNAL", "internal error");
@@ -39203,6 +39466,14 @@ function adminRoutes(deps) {
   }).get("/api/credentials", async ({ request: request2 }) => {
     await requireAdmin(request2, deps.admin);
     return { credentials: await listCredentials(deps.store) };
+  }).post("/api/credentials", async ({ request: request2 }) => {
+    await requireAdmin(request2, deps.admin);
+    const body2 = await readJsonRecord(request2);
+    if (body2 === null)
+      throw new GatewayError("BAD_REQUEST", "credential body is required");
+    return {
+      credential: await createApiKeyCredential(deps.store, { provider: body2.provider, apiKey: body2.apiKey, ...body2 }, logger2)
+    };
   }).get("/api/credentials/health", async ({ request: request2 }) => {
     await requireAdmin(request2, deps.admin);
     return credentialHealth(deps.store);
@@ -40863,7 +41134,7 @@ ${rendered}`;
 }
 
 // packages/rtk/src/index.ts
-var MIN_INPUT = 500;
+var MIN_INPUT = 0;
 var MAX_INPUT = 1e6;
 var MAX_OUTPUT2 = 250000;
 var SHELL = new Set(["bash", "shell", "terminal", "exec", "run_command", "execute_command"]);
@@ -41279,9 +41550,9 @@ function classify(error51) {
 var WRITE_OVER_INPUT = {
   anthropic: { fiveMinute: 1.25, oneHour: 2 },
   openai: { fiveMinute: 0, oneHour: 0 },
-  kimi: { fiveMinute: 0, oneHour: 0 }
+  kimi: { fiveMinute: 0, oneHour: 0 },
+  custom: { fiveMinute: 0, oneHour: 0 }
 };
-var READ_OVER_INPUT = 0.1;
 function splitWrites(usage) {
   const { cacheWrite5mTokens: five, cacheWrite1hTokens: hour, cacheWriteTokens: total } = usage;
   if (five !== undefined && hour !== undefined)
@@ -41294,7 +41565,7 @@ function splitWrites(usage) {
 }
 function priceOf(prices, usage, provider) {
   const fallback = WRITE_OVER_INPUT[provider];
-  const readRate = prices.cacheRead ?? prices.input * READ_OVER_INPUT;
+  const readRate = cacheReadRate(prices);
   const write5mRate = prices.cacheWrite5m ?? prices.input * fallback.fiveMinute;
   const write1hRate = prices.cacheWrite1h ?? prices.input * fallback.oneHour;
   const writes = splitWrites(usage);
@@ -41331,10 +41602,13 @@ async function dispatch(request2, deps, signal, requestId) {
     signal.addEventListener("abort", abortFromClient, { once: true });
   const deadlineTimer = deadlineAt === null ? null : setTimeout(() => dispatchController.abort(new GatewayError("TIMEOUT", "request deadline exceeded")), Math.max(0, deadlineAt - deps.now()));
   const dispatchSignal = dispatchController.signal;
+  let releaseOnAbort = null;
   const clearDeadline = () => {
     if (deadlineTimer !== null)
       clearTimeout(deadlineTimer);
     signal.removeEventListener("abort", abortFromClient);
+    if (releaseOnAbort !== null)
+      signal.removeEventListener("abort", releaseOnAbort);
   };
   const checkCancellation = () => {
     if (signal.aborted)
@@ -41365,7 +41639,8 @@ async function dispatch(request2, deps, signal, requestId) {
     model,
     snapshot,
     now: startedAt,
-    rand: deps.rand()
+    rand: deps.rand(),
+    load: deps.loadRegistry.counts()
   });
   logger2.debug("routing candidates ranked", {
     requestId,
@@ -41388,6 +41663,18 @@ async function dispatch(request2, deps, signal, requestId) {
     return fail("NO_CANDIDATES", `no eligible credential for model "${request2.model}"`);
   }
   const maxAttempts = Math.min(snapshot.settings.maxAttempts, candidates.length);
+  const head = candidates[0];
+  const eager = {
+    credentialId: head.credential.id,
+    model: head.target.model,
+    release: deps.loadRegistry.acquire(head.credential.id, head.target.model)
+  };
+  let eagerHeld = true;
+  releaseOnAbort = () => eager.release();
+  if (signal.aborted)
+    eager.release();
+  else
+    signal.addEventListener("abort", releaseOnAbort, { once: true });
   const persistHealth = async (next) => {
     await deps.store.credentials.saveHealth([next]);
   };
@@ -41406,184 +41693,196 @@ async function dispatch(request2, deps, signal, requestId) {
             break;
           }
           const candidate = candidates[i];
-          log.attempts = i + 1;
-          log.credentialId = candidate.credential.id;
-          log.resolvedProvider = candidate.target.provider;
-          log.resolvedModel = candidate.target.model;
-          await deps.onRoute?.({
-            provider: candidate.target.provider,
-            model: candidate.target.model,
-            credentialId: candidate.credential.id
-          });
-          logger2.debug("attempt started", {
-            requestId,
-            provider: candidate.target.provider,
-            model: candidate.target.model,
-            credentialId: candidate.credential.id,
-            attempt: i + 1
-          });
-          log.inputTokens = 0;
-          log.outputTokens = 0;
-          log.cacheReadTokens = 0;
-          log.cacheWriteTokens = 0;
-          log.ttftMs = null;
-          let committed = false;
-          let authRefreshRetried = false;
-          let retrySecrets;
-          const attemptNow = deps.now();
-          const preemptiveRefreshRequired = candidate.credential.authType === "oauth" && candidate.credential.expiresAt !== null && candidate.credential.expiresAt - DISPATCH_REFRESH_LEAD_MS <= attemptNow;
-          while (true) {
-            try {
-              const result = await waitForCancellation(attempt({
-                candidate,
-                request: dispatchRequest,
-                adapter: deps.adapters[candidate.target.provider],
-                http: deps.http,
-                now: attemptNow,
-                signal: dispatchSignal,
-                refresh: (credential) => waitForCancellation(deps.refresh(credential), dispatchSignal),
-                refreshLeadMs: DISPATCH_REFRESH_LEAD_MS,
-                ...retrySecrets === undefined ? {} : { secrets: retrySecrets },
-                logger: logger2,
-                requestId
-              }), dispatchSignal);
-              for (const d of result.degradations)
-                log.degradations.push(d);
-              let terminal = false;
-              const pending = [];
-              for await (const event of result.events) {
-                if (event.type === "blockDelta" && !committed) {
-                  committed = true;
-                  log.ttftMs = deps.now() - startedAt;
-                  logger2.debug("stream committed", {
+          const adoptable = eagerHeld && eager.credentialId === candidate.credential.id && eager.model === candidate.target.model;
+          if (adoptable)
+            eagerHeld = false;
+          const releaseSlot = adoptable ? eager.release : deps.loadRegistry.acquire(candidate.credential.id, candidate.target.model);
+          try {
+            log.attempts = i + 1;
+            log.credentialId = candidate.credential.id;
+            log.resolvedProvider = candidate.target.provider;
+            log.resolvedModel = candidate.target.model;
+            await deps.onRoute?.({
+              provider: candidate.target.provider,
+              model: candidate.target.model,
+              credentialId: candidate.credential.id
+            });
+            logger2.debug("attempt started", {
+              requestId,
+              provider: candidate.target.provider,
+              model: candidate.target.model,
+              credentialId: candidate.credential.id,
+              attempt: i + 1
+            });
+            log.inputTokens = 0;
+            log.outputTokens = 0;
+            log.cacheReadTokens = 0;
+            log.cacheWriteTokens = 0;
+            log.ttftMs = null;
+            let committed = false;
+            let authRefreshRetried = false;
+            let retrySecrets;
+            const attemptNow = deps.now();
+            const preemptiveRefreshRequired = candidate.credential.authType === "oauth" && candidate.credential.expiresAt !== null && candidate.credential.expiresAt - DISPATCH_REFRESH_LEAD_MS <= attemptNow;
+            const adapter = deps.adapters[candidate.target.provider];
+            if (adapter === undefined) {
+              throw new GatewayError("INTERNAL", `no adapter for provider ${candidate.target.provider}`);
+            }
+            while (true) {
+              try {
+                const result = await waitForCancellation(attempt({
+                  candidate,
+                  request: dispatchRequest,
+                  adapter,
+                  http: deps.http,
+                  now: attemptNow,
+                  signal: dispatchSignal,
+                  refresh: (credential) => waitForCancellation(deps.refresh(credential), dispatchSignal),
+                  refreshLeadMs: DISPATCH_REFRESH_LEAD_MS,
+                  ...retrySecrets === undefined ? {} : { secrets: retrySecrets },
+                  logger: logger2,
+                  requestId
+                }), dispatchSignal);
+                for (const d of result.degradations)
+                  log.degradations.push(d);
+                let terminal = false;
+                const pending = [];
+                for await (const event of result.events) {
+                  if (event.type === "blockDelta" && !committed) {
+                    committed = true;
+                    log.ttftMs = deps.now() - startedAt;
+                    logger2.debug("stream committed", {
+                      requestId,
+                      provider: candidate.target.provider,
+                      model: candidate.target.model,
+                      credentialId: candidate.credential.id,
+                      attempt: i + 1,
+                      ttftMs: log.ttftMs
+                    });
+                    for (const buffered of pending)
+                      yield buffered;
+                    pending.length = 0;
+                  }
+                  if (event.type === "end") {
+                    terminal = true;
+                    log.inputTokens = event.usage.inputTokens;
+                    log.outputTokens = event.usage.outputTokens;
+                    log.cacheReadTokens = event.usage.cacheReadTokens;
+                    log.cacheWriteTokens = event.usage.cacheWriteTokens;
+                    log.costUsd = priceOf(candidate.target.costPerMTok, event.usage, candidate.target.provider);
+                  }
+                  if (event.type === "error") {
+                    terminal = true;
+                    if (!committed && RETRYABLE[event.code]) {
+                      throw new GatewayError(event.code, event.message);
+                    }
+                    committed = true;
+                    yield event;
+                    await persistHealth(recordFailure(healthFor(candidate), {
+                      settings: snapshot.settings,
+                      now: deps.now(),
+                      code: event.code,
+                      jitter: deps.rand()
+                    }));
+                    log.status = HTTP_STATUS[event.code];
+                    log.errorCode = event.code;
+                    log.durationMs = deps.now() - startedAt;
+                    return;
+                  }
+                  if (!committed && event.type !== "end") {
+                    pending.push(event);
+                  } else {
+                    if (!committed) {
+                      for (const buffered of pending)
+                        yield buffered;
+                      pending.length = 0;
+                    }
+                    yield event;
+                  }
+                  if (event.type === "end")
+                    break;
+                }
+                if (!terminal) {
+                  throw new GatewayError("UPSTREAM", "upstream stream ended without a terminal event");
+                }
+                await persistHealth(recordSuccess(healthFor(candidate), {
+                  settings: snapshot.settings,
+                  now: deps.now(),
+                  ttftMs: log.ttftMs
+                }));
+                log.status = 200;
+                log.errorCode = null;
+                log.durationMs = deps.now() - startedAt;
+                return;
+              } catch (error51) {
+                if (signal.aborted)
+                  throw signal.reason;
+                const classifiedError = deadlineAt !== null && dispatchSignal.aborted ? { code: "TIMEOUT" } : classify(error51);
+                const { code: code2, retryAfterMs } = classifiedError;
+                const message = error51 instanceof Error ? error51.message : "attempt failed";
+                lastError = retryAfterMs === undefined ? new GatewayError(code2, message) : new GatewayError(code2, message, { retryAfterMs });
+                if (code2 === "AUTH" && !committed && !authRefreshRetried && !preemptiveRefreshRequired && candidate.credential.authType === "oauth" && candidate.credential.hasRefreshToken) {
+                  authRefreshRetried = true;
+                  logger2.warn("attempt authentication failed; refreshing credential", {
                     requestId,
                     provider: candidate.target.provider,
                     model: candidate.target.model,
                     credentialId: candidate.credential.id,
                     attempt: i + 1,
-                    ttftMs: log.ttftMs
+                    code: code2
                   });
-                  for (const buffered of pending)
-                    yield buffered;
-                  pending.length = 0;
+                  try {
+                    retrySecrets = await waitForCancellation(deps.refresh(candidate.credential), dispatchSignal);
+                    continue;
+                  } catch (refreshError) {
+                    if (signal.aborted)
+                      throw signal.reason;
+                    const classified = deadlineAt !== null && dispatchSignal.aborted ? { code: "TIMEOUT" } : classify(refreshError);
+                    const refreshMessage = refreshError instanceof Error ? refreshError.message : "credential refresh failed";
+                    lastError = classified.retryAfterMs === undefined ? new GatewayError(classified.code, refreshMessage) : new GatewayError(classified.code, refreshMessage, {
+                      retryAfterMs: classified.retryAfterMs
+                    });
+                  }
                 }
-                if (event.type === "end") {
-                  terminal = true;
-                  log.inputTokens = event.usage.inputTokens;
-                  log.outputTokens = event.usage.outputTokens;
-                  log.cacheReadTokens = event.usage.cacheReadTokens;
-                  log.cacheWriteTokens = event.usage.cacheWriteTokens;
-                  log.costUsd = priceOf(candidate.target.costPerMTok, event.usage, candidate.target.provider);
+                const failure = lastError;
+                await persistHealth(recordFailure(healthFor(candidate), {
+                  settings: snapshot.settings,
+                  now: deps.now(),
+                  code: failure.code,
+                  ...failure.retryAfterMs === undefined ? {} : { retryAfterMs: failure.retryAfterMs },
+                  jitter: deps.rand()
+                }));
+                if (!committed && RETRYABLE[failure.code] && i + 1 < maxAttempts) {
+                  logger2.warn("attempt failed; retrying", {
+                    requestId,
+                    provider: candidate.target.provider,
+                    model: candidate.target.model,
+                    credentialId: candidate.credential.id,
+                    attempt: i + 1,
+                    code: failure.code,
+                    retryable: true,
+                    retryAfterMs: failure.retryAfterMs
+                  });
                 }
-                if (event.type === "error") {
-                  terminal = true;
-                  if (!committed && RETRYABLE[event.code]) {
-                    throw new GatewayError(event.code, event.message);
-                  }
-                  committed = true;
-                  yield event;
-                  await persistHealth(recordFailure(healthFor(candidate), {
-                    settings: snapshot.settings,
-                    now: deps.now(),
-                    code: event.code,
-                    jitter: deps.rand()
-                  }));
-                  log.status = HTTP_STATUS[event.code];
-                  log.errorCode = event.code;
+                if (committed) {
+                  log.status = HTTP_STATUS[failure.code];
+                  log.errorCode = failure.code;
                   log.durationMs = deps.now() - startedAt;
+                  yield {
+                    type: "error",
+                    code: failure.code,
+                    message: failure.message,
+                    retryable: false
+                  };
                   return;
                 }
-                if (!committed && event.type !== "end") {
-                  pending.push(event);
-                } else {
-                  if (!committed) {
-                    for (const buffered of pending)
-                      yield buffered;
-                    pending.length = 0;
-                  }
-                  yield event;
-                }
-                if (event.type === "end")
-                  break;
-              }
-              if (!terminal) {
-                throw new GatewayError("UPSTREAM", "upstream stream ended without a terminal event");
-              }
-              await persistHealth(recordSuccess(healthFor(candidate), {
-                settings: snapshot.settings,
-                now: deps.now(),
-                ttftMs: log.ttftMs
-              }));
-              log.status = 200;
-              log.errorCode = null;
-              log.durationMs = deps.now() - startedAt;
-              return;
-            } catch (error51) {
-              if (signal.aborted)
-                throw signal.reason;
-              const classifiedError = deadlineAt !== null && dispatchSignal.aborted ? { code: "TIMEOUT" } : classify(error51);
-              const { code: code2, retryAfterMs } = classifiedError;
-              const message = error51 instanceof Error ? error51.message : "attempt failed";
-              lastError = retryAfterMs === undefined ? new GatewayError(code2, message) : new GatewayError(code2, message, { retryAfterMs });
-              if (code2 === "AUTH" && !committed && !authRefreshRetried && !preemptiveRefreshRequired && candidate.credential.authType === "oauth" && candidate.credential.hasRefreshToken) {
-                authRefreshRetried = true;
-                logger2.warn("attempt authentication failed; refreshing credential", {
-                  requestId,
-                  provider: candidate.target.provider,
-                  model: candidate.target.model,
-                  credentialId: candidate.credential.id,
-                  attempt: i + 1,
-                  code: code2
-                });
-                try {
-                  retrySecrets = await waitForCancellation(deps.refresh(candidate.credential), dispatchSignal);
-                  continue;
-                } catch (refreshError) {
-                  if (signal.aborted)
-                    throw signal.reason;
-                  const classified = deadlineAt !== null && dispatchSignal.aborted ? { code: "TIMEOUT" } : classify(refreshError);
-                  const refreshMessage = refreshError instanceof Error ? refreshError.message : "credential refresh failed";
-                  lastError = classified.retryAfterMs === undefined ? new GatewayError(classified.code, refreshMessage) : new GatewayError(classified.code, refreshMessage, {
-                    retryAfterMs: classified.retryAfterMs
-                  });
-                }
-              }
-              const failure = lastError;
-              await persistHealth(recordFailure(healthFor(candidate), {
-                settings: snapshot.settings,
-                now: deps.now(),
-                code: failure.code,
-                ...failure.retryAfterMs === undefined ? {} : { retryAfterMs: failure.retryAfterMs },
-                jitter: deps.rand()
-              }));
-              if (!committed && RETRYABLE[failure.code] && i + 1 < maxAttempts) {
-                logger2.warn("attempt failed; retrying", {
-                  requestId,
-                  provider: candidate.target.provider,
-                  model: candidate.target.model,
-                  credentialId: candidate.credential.id,
-                  attempt: i + 1,
-                  code: failure.code,
-                  retryable: true,
-                  retryAfterMs: failure.retryAfterMs
-                });
-              }
-              if (committed) {
-                log.status = HTTP_STATUS[failure.code];
-                log.errorCode = failure.code;
-                log.durationMs = deps.now() - startedAt;
-                yield {
-                  type: "error",
-                  code: failure.code,
-                  message: failure.message,
-                  retryable: false
-                };
-                return;
+                if (!RETRYABLE[failure.code])
+                  break candidateLoop;
+                continue candidateLoop;
               }
-              if (!RETRYABLE[failure.code])
-                break candidateLoop;
-              continue candidateLoop;
             }
+          } finally {
+            releaseSlot();
           }
         }
       const code = lastError?.code === "TIMEOUT" ? "TIMEOUT" : lastError !== null && !RETRYABLE[lastError.code] ? lastError.code : "ALL_CANDIDATES_FAILED";
@@ -41598,11 +41897,40 @@ async function dispatch(request2, deps, signal, requestId) {
       };
     } finally {
       clearDeadline();
+      eager.release();
       if (!dispatchController.signal.aborted)
         dispatchController.abort();
     }
   }
-  return { events: run(), log: () => log };
+  const inner = run();
+  const events = {
+    next: (...args) => inner.next(...args),
+    return: async (value) => {
+      try {
+        return await inner.return(value);
+      } finally {
+        eager.release();
+      }
+    },
+    throw: async (error51) => {
+      try {
+        return await inner.throw(error51);
+      } finally {
+        eager.release();
+      }
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async[Symbol.asyncDispose]() {
+      try {
+        await inner[Symbol.asyncDispose]();
+      } finally {
+        eager.release();
+      }
+    }
+  };
+  return { events, log: () => log };
 }
 function waitForCancellation(promise2, signal) {
   if (signal.aborted)
@@ -41620,6 +41948,35 @@ function waitForCancellation(promise2, signal) {
   });
 }
 
+// apps/gateway/src/dispatch/loadRegistry.ts
+function createLoadRegistry(logger2 = noopLogger) {
+  const counts = new Map;
+  return {
+    acquire(credentialId, model) {
+      const key = healthKey(credentialId, model);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        const next = (counts.get(key) ?? 0) - 1;
+        if (next > 0) {
+          counts.set(key, next);
+          return;
+        }
+        if (next < 0) {
+          logger2.warn("load registry released more than it acquired", { credentialId });
+        }
+        counts.delete(key);
+      };
+    },
+    counts() {
+      return new Map(counts);
+    }
+  };
+}
+
 // apps/gateway/src/egress/anthropic.ts
 var STOP_REASON2 = {
   endTurn: "end_turn",
@@ -41635,6 +41992,7 @@ var ERROR_TYPE2 = {
   QUOTA_EXHAUSTED: "rate_limit_error",
   OVERLOADED: "overloaded_error",
   BAD_REQUEST: "invalid_request_error",
+  CONFLICT: "invalid_request_error",
   CONTENT_FILTER: "invalid_request_error",
   CAPABILITY_MISMATCH: "invalid_request_error",
   MODEL_UNAVAILABLE: "not_found_error",
@@ -41797,6 +42155,7 @@ var ERROR_TYPE3 = {
   QUOTA_EXHAUSTED: { type: "insufficient_quota", code: "insufficient_quota" },
   OVERLOADED: { type: "server_error", code: "server_error" },
   BAD_REQUEST: { type: "invalid_request_error", code: "invalid_request" },
+  CONFLICT: { type: "invalid_request_error", code: "conflict" },
   CONTENT_FILTER: { type: "invalid_request_error", code: "content_policy_violation" },
   CAPABILITY_MISMATCH: { type: "invalid_request_error", code: "invalid_request" },
   MODEL_UNAVAILABLE: { type: "invalid_request_error", code: "model_not_found" },
@@ -42087,12 +42446,12 @@ function mcpServerNames(body2) {
 
 // apps/gateway/src/ingress/model.ts
 var DISCOVERY_PREFIX = "claude/";
-var ONE_M_SUFFIX = "[1m]";
+var ONE_M_SUFFIX2 = "[1m]";
 function normalizeClientModel(raw, betas2 = []) {
   let model = raw.trim();
   let wantsOneM = false;
-  if (model.toLowerCase().endsWith(ONE_M_SUFFIX)) {
-    const stripped = model.slice(0, -ONE_M_SUFFIX.length).trim();
+  if (model.toLowerCase().endsWith(ONE_M_SUFFIX2)) {
+    const stripped = model.slice(0, -ONE_M_SUFFIX2.length).trim();
     if (stripped.length > 0) {
       model = stripped;
       wantsOneM = true;
@@ -42443,10 +42802,10 @@ function toIrToolChoice(c) {
 }
 var EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 function readEffort(body2) {
-  if (!isRecord3(body2))
+  if (!isRecord4(body2))
     return;
   const outputConfig = body2.output_config;
-  if (!isRecord3(outputConfig))
+  if (!isRecord4(outputConfig))
     return;
   const effort = outputConfig.effort;
   return EFFORTS.find((level) => level === effort);
@@ -42780,7 +43139,7 @@ function asGatewayError(error51) {
     return error51;
   return new GatewayError("INTERNAL", error51 instanceof Error ? error51.message : "internal error");
 }
-function sseResponse(frames, onDone, keepaliveMs) {
+function sseResponse(frames, onDone, keepaliveMs, source) {
   const encoder2 = new TextEncoder;
   let done = null;
   const runOnce = (cancelled = false) => {
@@ -42818,6 +43177,7 @@ data: ${data}
     },
     async cancel() {
       await frames.return(undefined);
+      await source.return(undefined);
       await runOnce(true);
     }
   });
@@ -42895,7 +43255,7 @@ async function handle(deps, rateLimiter, surface, request2) {
     };
     if (chatRequest.stream) {
       const frames = surface === "anthropic" ? anthropicStream(outcome.events, requestId) : openaiStream(outcome.events, requestId, Math.floor(deps.now() / 1000));
-      return sseResponse(frames, log, deps.keepaliveMs);
+      return sseResponse(frames, log, deps.keepaliveMs, outcome.events);
     }
     const events = [];
     for await (const event of outcome.events)
@@ -42936,6 +43296,7 @@ function proxyRoutes(deps) {
     ...deps,
     logger: logger2,
     snapshots: deps.snapshots ?? createRoutingSnapshotCache(deps.store, logger2),
+    loadRegistry: deps.loadRegistry ?? createLoadRegistry(logger2),
     keepaliveMs: deps.keepaliveMs ?? KEEPALIVE_MS
   };
   return new Elysia().post("/v1/messages", ({ request: request2, server }) => {
@@ -43029,6 +43390,7 @@ function createApp(deps) {
     requestId,
     rateLimiter,
     logger: logger2,
+    ...deps.loadRegistry === undefined ? {} : { loadRegistry: deps.loadRegistry },
     discoveryMirrors: deps.discoveryMirrors === true
   })).use(adminRoutes({
     store: deps.store,