omnigateway 0.1.7 → 0.2.0

package/gateway.js

@@ -5296,6 +5296,11 @@ function createAdminAuth(store, opts) {
   };
 }
 // packages/ir/src/capabilities.ts
+var ANTHROPIC_NATIVE_TOOLS = {
+  anthropic: true,
+  openai: false,
+  kimi: false
+};
 var PROVIDER_CAPABILITIES = {
   anthropic: { tools: true, images: true, reasoning: true },
   openai: { tools: true, images: true, reasoning: true },
@@ -5497,7 +5502,13 @@ function collect(events) {
         model = ev.model;
         break;
       case "blockStart":
-        blocks.set(ev.index, ev.block.type === "toolUse" ? { kind: "toolUse", id: ev.block.id, name: ev.block.name, json: "" } : ev.block.type === "thinking" ? { kind: "thinking", text: "" } : { kind: "text", text: "" });
+        blocks.set(ev.index, ev.block.type === "toolUse" ? { kind: "toolUse", id: ev.block.id, name: ev.block.name, json: "" } : ev.block.type === "thinking" ? { kind: "thinking", text: "" } : ev.block.type === "anthropicNative" ? {
+          kind: "anthropicNative",
+          blockType: ev.block.blockType,
+          data: ev.block.data,
+          json: "",
+          deltas: []
+        } : { kind: "text", text: "", citations: [] });
         break;
       case "blockDelta": {
         const acc = blocks.get(ev.index);
@@ -5511,6 +5522,14 @@ function collect(events) {
           acc.signature = (acc.signature ?? "") + ev.delta.signature;
         else if (ev.delta.type === "toolJson" && acc.kind === "toolUse")
           acc.json += ev.delta.partial;
+        else if (ev.delta.type === "anthropicNativeJson" && acc.kind === "anthropicNative")
+          acc.json += ev.delta.partial;
+        else if (ev.delta.type === "anthropicNative") {
+          if (acc.kind === "anthropicNative")
+            acc.deltas.push(ev.delta);
+          else if (acc.kind === "text" && ev.delta.deltaType === "citations_delta")
+            acc.citations.push(ev.delta.data.citation);
+        }
         break;
       }
       case "end":
@@ -5523,13 +5542,25 @@ function collect(events) {
   }
   const content = [...blocks.entries()].sort(([a], [b]) => a - b).map(([, acc]) => {
     if (acc.kind === "text")
-      return { type: "text", text: acc.text };
+      return {
+        type: "text",
+        text: acc.text,
+        ...acc.citations.length === 0 ? {} : { citations: acc.citations }
+      };
     if (acc.kind === "thinking")
       return {
         type: "thinking",
         text: acc.text,
         ...acc.signature === undefined ? {} : { signature: acc.signature }
       };
+    if (acc.kind === "anthropicNative") {
+      let data = acc.json === "" ? acc.data : { ...acc.data, input: parseJson(acc.json) };
+      for (const delta of acc.deltas) {
+        if (delta.deltaType === "compaction_delta")
+          data = { ...data, ...delta.data };
+      }
+      return { type: "anthropicNative", blockType: acc.blockType, data };
+    }
     return { type: "toolUse", id: acc.id, name: acc.name, input: parseJson(acc.json) };
   });
   return { id, model, content, stopReason, usage };
@@ -5543,6 +5574,59 @@ function parseJson(raw) {
     return {};
   }
 }
+// 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;
+}
 // packages/ir/src/validate.ts
 function validateRequest(req) {
   const seenToolUseIds = new Set;
@@ -5573,6 +5657,7 @@ function validateRequest(req) {
 }
 // packages/control/src/config.ts
 var MIN_KEY_LENGTH = 16;
+var TRUTHY = new Set(["1", "true", "yes", "on"]);
 var DECIMAL_INTEGER = /^\d+$/;
 function optionalText(value, fallback) {
   return value?.trim() || fallback;
@@ -5592,6 +5677,7 @@ function loadConfig(env) {
   const baseUrl = optionalText(env.OMNI_BASE_URL, derivedBaseUrl).replace(/\/+$/, "") || derivedBaseUrl;
   const staticDir = env.OMNI_STATIC_DIR?.trim();
   const logFile = env.OMNI_LOG_FILE?.trim();
+  const exposeClaudeCodeAliases = TRUTHY.has((env.OMNI_EXPOSE_CLAUDE_CODE_ALIASES ?? "").trim().toLowerCase());
   const rawLogLevel = env.OMNI_LOG_LEVEL?.trim();
   const logLevel = parseLogLevel(rawLogLevel);
   return {
@@ -5603,9 +5689,14 @@ function loadConfig(env) {
     encryptionKey,
     baseUrl,
     staticDir: staticDir === undefined || staticDir.length === 0 ? null : staticDir,
+    exposeClaudeCodeAliases,
     logFile: logFile === undefined || logFile.length === 0 ? null : logFile
   };
 }
+// packages/providers/src/betas.ts
+var CONTEXT_1M_BETA = "context-1m-2025-08-07";
+var CONTEXT_1M_TOKENS = 1e6;
+
 // packages/providers/src/body.ts
 var BODY_ORDER = {
   anthropic: [
@@ -5713,6 +5804,119 @@ function signAnthropicBody(json) {
   return json.replace(needle, `cch=${computeCch(json)};`);
 }
 
+// packages/providers/src/anthropic/models.ts
+var ANTHROPIC_MODELS = {
+  defaultModel: "claude-opus-5",
+  models: [
+    {
+      id: "claude-fable-5",
+      label: "Claude Fable 5",
+      pricing: { input: 10, output: 50, cacheRead: 1, cacheWrite5m: 12.5, cacheWrite1h: 20 },
+      limits: { contextWindow: 1e6, maxOutputTokens: 128000 }
+    },
+    {
+      id: "claude-opus-5",
+      label: "Claude Opus 5",
+      pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite5m: 6.25, cacheWrite1h: 10 },
+      limits: { contextWindow: 1e6, maxOutputTokens: 128000 }
+    },
+    {
+      id: "claude-sonnet-5",
+      label: "Claude Sonnet 5",
+      pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite5m: 3.75, cacheWrite1h: 6 },
+      limits: { contextWindow: 1e6, maxOutputTokens: 128000 }
+    },
+    {
+      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 }
+    }
+  ]
+};
+
+// packages/providers/src/kimi/models.ts
+var KIMI_MODELS = {
+  defaultModel: "k3-256k",
+  models: [
+    {
+      id: "k3-256k",
+      label: "Kimi K3 \u2014 256K",
+      pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 262144, maxOutputTokens: 131072 }
+    },
+    {
+      id: "k3",
+      label: "Kimi K3 \u2014 up to 1M",
+      pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 1048576, maxOutputTokens: 131072 }
+    },
+    {
+      id: "kimi-for-coding",
+      label: "Kimi K2.7 Code",
+      pricing: { input: 0.95, output: 4, cacheRead: 0.19, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 262144, maxOutputTokens: 131072 }
+    },
+    {
+      id: "kimi-for-coding-highspeed",
+      label: "Kimi K2.7 Code \u2014 High Speed",
+      pricing: { input: 0.95, output: 8, cacheRead: 0.19, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 262144, maxOutputTokens: 131072 }
+    }
+  ]
+};
+
+// packages/providers/src/openai/models.ts
+var OPENAI_MODELS = {
+  defaultModel: "gpt-5.6",
+  models: [
+    {
+      id: "gpt-5.6",
+      label: "GPT-5.6 \u2014 routes to Sol",
+      pricing: { input: 5, output: 30, cacheRead: 0.5, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
+      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
+    },
+    {
+      id: "gpt-5.6-sol",
+      label: "GPT-5.6 Sol \u2014 deepest reasoning",
+      pricing: { input: 5, output: 30, cacheRead: 0.5, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
+      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
+    },
+    {
+      id: "gpt-5.6-terra",
+      label: "GPT-5.6 Terra \u2014 balanced",
+      pricing: { input: 2, output: 12, cacheRead: 0.2, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
+      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
+    },
+    {
+      id: "gpt-5.6-luna",
+      label: "GPT-5.6 Luna \u2014 fastest",
+      pricing: { input: 0.2, output: 1.2, cacheRead: 0.02, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
+      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
+    }
+  ]
+};
+
+// packages/providers/src/catalog.ts
+var PROVIDER_MODEL_CATALOG = {
+  anthropic: ANTHROPIC_MODELS,
+  openai: OPENAI_MODELS,
+  kimi: KIMI_MODELS
+};
+function catalogPricing(provider, model) {
+  return PROVIDER_MODEL_CATALOG[provider]?.models.find((entry) => entry.id === model)?.pricing ?? null;
+}
+function catalogLimits(provider, model, auth = "apiKey") {
+  const entry = PROVIDER_MODEL_CATALOG[provider]?.models.find((choice) => choice.id === model);
+  if (entry === undefined)
+    return null;
+  return (auth === "oauth" ? entry.oauthLimits : undefined) ?? entry.limits;
+}
+
 // packages/providers/src/http.ts
 function codeForStatus(status) {
   if (status === 401 || status === 403)
@@ -5974,14 +6178,248 @@ 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"]
+  }
+};
+function anthropicToolSpec(type) {
+  return Object.hasOwn(ANTHROPIC_TOOL_SPECS, type) ? ANTHROPIC_TOOL_SPECS[type] : undefined;
+}
+var ANTHROPIC_TOOL_CALLERS = [
+  "direct",
+  "code_execution_20250825",
+  "code_execution_20260120",
+  "code_execution_20260521"
+];
+var ANTHROPIC_CUSTOM_TOOL_OPTIONS = [
+  "strict",
+  "defer_loading",
+  "allowed_callers",
+  "input_examples",
+  "eager_input_streaming"
+];
+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",
@@ -6007,10 +6445,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 ?? {};
@@ -6035,6 +6484,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": {
@@ -6058,17 +6519,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;
@@ -6127,7 +6622,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",
@@ -6146,11 +6646,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 }]));
@@ -6162,6 +6667,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":
@@ -6216,14 +6738,8 @@ 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) {
@@ -6270,6 +6786,15 @@ var anthropicAdapter = {
       ["Accept", "text/event-stream"]
     ];
     const betas = new Set(req.request.betas ?? []);
+    const notes = [...degradations];
+    if (betas.has(CONTEXT_1M_BETA)) {
+      const limits = catalogLimits("anthropic", req.model, oauth ? "oauth" : "apiKey");
+      const window2 = limits?.contextWindow;
+      if (window2 !== undefined && window2 < CONTEXT_1M_TOKENS) {
+        betas.delete(CONTEXT_1M_BETA);
+        notes.push("anthropic:context-1m-dropped");
+      }
+    }
     if (oauth) {
       protocol.push(["Authorization", `Bearer ${req.credentials.accessToken}`]);
       betas.add(OAUTH_BETA);
@@ -6297,121 +6822,9 @@ var anthropicAdapter = {
       throw await httpError(res, "anthropic");
     if (res.body === null)
       throw new GatewayError("UPSTREAM", "empty response body", { provider: "anthropic" });
-    return { events: decodeAnthropic(parseSse(res.body)), degradations };
+    return { events: decodeAnthropic(parseSse(res.body)), degradations: notes };
   }
 };
-// packages/providers/src/anthropic/models.ts
-var ANTHROPIC_MODELS = {
-  defaultModel: "claude-opus-5",
-  models: [
-    {
-      id: "claude-fable-5",
-      label: "Claude Fable 5",
-      pricing: { input: 10, output: 50, cacheRead: 1, cacheWrite5m: 12.5, cacheWrite1h: 20 },
-      limits: { contextWindow: 1e6, maxOutputTokens: 128000 }
-    },
-    {
-      id: "claude-opus-5",
-      label: "Claude Opus 5",
-      pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite5m: 6.25, cacheWrite1h: 10 },
-      limits: { contextWindow: 1e6, maxOutputTokens: 128000 }
-    },
-    {
-      id: "claude-sonnet-5",
-      label: "Claude Sonnet 5",
-      pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite5m: 3.75, cacheWrite1h: 6 },
-      limits: { contextWindow: 1e6, maxOutputTokens: 128000 }
-    },
-    {
-      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 }
-    }
-  ]
-};
-
-// packages/providers/src/kimi/models.ts
-var KIMI_MODELS = {
-  defaultModel: "k3-256k",
-  models: [
-    {
-      id: "k3-256k",
-      label: "Kimi K3 \u2014 256K",
-      pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite5m: 0, cacheWrite1h: 0 },
-      limits: { contextWindow: 262144, maxOutputTokens: 131072 }
-    },
-    {
-      id: "k3",
-      label: "Kimi K3 \u2014 up to 1M",
-      pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite5m: 0, cacheWrite1h: 0 },
-      limits: { contextWindow: 1048576, maxOutputTokens: 131072 }
-    },
-    {
-      id: "kimi-for-coding",
-      label: "Kimi K2.7 Code",
-      pricing: { input: 0.95, output: 4, cacheRead: 0.19, cacheWrite5m: 0, cacheWrite1h: 0 },
-      limits: { contextWindow: 262144, maxOutputTokens: 131072 }
-    },
-    {
-      id: "kimi-for-coding-highspeed",
-      label: "Kimi K2.7 Code \u2014 High Speed",
-      pricing: { input: 0.95, output: 8, cacheRead: 0.19, cacheWrite5m: 0, cacheWrite1h: 0 },
-      limits: { contextWindow: 262144, maxOutputTokens: 131072 }
-    }
-  ]
-};
-
-// packages/providers/src/openai/models.ts
-var OPENAI_MODELS = {
-  defaultModel: "gpt-5.6",
-  models: [
-    {
-      id: "gpt-5.6",
-      label: "GPT-5.6 \u2014 routes to Sol",
-      pricing: { input: 5, output: 30, cacheRead: 0.5, cacheWrite5m: 0, cacheWrite1h: 0 },
-      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
-      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
-    },
-    {
-      id: "gpt-5.6-sol",
-      label: "GPT-5.6 Sol \u2014 deepest reasoning",
-      pricing: { input: 5, output: 30, cacheRead: 0.5, cacheWrite5m: 0, cacheWrite1h: 0 },
-      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
-      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
-    },
-    {
-      id: "gpt-5.6-terra",
-      label: "GPT-5.6 Terra \u2014 balanced",
-      pricing: { input: 2, output: 12, cacheRead: 0.2, cacheWrite5m: 0, cacheWrite1h: 0 },
-      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
-      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
-    },
-    {
-      id: "gpt-5.6-luna",
-      label: "GPT-5.6 Luna \u2014 fastest",
-      pricing: { input: 0.2, output: 1.2, cacheRead: 0.02, cacheWrite5m: 0, cacheWrite1h: 0 },
-      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
-      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
-    }
-  ]
-};
-
-// packages/providers/src/catalog.ts
-var PROVIDER_MODEL_CATALOG = {
-  anthropic: ANTHROPIC_MODELS,
-  openai: OPENAI_MODELS,
-  kimi: KIMI_MODELS
-};
-function catalogPricing(provider, model) {
-  return PROVIDER_MODEL_CATALOG[provider]?.models.find((entry) => entry.id === model)?.pricing ?? null;
-}
-function catalogLimits(provider, model, auth = "apiKey") {
-  const entry = PROVIDER_MODEL_CATALOG[provider]?.models.find((choice) => choice.id === model);
-  if (entry === undefined)
-    return null;
-  return (auth === "oauth" ? entry.oauthLimits : undefined) ?? entry.limits;
-}
 // packages/providers/src/http-client.ts
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
@@ -6637,6 +7050,8 @@ function toChatWire(req, model) {
     if (!degradations.includes(d))
       degradations.push(d);
   };
