omnigateway 0.1.8 → 0.2.1

package/bin/omni.js

@@ -91,9 +91,8 @@ function formatUsd(value) {
 }
 
 // apps/cli/src/run.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3 } from "path";
 
 // packages/control/src/adminAuth.ts
 import { hash, verify } from "@node-rs/argon2";
@@ -153,10 +152,17 @@ function createAdminAuth(store, opts) {
   };
 }
 // packages/ir/src/capabilities.ts
+var ANTHROPIC_NATIVE_TOOLS = {
+  anthropic: true,
+  openai: 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 = {
@@ -170,6 +176,7 @@ var RETRYABLE = {
   TIMEOUT: true,
   NETWORK: true,
   BAD_REQUEST: false,
+  CONFLICT: false,
   CONTENT_FILTER: false,
   NO_CANDIDATES: false,
   ALL_CANDIDATES_FAILED: false,
@@ -236,6 +243,82 @@ function usageFromPromptTotal(promptTokens, outputTokens, cacheReadTokens, cache
     cacheWriteTokens
   };
 }
+// packages/ir/src/tokens.ts
+var CHARS_PER_TOKEN = 4;
+var IMAGE_TOKENS = 1600;
+var BLOCK_OVERHEAD = 4;
+var MESSAGE_OVERHEAD = 4;
+function fromText(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function blockTokens(block) {
+  switch (block.type) {
+    case "text":
+      return BLOCK_OVERHEAD + fromText(block.text);
+    case "image":
+      return BLOCK_OVERHEAD + IMAGE_TOKENS;
+    case "thinking":
+      return BLOCK_OVERHEAD + fromText(block.text);
+    case "toolUse":
+      return BLOCK_OVERHEAD + fromText(block.name) + fromText(safeJson(block.input));
+    case "toolResult":
+      return BLOCK_OVERHEAD + fromText(block.toolUseId) + fromText(block.content);
+    case "anthropicNative":
+      return BLOCK_OVERHEAD + fromText(block.blockType) + fromText(safeJson(block.data));
+  }
+}
+function messageTokens(message) {
+  let total = MESSAGE_OVERHEAD;
+  for (const block of message.content)
+    total += blockTokens(block);
+  return total;
+}
+function toolTokens(tool) {
+  if (tool.provider === "anthropic") {
+    return BLOCK_OVERHEAD + fromText(tool.name) + fromText(tool.type) + fromText(safeJson(tool.wire));
+  }
+  return BLOCK_OVERHEAD + fromText(tool.name) + fromText(tool.description ?? "") + fromText(safeJson(tool.inputSchema));
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function estimateInputTokens(request) {
+  let total = 0;
+  for (const block of request.system ?? [])
+    total += blockTokens(block);
+  for (const message of request.messages)
+    total += messageTokens(message);
+  for (const tool of request.tools ?? [])
+    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/control/src/config.ts
 var MIN_KEY_LENGTH = 16;
 var TRUTHY = new Set(["1", "true", "yes", "on"]);
@@ -310,7 +393,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 = {};
@@ -411,10 +495,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 = {
@@ -486,7 +580,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;
@@ -699,7 +794,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
@@ -759,14 +855,232 @@ function parseRecord(record) {
 `) };
 }
 
+// packages/providers/src/anthropic/tools.ts
+var COMMON = ["cache_control", "strict", "defer_loading", "allowed_callers"];
+var COMMON_WITH_EXAMPLES = [...COMMON, "input_examples"];
+var searchDomains = ["max_uses", "allowed_domains", "blocked_domains"];
+var ANTHROPIC_TOOL_SPECS = {
+  web_search_20250305: {
+    family: "webSearch",
+    name: "web_search",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "user_location"]
+  },
+  web_search_20260209: {
+    family: "webSearch",
+    name: "web_search",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "user_location"]
+  },
+  web_search_20260318: {
+    family: "webSearch",
+    name: "web_search",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "user_location", "response_inclusion"]
+  },
+  web_fetch_20250910: {
+    family: "webFetch",
+    name: "web_fetch",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "citations", "max_content_tokens"]
+  },
+  web_fetch_20260209: {
+    family: "webFetch",
+    name: "web_fetch",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "citations", "max_content_tokens"]
+  },
+  web_fetch_20260309: {
+    family: "webFetch",
+    name: "web_fetch",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "citations", "max_content_tokens", "use_cache"]
+  },
+  web_fetch_20260318: {
+    family: "webFetch",
+    name: "web_fetch",
+    required: [],
+    optional: [
+      ...COMMON,
+      ...searchDomains,
+      "citations",
+      "max_content_tokens",
+      "use_cache",
+      "response_inclusion"
+    ]
+  },
+  code_execution_20250522: {
+    family: "codeExecution",
+    name: "code_execution",
+    required: [],
+    optional: [...COMMON]
+  },
+  code_execution_20250825: {
+    family: "codeExecution",
+    name: "code_execution",
+    required: [],
+    optional: [...COMMON]
+  },
+  code_execution_20260120: {
+    family: "codeExecution",
+    name: "code_execution",
+    required: [],
+    optional: [...COMMON]
+  },
+  code_execution_20260521: {
+    family: "codeExecution",
+    name: "code_execution",
+    required: [],
+    optional: [...COMMON]
+  },
+  bash_20241022: {
+    family: "bash",
+    name: "bash",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  bash_20250124: {
+    family: "bash",
+    name: "bash",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  text_editor_20241022: {
+    family: "textEditor",
+    name: "str_replace_editor",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  text_editor_20250124: {
+    family: "textEditor",
+    name: "str_replace_editor",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  text_editor_20250429: {
+    family: "textEditor",
+    name: "str_replace_based_edit_tool",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  text_editor_20250728: {
+    family: "textEditor",
+    name: "str_replace_based_edit_tool",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES, "max_characters"]
+  },
+  computer_20241022: {
+    family: "computer",
+    name: "computer",
+    required: ["display_width_px", "display_height_px"],
+    optional: [...COMMON_WITH_EXAMPLES, "display_number"]
+  },
+  computer_20250124: {
+    family: "computer",
+    name: "computer",
+    required: ["display_width_px", "display_height_px"],
+    optional: [...COMMON_WITH_EXAMPLES, "display_number"]
+  },
+  computer_20251124: {
+    family: "computer",
+    name: "computer",
+    required: ["display_width_px", "display_height_px"],
+    optional: [...COMMON_WITH_EXAMPLES, "display_number", "enable_zoom"]
+  },
+  memory_20250818: {
+    family: "memory",
+    name: "memory",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  tool_search_tool_regex_20251119: {
+    family: "toolSearchRegex",
+    name: "tool_search_tool_regex",
+    required: [],
+    optional: [...COMMON]
+  },
+  tool_search_tool_regex: {
+    family: "toolSearchRegex",
+    name: "tool_search_tool_regex",
+    required: [],
+    optional: [...COMMON]
+  },
+  tool_search_tool_bm25_20251119: {
+    family: "toolSearchBm25",
+    name: "tool_search_tool_bm25",
+    required: [],
+    optional: [...COMMON]
+  },
+  tool_search_tool_bm25: {
+    family: "toolSearchBm25",
+    name: "tool_search_tool_bm25",
+    required: [],
+    optional: [...COMMON]
+  },
+  advisor_20260301: {
+    family: "advisor",
+    name: "advisor",
+    required: ["model"],
+    optional: [...COMMON, "caching", "max_uses", "max_tokens"]
+  },
+  mcp_toolset: {
+    family: "mcpToolset",
+    required: ["mcp_server_name"],
+    optional: ["cache_control", "configs", "default_config"]
+  }
+};
+var ANTHROPIC_NATIVE_BLOCK_TYPES = new Set([
+  "server_tool_use",
+  "web_search_tool_result",
+  "web_fetch_tool_result",
+  "code_execution_tool_result",
+  "bash_code_execution_tool_result",
+  "text_editor_code_execution_tool_result",
+  "mcp_tool_use",
+  "mcp_tool_result",
+  "tool_search_tool_result",
+  "tool_reference",
+  "advisor_tool_result",
+  "advisor_result",
+  "advisor_redacted_result",
+  "container_upload",
+  "compaction",
+  "search_result",
+  "document",
+  "mid_conv_system",
+  "tool_addition",
+  "tool_removal",
+  "fallback",
+  "redacted_thinking"
+]);
+
 // packages/providers/src/anthropic/decode.ts
 var STOP_REASON = {
   end_turn: "endTurn",
   max_tokens: "maxTokens",
   stop_sequence: "stopSequence",
   tool_use: "toolUse",
-  refusal: "contentFilter"
+  refusal: "contentFilter",
+  pause_turn: "pauseTurn"
 };
+var KNOWN_EVENTS = new Set([
+  "message_start",
+  "content_block_start",
+  "content_block_delta",
+  "content_block_stop",
+  "message_delta",
+  "message_stop",
+  "error",
+  "ping"
+]);
+var KNOWN_DELTAS = new Set([
+  "text_delta",
+  "thinking_delta",
+  "signature_delta",
+  "input_json_delta",
+  "citations_delta",
+  "compaction_delta"
+]);
 var ERROR_TYPE = {
   overloaded_error: "OVERLOADED",
   rate_limit_error: "RATE_LIMIT",
@@ -792,10 +1106,21 @@ async function* decodeAnthropic(messages) {
   let outputTokens = 0;
   let stopReason = "endTurn";
   let terminal = false;
+  const nativeBlocks = new Set;
+  const protocolError = (message) => ({
+    type: "error",
+    code: "UPSTREAM",
+    message,
+    retryable: false
+  });
   for await (const msg of messages) {
     const d = json(msg.data);
     if (d === null)
       continue;
+    if (!KNOWN_EVENTS.has(msg.event)) {
+      yield protocolError(`unrecognized Anthropic stream event "${msg.event}"`);
+      return;
+    }
     switch (msg.event) {
       case "message_start": {
         const m = d.message ?? {};
@@ -820,6 +1145,18 @@ async function* decodeAnthropic(messages) {
             index,
             block: { type: "toolUse", id: String(cb.id), name: String(cb.name) }
           };
+        else if (cb.type !== undefined && ANTHROPIC_NATIVE_BLOCK_TYPES.has(cb.type)) {
+          nativeBlocks.add(index);
+          const { type: _blockType, ...data } = cb;
+          yield {
+            type: "blockStart",
+            index,
+            block: { type: "anthropicNative", blockType: cb.type, data }
+          };
+        } else {
+          yield protocolError(`unrecognized Anthropic content block type "${String(cb.type)}"`);
+          return;
+        }
         break;
       }
       case "content_block_delta": {
@@ -843,17 +1180,51 @@ async function* decodeAnthropic(messages) {
           yield {
             type: "blockDelta",
             index,
-            delta: { type: "toolJson", partial: delta.partial_json ?? "" }
+            delta: nativeBlocks.has(index) ? { type: "anthropicNativeJson", partial: delta.partial_json ?? "" } : { type: "toolJson", partial: delta.partial_json ?? "" }
+          };
+        else if (delta.type === "citations_delta")
+          yield {
+            type: "blockDelta",
+            index,
+            delta: {
+              type: "anthropicNative",
+              deltaType: delta.type,
+              data: { citation: delta.citation }
+            }
           };
+        else if (delta.type === "compaction_delta")
+          yield {
+            type: "blockDelta",
+            index,
+            delta: {
+              type: "anthropicNative",
+              deltaType: delta.type,
+              data: {
+                ...delta.content === undefined ? {} : { content: delta.content },
+                ...delta.encrypted_content === undefined ? {} : { encrypted_content: delta.encrypted_content }
+              }
+            }
+          };
+        else if (delta.type === undefined || !KNOWN_DELTAS.has(delta.type)) {
+          yield protocolError(`unrecognized Anthropic content block delta "${String(delta.type)}"`);
+          return;
+        }
         break;
       }
       case "content_block_stop":
+        nativeBlocks.delete(d.index ?? 0);
         yield { type: "blockEnd", index: d.index ?? 0 };
         break;
       case "message_delta": {
         const reason = d.delta?.stop_reason;
-        if (typeof reason === "string")
-          stopReason = STOP_REASON[reason] ?? "endTurn";
+        if (typeof reason === "string") {
+          const mapped = STOP_REASON[reason];
+          if (mapped === undefined) {
+            yield protocolError(`unrecognized Anthropic stop reason "${reason}"`);
+            return;
+          }
+          stopReason = mapped;
+        }
         inputTokens = d.usage?.input_tokens ?? inputTokens;
         outputTokens = d.usage?.output_tokens ?? outputTokens;
         break;
@@ -912,7 +1283,12 @@ function encodeBlock(b) {
   const cache = wireCacheControl(cacheControlOf(b));
   switch (b.type) {
     case "text":
-      return { type: "text", text: b.text, ...cache };
+      return {
+        type: "text",
+        text: b.text,
+        ...b.citations === undefined ? {} : { citations: b.citations },
+        ...cache
+      };
     case "image":
       return {
         type: "image",
@@ -931,11 +1307,16 @@ function encodeBlock(b) {
         is_error: b.isError,
         ...cache
       };
+    case "anthropicNative":
+      return { ...b.data, type: b.blockType, ...cache };
   }
 }
 function encodeSystemTurn(content) {
-  return content.flatMap((b) => b.type === "text" ? [b.text] : []).join(`
+  if (content.every((block) => block.type === "text")) {
+    return content.map((block) => block.text).join(`
 `);
+  }
+  return content.map(encodeBlock);
 }
 function systemCacheControl(req) {
   const cacheable = req.messages.flatMap((message) => message.content.flatMap((block) => block.type === "thinking" ? [] : [{ role: message.role, block }]));
@@ -947,6 +1328,23 @@ function systemCacheControl(req) {
     lost: markedSystemBlocks.length > (promoted === undefined ? 0 : 1)
   };
 }
+function encodeTool(t) {
+  if (t.provider === "anthropic") {
+    return {
+      type: t.type,
+      ...t.name === "" ? {} : { name: t.name },
+      ...t.wire,
+      ...wireCacheControl(t.cacheControl)
+    };
+  }
+  return {
+    name: t.name,
+    ...t.description === undefined ? {} : { description: t.description },
+    input_schema: t.inputSchema,
+    ...t.options ?? {},
+    ...wireCacheControl(t.cacheControl)
+  };
+}
 function encodeToolChoice(c) {
   switch (c.type) {
     case "auto":
@@ -959,6 +1357,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, note2) {
+  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;
+  note2("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, note2) {
+  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;
+  note2("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 note2 = (d) => {
@@ -1001,25 +1438,27 @@ function toWire(req, model, opts) {
     body.temperature = req.temperature;
   if (req.stopSequences !== undefined)
     body.stop_sequences = req.stopSequences;
-  if (req.tools !== undefined) {
-    body.tools = req.tools.map((t) => ({
-      name: t.name,
-      ...t.description === undefined ? {} : { description: t.description },
-      input_schema: t.inputSchema,
-      ...wireCacheControl(t.cacheControl)
-    }));
-  }
+  if (req.tools !== undefined)
+    body.tools = req.tools.map(encodeTool);
   if (req.toolChoice !== undefined)
     body.tool_choice = encodeToolChoice(req.toolChoice);
   if (req.reasoning !== undefined) {
     switch (req.reasoning.mode) {
       case "adaptive":
+        if (anthropicReasoningForm(model) === "budget") {
+          body.thinking = { type: "disabled" };
+          note2("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":
@@ -1030,7 +1469,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, note2) : vendor);
+  stripUnsupportedEdits(body, note2);
   return { body, degradations };
 }
 
@@ -1094,115 +1535,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",
@@ -1313,7 +1645,7 @@ function encodeToolChoice2(c) {
       return { type: "function", function: { name: c.name } };
   }
 }
-function toChatWire(req, model) {
+function toChatWire(req, model, vendor = "kimi") {
   const degradations = [];
   const note2 = (d) => {
     if (!degradations.includes(d))
@@ -1355,6 +1687,9 @@ function toChatWire(req, model) {
             content: block.content
           });
           break;
+        case "anthropicNative":
+          note2("kimi:anthropic-native-block-dropped");
+          break;
       }
     }
     if (toolCalls.length > 0) {
@@ -1382,7 +1717,10 @@ function toChatWire(req, model) {
   if (req.stopSequences !== undefined)
     body.stop = req.stopSequences;
   if (req.tools !== undefined) {
-    body.tools = req.tools.map((t) => ({
+    const custom = req.tools.filter((t) => t.provider === "custom");
+    if (custom.length !== req.tools.length)
+      note2("kimi:anthropic-tool-dropped");
+    body.tools = custom.map((t) => ({
       type: "function",
       function: { name: t.name, description: t.description, parameters: t.inputSchema }
     }));
@@ -1391,44 +1729,10 @@ function toChatWire(req, model) {
     body.tool_choice = encodeToolChoice2(req.toolChoice);
   if (req.reasoning !== undefined)
     note2("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",
@@ -1649,6 +1953,9 @@ ${block.text}
             output: block.content
           });
           break;
+        case "anthropicNative":
+          note2("openai:anthropic-native-block-dropped");
+          break;
       }
     }
     flush();
@@ -1672,7 +1979,10 @@ ${block.text}
       body.temperature = req.temperature;
   }
   if (req.tools !== undefined) {
-    body.tools = req.tools.map((t) => ({
+    const custom = req.tools.filter((t) => t.provider === "custom");
+    if (custom.length !== req.tools.length)
+      note2("openai:anthropic-tool-dropped");
+    body.tools = custom.map((t) => ({
       type: "function",
       name: t.name,
       description: t.description,
@@ -1693,11 +2003,195 @@ ${block.text}
     if (req.reasoning.mode === "budget") {
       degradations.push("openai:reasoning-budget-dropped");
     }
-  }
-  Object.assign(body, req.vendor?.openai ?? {});
-  return { body, degradations };
+  }
+  Object.assign(body, req.vendor?.openai ?? {});
+  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";
@@ -1910,11 +2404,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];
@@ -2117,7 +2611,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);
@@ -2158,6 +2652,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({
@@ -2201,6 +2697,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 });
@@ -13453,12 +13952,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 = () => {};
@@ -16590,20 +17089,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(),
@@ -16621,7 +17136,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"),
@@ -16635,14 +17158,15 @@ 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().positive(),
+  requestDeadlineMs: exports_external.number().int().min(0),
   breakerThreshold: exports_external.number().int().min(1),
   breakerCooldownMs: exports_external.number().int().positive(),
   logRetentionDays: exports_external.number().int().min(1),
-  quotaPollIntervalMs: exports_external.number().int().min(0)
+  quotaPollIntervalMs: exports_external.number().int().min(0),
+  rtkEnabled: exports_external.boolean()
 });
 var credentialPatchSchema = exports_external.object({
   label: exports_external.string().min(1).optional(),
@@ -16699,14 +17223,48 @@ async function getCredential(store, id) {
     throw new GatewayError("BAD_REQUEST", "no such credential");
   return summarizeCredential(credential);
 }
+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);
-  if (typeof input.apiKey !== "string" || input.apiKey.trim().length === 0) {
-    throw new GatewayError("BAD_REQUEST", "apiKey: must not be empty");
-  }
+  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(),
@@ -16718,12 +17276,12 @@ async function createApiKeyCredential(store, input, logger2 = noopLogger) {
     weight: 1,
     expiresAt: null,
     accountEmail: null,
-    providerData: {},
+    providerData,
     disabledReason: null,
     disabledAt: null,
     accessToken: null,
     refreshToken: null,
-    apiKey: input.apiKey,
+    apiKey,
     idToken: null
   });
   logger2.info("credential added", { credentialId: created.id, provider: created.provider });
@@ -16829,6 +17387,11 @@ async function buildSnapshot(store, now) {
 }
 
 // packages/router/src/filters.ts
+function needsAnthropicNative(request2) {
+  if (request2.tools?.some((t) => t.provider === "anthropic") === true)
+    return true;
+  return request2.messages.some((m) => m.content.some((b) => b.type === "anthropicNative"));
+}
 function requiredCapabilities(request2) {
   const images = request2.messages.some((m) => m.content.some((b) => b.type === "image"));
   return {
@@ -16845,13 +17408,17 @@ function eligible(input) {
   const { request: request2, model, snapshot, now } = input;
   const { breakerThreshold, breakerCooldownMs } = snapshot.settings;
   const need = requiredCapabilities(request2);
+  const needNative = needsAnthropicNative(request2);
   const pairs = [];
   const excluded = [];
   for (const target of model.targets) {
-    const missing = ["tools", "images", "reasoning"].find((cap) => need[cap] && !target.capabilities[cap]);
+    const missing = needNative && !ANTHROPIC_NATIVE_TOOLS[target.provider] ? "anthropicTools" : ["tools", "images", "reasoning"].find((cap) => need[cap] && !target.capabilities[cap]);
     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 });
       };
@@ -16923,6 +17490,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) {
@@ -16930,43 +17513,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,
@@ -16979,8 +17568,8 @@ function score(pairs, input) {
 var PROVIDERS = new Set(Object.keys(PROVIDER_CAPABILITIES));
 
 // 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);
@@ -17003,6 +17592,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);
@@ -17013,11 +17604,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;
@@ -17043,10 +17634,14 @@ async function dryRun(deps, modelId, input) {
       }
     ],
     stream: false,
-    ...need.tools ? { tools: [{ name: "probe", description: "", inputSchema: { type: "object" } }] } : {},
+    ...need.tools ? {
+      tools: [
+        { provider: "custom", name: "probe", description: "", inputSchema: { type: "object" } }
+      ]
+    } : {},
     ...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,
@@ -17103,20 +17698,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
-};
-
 // 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, emit2 = () => {}) {
   const readRaw = (key) => db.query("SELECT value FROM settings WHERE key = ?").get(key)?.value ?? null;
   const writeRaw = (key, value) => {
@@ -17147,12 +17746,18 @@ function createConfigRepo(db, emit2 = () => {}) {
       const raw = readRaw(SETTINGS_KEY);
       if (raw === null)
         return DEFAULT_SETTINGS;
-      const stored = JSON.parse(raw);
-      return {
-        ...DEFAULT_SETTINGS,
-        ...stored,
-        weights: { ...DEFAULT_SETTINGS.weights, ...stored.weights }
-      };
+      try {
+        const parsed = JSON.parse(raw);
+        const stored = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+        return {
+          ...DEFAULT_SETTINGS,
+          ...stored,
+          rtkEnabled: stored.rtkEnabled === true,
+          weights: knownWeights(stored.weights)
+        };
+      } catch {
+        return DEFAULT_SETTINGS;
+      }
     },
     async putSettings(patch) {
       const current = await this.getSettings();
@@ -17594,6 +18199,20 @@ ALTER TABLE request_logs ADD COLUMN state TEXT NOT NULL DEFAULT 'done';
 CREATE INDEX idx_request_logs_pending ON request_logs(state) WHERE state = 'pending';
 `;
 
+// packages/store/src/sqlite/migrations/005_rtk_metrics.sql
+var _005_rtk_metrics_default = `ALTER TABLE request_logs ADD COLUMN rtk_applied INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_filter_hits INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_original_code_units INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_compressed_code_units INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_estimated_tokens_saved INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_filters TEXT NOT NULL DEFAULT '[]';
+`;
+
+// packages/store/src/sqlite/migrations/006_rtk_usage.sql
+var _006_rtk_usage_default = `ALTER TABLE usage_daily ADD COLUMN rtk_saved_tokens INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE usage_daily ADD COLUMN rtk_applied_requests INTEGER NOT NULL DEFAULT 0;
+`;
+
 // packages/store/src/sqlite/rollup.ts
 function startOfLocalDay(at) {
   const day = new Date(at);
@@ -17604,8 +18223,8 @@ var UPSERT = `
   INSERT INTO usage_daily
     (day, provider, credential_id, requested_model, resolved_model, api_key_id,
      requests, errors, input_tokens, output_tokens, cache_read_tokens,
-     cache_write_tokens, cost_usd, duration_ms_sum)
-  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+     cache_write_tokens, rtk_saved_tokens, rtk_applied_requests, cost_usd, duration_ms_sum)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
   ON CONFLICT (day, provider, credential_id, requested_model, resolved_model, api_key_id)
   DO UPDATE SET
     requests           = requests + excluded.requests,
@@ -17613,8 +18232,10 @@ var UPSERT = `
     input_tokens       = input_tokens + excluded.input_tokens,
     output_tokens      = output_tokens + excluded.output_tokens,
     cache_read_tokens  = cache_read_tokens + excluded.cache_read_tokens,
-    cache_write_tokens = cache_write_tokens + excluded.cache_write_tokens,
-    cost_usd           = cost_usd + excluded.cost_usd,
+    cache_write_tokens    = cache_write_tokens + excluded.cache_write_tokens,
+    rtk_saved_tokens      = rtk_saved_tokens + excluded.rtk_saved_tokens,
+    rtk_applied_requests  = rtk_applied_requests + excluded.rtk_applied_requests,
+    cost_usd              = cost_usd + excluded.cost_usd,
     duration_ms_sum    = duration_ms_sum + excluded.duration_ms_sum`;
 function keyOf(log) {
   return [
@@ -17634,6 +18255,8 @@ function countersOf(log) {
     outputTokens: log.outputTokens,
     cacheReadTokens: log.cacheReadTokens,
     cacheWriteTokens: log.cacheWriteTokens,
+    rtkSavedTokens: log.rtkEstimatedTokensSaved,
+    rtkAppliedRequests: log.rtkApplied ? 1 : 0,
     costUsd: log.costUsd,
     durationMsSum: log.durationMs
   };
@@ -17647,6 +18270,8 @@ function upsert(db, key, c) {
     c.outputTokens,
     c.cacheReadTokens,
     c.cacheWriteTokens,
+    c.rtkSavedTokens,
+    c.rtkAppliedRequests,
     c.costUsd,
     c.durationMsSum
   ]);
@@ -17677,6 +18302,8 @@ function backfillDaily(db) {
       outputTokens: 0,
       cacheReadTokens: 0,
       cacheWriteTokens: 0,
+      rtkSavedTokens: 0,
+      rtkAppliedRequests: 0,
       costUsd: 0,
       durationMsSum: 0
     };
@@ -17695,13 +18322,42 @@ function backfillDaily(db) {
     upsert(db, group.key, group.counters);
   return groups.size;
 }
+function backfillRtkUsage(db) {
+  const groups = new Map;
+  for (const row of db.query(`SELECT at, api_key_id, requested_model, resolved_provider, resolved_model, credential_id,
+              rtk_applied, rtk_estimated_tokens_saved
+         FROM request_logs
+        WHERE state = 'done'`).all()) {
+    const key = [
+      startOfLocalDay(row.at),
+      row.resolved_provider ?? "",
+      row.credential_id ?? "",
+      row.requested_model,
+      row.resolved_model ?? "",
+      row.api_key_id ?? ""
+    ];
+    const id = key.join("\x00");
+    const group = groups.get(id) ?? { key, saved: 0, applied: 0 };
+    group.saved += row.rtk_estimated_tokens_saved;
+    group.applied += row.rtk_applied === 1 ? 1 : 0;
+    groups.set(id, group);
+  }
+  for (const { key, saved, applied } of groups.values()) {
+    db.run(`UPDATE usage_daily
+          SET rtk_saved_tokens = ?, rtk_applied_requests = ?
+        WHERE day = ? AND provider = ? AND credential_id = ? AND requested_model = ?
+          AND resolved_model = ? AND api_key_id = ?`, [saved, applied, ...key]);
+  }
+}
 
 // packages/store/src/sqlite/db.ts
 var MIGRATIONS = [
   { id: 1, sql: _001_init_default },
   { id: 2, sql: _002_usage_daily_default, after: backfillDaily },
   { id: 3, sql: _003_quota_snapshot_default },
-  { id: 4, sql: _004_request_state_default }
+  { id: 4, sql: _004_request_state_default },
+  { id: 5, sql: _005_rtk_metrics_default },
+  { id: 6, sql: _006_rtk_usage_default, after: backfillRtkUsage }
 ];
 function openDb(path) {
   const db = new Database(path, { create: true });
@@ -17770,7 +18426,38 @@ function createKeyRepo(db) {
     }
   };
 }
+// packages/rtk/src/catalog.ts
+var RTK_FILTER_IDS = [
+  "git-diff",
+  "git-status",
+  "git-log",
+  "grep",
+  "path-list",
+  "numbered-read",
+  "build-output",
+  "test-output",
+  "deduplicate-log",
+  "smart-truncate",
+  "lint-output",
+  "package-output",
+  "tree-output",
+  "git-operation",
+  "docker-build"
+];
+var FILTER_IDS = new Set(RTK_FILTER_IDS);
+function isRtkFilterId(value) {
+  return FILTER_IDS.has(value);
+}
+
 // packages/store/src/sqlite/usage.ts
+function parseRtkFilters(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter(isRtkFilterId) : [];
+  } catch {
+    return [];
+  }
+}
 var toLog = (r) => ({
   id: r.id,
   state: r.state === "pending" ? "pending" : "done",
@@ -17790,7 +18477,13 @@ var toLog = (r) => ({
   ttftMs: r.ttft_ms,
   durationMs: r.duration_ms,
   costUsd: r.cost_usd,
-  degradations: JSON.parse(r.degradations)
+  degradations: JSON.parse(r.degradations),
+  rtkApplied: r.rtk_applied === 1,
+  rtkFilterHits: r.rtk_filter_hits,
+  rtkOriginalCodeUnits: r.rtk_original_code_units,
+  rtkCompressedCodeUnits: r.rtk_compressed_code_units,
+  rtkEstimatedTokensSaved: r.rtk_estimated_tokens_saved,
+  rtkFilters: parseRtkFilters(r.rtk_filters)
 });
 var GROUP_COLUMN = {
   raw: {
@@ -17835,8 +18528,9 @@ function label(value) {
 var COLUMNS = `(id, state, at, api_key_id, requested_model, resolved_provider, resolved_model,
                   credential_id, attempts, status, error_code, input_tokens, output_tokens,
                   cache_read_tokens, cache_write_tokens, ttft_ms, duration_ms, cost_usd,
-                  degradations)`;
-var PLACEHOLDERS = "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
+                  degradations, rtk_applied, rtk_filter_hits, rtk_original_code_units,
+                  rtk_compressed_code_units, rtk_estimated_tokens_saved, rtk_filters)`;
+var PLACEHOLDERS = "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
 function values(log, state) {
   return [
     log.id,
@@ -17857,7 +18551,13 @@ function values(log, state) {
     log.ttftMs,
     log.durationMs,
     log.costUsd,
-    JSON.stringify(log.degradations)
+    JSON.stringify(log.degradations),
+    log.rtkApplied === true ? 1 : 0,
+    log.rtkFilterHits ?? 0,
+    log.rtkOriginalCodeUnits ?? 0,
+    log.rtkCompressedCodeUnits ?? 0,
+    log.rtkEstimatedTokensSaved ?? 0,
+    JSON.stringify(log.rtkFilters ?? [])
   ];
 }
 var COMPLETE = `INSERT INTO request_logs ${COLUMNS} VALUES ${PLACEHOLDERS}
@@ -17878,7 +18578,13 @@ var COMPLETE = `INSERT INTO request_logs ${COLUMNS} VALUES ${PLACEHOLDERS}
     ttft_ms = excluded.ttft_ms,
     duration_ms = excluded.duration_ms,
     cost_usd = excluded.cost_usd,
-    degradations = excluded.degradations`;
+    degradations = excluded.degradations,
+    rtk_applied = excluded.rtk_applied,
+    rtk_filter_hits = excluded.rtk_filter_hits,
+    rtk_original_code_units = excluded.rtk_original_code_units,
+    rtk_compressed_code_units = excluded.rtk_compressed_code_units,
+    rtk_estimated_tokens_saved = excluded.rtk_estimated_tokens_saved,
+    rtk_filters = excluded.rtk_filters`;
 function createUsageRepo(db) {
   const complete = db.transaction((log) => {
     db.run(COMPLETE, values(log, "done"));
@@ -17923,6 +18629,8 @@ function createUsageRepo(db) {
                   COALESCE(SUM(output_tokens), 0) AS output_tokens,
                   COALESCE(SUM(cache_read_tokens), 0) AS cache_read_tokens,
                   COALESCE(SUM(cache_write_tokens), 0) AS cache_write_tokens,
+                  COALESCE(SUM(${daily ? "rtk_saved_tokens" : "rtk_estimated_tokens_saved"}), 0) AS rtk_saved_tokens,
+                  COALESCE(SUM(${daily ? "rtk_applied_requests" : "CASE WHEN rtk_applied = 1 THEN 1 ELSE 0 END"}), 0) AS rtk_applied_requests,
                   COALESCE(SUM(cost_usd), 0) AS cost_usd
              FROM ${daily ? "usage_daily" : "request_logs"}
             WHERE ${daily ? "" : "state = 'done' AND "}${timeColumn} >= ? AND ${timeColumn} <= ?
@@ -17936,6 +18644,8 @@ function createUsageRepo(db) {
           outputTokens: r.output_tokens,
           cacheReadTokens: r.cache_read_tokens,
           cacheWriteTokens: r.cache_write_tokens,
+          rtkSavedTokens: r.rtk_saved_tokens,
+          rtkAppliedRequests: r.rtk_applied_requests,
           costUsd: r.cost_usd,
           errors: r.errors,
           durationMsSum: r.duration_ms_sum
@@ -18080,6 +18790,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) {
@@ -18202,7 +18917,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) {
@@ -18219,19 +18934,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,
@@ -18366,6 +19081,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
@@ -18436,33 +19154,77 @@ async function describeModelsForSetup(store) {
     label: modelDisplayName(model)
   }));
 }
-function slug(id) {
-  return encodeURIComponent(id).replace(/\./g, "%2E");
-}
-function claudeProfiles(described, input) {
-  const apiKey = input.apiKey ?? KEY_PLACEHOLDER;
-  return described.map(({ model, limits }) => {
-    const useMirror = input.discoveryMirrors === true && !/^(?:claude|anthropic)/i.test(model.id);
-    const modelId = useMirror ? `claude/${model.id}` : model.id;
-    const env2 = {
-      ANTHROPIC_BASE_URL: input.baseUrl,
-      ANTHROPIC_AUTH_TOKEN: apiKey,
-      ANTHROPIC_MODEL: modelId,
-      CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1"
-    };
-    if (limits.contextWindow !== undefined && !/^claude-/i.test(modelId)) {
-      env2.CLAUDE_CODE_MAX_CONTEXT_TOKENS = String(limits.contextWindow);
+var CLAUDE_MAPPING_KEYS = {
+  defaultModel: "ANTHROPIC_MODEL",
+  fableModel: "ANTHROPIC_DEFAULT_FABLE_MODEL",
+  opusModel: "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  sonnetModel: "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  haikuModel: "ANTHROPIC_DEFAULT_HAIKU_MODEL"
+};
+function settingsObject(existing) {
+  if (existing === undefined)
+    return {};
+  try {
+    const parsed = JSON.parse(existing);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("settings root is not an object");
     }
-    return {
-      path: `${slug(model.id)}/settings.json`,
-      contents: `${JSON.stringify({ env: env2 }, null, 2)}
+    return parsed;
+  } catch (error51) {
+    const reason = error51 instanceof Error ? error51.message : "invalid JSON";
+    throw new Error(`cannot parse existing settings.json: ${reason}`);
+  }
+}
+function claudeSettings(described, input, mapping, existing) {
+  if (mapping.defaultModel === "")
+    throw new Error("default model is required");
+  const ids = new Set(described.map(({ model }) => model.id));
+  const visibleId = (slot, id) => {
+    if (!ids.has(id))
+      throw new Error(`${slot} names unknown virtual model "${id}"`);
+    const useMirror = input.discoveryMirrors === true && !/^(?:claude|anthropic)/i.test(id);
+    return useMirror ? `claude/${id}` : id;
+  };
+  const settings = settingsObject(existing);
+  const currentEnv = settings.env;
+  const env2 = typeof currentEnv === "object" && currentEnv !== null && !Array.isArray(currentEnv) ? { ...currentEnv } : {};
+  for (const key of Object.values(CLAUDE_MAPPING_KEYS))
+    delete env2[key];
+  delete env2.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
+  env2.ANTHROPIC_BASE_URL = input.baseUrl;
+  env2.ANTHROPIC_AUTH_TOKEN = input.apiKey ?? KEY_PLACEHOLDER;
+  env2.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
+  for (const [slot, key] of Object.entries(CLAUDE_MAPPING_KEYS)) {
+    const id = mapping[slot];
+    if (id !== undefined && id !== "")
+      env2[key] = visibleId(slot, id);
+  }
+  return {
+    path: "settings.json",
+    contents: `${JSON.stringify({ ...settings, env: env2 }, null, 2)}
 `
-    };
-  });
+  };
 }
-function opencodeConfig(described, input) {
+function opencodeConfig(described, input, mapping) {
+  if (mapping.defaultModel === "")
+    throw new Error("default model is required");
+  const byId = new Map(described.map((entry) => [entry.model.id, entry]));
+  const selected = [];
+  const seen = new Set;
+  for (const slot of Object.keys(CLAUDE_MAPPING_KEYS)) {
+    const id = mapping[slot];
+    if (id === undefined || id === "")
+      continue;
+    const entry = byId.get(id);
+    if (entry === undefined)
+      throw new Error(`${slot} names unknown virtual model "${id}"`);
+    if (!seen.has(id)) {
+      seen.add(id);
+      selected.push(entry);
+    }
+  }
   const models = {};
-  for (const { model, limits, label: label2 } of described) {
+  for (const { model, limits, label: label2 } of selected) {
     const limit = limits.contextWindow === undefined ? undefined : {
       context: limits.contextWindow,
       ...limits.maxOutputTokens === undefined ? {} : { output: limits.maxOutputTokens }
@@ -18471,6 +19233,7 @@ function opencodeConfig(described, input) {
   }
   const contents = `${JSON.stringify({
     $schema: "https://opencode.ai/config.json",
+    model: `omnigateway/${mapping.defaultModel}`,
     provider: {
       omnigateway: {
         npm: "@ai-sdk/openai-compatible",
@@ -19040,7 +19803,8 @@ var console_ = {
 var PROVIDER_TONE = {
   anthropic: "magenta",
   openai: "green",
-  kimi: "blue"
+  kimi: "blue",
+  custom: "cyan"
 };
 function provider(ctx, id) {
   return paint(ctx, PROVIDER_TONE[id], id);
@@ -19204,21 +19968,36 @@ var credentialsRefresh = {
   }
 };
 var credentialsAddKey = {
-  usage: "credentials add-key <provider> [--label L]",
+  usage: "credentials add-key <provider> [--label L] [--endpoint-id ID --endpoint-label L --origin URL --protocol P]",
   summary: "Store a provider API key, read from a prompt or stdin",
-  options: { label: { type: "string" } },
+  options: {
+    label: { type: "string" },
+    "endpoint-id": { type: "string" },
+    "endpoint-label": { type: "string" },
+    origin: { type: "string" },
+    protocol: { type: "string" }
+  },
   async run(args, { ctx, writer, prompt }) {
     const providerId = requirePositional(args, 0, "provider");
     if (!isProviderId(providerId)) {
-      throw new UsageError("provider must be one of anthropic, openai, kimi");
+      throw new UsageError("provider must be one of anthropic, openai, kimi, custom");
     }
+    const protocolFlag = stringFlag(args.values, "protocol");
+    const protocol = protocolFlag === "chat-completions" ? "chat_completions" : protocolFlag === "responses" ? "responses" : protocolFlag;
     const key = await prompt.secret(`${providerId} API key: `);
     if (key.length === 0)
       throw new CliError("no API key given");
-    const created = await createApiKeyCredential(await ctx.store(), {
+    const store = await ctx.store();
+    const endpointId = stringFlag(args.values, "endpoint-id");
+    const existingEndpoint = providerId === "custom" && endpointId !== undefined ? (await listCredentials(store)).find((credential) => credential.provider === "custom" && credential.providerData.endpointId === endpointId.trim()) : undefined;
+    const created = await createApiKeyCredential(store, {
       provider: providerId,
       apiKey: key,
-      label: stringFlag(args.values, "label")
+      label: stringFlag(args.values, "label"),
+      endpointId,
+      endpointLabel: stringFlag(args.values, "endpoint-label") ?? existingEndpoint?.providerData.endpointLabel,
+      origin: stringFlag(args.values, "origin") ?? existingEndpoint?.providerData.origin,
+      protocol: protocol ?? existingEndpoint?.providerData.protocol
     });
     emit(ctx, writer, { id: created.id, provider: created.provider }, () => `stored ${created.provider} api key as ${created.id}`);
   }
@@ -19867,7 +20646,7 @@ var settingsSet = {
 };
 
 // apps/cli/src/commands/setup.ts
-import { dirname as dirname2, join as join4 } from "path";
+import { join as join4 } from "path";
 var OPTIONS = {
   dir: { type: "string" },
   key: { type: "string" },
@@ -19901,39 +20680,65 @@ ${f.contents}`).join(`
 function at(dir, file2) {
   return { path: join4(dir, file2.path), contents: file2.contents };
 }
+async function promptMapping(models, prompt) {
+  const choices = models.map(({ model }) => model.id).join(", ");
+  if (prompt.input === undefined) {
+    throw new CliError("model mapping requires an interactive terminal");
+  }
+  const ask = async (label2, required2) => {
+    const answer = await prompt.input?.(`${label2} model${required2 ? "" : " (blank to omit)"} [${choices}]: `);
+    if (required2 && answer === "")
+      throw new CliError("default model is required");
+    return answer === "" ? undefined : answer;
+  };
+  const defaultModel = await ask("Default", true);
+  if (defaultModel === undefined)
+    throw new CliError("default model is required");
+  const fableModel = await ask("Fable", false);
+  const opusModel = await ask("Opus", false);
+  const sonnetModel = await ask("Sonnet", false);
+  const haikuModel = await ask("Haiku", false);
+  return {
+    defaultModel,
+    ...fableModel === undefined ? {} : { fableModel },
+    ...opusModel === undefined ? {} : { opusModel },
+    ...sonnetModel === undefined ? {} : { sonnetModel },
+    ...haikuModel === undefined ? {} : { haikuModel }
+  };
+}
 var setupClaude = {
   usage: "setup claude [--dir <path>] [--key <key>] [--dry-run]",
-  summary: "Write a Claude Code profile per virtual model",
+  summary: "Write Claude Code settings for this gateway",
   options: OPTIONS,
-  async run(args, { ctx, writer, setupFs }) {
+  async run(args, { ctx, writer, prompt, setupFs }) {
     const models = await described(ctx);
-    const dir = stringFlag(args.values, "dir") ?? join4(setupFs.homeDir, ".claude", "profiles");
+    const dir = stringFlag(args.values, "dir") ?? join4(setupFs.homeDir, ".claude");
     const key = stringFlag(args.values, "key");
     const dryRun2 = boolFlag(args.values, "dry-run");
-    const files = claudeProfiles(models, {
+    const mapping = await promptMapping(models, prompt);
+    const path = join4(dir, "settings.json");
+    const file2 = claudeSettings(models, {
       baseUrl: baseUrl(ctx),
       discoveryMirrors: ctx.config().exposeClaudeCodeAliases,
       ...key === undefined ? {} : { apiKey: key }
-    }).map((file2) => at(dir, file2));
-    finish(ctx, writer, files, dryRun2, key, setupFs.write);
-    if (!dryRun2) {
-      note(ctx, writer, `run one with: CLAUDE_CONFIG_DIR=${dirname2(files[0]?.path ?? dir)} claude`);
-    }
+    }, mapping, setupFs.read(path) ?? undefined);
+    finish(ctx, writer, [at(dir, file2)], dryRun2, key, setupFs.write);
   }
 };
 var setupOpencode = {
   usage: "setup opencode [--dir <path>] [--key <key>] [--dry-run]",
   summary: "Write an opencode.json provider entry for this gateway",
   options: OPTIONS,
-  async run(args, { ctx, writer, setupFs }) {
+  async run(args, { ctx, writer, prompt, setupFs }) {
     const models = await described(ctx);
     const dir = stringFlag(args.values, "dir") ?? setupFs.cwd;
     const key = stringFlag(args.values, "key");
     const dryRun2 = boolFlag(args.values, "dry-run");
+    const mapping = await promptMapping(models, prompt);
     const file2 = opencodeConfig(models, {
       baseUrl: baseUrl(ctx),
       ...key === undefined ? {} : { apiKey: key }
-    });
+    }, mapping);
     finish(ctx, writer, [at(dir, file2)], dryRun2, key, setupFs.write);
   }
 };
@@ -20316,6 +21121,12 @@ function createPrompt(ctx, writer) {
   const isTty = process.stdin.isTTY === true;
   return {
     isTty,
+    async input(question) {
+      if (!isTty)
+        throw new CliError(`${question} \u2014 refusing without a terminal`);
+      writer.err(question);
+      return (await readLine()).trim();
+    },
     async secret(question) {
       if (!isTty)
         return (await readAllStdin()).trim();
@@ -20336,6 +21147,20 @@ function createPrompt(ctx, writer) {
   };
 }
 
+// apps/cli/src/setupFs.ts
+import { dirname as dirname2 } from "path";
+function atomicWriteFile(path, contents, ops) {
+  const temporary = `${path}.${process.pid}.tmp`;
+  ops.mkdir(dirname2(path));
+  try {
+    ops.write(temporary, contents);
+    ops.rename(temporary, path);
+  } catch (error51) {
+    ops.remove(temporary);
+    throw error51;
+  }
+}
+
 // apps/cli/src/run.ts
 var VERSION = "0.0.0";
 async function run(argv, writer, options = {}) {
@@ -20377,10 +21202,13 @@ async function run(argv, writer, options = {}) {
     setupFs: options.setupFs ?? {
       homeDir: homedir3(),
       cwd: process.cwd(),
-      write: (path, contents) => {
-        mkdirSync2(dirname3(path), { recursive: true });
-        writeFileSync2(path, contents);
-      }
+      read: (path) => existsSync6(path) ? readFileSync3(path, "utf8") : null,
+      write: (path, contents) => atomicWriteFile(path, contents, {
+        mkdir: (directory) => mkdirSync2(directory, { recursive: true }),
+        write: (temporary, data) => writeFileSync2(temporary, data),
+        rename: renameSync,
+        remove: (temporary) => rmSync2(temporary, { force: true })
+      })
     },
     service: () => options.service?.({ root: ctx.root.root, env: ctx.env }) ?? createServiceDeps({ root: ctx.root.root, env: ctx.env, scope, now: ctx.now }),
     foreground: options.foreground ?? runForeground,