omnigateway 0.1.8 → 0.2.0

package/bin/omni.js

@@ -91,9 +91,8 @@ function formatUsd(value) {
 }
 
 // apps/cli/src/run.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3 } from "path";
 
 // packages/control/src/adminAuth.ts
 import { hash, verify } from "@node-rs/argon2";
@@ -153,6 +152,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 },
@@ -759,14 +763,232 @@ function parseRecord(record) {
 `) };
 }
 
+// packages/providers/src/anthropic/tools.ts
+var COMMON = ["cache_control", "strict", "defer_loading", "allowed_callers"];
+var COMMON_WITH_EXAMPLES = [...COMMON, "input_examples"];
+var searchDomains = ["max_uses", "allowed_domains", "blocked_domains"];
+var ANTHROPIC_TOOL_SPECS = {
+  web_search_20250305: {
+    family: "webSearch",
+    name: "web_search",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "user_location"]
+  },
+  web_search_20260209: {
+    family: "webSearch",
+    name: "web_search",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "user_location"]
+  },
+  web_search_20260318: {
+    family: "webSearch",
+    name: "web_search",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "user_location", "response_inclusion"]
+  },
+  web_fetch_20250910: {
+    family: "webFetch",
+    name: "web_fetch",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "citations", "max_content_tokens"]
+  },
+  web_fetch_20260209: {
+    family: "webFetch",
+    name: "web_fetch",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "citations", "max_content_tokens"]
+  },
+  web_fetch_20260309: {
+    family: "webFetch",
+    name: "web_fetch",
+    required: [],
+    optional: [...COMMON, ...searchDomains, "citations", "max_content_tokens", "use_cache"]
+  },
+  web_fetch_20260318: {
+    family: "webFetch",
+    name: "web_fetch",
+    required: [],
+    optional: [
+      ...COMMON,
+      ...searchDomains,
+      "citations",
+      "max_content_tokens",
+      "use_cache",
+      "response_inclusion"
+    ]
+  },
+  code_execution_20250522: {
+    family: "codeExecution",
+    name: "code_execution",
+    required: [],
+    optional: [...COMMON]
+  },
+  code_execution_20250825: {
+    family: "codeExecution",
+    name: "code_execution",
+    required: [],
+    optional: [...COMMON]
+  },
+  code_execution_20260120: {
+    family: "codeExecution",
+    name: "code_execution",
+    required: [],
+    optional: [...COMMON]
+  },
+  code_execution_20260521: {
+    family: "codeExecution",
+    name: "code_execution",
+    required: [],
+    optional: [...COMMON]
+  },
+  bash_20241022: {
+    family: "bash",
+    name: "bash",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  bash_20250124: {
+    family: "bash",
+    name: "bash",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  text_editor_20241022: {
+    family: "textEditor",
+    name: "str_replace_editor",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  text_editor_20250124: {
+    family: "textEditor",
+    name: "str_replace_editor",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  text_editor_20250429: {
+    family: "textEditor",
+    name: "str_replace_based_edit_tool",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  text_editor_20250728: {
+    family: "textEditor",
+    name: "str_replace_based_edit_tool",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES, "max_characters"]
+  },
+  computer_20241022: {
+    family: "computer",
+    name: "computer",
+    required: ["display_width_px", "display_height_px"],
+    optional: [...COMMON_WITH_EXAMPLES, "display_number"]
+  },
+  computer_20250124: {
+    family: "computer",
+    name: "computer",
+    required: ["display_width_px", "display_height_px"],
+    optional: [...COMMON_WITH_EXAMPLES, "display_number"]
+  },
+  computer_20251124: {
+    family: "computer",
+    name: "computer",
+    required: ["display_width_px", "display_height_px"],
+    optional: [...COMMON_WITH_EXAMPLES, "display_number", "enable_zoom"]
+  },
+  memory_20250818: {
+    family: "memory",
+    name: "memory",
+    required: [],
+    optional: [...COMMON_WITH_EXAMPLES]
+  },
+  tool_search_tool_regex_20251119: {
+    family: "toolSearchRegex",
+    name: "tool_search_tool_regex",
+    required: [],
+    optional: [...COMMON]
+  },
+  tool_search_tool_regex: {
+    family: "toolSearchRegex",
+    name: "tool_search_tool_regex",
+    required: [],
+    optional: [...COMMON]
+  },
+  tool_search_tool_bm25_20251119: {
+    family: "toolSearchBm25",
+    name: "tool_search_tool_bm25",
+    required: [],
+    optional: [...COMMON]
+  },
+  tool_search_tool_bm25: {
+    family: "toolSearchBm25",
+    name: "tool_search_tool_bm25",
+    required: [],
+    optional: [...COMMON]
+  },
+  advisor_20260301: {
+    family: "advisor",
+    name: "advisor",
+    required: ["model"],
+    optional: [...COMMON, "caching", "max_uses", "max_tokens"]
+  },
+  mcp_toolset: {
+    family: "mcpToolset",
+    required: ["mcp_server_name"],
+    optional: ["cache_control", "configs", "default_config"]
+  }
+};
+var ANTHROPIC_NATIVE_BLOCK_TYPES = new Set([
+  "server_tool_use",
+  "web_search_tool_result",
+  "web_fetch_tool_result",
+  "code_execution_tool_result",
+  "bash_code_execution_tool_result",
+  "text_editor_code_execution_tool_result",
+  "mcp_tool_use",
+  "mcp_tool_result",
+  "tool_search_tool_result",
+  "tool_reference",
+  "advisor_tool_result",
+  "advisor_result",
+  "advisor_redacted_result",
+  "container_upload",
+  "compaction",
+  "search_result",
+  "document",
+  "mid_conv_system",
+  "tool_addition",
+  "tool_removal",
+  "fallback",
+  "redacted_thinking"
+]);
+
 // packages/providers/src/anthropic/decode.ts
 var STOP_REASON = {
   end_turn: "endTurn",
   max_tokens: "maxTokens",
   stop_sequence: "stopSequence",
   tool_use: "toolUse",
-  refusal: "contentFilter"
+  refusal: "contentFilter",
+  pause_turn: "pauseTurn"
 };
+var KNOWN_EVENTS = new Set([
+  "message_start",
+  "content_block_start",
+  "content_block_delta",
+  "content_block_stop",
+  "message_delta",
+  "message_stop",
+  "error",
+  "ping"
+]);
+var KNOWN_DELTAS = new Set([
+  "text_delta",
+  "thinking_delta",
+  "signature_delta",
+  "input_json_delta",
+  "citations_delta",
+  "compaction_delta"
+]);
 var ERROR_TYPE = {
   overloaded_error: "OVERLOADED",
   rate_limit_error: "RATE_LIMIT",
@@ -792,10 +1014,21 @@ async function* decodeAnthropic(messages) {
   let outputTokens = 0;
   let stopReason = "endTurn";
   let terminal = false;
+  const nativeBlocks = new Set;
+  const protocolError = (message) => ({
+    type: "error",
+    code: "UPSTREAM",
+    message,
+    retryable: false
+  });
   for await (const msg of messages) {
     const d = json(msg.data);
     if (d === null)
       continue;
+    if (!KNOWN_EVENTS.has(msg.event)) {
+      yield protocolError(`unrecognized Anthropic stream event "${msg.event}"`);
+      return;
+    }
     switch (msg.event) {
       case "message_start": {
         const m = d.message ?? {};
@@ -820,6 +1053,18 @@ async function* decodeAnthropic(messages) {
             index,
             block: { type: "toolUse", id: String(cb.id), name: String(cb.name) }
           };
+        else if (cb.type !== undefined && ANTHROPIC_NATIVE_BLOCK_TYPES.has(cb.type)) {
+          nativeBlocks.add(index);
+          const { type: _blockType, ...data } = cb;
+          yield {
+            type: "blockStart",
+            index,
+            block: { type: "anthropicNative", blockType: cb.type, data }
+          };
+        } else {
+          yield protocolError(`unrecognized Anthropic content block type "${String(cb.type)}"`);
+          return;
+        }
         break;
       }
       case "content_block_delta": {
@@ -843,17 +1088,51 @@ async function* decodeAnthropic(messages) {
           yield {
             type: "blockDelta",
             index,
-            delta: { type: "toolJson", partial: delta.partial_json ?? "" }
+            delta: nativeBlocks.has(index) ? { type: "anthropicNativeJson", partial: delta.partial_json ?? "" } : { type: "toolJson", partial: delta.partial_json ?? "" }
+          };
+        else if (delta.type === "citations_delta")
+          yield {
+            type: "blockDelta",
+            index,
+            delta: {
+              type: "anthropicNative",
+              deltaType: delta.type,
+              data: { citation: delta.citation }
+            }
           };
+        else if (delta.type === "compaction_delta")
+          yield {
+            type: "blockDelta",
+            index,
+            delta: {
+              type: "anthropicNative",
+              deltaType: delta.type,
+              data: {
+                ...delta.content === undefined ? {} : { content: delta.content },
+                ...delta.encrypted_content === undefined ? {} : { encrypted_content: delta.encrypted_content }
+              }
+            }
+          };
+        else if (delta.type === undefined || !KNOWN_DELTAS.has(delta.type)) {
+          yield protocolError(`unrecognized Anthropic content block delta "${String(delta.type)}"`);
+          return;
+        }
         break;
       }
       case "content_block_stop":
+        nativeBlocks.delete(d.index ?? 0);
         yield { type: "blockEnd", index: d.index ?? 0 };
         break;
       case "message_delta": {
         const reason = d.delta?.stop_reason;
-        if (typeof reason === "string")
-          stopReason = STOP_REASON[reason] ?? "endTurn";
+        if (typeof reason === "string") {
+          const mapped = STOP_REASON[reason];
+          if (mapped === undefined) {
+            yield protocolError(`unrecognized Anthropic stop reason "${reason}"`);
+            return;
+          }
+          stopReason = mapped;
+        }
         inputTokens = d.usage?.input_tokens ?? inputTokens;
         outputTokens = d.usage?.output_tokens ?? outputTokens;
         break;
@@ -912,7 +1191,12 @@ function encodeBlock(b) {
   const cache = wireCacheControl(cacheControlOf(b));
   switch (b.type) {
     case "text":
-      return { type: "text", text: b.text, ...cache };
+      return {
+        type: "text",
+        text: b.text,
+        ...b.citations === undefined ? {} : { citations: b.citations },
+        ...cache
+      };
     case "image":
       return {
         type: "image",
@@ -931,11 +1215,16 @@ function encodeBlock(b) {
         is_error: b.isError,
         ...cache
       };
+    case "anthropicNative":
+      return { ...b.data, type: b.blockType, ...cache };
   }
 }
 function encodeSystemTurn(content) {
-  return content.flatMap((b) => b.type === "text" ? [b.text] : []).join(`
+  if (content.every((block) => block.type === "text")) {
+    return content.map((block) => block.text).join(`
 `);
+  }
+  return content.map(encodeBlock);
 }
 function systemCacheControl(req) {
   const cacheable = req.messages.flatMap((message) => message.content.flatMap((block) => block.type === "thinking" ? [] : [{ role: message.role, block }]));
@@ -947,6 +1236,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":
@@ -1001,14 +1307,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) {
@@ -1355,6 +1655,9 @@ function toChatWire(req, model) {
             content: block.content
           });
           break;