+  if (req.betas?.includes(CONTEXT_1M_BETA))
+    note("kimi:context-1m-dropped");
   const messages = [];
   const system = req.system?.flatMap((b) => b.type === "text" ? [b.text] : []).join(`
 
@@ -6671,6 +7086,9 @@ function toChatWire(req, model) {
             content: block.content
           });
           break;
+        case "anthropicNative":
+          note("kimi:anthropic-native-block-dropped");
+          break;
       }
     }
     if (toolCalls.length > 0) {
@@ -6698,7 +7116,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)
+      note("kimi:anthropic-tool-dropped");
+    body.tools = custom.map((t) => ({
       type: "function",
       function: { name: t.name, description: t.description, parameters: t.inputSchema }
     }));
@@ -6913,6 +7334,8 @@ function toResponsesWire(req, model, opts = { oauth: false }) {
     if (!degradations.includes(d))
       degradations.push(d);
   };
+  if (req.betas?.includes(CONTEXT_1M_BETA))
+    note("openai:context-1m-dropped");
   for (const message of req.messages) {
     const parts = [];
     const inlined = message.role === "system";
@@ -6963,6 +7386,9 @@ ${block.text}
             output: block.content
           });
           break;
+        case "anthropicNative":
+          note("openai:anthropic-native-block-dropped");
+          break;
       }
     }
     flush();
@@ -6986,7 +7412,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)
+      note("openai:anthropic-tool-dropped");
+    body.tools = custom.map((t) => ({
       type: "function",
       name: t.name,
       description: t.description,
@@ -7607,12 +8036,10 @@ async function readSource(deps, source, lines) {
     return "";
   if (source.kind === "file")
     return deps.readFile(source.path, lines) ?? "";
-  const scope = source.scope === "system" ? [] : ["--user"];
+  const unit = source.scope === "system" ? ["-u", source.unit] : [`--user-unit=${source.unit}`];
   const result = await deps.run([
     "journalctl",
-    ...scope,
-    "-u",
-    source.unit,
+    ...unit,
     "-n",
     String(lines),
     "--no-pager",
@@ -21919,7 +22346,9 @@ var dryRunSchema = exports_external.object({
   reasoning: exports_external.boolean().default(false)
 }).strict();
 var modelSchema = exports_external.object({
-  id: exports_external.string().min(1),
+  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({
@@ -21958,11 +22387,12 @@ var settingsSchema = exports_external.object({
     recency: 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(),
@@ -22078,6 +22508,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 {
@@ -22094,10 +22529,11 @@ 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;
@@ -22405,7 +22841,11 @@ 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 });
@@ -22473,7 +22913,8 @@ var DEFAULT_SETTINGS = {
   breakerThreshold: 3,
   breakerCooldownMs: 30000,
   logRetentionDays: 30,
-  quotaPollIntervalMs: 300000
+  quotaPollIntervalMs: 300000,
+  rtkEnabled: false
 };
 
 // packages/store/src/sqlite/config.ts
@@ -22509,12 +22950,18 @@ function createConfigRepo(db, emit = () => {}) {
       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: { ...DEFAULT_SETTINGS.weights, ...stored.weights }
+        };
+      } catch {
+        return DEFAULT_SETTINGS;
+      }
     },
     async putSettings(patch) {
       const current = await this.getSettings();
@@ -22956,6 +23403,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);
@@ -22966,8 +23427,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,
@@ -22975,8 +23436,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 [
@@ -22996,6 +23459,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
   };
@@ -23009,6 +23474,8 @@ function upsert(db, key, c) {
     c.outputTokens,
     c.cacheReadTokens,
     c.cacheWriteTokens,
+    c.rtkSavedTokens,
+    c.rtkAppliedRequests,
     c.costUsd,
     c.durationMsSum
   ]);
@@ -23039,6 +23506,8 @@ function backfillDaily(db) {
       outputTokens: 0,
       cacheReadTokens: 0,
       cacheWriteTokens: 0,
+      rtkSavedTokens: 0,
+      rtkAppliedRequests: 0,
       costUsd: 0,
       durationMsSum: 0
     };
@@ -23057,13 +23526,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 });
@@ -23132,7 +23630,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",
@@ -23152,7 +23681,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: {
@@ -23197,8 +23732,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,
@@ -23219,7 +23755,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}
@@ -23240,7 +23782,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"));
@@ -23285,6 +23833,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} <= ?
@@ -23298,6 +23848,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
@@ -23373,6 +23925,60 @@ async function createKey(store, input) {
 async function revokeKey(store, id) {
   await store.keys.revoke(id);
 }
+// packages/control/src/modelLimits.ts
+function narrower(a, b) {
+  const context = [a.contextWindow, b.contextWindow].filter((n) => n !== undefined);
+  const output = [a.maxOutputTokens, b.maxOutputTokens].filter((n) => n !== undefined);
+  return {
+    ...context.length === 0 ? {} : { contextWindow: Math.min(...context) },
+    ...output.length === 0 ? {} : { maxOutputTokens: Math.min(...output) }
+  };
+}
+function targetLimits(target, auths) {
+  const ways = auths.size === 0 ? ["apiKey"] : [...auths];
+  let listed = {};
+  for (const auth of ways) {
+    const entry = catalogLimits(target.provider, target.model, auth);
+    if (entry === null)
+      continue;
+    listed = narrower(listed, {
+      contextWindow: entry.contextWindow,
+      maxOutputTokens: entry.maxOutputTokens
+    });
+  }
+  const contextWindow = target.contextWindow ?? listed.contextWindow;
+  const maxOutputTokens = target.maxOutputTokens ?? listed.maxOutputTokens;
+  return {
+    ...contextWindow === undefined ? {} : { contextWindow },
+    ...maxOutputTokens === undefined ? {} : { maxOutputTokens }
+  };
+}
+function servingAuths(credentials) {
+  const byProvider = new Map;
+  for (const credential of credentials) {
+    if (!credential.enabled)
+      continue;
+    const ways = byProvider.get(credential.provider) ?? new Set;
+    ways.add(credential.authType);
+    byProvider.set(credential.provider, ways);
+  }
+  return byProvider;
+}
+function resolveModelLimits(model, credentials) {
+  const auths = servingAuths(credentials);
+  let limits = {};
+  for (const target of model.targets) {
+    limits = narrower(limits, targetLimits(target, auths.get(target.provider) ?? new Set));
+  }
+  return limits;
+}
+function modelDisplayName(model) {
+  const only = model.targets.length === 1 ? model.targets[0] : undefined;
+  if (only === undefined)
+    return model.id;
+  const labelled = PROVIDER_MODEL_CATALOG[only.provider]?.models.find((choice) => choice.id === only.model);
+  return labelled?.label ?? model.id;
+}
 // packages/control/src/models.ts
 async function listModels(store) {
   return store.config.listModels();
@@ -23789,6 +24395,122 @@ async function putSettings(store, input) {
   await store.config.putSettings(settings);
   return settings;
 }
+// packages/control/src/setup.ts
+var KEY_PLACEHOLDER = "<your OmniGateway key>";
+async function describeModelsForSetup(store) {
+  const models = await listModels(store);
+  const credentials = (await listCredentials(store)).map((credential) => ({
+    provider: credential.provider,
+    authType: credential.authType,
+    enabled: credential.enabled
+  }));
+  return models.map((model) => ({
+    model,
+    limits: resolveModelLimits(model, credentials),
+    label: modelDisplayName(model)
+  }));
+}
+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 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, 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 selected) {
+    const limit = limits.contextWindow === undefined ? undefined : {
+      context: limits.contextWindow,
+      ...limits.maxOutputTokens === undefined ? {} : { output: limits.maxOutputTokens }
+    };
+    models[model.id] = { name: label2, ...limit === undefined ? {} : { limit } };
+  }
+  const contents = `${JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    model: `omnigateway/${mapping.defaultModel}`,
+    provider: {
+      omnigateway: {
+        npm: "@ai-sdk/openai-compatible",
+        name: "OmniGateway",
+        options: {
+          baseURL: `${input.baseUrl.replace(/\/+$/, "").replace(/(?:\/v1)+$/i, "")}/v1`,
+          apiKey: input.apiKey ?? KEY_PLACEHOLDER
+        },
+        models
+      }
+    }
+  }, null, 2)}
+`;
+  return { path: "opencode.json", contents };
+}
+async function setupFiles(store, client, input, mapping) {
+  const described = await describeModelsForSetup(store);
+  if (mapping === undefined)
+    throw new Error(`defaultModel is required for ${client} setup`);
+  return client === "opencode" ? [opencodeConfig(described, input, mapping)] : [claudeSettings(described, input, mapping)];
+}
 // packages/control/src/tail.ts
 import { closeSync, fstatSync, openSync, readSync, statSync } from "fs";
 var CHUNK = 64 * 1024;
@@ -26759,7 +27481,7 @@ __export(exports_type3, {
 // node_modules/.bun/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
 var Type = exports_type3;
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/index.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/index.mjs
 var import_fast_decode_uri_component4 = __toESM(require_fast_decode_uri_component(), 1);
 // node_modules/.bun/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/system/evaluate.mjs
 function Evaluate(...args) {
@@ -30637,7 +31359,7 @@ var TypeCompiler;
   TypeCompiler2.Compile = Compile;
 })(TypeCompiler || (TypeCompiler = {}));
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/universal/utils.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/universal/utils.mjs
 var isBun = typeof Bun < "u";
 function isCloudflareWorker() {
   try {
@@ -30649,7 +31371,7 @@ function isCloudflareWorker() {
   return false;
 }
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/universal/file.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/universal/file.mjs
 var mime = {
   aac: "audio/aac",
   abw: "application/x-abiword",
@@ -30776,7 +31498,7 @@ class ElysiaFile {
   }
 }
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/utils.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/utils.mjs
 var replaceUrlPath = (url2, pathname) => {
   const pathStartIndex = url2.indexOf("/", 11), queryIndex = url2.indexOf("?", pathStartIndex);
   return queryIndex === -1 ? `${url2.slice(0, pathStartIndex)}${pathname.charCodeAt(0) === 47 ? "" : "/"}${pathname}` : `${url2.slice(0, pathStartIndex)}${pathname.charCodeAt(0) === 47 ? "" : "/"}${pathname}${url2.slice(queryIndex)}`;
@@ -31250,7 +31972,7 @@ var emptySchema = {
   response: true
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/error.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/error.mjs
 var env2 = typeof Bun < "u" ? Bun.env : typeof process < "u" ? process?.env : undefined;
 var ERROR_CODE2 = Symbol("ElysiaErrorCode");
 var isProduction = (env2?.NODE_ENV ?? env2?.ENV) === "production";
@@ -31499,7 +32221,7 @@ class ValidationError extends Error {
   }
 }
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/type-system/utils.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/type-system/utils.mjs
 var tryParse = (v, schema) => {
   try {
     return JSON.parse(v);
@@ -31581,7 +32303,7 @@ var validateFile = (options, value) => {
   return true;
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/type-system/format.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/type-system/format.mjs
 var fullFormats = {
   date: date5,
   time: getTime(true),
@@ -31720,7 +32442,7 @@ exports_format.Has("date") || exports_format.Set("date", (value) => {
   }
 });
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/type-system/index.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/type-system/index.mjs
 var t = Object.assign({}, Type);
 createType("UnionEnum", (schema, value) => (typeof value == "number" || typeof value == "string" || value === null) && schema.enum.includes(value)), createType("ArrayBuffer", (schema, value) => value instanceof ArrayBuffer);
 var internalFiles = createType("Files", (options, value) => {
@@ -32043,7 +32765,7 @@ t.BooleanString = ElysiaType.BooleanString, t.ObjectString = ElysiaType.ObjectSt
   }
 })), t.Nullable = ElysiaType.Nullable, t.MaybeEmpty = ElysiaType.MaybeEmpty, t.Cookie = ElysiaType.Cookie, t.Date = ElysiaType.Date, t.UnionEnum = ElysiaType.UnionEnum, t.NoValidate = ElysiaType.NoValidate, t.Form = ElysiaType.Form, t.ArrayBuffer = ElysiaType.ArrayBuffer, t.Uint8Array = ElysiaType.Uint8Array;
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/sucrose.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/sucrose.mjs
 var separateFunction = (code) => {
   code.startsWith("async") && (code = code.slice(5)), code = code.trimStart();
   let index = -1;
@@ -32307,7 +33029,7 @@ var sucrose = (lifeCycle, inference = {
   return inference;
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/cookies.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/cookies.mjs
 var import_cookie = __toESM(require_dist(), 1);
 var import_fast_decode_uri_component = __toESM(require_fast_decode_uri_component(), 1);
 var hashString = (str) => {
@@ -32508,7 +33230,7 @@ var serializeCookie = (cookies) => {
     return set2.length === 1 ? set2[0] : set2;
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/adapter/utils.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/adapter/utils.mjs
 var handleFile = (response, set2, request2) => {
   if (!isBun && response instanceof Promise)
     return response.then((res) => handleFile(res, set2, request2));
@@ -32765,7 +33487,7 @@ async function tee(source, branches = 2) {
   return Array.from({ length: branches }, makeIterator);
 }
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/adapter/web-standard/handler.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/adapter/web-standard/handler.mjs
 var handleElysiaFile = (file2, set2 = {
   headers: {}
 }, request2) => {
@@ -33082,7 +33804,7 @@ var handleStream = createStreamHandler({
   mapCompactResponse
 });
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/adapter/web-standard/index.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/adapter/web-standard/index.mjs
 var WebStandardAdapter = {
   name: "web-standard",
   isWebStandard: true,
@@ -33219,7 +33941,7 @@ const error404=new Response(error404Message,{status:404})
   }
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/adapter/bun/handler.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/adapter/bun/handler.mjs
 var mapResponse2 = (response, set2, request2) => {
   if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
     switch (handleSet(set2), response?.constructor?.name) {
@@ -33491,10 +34213,10 @@ var handleStream2 = createStreamHandler({
   mapCompactResponse: mapCompactResponse2
 });
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/compose.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/compose.mjs
 var import_fast_decode_uri_component3 = __toESM(require_fast_decode_uri_component(), 1);
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/parse-query.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/parse-query.mjs
 var import_fast_decode_uri_component2 = __toESM(require_fast_decode_uri_component(), 1);
 var KEY_HAS_PLUS = 1;
 var KEY_NEEDS_DECODE = 2;
@@ -33620,7 +34342,7 @@ function parseQuery(input) {
   }
 }
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/trace.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/trace.mjs
 var ELYSIA_TRACE = Symbol("ElysiaTrace");
 var createProcess = () => {
   const { promise: promise2, resolve } = Promise.withResolvers(), { promise: end, resolve: resolveEnd } = Promise.withResolvers(), { promise: error51, resolve: resolveError } = Promise.withResolvers(), callbacks = [], callbacksEnd = [];
@@ -34061,7 +34783,7 @@ var createMirror = (schema, {
   });
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/replace-schema.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/replace-schema.mjs
 var replaceSchemaTypeFromManyOptions = (schema, options) => {
   if (Array.isArray(options)) {
     let result = schema;
@@ -34159,7 +34881,7 @@ var coerceFormData = () => (_coerceFormData || (_coerceFormData = [
   }
 ]), _coerceFormData);
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/schema.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/schema.mjs
 var isOptional = (schema) => schema ? schema?.[Kind] === "Import" && schema.References ? schema.References().some(isOptional) : (schema.schema && (schema = schema.schema), !!schema && (OptionalKind in schema)) : false;
 var hasAdditionalProperties = (_schema) => {
   if (!_schema)
@@ -34946,7 +35668,7 @@ var getCookieValidator = ({
 };
 var unwrapImportSchema = (schema) => schema && schema[Kind] === "Import" && schema.$defs[schema.$ref][Kind] === "Object" ? schema.$defs[schema.$ref] : schema;
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/compose.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/compose.mjs
 var allocateIf = (value, condition) => condition ? value : "";
 var defaultParsers = [
   "json",
@@ -36095,7 +36817,7 @@ return mapResponse(${saveResponse}error,set${adapter.mapResponseContext})}`;
   });
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/adapter/bun/compose.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/adapter/bun/compose.mjs
 var allocateIf2 = (value, condition) => condition ? value : "";
 var createContext = (app, route, inference, isInline = false) => {
   let fnLiteral = "";
@@ -36146,7 +36868,7 @@ var createBunRouteHandler = (app, route) => {
   });
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/adapter/bun/handler-native.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/adapter/bun/handler-native.mjs
 var createNativeStaticHandler = (handle, hooks, set2) => {
   if (typeof handle == "function" || handle instanceof Blob)
     return;
@@ -36162,7 +36884,7 @@ var createNativeStaticHandler = (handle, hooks, set2) => {
     }) : () => response.clone();
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/ws/index.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/ws/index.mjs
 var websocket = {
   open(ws) {
     ws.data.open?.(ws);
@@ -36265,7 +36987,7 @@ var createHandleWSResponse = (responseValidator) => {
   return handleWSResponse;
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/adapter/bun/index.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/adapter/bun/index.mjs
 var optionalParam = /:.+?\?(?=\/|$)/;
 var getPossibleParams = (path) => {
   const match = optionalParam.exec(path);
@@ -36549,10 +37271,10 @@ for(const [k,v] of c.request.headers.entries())c.headers[k]=v
   }
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/universal/env.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/universal/env.mjs
 var env3 = isBun ? Bun.env : typeof process < "u" && process?.env ? process.env : {};
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/dynamic-handle.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/dynamic-handle.mjs
 var ARRAY_INDEX_REGEX = /^(.+)\[(\d+)\]$/;
 var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 var isDangerousKey = (key) => {
@@ -36988,7 +37710,7 @@ var createDynamicErrorHandler = (app) => {
   };
 };
 
-// node_modules/.bun/elysia@1.4.29+cb62960704ad082f/node_modules/elysia/dist/index.mjs
+// node_modules/.bun/elysia@1.4.29+5b33ebcc42722450/node_modules/elysia/dist/index.mjs
 var _a3;
 _a3 = Symbol.dispose;
 var _Elysia = class _Elysia2 {
@@ -38503,6 +39225,30 @@ function adminRoutes(deps) {
     await requireAdmin(request2, deps.admin);
     await removeModel(deps.store, params.id);
     return { ok: true };
+  }).get("/api/agent-setup", async ({ request: request2, query }) => {
+    await requireAdmin(request2, deps.admin);
+    const client = query.client === "opencode" ? "opencode" : "claude";
+    const defaultModel = query.defaultModel;
+    if (!defaultModel) {
+      throw new GatewayError("BAD_REQUEST", `defaultModel is required for ${client} setup`);
+    }
+    try {
+      return {
+        client,
+        files: await setupFiles(deps.store, client, {
+          baseUrl: deps.baseUrl,
+          discoveryMirrors: deps.discoveryMirrors === true
+        }, {
+          defaultModel,
+          ...query.fableModel ? { fableModel: query.fableModel } : {},
+          ...query.opusModel ? { opusModel: query.opusModel } : {},
+          ...query.sonnetModel ? { sonnetModel: query.sonnetModel } : {},
+          ...query.haikuModel ? { haikuModel: query.haikuModel } : {}
+        })
+      };
+    } catch (error51) {
+      throw new GatewayError("BAD_REQUEST", error51 instanceof Error ? error51.message : "invalid Claude model mapping");
+    }
   }).get("/api/keys", async ({ request: request2 }) => {
     await requireAdmin(request2, deps.admin);
     return { keys: await listKeys(deps.store) };
@@ -38607,6 +39353,1797 @@ function extractToken(header) {
   return match === null ? value : match[1].trim();
 }
 
+// packages/rtk/src/command.ts
+var UNSUPPORTED_OUTPUT = new Set(["--json", "--sarif"]);
+function tokenize(command) {
+  if (command.length > 16384 || /[\r\n`]/.test(command) || command.includes("$(") || command.includes("<(") || command.includes(">("))
+    return;
+  const tokens2 = [];
+  let word = "";
+  let wordStarted = false;
+  let quote;
+  const pushWord = () => {
+    if (wordStarted)
+      tokens2.push({ kind: "word", value: word });
+    word = "";
+    wordStarted = false;
+  };
+  for (let i = 0;i < command.length; i++) {
+    const char = command[i];
+    if (char === undefined)
+      continue;
+    if (quote !== undefined) {
+      if (char === quote)
+        quote = undefined;
+      else if (char === "\\" && quote === '"' && command[i + 1] !== undefined)
+        word += command[++i];
+      else
+        word += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      wordStarted = true;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      pushWord();
+      continue;
+    }
+    if (";&|<>".includes(char) || char === "$" && command[i + 1] === "(") {
+      pushWord();
+      const next = command[i + 1];
+      const value = next !== undefined && (next === char || char === ">" && next === ">") ? char + command[++i] : char;
+      tokens2.push({ kind: "operator", value });
+      continue;
+    }
+    word += char;
+    wordStarted = true;
+  }
+  if (quote !== undefined)
+    return;
+  pushWord();
+  return tokens2.length <= 256 ? tokens2 : undefined;
+}
+function unwrap(tokens2) {
+  let words = tokens2;
+  const operatorIndexes = words.flatMap((token, index) => token.kind === "operator" ? [index] : []);
+  if (operatorIndexes.length > 1)
+    return;
+  if (operatorIndexes.length === 1) {
+    const index = operatorIndexes[0];
+    if (index === undefined || words[index]?.value !== "&&" || words[0]?.kind !== "word" || words[0].value !== "cd" || index !== 2)
+      return;
+    words = words.slice(index + 1);
+  }
+  if (words.some((token) => token.kind === "operator"))
+    return;
+  const values2 = words.map((token) => token.value);
+  while (/^[A-Za-z_][A-Za-z0-9_]*=/.test(values2[0] ?? ""))
+    values2.shift();
+  if (values2[0] === "env") {
+    values2.shift();
+    while (values2.length > 0) {
+      const value = values2.at(0);
+      if (value === "-i" || value === "--ignore-environment" || /^[A-Za-z_][A-Za-z0-9_]*=/.test(value ?? ""))
+        values2.shift();
+      else if (value === "-u") {
+        if (values2[1] === undefined)
+          return;
+        values2.splice(0, 2);
+      } else if (value?.startsWith("--unset="))
+        values2.shift();
+      else if (value === "--")
+        values2.shift();
+      else
+        break;
+    }
+  }
+  if (values2[0] === "timeout") {
+    values2.shift();
+    while (values2[0]?.startsWith("-")) {
+      const option = values2.shift();
+      if (option === "--")
+        break;
+      if (option === "-s" || option === "-k") {
+        if (values2.shift() === undefined)
+          return;
+      } else if (!option?.startsWith("--signal=") && !option?.startsWith("--kill-after="))
+        return;
+    }
+    if (values2.shift() === undefined)
+      return;
+  }
+  return values2.length > 0 ? values2 : undefined;
+}
+function scriptFamily(name) {
+  if (["test", "test:unit", "test:integration", "test:e2e"].includes(name) || name.startsWith("test:"))
+    return "test-output";
+  if (["lint", "typecheck", "check"].includes(name) || name.startsWith("lint:") || name.startsWith("typecheck:"))
+    return "lint-output";
+  return "build-output";
+}
+function classifyGrep(executable, args) {
+  let heading = false;
+  let beforeContext = 0;
+  let afterContext = 0;
+  let lineNumber = false;
+  let operands = 0;
+  for (let index = 0;index < args.length; index++) {
+    const argument = args[index] ?? "";
+    if (argument === "--") {
+      operands += args.length - index - 1;
+      break;
+    }
+    if (!argument.startsWith("-")) {
+      operands++;
+      continue;
+    }
+    if (["--json", "--files", "--replace", "-r", "--files-with-matches", "-l", "-P"].includes(argument))
+      return;
+    if (argument === "--heading")
+      heading = true;
+    else if (argument === "--no-heading")
+      heading = false;
+    else if (argument === "-n" || argument === "--line-number")
+      lineNumber = true;
+    else if (["-C", "-A", "-B", "--context", "--after-context", "--before-context"].includes(argument)) {
+      const count = args[++index];
+      if (count === undefined || !/^\d+$/.test(count))
+        return;
+      const value = Number(count);
+      if (argument === "-C" || argument === "--context") {
+        beforeContext = value;
+        afterContext = value;
+      } else if (argument === "-A" || argument === "--after-context")
+        afterContext = value;
+      else
+        beforeContext = value;
+    } else if (/^-[CAB]\d+$/.test(argument)) {
+      const value = Number(argument.slice(2));
+      if (argument[1] === "C") {
+        beforeContext = value;
+        afterContext = value;
+      } else if (argument[1] === "A")
+        afterContext = value;
+      else
+        beforeContext = value;
+    } else if (/^--(?:context|after-context|before-context)=\d+$/.test(argument)) {
+      const value = Number(argument.slice(argument.indexOf("=") + 1));
+      if (argument.startsWith("--context=")) {
+        beforeContext = value;
+        afterContext = value;
+      } else if (argument.startsWith("--after-context="))
+        afterContext = value;
+      else
+        beforeContext = value;
+    } else if (!["-i", "--ignore-case", "-F", "--fixed-strings", "-w", "--word-regexp"].includes(argument))
+      return;
+  }
+  if (operands === 0)
+    return;
+  return {
+    family: "grep",
+    executable,
+    grepMode: { heading, lineNumber, beforeContext, afterContext }
+  };
+}
+function direct(executable, args) {
+  if (executable.length === 0)
+    return;
+  if (executable === "rg" || executable === "grep")
+    return classifyGrep(executable, args);
+  const subcommand = args[0];
+  if (executable === "git") {
+    if (subcommand === "diff")
+      return { family: "git-diff", executable, subcommand };
+    if (subcommand === "status")
+      return { family: "git-status", executable, subcommand };
+    if (subcommand === "log")
+      return { family: "git-log", executable, subcommand };
+    if (["branch", "switch", "checkout", "push", "pull", "fetch"].includes(subcommand ?? ""))
+      return { family: "git-operation", executable, subcommand: subcommand ?? "" };
+    if (subcommand === "ls-files")
+      return { family: "path-list", executable, subcommand };
+  }
+  if (executable === "docker" && (subcommand === "build" || subcommand === "buildx" && args[1] === "build" || subcommand === "compose" && args[1] === "build"))
+    return { family: "docker-build", executable, subcommand };
+  if (executable === "tree") {
+    const options = args.filter((argument) => argument.startsWith("-"));
+    if (options.some((option) => option !== "-F" && option !== "--classify"))
+      return;
+    return {
+      family: "tree-output",
+      executable,
+      ...options.length === 0 ? {} : { subcommand: "classified" }
+    };
+  }
+  if (executable === "ls") {
+    const options = args.filter((arg) => arg.startsWith("-"));
+    if (options.some((option) => !/^-+[alRh]+$/.test(option)))
+      return;
+    const recursive = options.some((option) => option.includes("R"));
+    const long = options.some((option) => option.includes("l"));
+    if (!recursive && !long)
+      return;
+    return {
+      family: "tree-output",
+      executable,
+      subcommand: recursive ? long ? "recursive-long" : "recursive-plain" : "long"
+    };
+  }
+  if (["find", "glob"].includes(executable))
+    return { family: "path-list", executable };
+  if (["sed", "cat", "head", "tail", "awk", "nl"].includes(executable))
+    return { family: "numbered-read", executable };
+  if (executable === "tsc" || executable === "eslint" || executable === "golangci-lint" || executable === "biome" && ["check", "lint"].includes(subcommand ?? "") || executable === "ruff" && subcommand === "check" || executable === "cargo" && subcommand === "clippy")
+    return {
+      family: "lint-output",
+      executable,
+      ...subcommand === undefined ? {} : { subcommand }
+    };
+  if (["vitest", "jest", "pytest"].includes(executable) || executable === "go" && subcommand === "test")
+    return {
+      family: "test-output",
+      executable,
+      ...subcommand === undefined ? {} : { subcommand }
+    };
+  if (executable === "bun" && ["add", "install", "update", "remove"].includes(subcommand ?? "") || executable === "npm" && ["install", "update", "audit"].includes(subcommand ?? "") || executable === "pnpm" && ["install", "update"].includes(subcommand ?? "") || executable === "yarn" && ["install", "up"].includes(subcommand ?? "") || executable === "cargo" && ["add", "update", "fetch"].includes(subcommand ?? "") || executable === "pip" && subcommand === "install" || executable === "uv" && ["sync", "add", "remove"].includes(subcommand ?? ""))
+    return { family: "package-output", executable, subcommand: subcommand ?? "" };
+  if (executable === "bun" && subcommand === "test" || executable === "npm" && subcommand === "test" || executable === "cargo" && subcommand === "test")
+    return { family: "test-output", executable, subcommand };
+  if (executable === "bun" && subcommand === "build" || executable === "cargo" && ["build", "check"].includes(subcommand ?? ""))
+    return { family: "build-output", executable, subcommand: subcommand ?? "" };
+  return;
+}
+function classifyCommand(command) {
+  const tokens2 = tokenize(command);
+  if (tokens2 === undefined)
+    return;
+  const words = unwrap(tokens2);
+  if (words === undefined)
+    return;
+  if (words.some((word) => UNSUPPORTED_OUTPUT.has(word) || /^(?:--format|--output-format|--reporter)=/.test(word)))
+    return;
+  for (let index = 0;index < words.length; index++) {
+    if (!["--format", "--output-format", "--reporter"].includes(words[index] ?? ""))
+      continue;
+    if (words[index + 1] === undefined)
+      return;
+    return;
+  }
+  const executable = words[0];
+  if (executable === undefined)
+    return;
+  if (executable === "bun" && words[1] === "run" || executable === "npm" && words[1] === "run") {
+    let index = 2;
+    if (words[index] === "--")
+      index++;
+    const script = words[index];
+    return script === undefined || script.length === 0 ? undefined : { family: scriptFamily(script), executable, subcommand: "run" };
+  }
+  if (executable === "bun" && words[1] === "x" || executable === "bunx") {
+    let index = executable === "bun" ? 2 : 1;
+    let sawBun = false;
+    let sawSeparator = false;
+    while (words[index]?.startsWith("-")) {
+      const option = words[index++];
+      if (option === "--bun" && !sawBun && !sawSeparator)
+        sawBun = true;
+      else if (option === "--" && !sawSeparator)
+        sawSeparator = true;
+      else
+        return;
+    }
+    const wrapped = words[index];
+    return wrapped === undefined || wrapped.length === 0 || wrapped === "--" ? undefined : direct(wrapped, words.slice(index + 1));
+  }
+  if (executable === "npx") {
+    let index = 1;
+    let sawYes = false;
+    let sawSeparator = false;
+    while (words[index]?.startsWith("-")) {
+      const option = words[index++];
+      if ((option === "--yes" || option === "-y") && !sawYes && !sawSeparator)
+        sawYes = true;
+      else if (option === "--" && !sawSeparator)
+        sawSeparator = true;
+      else
+        return;
+    }
+    const wrapped = words[index];
+    return wrapped === undefined || wrapped.length === 0 || wrapped === "--" ? undefined : direct(wrapped, words.slice(index + 1));
+  }
+  return direct(executable, words.slice(1));
+}
+
+// packages/rtk/src/detect.ts
+function distinctRows(lines, patterns) {
+  const rows = new Set;
+  for (let index = 0;index < lines.length; index++)
+    if (patterns.some((pattern) => pattern.test(lines[index] ?? "")))
+      rows.add(index);
+  return rows;
+}
+function inferBuildOrTest(lines) {
+  const bunBuildA = distinctRows(lines, [/^\$?\s*bun (?:run|build)\b/, /^bun build v/]);
+  const bunBuildB = distinctRows(lines, [
+    /^(?:Bundled |Build (?:completed|failed)|\S+\.(?:js|css|map)\s+\d)/
+  ]);
+  if ([...bunBuildA].some((row) => [...bunBuildB].some((other) => other !== row)))
+    return "build-output";
+  const cargoA = distinctRows(lines, [/^(?:Compiling |Checking |\$?\s*cargo (?:build|check)\b)/]);
+  const cargoB = distinctRows(lines, [
+    /^Finished .+ target/,
+    /^(?:error|warning)\[[A-Z]\d+\]:/,
+    /^\s*--> \S+:\d+:\d+/
+  ]);
+  if ([...cargoA].some((row) => [...cargoB].some((other) => other !== row)))
+    return "build-output";
+  const compiler = distinctRows(lines, [/^\S.+:\d+:\d+.*(?:error|warning).*(?:TS\d+|[A-Z]\d+)/]);
+  const buildSummary = distinctRows(lines, [
+    /^(?:Build|Compilation).*(?:failed|completed|errors?)/
+  ]);
+  if (compiler.size >= 2 || [...compiler].some((row) => [...buildSummary].some((other) => other !== row)))
+    return "build-output";
+  const bunTestA = distinctRows(lines, [/^(?:bun test v|vitest|jest|PASS |FAIL |Test Files)/i]);
+  const bunTestB = distinctRows(lines, [
+    /^(?:\d+ (?:pass|fail)|Ran \d+ tests?|Tests?:|Test Files)/
+  ]);
+  if ([...bunTestA].some((row) => [...bunTestB].some((other) => other !== row)))
+    return "test-output";
+  const pytestA = distinctRows(lines, [/^={2,} test session starts/, /^collected \d+ items/]);
+  const pytestB = distinctRows(lines, [/^={2,} short test summary/, /\d+ (?:passed|failed|error)/]);
+  if ([...pytestA].some((row) => [...pytestB].some((other) => other !== row)))
+    return "test-output";
+  const goA = distinctRows(lines, [/^=== RUN /, /^\$?\s*go test\b/]);
+  const goB = distinctRows(lines, [/^--- (?:PASS|FAIL):/, /^(?:ok|FAIL)\s+\S/]);
+  if ([...goA].some((row) => [...goB].some((other) => other !== row)))
+    return "test-output";
+  return;
+}
+
+// packages/rtk/src/filters/shared.ts
+var MAX_OUTPUT = 250000;
+
+class ParserBudget {
+  inputCodeUnits;
+  records = 0;
+  codeUnits = 0;
+  constructor(inputCodeUnits) {
+    this.inputCodeUnits = inputCodeUnits;
+  }
+  chargeRecords(count) {
+    this.records += count;
+    return this.records <= 1e5;
+  }
+  chargeCodeUnits(count) {
+    this.codeUnits += count;
+    return this.codeUnits <= this.inputCodeUnits * 3;
+  }
+}
+function scanText(text) {
+  const lines = [];
+  const budget = new ParserBudget(text.length);
+  let start = 0;
+  for (let index = 0;index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (code !== 10 && code !== 13)
+      continue;
+    if (!budget.chargeRecords(1))
+      return;
+    const line2 = text.slice(start, index);
+    if (!budget.chargeCodeUnits(line2.length))
+      return;
+    lines.push(line2);
+    if (code === 13 && text.charCodeAt(index + 1) === 10)
+      index++;
+    start = index + 1;
+  }
+  if (!budget.chargeRecords(1))
+    return;
+  const line = text.slice(start);
+  if (!budget.chargeCodeUnits(line.length))
+    return;
+  lines.push(line);
+  return { text, lines, budget };
+}
+function renderGaps(input, selected, describe3) {
+  const output = [];
+  if (!input.budget.chargeRecords(selected.size))
+    return;
+  let previous = -1;
+  for (const index of [...selected].sort((left, right) => left - right)) {
+    if (previous >= 0 && index > previous + 1) {
+      const marker = describe3(previous + 1, index - 1);
+      if (marker !== undefined) {
+        if (!input.budget.chargeCodeUnits(marker.length))
+          return;
+        output.push(marker);
+      }
+    }
+    const line = input.lines[index];
+    if (line !== undefined) {
+      if (!input.budget.chargeCodeUnits(line.length))
+        return;
+      output.push(line);
+    }
+    previous = index;
+  }
+  return output.join(`
+`);
+}
+function renderSelection(input, selected, unit = "lines") {
+  return renderGaps(input, selected, (start, end) => `... ${end - start + 1} ${unit} omitted ...`);
+}
+function selectBlock(input, selected, block) {
+  const count = block.end - block.start + 1;
+  if (!input.budget.chargeRecords(count))
+    return false;
+  for (let index = block.start;index <= block.end; index++)
+    selected.add(index);
+  return true;
+}
+function diagnosticBlocks(input, primary) {
+  const starts = [];
+  for (let index = 0;index < input.lines.length; index++) {
+    if (!primary.test(input.lines[index] ?? ""))
+      continue;
+    if (!input.budget.chargeRecords(1))
+      return;
+    starts.push(index);
+  }
+  const blocks = [];
+  for (let offset = 0;offset < starts.length; offset++) {
+    const start = starts[offset];
+    if (start === undefined || !input.budget.chargeRecords(1))
+      return;
+    const next = starts[offset + 1] ?? input.lines.length;
+    let end = start;
+    while (end + 1 < next) {
+      const line = input.lines[end + 1] ?? "";
+      if (!/^(?:\s|\||\^|~|help:|note:|=|-->|Caused by:|at\s|detail$)/.test(line))
+        break;
+      end++;
+    }
+    const header = input.lines[start] ?? "";
+    blocks.push({
+      start,
+      end,
+      severity: /\bwarning\b/i.test(header) ? "warning" : "error",
+      identity: header
+    });
+  }
+  return blocks;
+}
+
+// packages/rtk/src/filters/build.ts
+var DIAGNOSTIC = /^(?:[^\n]+:\d+:\d+.*(?:error|warning)|(?:error|warning)(?:\[[^\]]+\])?:|panic:|\s*--> \S+:\d+:\d+)/i;
+var SEMANTIC = /^(?:bun build v|Compiling \S|Checking \S|Downloading \S|Downloaded \S|Running `.+`|Finished .+ target|Build (?:completed|failed)|Bundled |\S*(?:dist|build|target)[/\\]\S+|\S+\.(?:js|css|map|wasm)\s+\d|sourcemap)/i;
+var PROGRESS = /^progress \d+$|^(?:Compiling|Downloading) repeated\b/i;
+var CONTINUATION = /^(?:\s|\||\^|~|help:|note:|Caused by:|at\s)/;
+function compressBuild(input) {
+  const { text, lines } = input;
+  const selected = new Set;
+  const compileRows = new Set;
+  let inDiagnostic = false;
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index] ?? "";
+    if (line.length === 0 || PROGRESS.test(line)) {
+      if (/^(?:Compiling|Downloading) repeated/.test(line))
+        compileRows.add(index);
+      continue;
+    }
+    if (DIAGNOSTIC.test(line))
+      inDiagnostic = true;
+    else if (inDiagnostic && CONTINUATION.test(line)) {
+      selected.add(index);
+      continue;
+    } else
+      inDiagnostic = false;
+    if (!DIAGNOSTIC.test(line) && !SEMANTIC.test(line))
+      return text;
+    if (!input.budget.chargeRecords(1))
+      return text;
+    selected.add(index);
+  }
+  if (selected.size === 0 || !lines.some((line) => /^(?:Finished|Build |Bundled )/.test(line)))
+    return text;
+  let rendered = renderGaps(input, selected, (start, end) => {
+    let compile2 = 0;
+    for (let index = start;index <= end; index++)
+      if (compileRows.has(index))
+        compile2++;
+    const others = end - start + 1 - compile2;
+    const parts = [];
+    if (compile2 > 0)
+      parts.push(`... ${compile2} compile/download rows omitted ...`);
+    if (others > 0)
+      parts.push(`... ${others} lines omitted ...`);
+    return parts.length === 0 ? undefined : parts.join(`
+`);
+  });
+  if (rendered === undefined)
+    return text;
+  const indexes = [...selected];
+  const first = Math.min(...indexes);
+  const last = Math.max(...indexes);
+  const describeOutside = (from, to) => {
+    let compile2 = 0;
+    for (let index = from;index < to; index++)
+      if (compileRows.has(index))
+        compile2++;
+    const others = to - from - compile2;
+    const parts = [];
+    if (compile2 > 0)
+      parts.push(`... ${compile2} compile/download rows omitted ...`);
+    if (others > 0)
+      parts.push(`... ${others} lines omitted ...`);
+    return parts.length === 0 ? undefined : parts.join(`
+`);
+  };
+  const leading = describeOutside(0, first);
+  const trailing = describeOutside(last + 1, lines.length);
+  if (leading !== undefined)
+    rendered = `${leading}
+${rendered}`;
+  if (trailing !== undefined)
+    rendered = `${rendered}
+${trailing}`;
+  return rendered.length > MAX_OUTPUT ? text : rendered;
+}
+
+// packages/rtk/src/filters/diagnostics.ts
+var PRIMARY = /^(?:[^\n]+\(\d+,\d+\):\s+(?:error|warning)\s+TS\d+:|[^\n]+:\d+:\d+(?::|\s).+|[^\n]+\n\s*\d+:\d+\s+(?:error|warning)\s|\s*\d+:\d+\s+(?:error|warning)\s|(?:error|warning)(?:\[[^\]]+\])?:)/i;
+var SUMMARY = /(?:Found \d+ errors?(?: and \d+ warnings?)?(?: in \d+ files?)?|\d+ problems?(?: \([^)\n]*\))?|Checked \d+ files?|could not compile|\d+ issues?)\.?$/i;
+function compressDiagnostics(input) {
+  const { text, lines } = input;
+  const blocks = diagnosticBlocks(input, PRIMARY);
+  if (blocks === undefined || blocks.length === 0)
+    return text;
+  const summary = lines.findLastIndex((line) => SUMMARY.test(line));
+  if (summary < 0)
+    return text;
+  const selected = new Set([0, summary]);
+  const errors4 = blocks.filter((block) => block.severity === "error");
+  const warningByIdentity = new Map;
+  for (const block of blocks)
+    if (block.severity === "warning" && !warningByIdentity.has(block.identity))
+      warningByIdentity.set(block.identity, block);
+  const warnings = [...warningByIdentity.values()];
+  for (const block of [...errors4, ...warnings.slice(0, 20)])
+    if (!selectBlock(input, selected, block))
+      return text;
+  const omittedWarningRows = new Set;
+  const omittedWarningStarts = new Set;
+  for (const block of warnings.slice(20)) {
+    if (!input.budget.chargeRecords(block.end - block.start + 1))
+      return text;
+    let whole = true;
+    for (let index = block.start;index <= block.end; index++)
+      whole &&= !selected.has(index);
+    if (!whole)
+      continue;
+    omittedWarningStarts.add(block.start);
+    for (let index = block.start;index <= block.end; index++)
+      omittedWarningRows.add(index);
+  }
+  const describe3 = (from, to) => {
+    let warningBlocks = 0;
+    let otherRows = 0;
+    for (let index = from;index < to; index++) {
+      if (omittedWarningStarts.has(index))
+        warningBlocks++;
+      if (!omittedWarningRows.has(index))
+        otherRows++;
+    }
+    const parts = [];
+    if (warningBlocks > 0)
+      parts.push(`... ${warningBlocks} warnings omitted ...`);
+    if (otherRows > 0)
+      parts.push(`... ${otherRows} lines omitted ...`);
+    return parts.length === 0 ? undefined : parts.join(`
+`);
+  };
+  let rendered = renderGaps(input, selected, (start, end) => describe3(start, end + 1));
+  if (rendered === undefined)
+    return text;
+  const indexes = [...selected];
+  const leading = describe3(0, Math.min(...indexes));
+  const trailing = describe3(Math.max(...indexes) + 1, lines.length);
+  if (leading !== undefined)
+    rendered = `${leading}
+${rendered}`;
+  if (trailing !== undefined)
+    rendered = `${rendered}
+${trailing}`;
+  if (rendered.length > MAX_OUTPUT)
+    return text;
+  for (const block of errors4)
+    for (let index = block.start;index <= block.end; index++)
+      if (!rendered.includes(lines[index] ?? ""))
+        return text;
+  return rendered;
+}
+
+// packages/rtk/src/filters/docker.ts
+var SEMANTIC2 = /^(?:#\d+\s+(?:\[[^\]]+\].*(?:FROM|RUN|COPY|ADD|load build definition)|(?:\d+(?:\.\d+)?\s+)?(?:Dockerfile:|ERROR|error|warning|caused|Caused|failed|exit code|exporting|naming|writing|DONE|CACHED|command:|digest:|manifest|provenance))|Dockerfile:\d+|naming to |digest:|manifest |provenance |image id |Step \d+\/\d+|Successfully built|Successfully tagged|ERROR|failed to solve)/;
+var CONTINUATION2 = /^(?:#\d+\s+(?:\d+(?:\.\d+)?\s+)?\s+(?:command:|caused by|Caused by:|at\s)|\s+(?:command:|caused by|Caused by:|at\s)|Dockerfile:\d+)/;
+var PROGRESS2 = /^(?:#\d+\s+\d+(?:\.\d+)?\s+)(?:\d+% transferring|\d+(?:\.\d+)?s$)|^#\d+\s+(?:transferring|extracting|downloading)\b/i;
+function compressDocker(input) {
+  const { text, lines } = input;
+  const selected = new Set;
+  const cached2 = new Set;
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index] ?? "";
+    if (line.length === 0 || PROGRESS2.test(line))
+      continue;
+    if (CONTINUATION2.test(line)) {
+      if (selected.size === 0)
+        return text;
+      selected.add(index);
+      continue;
+    }
+    if (!SEMANTIC2.test(line))
+      return text;
+    if (/\bCACHED\b/.test(line)) {
+      const key = line.replace(/\s+\d+(?:\.\d+)?s$/, "");
+      if (cached2.has(key))
+        continue;
+      cached2.add(key);
+    }
+    if (!input.budget.chargeRecords(1))
+      return text;
+    selected.add(index);
+  }
+  if (selected.size === 0)
+    return text;
+  let rendered = renderSelection(input, selected);
+  if (rendered === undefined)
+    return text;
+  const indexes = [...selected];
+  const leading = Math.min(...indexes);
+  const trailing = lines.length - 1 - Math.max(...indexes);
+  if (leading > 0)
+    rendered = `... ${leading} lines omitted ...
+${rendered}`;
+  if (trailing > 0)
+    rendered = `${rendered}
+... ${trailing} lines omitted ...`;
+  return rendered.length <= MAX_OUTPUT ? rendered : text;
+}
+
+// packages/rtk/src/filters/git.ts
+var DIFF_HEADER_ROW = "diff --(?:git|cc|combined) ";
+var DIFF_PAIR_ROW = "(?:--- |\\+\\+\\+ |@@+ )";
+var DIFF_DETAIL_ROW = "(?:index [0-9a-f][0-9a-f,]*\\.\\.|(?:old|new|new file|deleted file) mode |mode [0-7][0-7,]*\\.\\.|(?:similarity|dissimilarity) index |(?:rename|copy) (?:from|to) |Binary files |GIT binary patch$|(?:literal|delta) \\d+$|\\\\ No newline|[ +-]*[-+]| .+files? changed)";
+var LOG_COMMIT_ROW = "commit [0-9a-f]{4,}(?: \\(|$)";
+var LOG_BODY_ROW = "(?:Author:|Date:| {4}[ \\t]*\\S)";
+var LOG_DETAIL_ROW = "(?:Merge: |AuthorDate:|Commit:|CommitDate:|Reflog:|Tag:| \\S.*\\|\\s+\\d+| .+files? changed)";
+var LOG_SEPARATOR_ROW = "\\s*$";
+var GIT_DIFF_ANCHOR = new RegExp(`^(?:${DIFF_HEADER_ROW}|${DIFF_PAIR_ROW}|${DIFF_DETAIL_ROW})`);
+var GIT_LOG_ANCHOR = new RegExp(`^(?:${LOG_COMMIT_ROW}|${LOG_BODY_ROW}|${LOG_DETAIL_ROW}|${LOG_SEPARATOR_ROW})`);
+var GIT_DIFF_EVIDENCE_HEADER = new RegExp(`^${DIFF_HEADER_ROW}`, "m");
+var GIT_DIFF_EVIDENCE_PAIR = new RegExp(`^${DIFF_PAIR_ROW}`, "m");
+var GIT_LOG_EVIDENCE_COMMIT = new RegExp(`^${LOG_COMMIT_ROW}`, "m");
+var GIT_LOG_EVIDENCE_BODY = new RegExp(`^${LOG_BODY_ROW}`, "m");
+var SEMANTIC3 = /^(?:\* |\+ | {2}|Already on|Switched to|Your branch|HEAD is now|From |To |!?\s*\[| \* | - |error:|fatal:|CONFLICT|Everything up-to-date|Updating |Fast-forward|remote:|## |On branch|rebase |merge |cherry-pick |revert |bisect |[0-9a-f]+\.\.[0-9a-f]+\s+\S+\s+->\s+\S+|\s+\S.+\|\s+\d+|\s+\d+ files? changed|Automatic merge failed|\s+(?:modified|deleted|new file|renamed|copied):)/;
+var PROGRESS3 = /^(?:remote: )?(?:Enumerating|Counting|Compressing|Receiving|Resolving|Writing) objects|^(?:remote: )?Total \d+|^\s*\d+% \(|^(?:remote )?progress \d+$/;
+function compressGitOperation(input) {
+  const { text, lines } = input;
+  const selected = new Set;
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index] ?? "";
+    if (line.length === 0 || PROGRESS3.test(line))
+      continue;
+    if (!SEMANTIC3.test(line))
+      return text;
+    selected.add(index);
+  }
+  if (selected.size === 0)
+    return text;
+  let rendered = renderSelection(input, selected);
+  if (rendered === undefined)
+    return text;
+  const indexes = [...selected];
+  const leading = Math.min(...indexes);
+  const trailing = lines.length - 1 - Math.max(...indexes);
+  if (leading > 0)
+    rendered = `... ${leading} lines omitted ...
+${rendered}`;
+  if (trailing > 0)
+    rendered = `${rendered}
+... ${trailing} lines omitted ...`;
+  return rendered.length <= MAX_OUTPUT ? rendered : text;
+}
+
+// packages/rtk/src/filters/listings.ts
+var LONG = /^[bcdlps-][rwxStTs-]{9}\s+\d+\s+\S+\s+\S+\s+\d+\s+\S+\s+\d+\s+(?:\d{2}:\d{2}|\d{4})\s+.+$/;
+var SUMMARY2 = /^\d+ director(?:y|ies), \d+ files?$/;
+var TREE_ROW = /^((?:\u2502 {3}| {4})*)(\u251C\u2500\u2500 |\u2514\u2500\u2500 )(.+)$/;
+function renderGroups(input, groups) {
+  const output = [];
+  let omittedGroups = 0;
+  let omittedEntries = 0;
+  const append = (fragment) => {
+    if (!input.budget.chargeRecords(1) || !input.budget.chargeCodeUnits(fragment.length))
+      return false;
+    output.push(fragment);
+    return true;
+  };
+  const flushOmitted = () => {
+    if (omittedGroups === 0)
+      return true;
+    const marker = `... ${omittedGroups} ${omittedGroups === 1 ? "directory" : "directories"} omitted containing ${omittedEntries} ${omittedEntries === 1 ? "entry" : "entries"} ...`;
+    omittedGroups = 0;
+    omittedEntries = 0;
+    return append(marker);
+  };
+  for (let groupIndex = 0;groupIndex < groups.length; groupIndex++) {
+    const group = groups[groupIndex];
+    if (group === undefined || !input.budget.chargeRecords(1))
+      return;
+    const retain = groups.length <= 40 || groupIndex < 20 || groupIndex >= groups.length - 20;
+    if (!retain) {
+      omittedGroups++;
+      omittedEntries += group.entryCount;
+      continue;
+    }
+    if (!flushOmitted())
+      return;
+    const prefixCount = group.rows.length - group.entryCount;
+    for (let rowIndex = 0;rowIndex < group.rows.length; rowIndex++) {
+      const row = group.rows[rowIndex];
+      if (row === undefined || !input.budget.chargeRecords(1))
+        return;
+      const entryIndex = rowIndex - prefixCount;
+      const retainEntry = entryIndex < 0 || group.entryCount <= 12 || entryIndex < 6 || entryIndex >= group.entryCount - 6;
+      if (retainEntry && !append(row))
+        return;
+    }
+    if (group.entryCount > 12) {
+      const count = group.entryCount - 12;
+      if (!append(`... ${count} ${count === 1 ? "entry" : "entries"} omitted from ${group.key} ...`))
+        return;
+    }
+  }
+  if (!flushOmitted())
+    return;
+  const rendered = output.join(`
+`);
+  return rendered.length <= MAX_OUTPUT ? rendered : undefined;
+}
+function subtreeCounts(input, node, classified) {
+  if (!input.budget.chargeRecords(1))
+    return;
+  if (node.children.length === 0)
+    return {
+      directories: node.classifiedDirectory ? 1 : 0,
+      entries: node.classifiedDirectory ? 0 : 1,
+      ambiguous: !classified
+    };
+  let directories = 1;
+  let entries = 0;
+  let ambiguous = false;
+  for (const child of node.children) {
+    const count = subtreeCounts(input, child, classified);
+    if (count === undefined)
+      return;
+    directories += count.directories;
+    entries += count.entries;
+    ambiguous ||= count.ambiguous;
+  }
+  return { directories, entries, ambiguous };
+}
+function appendSubtree(input, output, node, classified) {
+  if (!input.budget.chargeRecords(1) || !input.budget.chargeCodeUnits(node.line.length))
+    return false;
+  output.push(node.line);
+  const retainedValues = node.children.length <= 12 ? node.children : [...node.children.slice(0, 6), ...node.children.slice(-6)];
+  if (!input.budget.chargeRecords(retainedValues.length))
+    return false;
+  const retained = new Set(retainedValues);
+  let omitted = [];
+  const flushOmitted = () => {
+    if (omitted.length === 0)
+      return true;
+    let directories = 0;
+    let entries = 0;
+    let ambiguous = false;
+    for (const child of omitted) {
+      const count = subtreeCounts(input, child, classified);
+      if (count === undefined)
+        return false;
+      directories += count.directories;
+      entries += count.entries;
+      ambiguous ||= count.ambiguous;
+    }
+    if (ambiguous)
+      return false;
+    const marker = directories === 0 ? `... ${entries} ${entries === 1 ? "entry" : "entries"} omitted from ${node.key} ...` : `... ${directories} ${directories === 1 ? "directory" : "directories"} omitted containing ${entries} ${entries === 1 ? "entry" : "entries"} ...`;
+    if (!input.budget.chargeCodeUnits(marker.length))
+      return false;
+    output.push(marker);
+    omitted = [];
+    return true;
+  };
+  for (const child of node.children) {
+    if (!input.budget.chargeRecords(1))
+      return false;
+    if (!retained.has(child)) {
+      omitted.push(child);
+      continue;
+    }
+    if (!flushOmitted() || !appendSubtree(input, output, child, classified))
+      return false;
+  }
+  return flushOmitted();
+}
+function tree(input, lines, classified) {
+  const root = lines[0];
+  const summary = lines.at(-1);
+  if (lines.length < 3 || root === undefined || /[\u2502\u251C\u2514]/.test(root) || summary === undefined || !SUMMARY2.test(summary))
+    return input.text;
+  if (!input.budget.chargeRecords(1) || !input.budget.chargeCodeUnits(root.length))
+    return input.text;
+  const rootNode = { key: root, line: root, classifiedDirectory: true, children: [] };
+  const stack = [rootNode];
+  for (const line of lines.slice(1, -1)) {
+    const match = line.match(TREE_ROW);
+    const depth = (match?.[1]?.length ?? -1) / 4;
+    const parent = stack[depth];
+    const name = match?.[3];
+    if (!Number.isInteger(depth) || parent === undefined || name === undefined)
+      return input.text;
+    const plainName = name.replace(/ -> .+$/, "").replace(/[/@*=>|]$/, "");
+    const key = `${parent.key}/${plainName}`;
+    if (!input.budget.chargeRecords(3) || !input.budget.chargeCodeUnits(key.length))
+      return input.text;
+    const node = {
+      key,
+      line,
+      classifiedDirectory: classified && name.endsWith("/"),
+      children: []
+    };
+    parent.children.push(node);
+    stack.length = depth + 1;
+    stack.push(node);
+  }
+  const output = [];
+  if (!appendSubtree(input, output, rootNode, classified))
+    return input.text;
+  if (!input.budget.chargeRecords(1) || !input.budget.chargeCodeUnits(summary.length))
+    return input.text;
+  output.push(summary);
+  const rendered = output.join(`
+`);
+  return rendered.length <= MAX_OUTPUT ? rendered : input.text;
+}
+function recursiveLs(input, long) {
+  const groups = [];
+  let current;
+  let sawTotal = false;
+  for (const line of input.lines) {
+    if (line.length === 0)
+      continue;
+    if (/^.+:$/.test(line)) {
+      if (current !== undefined && (long && !sawTotal || current.entryCount === 0))
+        return input.text;
+      const key = line.slice(0, -1);
+      if (!input.budget.chargeRecords(3) || !input.budget.chargeCodeUnits(key.length + line.length))
+        return input.text;
+      current = { key, rows: [line], entryCount: 0 };
+      groups.push(current);
+      sawTotal = false;
+      continue;
+    }
+    if (current === undefined)
+      return input.text;
+    if (/^total \d+$/.test(line)) {
+      if (!long || sawTotal || current.entryCount > 0)
+        return input.text;
+      if (!input.budget.chargeRecords(1) || !input.budget.chargeCodeUnits(line.length))
+        return input.text;
+      current.rows.push(line);
+      sawTotal = true;
+      continue;
+    }
+    if (long && (!sawTotal || !LONG.test(line)) || !long && !/^[^/\\:\n]+$/.test(line))
+      return input.text;
+    if (!input.budget.chargeRecords(1) || !input.budget.chargeCodeUnits(line.length))
+      return input.text;
+    current.rows.push(line);
+    current.entryCount++;
+  }
+  if (current === undefined || long && !sawTotal || current.entryCount === 0)
+    return input.text;
+  return renderGroups(input, groups) ?? input.text;
+}
+var RELATIVE_PATH = /^(?![[{`|])(?!.+:\d+(?::|$))[^\s:\n]+(?:[/\\][^\s:\n]+)*$/;
+var GATED_PROSE = /\s(?:is|are|the|this|that|because|and|with|from|into|were)\s/i;
+var GATED_TABLE = /^\|.*\|$/;
+var GATED_STRUCTURE = /^(?:```|\{|\[|`|\|)/;
+var GATED_DRIVE = /^[A-Za-z]:[/\\]/;
+function hasIllegalControl(line) {
+  for (let index = 0;index < line.length; index++) {
+    const code = line.charCodeAt(index);
+    if (code === 9)
+      continue;
+    if (code < 32 || code === 127)
+      return true;
+  }
+  return false;
+}
+function gatedPath(line) {
+  if (line.length === 0 || hasIllegalControl(line))
+    return false;
+  if (line !== line.trim())
+    return false;
+  if (GATED_STRUCTURE.test(line) || GATED_TABLE.test(line) || GATED_PROSE.test(line))
+    return false;
+  const drive = GATED_DRIVE.test(line);
+  if (line.indexOf(":", drive ? 2 : 0) >= 0)
+    return false;
+  const separator = line.search(/[/\\]/);
+  if (separator < 0)
+    return !/\s/.test(line);
+  return !/\s/.test(line.slice(0, separator));
+}
+function paths(input, commandGated) {
+  const groups = new Map;
+  const ordered = [];
+  for (const line of input.lines) {
+    if (line.length === 0)
+      continue;
+    if (!(commandGated ? gatedPath(line) : RELATIVE_PATH.test(line)))
+      return input.text;
+    const separator = Math.max(line.lastIndexOf("/"), line.lastIndexOf("\\"));
+    const key = separator < 0 ? "." : line.slice(0, separator) || ".";
+    let group = groups.get(key);
+    if (group === undefined) {
+      if (!input.budget.chargeRecords(2) || !input.budget.chargeCodeUnits(key.length))
+        return input.text;
+      group = { key, rows: [], entryCount: 0 };
+      groups.set(key, group);
+      ordered.push(group);
+    }
+    if (!input.budget.chargeRecords(1))
+      return input.text;
+    group.rows.push(line);
+    group.entryCount++;
+  }
+  if (ordered.length === 0)
+    return input.text;
+  return renderGroups(input, ordered) ?? input.text;
+}
+function longLs(input) {
+  let header;
+  const rows = [];
+  for (const line of input.lines) {
+    if (line.length === 0)
+      continue;
+    if (/^total \d+$/.test(line)) {
+      if (header !== undefined || rows.length > 0)
+        return input.text;
+      if (!input.budget.chargeRecords(1) || !input.budget.chargeCodeUnits(line.length))
+        return input.text;
+      header = line;
+      continue;
+    }
+    if (header === undefined || !LONG.test(line))
+      return input.text;
+    if (!input.budget.chargeRecords(1))
+      return input.text;
+    rows.push(line);
+  }
+  if (header === undefined || rows.length === 0)
+    return input.text;
+  const rendered = renderGroups(input, [{ key: ".", rows, entryCount: rows.length }]);
+  if (rendered === undefined)
+    return input.text;
+  const output = `${header}
+${rendered}`;
+  return output.length <= MAX_OUTPUT ? output : input.text;
+}
+function nonemptyLines(input) {
+  const lines = [];
+  for (const line of input.lines) {
+    if (line.length === 0)
+      continue;
+    if (!input.budget.chargeRecords(1))
+      return;
+    lines.push(line);
+  }
+  return lines;
+}
+function compressListing(input, executable, subcommand, commandGated = false) {
+  if (executable === "ls" && subcommand === "recursive-long")
+    return recursiveLs(input, true);
+  if (executable === "ls" && subcommand === "recursive-plain")
+    return recursiveLs(input, false);
+  if (executable === "ls")
+    return longLs(input);
+  if (executable === "tree") {
+    const lines = nonemptyLines(input);
+    if (lines === undefined)
+      return input.text;
+    return tree(input, lines, subcommand === "classified");
+  }
+  return paths(input, commandGated);
+}
+
+// packages/rtk/src/filters/packages.ts
+var MUTATION = /(?:^|\s)(?:added|removed|updated|upgraded|downgraded|installed)\s+\S|lockfile|package-lock|blocked.*script|postinstall|lifecycle|vulnerabilit|peer.*conflict|resolution.*conflict|generated\s+\S/i;
+var SUMMARY3 = /(?:installed|added|removed|updated|audited) \d+ packages?|found \d+ vulnerabilities|Saved lockfile/i;
+var PROGRESS4 = /^(?:download|Resolving|Progress:|Packages:|Fetching|Downloaded|Using cached|Collecting)\b/i;
+function diagnosticStart(line, executable) {
+  const lower = line.toLowerCase();
+  if (executable === "npm" && /^npm (?:warn|warning|error)\b/.test(lower))
+    return lower.startsWith("npm error") ? "error" : "warning";
+  if (executable === "pnpm" && /^(?:warn(?:ing)?\b|err_pnpm_|error\b)/i.test(line))
+    return /^(?:err_pnpm_|error\b)/i.test(line) ? "error" : "warning";
+  if (executable === "yarn" && /^YN\d{4}:/.test(line))
+    return /^YN(?:0009|0018|0028):/.test(line) ? "error" : "warning";
+  if (["cargo", "uv", "bun"].includes(executable) && /^(?:warning|error):/i.test(line))
+    return /^error:/i.test(line) ? "error" : "warning";
+  if (executable === "pip" && /^(?:WARNING|ERROR):/.test(line))
+    return line.startsWith("ERROR") ? "error" : "warning";
+  return;
+}
+function stableIdentity(line, executable, severity) {
+  let normalized = line;
+  if (executable === "npm") {
+    normalized = normalized.replace(/^npm (?:warn|warning|error)\s+/i, "").replace(/^\[\d+\/\d+\]\s+/, "").replace(/^workspace\s+[^:]+:\s*/i, "");
+  } else if (executable === "pnpm") {
+    normalized = normalized.replace(/^(?:WARN(?:ING)?|ERR_PNPM_[A-Z_]+|ERROR)\s+/i, "");
+  } else if (executable === "yarn") {
+    normalized = normalized.replace(/^(YN\d{4}:)\s*(?:\[[^\]]+\]\s*)?/, "$1 ");
+  } else {
+    normalized = normalized.replace(/^(?:warning|error):\s*/i, "");
+  }
+  return `${executable}\x00${severity}\x00${normalized}`;
+}
+function blocks(input, executable) {
+  const { lines } = input;
+  const result = [];
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index] ?? "";
+    const severity = diagnosticStart(line, executable);
+    if (severity === undefined) {
+      if (/^(?:DIAGNOSTIC|WARN(?:ING)?|ERR(?:OR)?|npm (?!install\b)|YN\d{4}:)/i.test(line) && !PROGRESS4.test(line))
+        return;
+      continue;
+    }
+    let end = index;
+    while (end + 1 < lines.length) {
+      const continuation = lines[end + 1] ?? "";
+      if (SUMMARY3.test(continuation) || PROGRESS4.test(continuation))
+        break;
+      const nextSeverity = diagnosticStart(continuation, executable);
+      if (nextSeverity !== undefined) {
+        const continuationMessage = continuation.replace(/^npm (?:warn|error)\s+/i, "");
+        if (!/^(?:required by|While resolving|Found:|Could not resolve)/i.test(continuationMessage))
+          break;
+      } else if (!/^(?:\s|Caused by:|note:|help:)/i.test(continuation)) {
+        break;
+      }
+      end++;
+    }
+    if (!input.budget.chargeRecords(1))
+      return;
+    const identity = stableIdentity(line, executable, severity);
+    if (!input.budget.chargeCodeUnits(identity.length))
+      return;
+    result.push({ start: index, end, severity, identity });
+    index = end;
+  }
+  return result;
+}
+function compressPackages(input, executable) {
+  const { text, lines } = input;
+  const parsed = blocks(input, executable);
+  if (parsed === undefined)
+    return text;
+  const byIdentity = new Map;
+  for (const block of parsed) {
+    if (byIdentity.has(block.identity))
+      continue;
+    if (!input.budget.chargeRecords(1))
+      return text;
+    byIdentity.set(block.identity, block);
+  }
+  if (!input.budget.chargeRecords(byIdentity.size))
+    return text;
+  const unique = [...byIdentity.values()];
+  const errors4 = unique.filter((block) => block.severity === "error");
+  const warnings = unique.filter((block) => block.severity === "warning");
+  const selected = new Set;
+  for (const block of [...errors4, ...warnings.slice(0, 20)])
+    for (let index = block.start;index <= block.end; index++) {
+      if (!input.budget.chargeRecords(1))
+        return text;
+      selected.add(index);
+    }
+  const diagnosticRows = new Set;
+  for (const block of parsed)
+    for (let index = block.start;index <= block.end; index++) {
+      if (!input.budget.chargeRecords(1))
+        return text;
+      diagnosticRows.add(index);
+    }
+  for (let index = 0;index < lines.length; index++)
+    if (!diagnosticRows.has(index) && (MUTATION.test(lines[index] ?? "") || SUMMARY3.test(lines[index] ?? "")))
+      selected.add(index);
+  if (selected.size === 0 || !lines.some((line) => SUMMARY3.test(line)))
+    return text;
+  const omittedWarningRows = new Set;
+  const omittedWarningStarts = new Set;
+  for (const block of warnings.slice(20)) {
+    if (!input.budget.chargeRecords(block.end - block.start + 1))
+      return text;
+    let whole = true;
+    for (let index = block.start;index <= block.end; index++)
+      whole &&= !selected.has(index);
+    if (!whole)
+      continue;
+    omittedWarningStarts.add(block.start);
+    for (let index = block.start;index <= block.end; index++)
+      omittedWarningRows.add(index);
+  }
+  const describe3 = (from, to) => {
+    let warningBlocks = 0;
+    let otherRows = 0;
+    for (let index = from;index < to; index++) {
+      if (omittedWarningStarts.has(index))
+        warningBlocks++;
+      if (!omittedWarningRows.has(index))
+        otherRows++;
+    }
+    const parts = [];
+    if (warningBlocks > 0)
+      parts.push(`... ${warningBlocks} warnings omitted ...`);
+    if (otherRows > 0)
+      parts.push(`... ${otherRows} lines omitted ...`);
+    return parts.length === 0 ? undefined : parts.join(`
+`);
+  };
+  let rendered = renderGaps(input, selected, (start, end) => describe3(start, end + 1));
+  if (rendered === undefined)
+    return text;
+  const indexes = [...selected];
+  const leading = describe3(0, Math.min(...indexes));
+  const trailing = describe3(Math.max(...indexes) + 1, lines.length);
+  if (leading !== undefined)
+    rendered = `${leading}
+${rendered}`;
+  if (trailing !== undefined)
+    rendered = `${rendered}
+${trailing}`;
+  if (rendered.length > MAX_OUTPUT)
+    return text;
+  for (const block of errors4)
+    for (let index = block.start;index <= block.end; index++)
+      if (!rendered.includes(lines[index] ?? ""))
+        return text;
+  return rendered;
+}
+
+// packages/rtk/src/filters/search.ts
+var FULL = /^((?:[A-Za-z]:\\[^\n:]+|[^\n:]+)):(\d+):(.+)$/;
+var CONTEXT = /^((?:[A-Za-z]:\\[^\n]+|[^\n]+))-(\d+)-(.+)$/;
+var HEADING_MATCH = /^\d+:.+$/;
+var HEADING_CONTEXT = /^\d+-.+$/;
+var PATH = /^(?:[A-Za-z]:\\|[./~])?[^\n:]+$/;
+function retainedRecords(group, mode) {
+  const matches = group.records.flatMap((record2, index) => record2.kind === "match" ? [index] : []);
+  const retained = new Set(matches.length <= 12 ? matches : [...matches.slice(0, 6), ...matches.slice(-6)]);
+  const selected = new Set;
+  for (const match of retained) {
+    selected.add(match);
+    for (let index = match - 1;index >= 0; index--) {
+      const record2 = group.records[index];
+      if (record2?.kind === "match")
+        break;
+      if (record2?.kind === "separator")
+        selected.add(index);
+    }
+    for (let index = match + 1;index < group.records.length; index++) {
+      const record2 = group.records[index];
+      if (record2?.kind === "match")
+        break;
+      if (record2?.kind === "separator")
+        selected.add(index);
+    }
+    let before = mode.beforeContext;
+    for (let index = match - 1;index >= 0 && before > 0; index--) {
+      const record2 = group.records[index];
+      if (record2?.kind === "match")
+        break;
+      if (record2?.kind === "context")
+        before--;
+      if (record2 !== undefined)
+        selected.add(index);
+    }
+    let after = mode.afterContext;
+    for (let index = match + 1;index < group.records.length && after > 0; index++) {
+      const record2 = group.records[index];
+      if (record2?.kind === "match")
+        break;
+      if (record2?.kind === "context")
+        after--;
+      if (record2 !== undefined)
+        selected.add(index);
+    }
+  }
+  for (let index = 0;index < group.records.length; index++)
+    if (group.records[index]?.kind === "heading")
+      selected.add(index);
+  return {
+    records: group.records.filter((_2, index) => selected.has(index)),
+    omittedMatches: matches.length - retained.size
+  };
+}
+function render(input, groups, mode) {
+  if (!input.budget.chargeRecords(groups.length))
+    return;
+  const base = groups.length <= 40 ? groups : [...groups.slice(0, 20), ...groups.slice(-20)];
+  const retained = new Set(base);
+  for (const group of groups)
+    if (group.matches === 1)
+      retained.add(group);
+  const output = [];
+  let omitted = [];
+  const flushOmitted = () => {
+    if (omitted.length === 0)
+      return;
+    const matches = omitted.reduce((sum, group) => sum + group.matches, 0);
+    output.push(`... ${omitted.length} ${omitted.length === 1 ? "file" : "files"} omitted containing ${matches} ${matches === 1 ? "match" : "matches"} ...`);
+    omitted = [];
+  };
+  for (const group of groups) {
+    if (!retained.has(group)) {
+      omitted.push(group);
+      continue;
+    }
+    flushOmitted();
+    const selection = retainedRecords(group, mode);
+    if (!input.budget.chargeRecords(selection.records.length))
+      return;
+    output.push(...selection.records.map((record2) => record2.text));
+    if (selection.omittedMatches > 0) {
+      const unit = selection.omittedMatches === 1 ? "match" : "matches";
+      output.push(`... ${selection.omittedMatches} ${unit} omitted from ${group.file} ...`);
+    }
+  }
+  flushOmitted();
+  const content = output.join(`
+`);
+  return input.budget.chargeCodeUnits(content.length) && content.length <= MAX_OUTPUT ? content : undefined;
+}
+function compressGrep(input, mode) {
+  const groups = new Map;
+  let heading;
+  let activeFile;
+  let pendingSeparator = false;
+  for (const line of input.lines) {
+    if (line === "--") {
+      if (activeFile === undefined || pendingSeparator)
+        return input.text;
+      pendingSeparator = true;
+      continue;
+    }
+    if (mode.heading && PATH.test(line) && !HEADING_MATCH.test(line) && !HEADING_CONTEXT.test(line)) {
+      heading = line;
+      activeFile = line;
+      const group2 = groups.get(line) ?? { file: line, records: [], matches: 0 };
+      if (!input.budget.chargeRecords(1))
+        return input.text;
+      group2.records.push({ kind: "heading", text: line });
+      groups.set(line, group2);
+      continue;
+    }
+    const full = line.match(FULL);
+    const context = mode.beforeContext > 0 || mode.afterContext > 0 ? line.match(CONTEXT) : null;
+    const file3 = mode.heading ? heading : full?.[1] ?? context?.[1];
+    const matched = mode.heading ? HEADING_MATCH.test(line) : full !== null;
+    const validContext = mode.heading ? (mode.beforeContext > 0 || mode.afterContext > 0) && HEADING_CONTEXT.test(line) : context !== null;
+    if (file3 === undefined || !matched && !validContext)
+      return input.text;
+    if (pendingSeparator && file3 !== activeFile)
+      return input.text;
+    const group = groups.get(file3) ?? { file: file3, records: [], matches: 0 };
+    const addedRecords = pendingSeparator ? 2 : 1;
+    if (!input.budget.chargeRecords(addedRecords))
+      return input.text;
+    if (pendingSeparator)
+      group.records.push({ kind: "separator", text: "--" });
+    group.records.push({ kind: matched ? "match" : "context", text: line });
+    if (matched)
+      group.matches++;
+    groups.set(file3, group);
+    activeFile = file3;
+    pendingSeparator = false;
+  }
+  if (groups.size === 0 || pendingSeparator)
+    return input.text;
+  return render(input, [...groups.values()], mode) ?? input.text;
+}
+
+// packages/rtk/src/filters/status.ts
+var HEADER = /^(?:## .+|On branch .+|HEAD detached at .+|HEAD detached from .+)$/;
+var OPERATION = /^(?:(?:(?:interactive )?rebase|merge|cherry-pick|revert|bisect)(?: in progress| currently|ing|ing in progress| .*)|You are currently rebasing .+|All conflicts fixed but you are still merging\.)/i;
+var CHATTER = /^ {2}\((?:use |fix conflicts|all conflicts|no commands remaining).+\)$/i;
+var RELATION = /^(?:Your branch (?:is ahead of|is behind|and .+ have diverged).*[,.]|and have \d+ and \d+ different commits each, respectively\.)$/;
+var SECTION = /^(?:Changes to be committed|Changes not staged for commit|Unmerged paths|Untracked files):$/;
+var FINAL = /^(?:nothing to commit, working tree clean|no changes added to commit .+|nothing added to commit but untracked files present .+)$/;
+var LONG_RECORD = /^\t(?:modified|deleted|new file|renamed|copied|both modified|both added|added by us|added by them|deleted by us|deleted by them):\s+.+$/;
+var XY = new Set([
+  " M",
+  "M ",
+  "MM",
+  " A",
+  "A ",
+  "AM",
+  " D",
+  "D ",
+  "DM",
+  " R",
+  "R ",
+  "RM",
+  " C",
+  "C ",
+  "CM",
+  "??",
+  "!!",
+  "DD",
+  "AU",
+  "UD",
+  "UA",
+  "DU",
+  "AA",
+  "UU"
+]);
+function statusRecord(line) {
+  if (line.length < 3 || !XY.has(line.slice(0, 2)))
+    return false;
+  const separator = line[2];
+  if (separator !== " " && separator !== "\t")
+    return false;
+  const path = line.slice(3);
+  if (path.length === 0)
+    return false;
+  if (line[0] === "R" || line[1] === "R" || line[0] === "C" || line[1] === "C")
+    return /^.+ -> .+$/.test(path);
+  return true;
+}
+function append(input, output, line) {
+  if (!input.budget.chargeRecords(1) || !input.budget.chargeCodeUnits(line.length))
+    return false;
+  output.push(line);
+  return true;
+}
+function compressGitStatus(input) {
+  const output = [];
+  let section;
+  let long = false;
+  let sawRecord = false;
+  for (const line of input.lines) {
+    if (line.length === 0)
+      continue;
+    if (!input.budget.chargeRecords(1))
+      return input.text;
+    if (SECTION.test(line)) {
+      long = true;
+      section = line === "Untracked files:" ? "untracked" : "tracked";
+      if (!append(input, output, line))
+        return input.text;
+      continue;
+    }
+    if (HEADER.test(line) || RELATION.test(line) || OPERATION.test(line) || FINAL.test(line)) {
+      if (!append(input, output, line))
+        return input.text;
+      continue;
+    }
+    if (CHATTER.test(line))
+      continue;
+    if (long) {
+      const record2 = section === "untracked" ? /^\t\S.+$/.test(line) : LONG_RECORD.test(line);
+      if (!record2)
+        return input.text;
+      sawRecord = true;
+      if (!append(input, output, line))
+        return input.text;
+      continue;
+    }
+    if (!statusRecord(line))
+      return input.text;
+    sawRecord = true;
+    if (!append(input, output, line))
+      return input.text;
+  }
+  if (!sawRecord)
+    return input.text;
+  const rendered = output.join(`
+`);
+  return rendered.length <= MAX_OUTPUT ? rendered : input.text;
+}
+
+// packages/rtk/src/filters/tests.ts
+function isFailureStart(line, executable) {
+  if (executable === "vitest")
+    return /^\s*FAIL\s{2}\S.+\s>\s/.test(line);
+  if (executable === "jest")
+    return /^\s*\u25CF\s/.test(line);
+  if (executable === "bun")
+    return /^\s*(?:FAIL\s|UnhandledPromiseRejection|Uncaught exception|panic:|error:.*(?:hook|unhandled rejection))/.test(line);
+  if (executable === "pytest")
+    return /^\s*(?:FAILED\s|={2,} FAILURES ={2,}|ERROR collecting)/.test(line);
+  if (executable === "go")
+    return /^\s*(?:--- FAIL:|# \S|FAIL\s+\S+\s+\[build failed\])/.test(line);
+  return /^\s*(?:FAIL\b|--- FAIL:|FAILED\b|={2,} FAILURES ={2,}|panic:|ERROR collecting|\u25CF )/.test(line);
+}
+function isSummary(line, executable) {
+  if (executable === "bun")
+    return /^(?:\d+ (?:pass|fail|skip|todo)|Ran \d+ tests?|error: \d+ unhandled)/.test(line);
+  if (executable === "vitest")
+    return /^(?:Test Files|Tests |Snapshots |Snapshots:|Projects? |Shards? |Attachments? |Retries? )/i.test(line);
+  if (executable === "jest")
+    return /^(?:Test Suites:|Tests:|Snapshots:)/.test(line);
+  if (executable === "pytest")
+    return /(?:\d+ (?:passed|failed|errors?|skipped|xfailed|xpassed))(?:,| in|$)/.test(line) || /^=+ short test summary/.test(line);
+  if (executable === "go")
+    return /^(?:--- SKIP:|(?:ok|FAIL)\s+\S)/.test(line);
+  return /^(?:\d+ (?:pass|fail|skip|todo)|Ran \d+ tests?|Tests?:|Test Files|Snapshots:|test result:|(?:ok|FAIL)\s+\S|=+ .* (?:passed|failed|error|skipped))/i.test(line);
+}
+function isFailureSummary(line, executable) {
+  if (executable === "bun")
+    return /^(?:[1-9]\d* fail|error: [1-9]\d* unhandled)/.test(line);
+  if (["vitest", "jest"].includes(executable))
+    return /(?:^|\s)[1-9]\d* failed/.test(line);
+  if (executable === "pytest")
+    return /[1-9]\d* (?:failed|errors?)/.test(line);
+  if (executable === "go")
+    return /^FAIL\s+\S/.test(line);
+  return /(?:[1-9]\d* fail|[1-9]\d* failed|FAIL\s+\S)/.test(line);
+}
+function compressTests(input, executable = "unknown") {
+  const { text, lines } = input;
+  const selected = new Set;
+  const starts = [];
+  let hasFailureSummary = false;
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index] ?? "";
+    if (isFailureStart(line, executable))
+      starts.push(index);
+    if (isSummary(line, executable))
+      selected.add(index);
+    if (isFailureSummary(line, executable))
+      hasFailureSummary = true;
+  }
+  if (hasFailureSummary && starts.length === 0)
+    return text;
+  for (let offset = 0;offset < starts.length; offset++) {
+    const start = starts[offset];
+    if (start === undefined || !input.budget.chargeRecords(1))
+      return text;
+    const nextFailure = starts[offset + 1] ?? lines.length;
+    let end = start;
+    while (end + 1 < nextFailure) {
+      const line = lines[end + 1] ?? "";
+      if (/^progress \d+$/.test(line) || isSummary(line, executable))
+        break;
+      end++;
+    }
+    const count = end - start + 1;
+    if (!input.budget.chargeRecords(count))
+      return text;
+    for (let index = start;index <= end; index++)
+      selected.add(index);
+  }
+  if (selected.size === 0)
+    return text;
+  let rendered = renderGaps(input, selected, (start, end) => `... ${end - start + 1} lines omitted ...`);
+  if (rendered === undefined)
+    return text;
+  const indexes = [...selected];
+  const leading = Math.min(...indexes);
+  const trailing = lines.length - 1 - Math.max(...indexes);
+  if (leading > 0)
+    rendered = `... ${leading} lines omitted ...
+${rendered}`;
+  if (trailing > 0)
+    rendered = `${rendered}
+... ${trailing} lines omitted ...`;
+  if (rendered.length > MAX_OUTPUT)
+    return text;
+  for (const start of starts)
+    if (!rendered.includes(lines[start] ?? ""))
+      return text;
+  return rendered;
+}
+
+// packages/rtk/src/index.ts
+var MIN_INPUT = 500;
+var MAX_INPUT = 1e6;
+var MAX_OUTPUT2 = 250000;
+var SHELL = new Set(["bash", "shell", "terminal", "exec", "run_command", "execute_command"]);
+var NON_SHELL = new Set([
+  "read",
+  "edit",
+  "write",
+  "glob",
+  "grep_search",
+  "search",
+  "web_search",
+  "web_fetch",
+  "read_file",
+  "list_directory",
+  "find_files",
+  "code_search",
+  "apply_patch"
+]);
+function emptyReport(errors4 = 0) {
+  return {
+    applied: false,
+    filterHits: 0,
+    originalCodeUnits: 0,
+    compressedCodeUnits: 0,
+    estimatedTokensSaved: 0,
+    filters: [],
+    skippedInternalErrors: errors4
+  };
+}
+function normalizeName(name) {
+  return name.toLowerCase().replace(/[-./\s]+/g, "_");
+}
+function originOf(tool) {
+  if (tool === undefined)
+    return "unknown";
+  const name = normalizeName(tool.name);
+  if (SHELL.has(name))
+    return "shell";
+  if (NON_SHELL.has(name))
+    return "non-shell";
+  return "unknown";
+}
+function extractCommand(input) {
+  if (typeof input === "string")
+    return input.length === 0 ? undefined : input;
+  if (input === null || typeof input !== "object" || Array.isArray(input))
+    return;
+  if (Object.getPrototypeOf(input) !== Object.prototype)
+    return;
+  const object2 = input;
+  for (const key of ["command", "cmd", "script"]) {
+    if (!Object.hasOwn(object2, key))
+      continue;
+    const value = object2[key];
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  return;
+}
+function prefix(lines) {
+  return lines.slice(0, 64).join(`
+`).slice(0, 4096);
+}
+function sampleRows(lines) {
+  return lines.length <= 128 ? lines : [...lines.slice(0, 64), ...lines.slice(-64)];
+}
+function detect(input, command, origin) {
+  const { lines } = input;
+  const sample = prefix(lines);
+  const classification = origin === "shell" && command !== undefined ? classifyCommand(command) : undefined;
+  if (origin === "shell" && command !== undefined && classification === undefined)
+    return;
+  if (classification !== undefined)
+    return { id: classification.family, classification };
+  if (GIT_DIFF_EVIDENCE_HEADER.test(sample) && GIT_DIFF_EVIDENCE_PAIR.test(sample))
+    return { id: "git-diff" };
+  if (/^(?:On branch |## |Changes |Untracked files:)/m.test(sample) && /^(?:[ MADRCU?!]{2} |\s+(?:modified|deleted|new file):)/m.test(sample))
+    return { id: "git-status" };
+  if (GIT_LOG_EVIDENCE_COMMIT.test(sample) && GIT_LOG_EVIDENCE_BODY.test(sample))
+    return { id: "git-log" };
+  if (origin === "unknown") {
+    const inferred = inferBuildOrTest(sampleRows(lines));
+    if (inferred !== undefined)
+      return { id: inferred };
+  }
+  const inferredGrepRows = lines.filter((line) => /^(?:[A-Za-z]:\\.+|[^\n:]+):\d+:.+$/.test(line));
+  if (origin === "unknown" && inferredGrepRows.length >= 3 && inferredGrepRows.length / Math.max(1, lines.filter((line) => line.length > 0).length) >= 0.8)
+    return {
+      id: "grep",
+      classification: {
+        family: "grep",
+        executable: "inferred",
+        grepMode: { heading: false, lineNumber: true, beforeContext: 0, afterContext: 0 }
+      }
+    };
+  let candidates = 0;
+  let pathLines = 0;
+  let conflicts = 0;
+  for (const line of lines) {
+    if (line.length === 0)
+      continue;
+    candidates++;
+    if (/^(?![[{`|])(?!.+:\d+(?::|$))[^\s:\n]+(?:[/\\][^\s:\n]+)*$/.test(line))
+      pathLines++;
+    if (/\s(?:is|are|the|this|that)\s/i.test(line) || /^(?:```|\{|\[)|\|.+\|$/.test(line))
+      conflicts++;
+  }
+  if (candidates >= 10 && pathLines / candidates >= 0.8 && conflicts / candidates <= 0.1)
+    return { id: "path-list" };
+  if (origin === "shell" && (sample.match(/^\s*\d+[\t |:].+$/gm)?.length ?? 0) >= 10)
+    return { id: "numbered-read" };
+  return;
+}
+function keepRegions(input, head, tail) {
+  const selected = new Set;
+  if (!input.budget.chargeRecords(head + tail))
+    return input.text;
+  for (let index = 0;index < Math.min(head, input.lines.length); index++)
+    selected.add(index);
+  for (let index = Math.max(head, input.lines.length - tail);index < input.lines.length; index++)
+    selected.add(index);
+  return renderSelection(input, selected) ?? input.text;
+}
+function deduplicate(input) {
+  const selected = new Set;
+  let previous;
+  for (let index = 0;index < input.lines.length; index++) {
+    const line = input.lines[index] ?? "";
+    if (line === previous)
+      continue;
+    if (!input.budget.chargeRecords(1))
+      return input.text;
+    selected.add(index);
+    previous = line;
+  }
+  return renderSelection(input, selected) ?? input.text;
+}
+function keepAnchors(input, isAnchor, head, tail) {
+  const selected = new Set;
+  for (let index = 0;index < input.lines.length; index++) {
+    if (index < head || index >= input.lines.length - tail || isAnchor(input.lines[index] ?? "")) {
+      if (!input.budget.chargeRecords(1))
+        return input.text;
+      selected.add(index);
+    }
+  }
+  return renderSelection(input, selected) ?? input.text;
+}
+function specialized(input, id, classification) {
+  const { text: content, lines } = input;
+  if (id === "git-status")
+    return compressGitStatus(input);
+  if (id === "lint-output")
+    return compressDiagnostics(input);
+  if (id === "build-output")
+    return compressBuild(input);
+  if (id === "test-output")
+    return compressTests(input, classification?.executable);
+  if (id === "package-output")
+    return compressPackages(input, classification?.executable ?? "unknown");
+  if (id === "git-operation")
+    return compressGitOperation(input);
+  if (id === "docker-build")
+    return compressDocker(input);
+  if (id === "tree-output" || id === "path-list")
+    return compressListing(input, classification?.executable ?? "find", classification?.subcommand, classification !== undefined);
+  if (id === "grep" && classification?.grepMode !== undefined)
+    return compressGrep(input, classification.grepMode);
+  if (!input.budget.chargeRecords(lines.length))
+    return content;
+  switch (id) {
+    case "git-diff":
+      return keepAnchors(input, (line) => GIT_DIFF_ANCHOR.test(line), 20, 12);
+    case "git-log":
+      return keepAnchors(input, (line) => GIT_LOG_ANCHOR.test(line), 20, 12);
+    case "grep":
+      return keepRegions(input, 40, 20);
+    case "numbered-read":
+      return lines.length >= 250 ? keepRegions(input, 100, 50) : content;
+    case "deduplicate-log":
+      return deduplicate(input);
+    case "smart-truncate":
+      return keepRegions(input, 200, 100);
+  }
+}
+function accept(original, candidate) {
+  return candidate.length > 0 && candidate.length < original.length && candidate.length <= MAX_OUTPUT2 ? candidate : undefined;
+}
+function filter(input, origin, command) {
+  const { text: content, lines } = input;
+  const detection = detect(input, command, origin);
+  if (detection !== undefined) {
+    const { id, classification } = detection;
+    const first = accept(content, specialized(input, id, classification));
+    if (first === undefined)
+      return;
+    return { content: first, filters: [id] };
+  }
+  if (origin !== "shell")
+    return;
+  if (lines.length >= 20) {
+    const compact = accept(content, deduplicate(input));
+    if (compact !== undefined)
+      return { content: compact, filters: ["deduplicate-log"] };
+  }
+  if (lines.length >= 500) {
+    const compact = accept(content, specialized(input, "smart-truncate"));
+    if (compact !== undefined)
+      return { content: compact, filters: ["smart-truncate"] };
+  }
+  return;
+}
+function transformRequest(request2, config2) {
+  if (!config2.enabled)
+    return { request: request2, report: emptyReport() };
+  try {
+    const uses = new Map;
+    let changed = false;
+    let originalCodeUnits = 0;
+    let compressedCodeUnits = 0;
+    let filterHits = 0;
+    let skippedInternalErrors = 0;
+    const filterOrder = [];
+    const messages = request2.messages.map((message) => {
+      let messageChanged = false;
+      const content = message.content.map((block) => {
+        if (block.type === "toolUse") {
+          uses.set(block.id, block);
+          return block;
+        }
+        if (block.type !== "toolResult" || block.isError === true || block.cacheControl !== undefined || block.content.length < MIN_INPUT || block.content.length > MAX_INPUT)
+          return block;
+        const use = uses.get(block.toolUseId);
+        const origin = originOf(use);
+        if (origin === "non-shell")
+          return block;
+        try {
+          const command = origin === "shell" && use !== undefined ? extractCommand(use.input) : undefined;
+          const bounded = scanText(block.content);
+          if (bounded === undefined)
+            return block;
+          const result = filter(bounded, origin, command);
+          if (result === undefined)
+            return block;
+          changed = true;
+          messageChanged = true;
+          originalCodeUnits += block.content.length;
+          compressedCodeUnits += result.content.length;
+          filterHits += result.filters.length;
+          for (const id of result.filters)
+            if (!filterOrder.includes(id))
+              filterOrder.push(id);
+          return { ...block, content: result.content };
+        } catch {
+          skippedInternalErrors++;
+          return block;
+        }
+      });
+      return messageChanged ? { ...message, content } : message;
+    });
+    if (!changed)
+      return { request: request2, report: { ...emptyReport(), skippedInternalErrors } };
+    const transformed = { ...request2, messages };
+    return {
+      request: transformed,
+      report: {
+        applied: true,
+        filterHits,
+        originalCodeUnits,
+        compressedCodeUnits,
+        estimatedTokensSaved: Math.max(0, estimateInputTokens(request2) - estimateInputTokens(transformed)),
+        filters: filterOrder,
+        skippedInternalErrors
+      }
+    };
+  } catch {
+    return { request: request2, report: emptyReport(1) };
+  }
+}
+
 // apps/gateway/src/logging.ts
 function requestLogDefaults(id, at) {
   return {
@@ -38628,7 +41165,13 @@ function requestLogDefaults(id, at) {
     ttftMs: null,
     durationMs: 0,
     costUsd: 0,
-    degradations: []
+    degradations: [],
+    rtkApplied: false,
+    rtkFilterHits: 0,
+    rtkOriginalCodeUnits: 0,
+    rtkCompressedCodeUnits: 0,
+    rtkEstimatedTokensSaved: 0,
+    rtkFilters: []
   };
 }
 function newCompletedRequestLog(id, at, overrides) {
@@ -38763,11 +41306,12 @@ async function dispatch(request2, deps, signal, requestId) {
   const logger2 = deps.logger ?? noopLogger;
   const startedAt = deps.now();
   const snapshot = await deps.snapshots.get(startedAt);
-  const deadlineAt = startedAt + snapshot.settings.requestDeadlineMs;
+  const deadlineAt = snapshot.settings.requestDeadlineMs === 0 ? null : startedAt + snapshot.settings.requestDeadlineMs;
   const log = newCompletedRequestLog(requestId, startedAt, {
     requestedModel: request2.model,
     status: 0
   });
+  let dispatchRequest = request2;
   const fail = (code, message) => {
     log.errorCode = code;
     log.status = HTTP_STATUS[code];
@@ -38779,36 +41323,45 @@ async function dispatch(request2, deps, signal, requestId) {
       log: () => log
     };
   };
-  const deadlineController = new AbortController;
-  const abortFromClient = () => deadlineController.abort(signal.reason);
+  const dispatchController = new AbortController;
+  const abortFromClient = () => dispatchController.abort(signal.reason);
   if (signal.aborted)
     abortFromClient();
   else
     signal.addEventListener("abort", abortFromClient, { once: true });
-  const deadlineTimer = setTimeout(() => deadlineController.abort(new GatewayError("TIMEOUT", "request deadline exceeded")), Math.max(0, deadlineAt - deps.now()));
-  const dispatchSignal = deadlineController.signal;
+  const deadlineTimer = deadlineAt === null ? null : setTimeout(() => dispatchController.abort(new GatewayError("TIMEOUT", "request deadline exceeded")), Math.max(0, deadlineAt - deps.now()));
+  const dispatchSignal = dispatchController.signal;
   const clearDeadline = () => {
-    clearTimeout(deadlineTimer);
+    if (deadlineTimer !== null)
+      clearTimeout(deadlineTimer);
     signal.removeEventListener("abort", abortFromClient);
   };
   const checkCancellation = () => {
-    if (!dispatchSignal.aborted)
-      return;
     if (signal.aborted)
       throw signal.reason;
-    throw new GatewayError("TIMEOUT", "request deadline exceeded");
+    if (deadlineAt !== null && (dispatchSignal.aborted || deps.now() >= deadlineAt))
+      throw new GatewayError("TIMEOUT", "request deadline exceeded");
   };
   let model;
   try {
     checkCancellation();
-    model = resolveModel(request2.model, snapshot);
+    const transformed = transformRequest(request2, { enabled: snapshot.settings.rtkEnabled });
+    dispatchRequest = transformed.request;
+    log.rtkApplied = transformed.report.applied;
+    log.rtkFilterHits = transformed.report.filterHits;
+    log.rtkOriginalCodeUnits = transformed.report.originalCodeUnits;
+    log.rtkCompressedCodeUnits = transformed.report.compressedCodeUnits;
+    log.rtkEstimatedTokensSaved = transformed.report.estimatedTokensSaved;
+    log.rtkFilters = transformed.report.filters;
+    checkCancellation();
+    model = resolveModel(dispatchRequest.model, snapshot);
   } catch (error51) {
     const { code } = classify(error51);
     clearDeadline();
     return fail(code, error51 instanceof Error ? error51.message : "unresolvable model");
   }
   const { candidates, excluded } = rank({
-    request: request2,
+    request: dispatchRequest,
     model,
     snapshot,
     now: startedAt,
@@ -38822,10 +41375,11 @@ async function dispatch(request2, deps, signal, requestId) {
     count: candidates.length
   });
   for (const e of excluded) {
-    log.degradations.push(`excluded:${e.credentialId}:${e.reason}`);
+    const capabilityOnly = e.reason === "capability:anthropicTools";
+    log.degradations.push(capabilityOnly ? `excluded:${e.reason}` : `excluded:${e.credentialId}:${e.reason}`);
     logger2.debug("routing candidate excluded", {
       requestId,
-      credentialId: e.credentialId,
+      ...capabilityOnly ? {} : { credentialId: e.credentialId },
       reason: e.reason
     });
   }
@@ -38843,11 +41397,14 @@ async function dispatch(request2, deps, signal, requestId) {
       let lastError = null;
       candidateLoop:
         for (let i = 0;i < maxAttempts; i++) {
-          if (dispatchSignal.aborted && !signal.aborted) {
-            lastError = new GatewayError("TIMEOUT", "request deadline exceeded");
+          try {
+            checkCancellation();
+          } catch (error51) {
+            if (signal.aborted)
+              throw signal.reason;
+            lastError = error51 instanceof GatewayError ? error51 : new GatewayError("TIMEOUT", "request deadline exceeded");
             break;
           }
-          checkCancellation();
           const candidate = candidates[i];
           log.attempts = i + 1;
           log.credentialId = candidate.credential.id;
@@ -38879,7 +41436,7 @@ async function dispatch(request2, deps, signal, requestId) {
             try {
               const result = await waitForCancellation(attempt({
                 candidate,
-                request: request2,
+                request: dispatchRequest,
                 adapter: deps.adapters[candidate.target.provider],
                 http: deps.http,
                 now: attemptNow,
@@ -38964,7 +41521,7 @@ async function dispatch(request2, deps, signal, requestId) {
             } catch (error51) {
               if (signal.aborted)
                 throw signal.reason;
-              const classifiedError = dispatchSignal.aborted ? { code: "TIMEOUT" } : classify(error51);
+              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 });
@@ -38984,7 +41541,7 @@ async function dispatch(request2, deps, signal, requestId) {
                 } catch (refreshError) {
                   if (signal.aborted)
                     throw signal.reason;
-                  const classified = dispatchSignal.aborted ? { code: "TIMEOUT" } : classify(refreshError);
+                  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
@@ -39041,8 +41598,8 @@ async function dispatch(request2, deps, signal, requestId) {
       };
     } finally {
       clearDeadline();
-      if (!deadlineController.signal.aborted)
-        deadlineController.abort();
+      if (!dispatchController.signal.aborted)
+        dispatchController.abort();
     }
   }
   return { events: run(), log: () => log };
@@ -39069,7 +41626,8 @@ var STOP_REASON2 = {
   maxTokens: "max_tokens",
   stopSequence: "stop_sequence",
   toolUse: "tool_use",
-  contentFilter: "refusal"
+  contentFilter: "refusal",
+  pauseTurn: "pause_turn"
 };
 var ERROR_TYPE2 = {
   AUTH: "authentication_error",
@@ -39125,7 +41683,7 @@ async function* anthropicStream(events, requestId) {
           suppressed.add(event.index);
           break;
         }
-        const content_block = b.type === "text" ? { type: "text", text: "" } : b.type === "thinking" ? { type: "thinking", thinking: "" } : { type: "tool_use", id: b.id, name: b.name, input: {} };
+        const content_block = b.type === "text" ? { type: "text", text: "" } : b.type === "thinking" ? { type: "thinking", thinking: "" } : b.type === "anthropicNative" ? { ...b.data, type: b.blockType } : { type: "tool_use", id: b.id, name: b.name, input: {} };
         const index = nextOutIndex++;
         outIndex.set(event.index, index);
         yield frame("content_block_start", {
@@ -39139,7 +41697,7 @@ async function* anthropicStream(events, requestId) {
         if (suppressed.has(event.index))
           break;
         const d = event.delta;
-        const delta2 = d.type === "text" ? { type: "text_delta", text: d.text } : d.type === "thinking" ? { type: "thinking_delta", thinking: d.text } : d.type === "thinkingSignature" ? { type: "signature_delta", signature: d.signature } : { type: "input_json_delta", partial_json: d.partial };
+        const delta2 = d.type === "text" ? { type: "text_delta", text: d.text } : d.type === "thinking" ? { type: "thinking_delta", thinking: d.text } : d.type === "thinkingSignature" ? { type: "signature_delta", signature: d.signature } : d.type === "anthropicNative" ? { type: d.deltaType, ...d.data } : { type: "input_json_delta", partial_json: d.partial };
         yield frame("content_block_delta", {
           type: "content_block_delta",
           index: outIndex.get(event.index) ?? event.index,
@@ -39186,11 +41744,17 @@ function anthropicResponse(collected, requestId) {
     content: collected.content.filter((b) => b.type !== "thinking" || b.signature !== undefined && b.signature !== "").map((b) => {
       switch (b.type) {
         case "text":
-          return { type: "text", text: b.text };
+          return {
+            type: "text",
+            text: b.text,
+            ...b.citations === undefined ? {} : { citations: b.citations }
+          };
         case "thinking":
           return { type: "thinking", thinking: b.text, signature: b.signature };
         case "toolUse":
           return { type: "tool_use", id: b.id, name: b.name, input: b.input };
+        case "anthropicNative":
+          return { ...b.data, type: b.blockType };
         default:
           return { type: "text", text: "" };
       }
@@ -39224,7 +41788,8 @@ var FINISH2 = {
   maxTokens: "length",
   stopSequence: "stop",
   toolUse: "tool_calls",
-  contentFilter: "content_filter"
+  contentFilter: "content_filter",
+  pauseTurn: "stop"
 };
 var ERROR_TYPE3 = {
   AUTH: { type: "invalid_request_error", code: "invalid_api_key" },
@@ -39361,11 +41926,199 @@ function openaiErrorBody(code, message) {
   return { error: { message, type: e.type, code: e.code } };
 }
 
+// apps/gateway/src/ingress/anthropicTools.ts
+var TOOL_FIELDS = {
+  cache_control: cacheControlSchema.nullable(),
+  strict: exports_external.boolean().nullable(),
+  defer_loading: exports_external.boolean().nullable(),
+  allowed_callers: exports_external.array(exports_external.enum(ANTHROPIC_TOOL_CALLERS)).nullable(),
+  input_examples: exports_external.array(exports_external.record(exports_external.string(), exports_external.unknown())).nullable(),
+  eager_input_streaming: exports_external.boolean().nullable(),
+  max_uses: exports_external.number().int().positive().nullable(),
+  allowed_domains: exports_external.array(exports_external.string()).nullable(),
+  blocked_domains: exports_external.array(exports_external.string()).nullable(),
+  user_location: exports_external.object({
+    type: exports_external.literal("approximate"),
+    city: exports_external.string().optional(),
+    region: exports_external.string().optional(),
+    country: exports_external.string().optional(),
+    timezone: exports_external.string().optional()
+  }).nullable(),
+  citations: exports_external.object({ enabled: exports_external.boolean() }).nullable(),
+  max_content_tokens: exports_external.number().int().positive().nullable(),
+  use_cache: exports_external.boolean().nullable(),
+  response_inclusion: exports_external.enum(["full", "excluded"]).nullable(),
+  display_width_px: exports_external.number().int().positive(),
+  display_height_px: exports_external.number().int().positive(),
+  display_number: exports_external.number().int().nullable(),
+  enable_zoom: exports_external.boolean().nullable(),
+  max_characters: exports_external.number().int().positive().nullable(),
+  model: exports_external.string().min(1),
+  caching: cacheControlSchema.nullable(),
+  max_tokens: exports_external.number().int().positive().nullable(),
+  mcp_server_name: exports_external.string().min(1),
+  configs: exports_external.record(exports_external.string(), exports_external.unknown()).nullable(),
+  default_config: exports_external.record(exports_external.string(), exports_external.unknown()).nullable()
+};
+var customToolSchema = exports_external.object({
+  type: exports_external.literal("custom").nullish(),
+  name: exports_external.string().min(1),
+  description: exports_external.string().optional(),
+  input_schema: exports_external.record(exports_external.string(), exports_external.unknown()),
+  cache_control: cacheControlSchema.nullish()
+});
+function fail(path, message) {
+  throw new GatewayError("BAD_REQUEST", `${path}: ${message}`);
+}
+function field(path, name, value) {
+  const schema = TOOL_FIELDS[name];
+  if (schema === undefined)
+    fail(`${path}.${name}`, `unsupported field "${name}"`);
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    fail(`${path}.${name}`, parsed.error.issues[0]?.message ?? "invalid value");
+  }
+  return parsed.data;
+}
+function parseAnthropicTool(raw, type, path, mcpServerNames) {
+  const spec = anthropicToolSpec(type);
+  if (spec === undefined)
+    fail(`${path}.type`, `unrecognized tool type "${type}"`);
+  if (spec.name !== undefined && raw.name !== spec.name) {
+    fail(`${path}.name`, `${type} must be declared with name "${spec.name}"`);
+  }
+  if (spec.name === undefined && raw.name !== undefined) {
+    fail(`${path}.name`, `${type} does not take a name`);
+  }
+  for (const required2 of spec.required) {
+    if (raw[required2] === undefined)
+      fail(`${path}.${required2}`, `${type} requires ${required2}`);
+  }
+  const allowed = new Set([...spec.required, ...spec.optional]);
+  const wire = {};
+  let cacheControl;
+  for (const [key, value] of Object.entries(raw)) {
+    if (key === "type" || key === "name")
+      continue;
+    if (!allowed.has(key))
+      fail(`${path}.${key}`, `${type} does not accept "${key}"`);
+    const parsed = field(path, key, value);
+    if (key === "cache_control") {
+      cacheControl = irCacheControl(parsed === null ? undefined : parsed).cacheControl;
+      continue;
+    }
+    if (parsed !== null)
+      wire[key] = parsed;
+  }
+  if (wire.allowed_domains !== undefined && wire.blocked_domains !== undefined) {
+    fail(`${path}.blocked_domains`, "allowed_domains and blocked_domains are mutually exclusive");
+  }
+  if (spec.family === "mcpToolset") {
+    const server = wire.mcp_server_name;
+    if (typeof server === "string" && !mcpServerNames.has(server)) {
+      fail(`${path}.mcp_server_name`, `no mcp_servers entry named "${server}"`);
+    }
+  }
+  return {
+    provider: "anthropic",
+    family: spec.family,
+    type,
+    name: spec.name ?? "",
+    wire,
+    ...cacheControl === undefined ? {} : { cacheControl }
+  };
+}
+function parseCustomTool(raw, path) {
+  const parsed = customToolSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issue2 = parsed.error.issues[0];
+    fail(`${path}${issue2?.path.length ? `.${issue2.path.join(".")}` : ""}`, issue2?.message ?? "invalid tool");
+  }
+  const options = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (["type", "name", "description", "input_schema", "cache_control"].includes(key))
+      continue;
+    if (!ANTHROPIC_CUSTOM_TOOL_OPTIONS.includes(key)) {
+      fail(`${path}.${key}`, `unsupported field "${key}"`);
+    }
+    const value_ = field(path, key, value);
+    if (value_ !== null)
+      options[key] = value_;
+  }
+  return {
+    provider: "custom",
+    name: parsed.data.name,
+    ...parsed.data.description === undefined ? {} : { description: parsed.data.description },
+    inputSchema: parsed.data.input_schema,
+    ...irCacheControl(parsed.data.cache_control ?? undefined),
+    ...Object.keys(options).length === 0 ? {} : { options }
+  };
+}
+function parseTools(raw, mcpServerNames) {
+  return raw.map((entry, index) => {
+    const path = `tools.${index}`;
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      fail(path, "expected a tool definition object");
+    }
+    const tool = entry;
+    const type = tool.type;
+    if (type === undefined || type === null || type === "custom") {
+      return parseCustomTool(tool, path);
+    }
+    if (typeof type !== "string")
+      fail(`${path}.type`, "expected a string");
+    return parseAnthropicTool(tool, type, path, mcpServerNames);
+  });
+}
+function mcpServerNames(body2) {
+  const servers = body2.mcp_servers;
+  if (!Array.isArray(servers))
+    return new Set;
+  const names = new Set;
+  for (const server of servers) {
+    if (typeof server === "object" && server !== null) {
+      const name = server.name;
+      if (typeof name === "string")
+        names.add(name);
+    }
+  }
+  return names;
+}
+
+// apps/gateway/src/ingress/model.ts
+var DISCOVERY_PREFIX = "claude/";
+var ONE_M_SUFFIX = "[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 (stripped.length > 0) {
+      model = stripped;
+      wantsOneM = true;
+    }
+  }
+  if (model.toLowerCase().startsWith(DISCOVERY_PREFIX)) {
+    const stripped = model.slice(DISCOVERY_PREFIX.length);
+    if (stripped.length > 0)
+      model = stripped;
+  }
+  const merged = [...betas2];
+  if (wantsOneM && !merged.includes(CONTEXT_1M_BETA))
+    merged.push(CONTEXT_1M_BETA);
+  return { model, betas: merged };
+}
+
 // apps/gateway/src/ingress/anthropic.ts
 var textBlock = exports_external.object({
   type: exports_external.literal("text"),
   text: exports_external.string(),
-  cache_control: cacheControlSchema.optional()
+  cache_control: cacheControlSchema.optional(),
+  citations: exports_external.array(exports_external.unknown()).optional()
+});
+var midConversationTextBlock = textBlock.extend({
+  cache_control: cacheControlSchema.nullable().optional(),
+  citations: exports_external.array(exports_external.unknown()).nullable().optional()
 });
 var imageBlock = exports_external.object({
   type: exports_external.literal("image"),
@@ -39402,9 +42155,137 @@ var block = exports_external.discriminatedUnion("type", [
   toolUseBlock,
   toolResultBlock
 ]);
+var nativeBase = {
+  cache_control: cacheControlSchema.nullable().optional()
+};
+var nativeResultContent = exports_external.unknown().refine((value) => value !== null, {
+  message: "expected native result content"
+});
+var caller = exports_external.discriminatedUnion("type", [
+  exports_external.object({ type: exports_external.literal("direct") }).strict(),
+  exports_external.object({
+    type: exports_external.enum([
+      "code_execution_20250825",
+      "code_execution_20260120",
+      "code_execution_20260521"
+    ]),
+    tool_id: exports_external.string()
+  }).strict()
+]).optional();
+var documentSource = exports_external.discriminatedUnion("type", [
+  exports_external.object({
+    type: exports_external.literal("base64"),
+    media_type: exports_external.literal("application/pdf"),
+    data: exports_external.string()
+  }).strict(),
+  exports_external.object({ type: exports_external.literal("text"), media_type: exports_external.literal("text/plain"), data: exports_external.string() }).strict(),
+  exports_external.object({ type: exports_external.literal("content"), content: exports_external.array(exports_external.unknown()) }).strict(),
+  exports_external.object({ type: exports_external.literal("url"), url: exports_external.string() }).strict(),
+  exports_external.object({ type: exports_external.literal("file"), file_id: exports_external.string() }).strict()
+]);
+var citationsConfig = exports_external.object({ enabled: exports_external.boolean().optional() }).strict();
+var fallbackModel = exports_external.object({ model: exports_external.string() }).strict();
+var toolChangeReference = exports_external.discriminatedUnion("type", [
+  exports_external.object({ type: exports_external.literal("tool_reference"), name: exports_external.string() }).strict(),
+  exports_external.object({ type: exports_external.literal("mcp_tool_reference"), server_name: exports_external.string(), name: exports_external.string() }).strict(),
+  exports_external.object({ type: exports_external.literal("mcp_toolset_reference"), server_name: exports_external.string() }).strict()
+]);
+function nativeToolChange(type) {
+  return exports_external.object({ type: exports_external.literal(type), tool: toolChangeReference, ...nativeBase }).strict();
+}
+var toolAddition = nativeToolChange("tool_addition");
+var toolRemoval = nativeToolChange("tool_removal");
+var midConversationSystem = exports_external.object({
+  type: exports_external.literal("mid_conv_system"),
+  content: exports_external.array(exports_external.discriminatedUnion("type", [midConversationTextBlock.strict(), toolAddition, toolRemoval])),
+  ...nativeBase
+}).strict();
+var nativeSchemas = {
+  server_tool_use: exports_external.object({
+    type: exports_external.literal("server_tool_use"),
+    id: exports_external.string(),
+    name: exports_external.enum([
+      "advisor",
+      "web_search",
+      "web_fetch",
+      "code_execution",
+      "bash_code_execution",
+      "text_editor_code_execution",
+      "tool_search_tool_regex",
+      "tool_search_tool_bm25"
+    ]),
+    input: exports_external.unknown(),
+    caller,
+    ...nativeBase
+  }).strict(),
+  web_search_tool_result: nativeResult("web_search_tool_result", true),
+  web_fetch_tool_result: nativeResult("web_fetch_tool_result", true),
+  code_execution_tool_result: nativeResult("code_execution_tool_result"),
+  bash_code_execution_tool_result: nativeResult("bash_code_execution_tool_result"),
+  text_editor_code_execution_tool_result: nativeResult("text_editor_code_execution_tool_result"),
+  tool_search_tool_result: nativeResult("tool_search_tool_result"),
+  advisor_tool_result: nativeResult("advisor_tool_result"),
+  mcp_tool_use: exports_external.object({
+    type: exports_external.literal("mcp_tool_use"),
+    id: exports_external.string(),
+    name: exports_external.string(),
+    server_name: exports_external.string(),
+    input: exports_external.unknown(),
+    ...nativeBase
+  }).strict(),
+  mcp_tool_result: exports_external.object({
+    type: exports_external.literal("mcp_tool_result"),
+    tool_use_id: exports_external.string(),
+    content: exports_external.union([exports_external.string(), exports_external.array(exports_external.unknown())]).optional(),
+    is_error: exports_external.boolean().optional(),
+    ...nativeBase
+  }).strict(),
+  container_upload: exports_external.object({ type: exports_external.literal("container_upload"), file_id: exports_external.string(), ...nativeBase }).strict(),
+  compaction: exports_external.object({
+    type: exports_external.literal("compaction"),
+    content: exports_external.string().nullable(),
+    encrypted_content: exports_external.string().nullable().optional(),
+    ...nativeBase
+  }).strict(),
+  search_result: exports_external.object({
+    type: exports_external.literal("search_result"),
+    source: exports_external.string(),
+    title: exports_external.string(),
+    content: exports_external.array(exports_external.unknown()),
+    citations: citationsConfig.optional(),
+    ...nativeBase
+  }).strict(),
+  redacted_thinking: exports_external.object({ type: exports_external.literal("redacted_thinking"), data: exports_external.string() }).strict(),
+  document: exports_external.object({
+    type: exports_external.literal("document"),
+    source: documentSource,
+    citations: citationsConfig.nullable().optional(),
+    context: exports_external.string().nullable().optional(),
+    title: exports_external.string().nullable().optional(),
+    ...nativeBase
+  }).strict(),
+  mid_conv_system: midConversationSystem,
+  tool_addition: toolAddition,
+  tool_removal: toolRemoval,
+  fallback: exports_external.object({
+    type: exports_external.literal("fallback"),
+    from: fallbackModel,
+    to: fallbackModel,
+    trigger: exports_external.unknown().optional()
+  }).strict()
+};
+function nativeResult(type, hasCaller = false) {
+  return exports_external.object({
+    type: exports_external.literal(type),
+    tool_use_id: exports_external.string(),
+    content: nativeResultContent,
+    ...hasCaller ? { caller } : {},
+    ...nativeBase
+  }).strict();
+}
 var message = exports_external.object({
   role: exports_external.enum(["user", "assistant", "system"]),
-  content: exports_external.union([exports_external.string(), exports_external.array(block)])
+  content: exports_external.union([exports_external.string(), exports_external.array(exports_external.unknown())])
 });
 var schema = exports_external.object({
   model: exports_external.string().min(1),
@@ -39414,12 +42295,7 @@ var schema = exports_external.object({
   temperature: exports_external.number().optional(),
   stop_sequences: exports_external.array(exports_external.string()).optional(),
   stream: exports_external.boolean().optional(),
-  tools: exports_external.array(exports_external.object({
-    name: exports_external.string(),
-    description: exports_external.string().optional(),
-    input_schema: exports_external.record(exports_external.string(), exports_external.unknown()),
-    cache_control: cacheControlSchema.optional()
-  })).optional(),
+  tools: exports_external.array(exports_external.unknown()).optional(),
   tool_choice: exports_external.union([
     exports_external.object({ type: exports_external.enum(["auto", "any", "none"]) }),
     exports_external.object({ type: exports_external.literal("tool"), name: exports_external.string() })
@@ -39462,7 +42338,12 @@ function flattenToolResult(content) {
 function toIrBlock(b) {
   switch (b.type) {
     case "text":
-      return { type: "text", text: b.text, ...irCacheControl(b.cache_control) };
+      return {
+        type: "text",
+        text: b.text,
+        ...b.citations === undefined ? {} : { citations: b.citations },
+        ...irCacheControl(b.cache_control)
+      };
     case "image":
       return {
         type: "image",
@@ -39494,6 +42375,69 @@ function toIrBlock(b) {
       };
   }
 }
+var nativeRoles = {
+  server_tool_use: "assistant",
+  web_search_tool_result: "assistant",
+  web_fetch_tool_result: "assistant",
+  code_execution_tool_result: "assistant",
+  bash_code_execution_tool_result: "assistant",
+  text_editor_code_execution_tool_result: "assistant",
+  tool_search_tool_result: "assistant",
+  advisor_tool_result: "assistant",
+  mcp_tool_use: "assistant",
+  mcp_tool_result: "user",
+  container_upload: "user",
+  compaction: "assistant",
+  search_result: "user",
+  redacted_thinking: "assistant",
+  document: "user",
+  mid_conv_system: "system",
+  tool_addition: "system",
+  tool_removal: "system",
+  fallback: "assistant"
+};
+function readBlock(raw, role, path) {
+  if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+    const type = raw.type;
+    if (typeof type === "string" && ANTHROPIC_NATIVE_BLOCK_TYPES.has(type)) {
+      const nativeSchema = nativeSchemas[type];
+      const nativeRole = nativeRoles[type];
+      if (nativeSchema === undefined || nativeRole === undefined) {
+        throw new GatewayError("BAD_REQUEST", `${path}.type: block type "${type}" is not legal in request history`);
+      }
+      if (role !== nativeRole) {
+        throw new GatewayError("BAD_REQUEST", `${path}: block type "${type}" is not legal in ${role} messages`);
+      }
+      const parsed2 = nativeSchema.safeParse(raw);
+      if (!parsed2.success) {
+        const issue2 = parsed2.error.issues[0];
+        const issuePath = issue2?.code === "unrecognized_keys" ? [...issue2.path, issue2.keys[0]] : issue2?.path;
+        const suffix = issuePath?.length ? `.${issuePath.join(".")}` : "";
+        throw new GatewayError("BAD_REQUEST", `${path}${suffix}: ${issue2?.message ?? "invalid native content block"}`);
+      }
+      const { type: _type, cache_control, ...data } = parsed2.data;
+      return {
+        type: "anthropicNative",
+        blockType: type,
+        data,
+        ...cache_control === undefined || cache_control === null ? {} : irCacheControl(cache_control)
+      };
+    }
+  }
+  const parsed = block.safeParse(raw);
+  if (!parsed.success) {
+    const issue2 = parsed.error.issues[0];
+    if (issue2?.code === "invalid_union" || issue2?.path.at(-1) === "type") {
+      const type = raw?.type;
+      if (typeof type === "string") {
+        throw new GatewayError("BAD_REQUEST", `${path}.type: unrecognized block type "${type}"`);
+      }
+    }
+    const suffix = issue2?.path.length ? `.${issue2.path.join(".")}` : "";
+    throw new GatewayError("BAD_REQUEST", `${path}${suffix}: ${issue2?.message ?? "invalid content block"}`);
+  }
+  return toIrBlock(parsed.data);
+}
 function toIrToolChoice(c) {
   return c.type === "tool" ? { type: "tool", name: c.name } : { type: c.type };
 }
@@ -39533,17 +42477,25 @@ function parseAnthropicRequest(body2, headers) {
     throw new GatewayError("BAD_REQUEST", "request body must be a JSON object");
   }
   const parsed = parseOrThrow2(schema, body2);
-  const messages = parsed.messages.map((m) => ({
-    role: m.role,
-    content: typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content.map(toIrBlock)
-  }));
+  const messages = parsed.messages.map((m, i) => {
+    const content = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content.map((b, j) => readBlock(b, m.role, `messages.${i}.content.${j}`));
+    if (m.role === "system") {
+      const previous = parsed.messages[i - 1];
+      const next = parsed.messages[i + 1];
+      if (previous === undefined || next !== undefined && next.role !== "assistant") {
+        throw new GatewayError("BAD_REQUEST", `messages.${i}: system message must follow another message and be last or precede an assistant message`);
+      }
+    }
+    return { role: m.role, content };
+  });
   const system = parsed.system === undefined ? undefined : typeof parsed.system === "string" ? [{ type: "text", text: parsed.system }] : parsed.system.map((b) => ({
     type: "text",
     text: b.text,
     ...irCacheControl(b.cache_control)
   }));
+  const named = normalizeClientModel(parsed.model, readBetas(headers));
   const request2 = {
-    model: parsed.model,
+    model: named.model,
     messages,
     stream: parsed.stream ?? false
   };
@@ -39556,12 +42508,7 @@ function parseAnthropicRequest(body2, headers) {
   if (parsed.stop_sequences !== undefined)
     request2.stopSequences = parsed.stop_sequences;
   if (parsed.tools !== undefined) {
-    request2.tools = parsed.tools.map((t2) => ({
-      name: t2.name,
-      ...t2.description !== undefined && { description: t2.description },
-      inputSchema: t2.input_schema,
-      ...irCacheControl(t2.cache_control)
-    }));
+    request2.tools = parseTools(parsed.tools, mcpServerNames(body2));
   }
   if (parsed.tool_choice !== undefined)
     request2.toolChoice = toIrToolChoice(parsed.tool_choice);
@@ -39574,9 +42521,8 @@ function parseAnthropicRequest(body2, headers) {
   const extras = extraFields(body2, KNOWN);
   if (extras !== undefined)
     request2.vendor = { anthropic: extras };
-  const betas = readBetas(headers);
-  if (betas.length > 0)
-    request2.betas = betas;
+  if (named.betas.length > 0)
+    request2.betas = named.betas;
   return validateRequest(request2);
 }
 
@@ -39685,9 +42631,9 @@ function parseOpenAIRequest(body2) {
   const messages = [];
   for (const m of parsed.messages) {
     if (m.role === "system" || m.role === "developer") {
-      const blocks = contentBlocks(m.content);
-      applyMessageCacheControl(blocks, m.cache_control);
-      system.push(...blocks);
+      const blocks2 = contentBlocks(m.content);
+      applyMessageCacheControl(blocks2, m.cache_control);
+      system.push(...blocks2);
       continue;
     }
     if (m.role === "tool") {
@@ -39725,7 +42671,7 @@ function parseOpenAIRequest(body2) {
     throw new GatewayError("BAD_REQUEST", "messages: at least one non-system message is required");
   }
   const request2 = {
-    model: parsed.model,
+    model: normalizeClientModel(parsed.model).model,
     messages,
     stream: parsed.stream ?? false
   };
@@ -39741,6 +42687,7 @@ function parseOpenAIRequest(body2) {
   }
   if (parsed.tools !== undefined) {
     request2.tools = parsed.tools.map((t2) => ({
+      provider: "custom",
       name: t2.function.name,
       ...t2.function.description !== undefined && { description: t2.function.description },
       inputSchema: t2.function.parameters ?? { type: "object" },
@@ -39759,65 +42706,13 @@ function parseOpenAIRequest(body2) {
 
 // apps/gateway/src/routes/models.ts
 var CREATED_AT = new Date(0).toISOString();
-function narrower(a, b) {
-  const context = [a.contextWindow, b.contextWindow].filter((n) => n !== undefined);
-  const output = [a.maxOutputTokens, b.maxOutputTokens].filter((n) => n !== undefined);
-  return {
-    ...context.length === 0 ? {} : { contextWindow: Math.min(...context) },
-    ...output.length === 0 ? {} : { maxOutputTokens: Math.min(...output) }
-  };
-}
-function targetLimits(target, auths) {
-  const ways = auths.size === 0 ? ["apiKey"] : [...auths];
-  let listed = {};
-  for (const auth of ways) {
-    const entry = catalogLimits(target.provider, target.model, auth);
-    if (entry === null)
-      continue;
-    listed = narrower(listed, {
-      contextWindow: entry.contextWindow,
-      maxOutputTokens: entry.maxOutputTokens
-    });
-  }
-  const contextWindow = target.contextWindow ?? listed.contextWindow;
-  const maxOutputTokens = target.maxOutputTokens ?? listed.maxOutputTokens;
-  return {
-    ...contextWindow === undefined ? {} : { contextWindow },
-    ...maxOutputTokens === undefined ? {} : { maxOutputTokens }
-  };
-}
-function limitsOf(model, authsByProvider) {
-  let limits = {};
-  for (const target of model.targets) {
-    limits = narrower(limits, targetLimits(target, authsByProvider.get(target.provider) ?? new Set));
-  }
-  return limits;
-}
-function displayName(model) {
-  const only = model.targets.length === 1 ? model.targets[0] : undefined;
-  if (only === undefined)
-    return model.id;
-  const labelled = PROVIDER_MODEL_CATALOG[only.provider]?.models.find((choice) => choice.id === only.model);
-  return labelled?.label ?? model.id;
-}
-function servingAuths(credentials) {
-  const byProvider = new Map;
-  for (const credential of credentials) {
-    if (!credential.enabled)
-      continue;
-    const ways = byProvider.get(credential.provider) ?? new Set;
-    ways.add(credential.authType);
-    byProvider.set(credential.provider, ways);
-  }
-  return byProvider;
-}
 function describeModel(model, credentials) {
-  const limits = limitsOf(model, servingAuths(credentials));
+  const limits = resolveModelLimits(model, credentials);
   return {
     id: model.id,
     object: "model",
     type: "model",
-    display_name: displayName(model),
+    display_name: modelDisplayName(model),
     created: 0,
     created_at: CREATED_AT,
     owned_by: "omnigateway",
@@ -39825,8 +42720,29 @@ function describeModel(model, credentials) {
     ...limits.maxOutputTokens === undefined ? {} : { max_tokens: limits.maxOutputTokens }
   };
 }
-function modelListBody(models, credentials) {
-  const data = models.map((model) => describeModel(model, credentials));
+var ALREADY_CLAUDE = /^(?:claude|anthropic)/i;
+var MIRROR_PREFIX = "claude/";
+function discoveryMirrors(data) {
+  const taken = new Set(data.map((entry) => entry.id));
+  const mirrors = [];
+  for (const entry of data) {
+    if (ALREADY_CLAUDE.test(entry.id))
+      continue;
+    const id = `${MIRROR_PREFIX}${entry.id}`;
+    if (taken.has(id))
+      continue;
+    mirrors.push({
+      ...entry,
+      id,
+      root: entry.id,
+      display_name: `${entry.display_name} (OmniGateway)`
+    });
+  }
+  return mirrors;
+}
+function modelListBody(models, credentials, options = {}) {
+  const described = models.map((model) => describeModel(model, credentials));
+  const data = options.discoveryMirrors === true ? [...described, ...discoveryMirrors(described)] : described;
   return {
     object: "list",
     data,
@@ -40022,13 +42938,21 @@ function proxyRoutes(deps) {
     snapshots: deps.snapshots ?? createRoutingSnapshotCache(deps.store, logger2),
     keepaliveMs: deps.keepaliveMs ?? KEEPALIVE_MS
   };
-  return new Elysia().post("/v1/messages", ({ request: request2 }) => handle(dispatchDeps, rateLimiter, "anthropic", request2)).post("/v1/chat/completions", ({ request: request2 }) => handle(dispatchDeps, rateLimiter, "openai", request2)).get("/v1/models", async ({ request: request2 }) => {
+  return new Elysia().post("/v1/messages", ({ request: request2, server }) => {
+    server?.timeout(request2, 0);
+    return handle(dispatchDeps, rateLimiter, "anthropic", request2);
+  }).post("/v1/chat/completions", ({ request: request2, server }) => {
+    server?.timeout(request2, 0);
+    return handle(dispatchDeps, rateLimiter, "openai", request2);
+  }).get("/v1/models", async ({ request: request2 }) => {
     try {
       const key = await authenticateApiKey(deps.store, apiKeyHeader(request2.headers));
       const snapshot = await dispatchDeps.snapshots.get(deps.now());
       const models = [...snapshot.models.values()];
       const visibleModels = key.modelAllowlist === null ? models : models.filter((model) => key.modelAllowlist?.includes(model.id));
-      return Response.json(modelListBody(visibleModels, snapshot.credentials));
+      return Response.json(modelListBody(visibleModels, snapshot.credentials, {
+        discoveryMirrors: deps.discoveryMirrors === true
+      }));
     } catch (error51) {
       const gatewayError = asGatewayError(error51);
       logger2.error("model listing failed", {
@@ -40038,6 +42962,25 @@ function proxyRoutes(deps) {
       });
       return errorResponse("anthropic", gatewayError.code, gatewayError.message);
     }
+  }).post("/v1/messages/count_tokens", async ({ request: request2 }) => {
+    try {
+      const key = await authenticateApiKey(deps.store, apiKeyHeader(request2.headers));
+      rateLimiter.consume(key.id, key.rateLimitPerMin);
+      const body2 = await request2.json();
+      const chatRequest = parseAnthropicRequest(body2, request2.headers);
+      if (key.modelAllowlist !== null && !key.modelAllowlist.includes(chatRequest.model)) {
+        throw new GatewayError("AUTH", `model "${chatRequest.model}" is not allowed for this API key`);
+      }
+      return Response.json({ input_tokens: estimateInputTokens(chatRequest) });
+    } catch (error51) {
+      const gatewayError = asGatewayError(error51);
+      logger2.warn("token count failed", {
+        status: HTTP_STATUS[gatewayError.code],
+        code: gatewayError.code,
+        reason: gatewayError.message
+      });
+      return errorResponse("anthropic", gatewayError.code, gatewayError.message);
+    }
   }).onError(({ error: error51 }) => {
     const gatewayError = asGatewayError(error51);
     logger2.error("unhandled proxy route error", {
@@ -40085,10 +43028,13 @@ function createApp(deps) {
     refresh,
     requestId,
     rateLimiter,
-    logger: logger2
+    logger: logger2,
+    discoveryMirrors: deps.discoveryMirrors === true
   })).use(adminRoutes({
     store: deps.store,
     admin,
+    baseUrl: deps.baseUrl,
+    discoveryMirrors: deps.discoveryMirrors === true,
     now,
     sessionTtlMs: ADMIN_SESSION_TTL_MS,
     logger: logger2,
@@ -40114,7 +43060,7 @@ function createApp(deps) {
     } catch {
       return error51();
     }
-    const protectedPrefix = ["/api", "/v1", "/oauth"].some((prefix) => decodedPath === prefix || decodedPath.startsWith(`${prefix}/`));
+    const protectedPrefix = ["/api", "/v1", "/oauth"].some((prefix2) => decodedPath === prefix2 || decodedPath.startsWith(`${prefix2}/`));
     if (protectedPrefix)
       return error51();
     const requestedPath = decodedPath === "/" ? "/index.html" : decodedPath;
@@ -40331,7 +43277,8 @@ async function main() {
     refresh,
     staticDir,
     logger: logger2,
-    console: console2
+    console: console2,
+    discoveryMirrors: config2.exposeClaudeCodeAliases
   });
   const stopMaintenance = startMaintenance({ store, now, logger: logger2 });
   const stopRefreshScheduler = startRefreshScheduler({ store, refresh, now, logger: logger2 });