+        case "anthropicNative":
+          note2("kimi:anthropic-native-block-dropped");
+          break;
       }
     }
     if (toolCalls.length > 0) {
@@ -1382,7 +1685,10 @@ function toChatWire(req, model) {
   if (req.stopSequences !== undefined)
     body.stop = req.stopSequences;
   if (req.tools !== undefined) {
-    body.tools = req.tools.map((t) => ({
+    const custom = req.tools.filter((t) => t.provider === "custom");
+    if (custom.length !== req.tools.length)
+      note2("kimi:anthropic-tool-dropped");
+    body.tools = custom.map((t) => ({
       type: "function",
       function: { name: t.name, description: t.description, parameters: t.inputSchema }
     }));
@@ -1649,6 +1955,9 @@ ${block.text}
             output: block.content
           });
           break;
+        case "anthropicNative":
+          note2("openai:anthropic-native-block-dropped");
+          break;
       }
     }
     flush();
@@ -1672,7 +1981,10 @@ ${block.text}
       body.temperature = req.temperature;
   }
   if (req.tools !== undefined) {
-    body.tools = req.tools.map((t) => ({
+    const custom = req.tools.filter((t) => t.provider === "custom");
+    if (custom.length !== req.tools.length)
+      note2("openai:anthropic-tool-dropped");
+    body.tools = custom.map((t) => ({
       type: "function",
       name: t.name,
       description: t.description,
@@ -16638,11 +16950,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(),
@@ -16829,6 +17142,11 @@ async function buildSnapshot(store, now) {
 }
 
 // packages/router/src/filters.ts
+function needsAnthropicNative(request2) {
+  if (request2.tools?.some((t) => t.provider === "anthropic") === true)
+    return true;
+  return request2.messages.some((m) => m.content.some((b) => b.type === "anthropicNative"));
+}
 function requiredCapabilities(request2) {
   const images = request2.messages.some((m) => m.content.some((b) => b.type === "image"));
   return {
@@ -16845,10 +17163,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;
@@ -17043,7 +17362,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 });
@@ -17111,7 +17434,8 @@ var DEFAULT_SETTINGS = {
   breakerThreshold: 3,
   breakerCooldownMs: 30000,
   logRetentionDays: 30,
-  quotaPollIntervalMs: 300000
+  quotaPollIntervalMs: 300000,
+  rtkEnabled: false
 };
 
 // packages/store/src/sqlite/config.ts
@@ -17147,12 +17471,18 @@ function createConfigRepo(db, emit2 = () => {}) {
       const raw = readRaw(SETTINGS_KEY);
       if (raw === null)
         return DEFAULT_SETTINGS;
-      const stored = JSON.parse(raw);
-      return {
-        ...DEFAULT_SETTINGS,
-        ...stored,
-        weights: { ...DEFAULT_SETTINGS.weights, ...stored.weights }
-      };
+      try {
+        const parsed = JSON.parse(raw);
+        const stored = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+        return {
+          ...DEFAULT_SETTINGS,
+          ...stored,
+          rtkEnabled: stored.rtkEnabled === true,
+          weights: { ...DEFAULT_SETTINGS.weights, ...stored.weights }
+        };
+      } catch {
+        return DEFAULT_SETTINGS;
+      }
     },
     async putSettings(patch) {
       const current = await this.getSettings();
@@ -17594,6 +17924,20 @@ ALTER TABLE request_logs ADD COLUMN state TEXT NOT NULL DEFAULT 'done';
 CREATE INDEX idx_request_logs_pending ON request_logs(state) WHERE state = 'pending';
 `;
 
+// packages/store/src/sqlite/migrations/005_rtk_metrics.sql
+var _005_rtk_metrics_default = `ALTER TABLE request_logs ADD COLUMN rtk_applied INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_filter_hits INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_original_code_units INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_compressed_code_units INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_estimated_tokens_saved INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN rtk_filters TEXT NOT NULL DEFAULT '[]';
+`;
+
+// packages/store/src/sqlite/migrations/006_rtk_usage.sql
+var _006_rtk_usage_default = `ALTER TABLE usage_daily ADD COLUMN rtk_saved_tokens INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE usage_daily ADD COLUMN rtk_applied_requests INTEGER NOT NULL DEFAULT 0;
+`;
+
 // packages/store/src/sqlite/rollup.ts
 function startOfLocalDay(at) {
   const day = new Date(at);
@@ -17604,8 +17948,8 @@ var UPSERT = `
   INSERT INTO usage_daily
     (day, provider, credential_id, requested_model, resolved_model, api_key_id,
      requests, errors, input_tokens, output_tokens, cache_read_tokens,
-     cache_write_tokens, cost_usd, duration_ms_sum)
-  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+     cache_write_tokens, rtk_saved_tokens, rtk_applied_requests, cost_usd, duration_ms_sum)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
   ON CONFLICT (day, provider, credential_id, requested_model, resolved_model, api_key_id)
   DO UPDATE SET
     requests           = requests + excluded.requests,
@@ -17613,8 +17957,10 @@ var UPSERT = `
     input_tokens       = input_tokens + excluded.input_tokens,
     output_tokens      = output_tokens + excluded.output_tokens,
     cache_read_tokens  = cache_read_tokens + excluded.cache_read_tokens,
-    cache_write_tokens = cache_write_tokens + excluded.cache_write_tokens,
-    cost_usd           = cost_usd + excluded.cost_usd,
+    cache_write_tokens    = cache_write_tokens + excluded.cache_write_tokens,
+    rtk_saved_tokens      = rtk_saved_tokens + excluded.rtk_saved_tokens,
+    rtk_applied_requests  = rtk_applied_requests + excluded.rtk_applied_requests,
+    cost_usd              = cost_usd + excluded.cost_usd,
     duration_ms_sum    = duration_ms_sum + excluded.duration_ms_sum`;
 function keyOf(log) {
   return [
@@ -17634,6 +17980,8 @@ function countersOf(log) {
     outputTokens: log.outputTokens,
     cacheReadTokens: log.cacheReadTokens,
     cacheWriteTokens: log.cacheWriteTokens,
+    rtkSavedTokens: log.rtkEstimatedTokensSaved,
+    rtkAppliedRequests: log.rtkApplied ? 1 : 0,
     costUsd: log.costUsd,
     durationMsSum: log.durationMs
   };
@@ -17647,6 +17995,8 @@ function upsert(db, key, c) {
     c.outputTokens,
     c.cacheReadTokens,
     c.cacheWriteTokens,
+    c.rtkSavedTokens,
+    c.rtkAppliedRequests,
     c.costUsd,
     c.durationMsSum
   ]);
@@ -17677,6 +18027,8 @@ function backfillDaily(db) {
       outputTokens: 0,
       cacheReadTokens: 0,
       cacheWriteTokens: 0,
+      rtkSavedTokens: 0,
+      rtkAppliedRequests: 0,
       costUsd: 0,
       durationMsSum: 0
     };
@@ -17695,13 +18047,42 @@ function backfillDaily(db) {
     upsert(db, group.key, group.counters);
   return groups.size;
 }
+function backfillRtkUsage(db) {
+  const groups = new Map;
+  for (const row of db.query(`SELECT at, api_key_id, requested_model, resolved_provider, resolved_model, credential_id,
+              rtk_applied, rtk_estimated_tokens_saved
+         FROM request_logs
+        WHERE state = 'done'`).all()) {
+    const key = [
+      startOfLocalDay(row.at),
+      row.resolved_provider ?? "",
+      row.credential_id ?? "",
+      row.requested_model,
+      row.resolved_model ?? "",
+      row.api_key_id ?? ""
+    ];
+    const id = key.join("\x00");
+    const group = groups.get(id) ?? { key, saved: 0, applied: 0 };
+    group.saved += row.rtk_estimated_tokens_saved;
+    group.applied += row.rtk_applied === 1 ? 1 : 0;
+    groups.set(id, group);
+  }
+  for (const { key, saved, applied } of groups.values()) {
+    db.run(`UPDATE usage_daily
+          SET rtk_saved_tokens = ?, rtk_applied_requests = ?
+        WHERE day = ? AND provider = ? AND credential_id = ? AND requested_model = ?
+          AND resolved_model = ? AND api_key_id = ?`, [saved, applied, ...key]);
+  }
+}
 
 // packages/store/src/sqlite/db.ts
 var MIGRATIONS = [
   { id: 1, sql: _001_init_default },
   { id: 2, sql: _002_usage_daily_default, after: backfillDaily },
   { id: 3, sql: _003_quota_snapshot_default },
-  { id: 4, sql: _004_request_state_default }
+  { id: 4, sql: _004_request_state_default },
+  { id: 5, sql: _005_rtk_metrics_default },
+  { id: 6, sql: _006_rtk_usage_default, after: backfillRtkUsage }
 ];
 function openDb(path) {
   const db = new Database(path, { create: true });
@@ -17770,7 +18151,38 @@ function createKeyRepo(db) {
     }
   };
 }
+// packages/rtk/src/catalog.ts
+var RTK_FILTER_IDS = [
+  "git-diff",
+  "git-status",
+  "git-log",
+  "grep",
+  "path-list",
+  "numbered-read",
+  "build-output",
+  "test-output",
+  "deduplicate-log",
+  "smart-truncate",
+  "lint-output",
+  "package-output",
+  "tree-output",
+  "git-operation",
+  "docker-build"
+];
+var FILTER_IDS = new Set(RTK_FILTER_IDS);
+function isRtkFilterId(value) {
+  return FILTER_IDS.has(value);
+}
+
 // packages/store/src/sqlite/usage.ts
+function parseRtkFilters(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter(isRtkFilterId) : [];
+  } catch {
+    return [];
+  }
+}
 var toLog = (r) => ({
   id: r.id,
   state: r.state === "pending" ? "pending" : "done",
@@ -17790,7 +18202,13 @@ var toLog = (r) => ({
   ttftMs: r.ttft_ms,
   durationMs: r.duration_ms,
   costUsd: r.cost_usd,
-  degradations: JSON.parse(r.degradations)
+  degradations: JSON.parse(r.degradations),
+  rtkApplied: r.rtk_applied === 1,
+  rtkFilterHits: r.rtk_filter_hits,
+  rtkOriginalCodeUnits: r.rtk_original_code_units,
+  rtkCompressedCodeUnits: r.rtk_compressed_code_units,
+  rtkEstimatedTokensSaved: r.rtk_estimated_tokens_saved,
+  rtkFilters: parseRtkFilters(r.rtk_filters)
 });
 var GROUP_COLUMN = {
   raw: {
@@ -17835,8 +18253,9 @@ function label(value) {
 var COLUMNS = `(id, state, at, api_key_id, requested_model, resolved_provider, resolved_model,
                   credential_id, attempts, status, error_code, input_tokens, output_tokens,
                   cache_read_tokens, cache_write_tokens, ttft_ms, duration_ms, cost_usd,
-                  degradations)`;
-var PLACEHOLDERS = "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
+                  degradations, rtk_applied, rtk_filter_hits, rtk_original_code_units,
+                  rtk_compressed_code_units, rtk_estimated_tokens_saved, rtk_filters)`;
+var PLACEHOLDERS = "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
 function values(log, state) {
   return [
     log.id,
@@ -17857,7 +18276,13 @@ function values(log, state) {
     log.ttftMs,
     log.durationMs,
     log.costUsd,
-    JSON.stringify(log.degradations)
+    JSON.stringify(log.degradations),
+    log.rtkApplied === true ? 1 : 0,
+    log.rtkFilterHits ?? 0,
+    log.rtkOriginalCodeUnits ?? 0,
+    log.rtkCompressedCodeUnits ?? 0,
+    log.rtkEstimatedTokensSaved ?? 0,
+    JSON.stringify(log.rtkFilters ?? [])
   ];
 }
 var COMPLETE = `INSERT INTO request_logs ${COLUMNS} VALUES ${PLACEHOLDERS}
@@ -17878,7 +18303,13 @@ var COMPLETE = `INSERT INTO request_logs ${COLUMNS} VALUES ${PLACEHOLDERS}
     ttft_ms = excluded.ttft_ms,
     duration_ms = excluded.duration_ms,
     cost_usd = excluded.cost_usd,
-    degradations = excluded.degradations`;
+    degradations = excluded.degradations,
+    rtk_applied = excluded.rtk_applied,
+    rtk_filter_hits = excluded.rtk_filter_hits,
+    rtk_original_code_units = excluded.rtk_original_code_units,
+    rtk_compressed_code_units = excluded.rtk_compressed_code_units,
+    rtk_estimated_tokens_saved = excluded.rtk_estimated_tokens_saved,
+    rtk_filters = excluded.rtk_filters`;
 function createUsageRepo(db) {
   const complete = db.transaction((log) => {
     db.run(COMPLETE, values(log, "done"));
@@ -17923,6 +18354,8 @@ function createUsageRepo(db) {
                   COALESCE(SUM(output_tokens), 0) AS output_tokens,
                   COALESCE(SUM(cache_read_tokens), 0) AS cache_read_tokens,
                   COALESCE(SUM(cache_write_tokens), 0) AS cache_write_tokens,
+                  COALESCE(SUM(${daily ? "rtk_saved_tokens" : "rtk_estimated_tokens_saved"}), 0) AS rtk_saved_tokens,
+                  COALESCE(SUM(${daily ? "rtk_applied_requests" : "CASE WHEN rtk_applied = 1 THEN 1 ELSE 0 END"}), 0) AS rtk_applied_requests,
                   COALESCE(SUM(cost_usd), 0) AS cost_usd
              FROM ${daily ? "usage_daily" : "request_logs"}
             WHERE ${daily ? "" : "state = 'done' AND "}${timeColumn} >= ? AND ${timeColumn} <= ?
@@ -17936,6 +18369,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
@@ -18436,33 +18871,77 @@ async function describeModelsForSetup(store) {
     label: modelDisplayName(model)
   }));
 }
-function slug(id) {
-  return encodeURIComponent(id).replace(/\./g, "%2E");
-}
-function claudeProfiles(described, input) {
-  const apiKey = input.apiKey ?? KEY_PLACEHOLDER;
-  return described.map(({ model, limits }) => {
-    const useMirror = input.discoveryMirrors === true && !/^(?:claude|anthropic)/i.test(model.id);
-    const modelId = useMirror ? `claude/${model.id}` : model.id;
-    const env2 = {
-      ANTHROPIC_BASE_URL: input.baseUrl,
-      ANTHROPIC_AUTH_TOKEN: apiKey,
-      ANTHROPIC_MODEL: modelId,
-      CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1"
-    };
-    if (limits.contextWindow !== undefined && !/^claude-/i.test(modelId)) {
-      env2.CLAUDE_CODE_MAX_CONTEXT_TOKENS = String(limits.contextWindow);
+var CLAUDE_MAPPING_KEYS = {
+  defaultModel: "ANTHROPIC_MODEL",
+  fableModel: "ANTHROPIC_DEFAULT_FABLE_MODEL",
+  opusModel: "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  sonnetModel: "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  haikuModel: "ANTHROPIC_DEFAULT_HAIKU_MODEL"
+};
+function settingsObject(existing) {
+  if (existing === undefined)
+    return {};
+  try {
+    const parsed = JSON.parse(existing);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("settings root is not an object");
     }
-    return {
-      path: `${slug(model.id)}/settings.json`,
-      contents: `${JSON.stringify({ env: env2 }, null, 2)}
+    return parsed;
+  } catch (error51) {
+    const reason = error51 instanceof Error ? error51.message : "invalid JSON";
+    throw new Error(`cannot parse existing settings.json: ${reason}`);
+  }
+}
+function claudeSettings(described, input, mapping, existing) {
+  if (mapping.defaultModel === "")
+    throw new Error("default model is required");
+  const ids = new Set(described.map(({ model }) => model.id));
+  const visibleId = (slot, id) => {
+    if (!ids.has(id))
+      throw new Error(`${slot} names unknown virtual model "${id}"`);
+    const useMirror = input.discoveryMirrors === true && !/^(?:claude|anthropic)/i.test(id);
+    return useMirror ? `claude/${id}` : id;
+  };
+  const settings = settingsObject(existing);
+  const currentEnv = settings.env;
+  const env2 = typeof currentEnv === "object" && currentEnv !== null && !Array.isArray(currentEnv) ? { ...currentEnv } : {};
+  for (const key of Object.values(CLAUDE_MAPPING_KEYS))
+    delete env2[key];
+  delete env2.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
+  env2.ANTHROPIC_BASE_URL = input.baseUrl;
+  env2.ANTHROPIC_AUTH_TOKEN = input.apiKey ?? KEY_PLACEHOLDER;
+  env2.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
+  for (const [slot, key] of Object.entries(CLAUDE_MAPPING_KEYS)) {
+    const id = mapping[slot];
+    if (id !== undefined && id !== "")
+      env2[key] = visibleId(slot, id);
+  }
+  return {
+    path: "settings.json",
+    contents: `${JSON.stringify({ ...settings, env: env2 }, null, 2)}
 `
-    };
-  });
+  };
 }
-function opencodeConfig(described, input) {
+function opencodeConfig(described, input, mapping) {
+  if (mapping.defaultModel === "")
+    throw new Error("default model is required");
+  const byId = new Map(described.map((entry) => [entry.model.id, entry]));
+  const selected = [];
+  const seen = new Set;
+  for (const slot of Object.keys(CLAUDE_MAPPING_KEYS)) {
+    const id = mapping[slot];
+    if (id === undefined || id === "")
+      continue;
+    const entry = byId.get(id);
+    if (entry === undefined)
+      throw new Error(`${slot} names unknown virtual model "${id}"`);
+    if (!seen.has(id)) {
+      seen.add(id);
+      selected.push(entry);
+    }
+  }
   const models = {};
-  for (const { model, limits, label: label2 } of described) {
+  for (const { model, limits, label: label2 } of selected) {
     const limit = limits.contextWindow === undefined ? undefined : {
       context: limits.contextWindow,
       ...limits.maxOutputTokens === undefined ? {} : { output: limits.maxOutputTokens }
@@ -18471,6 +18950,7 @@ function opencodeConfig(described, input) {
   }
   const contents = `${JSON.stringify({
     $schema: "https://opencode.ai/config.json",
+    model: `omnigateway/${mapping.defaultModel}`,
     provider: {
       omnigateway: {
         npm: "@ai-sdk/openai-compatible",
@@ -19867,7 +20347,7 @@ var settingsSet = {
 };
 
 // apps/cli/src/commands/setup.ts
-import { dirname as dirname2, join as join4 } from "path";
+import { join as join4 } from "path";
 var OPTIONS = {
   dir: { type: "string" },
   key: { type: "string" },
@@ -19901,39 +20381,65 @@ ${f.contents}`).join(`
 function at(dir, file2) {
   return { path: join4(dir, file2.path), contents: file2.contents };
 }
+async function promptMapping(models, prompt) {
+  const choices = models.map(({ model }) => model.id).join(", ");
+  if (prompt.input === undefined) {
+    throw new CliError("model mapping requires an interactive terminal");
+  }
+  const ask = async (label2, required2) => {
+    const answer = await prompt.input?.(`${label2} model${required2 ? "" : " (blank to omit)"} [${choices}]: `);
+    if (required2 && answer === "")
+      throw new CliError("default model is required");
+    return answer === "" ? undefined : answer;
+  };
+  const defaultModel = await ask("Default", true);
+  if (defaultModel === undefined)
+    throw new CliError("default model is required");
+  const fableModel = await ask("Fable", false);
+  const opusModel = await ask("Opus", false);
+  const sonnetModel = await ask("Sonnet", false);
+  const haikuModel = await ask("Haiku", false);
+  return {
+    defaultModel,
+    ...fableModel === undefined ? {} : { fableModel },
+    ...opusModel === undefined ? {} : { opusModel },
+    ...sonnetModel === undefined ? {} : { sonnetModel },
+    ...haikuModel === undefined ? {} : { haikuModel }
+  };
+}
 var setupClaude = {
   usage: "setup claude [--dir <path>] [--key <key>] [--dry-run]",
-  summary: "Write a Claude Code profile per virtual model",
+  summary: "Write Claude Code settings for this gateway",
   options: OPTIONS,
-  async run(args, { ctx, writer, setupFs }) {
+  async run(args, { ctx, writer, prompt, setupFs }) {
     const models = await described(ctx);
-    const dir = stringFlag(args.values, "dir") ?? join4(setupFs.homeDir, ".claude", "profiles");
+    const dir = stringFlag(args.values, "dir") ?? join4(setupFs.homeDir, ".claude");
     const key = stringFlag(args.values, "key");
     const dryRun2 = boolFlag(args.values, "dry-run");
-    const files = claudeProfiles(models, {
+    const mapping = await promptMapping(models, prompt);
+    const path = join4(dir, "settings.json");
+    const file2 = claudeSettings(models, {
       baseUrl: baseUrl(ctx),
       discoveryMirrors: ctx.config().exposeClaudeCodeAliases,
       ...key === undefined ? {} : { apiKey: key }
-    }).map((file2) => at(dir, file2));
-    finish(ctx, writer, files, dryRun2, key, setupFs.write);
-    if (!dryRun2) {
-      note(ctx, writer, `run one with: CLAUDE_CONFIG_DIR=${dirname2(files[0]?.path ?? dir)} claude`);
-    }
+    }, mapping, setupFs.read(path) ?? undefined);
+    finish(ctx, writer, [at(dir, file2)], dryRun2, key, setupFs.write);
   }
 };
 var setupOpencode = {
   usage: "setup opencode [--dir <path>] [--key <key>] [--dry-run]",
   summary: "Write an opencode.json provider entry for this gateway",
   options: OPTIONS,
-  async run(args, { ctx, writer, setupFs }) {
+  async run(args, { ctx, writer, prompt, setupFs }) {
     const models = await described(ctx);
     const dir = stringFlag(args.values, "dir") ?? setupFs.cwd;
     const key = stringFlag(args.values, "key");
     const dryRun2 = boolFlag(args.values, "dry-run");
+    const mapping = await promptMapping(models, prompt);
     const file2 = opencodeConfig(models, {
       baseUrl: baseUrl(ctx),
       ...key === undefined ? {} : { apiKey: key }
-    });
+    }, mapping);
     finish(ctx, writer, [at(dir, file2)], dryRun2, key, setupFs.write);
   }
 };
@@ -20316,6 +20822,12 @@ function createPrompt(ctx, writer) {
   const isTty = process.stdin.isTTY === true;
   return {
     isTty,
+    async input(question) {
+      if (!isTty)
+        throw new CliError(`${question} \u2014 refusing without a terminal`);
+      writer.err(question);
+      return (await readLine()).trim();
+    },
     async secret(question) {
       if (!isTty)
         return (await readAllStdin()).trim();
@@ -20336,6 +20848,20 @@ function createPrompt(ctx, writer) {
   };
 }
 
+// apps/cli/src/setupFs.ts
+import { dirname as dirname2 } from "path";
+function atomicWriteFile(path, contents, ops) {
+  const temporary = `${path}.${process.pid}.tmp`;
+  ops.mkdir(dirname2(path));
+  try {
+    ops.write(temporary, contents);
+    ops.rename(temporary, path);
+  } catch (error51) {
+    ops.remove(temporary);
+    throw error51;
+  }
+}
+
 // apps/cli/src/run.ts
 var VERSION = "0.0.0";
 async function run(argv, writer, options = {}) {
@@ -20377,10 +20903,13 @@ async function run(argv, writer, options = {}) {
     setupFs: options.setupFs ?? {
       homeDir: homedir3(),
       cwd: process.cwd(),
-      write: (path, contents) => {
-        mkdirSync2(dirname3(path), { recursive: true });
-        writeFileSync2(path, contents);
-      }
+      read: (path) => existsSync6(path) ? readFileSync3(path, "utf8") : null,
+      write: (path, contents) => atomicWriteFile(path, contents, {
+        mkdir: (directory) => mkdirSync2(directory, { recursive: true }),
+        write: (temporary, data) => writeFileSync2(temporary, data),
+        rename: renameSync,
+        remove: (temporary) => rmSync2(temporary, { force: true })
+      })
     },
     service: () => options.service?.({ root: ctx.root.root, env: ctx.env }) ?? createServiceDeps({ root: ctx.root.root, env: ctx.env, scope, now: ctx.now }),
     foreground: options.foreground ?? runForeground,