omnigateway 0.9.1 → 0.10.0

package/gateway.js

@@ -4687,8 +4687,8 @@ class FileTypeParser {
       if (jsonSize > 12 && this.buffer.length >= jsonSize + 16) {
         try {
           const header = new TextDecoder().decode(this.buffer.subarray(16, jsonSize + 16));
-          const json8 = JSON.parse(header);
-          if (json8.files) {
+          const json10 = JSON.parse(header);
+          if (json10.files) {
             return {
               ext: "asar",
               mime: "application/x-asar"
@@ -28911,6 +28911,12 @@ var ANTHROPIC_MODELS = {
   defaultModel: "claude-opus-5",
   authTypes: ["oauth", "apiKey"],
   models: [
+    {
+      id: "claude-fable-5-1",
+      label: "Claude Fable 5.1",
+      pricing: { input: 10, output: 50, cacheRead: 0.25, cacheWrite5m: 12.5, cacheWrite1h: 20 },
+      limits: { contextWindow: 1e6, maxOutputTokens: 128000 }
+    },
     {
       id: "claude-fable-5",
       label: "Claude Fable 5",
@@ -28926,7 +28932,7 @@ var ANTHROPIC_MODELS = {
     {
       id: "claude-sonnet-5",
       label: "Claude Sonnet 5",
-      pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite5m: 3.75, cacheWrite1h: 6 },
+      pricing: { input: 2, output: 10, cacheRead: 0.2, cacheWrite5m: 2.5, cacheWrite1h: 4 },
       limits: { contextWindow: 1e6, maxOutputTokens: 128000 }
     },
     {
@@ -28964,6 +28970,144 @@ var anthropicDescriptor = {
   }
 };
 
+// packages/providers/src/antigravity/models.ts
+var MAX_OUTPUT_TOKENS = 65536;
+var PRO_MAX_OUTPUT_TOKENS = 65535;
+var FREE = { input: 0, output: 0, cacheRead: 0, cacheWrite5m: 0, cacheWrite1h: 0 };
+var FLASH_LIMITS = { contextWindow: 1048576, maxOutputTokens: MAX_OUTPUT_TOKENS };
+var PRO_LIMITS = { contextWindow: 1048576, maxOutputTokens: PRO_MAX_OUTPUT_TOKENS };
+var ANTIGRAVITY_MODELS = {
+  defaultModel: "gemini-3.8-flash-high",
+  authTypes: ["oauth"],
+  models: [
+    {
+      id: "gemini-3.8-flash-high",
+      label: "Gemini 3.8 Flash (High)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.8-flash-medium",
+      label: "Gemini 3.8 Flash (Medium)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.8-flash-low",
+      label: "Gemini 3.8 Flash (Low)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.7-flash-high",
+      label: "Gemini 3.7 Flash (High)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.7-flash-medium",
+      label: "Gemini 3.7 Flash (Medium)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.7-flash-low",
+      label: "Gemini 3.7 Flash (Low)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.6-flash-high",
+      label: "Gemini 3.6 Flash (High)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.6-flash-medium",
+      label: "Gemini 3.6 Flash (Medium)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.6-flash-low",
+      label: "Gemini 3.6 Flash (Low)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3-flash-agent",
+      label: "Gemini 3.5 Flash (High)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.5-flash-low",
+      label: "Gemini 3.5 Flash (Medium)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.5-flash-extra-low",
+      label: "Gemini 3.5 Flash (Low)",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3-flash",
+      label: "Gemini 3 Flash",
+      pricing: FREE,
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.5-flash-lite",
+      label: "Gemini 3.5 Flash Lite",
+      pricing: FREE,
+      limits: PRO_LIMITS
+    },
+    {
+      id: "gemini-3.1-pro-high",
+      label: "Gemini 3.1 Pro (High)",
+      pricing: FREE,
+      limits: PRO_LIMITS
+    },
+    {
+      id: "gemini-3.1-pro-low",
+      label: "Gemini 3.1 Pro (Low)",
+      pricing: FREE,
+      limits: PRO_LIMITS
+    },
+    {
+      id: "gemini-3.1-flash-lite",
+      label: "Gemini 3.1 Flash Lite",
+      pricing: FREE,
+      limits: PRO_LIMITS
+    },
+    {
+      id: "gemini-2.5-pro",
+      label: "Gemini 2.5 Pro",
+      pricing: FREE,
+      limits: PRO_LIMITS
+    }
+  ]
+};
+
+// packages/providers/src/antigravity/descriptor.ts
+var antigravityDescriptor = {
+  id: "antigravity",
+  capabilities: { tools: true, images: true, reasoning: true },
+  writeOverInput: { fiveMinute: 0, oneHour: 0 },
+  catalog: ANTIGRAVITY_MODELS,
+  modelPrefixes: ["gemini-"],
+  callback: { uri: "http://127.0.0.1:51121/callback", label: "Antigravity" },
+  presentation: {
+    label: "Antigravity",
+    order: 6,
+    tone: "violet",
+    colour: { light: "oklch(0.52 0.14 277)", dark: "oklch(0.74 0.14 277)" },
+    pasteHint: "Approve in a browser on the gateway's own machine \u2014 or SSH-forward port 51121 first. When it redirects to 127.0.0.1, paste the whole URL."
+  }
+};
+
 // packages/providers/src/custom/models.ts
 var CUSTOM_MODELS = {
   defaultModel: "",
@@ -28980,7 +29124,7 @@ var customDescriptor = {
   modelPrefixes: [],
   presentation: {
     label: "OpenAI Compatible",
-    order: 6,
+    order: 8,
     tone: "cyan",
     colour: { light: "oklch(0.5 0.03 258)", dark: "oklch(0.72 0.03 258)" },
     pasteHint: "Enter endpoint metadata and API key."
@@ -29305,35 +29449,90 @@ var kimiDescriptor = {
   }
 };
 
+// packages/providers/src/muse/models.ts
+var MUSE_MODELS = {
+  defaultModel: "muse-spark-1.3",
+  authTypes: ["oauth", "apiKey"],
+  models: [
+    {
+      id: "muse-spark-1.3",
+      label: "Muse Spark 1.3",
+      pricing: { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 1048576, maxOutputTokens: 943718 }
+    },
+    {
+      id: "muse-spark-1.3-contributor",
+      label: "Muse Spark 1.3 \u2014 Meta trains on this traffic",
+      pricing: { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 1048576, maxOutputTokens: 943718 }
+    },
+    {
+      id: "muse-spark-1.2",
+      label: "Muse Spark 1.2",
+      pricing: { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 1048576, maxOutputTokens: 943718 }
+    },
+    {
+      id: "muse-spark-1.2-contributor",
+      label: "Muse Spark 1.2 \u2014 Meta trains on this traffic",
+      pricing: { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 1048576, maxOutputTokens: 943718 }
+    }
+  ]
+};
+
+// packages/providers/src/muse/descriptor.ts
+var museDescriptor = {
+  id: "muse",
+  capabilities: { tools: true, images: true, reasoning: true },
+  writeOverInput: { fiveMinute: 0, oneHour: 0 },
+  catalog: MUSE_MODELS,
+  modelPrefixes: ["muse-", "muse-spark"],
+  presentation: {
+    label: "Muse",
+    order: 7,
+    tone: "azure",
+    colour: { light: "oklch(0.55 0.23 262)", dark: "oklch(0.72 0.17 262)" },
+    pasteHint: "Enter the code on Meta's device page. This dialog finishes on its own."
+  }
+};
+
 // packages/providers/src/openai/models.ts
 var OPENAI_MODELS = {
   defaultModel: "gpt-5.6",
   authTypes: ["oauth", "apiKey"],
   models: [
+    {
+      id: "gpt-6-astra",
+      label: "GPT-6 Astra",
+      pricing: { input: 10, output: 50, cacheRead: 1, cacheWrite5m: 0, cacheWrite1h: 0 },
+      limits: { contextWindow: 922000, maxOutputTokens: 128000 },
+      oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
+    },
     {
       id: "gpt-5.6",
       label: "GPT-5.6 \u2014 routes to Sol",
-      pricing: { input: 5, output: 30, cacheRead: 0.5, cacheWrite5m: 0, cacheWrite1h: 0 },
+      pricing: { input: 4, output: 20, cacheRead: 0.4, 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 },
+      label: "GPT-5.6 Sol",
+      pricing: { input: 4, output: 20, cacheRead: 0.4, 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",
+      label: "GPT-5.6 Terra",
       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",
+      label: "GPT-5.6 Luna",
       pricing: { input: 0.2, output: 1.2, cacheRead: 0.02, cacheWrite5m: 0, cacheWrite1h: 0 },
       limits: { contextWindow: 922000, maxOutputTokens: 128000 },
       oauthLimits: { contextWindow: 272000, maxOutputTokens: 128000 }
@@ -29371,6 +29570,8 @@ var PROVIDER_DESCRIPTORS = {
   kimi: kimiDescriptor,
   kilo: kiloDescriptor,
   grok: grokDescriptor,
+  antigravity: antigravityDescriptor,
+  muse: museDescriptor,
   custom: customDescriptor
 };
 Object.setPrototypeOf(PROVIDER_DESCRIPTORS, null);
@@ -29520,6 +29721,19 @@ function loadConfig(env) {
   const bodyLoggingAllowed = TRUTHY.has((env.OMNI_BODY_LOGGING_ALLOWED ?? "").trim().toLowerCase());
   const rawLogLevel = env.OMNI_LOG_LEVEL?.trim();
   const logLevel = parseLogLevel(rawLogLevel);
+  const metricsToken = env.OMNI_METRICS_TOKEN?.trim() || null;
+  const rawMaxSeries = env.OMNI_METRICS_MAX_SERIES ?? "5000";
+  const metricsMaxSeries = Number(rawMaxSeries);
+  if (!DECIMAL_INTEGER.test(rawMaxSeries) || metricsMaxSeries < 1) {
+    throw new Error(`OMNI_METRICS_MAX_SERIES must be a positive integer, got "${rawMaxSeries}"`);
+  }
+  const otlpEndpoint = env.OMNI_OTLP_ENDPOINT?.trim().replace(/\/+$/, "") || null;
+  const otlpHeaders = env.OMNI_OTLP_HEADERS?.trim() || null;
+  const rawTraceSample = env.OMNI_TRACE_SAMPLE ?? "1.0";
+  const traceSample = Number(rawTraceSample);
+  if (!Number.isFinite(traceSample) || traceSample < 0 || traceSample > 1) {
+    throw new Error(`OMNI_TRACE_SAMPLE must be between 0 and 1, got "${rawTraceSample}"`);
+  }
   return {
     logLevel: logLevel ?? "info",
     logLevelFallbackFrom: logLevel === null && rawLogLevel ? rawLogLevel : null,
@@ -29533,7 +29747,12 @@ function loadConfig(env) {
     logFile: logFile === undefined || logFile.length === 0 ? null : logFile,
     clusterMode,
     databaseUrl: clusterMode ? databaseUrl ?? null : null,
-    redisUrl: clusterMode ? redisUrl ?? null : null
+    redisUrl: clusterMode ? redisUrl ?? null : null,
+    metricsToken,
+    metricsMaxSeries,
+    otlpEndpoint,
+    otlpHeaders,
+    traceSample
   };
 }
 // packages/control/src/oauth/pending.ts
@@ -29732,7 +29951,8 @@ function codecAdapter(id, capabilities2, codec2, origins) {
       const res = await req.http({
         provider: id,
         ...sendable,
-        signal: req.signal
+        signal: req.signal,
+        ...req.requestId === undefined ? {} : { requestId: req.requestId }
       });
       if (res.status < 200 || res.status >= 300) {
         const text = await res.text().catch(() => "");
@@ -29890,6 +30110,38 @@ var anthropicBodyOrder = [
   "stream"
 ];
 
+// packages/providers/src/antigravity/profile.ts
+var ANTIGRAVITY_IDE_VERSION = env("OMNI_ANTIGRAVITY_IDE_VERSION", "2.12.2");
+var PLATFORM = "darwin/arm64";
+var antigravityProfile = {
+  headers: [
+    [
+      "User-Agent",
+      env("OMNI_UA_ANTIGRAVITY", `antigravity/ide/${ANTIGRAVITY_IDE_VERSION} ${PLATFORM}`)
+    ],
+    ["Content-Type", "application/json"],
+    ["Accept", "text/event-stream"]
+  ],
+  order: envOrder("OMNI_ORDER_ANTIGRAVITY", [
+    "Host",
+    "Content-Type",
+    "Authorization",
+    "User-Agent",
+    "X-Goog-Api-Client",
+    "Accept",
+    "Accept-Encoding",
+    "Content-Length"
+  ])
+};
+var antigravityBodyOrder = [
+  "project",
+  "requestId",
+  "model",
+  "userAgent",
+  "requestType",
+  "request"
+];
+
 // packages/providers/src/custom/profile.ts
 var customProfile = { headers: [], order: [] };
 var customBodyOrder = [];
@@ -30011,6 +30263,43 @@ var kimiBodyOrder = [
   "stream"
 ];
 
+// packages/providers/src/muse/profile.ts
+var MUSE_CLI_VERSION = env("OMNI_MUSE_CLI_VERSION", "1.0.3");
+var museProfile = {
+  headers: [
+    ["User-Agent", env("OMNI_UA_MUSE", `muse-code/${MUSE_CLI_VERSION}`)],
+    ["x-api-version", env("OMNI_MUSE_API_VERSION", "1.0.0")],
+    ["Accept", "text/event-stream"]
+  ],
+  order: envOrder("OMNI_ORDER_MUSE", [
+    "Host",
+    "Content-Type",
+    "Authorization",
+    "x-meta-ai-gateway-session-id",
+    "x-api-version",
+    "Accept",
+    "User-Agent",
+    "Accept-Encoding",
+    "Content-Length"
+  ])
+};
+var museBodyOrder = [
+  "model",
+  "stream",
+  "input",
+  "instructions",
+  "store",
+  "reasoning",
+  "prompt_cache_key",
+  "max_output_tokens",
+  "temperature",
+  "tools",
+  "tool_choice",
+  "include",
+  "parallel_tool_calls",
+  "metadata"
+];
+
 // packages/providers/src/openai/profile.ts
 var OPENAI_CLI_VERSION = env("OMNI_OPENAI_CLI_VERSION", "0.144.1");
 var OPENAI_UA_PLATFORM = env("OMNI_OPENAI_UA_PLATFORM", "Windows 10.0.26200");
@@ -30067,6 +30356,8 @@ var BODY_ORDER = {
   kimi: kimiBodyOrder,
   kilo: kiloBodyOrder,
   grok: grokBodyOrder,
+  antigravity: antigravityBodyOrder,
+  muse: museBodyOrder,
   custom: customBodyOrder
 };
 Object.setPrototypeOf(BODY_ORDER, null);
@@ -30160,6 +30451,8 @@ var PROVIDER_MODEL_CATALOG = {
   kimi: KIMI_MODELS,
   kilo: KILO_MODELS,
   grok: GROK_MODELS,
+  antigravity: ANTIGRAVITY_MODELS,
+  muse: MUSE_MODELS,
   custom: CUSTOM_MODELS
 };
 Object.setPrototypeOf(PROVIDER_MODEL_CATALOG, null);
@@ -30190,6 +30483,8 @@ var PROFILES = {
   kimi: kimiProfile,
   kilo: kiloProfile,
   grok: grokProfile,
+  antigravity: antigravityProfile,
+  muse: museProfile,
   custom: customProfile
 };
 Object.setPrototypeOf(PROFILES, null);
@@ -31474,6 +31769,751 @@ var anthropicOAuthFlow = {
     return parseAnthropicUsage(parsed(res.body), now());
   }
 };
+// packages/providers/src/antigravity/codec.ts
+import { createHash as createHash2 } from "crypto";
+
+// packages/providers/src/antigravity/decode.ts
+var STOP_REASON2 = {
+  STOP: "endTurn",
+  MAX_TOKENS: "maxTokens",
+  SAFETY: "contentFilter",
+  PROHIBITED_CONTENT: "contentFilter",
+  SPII: "contentFilter",
+  BLOCKLIST: "contentFilter",
+  RECITATION: "contentFilter"
+};
+var ERROR_CODE = {
+  RESOURCE_EXHAUSTED: "RATE_LIMIT",
+  UNAUTHENTICATED: "AUTH",
+  PERMISSION_DENIED: "AUTH",
+  INVALID_ARGUMENT: "BAD_REQUEST",
+  FAILED_PRECONDITION: "BAD_REQUEST",
+  UNAVAILABLE: "UPSTREAM",
+  INTERNAL: "UPSTREAM",
+  DEADLINE_EXCEEDED: "TIMEOUT"
+};
+function json3(data) {
+  try {
+    const value = JSON.parse(data);
+    return typeof value === "object" && value !== null ? value : null;
+  } catch {
+    return null;
+  }
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function usageOf(meta3) {
+  return usageFromPromptTotal(count(meta3?.promptTokenCount), count(meta3?.candidatesTokenCount) + count(meta3?.thoughtsTokenCount), count(meta3?.cachedContentTokenCount));
+}
+async function* decodeAntigravityStream(messages) {
+  let started = false;
+  let terminal = false;
+  let nextIndex = 0;
+  let toolCalls = 0;
+  let open2 = null;
+  const closeOpen = function* () {
+    if (open2 === null)
+      return;
+    yield { type: "blockEnd", index: open2.index };
+    open2 = null;
+  };
+  for await (const message of messages) {
+    if (message.data === "[DONE]")
+      continue;
+    const frame = json3(message.data);
+    if (frame === null)
+      continue;
+    const failure = frame.error ?? frame.response?.error;
+    if (failure !== undefined) {
+      terminal = true;
+      yield* closeOpen();
+      const status = String(failure.status ?? "");
+      const code = (Object.hasOwn(ERROR_CODE, status) ? ERROR_CODE[status] : undefined) ?? "UPSTREAM";
+      yield {
+        type: "error",
+        code,
+        message: String(failure.message ?? "upstream error"),
+        retryable: RETRYABLE[code]
+      };
+      return;
+    }
+    const response = frame.response;
+    if (response === undefined)
+      continue;
+    const blocked = response.promptFeedback?.blockReason;
+    if (blocked !== undefined && (response.candidates ?? []).length === 0) {
+      terminal = true;
+      if (!started)
+        yield { type: "start", id: "", model: "" };
+      yield* closeOpen();
+      yield { type: "end", stopReason: "contentFilter", usage: usageOf(response.usageMetadata) };
+      return;
+    }
+    if (!started) {
+      started = true;
+      yield {
+        type: "start",
+        id: String(response.responseId ?? ""),
+        model: String(response.modelVersion ?? "")
+      };
+    }
+    const candidates = response.candidates ?? [];
+    if (candidates.length > 1) {
+      terminal = true;
+      yield* closeOpen();
+      yield {
+        type: "error",
+        code: "UPSTREAM",
+        message: `Antigravity returned ${candidates.length} candidates, which cannot be represented`,
+        retryable: false
+      };
+      return;
+    }
+    const candidate = candidates[0];
+    for (const part of candidate?.content?.parts ?? []) {
+      const call = part.functionCall;
+      if (call !== undefined && typeof call.name === "string") {
+        yield* closeOpen();
+        const index = nextIndex++;
+        yield {
+          type: "blockStart",
+          index,
+          block: {
+            type: "toolUse",
+            id: typeof call.id === "string" && call.id.length > 0 ? call.id : `fc_${toolCalls}`,
+            name: call.name
+          }
+        };
+        yield {
+          type: "blockDelta",
+          index,
+          delta: { type: "toolJson", partial: JSON.stringify(call.args ?? {}) }
+        };
+        yield { type: "blockEnd", index };
+        toolCalls++;
+        continue;
+      }
+      if (typeof part.text !== "string")
+        continue;
+      const kind = part.thought === true ? "thinking" : "text";
+      if (open2 === null || open2.kind !== kind) {
+        yield* closeOpen();
+        open2 = { kind, index: nextIndex++ };
+        yield { type: "blockStart", index: open2.index, block: { type: kind } };
+      }
+      yield {
+        type: "blockDelta",
+        index: open2.index,
+        delta: kind === "thinking" ? { type: "thinking", text: part.text } : { type: "text", text: part.text }
+      };
+    }
+    const finish = candidate?.finishReason;
+    if (finish === undefined || finish === null)
+      continue;
+    terminal = true;
+    yield* closeOpen();
+    const raw = String(finish);
+    if (raw === "MALFORMED_FUNCTION_CALL") {
+      yield {
+        type: "error",
+        code: "BAD_REQUEST",
+        message: "the model emitted a malformed function call",
+        retryable: false
+      };
+      return;
+    }
+    const mapped = Object.hasOwn(STOP_REASON2, raw) ? STOP_REASON2[raw] : undefined;
+    if (mapped === undefined) {
+      yield {
+        type: "error",
+        code: "UPSTREAM",
+        message: `unrecognized Antigravity finish reason "${raw}"`,
+        retryable: false
+      };
+      return;
+    }
+    yield {
+      type: "end",
+      stopReason: toolCalls > 0 ? "toolUse" : mapped,
+      usage: usageOf(response.usageMetadata)
+    };
+    return;
+  }
+  if (!terminal) {
+    yield* closeOpen();
+    yield {
+      type: "error",
+      code: "UPSTREAM",
+      message: "upstream stream ended before the response finished",
+      retryable: RETRYABLE.UPSTREAM
+    };
+  }
+}
+
+// packages/providers/src/antigravity/wire.ts
+var SIGNATURE_BYPASS = "skip_thought_signature_validator";
+function toolNamesById(req) {
+  const names = new Map;
+  for (const message of req.messages) {
+    for (const block of message.content) {
+      if (block.type === "toolUse")
+        names.set(block.id, block.name);
+    }
+  }
+  return names;
+}
+function mergeSameRole(contents) {
+  const merged = [];
+  for (const entry of contents) {
+    const last = merged[merged.length - 1];
+    if (last !== undefined && last.role === entry.role)
+      last.parts.push(...entry.parts);
+    else
+      merged.push({ role: entry.role, parts: [...entry.parts] });
+  }
+  return merged;
+}
+var hasCacheControl = (block) => ("cacheControl" in block) && block.cacheControl !== undefined;
+function encodeToolChoice2(choice) {
+  switch (choice.type) {
+    case "auto":
+      return { functionCallingConfig: { mode: "AUTO" } };
+    case "any":
+      return { functionCallingConfig: { mode: "ANY" } };
+    case "none":
+      return { functionCallingConfig: { mode: "NONE" } };
+    case "tool":
+      return { functionCallingConfig: { mode: "ANY", allowedFunctionNames: [choice.name] } };
+  }
+}
+function toAntigravityWire(req, model, identity) {
+  const degradations = [];
+  const note = (d) => {
+    if (!degradations.includes(d))
+      degradations.push(d);
+  };
+  const names = toolNamesById(req);
+  const contents = [];
+  for (const message of req.messages) {
+    const parts = [];
+    if (message.role === "system")
+      note("antigravity:system-turn-as-user");
+    let role = message.role === "assistant" ? "model" : "user";
+    for (const block of message.content) {
+      if (hasCacheControl(block))
+        note("antigravity:cache-control-dropped");
+      switch (block.type) {
+        case "text":
+          parts.push({ text: block.text });
+          break;
+        case "image":
+          parts.push({ inlineData: { mimeType: block.mediaType, data: block.data } });
+          break;
+        case "thinking":
+          note("antigravity:thinking-dropped");
+          break;
+        case "toolUse":
+          parts.push({
+            thoughtSignature: SIGNATURE_BYPASS,
+            functionCall: { name: block.name, args: block.input }
+          });
+          break;
+        case "toolResult": {
+          const name = names.get(block.toolUseId);
+          if (name === undefined)
+            note("antigravity:tool-result-unmatched");
+          if (block.isError === true)
+            note("antigravity:tool-result-error-flag-dropped");
+          parts.push({
+            functionResponse: {
+              name: name ?? block.toolUseId,
+              response: { output: block.content }
+            }
+          });
+          role = "user";
+          break;
+        }
+        case "providerNative":
+          note("antigravity:provider-native-block-dropped");
+          break;
+      }
+    }
+    if (parts.length > 0)
+      contents.push({ role, parts });
+  }
+  const request2 = { contents: mergeSameRole(contents) };
+  const system = systemText(req.system, "antigravity", note);
+  if (system !== undefined && system.length > 0) {
+    request2.systemInstruction = { parts: [{ text: system }] };
+  }
+  const generationConfig = {};
+  if (req.maxTokens !== undefined)
+    generationConfig.maxOutputTokens = req.maxTokens;
+  if (req.temperature !== undefined)
+    generationConfig.temperature = req.temperature;
+  if (req.stopSequences !== undefined)
+    generationConfig.stopSequences = req.stopSequences;
+  if (req.reasoning !== undefined) {
+    switch (req.reasoning.mode) {
+      case "off":
+        generationConfig.thinkingConfig = { thinkingBudget: 0, includeThoughts: false };
+        break;
+      case "budget":
+        generationConfig.thinkingConfig = {
+          thinkingBudget: req.reasoning.budgetTokens,
+          includeThoughts: req.reasoning.budgetTokens !== 0
+        };
+        break;
+      case "adaptive":
+        generationConfig.thinkingConfig = {
+          includeThoughts: req.reasoning.display !== "omitted"
+        };
+        if (req.reasoning.effort !== undefined)
+          note("antigravity:reasoning-effort-dropped");
+        break;
+    }
+  }
+  const max = generationConfig.maxOutputTokens;
+  if (max !== undefined && max > MAX_OUTPUT_TOKENS) {
+    generationConfig.maxOutputTokens = MAX_OUTPUT_TOKENS;
+    note("antigravity:max-tokens-clamped");
+  }
+  const budget = generationConfig.thinkingConfig?.thinkingBudget;
+  if (budget !== undefined && budget > 0) {
+    const ceiling = generationConfig.maxOutputTokens;
+    if (ceiling === undefined || ceiling <= budget) {
+      generationConfig.maxOutputTokens = Math.min(budget + 1, MAX_OUTPUT_TOKENS);
+    }
+  }
+  if (Object.keys(generationConfig).length > 0)
+    request2.generationConfig = generationConfig;
+  if (req.tools !== undefined) {
+    const portable = req.tools.filter((t) => t.kind === "portable");
+    if (portable.length !== req.tools.length)
+      note("antigravity:provider-tool-dropped");
+    if (portable.length > 0) {
+      request2.tools = [
+        {
+          functionDeclarations: portable.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.inputSchema
+          }))
+        }
+      ];
+    }
+  }
+  if (req.toolChoice !== undefined)
+    request2.toolConfig = encodeToolChoice2(req.toolChoice);
+  Object.assign(request2, req.vendor?.antigravity ?? {});
+  return {
+    body: {
+      project: identity.project,
+      requestId: identity.requestId,
+      model,
+      userAgent: "antigravity",
+      requestType: "agent",
+      request: request2
+    },
+    degradations
+  };
+}
+
+// packages/providers/src/antigravity/codec.ts
+var URL2 = "https://daily-cloudcode-pa.googleapis.com/v1internal:streamGenerateContent?alt=sse";
+var REQUEST_NAMESPACE = "omni-antigravity-req";
+function derivedRequestId(seed) {
+  const h = createHash2("sha256").update(`${REQUEST_NAMESPACE}:${seed}`).digest("hex");
+  const variant = (Number.parseInt(h[16], 16) & 3 | 8).toString(16);
+  return [
+    h.slice(0, 8),
+    h.slice(8, 12),
+    `4${h.slice(13, 16)}`,
+    `${variant}${h.slice(17, 20)}`,
+    h.slice(20, 32)
+  ].join("-");
+}
+function projectOf(input2) {
+  const stored = input2.credentials.providerData.projectId;
+  const project = typeof stored === "string" ? stored.trim() : "";
+  if (project.length === 0) {
+    throw input2.fail("AUTH", "antigravity credential has no Cloud Code project; reconnect the account");
+  }
+  return project;
+}
+var antigravityCodec = {
+  buildRequest(input2) {
+    const accessToken = input2.credentials.accessToken;
+    if (accessToken === null || accessToken.length === 0) {
+      throw input2.fail("AUTH", "antigravity credential has no access token");
+    }
+    const project = projectOf(input2);
+    const requestId = input2.requestId !== undefined && input2.requestId.length > 0 ? input2.requestId : derivedRequestId(`${input2.model}:${project}`);
+    const { body, degradations } = toAntigravityWire(input2.request, input2.model, {
+      project,
+      requestId
+    });
+    const protocol = [["Authorization", `Bearer ${accessToken}`]];
+    const headers = orderHeaders(mergeHeaders(antigravityProfile.headers, protocol), antigravityProfile.order);
+    return {
+      request: {
+        url: URL2,
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      },
+      degradations
+    };
+  },
+  decode({ body }) {
+    return decodeAntigravityStream(parseSse(body));
+  }
+};
+
+// packages/providers/src/antigravity/index.ts
+var antigravityAdapter = codecAdapter("antigravity", antigravityDescriptor.capabilities, antigravityCodec);
+// packages/providers/src/antigravity/oauth.ts
+var MASK = "omnigateway-public-v1";
+function unmask(bytes) {
+  let out = "";
+  for (let i = 0;i < bytes.length; i++) {
+    out += String.fromCharCode(bytes[i] ^ MASK.charCodeAt(i % MASK.length));
+  }
+  return out;
+}
+var ANTIGRAVITY_CLIENT_ID = unmask([
+  94,
+  93,
+  89,
+  88,
+  87,
+  81,
+  66,
+  85,
+  65,
+  81,
+  76,
+  20,
+  65,
+  88,
+  22,
+  1,
+  1,
+  16,
+  94,
+  31,
+  95,
+  93,
+  5,
+  92,
+  88,
+  11,
+  2,
+  6,
+  0,
+  69,
+  82,
+  76,
+  91,
+  4,
+  26,
+  14,
+  3,
+  3,
+  11,
+  25,
+  17,
+  5,
+  95,
+  94,
+  11,
+  25,
+  73,
+  0,
+  4,
+  21,
+  4,
+  79,
+  30,
+  66,
+  31,
+  18,
+  14,
+  9,
+  28,
+  16,
+  72,
+  4,
+  82,
+  0,
+  3,
+  26,
+  12,
+  9,
+  21,
+  90,
+  6,
+  24,
+  12
+]);
+var CLIENT_ID2 = ANTIGRAVITY_CLIENT_ID;
+var CLIENT_SECRET = unmask([
+  40,
+  34,
+  45,
+  58,
+  55,
+  57,
+  89,
+  46,
+  66,
+  89,
+  63,
+  122,
+  34,
+  65,
+  90,
+  90,
+  37,
+  7,
+  97,
+  60,
+  0,
+  2,
+  33,
+  44,
+  81,
+  20,
+  57,
+  55,
+  81,
+  13,
+  87,
+  8,
+  105,
+  49,
+  19
+]);
+var AUTHORIZE_URL2 = "https://accounts.google.com/o/oauth2/v2/auth";
+var TOKEN_URL2 = "https://oauth2.googleapis.com/token";
+var USERINFO_URL = "https://www.googleapis.com/oauth2/v1/userinfo?alt=json";
+var CODE_ASSIST = "https://cloudcode-pa.googleapis.com/v1internal";
+var LOAD_CODE_ASSIST_URL = `${CODE_ASSIST}:loadCodeAssist`;
+var ONBOARD_USER_URL = `${CODE_ASSIST}:onboardUser`;
+var QUOTA_SUMMARY_URL = `${CODE_ASSIST}:retrieveUserQuotaSummary`;
+var SCOPES2 = [
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile",
+  "https://www.googleapis.com/auth/cclog",
+  "https://www.googleapis.com/auth/experimentsandconfigs"
+].join(" ");
+var IDE_METADATA = { ideType: "ANTIGRAVITY" };
+var DEFAULT_TIER = "legacy-tier";
+function parseTokenResponse(value) {
+  const record2 = recordOf(value);
+  if (record2 === null || typeof record2.access_token !== "string")
+    return null;
+  return {
+    accessToken: record2.access_token,
+    refreshToken: typeof record2.refresh_token === "string" ? record2.refresh_token : null,
+    expiresIn: typeof record2.expires_in === "number" ? record2.expires_in : null
+  };
+}
+async function* postToken2(body, fail) {
+  const res = yield postJsonRequest(TOKEN_URL2, antigravityProfile, {
+    contentType: "application/x-www-form-urlencoded",
+    body: new URLSearchParams(body).toString()
+  });
+  const parsed2 = parsed(res.body);
+  if (res.status < 200 || res.status >= 300) {
+    throw fail(tokenErrorCode(res.status), tokenErrorMessage(res.status, parsed2));
+  }
+  const token = parseTokenResponse(parsed2);
+  if (token === null)
+    throw fail("AUTH", "token endpoint returned no access_token");
+  return token;
+}
+function projectFrom(value) {
+  const record2 = recordOf(value);
+  if (record2 === null)
+    return "";
+  const project = record2.cloudaicompanionProject;
+  if (typeof project === "string")
+    return project.trim();
+  const nested = recordOf(project);
+  const id = nested?.id;
+  return typeof id === "string" ? id.trim() : "";
+}
+function tierFrom(value) {
+  const record2 = recordOf(value);
+  const tiers = record2?.allowedTiers;
+  if (Array.isArray(tiers)) {
+    for (const entry of tiers) {
+      const tier = recordOf(entry);
+      if (tier?.isDefault === true && typeof tier.id === "string")
+        return tier.id;
+    }
+  }
+  const current = recordOf(record2?.currentTier);
+  return typeof current?.id === "string" ? current.id : DEFAULT_TIER;
+}
+function codeAssistRequest(url2, accessToken, body) {
+  return postJsonRequest(url2, antigravityProfile, {
+    contentType: "application/json",
+    body: JSON.stringify(body),
+    extraHeaders: [["Authorization", `Bearer ${accessToken}`]]
+  });
+}
+async function* bootstrapProject(accessToken) {
+  const loaded = yield codeAssistRequest(LOAD_CODE_ASSIST_URL, accessToken, {
+    metadata: IDE_METADATA
+  });
+  const body = loaded.status >= 200 && loaded.status < 300 ? parsed(loaded.body) : null;
+  const tier = tierFrom(body);
+  const existing = projectFrom(body);
+  if (existing.length > 0)
+    return { projectId: existing, tier };
+  const onboarded = yield codeAssistRequest(ONBOARD_USER_URL, accessToken, {
+    tier_id: tier,
+    metadata: IDE_METADATA
+  });
+  if (onboarded.status < 200 || onboarded.status >= 300)
+    return { projectId: "", tier };
+  const operation = recordOf(parsed(onboarded.body));
+  return { projectId: projectFrom(operation?.response), tier };
+}
+async function* readEmail(accessToken) {
+  const res = yield getJsonRequest(USERINFO_URL, antigravityProfile, { accessToken });
+  if (res.status < 200 || res.status >= 300)
+    return null;
+  const record2 = recordOf(parsed(res.body));
+  const email3 = record2?.email;
+  return typeof email3 === "string" && email3.trim().length > 0 ? email3 : null;
+}
+function toResult2(token, fallbackRefresh, accountEmail, providerData, now) {
+  return {
+    secrets: {
+      accessToken: token.accessToken,
+      refreshToken: token.refreshToken ?? fallbackRefresh,
+      apiKey: null,
+      idToken: null
+    },
+    expiresAt: token.expiresIn === null ? null : now() + token.expiresIn * 1000,
+    accountEmail,
+    providerData
+  };
+}
+var GEMINI_GROUP = /\bgemini\b/;
+function windowOf(bucket) {
+  const text = `${String(bucket.bucketId ?? "")} ${String(bucket.displayName ?? "")}`.toLowerCase();
+  if (/\bweekly\b|\bweek\b/.test(text))
+    return "weekly";
+  if (/\b5\s*-?\s*hour|\b5h\b|\bfive\s*hour/.test(text))
+    return "fiveHour";
+  return null;
+}
+function groupsOf(value) {
+  const root = recordOf(value);
+  if (root === null)
+    return [];
+  if (Array.isArray(root.groups))
+    return root.groups;
+  const nested = recordOf(root.quotaSummary)?.groups;
+  return Array.isArray(nested) ? nested : [];
+}
+function parseAntigravityQuota(value, now) {
+  const windows = [];
+  for (const groupValue of groupsOf(value)) {
+    const group = recordOf(groupValue);
+    if (group === null)
+      continue;
+    if (!GEMINI_GROUP.test(String(group.displayName ?? "").toLowerCase()))
+      continue;
+    const buckets = Array.isArray(group.buckets) ? group.buckets : [];
+    for (const bucketValue of buckets) {
+      const bucket = recordOf(bucketValue);
+      if (bucket === null || bucket.disabled === true)
+        continue;
+      const windowType = windowOf(bucket);
+      if (windowType === null)
+        continue;
+      const fraction = numberOf(bucket, ["remainingFraction"]);
+      if (fraction === null)
+        continue;
+      const remaining = Math.max(0, Math.min(1, fraction));
+      windows.push({
+        windowType,
+        used: Math.round((1 - remaining) * 100),
+        limit: 100,
+        resetsAt: resetAtOf(bucket, { absolute: ["resetTime"] }, now),
+        windowMs: null
+      });
+    }
+  }
+  return reportFrom(windows);
+}
+var antigravityOAuthFlow = {
+  kind: "pkce",
+  supportsManualPaste: true,
+  async* start({ redirectUri, randomState }) {
+    const state = randomState();
+    const url2 = new URL(AUTHORIZE_URL2);
+    url2.searchParams.set("client_id", CLIENT_ID2);
+    url2.searchParams.set("response_type", "code");
+    url2.searchParams.set("redirect_uri", redirectUri);
+    url2.searchParams.set("scope", SCOPES2);
+    url2.searchParams.set("state", state);
+    url2.searchParams.set("access_type", "offline");
+    url2.searchParams.set("prompt", "consent");
+    return {
+      authorizeUrl: url2.toString(),
+      pending: { verifier: "", challenge: "", state, redirectUri }
+    };
+  },
+  async* exchange({ code, pending, fail, now }) {
+    const [rawCode, pastedState] = code.split("#");
+    if (pastedState !== undefined && pastedState !== pending.state) {
+      throw fail("AUTH", "authorization state mismatch");
+    }
+    const token = yield* postToken2({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID2,
+      client_secret: CLIENT_SECRET,
+      code: (rawCode ?? "").trim(),
+      redirect_uri: pending.redirectUri
+    }, fail);
+    const email3 = yield* readEmail(token.accessToken);
+    const { projectId, tier } = yield* bootstrapProject(token.accessToken);
+    return toResult2(token, null, email3, { projectId, tier }, now);
+  },
+  async* refresh({ refreshToken, providerData, fail, now }) {
+    const token = yield* postToken2({
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID2,
+      client_secret: CLIENT_SECRET,
+      refresh_token: refreshToken
+    }, fail);
+    return toResult2(token, refreshToken, null, providerData, now);
+  },
+  async* usage({ secrets, providerData, now }) {
+    const project = typeof providerData.projectId === "string" ? providerData.projectId : "";
+    if (project.trim().length === 0)
+      return null;
+    const res = yield {
+      ...postJsonRequest(QUOTA_SUMMARY_URL, antigravityProfile, {
+        contentType: "application/json",
+        body: JSON.stringify({ project }),
+        extraHeaders: [["Authorization", `Bearer ${secrets.accessToken}`]]
+      }),
+      timeoutMs: SHORT_TIMEOUT_MS
+    };
+    if (!usageReadable(res.status, "antigravity"))
+      return null;
+    return parseAntigravityQuota(parsed(res.body), now());
+  }
+};
 // packages/providers/src/grok/device.ts
 import { randomUUID } from "crypto";
 function mintGrokDevice() {
@@ -31487,10 +32527,10 @@ function grokDeviceHeaders(providerData) {
 }
 
 // packages/providers/src/grok/oauth.ts
-var CLIENT_ID2 = "b1a00492-073a-47ea-816f-4c329264a828";
+var CLIENT_ID3 = "b1a00492-073a-47ea-816f-4c329264a828";
 var ISSUER = "https://auth.x.ai";
 var DISCOVERY_URL = `${ISSUER}/.well-known/openid-configuration`;
-var SCOPES2 = [
+var SCOPES3 = [
   "openid",
   "profile",
   "email",
@@ -31536,7 +32576,7 @@ async function* discover(fail) {
     tokenUrl: trustedEndpoint(parsed2.token_endpoint, "token_endpoint", fail)
   };
 }
-function parseTokenResponse(value) {
+function parseTokenResponse2(value) {
   if (!isRecord2(value) || typeof value.access_token !== "string")
     return null;
   return {
@@ -31552,15 +32592,15 @@ function emailFromIdToken(idToken) {
   if (parts.length !== 3 || payload === undefined || payload.length === 0)
     return null;
   try {
-    const json3 = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-    if (!isRecord2(json3))
+    const json4 = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    if (!isRecord2(json4))
       return null;
-    return typeof json3.email === "string" && json3.email.trim().length > 0 ? json3.email : null;
+    return typeof json4.email === "string" && json4.email.trim().length > 0 ? json4.email : null;
   } catch {
     return null;
   }
 }
-async function* postToken2(tokenUrl, body, fail) {
+async function* postToken3(tokenUrl, body, fail) {
   const res = yield postJsonRequest(tokenUrl, grokProfile, {
     contentType: "application/x-www-form-urlencoded",
     body: new URLSearchParams(body).toString()
@@ -31569,7 +32609,7 @@ async function* postToken2(tokenUrl, body, fail) {
   if (res.status < 200 || res.status >= 300) {
     throw fail(tokenErrorCode(res.status), tokenErrorMessage(res.status, parsed2));
   }
-  const token = parseTokenResponse(parsed2);
+  const token = parseTokenResponse2(parsed2);
   if (token === null) {
     throw fail("AUTH", "token endpoint returned no access_token");
   }
@@ -31579,7 +32619,7 @@ function agentIdFrom(providerData) {
   const stored = providerData.agentId;
   return typeof stored === "string" && stored.trim().length > 0 ? stored : mintGrokDevice().agentId;
 }
-function toResult2(token, fallbackRefresh, agentId, now) {
+function toResult3(token, fallbackRefresh, agentId, now) {
   return {
     secrets: {
       accessToken: token.accessToken,
@@ -31601,9 +32641,9 @@ var grokOAuthFlow = {
     const state = randomState();
     const url2 = new URL(authorizeUrl);
     url2.searchParams.set("response_type", "code");
-    url2.searchParams.set("client_id", CLIENT_ID2);
+    url2.searchParams.set("client_id", CLIENT_ID3);
     url2.searchParams.set("redirect_uri", redirectUri);
-    url2.searchParams.set("scope", SCOPES2);
+    url2.searchParams.set("scope", SCOPES3);
     url2.searchParams.set("code_challenge", challenge);
     url2.searchParams.set("code_challenge_method", "S256");
     url2.searchParams.set("state", state);
@@ -31617,19 +32657,19 @@ var grokOAuthFlow = {
       throw fail("AUTH", "authorization state mismatch");
     }
     const { tokenUrl } = yield* discover(fail);
-    const token = yield* postToken2(tokenUrl, {
+    const token = yield* postToken3(tokenUrl, {
       grant_type: "authorization_code",
       code: (rawCode ?? "").trim(),
       redirect_uri: pending.redirectUri,
-      client_id: CLIENT_ID2,
+      client_id: CLIENT_ID3,
       code_verifier: pending.verifier
     }, fail);
-    return toResult2(token, null, mintGrokDevice().agentId, now);
+    return toResult3(token, null, mintGrokDevice().agentId, now);
   },
   async* refresh({ refreshToken, providerData, fail, now }) {
     const { tokenUrl } = yield* discover(fail);
-    const token = yield* postToken2(tokenUrl, { grant_type: "refresh_token", client_id: CLIENT_ID2, refresh_token: refreshToken }, fail);
-    return toResult2(token, refreshToken, agentIdFrom(providerData), now);
+    const token = yield* postToken3(tokenUrl, { grant_type: "refresh_token", client_id: CLIENT_ID3, refresh_token: refreshToken }, fail);
+    return toResult3(token, refreshToken, agentIdFrom(providerData), now);
   }
 };
 
@@ -31789,9 +32829,9 @@ function kimiDeviceHeaders(providerData) {
 }
 
 // packages/providers/src/kimi/oauth.ts
-var CLIENT_ID3 = "17e5f671-d194-4dfb-9706-5516cb48c098";
+var CLIENT_ID4 = "17e5f671-d194-4dfb-9706-5516cb48c098";
 var DEVICE_CODE_URL = "https://auth.kimi.com/api/oauth/device_authorization";
-var TOKEN_URL2 = "https://auth.kimi.com/api/oauth/token";
+var TOKEN_URL3 = "https://auth.kimi.com/api/oauth/token";
 var USAGE_URL2 = "https://api.kimi.com/coding/v1/usages";
 var DEFAULT_INTERVAL_SECONDS = 5;
 var PENDING_ERRORS = new Set(["authorization_pending", "slow_down"]);
@@ -31845,7 +32885,7 @@ function deviceCodeFrom2(value, fail) {
 async function* post(url2, body, device, fail, keepPolling) {
   const res = yield postJsonRequest(url2, kimiProfile, {
     contentType: "application/x-www-form-urlencoded",
-    body: new URLSearchParams({ ...body, client_id: CLIENT_ID3 }).toString(),
+    body: new URLSearchParams({ ...body, client_id: CLIENT_ID4 }).toString(),
     extraHeaders: kimiDeviceHeaders(device)
   });
   const parsed2 = parsed(res.body);
@@ -31876,7 +32916,7 @@ function deviceFrom(source) {
 function deviceForBegin(deviceId) {
   return { ...mintKimiDevice(), deviceId };
 }
-function toResult3(token, device, fallbackRefresh, now) {
+function toResult4(token, device, fallbackRefresh, now) {
   return {
     secrets: {
       accessToken: token.accessToken,
@@ -31931,17 +32971,17 @@ var kimiOAuthFlow = {
       throw fail("INTERNAL", "kimi exchange requires a pending flow produced by begin()");
     }
     const device = deviceFrom(pending.extra);
-    const token = tokenFrom(yield* post(TOKEN_URL2, {
+    const token = tokenFrom(yield* post(TOKEN_URL3, {
       grant_type: "urn:ietf:params:oauth:grant-type:device_code",
       device_code: pending.deviceCode,
       device_id: device.deviceId
     }, device, fail, keepPolling), fail);
-    return toResult3(token, device, null, now);
+    return toResult4(token, device, null, now);
   },
   async* refresh({ refreshToken, providerData, fail, keepPolling, now }) {
     const device = deviceFrom(providerData);
-    const token = tokenFrom(yield* post(TOKEN_URL2, { grant_type: "refresh_token", refresh_token: refreshToken, device_id: device.deviceId }, device, fail, keepPolling), fail);
-    return toResult3(token, device, refreshToken, now);
+    const token = tokenFrom(yield* post(TOKEN_URL3, { grant_type: "refresh_token", refresh_token: refreshToken, device_id: device.deviceId }, device, fail, keepPolling), fail);
+    return toResult4(token, device, refreshToken, now);
   },
   async* usage({ secrets, providerData, now }) {
     if (secrets.accessToken === null)
@@ -31957,13 +32997,225 @@ var kimiOAuthFlow = {
   }
 };
 
+// packages/providers/src/muse/endpoint.ts
+var TRUSTED_HOST2 = "meta.ai";
+var MUSE_DEFAULT_BASE_URL = "https://api.meta.ai/v1";
+function trustedBaseUrl(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return null;
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return null;
+  }
+  if (url2.protocol !== "https:")
+    return null;
+  const host2 = url2.hostname;
+  if (host2 !== TRUSTED_HOST2 && !host2.endsWith(`.${TRUSTED_HOST2}`))
+    return null;
+  return `${url2.origin}${url2.pathname}`.replace(/\/$/, "");
+}
+function museResponsesUrl(providerData) {
+  return `${trustedBaseUrl(providerData.baseUrl) ?? MUSE_DEFAULT_BASE_URL}/responses`;
+}
+
+// packages/providers/src/muse/oauth.ts
+var AUTH_BASE = "https://auth.meta.com";
+var DEVICE_CODE_URL2 = `${AUTH_BASE}/oidc/device/authorization/`;
+var TOKEN_URL4 = `${AUTH_BASE}/oidc/device/token/`;
+var MINT_URL = "https://api.meta.ai/muse-code/key";
+var CLIENT_ID5 = "1031625952748946";
+var DEVICE_CODE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+var FALLBACK_VERIFICATION_URL2 = "https://auth.meta.com/oauth/device/";
+var DEFAULT_INTERVAL_SECONDS2 = 5;
+var PENDING_ERRORS2 = new Set(["authorization_pending", "slow_down"]);
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+function recordFrom3(value) {
+  return isRecord5(value) ? value : null;
+}
+function stringFrom3(value, field) {
+  const candidate = value[field];
+  return typeof candidate === "string" && candidate.trim().length > 0 ? candidate : null;
+}
+function positiveNumberFrom3(value, field) {
+  const candidate = value[field];
+  return typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0 ? candidate : null;
+}
+function tokenFrom2(value, fail) {
+  const record2 = recordFrom3(value);
+  const accessToken = record2 === null ? null : stringFrom3(record2, "access_token");
+  if (record2 === null || accessToken === null) {
+    throw fail("AUTH", "token endpoint returned no access_token");
+  }
+  return {
+    accessToken,
+    refreshToken: stringFrom3(record2, "refresh_token"),
+    expiresIn: positiveNumberFrom3(record2, "expires_in")
+  };
+}
+function deviceCodeFrom3(value, fail) {
+  const record2 = recordFrom3(value);
+  const deviceCode = record2 === null ? null : stringFrom3(record2, "device_code");
+  const userCode = record2 === null ? null : stringFrom3(record2, "user_code");
+  if (record2 === null || deviceCode === null || userCode === null) {
+    throw fail("AUTH", "device authorization response missing user_code or verification_uri");
+  }
+  return {
+    deviceCode,
+    userCode,
+    verificationUri: stringFrom3(record2, "verification_uri_complete") ?? stringFrom3(record2, "verification_uri") ?? FALLBACK_VERIFICATION_URL2,
+    interval: positiveNumberFrom3(record2, "interval") ?? DEFAULT_INTERVAL_SECONDS2
+  };
+}
+async function* postForm(url2, body, fail, keepPolling) {
+  const res = yield postJsonRequest(url2, museProfile, {
+    contentType: "application/x-www-form-urlencoded",
+    body: new URLSearchParams({ ...body, client_id: CLIENT_ID5 }).toString(),
+    extraHeaders: [["Accept", "application/json"]]
+  });
+  const parsed2 = parsed(res.body);
+  if (res.status >= 200 && res.status < 300)
+    return parsed2;
+  const record2 = recordFrom3(parsed2);
+  const code = record2 === null ? `http_${res.status}` : stringFrom3(record2, "error") ?? `http_${res.status}`;
+  if (PENDING_ERRORS2.has(code))
+    throw keepPolling(code);
+  if (code === "expired_token") {
+    throw fail("AUTH", "muse device code expired; start the authorization again");
+  }
+  throw fail(tokenErrorCode(res.status), tokenErrorMessage(res.status, parsed2));
+}
+async function* mint(accessToken, fail) {
+  const res = yield postJsonRequest(MINT_URL, museProfile, {
+    contentType: "application/json",
+    body: "{}",
+    extraHeaders: [
+      ["Authorization", `Bearer ${accessToken}`],
+      ["Accept", "application/json"]
+    ]
+  });
+  const parsed2 = parsed(res.body);
+  if (res.status < 200 || res.status >= 300) {
+    if (res.status === 401 || res.status === 403) {
+      throw fail("AUTH", "muse rejected the saved login; reconnect the account or use a different one");
+    }
+    if (res.status === 429) {
+      throw fail("RATE_LIMIT", `muse rate limited the key mint: http_${res.status}`);
+    }
+    throw fail("UPSTREAM", `muse key mint failed: http_${res.status}`);
+  }
+  const record2 = recordFrom3(parsed2);
+  if (record2 === null) {
+    throw fail("UPSTREAM", "muse key mint returned an unusable response");
+  }
+  if (record2.require_payment === true) {
+    throw fail("AUTH", "muse requires a payment method on the Meta account; add one at https://dev.meta.ai and reconnect");
+  }
+  const apiKey = stringFrom3(record2, "api_key");
+  if (apiKey === null) {
+    throw fail("AUTH", "muse key mint returned an empty api key; finish onboarding at https://dev.meta.ai and reconnect");
+  }
+  return {
+    apiKey,
+    email: stringFrom3(record2, "user_email"),
+    tierName: stringFrom3(record2, "subs_tier_name"),
+    subscriptionActive: record2.is_subs_active === true,
+    baseUrl: trustedBaseUrl(record2.base_url),
+    usage: record2.subs_usage
+  };
+}
+function toResult5(token, key, fallbackRefresh, now) {
+  return {
+    secrets: {
+      accessToken: token.accessToken,
+      refreshToken: token.refreshToken ?? fallbackRefresh,
+      apiKey: key.apiKey,
+      idToken: null
+    },
+    expiresAt: token.expiresIn === null ? null : now() + token.expiresIn * 1000,
+    accountEmail: key.email,
+    providerData: {
+      ...key.tierName === null ? {} : { subscriptionTier: key.tierName },
+      subscriptionActive: key.subscriptionActive,
+      ...key.baseUrl === null ? {} : { baseUrl: key.baseUrl }
+    }
+  };
+}
+var museOAuthFlow = {
+  kind: "device",
+  supportsManualPaste: false,
+  needsDeviceId: false,
+  async* start() {
+    return {
+      authorizeUrl: FALLBACK_VERIFICATION_URL2,
+      pending: { verifier: "", challenge: "", state: "", redirectUri: "" }
+    };
+  },
+  async* begin({ fail, keepPolling }) {
+    const response = deviceCodeFrom3(yield* postForm(DEVICE_CODE_URL2, {}, fail, keepPolling), fail);
+    return {
+      authorizeUrl: response.verificationUri,
+      userCode: response.userCode,
+      pending: {
+        verifier: "",
+        challenge: "",
+        state: "",
+        redirectUri: "",
+        deviceCode: response.deviceCode,
+        interval: response.interval
+      }
+    };
+  },
+  async* exchange({ pending, fail, keepPolling, now }) {
+    if (pending.deviceCode === undefined) {
+      throw fail("INTERNAL", "muse exchange requires a pending flow produced by begin()");
+    }
+    const token = tokenFrom2(yield* postForm(TOKEN_URL4, { grant_type: DEVICE_CODE_GRANT, device_code: pending.deviceCode }, fail, keepPolling), fail);
+    return toResult5(token, yield* mint(token.accessToken, fail), null, now);
+  },
+  async* refresh({ refreshToken, fail, keepPolling, now }) {
+    const token = tokenFrom2(yield* postForm(TOKEN_URL4, { grant_type: "refresh_token", refresh_token: refreshToken }, fail, keepPolling), fail);
+    return toResult5(token, yield* mint(token.accessToken, fail), refreshToken, now);
+  },
+  async* usage({ secrets, now }) {
+    if (secrets.accessToken === null)
+      return null;
+    const res = yield postJsonRequest(MINT_URL, museProfile, {
+      contentType: "application/json",
+      body: "{}",
+      extraHeaders: [
+        ["Authorization", `Bearer ${secrets.accessToken}`],
+        ["Accept", "application/json"]
+      ]
+    });
+    if (!usageReadable(res.status, "muse"))
+      return null;
+    const record2 = recordOf(parsed(res.body));
+    return record2 === null ? null : parseMuseUsage(record2.subs_usage, now());
+  }
+};
+function parseMuseUsage(value, now) {
+  const root = recordOf(value);
+  if (root === null)
+    return null;
+  const window2 = recordOf(root.window);
+  const mins = window2 === null ? null : numberOf(window2, ["window_duration_mins"]);
+  return reportFrom([
+    windowFrom(root.window, "fiveHour", now, mins === null ? null : mins * 60000),
+    windowFrom(root.weekly, "weekly", now)
+  ]);
+}
+
 // packages/providers/src/openai/oauth.ts
-var CLIENT_ID4 = "app_EMoamEEZ73f0CkXaXp7hrann";
-var AUTHORIZE_URL2 = "https://auth.openai.com/oauth/authorize";
-var TOKEN_URL3 = "https://auth.openai.com/oauth/token";
-var SCOPES3 = "openid profile email offline_access";
+var CLIENT_ID6 = "app_EMoamEEZ73f0CkXaXp7hrann";
+var AUTHORIZE_URL3 = "https://auth.openai.com/oauth/authorize";
+var TOKEN_URL5 = "https://auth.openai.com/oauth/token";
+var SCOPES4 = "openid profile email offline_access";
 var USAGE_URL3 = "https://chatgpt.com/backend-api/wham/usage";
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 function nonBlankStringOrNull(value) {
@@ -31979,20 +33231,20 @@ function decodeClaims(idToken) {
     return { email: null, accountId: null };
   }
   try {
-    const json3 = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-    if (!isRecord5(json3))
+    const json4 = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    if (!isRecord6(json4))
       return { email: null, accountId: null };
-    const auth = json3["https://api.openai.com/auth"];
+    const auth = json4["https://api.openai.com/auth"];
     return {
-      email: typeof json3.email === "string" ? json3.email : null,
-      accountId: isRecord5(auth) ? nonBlankStringOrNull(auth.chatgpt_account_id) : null
+      email: typeof json4.email === "string" ? json4.email : null,
+      accountId: isRecord6(auth) ? nonBlankStringOrNull(auth.chatgpt_account_id) : null
     };
   } catch {
     return { email: null, accountId: null };
   }
 }
-function parseTokenResponse2(value) {
-  if (!isRecord5(value) || typeof value.access_token !== "string")
+function parseTokenResponse3(value) {
+  if (!isRecord6(value) || typeof value.access_token !== "string")
     return null;
   return {
     accessToken: value.access_token,
@@ -32001,22 +33253,22 @@ function parseTokenResponse2(value) {
     idToken: typeof value.id_token === "string" ? value.id_token : null
   };
 }
-async function* postToken3(body, fail) {
-  const res = yield postJsonRequest(TOKEN_URL3, openaiProfile, {
+async function* postToken4(body, fail) {
+  const res = yield postJsonRequest(TOKEN_URL5, openaiProfile, {
     contentType: "application/x-www-form-urlencoded",
-    body: new URLSearchParams({ ...body, client_id: CLIENT_ID4 }).toString()
+    body: new URLSearchParams({ ...body, client_id: CLIENT_ID6 }).toString()
   });
   const parsed2 = parsed(res.body);
   if (res.status < 200 || res.status >= 300) {
     throw fail(tokenErrorCode(res.status), tokenErrorMessage(res.status, parsed2));
   }
-  const token = parseTokenResponse2(parsed2);
+  const token = parseTokenResponse3(parsed2);
   if (token === null) {
     throw fail("AUTH", "token endpoint returned no access_token");
   }
   return token;
 }
-function toResult4(token, fallbackRefresh, now, fallbackAccountId = null) {
+function toResult6(token, fallbackRefresh, now, fallbackAccountId = null) {
   const claims = decodeClaims(token.idToken);
   return {
     secrets: {
@@ -32074,11 +33326,11 @@ var openaiOAuthFlow = {
   async* start({ redirectUri, pkce, randomState }) {
     const { verifier, challenge } = pkce();
     const state = randomState();
-    const url2 = new URL(AUTHORIZE_URL2);
-    url2.searchParams.set("client_id", CLIENT_ID4);
+    const url2 = new URL(AUTHORIZE_URL3);
+    url2.searchParams.set("client_id", CLIENT_ID6);
     url2.searchParams.set("response_type", "code");
     url2.searchParams.set("redirect_uri", redirectUri);
-    url2.searchParams.set("scope", SCOPES3);
+    url2.searchParams.set("scope", SCOPES4);
     url2.searchParams.set("code_challenge", challenge);
     url2.searchParams.set("code_challenge_method", "S256");
     url2.searchParams.set("id_token_add_organizations", "true");
@@ -32093,17 +33345,17 @@ var openaiOAuthFlow = {
     if (pastedState !== undefined && pastedState !== pending.state) {
       throw fail("AUTH", "authorization state mismatch");
     }
-    const token = yield* postToken3({
+    const token = yield* postToken4({
       grant_type: "authorization_code",
       code: (rawCode ?? "").trim(),
       redirect_uri: pending.redirectUri,
       code_verifier: pending.verifier
     }, fail);
-    return toResult4(token, null, now);
+    return toResult6(token, null, now);
   },
   async* refresh({ refreshToken, providerData, fail, now }) {
-    const token = yield* postToken3({ grant_type: "refresh_token", refresh_token: refreshToken, scope: SCOPES3 }, fail);
-    return toResult4(token, refreshToken, now, accountIdFromProviderData(providerData));
+    const token = yield* postToken4({ grant_type: "refresh_token", refresh_token: refreshToken, scope: SCOPES4 }, fail);
+    return toResult6(token, refreshToken, now, accountIdFromProviderData(providerData));
   },
   async* usage({ secrets, providerData, now }) {
     if (secrets.accessToken === null)
@@ -32126,7 +33378,9 @@ function builtinOAuthFlows() {
     ["openai", openaiOAuthFlow],
     ["kimi", kimiOAuthFlow],
     ["kilo", kiloOAuthFlow],
-    ["grok", grokOAuthFlow]
+    ["grok", grokOAuthFlow],
+    ["antigravity", antigravityOAuthFlow],
+    ["muse", museOAuthFlow]
   ];
 }
 // packages/providers/src/custom/decode.ts
@@ -32154,7 +33408,7 @@ function reasoningText(delta) {
     return [];
   }).join("");
 }
-function json3(data) {
+function json4(data) {
   try {
     const v = JSON.parse(data);
     return typeof v === "object" && v !== null ? v : null;
@@ -32176,7 +33430,7 @@ async function* decodeCustomChat(messages) {
       done = true;
       break;
     }
-    const d = json3(msg.data);
+    const d = json4(msg.data);
     if (d === null)
       continue;
     if (!started && (d.id !== undefined || d.model !== undefined)) {
@@ -32334,7 +33588,7 @@ async function* decodeCustomResponses(messages) {
       };
       return;
     }
-    const d = json3(msg.data);
+    const d = json4(msg.data);
     if (d === null)
       continue;
     switch (msg.event) {
@@ -32722,10 +33976,10 @@ var customCodec = {
 // packages/providers/src/custom/index.ts
 var customAdapter = codecAdapter("custom", customDescriptor.capabilities, customCodec);
 // packages/providers/src/grok/codec.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 
 // packages/providers/src/grok/decode.ts
-var ERROR_CODE = {
+var ERROR_CODE2 = {
   rate_limit_exceeded: "RATE_LIMIT",
   insufficient_quota: "QUOTA_EXHAUSTED",
   invalid_api_key: "AUTH",
@@ -32759,7 +34013,7 @@ var KNOWN_EVENTS2 = new Set([
   "response.failed",
   "error"
 ]);
-function json4(data) {
+function json5(data) {
   try {
     const v = JSON.parse(data);
     return typeof v === "object" && v !== null ? v : null;
@@ -32794,7 +34048,7 @@ async function* decodeGrokResponses(messages) {
       };
       return;
     }
-    const d = json4(msg.data);
+    const d = json5(msg.data);
     if (d === null)
       continue;
     switch (msg.event) {
@@ -32897,7 +34151,7 @@ async function* decodeGrokResponses(messages) {
         terminal = true;
         const err = d.response?.error ?? d.error ?? {};
         const raw = String(err.code ?? err.type);
-        const code = (Object.hasOwn(ERROR_CODE, raw) ? ERROR_CODE[raw] : undefined) ?? "UPSTREAM";
+        const code = (Object.hasOwn(ERROR_CODE2, raw) ? ERROR_CODE2[raw] : undefined) ?? "UPSTREAM";
         yield {
           type: "error",
           code,
@@ -32921,9 +34175,9 @@ async function* decodeGrokResponses(messages) {
 }
 
 // packages/providers/src/grok/wire.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var MAX_TOOLS = 200;
-function encodeToolChoice2(c) {
+function encodeToolChoice3(c) {
   switch (c.type) {
     case "auto":
       return "auto";
@@ -32937,7 +34191,7 @@ function encodeToolChoice2(c) {
 }
 function promptCacheKey(instructions, firstInput) {
   const stable = JSON.stringify({ instructions, firstInput });
-  return createHash2("sha256").update(stable).digest("hex").slice(0, 32);
+  return createHash3("sha256").update(stable).digest("hex").slice(0, 32);
 }
 function toGrokWire(req, model) {
   const degradations = [];
@@ -33030,7 +34284,7 @@ function toGrokWire(req, model) {
     }));
   }
   if (req.toolChoice !== undefined)
-    body.tool_choice = encodeToolChoice2(req.toolChoice);
+    body.tool_choice = encodeToolChoice3(req.toolChoice);
   if (req.reasoning !== undefined && req.reasoning.mode !== "off") {
     if (req.reasoning.mode === "budget") {
       note("grok:reasoning-budget-dropped");
@@ -33048,7 +34302,7 @@ var PROXY_URL = "https://cli-chat-proxy.grok.com/v1/responses";
 var API_URL = "https://api.x.ai/v1/responses";
 var CONV_NAMESPACE = "omni-grok-conv";
 function derivedUuid(value) {
-  const h = createHash3("sha256").update(`${CONV_NAMESPACE}:${value}`).digest("hex");
+  const h = createHash4("sha256").update(`${CONV_NAMESPACE}:${value}`).digest("hex");
   const variant = (Number.parseInt(h[16], 16) & 3 | 8).toString(16);
   return [
     h.slice(0, 8),
@@ -33117,15 +34371,28 @@ function nodeHttpClient(options = {}) {
     const startedAt = now();
     let traced = false;
     const trace = (status, failed = false) => {
-      if (traced || !logger2.enabled("debug"))
+      if (traced)
         return;
       traced = true;
+      const durationMs = now() - startedAt;
+      try {
+        options.onResponseHead?.({
+          provider: req.provider,
+          host: url2.host,
+          path: url2.pathname,
+          ...status === undefined ? {} : { status },
+          durationMs,
+          ...req.requestId === undefined ? {} : { requestId: req.requestId }
+        });
+      } catch {}
+      if (!logger2.enabled("debug"))
+        return;
       logger2.debug("upstream http", {
         provider: req.provider,
         status,
         host: url2.host,
         path: url2.pathname,
-        durationMs: now() - startedAt,
+        durationMs,
         reason: failed ? "transport error" : undefined
       });
     };
@@ -33218,7 +34485,7 @@ function reasoningText2(delta) {
     return [];
   }).join("");
 }
-function json5(data) {
+function json6(data) {
   try {
     const v = JSON.parse(data);
     return typeof v === "object" && v !== null ? v : null;
@@ -33240,7 +34507,7 @@ async function* decodeKiloChat(messages) {
       done = true;
       break;
     }
-    const d = json5(msg.data);
+    const d = json6(msg.data);
     if (d === null)
       continue;
     if (!started && (d.id !== undefined || d.model !== undefined)) {
@@ -33340,7 +34607,7 @@ async function* decodeKiloChat(messages) {
 }
 
 // packages/providers/src/kilo/wire.ts
-function encodeToolChoice3(c) {
+function encodeToolChoice4(c) {
   switch (c.type) {
     case "auto":
       return "auto";
@@ -33451,7 +34718,7 @@ function toKiloWire(req, model) {
     }));
   }
   if (req.toolChoice !== undefined)
-    body.tool_choice = encodeToolChoice3(req.toolChoice);
+    body.tool_choice = encodeToolChoice4(req.toolChoice);
   if (req.reasoning !== undefined && req.reasoning.mode !== "off") {
     if (req.reasoning.mode === "budget") {
       body.reasoning = { max_tokens: req.reasoning.budgetTokens };
@@ -33510,7 +34777,7 @@ var FINISH2 = {
   tool_calls: "toolUse",
   content_filter: "contentFilter"
 };
-function json6(data) {
+function json7(data) {
   try {
     const v = JSON.parse(data);
     return typeof v === "object" && v !== null ? v : null;
@@ -33532,7 +34799,7 @@ async function* decodeChat(messages) {
       done = true;
       break;
     }
-    const d = json6(msg.data);
+    const d = json7(msg.data);
     if (d === null)
       continue;
     if (!started && (d.id !== undefined || d.model !== undefined)) {
@@ -33616,7 +34883,7 @@ async function* decodeChat(messages) {
 }
 
 // packages/providers/src/kimi/wire.ts
-function encodeToolChoice4(c) {
+function encodeToolChoice5(c) {
   switch (c.type) {
     case "auto":
       return "auto";
@@ -33707,7 +34974,7 @@ function toChatWire(req, model, vendor = "kimi") {
     }));
   }
   if (req.toolChoice !== undefined)
-    body.tool_choice = encodeToolChoice4(req.toolChoice);
+    body.tool_choice = encodeToolChoice5(req.toolChoice);
   if (req.reasoning !== undefined)
     note("kimi:reasoning-dropped");
   Object.assign(body, req.vendor?.[vendor] ?? {});
@@ -33747,8 +35014,8 @@ var kimiCodec = {
 
 // packages/providers/src/kimi/index.ts
 var kimiAdapter = codecAdapter("kimi", kimiDescriptor.capabilities, kimiCodec);
-// packages/providers/src/openai/decode.ts
-var ERROR_CODE2 = {
+// packages/providers/src/muse/decode.ts
+var ERROR_CODE3 = {
   rate_limit_exceeded: "RATE_LIMIT",
   insufficient_quota: "QUOTA_EXHAUSTED",
   invalid_api_key: "AUTH",
@@ -33783,7 +35050,7 @@ var KNOWN_EVENTS3 = new Set([
   "response.failed",
   "error"
 ]);
-function json7(data) {
+function json8(data) {
   try {
     const v = JSON.parse(data);
     return typeof v === "object" && v !== null ? v : null;
@@ -33791,7 +35058,7 @@ function json7(data) {
     return null;
   }
 }
-async function* decodeResponses(messages, options = {}) {
+async function* decodeMuseResponses(messages, options = {}) {
   const nativeReasoning = options.nativeReasoning === true;
   const indices = new Map;
   let next = 0;
@@ -33811,6 +35078,406 @@ async function* decodeResponses(messages, options = {}) {
     if (msg.data === "[DONE]")
       continue;
     if (!KNOWN_EVENTS3.has(msg.event)) {
+      yield {
+        type: "error",
+        code: "UPSTREAM",
+        message: `unrecognized muse stream event "${msg.event}"`,
+        retryable: false
+      };
+      return;
+    }
+    const d = json8(msg.data);
+    if (d === null)
+      continue;
+    switch (msg.event) {
+      case "response.created":
+        yield {
+          type: "start",
+          id: String(d.response?.id ?? ""),
+          model: String(d.response?.model ?? "")
+        };
+        break;
+      case "response.output_item.added": {
+        const item = d.item ?? {};
+        if (item.type === "reasoning") {
+          ownsBlock.add(d.output_index ?? 0);
+          yield {
+            type: "blockStart",
+            index: irIndex(d.output_index ?? 0),
+            block: nativeReasoning ? { type: "providerNative", provider: "muse", blockType: "reasoning", data: {} } : { type: "thinking" }
+          };
+        } else if (item.type === "function_call") {
+          sawToolCall = true;
+          ownsBlock.add(d.output_index ?? 0);
+          yield {
+            type: "blockStart",
+            index: irIndex(d.output_index ?? 0),
+            block: { type: "toolUse", id: String(item.call_id), name: String(item.name) }
+          };
+        }
+        break;
+      }
+      case "response.content_part.added":
+        if (d.part?.type === "output_text") {
+          yield {
+            type: "blockStart",
+            index: irIndex(d.output_index ?? 0, d.content_index ?? 0),
+            block: { type: "text" }
+          };
+        }
+        break;
+      case "response.output_text.delta":
+        yield {
+          type: "blockDelta",
+          index: irIndex(d.output_index ?? 0, d.content_index ?? 0),
+          delta: { type: "text", text: String(d.delta ?? "") }
+        };
+        break;
+      case "response.reasoning_summary_text.delta":
+        yield {
+          type: "blockDelta",
+          index: irIndex(d.output_index ?? 0),
+          delta: nativeReasoning ? {
+            type: "providerNative",
+            provider: "muse",
+            deltaType: "reasoning_summary_text.delta",
+            data: { text: String(d.delta ?? "") }
+          } : { type: "thinking", text: String(d.delta ?? "") }
+        };
+        break;
+      case "response.function_call_arguments.delta":
+        yield {
+          type: "blockDelta",
+          index: irIndex(d.output_index ?? 0),
+          delta: { type: "toolJson", partial: String(d.delta ?? "") }
+        };
+        break;
+      case "response.content_part.done":
+        yield { type: "blockEnd", index: irIndex(d.output_index ?? 0, d.content_index ?? 0) };
+        break;
+      case "response.output_item.done": {
+        const outputIndex = d.output_index ?? 0;
+        if (ownsBlock.delete(outputIndex)) {
+          const item = d.item ?? {};
+          if (nativeReasoning && item.type === "reasoning") {
+            yield {
+              type: "blockDelta",
+              index: irIndex(outputIndex),
+              delta: {
+                type: "providerNative",
+                provider: "muse",
+                deltaType: "response.output_item.done",
+                fold: "merge",
+                data: item
+              }
+            };
+          }
+          yield { type: "blockEnd", index: irIndex(outputIndex) };
+        }
+        break;
+      }
+      case "response.completed":
+      case "response.incomplete": {
+        terminal = true;
+        const r = d.response ?? {};
+        const reason = r.incomplete_details?.reason;
+        let stopReason = sawToolCall ? "toolUse" : "endTurn";
+        if (reason === "max_output_tokens")
+          stopReason = "maxTokens";
+        else if (reason === "content_filter")
+          stopReason = "contentFilter";
+        else if (reason !== undefined || msg.event === "response.incomplete" || r.status !== undefined && r.status !== "completed") {
+          yield {
+            type: "error",
+            code: "UPSTREAM",
+            message: reason !== undefined ? `unrecognized muse incomplete reason "${String(reason)}"` : r.status !== undefined && r.status !== "incomplete" ? `muse reported terminal response status "${String(r.status)}"` : "muse reported the response incomplete without a reason",
+            retryable: false
+          };
+          break;
+        }
+        yield {
+          type: "end",
+          stopReason,
+          usage: usageFromPromptTotal(r.usage?.input_tokens ?? 0, r.usage?.output_tokens ?? 0, r.usage?.input_tokens_details?.cached_tokens ?? r.usage?.prompt_tokens_details?.cached_tokens ?? 0)
+        };
+        break;
+      }
+      case "response.failed":
+      case "error": {
+        terminal = true;
+        const err = d.response?.error ?? d.error ?? {};
+        const raw = String(err.code ?? err.type);
+        const code = (Object.hasOwn(ERROR_CODE3, raw) ? ERROR_CODE3[raw] : undefined) ?? "UPSTREAM";
+        yield {
+          type: "error",
+          code,
+          message: String(err.message ?? "upstream error"),
+          retryable: RETRYABLE[code]
+        };
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!terminal) {
+    yield {
+      type: "error",
+      code: "UPSTREAM",
+      message: "upstream stream ended before response completion",
+      retryable: RETRYABLE.UPSTREAM
+    };
+  }
+}
+
+// packages/providers/src/muse/wire.ts
+import { createHash as createHash5 } from "crypto";
+function suppliedKey(req) {
+  const vendor = req.vendor?.openai;
+  for (const name of ["prompt_cache_key", "session_id"]) {
+    const value = vendor?.[name];
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  return;
+}
+function cacheKey(req, instructions, firstInput) {
+  const stable = req.conversationId !== undefined && req.conversationId.length > 0 ? JSON.stringify({ conversation: req.conversationId }) : JSON.stringify({ instructions, firstInput: firstInput ?? null });
+  return createHash5("sha256").update(stable).digest("hex").slice(0, 32);
+}
+function repairOrphanedCalls(input2) {
+  const answered = new Set;
+  for (const item of input2) {
+    const record2 = item;
+    if (record2.type === "function_call_output" && typeof record2.call_id === "string") {
+      answered.add(record2.call_id);
+    }
+  }
+  for (let i = input2.length - 1;i >= 0; i--) {
+    const record2 = input2[i];
+    if (record2.type !== "function_call" || typeof record2.call_id !== "string")
+      continue;
+    if (answered.has(record2.call_id))
+      continue;
+    input2.splice(i + 1, 0, { type: "function_call_output", call_id: record2.call_id, output: "" });
+  }
+}
+function encodeToolChoice6(c) {
+  switch (c.type) {
+    case "auto":
+      return "auto";
+    case "any":
+      return "required";
+    case "none":
+      return "none";
+    case "tool":
+      return { type: "function", name: c.name };
+  }
+}
+function toMuseWire(req, model) {
+  const degradations = [];
+  const input2 = [];
+  const note = (d) => {
+    if (!degradations.includes(d))
+      degradations.push(d);
+  };
+  if (req.betas?.includes(CONTEXT_1M_BETA))
+    note("muse:context-1m-dropped");
+  for (const message of req.messages) {
+    const parts = [];
+    const asDeveloper = message.role === "system";
+    if (asDeveloper)
+      note("muse:system-turn-as-developer");
+    const role = asDeveloper ? "developer" : message.role;
+    const flush = () => {
+      if (parts.length === 0)
+        return;
+      input2.push({ type: "message", role, content: [...parts] });
+      parts.length = 0;
+    };
+    for (const block of message.content) {
+      switch (block.type) {
+        case "text":
+          parts.push({
+            type: role === "assistant" ? "output_text" : "input_text",
+            text: block.text
+          });
+          break;
+        case "image":
+          parts.push({
+            type: "input_image",
+            image_url: `data:${block.mediaType};base64,${block.data}`
+          });
+          break;
+        case "thinking":
+          note("muse:thinking-dropped");
+          break;
+        case "toolUse":
+          flush();
+          input2.push({
+            type: "function_call",
+            call_id: block.id,
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          });
+          break;
+        case "toolResult":
+          flush();
+          input2.push({
+            type: "function_call_output",
+            call_id: block.toolUseId,
+            output: block.content
+          });
+          break;
+        case "providerNative":
+          if (block.provider === "muse") {
+            flush();
+            const { id: _id, ...rest } = block.data;
+            input2.push({ type: block.blockType, ...rest });
+            break;
+          }
+          note("muse:foreign-native-block-dropped");
+          break;
+      }
+    }
+    flush();
+  }
+  repairOrphanedCalls(input2);
+  const body = { model, input: input2, stream: req.stream, store: false };
+  const instructions = systemText(req.system, "muse", note);
+  if (instructions !== undefined && instructions.length > 0)
+    body.instructions = instructions;
+  if (req.maxTokens !== undefined)
+    body.max_output_tokens = req.maxTokens;
+  if (req.temperature !== undefined)
+    body.temperature = req.temperature;
+  if (req.tools !== undefined) {
+    const portable = req.tools.filter((t) => t.kind === "portable");
+    if (portable.length !== req.tools.length)
+      note("muse:provider-tool-dropped");
+    body.tools = portable.map((t) => ({
+      type: "function",
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }));
+  }
+  if (req.toolChoice !== undefined)
+    body.tool_choice = encodeToolChoice6(req.toolChoice);
+  if (req.reasoning !== undefined && req.reasoning.mode !== "off") {
+    if (req.reasoning.mode === "budget") {
+      note("muse:reasoning-budget-dropped");
+    } else {
+      const effort = req.reasoning.effort ?? "medium";
+      body.reasoning = { effort, summary: "auto" };
+    }
+  }
+  const key = suppliedKey(req) ?? cacheKey(req, instructions ?? "", input2[0]);
+  Object.assign(body, req.vendor?.openai ?? {});
+  body.prompt_cache_key = key;
+  return { body, degradations, cacheKey: key };
+}
+
+// packages/providers/src/muse/codec.ts
+var museCodec = {
+  buildRequest(input2) {
+    const { body, degradations, cacheKey: cacheKey2 } = toMuseWire(input2.request, input2.model);
+    if (input2.credentials.apiKey === null) {
+      throw input2.fail("AUTH", "muse credential has no model api key");
+    }
+    const protocol = [
+      ["Content-Type", "application/json"],
+      ["Authorization", `Bearer ${input2.credentials.apiKey}`],
+      ["x-meta-ai-gateway-session-id", cacheKey2]
+    ];
+    const headers = orderHeaders(mergeHeaders(museProfile.headers, protocol), museProfile.order);
+    const include = body.include;
+    const nativeReasoning = Array.isArray(include) && include.includes("reasoning.encrypted_content");
+    return {
+      decodeState: { nativeReasoning },
+      request: {
+        url: museResponsesUrl(input2.credentials.providerData),
+        method: "POST",
+        headers,
+        body: JSON.stringify(orderFields({ ...body, stream: true }, museBodyOrder))
+      },
+      degradations
+    };
+  },
+  decode({ body, decodeState }) {
+    const state = decodeState;
+    return decodeMuseResponses(parseSse(body), {
+      nativeReasoning: state?.nativeReasoning === true
+    });
+  }
+};
+
+// packages/providers/src/muse/index.ts
+var museAdapter = codecAdapter("muse", museDescriptor.capabilities, museCodec);
+// packages/providers/src/openai/decode.ts
+var ERROR_CODE4 = {
+  rate_limit_exceeded: "RATE_LIMIT",
+  insufficient_quota: "QUOTA_EXHAUSTED",
+  invalid_api_key: "AUTH",
+  server_error: "UPSTREAM",
+  context_length_exceeded: "BAD_REQUEST",
+  content_policy_violation: "CONTENT_FILTER"
+};
+var KNOWN_EVENTS4 = new Set([
+  "keepalive",
+  "response.created",
+  "response.queued",
+  "response.in_progress",
+  "response.output_item.added",
+  "response.output_item.done",
+  "response.content_part.added",
+  "response.content_part.done",
+  "response.output_text.delta",
+  "response.output_text.done",
+  "response.output_text.annotation.added",
+  "response.refusal.delta",
+  "response.refusal.done",
+  "response.reasoning_summary_part.added",
+  "response.reasoning_summary_part.done",
+  "response.reasoning_summary_text.delta",
+  "response.reasoning_summary_text.done",
+  "response.reasoning_text.delta",
+  "response.reasoning_text.done",
+  "response.function_call_arguments.delta",
+  "response.function_call_arguments.done",
+  "response.completed",
+  "response.incomplete",
+  "response.failed",
+  "error"
+]);
+function json9(data) {
+  try {
+    const v = JSON.parse(data);
+    return typeof v === "object" && v !== null ? v : null;
+  } catch {
+    return null;
+  }
+}
+async function* decodeResponses(messages, options = {}) {
+  const nativeReasoning = options.nativeReasoning === true;
+  const indices = new Map;
+  let next = 0;
+  const irIndex = (outputIndex, contentIndex = 0) => {
+    const key = `${outputIndex}:${contentIndex}`;
+    const existing = indices.get(key);
+    if (existing !== undefined)
+      return existing;
+    const assigned = next++;
+    indices.set(key, assigned);
+    return assigned;
+  };
+  let sawToolCall = false;
+  let terminal = false;
+  const ownsBlock = new Set;
+  for await (const msg of messages) {
+    if (msg.data === "[DONE]")
+      continue;
+    if (!KNOWN_EVENTS4.has(msg.event)) {
       yield {
         type: "error",
         code: "UPSTREAM",
@@ -33819,7 +35486,7 @@ async function* decodeResponses(messages, options = {}) {
       };
       return;
     }
-    const d = json7(msg.data);
+    const d = json9(msg.data);
     if (d === null)
       continue;
     switch (msg.event) {
@@ -33940,7 +35607,7 @@ async function* decodeResponses(messages, options = {}) {
         terminal = true;
         const err = d.response?.error ?? d.error ?? {};
         const raw = String(err.code ?? err.type);
-        const code = (Object.hasOwn(ERROR_CODE2, raw) ? ERROR_CODE2[raw] : undefined) ?? "UPSTREAM";
+        const code = (Object.hasOwn(ERROR_CODE4, raw) ? ERROR_CODE4[raw] : undefined) ?? "UPSTREAM";
         yield {
           type: "error",
           code,
@@ -33964,8 +35631,8 @@ async function* decodeResponses(messages, options = {}) {
 }
 
 // packages/providers/src/openai/wire.ts
-import { createHash as createHash4 } from "crypto";
-function suppliedKey(req) {
+import { createHash as createHash6 } from "crypto";
+function suppliedKey2(req) {
   const vendor = req.vendor?.openai;
   for (const name of ["prompt_cache_key", "session_id"]) {
     const value = vendor?.[name];
@@ -33974,11 +35641,11 @@ function suppliedKey(req) {
   }
   return;
 }
-function cacheKey(req, instructions, firstInput) {
+function cacheKey2(req, instructions, firstInput) {
   const stable = req.conversationId !== undefined && req.conversationId.length > 0 ? JSON.stringify({ conversation: req.conversationId }) : JSON.stringify({ instructions, firstInput: firstInput ?? null });
-  return createHash4("sha256").update(stable).digest("hex").slice(0, 32);
+  return createHash6("sha256").update(stable).digest("hex").slice(0, 32);
 }
-function repairOrphanedCalls(input2) {
+function repairOrphanedCalls2(input2) {
   const answered = new Set;
   for (const item of input2) {
     const record2 = item;
@@ -33995,7 +35662,7 @@ function repairOrphanedCalls(input2) {
     input2.splice(i + 1, 0, { type: "function_call_output", call_id: record2.call_id, output: "" });
   }
 }
-function encodeToolChoice5(c) {
+function encodeToolChoice7(c) {
   switch (c.type) {
     case "auto":
       return "auto";
@@ -34077,7 +35744,7 @@ function toResponsesWire(req, model, opts = { oauth: false }) {
     }
     flush();
   }
-  repairOrphanedCalls(input2);
+  repairOrphanedCalls2(input2);
   const body = { model, input: input2, stream: req.stream, store: false };
   const instructions = systemText(req.system, "openai", note);
   if (instructions !== undefined && instructions.length > 0)
@@ -34106,7 +35773,7 @@ function toResponsesWire(req, model, opts = { oauth: false }) {
     }));
   }
   if (req.toolChoice !== undefined)
-    body.tool_choice = encodeToolChoice5(req.toolChoice);
+    body.tool_choice = encodeToolChoice7(req.toolChoice);
   if (req.reasoning !== undefined && req.reasoning.mode !== "off") {
     if (req.reasoning.mode === "budget") {
       degradations.push("openai:reasoning-budget-dropped");
@@ -34115,7 +35782,7 @@ function toResponsesWire(req, model, opts = { oauth: false }) {
       body.reasoning = { effort, summary: "auto" };
     }
   }
-  const key = suppliedKey(req) ?? cacheKey(req, instructions ?? "", input2[0]);
+  const key = suppliedKey2(req) ?? cacheKey2(req, instructions ?? "", input2[0]);
   Object.assign(body, req.vendor?.openai ?? {});
   body.prompt_cache_key = key;
   return { body, degradations, cacheKey: key };
@@ -34127,14 +35794,14 @@ var API_URL3 = "https://api.openai.com/v1/responses";
 var openaiCodec = {
   buildRequest(input2) {
     const oauth = input2.credentials.accessToken !== null;
-    const { body, degradations, cacheKey: cacheKey2 } = toResponsesWire(input2.request, input2.model, { oauth });
+    const { body, degradations, cacheKey: cacheKey3 } = toResponsesWire(input2.request, input2.model, { oauth });
     const protocol = [["Content-Type", "application/json"]];
     if (oauth) {
       protocol.push(["Authorization", `Bearer ${input2.credentials.accessToken}`]);
       const accountId = input2.credentials.providerData.accountId;
       if (typeof accountId === "string")
         protocol.push(["chatgpt-account-id", accountId]);
-      protocol.push(["session_id", cacheKey2]);
+      protocol.push(["session_id", cacheKey3]);
     } else if (input2.credentials.apiKey !== null) {
       protocol.push(["Authorization", `Bearer ${input2.credentials.apiKey}`]);
     } else {
@@ -34169,6 +35836,8 @@ var ADAPTERS = {
   kimi: kimiAdapter,
   kilo: kiloAdapter,
   grok: grokAdapter,
+  antigravity: antigravityAdapter,
+  muse: museAdapter,
   custom: customAdapter
 };
 Object.setPrototypeOf(ADAPTERS, null);
@@ -35780,7 +37449,7 @@ import { join as join3 } from "path";
 
 // packages/plugin-api/src/version.ts
 var PLUGIN_API_VERSION = 3;
-var DASHBOARD_SDK_VERSION = "0.1.6";
+var DASHBOARD_SDK_VERSION = "0.1.8";
 // packages/plugin-api/src/manifest.ts
 var CAPABILITIES = [
   "storage",
@@ -36218,7 +37887,7 @@ function createRefresher(deps) {
   };
 }
 // packages/control/src/pluginProviders.ts
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNumber(value) {
@@ -36229,7 +37898,7 @@ function checkAt(ok, id, path, expected) {
     throw new Error(`provider ${id} descriptor: ${path} must be ${expected}`);
 }
 function checkLimits(id, path, value) {
-  checkAt(isRecord6(value), id, path, "an object");
+  checkAt(isRecord7(value), id, path, "an object");
   const limits = value;
   checkAt(isNumber(limits.contextWindow), id, `${path}.contextWindow`, "a finite number");
   checkAt(isNumber(limits.maxOutputTokens), id, `${path}.maxOutputTokens`, "a finite number");
@@ -36247,19 +37916,19 @@ function checkDescriptor(id, record2) {
     }
   }
   const capabilities2 = record2.capabilities;
-  checkAt(isRecord6(capabilities2), id, "capabilities", "an object");
+  checkAt(isRecord7(capabilities2), id, "capabilities", "an object");
   for (const flag of ["tools", "images", "reasoning"]) {
     const value = capabilities2[flag];
     checkAt(typeof value === "boolean", id, `capabilities.${flag}`, "a boolean");
   }
   const write = record2.writeOverInput;
-  checkAt(isRecord6(write), id, "writeOverInput", "an object");
+  checkAt(isRecord7(write), id, "writeOverInput", "an object");
   for (const ttl of ["fiveMinute", "oneHour"]) {
     const value = write[ttl];
     checkAt(isNumber(value), id, `writeOverInput.${ttl}`, "a finite number");
   }
   const catalog2 = record2.catalog;
-  checkAt(isRecord6(catalog2), id, "catalog", "an object");
+  checkAt(isRecord7(catalog2), id, "catalog", "an object");
   const entry = catalog2;
   checkAt(typeof entry.defaultModel === "string", id, "catalog.defaultModel", "a string");
   checkAt(Array.isArray(entry.authTypes), id, "catalog.authTypes", "an array");
@@ -36270,11 +37939,11 @@ function checkDescriptor(id, record2) {
   checkAt(Array.isArray(entry.models), id, "catalog.models", "an array");
   for (const [index, model] of entry.models.entries()) {
     const at = `catalog.models[${index}]`;
-    checkAt(isRecord6(model), id, at, "an object");
+    checkAt(isRecord7(model), id, at, "an object");
     const choice = model;
     checkAt(typeof choice.id === "string", id, `${at}.id`, "a string");
     checkAt(typeof choice.label === "string", id, `${at}.label`, "a string");
-    checkAt(isRecord6(choice.pricing), id, `${at}.pricing`, "an object");
+    checkAt(isRecord7(choice.pricing), id, `${at}.pricing`, "an object");
     const pricing = choice.pricing;
     for (const field of ["input", "output", "cacheRead", "cacheWrite5m", "cacheWrite1h"]) {
       checkAt(isNumber(pricing[field]), id, `${at}.pricing.${field}`, "a finite number");
@@ -36290,13 +37959,13 @@ function checkDescriptor(id, record2) {
     checkAt(typeof prefix === "string", id, `modelPrefixes[${index}]`, "a string");
   }
   const presentation = record2.presentation;
-  checkAt(isRecord6(presentation), id, "presentation", "an object");
+  checkAt(isRecord7(presentation), id, "presentation", "an object");
   const shown = presentation;
   for (const field of ["label", "tone"]) {
     checkAt(typeof shown[field] === "string", id, `presentation.${field}`, "a string");
   }
   checkAt(isNumber(shown.order), id, "presentation.order", "a finite number");
-  checkAt(isRecord6(shown.colour), id, "presentation.colour", "an object");
+  checkAt(isRecord7(shown.colour), id, "presentation.colour", "an object");
   for (const scheme of ["light", "dark"]) {
     const value = shown.colour[scheme];
     checkAt(typeof value === "string", id, `presentation.colour.${scheme}`, "a string");
@@ -36308,7 +37977,7 @@ function checkDescriptor(id, record2) {
 function validateOAuthFlow(id, value) {
   if (value === undefined)
     return;
-  if (!isRecord6(value))
+  if (!isRecord7(value))
     throw new Error(`provider ${id} oauth must be an object`);
   const kind = value.kind;
   if (kind !== "pkce" && kind !== "device") {
@@ -36847,6 +38516,7 @@ var WINDOW_MS2 = {
   "1w": 7 * 24 * 60 * 60 * 1000
 };
 // apps/gateway/src/app.ts
+import { timingSafeEqual } from "crypto";
 import { existsSync, realpathSync as realpathSync3 } from "fs";
 import { resolve as resolve3, sep as sep3 } from "path";
 
@@ -37939,13 +39609,13 @@ function IsSeparator(pattern, index) {
 function IsGroup(pattern) {
   if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
     return false;
-  let count = 0;
+  let count2 = 0;
   for (let index = 0;index < pattern.length; index++) {
     if (IsOpenParen(pattern, index))
-      count += 1;
+      count2 += 1;
     if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (count === 0 && index !== pattern.length - 1)
+      count2 -= 1;
+    if (count2 === 0 && index !== pattern.length - 1)
       return false;
   }
   return true;
@@ -37954,13 +39624,13 @@ function InGroup(pattern) {
   return pattern.slice(1, pattern.length - 1);
 }
 function IsPrecedenceOr(pattern) {
-  let count = 0;
+  let count2 = 0;
   for (let index = 0;index < pattern.length; index++) {
     if (IsOpenParen(pattern, index))
-      count += 1;
+      count2 += 1;
     if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (IsSeparator(pattern, index) && count === 0)
+      count2 -= 1;
+    if (IsSeparator(pattern, index) && count2 === 0)
       return true;
   }
   return false;
@@ -37973,14 +39643,14 @@ function IsPrecedenceAnd(pattern) {
   return false;
 }
 function Or(pattern) {
-  let [count, start] = [0, 0];
+  let [count2, start] = [0, 0];
   const expressions = [];
   for (let index = 0;index < pattern.length; index++) {
     if (IsOpenParen(pattern, index))
-      count += 1;
+      count2 += 1;
     if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (IsSeparator(pattern, index) && count === 0) {
+      count2 -= 1;
+    if (IsSeparator(pattern, index) && count2 === 0) {
       const range2 = pattern.slice(start, index);
       if (range2.length > 0)
         expressions.push(TemplateLiteralParse(range2));
@@ -38000,13 +39670,13 @@ function And(pattern) {
   function Group(value, index) {
     if (!IsOpenParen(value, index))
       throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
-    let count = 0;
+    let count2 = 0;
     for (let scan = index;scan < value.length; scan++) {
       if (IsOpenParen(value, scan))
-        count += 1;
+        count2 += 1;
       if (IsCloseParen(value, scan))
-        count -= 1;
-      if (count === 0)
+        count2 -= 1;
+      if (count2 === 0)
         return [index, scan];
     }
     throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
@@ -38776,8 +40446,8 @@ function FromNumberRight(left, right) {
 function FromNumber(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsInteger(right) || exports_type.IsNumber(right) ? ExtendsResult.True : ExtendsResult.False;
 }
-function IsObjectPropertyCount(schema, count) {
-  return Object.getOwnPropertyNames(schema.properties).length === count;
+function IsObjectPropertyCount(schema, count2) {
+  return Object.getOwnPropertyNames(schema.properties).length === count2;
 }
 function IsObjectStringLike(schema) {
   return IsObjectArrayLike(schema);
@@ -44246,7 +45916,7 @@ var emptySchema = {
 
 // node_modules/.bun/elysia@1.4.30+7c910760591f72db/node_modules/elysia/dist/error.mjs
 var env2 = typeof Bun < "u" ? Bun.env : typeof process < "u" ? process?.env : undefined;
-var ERROR_CODE3 = Symbol("ElysiaErrorCode");
+var ERROR_CODE5 = Symbol("ElysiaErrorCode");
 var isProduction = (env2?.NODE_ENV ?? env2?.ENV) === "production";
 var emptyHttpStatus = {
   101: undefined,
@@ -48819,7 +50489,7 @@ c.defs=definitions
       schema: app.router.history,
       definitions: app.definitions.type,
       tee,
-      ERROR_CODE: ERROR_CODE3,
+      ERROR_CODE: ERROR_CODE5,
       parseCookie: hasCookie ? parseCookie : undefined,
       signCookie: hasCookie ? signCookie : undefined,
       Cookie: hasCookie ? Cookie : undefined,
@@ -49092,7 +50762,7 @@ return mapResponse(${saveResponse}error,set${adapter.mapResponseContext})}`;
   return Function("inject", `"use strict";
 ` + fnLiteral)({
     mapResponse: app["~adapter"].handler.mapResponse,
-    ERROR_CODE: ERROR_CODE3,
+    ERROR_CODE: ERROR_CODE5,
     ElysiaCustomStatusResponse,
     ValidationError,
     TransformDecodeError,
@@ -50575,12 +52245,12 @@ var _Elysia = class _Elysia2 {
   error(name, error61) {
     switch (typeof name) {
       case "string":
-        return error61.prototype[ERROR_CODE3] = name, this.definitions.error[name] = error61, this;
+        return error61.prototype[ERROR_CODE5] = name, this.definitions.error[name] = error61, this;
       case "function":
         return this.definitions.error = name(this.definitions.error), this;
     }
     for (const [code, error210] of Object.entries(name))
-      error210.prototype[ERROR_CODE3] = code, this.definitions.error[code] = error210;
+      error210.prototype[ERROR_CODE5] = code, this.definitions.error[code] = error210;
     return this;
   }
   onError(options, handler) {
@@ -51324,11 +52994,13 @@ class ApiKeyRateLimiter {
   store;
   now;
   logger;
+  onRejected;
   constructor(deps) {
     this.store = deps.store;
     this.now = deps.now;
     this.logger = deps.logger ?? noopLogger;
     this.coord = deps.coord ?? memoryCoord();
+    this.onRejected = deps.onRejected;
   }
   async admit(keyId, limits, requestId) {
     if (!anyLimit(limits))
@@ -51403,6 +53075,9 @@ class ApiKeyRateLimiter {
     const exact = await this.exactReset(keyId, window2, now, requestId);
     const resolved = exact === null ? violation : { ...violation, resetAt: exact };
     const headroom = exact === null || window2 === null ? decision.headroom : withReset(decision.headroom, window2, exact);
+    try {
+      this.onRejected?.(violation.dimension, violation.window);
+    } catch {}
     throw new RateLimitExceeded(retryAfterMs(resolved, now), headroom);
   }
   async exactReset(keyId, window2, now, requestId) {
@@ -51501,6 +53176,61 @@ function withReset(headroom, window2, resetAt) {
   return corrected;
 }
 
+// apps/gateway/src/dispatch/loadRegistry.ts
+var PREFIX6 = "load:";
+var SLOT_TTL_MS = 300000;
+function createLoadRegistry(coord = memoryCoord()) {
+  const local = new Map;
+  const providers = new Map;
+  let remote = new Map;
+  return {
+    acquire(credentialId, model, provider) {
+      const key = healthKey(credentialId, model);
+      local.set(key, (local.get(key) ?? 0) + 1);
+      if (provider !== undefined)
+        providers.set(provider, (providers.get(provider) ?? 0) + 1);
+      coord.gauge.acquire(PREFIX6 + key, SLOT_TTL_MS);
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        const next = (local.get(key) ?? 0) - 1;
+        if (next > 0)
+          local.set(key, next);
+        else
+          local.delete(key);
+        if (provider !== undefined) {
+          const providerCount = (providers.get(provider) ?? 0) - 1;
+          if (providerCount > 0)
+            providers.set(provider, providerCount);
+          else
+            providers.delete(provider);
+        }
+        coord.gauge.release(PREFIX6 + key);
+      };
+    },
+    counts() {
+      const out = new Map(local);
+      for (const [key, count2] of remote) {
+        if (count2 > (out.get(key) ?? 0))
+          out.set(key, count2);
+      }
+      return out;
+    },
+    localCounts() {
+      return new Map(providers);
+    },
+    async refresh() {
+      const held = await coord.gauge.snapshot(PREFIX6);
+      const sample = new Map;
+      for (const [key, count2] of held)
+        sample.set(key.slice(PREFIX6.length), count2);
+      remote = sample;
+    }
+  };
+}
+
 // apps/gateway/src/dispatch/snapshotCache.ts
 function createRoutingSnapshotCache(store, logger2 = noopLogger) {
   let snapshot = null;
@@ -51571,7 +53301,7 @@ function createRoutingSnapshotCache(store, logger2 = noopLogger) {
 }
 
 // apps/gateway/src/egress/anthropic.ts
-var STOP_REASON2 = {
+var STOP_REASON3 = {
   endTurn: "end_turn",
   maxTokens: "max_tokens",
   stopSequence: "stop_sequence",
@@ -51668,7 +53398,7 @@ async function* anthropicStream(events, requestId) {
       case "end":
         yield frame("message_delta", {
           type: "message_delta",
-          delta: { stop_reason: STOP_REASON2[event.stopReason], stop_sequence: null },
+          delta: { stop_reason: STOP_REASON3[event.stopReason], stop_sequence: null },
           usage: {
             input_tokens: event.usage.inputTokens,
             output_tokens: event.usage.outputTokens,
@@ -51711,7 +53441,7 @@ function anthropicResponse(collected, requestId) {
           return { type: "text", text: "" };
       }
     }),
-    stop_reason: STOP_REASON2[collected.stopReason],
+    stop_reason: STOP_REASON3[collected.stopReason],
     stop_sequence: null,
     usage: {
       input_tokens: collected.usage.inputTokens,
@@ -52339,7 +54069,7 @@ function zodDetail(issue2) {
   }
   return issue2.message;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 function extraFields(body2, known) {
@@ -52474,7 +54204,7 @@ async function readJson(request2) {
 }
 async function readJsonRecord(request2) {
   const body2 = await readJson(request2);
-  return isRecord7(body2) ? body2 : null;
+  return isRecord8(body2) ? body2 : null;
 }
 function apiErrorResponse(error61) {
   const gatewayError = error61 instanceof GatewayError ? error61 : new GatewayError("INTERNAL", "internal error");
@@ -53714,10 +55444,10 @@ function classifyGrep(executable, args) {
     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))
+      const count2 = args[++index];
+      if (count2 === undefined || !/^\d+$/.test(count2))
         return;
-      const value = Number(count);
+      const value = Number(count2);
       if (argument === "-C" || argument === "--context") {
         beforeContext = value;
         afterContext = value;
@@ -53939,12 +55669,12 @@ class ParserBudget {
   constructor(inputCodeUnits) {
     this.inputCodeUnits = inputCodeUnits;
   }
-  chargeRecords(count) {
-    this.records += count;
+  chargeRecords(count2) {
+    this.records += count2;
     return this.records <= 1e5;
   }
-  chargeCodeUnits(count) {
-    this.codeUnits += count;
+  chargeCodeUnits(count2) {
+    this.codeUnits += count2;
     return this.codeUnits <= this.inputCodeUnits * 3;
   }
 }
@@ -54003,8 +55733,8 @@ function renderSelection(input2, selected, unit = "lines") {
   return renderGaps(input2, selected, (start, end) => `... ${end - start + 1} ${unit} omitted ...`);
 }
 function selectBlock(input2, selected, block) {
-  const count = block.end - block.start + 1;
-  if (!input2.budget.chargeRecords(count))
+  const count2 = block.end - block.start + 1;
+  if (!input2.budget.chargeRecords(count2))
     return false;
   for (let index = block.start;index <= block.end; index++)
     selected.add(index);
@@ -54328,8 +56058,8 @@ function renderGroups(input2, groups) {
         return;
     }
     if (group.entryCount > 12) {
-      const count = group.entryCount - 12;
-      if (!append(`... ${count} ${count === 1 ? "entry" : "entries"} omitted from ${group.key} ...`))
+      const count2 = group.entryCount - 12;
+      if (!append(`... ${count2} ${count2 === 1 ? "entry" : "entries"} omitted from ${group.key} ...`))
         return;
     }
   }
@@ -54352,12 +56082,12 @@ function subtreeCounts(input2, node2, classified) {
   let entries = 0;
   let ambiguous = false;
   for (const child of node2.children) {
-    const count = subtreeCounts(input2, child, classified);
-    if (count === undefined)
+    const count2 = subtreeCounts(input2, child, classified);
+    if (count2 === undefined)
       return;
-    directories += count.directories;
-    entries += count.entries;
-    ambiguous ||= count.ambiguous;
+    directories += count2.directories;
+    entries += count2.entries;
+    ambiguous ||= count2.ambiguous;
   }
   return { directories, entries, ambiguous };
 }
@@ -54377,12 +56107,12 @@ function appendSubtree(input2, output2, node2, classified) {
     let entries = 0;
     let ambiguous = false;
     for (const child of omitted) {
-      const count = subtreeCounts(input2, child, classified);
-      if (count === undefined)
+      const count2 = subtreeCounts(input2, child, classified);
+      if (count2 === undefined)
         return false;
-      directories += count.directories;
-      entries += count.entries;
-      ambiguous ||= count.ambiguous;
+      directories += count2.directories;
+      entries += count2.entries;
+      ambiguous ||= count2.ambiguous;
     }
     if (ambiguous)
       return false;
@@ -55060,8 +56790,8 @@ function compressTests(input2, executable = "unknown") {
         break;
       end++;
     }
-    const count = end - start + 1;
-    if (!input2.budget.chargeRecords(count))
+    const count2 = end - start + 1;
+    if (!input2.budget.chargeRecords(count2))
       return text;
     for (let index = start;index <= end; index++)
       selected.add(index);
@@ -55473,7 +57203,7 @@ async function routeLog(store, requestId, target, logger2 = noopLogger, broadcas
     }
   }
 }
-async function finishLog(store, log, keyId, logger2 = noopLogger, bodies, debit, emit, broadcast) {
+async function finishLog(store, log, keyId, logger2 = noopLogger, bodies, debit, emit, broadcast, telemetry, trace) {
   let appended = true;
   try {
     await store.usage.append({ ...log, apiKeyId: keyId });
@@ -55517,13 +57247,106 @@ async function finishLog(store, log, keyId, logger2 = noopLogger, bodies, debit,
       report(logger2, "failed to publish a resource invalidation", log.id, error61);
     }
   }
-  if (bodies === undefined)
-    return;
+  if (bodies !== undefined) {
+    try {
+      await bodies(log);
+    } catch (error61) {
+      report(logger2, "failed to persist request bodies", log.id, error61);
+    }
+  }
+  try {
+    telemetry?.record(log, keyId, trace ?? null);
+  } catch (error61) {
+    report(logger2, "failed to record request telemetry", log.id, error61);
+  }
   try {
-    await bodies(log);
+    telemetry?.flush(log.id, trace ?? null);
   } catch (error61) {
-    report(logger2, "failed to persist request bodies", log.id, error61);
+    report(logger2, "failed to export request telemetry", log.id, error61);
+  }
+}
+
+// apps/gateway/src/telemetry/spans.ts
+var TRACEPARENT = /^[\da-f]{2}-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(?:-[\da-f]+)*$/i;
+var ZERO_TRACE = "0".repeat(32);
+var ZERO_SPAN = "0".repeat(16);
+function parseTraceparent(value) {
+  if (value === null)
+    return null;
+  const match = TRACEPARENT.exec(value);
+  const traceId = match?.[1]?.toLowerCase();
+  const parentSpanId = match?.[2]?.toLowerCase();
+  const flags = match?.[3];
+  if (traceId === undefined || parentSpanId === undefined || flags === undefined)
+    return null;
+  if (traceId === ZERO_TRACE || parentSpanId === ZERO_SPAN)
+    return null;
+  return { traceId, parentSpanId, sampled: (Number.parseInt(flags, 16) & 1) === 1 };
+}
+function randomHex(bytes) {
+  const out = new Uint8Array(bytes);
+  crypto.getRandomValues(out);
+  return [...out].map((byte2) => byte2.toString(16).padStart(2, "0")).join("");
+}
+function createTrace(opts) {
+  const id = opts.id ?? (() => randomHex(8));
+  return {
+    startedAt: opts.startedAt,
+    traceId: opts.traceparent?.traceId ?? `${id()}${id()}`.slice(0, 32),
+    parentSpanId: opts.traceparent?.parentSpanId ?? null,
+    spanIds: [],
+    spans: [],
+    activeAttempt: null,
+    routeSpan: null,
+    nextId: id
+  };
+}
+function addSpan(trace, name, parent, startMs, endMs, attrs) {
+  try {
+    const id = trace.spans.length;
+    trace.spanIds.push(trace.nextId());
+    trace.spans.push({ id, parent, name, startMs, endMs, attrs });
+    return id;
+  } catch {
+    return -1;
+  }
+}
+function otlpAttrs(attrs) {
+  const out = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value === undefined)
+      continue;
+    out.push(typeof value === "number" ? { key, value: { intValue: String(value) } } : { key, value: { stringValue: value } });
   }
+  return out;
+}
+function encodeTrace(trace, serviceVersion) {
+  const spans = trace.spans.map((span) => {
+    const parentSpanId = span.parent === null ? trace.parentSpanId : trace.spanIds[span.parent] ?? trace.parentSpanId;
+    return {
+      traceId: trace.traceId,
+      spanId: trace.spanIds[span.id] ?? trace.nextId(),
+      ...parentSpanId === null ? {} : { parentSpanId },
+      name: span.name,
+      startTimeUnixNano: String(BigInt(Math.round(trace.startedAt + span.startMs)) * 1000000n),
+      endTimeUnixNano: String(BigInt(Math.round(trace.startedAt + span.endMs)) * 1000000n),
+      attributes: otlpAttrs(span.attrs),
+      status: { code: span.attrs.code === undefined ? 0 : 2 }
+    };
+  });
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [
+            { key: "service.name", value: { stringValue: "omnigateway" } },
+            { key: "service.version", value: { stringValue: serviceVersion } }
+          ]
+        },
+        scopeSpans: [{ spans }]
+      }
+    ]
+  };
 }
 
 // apps/gateway/src/dispatch/attempt.ts
@@ -55708,6 +57531,7 @@ async function dispatch(request2, deps, signal, requestId) {
     return fail(code, describeError(error61, "unresolvable model"));
   }
   await deps.loadRegistry.refresh();
+  const routeStartedAt = deps.now();
   const { candidates, excluded } = rank({
     request: dispatchRequest,
     model,
@@ -55717,6 +57541,15 @@ async function dispatch(request2, deps, signal, requestId) {
     load: deps.loadRegistry.counts(),
     providers: deps.providers
   });
+  if (deps.trace !== null && deps.trace !== undefined) {
+    deps.trace.routeSpan = addSpan(deps.trace, "dispatch.route", 0, routeStartedAt - startedAt, deps.now() - startedAt, {
+      candidates: candidates.length,
+      ...candidates[0] === undefined ? {} : {
+        chosen_provider: candidates[0].target.provider,
+        chosen_model: candidates[0].target.model
+      }
+    });
+  }
   logger2.debug("routing candidates ranked", {
     requestId,
     requestedModel: request2.model,
@@ -55744,7 +57577,7 @@ async function dispatch(request2, deps, signal, requestId) {
   const eager = {
     credentialId: head.credential.id,
     model: head.target.model,
-    release: deps.loadRegistry.acquire(head.credential.id, head.target.model)
+    release: deps.loadRegistry.acquire(head.credential.id, head.target.model, head.target.provider)
   };
   let eagerHeld = true;
   releaseOnAbort = () => eager.release();
@@ -55755,7 +57588,14 @@ async function dispatch(request2, deps, signal, requestId) {
   const persistHealth = async (candidate, transition) => {
     const credentialId = candidate.credential.id;
     const { model: model2 } = candidate.target;
-    await deps.store.credentials.updateHealth(credentialId, model2, (current) => transition(current ?? blankHealth(credentialId, model2)));
+    await deps.store.credentials.updateHealth(credentialId, model2, (current) => {
+      const before = current ?? blankHealth(credentialId, model2);
+      const after = transition(before);
+      try {
+        deps.telemetry?.breaker(candidate.target.provider, before.breakerState, after.breakerState);
+      } catch {}
+      return after;
+    });
   };
   async function* run() {
     try {
@@ -55774,7 +57614,17 @@ async function dispatch(request2, deps, signal, requestId) {
           const adoptable = eagerHeld && eager.credentialId === candidate.credential.id && eager.model === candidate.target.model;
           if (adoptable)
             eagerHeld = false;
-          const releaseSlot = adoptable ? eager.release : deps.loadRegistry.acquire(candidate.credential.id, candidate.target.model);
+          const releaseSlot = adoptable ? eager.release : deps.loadRegistry.acquire(candidate.credential.id, candidate.target.model, candidate.target.provider);
+          const attemptStartedAt = deps.now();
+          let attemptCode;
+          if (deps.trace !== null && deps.trace !== undefined) {
+            deps.trace.activeAttempt = addSpan(deps.trace, "dispatch.attempt", 0, attemptStartedAt - startedAt, attemptStartedAt - startedAt, {
+              attempt: i + 1,
+              provider: candidate.target.provider,
+              model: candidate.target.model,
+              credential_id: candidate.credential.id
+            });
+          }
           try {
             log.attempts = i + 1;
             log.credentialId = candidate.credential.id;
@@ -55838,6 +57688,9 @@ async function dispatch(request2, deps, signal, requestId) {
                   if (event.type === "blockDelta" && !committed) {
                     committed = true;
                     log.ttftMs = deps.now() - startedAt;
+                    if (deps.trace !== null && deps.trace !== undefined && deps.trace.activeAttempt !== null) {
+                      addSpan(deps.trace, "stream.commit", deps.trace.activeAttempt, log.ttftMs, log.ttftMs, { provider: candidate.target.provider, model: candidate.target.model });
+                    }
                     logger2.debug("stream committed", {
                       requestId,
                       provider: candidate.target.provider,
@@ -55920,6 +57773,7 @@ async function dispatch(request2, deps, signal, requestId) {
                   throw signal.reason;
                 const classifiedError = deadlineAt !== null && dispatchSignal.aborted ? { code: "TIMEOUT" } : classify(error61);
                 const { code: code2 } = classifiedError;
+                attemptCode = code2;
                 const message2 = describeError(error61, "attempt failed");
                 lastError = rewrap(classifiedError, message2);
                 if (error61 instanceof GatewayError)
@@ -55993,6 +57847,15 @@ async function dispatch(request2, deps, signal, requestId) {
               }
             }
           } finally {
+            if (deps.trace !== null && deps.trace !== undefined && deps.trace.activeAttempt !== null) {
+              const span = deps.trace.spans[deps.trace.activeAttempt];
+              if (span !== undefined) {
+                span.endMs = deps.now() - startedAt;
+                if (attemptCode !== undefined)
+                  span.attrs = { ...span.attrs, code: attemptCode };
+              }
+              deps.trace.activeAttempt = null;
+            }
             releaseSlot();
           }
         }
@@ -56064,48 +57927,6 @@ function waitForCancellation(promise2, signal) {
   });
 }
 
-// apps/gateway/src/dispatch/loadRegistry.ts
-var PREFIX6 = "load:";
-var SLOT_TTL_MS = 300000;
-function createLoadRegistry(coord = memoryCoord()) {
-  const local = new Map;
-  let remote = new Map;
-  return {
-    acquire(credentialId, model) {
-      const key = healthKey(credentialId, model);
-      local.set(key, (local.get(key) ?? 0) + 1);
-      coord.gauge.acquire(PREFIX6 + key, SLOT_TTL_MS);
-      let released = false;
-      return () => {
-        if (released)
-          return;
-        released = true;
-        const next = (local.get(key) ?? 0) - 1;
-        if (next > 0)
-          local.set(key, next);
-        else
-          local.delete(key);
-        coord.gauge.release(PREFIX6 + key);
-      };
-    },
-    counts() {
-      const out = new Map(local);
-      for (const [key, count] of remote) {
-        if (count > (out.get(key) ?? 0))
-          out.set(key, count);
-      }
-      return out;
-    },
-    async refresh() {
-      const held = await coord.gauge.snapshot(PREFIX6);
-      const sample = new Map;
-      for (const [key, count] of held)
-        sample.set(key.slice(PREFIX6.length), count);
-      remote = sample;
-    }
-  };
-}
-
 // apps/gateway/src/ingress/anthropicTools.ts
 var TOOL_FIELDS = {
   cache_control: cacheControlSchema.nullable(),
@@ -56623,10 +58444,10 @@ function toIrToolChoice(c) {
 }
 var EFFORTS = REASONING_EFFORTS;
 function readEffort(body2) {
-  if (!isRecord7(body2))
+  if (!isRecord8(body2))
     return;
   const outputConfig = body2.output_config;
-  if (!isRecord7(outputConfig))
+  if (!isRecord8(outputConfig))
     return;
   const effort = outputConfig.effort;
   return EFFORTS.find((level) => level === effort);
@@ -56921,7 +58742,7 @@ function parseOpenAIRequest(body2, headers) {
 }
 
 // apps/gateway/src/ingress/responses.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var reasoning = exports_external.object({
   effort: exports_external.enum(REASONING_EFFORTS).optional(),
   summary: exports_external.string().optional()
@@ -56987,7 +58808,7 @@ function toIrReasoning2(r) {
   };
 }
 function clampCallId(raw) {
-  return raw.length <= 64 ? raw : createHash5("sha256").update(raw).digest("hex");
+  return raw.length <= 64 ? raw : createHash7("sha256").update(raw).digest("hex");
 }
 function roleOf(raw) {
   if (raw === "assistant")
@@ -56997,7 +58818,7 @@ function roleOf(raw) {
   return "user";
 }
 function contentPart(part2) {
-  if (!isRecord7(part2))
+  if (!isRecord8(part2))
     throw new GatewayError("BAD_REQUEST", "input: content part must be an object");
   const type = part2.type;
   if (type === "input_text" || type === "output_text") {
@@ -57037,7 +58858,7 @@ function readInputItems(items) {
       messages.push({ role, content });
   };
   for (const raw of items) {
-    if (!isRecord7(raw))
+    if (!isRecord8(raw))
       throw new GatewayError("BAD_REQUEST", "input: item must be an object");
     const type = raw.type ?? (raw.role === undefined ? undefined : "message");
     switch (type) {
@@ -57093,7 +58914,7 @@ function jsonArguments(raw, callId) {
   const text = typeof raw === "string" ? raw : "";
   try {
     const parsed2 = text === "" ? {} : JSON.parse(text);
-    return isRecord7(parsed2) ? parsed2 : { value: parsed2 };
+    return isRecord8(parsed2) ? parsed2 : { value: parsed2 };
   } catch {
     throw new GatewayError("BAD_REQUEST", `input: arguments for call ${safeToken(callId)} are not valid JSON`);
   }
@@ -57102,7 +58923,7 @@ var TOOL_NAME = /^[A-Za-z0-9_-]{1,128}$/;
 function readTools(raw) {
   const tools2 = [];
   for (const entry of raw) {
-    if (!isRecord7(entry))
+    if (!isRecord8(entry))
       throw new GatewayError("BAD_REQUEST", "tools: each tool must be an object");
     const type = typeof entry.type === "string" ? entry.type : "";
     const declared = typeof entry.name === "string" ? entry.name : "";
@@ -57115,7 +58936,7 @@ function readTools(raw) {
         kind: "portable",
         name: declared,
         ...description === undefined ? {} : { description },
-        inputSchema: type === "custom" ? { type: "object", properties: { input: { type: "string" } }, required: ["input"] } : isRecord7(entry.parameters) ? entry.parameters : { type: "object" }
+        inputSchema: type === "custom" ? { type: "object", properties: { input: { type: "string" } }, required: ["input"] } : isRecord8(entry.parameters) ? entry.parameters : { type: "object" }
       });
       continue;
     }
@@ -57130,10 +58951,10 @@ function readTools(raw) {
 }
 function customToolNames(body2) {
   const names = new Set;
-  if (!isRecord7(body2) || !Array.isArray(body2.tools))
+  if (!isRecord8(body2) || !Array.isArray(body2.tools))
     return names;
   for (const entry of body2.tools) {
-    if (isRecord7(entry) && entry.type === "custom" && typeof entry.name === "string") {
+    if (isRecord8(entry) && entry.type === "custom" && typeof entry.name === "string") {
       names.add(entry.name);
     }
   }
@@ -57330,6 +59151,7 @@ async function bodyCollectorFor(deps, key) {
 async function handle(deps, rateLimiter, surface, request2) {
   const requestId = deps.requestId();
   const startedAt = deps.now();
+  const trace = deps.telemetry?.startRequest(requestId, startedAt, request2.headers.get("traceparent"), surface, deps.rand()) ?? null;
   let keyId = null;
   let requestedModel = "";
   let outcome = null;
@@ -57411,6 +59233,7 @@ async function handle(deps, rateLimiter, surface, request2) {
     const dispatched = await dispatch(chatRequest, {
       ...deps,
       ...captured === null ? {} : { http: captured.wrap(deps.http) },
+      trace,
       async onRoute(target) {
         if (began) {
           await routeLog(deps.store, requestId, target, deps.logger, deps.broadcaster);
@@ -57448,7 +59271,7 @@ async function handle(deps, rateLimiter, surface, request2) {
         reportRejection(deps.logger, requestId, completed, gatewayError, surface);
       }
       logged = true;
-      await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit, deps.emit, deps.broadcaster);
+      await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit, deps.emit, deps.broadcaster, deps.telemetry, trace);
     };
     if (chatRequest.stream) {
       const frames = surface === "anthropic" ? anthropicStream(dispatched.events, requestId) : surface === "responses" ? responsesStream(dispatched.events, render2()) : openaiStream(dispatched.events, requestId, Math.floor(deps.now() / 1000));
@@ -57489,7 +59312,7 @@ async function handle(deps, rateLimiter, surface, request2) {
     if (collector !== null && !logged)
       collector.client.response = rejection;
     if (!logged)
-      await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit, deps.emit, deps.broadcaster);
+      await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit, deps.emit, deps.broadcaster, deps.telemetry, trace);
     if (!cancelled)
       reportRejection(deps.logger, requestId, completed, gatewayError, surface);
     return jsonResponse(rejection, HTTP_STATUS[gatewayError.code], {
@@ -57770,11 +59593,11 @@ function topicClass(topic) {
   return null;
 }
 var MAX_TOPIC = 128;
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseClientFrame(raw) {
-  if (!isRecord8(raw))
+  if (!isRecord9(raw))
     return null;
   const { id, type, topic } = raw;
   if (id !== undefined && typeof id !== "string")
@@ -57980,16 +59803,16 @@ function createChannelRegistry(deps) {
     cancelReport = undefined;
     if (!live)
       return;
-    for (const [pluginId, count] of dropsSinceReport) {
-      logger2.warn("plugin channel broadcast dropped", { plugin: pluginId, count });
+    for (const [pluginId, count2] of dropsSinceReport) {
+      logger2.warn("plugin channel broadcast dropped", { plugin: pluginId, count: count2 });
     }
     dropsSinceReport.clear();
-    for (const [pluginId, count] of unencodableSinceReport) {
-      logger2.warn("plugin channel payload could not be serialised", { plugin: pluginId, count });
+    for (const [pluginId, count2] of unencodableSinceReport) {
+      logger2.warn("plugin channel payload could not be serialised", { plugin: pluginId, count: count2 });
     }
     unencodableSinceReport.clear();
-    for (const [pluginId, count] of errorsSinceReport) {
-      logger2.warn("plugin channel handler failed", { plugin: pluginId, count });
+    for (const [pluginId, count2] of errorsSinceReport) {
+      logger2.warn("plugin channel handler failed", { plugin: pluginId, count: count2 });
     }
     errorsSinceReport.clear();
   };
@@ -58457,7 +60280,7 @@ function createRing(limits) {
 }
 
 // apps/gateway/src/version.ts
-var VERSION = "0.9.1";
+var VERSION = "0.10.0";
 
 // apps/gateway/src/app.ts
 var ADMIN_SESSION_TTL_MS = 12 * 60 * 60 * 1000;
@@ -58495,10 +60318,22 @@ function createApp(deps) {
   const nodeId = deps.nodeId ?? crypto.randomUUID();
   const logger2 = deps.logger ?? noopLogger;
   const rand = deps.rand ?? Math.random;
-  const http = deps.http ?? nodeHttpClient({ logger: logger2, now });
+  const http = deps.http ?? nodeHttpClient({
+    logger: logger2,
+    now,
+    ...deps.telemetry === undefined ? {} : { onResponseHead: deps.telemetry.httpHead }
+  });
   const adapters = deps.adapters ?? ADAPTERS;
   const requestId = deps.requestId ?? (() => `req_${crypto.randomUUID()}`);
-  const rateLimiter = deps.rateLimiter ?? new ApiKeyRateLimiter({ store: deps.store, now, logger: logger2, coord });
+  const loadRegistry = deps.loadRegistry ?? createLoadRegistry(coord);
+  const telemetry = deps.telemetry;
+  const rateLimiter = deps.rateLimiter ?? new ApiKeyRateLimiter({
+    store: deps.store,
+    now,
+    logger: logger2,
+    coord,
+    ...telemetry === undefined ? {} : { onRejected: telemetry.rateLimit }
+  });
   const snapshots = createRoutingSnapshotCache(deps.store, logger2);
   const ROUTING_TOPIC = "routing";
   deps.store.routing.subscribe((change) => {
@@ -58563,7 +60398,17 @@ function createApp(deps) {
     ok: true,
     mode: deps.mode ?? "single",
     nodeId,
-    coord: "healthy" in coord && !coord.healthy() ? "fallback" : "ok"
+    coord: deps.coordHealthy?.() === false ? "fallback" : "ok"
+  })).use(deps.metricsToken === undefined || telemetry === undefined ? new Elysia : new Elysia().get("/metrics", ({ request: request2 }) => {
+    const supplied = request2.headers.get("authorization");
+    const expected = `Bearer ${deps.metricsToken}`;
+    const actualBytes = Buffer.from(supplied ?? "");
+    const expectedBytes = Buffer.from(expected);
+    if (actualBytes.length !== expectedBytes.length || !timingSafeEqual(actualBytes, expectedBytes)) {
+      return new Response(null, { status: 401 });
+    }
+    const coordFallback = deps.coordHealthy?.() === false;
+    return new Response(telemetry.scrape(loadRegistry.localCounts?.() ?? new Map, registry2.stats(), coordFallback), { headers: { "content-type": "text/plain; version=0.0.4; charset=utf-8" } });
   })).use(proxyRoutes({
     store: deps.store,
     snapshots,
@@ -58576,9 +60421,10 @@ function createApp(deps) {
     rateLimiter,
     logger: logger2,
     coord,
-    ...deps.loadRegistry === undefined ? {} : { loadRegistry: deps.loadRegistry },
+    loadRegistry,
     bodyLoggingAllowed: deps.bodyLoggingAllowed === true,
     ...deps.emit === undefined ? {} : { emit: deps.emit },
+    ...telemetry === undefined ? {} : { telemetry },
     broadcaster
   })).use(adminRoutes({
     store: deps.store,
@@ -59188,9 +61034,9 @@ function startMaintenance(deps) {
     });
   }, SWEEP_INTERVAL_MS2);
   const prune = async () => {
-    await deps.store.usage.sweepPending(deps.now()).then((count) => {
-      if (count > 0)
-        logger2.info("retired interrupted requests", { count });
+    await deps.store.usage.sweepPending(deps.now()).then((count2) => {
+      if (count2 > 0)
+        logger2.info("retired interrupted requests", { count: count2 });
     }).catch((error61) => {
       logger2.error("pending sweep failed", { reason: describeError(error61, "unknown") });
     });
@@ -59315,8 +61161,8 @@ function createPluginEventBus(opts) {
         }
       }
     }
-    for (const [pluginId, count] of errorsSinceReport) {
-      logger2.warn("plugin event handler failed", { plugin: pluginId, count });
+    for (const [pluginId, count2] of errorsSinceReport) {
+      logger2.warn("plugin event handler failed", { plugin: pluginId, count: count2 });
     }
     errorsSinceReport.clear();
     if (droppedSinceReport > 0) {
@@ -59847,6 +61693,340 @@ function startJournalPoll(deps, source, logger2) {
   };
 }
 
+// apps/gateway/src/telemetry/otlp.ts
+function createOtlpExporter(opts) {
+  const queue = [];
+  const send = opts.fetch ?? fetch;
+  const schedule = opts.schedule ?? ((run, ms) => {
+    const timer = setInterval(run, ms);
+    timer.unref?.();
+    return () => clearInterval(timer);
+  });
+  let reporting = false;
+  const exporter = {
+    enqueue(trace) {
+      try {
+        const encoded = JSON.stringify(encodeTrace(trace, opts.version ?? "unknown"));
+        if (queue.length >= opts.capacity) {
+          opts.registry.add("omni_otlp_spans_dropped_total", { reason: "queue_full" });
+          return;
+        }
+        queue.push(encoded);
+      } catch {
+        opts.registry.add("omni_otlp_spans_dropped_total", { reason: "encode" });
+      }
+    },
+    async flush() {
+      if (queue.length === 0)
+        return;
+      const encoded = queue.splice(0, opts.batchMax);
+      try {
+        const bodies = encoded.map((body2) => JSON.parse(body2));
+        const resourceSpans = bodies.flatMap((body2) => body2.resourceSpans);
+        const response = await send(`${opts.endpoint.replace(/\/+$/, "")}/v1/traces`, {
+          method: "POST",
+          headers: { "content-type": "application/json", ...opts.headers },
+          body: JSON.stringify({ resourceSpans })
+        });
+        if (!response.ok)
+          throw new Error(`collector returned ${response.status}`);
+        reporting = false;
+      } catch {
+        if (!reporting)
+          opts.logger?.warn("trace export failed", { reason: "collector unavailable" });
+        reporting = true;
+      }
+    },
+    queued: () => queue.length,
+    stop() {
+      cancel();
+    }
+  };
+  const cancel = schedule(() => void exporter.flush(), opts.intervalMs);
+  return exporter;
+}
+
+// apps/gateway/src/telemetry/registry.ts
+var DEFINITIONS = {
+  omni_requests_total: { help: "Requests completed by this process.", type: "counter" },
+  omni_request_duration_seconds: { help: "Request duration in seconds.", type: "histogram" },
+  omni_ttft_seconds: { help: "Streaming time to first token in seconds.", type: "histogram" },
+  omni_tokens_total: { help: "Billable tokens completed by this process.", type: "counter" },
+  omni_cost_usd_total: { help: "Request cost in US dollars.", type: "counter" },
+  omni_upstream_duration_seconds: {
+    help: "Provider response-head duration in seconds.",
+    type: "histogram"
+  },
+  omni_inflight: { help: "Provider requests in flight in this process.", type: "gauge" },
+  omni_breaker_open: { help: "Credential breakers observed open in this process.", type: "gauge" },
+  omni_ratelimit_rejected_total: { help: "API-key rate-limit refusals.", type: "counter" },
+  omni_stream_connections: { help: "Live stream connections in this process.", type: "gauge" },
+  omni_stream_queued: { help: "Stream frames queued in this process.", type: "gauge" },
+  omni_stream_dropped_total: { help: "Stream frames dropped in this process.", type: "counter" },
+  omni_coord_fallback: {
+    help: "Whether this process is using coordination fallback.",
+    type: "gauge"
+  },
+  omni_metrics_series_folded_total: {
+    help: "Metric series folded into api_key_id other.",
+    type: "counter"
+  },
+  omni_otlp_spans_dropped_total: { help: "Spans dropped before OTLP export.", type: "counter" },
+  omni_build_info: { help: "Gateway build information.", type: "gauge" }
+};
+var HISTOGRAM_BUCKETS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60];
+function labelKey(labels) {
+  return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key.length}:${key}${value.length}:${value}`).join("");
+}
+function createMetricRegistry(opts) {
+  const series = new Map;
+  const rawSeries = new Set;
+  const folded = new Set;
+  const normalize = (name, labels) => {
+    const copy = { ...labels };
+    const raw = `${name}:${labelKey(copy)}`;
+    if (rawSeries.has(raw))
+      return copy;
+    if (rawSeries.size < opts.maxSeries || copy.api_key_id === undefined) {
+      rawSeries.add(raw);
+      return copy;
+    }
+    copy.api_key_id = "other";
+    if (!folded.has(raw)) {
+      folded.add(raw);
+      change("omni_metrics_series_folded_total", {}, 1, false);
+    }
+    return copy;
+  };
+  const change = (name, labels, value, replace) => {
+    const normalized = normalize(name, labels);
+    const key = labelKey(normalized);
+    const table = series.get(name) ?? new Map;
+    const current = table.get(key) ?? { labels: normalized, value: 0 };
+    current.value = replace ? value : current.value + value;
+    table.set(key, current);
+    series.set(name, table);
+    return current;
+  };
+  return {
+    add(name, labels, value = 1) {
+      change(name, labels, value, false);
+    },
+    set(name, labels, value) {
+      change(name, labels, value, true);
+    },
+    observe(name, value, labels) {
+      const current = change(name, labels, value, false);
+      current.count = (current.count ?? 0) + 1;
+      const buckets = current.buckets ?? HISTOGRAM_BUCKETS.map(() => 0);
+      for (let i = 0;i < HISTOGRAM_BUCKETS.length; i++) {
+        if (value <= HISTOGRAM_BUCKETS[i])
+          buckets[i] = (buckets[i] ?? 0) + 1;
+      }
+      current.buckets = buckets;
+    },
+    value(name, labels) {
+      return series.get(name)?.get(labelKey(labels))?.value ?? 0;
+    },
+    snapshot() {
+      return {
+        at: opts.now(),
+        metrics: Object.entries(DEFINITIONS).map(([name, definition]) => ({
+          name,
+          ...definition,
+          samples: [...series.get(name)?.values() ?? []].map((sample) => definition.type === "histogram" ? {
+            labels: sample.labels,
+            value: sample.value,
+            sum: sample.value,
+            count: sample.count ?? 0,
+            buckets: sample.buckets ?? HISTOGRAM_BUCKETS.map(() => 0)
+          } : { labels: sample.labels, value: sample.value })
+        })).filter((metric) => metric.samples.length > 0)
+      };
+    }
+  };
+}
+
+// apps/gateway/src/telemetry/render.ts
+function escapeLabel(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll(`
+`, "\\n").replaceAll('"', "\\\"");
+}
+function labels(labels2, extra) {
+  const entries = Object.entries(labels2);
+  if (extra !== undefined)
+    entries.push([extra[0], extra[1]]);
+  if (entries.length === 0)
+    return "";
+  return `{${entries.map(([key, value]) => `${key}="${escapeLabel(value)}"`).join(",")}}`;
+}
+function number4(value) {
+  if (value === Number.POSITIVE_INFINITY)
+    return "+Inf";
+  if (value === Number.NEGATIVE_INFINITY)
+    return "-Inf";
+  if (Number.isNaN(value))
+    return "NaN";
+  return String(value);
+}
+function renderPrometheus(snapshot) {
+  const out = [];
+  for (const metric of snapshot.metrics) {
+    out.push(`# HELP ${metric.name} ${metric.help}`, `# TYPE ${metric.name} ${metric.type}`);
+    for (const sample of metric.samples) {
+      if (metric.type !== "histogram" || !("buckets" in sample)) {
+        out.push(`${metric.name}${labels(sample.labels)} ${number4(sample.value)}`);
+        continue;
+      }
+      for (let i = 0;i < HISTOGRAM_BUCKETS.length; i++) {
+        out.push(`${metric.name}_bucket${labels(sample.labels, ["le", String(HISTOGRAM_BUCKETS[i])])} ${number4(sample.buckets[i] ?? 0)}`);
+      }
+      out.push(`${metric.name}_bucket${labels(sample.labels, ["le", "+Inf"])} ${sample.count}`, `${metric.name}_sum${labels(sample.labels)} ${number4(sample.sum)}`, `${metric.name}_count${labels(sample.labels)} ${sample.count}`);
+    }
+  }
+  return `${out.join(`
+`)}
+`;
+}
+
+// apps/gateway/src/telemetry/index.ts
+function parseOtlpHeaders(value) {
+  const headers = {};
+  if (value === null)
+    return headers;
+  for (const entry of value.split(",")) {
+    const at = entry.indexOf("=");
+    if (at <= 0)
+      continue;
+    const key = entry.slice(0, at).trim();
+    if (key.length > 0)
+      headers[key] = entry.slice(at + 1).trim();
+  }
+  return headers;
+}
+function codeAttr(value) {
+  return value === "interrupted" || /^[A-Z_]{1,32}$/.test(value) ? { code: value } : {};
+}
+function createTelemetry(opts) {
+  const registry2 = createMetricRegistry({ maxSeries: opts.maxSeries, now: opts.now });
+  const traces = new Map;
+  const openBreakers = new Map;
+  const exporter = opts.exporter ?? (opts.otlpEndpoint === null ? null : createOtlpExporter({
+    endpoint: opts.otlpEndpoint,
+    headers: opts.otlpHeaders,
+    capacity: 1e4,
+    batchMax: 512,
+    intervalMs: 5000,
+    registry: registry2,
+    ...opts.logger === undefined ? {} : { logger: opts.logger },
+    version: opts.version
+  }));
+  if (opts.metricsEnabled)
+    registry2.set("omni_build_info", { version: opts.version }, 1);
+  return {
+    metricsEnabled: opts.metricsEnabled,
+    tracingEnabled: exporter !== null,
+    registry: registry2,
+    startRequest(requestId, startedAt, traceparent, surface, rand) {
+      if (exporter === null)
+        return null;
+      const inbound = parseTraceparent(traceparent);
+      if (inbound !== null ? !inbound.sampled : rand >= opts.traceSample)
+        return null;
+      const trace = createTrace({ startedAt, traceparent: inbound });
+      addSpan(trace, "gateway.request", null, 0, 0, { surface });
+      traces.set(requestId, trace);
+      return trace;
+    },
+    record(log, keyId, trace) {
+      if (opts.metricsEnabled) {
+        const provider = log.resolvedProvider ?? "";
+        const model = log.resolvedModel ?? log.requestedModel;
+        const key = keyId ?? "";
+        registry2.add("omni_requests_total", {
+          provider,
+          model,
+          status: String(log.status),
+          code: log.errorCode ?? "",
+          api_key_id: key
+        });
+        registry2.observe("omni_request_duration_seconds", log.durationMs / 1000, {
+          provider,
+          model
+        });
+        if (log.ttftMs !== null)
+          registry2.observe("omni_ttft_seconds", log.ttftMs / 1000, { provider, model });
+        for (const [kind, value] of [
+          ["input", log.inputTokens],
+          ["output", log.outputTokens],
+          ["cache_read", log.cacheReadTokens],
+          ["cache_write", log.cacheWriteTokens]
+        ]) {
+          registry2.add("omni_tokens_total", { provider, model, api_key_id: key, kind }, value);
+        }
+        registry2.add("omni_cost_usd_total", { provider, model, api_key_id: key }, log.costUsd);
+      }
+      if (trace !== null) {
+        const root = trace.spans[0];
+        if (root !== undefined) {
+          root.endMs = log.durationMs;
+          root.attrs = {
+            ...root.attrs,
+            requested_model: log.requestedModel,
+            api_key_id: keyId ?? "",
+            status: log.status,
+            ...log.errorCode === null ? {} : codeAttr(log.errorCode)
+          };
+        }
+      }
+    },
+    flush(requestId, trace) {
+      traces.delete(requestId);
+      if (trace !== null)
+        exporter?.enqueue(trace);
+    },
+    httpHead(event) {
+      if (opts.metricsEnabled)
+        registry2.observe("omni_upstream_duration_seconds", event.durationMs / 1000, {
+          provider: event.provider
+        });
+      const trace = event.requestId === undefined ? undefined : traces.get(event.requestId);
+      if (trace === undefined)
+        return;
+      const endMs = Math.max(0, opts.now() - trace.startedAt);
+      addSpan(trace, "provider.http", trace.activeAttempt ?? null, Math.max(0, endMs - event.durationMs), endMs, {
+        provider: event.provider,
+        host: event.host,
+        path: event.path,
+        ...event.status === undefined ? {} : { status: event.status }
+      });
+    },
+    breaker(provider, before, after) {
+      if (!opts.metricsEnabled || before === after)
+        return;
+      const count2 = Math.max(0, (openBreakers.get(provider) ?? 0) + (after === "open" ? 1 : before === "open" ? -1 : 0));
+      openBreakers.set(provider, count2);
+      registry2.set("omni_breaker_open", { provider }, count2);
+    },
+    rateLimit(dimension, window2) {
+      if (opts.metricsEnabled)
+        registry2.add("omni_ratelimit_rejected_total", { dimension, window: window2 ?? "none" });
+    },
+    scrape(localInflight, streams, coordFallback) {
+      for (const [provider, value] of localInflight)
+        registry2.set("omni_inflight", { provider }, value);
+      registry2.set("omni_stream_connections", {}, streams.connections);
+      registry2.set("omni_stream_queued", {}, streams.queued);
+      registry2.set("omni_stream_dropped_total", {}, streams.dropped);
+      registry2.set("omni_coord_fallback", {}, coordFallback ? 1 : 0);
+      return renderPrometheus(registry2.snapshot());
+    },
+    stop() {
+      exporter?.stop();
+    }
+  };
+}
+
 // apps/gateway/src/index.ts
 function stdoutLogger(level) {
   return createLogger({
@@ -59915,7 +62095,17 @@ async function main() {
     logger2.info("retired interrupted requests", { count: swept });
   const console2 = consoleSource(config2.logFile);
   logger2.info("console log source resolved", { reason: console2.source.kind });
-  const http = nodeHttpClient({ logger: logger2, now });
+  const telemetry = createTelemetry({
+    metricsEnabled: config2.metricsToken !== null,
+    maxSeries: config2.metricsMaxSeries,
+    otlpEndpoint: config2.otlpEndpoint,
+    otlpHeaders: parseOtlpHeaders(config2.otlpHeaders),
+    traceSample: config2.traceSample,
+    now,
+    version: VERSION,
+    logger: logger2
+  });
+  const http = nodeHttpClient({ logger: logger2, now, onResponseHead: telemetry.httpHead });
   const shared = config2.clusterMode && config2.redisUrl !== null ? redisCoord({ url: config2.redisUrl, logger: logger2, now }) : null;
   const coord = shared ?? memoryCoord({ now });
   const lease = { coord, nodeId };
@@ -59986,6 +62176,8 @@ async function main() {
     broadcaster,
     ring: streamRing,
     channels: pluginChannels,
+    telemetry,
+    ...config2.metricsToken === null ? {} : { metricsToken: config2.metricsToken },
     bodyLoggingAllowed: config2.bodyLoggingAllowed,
     plugins: loadedPlugins.plugins.map((plugin) => ({ id: plugin.id, routes: plugin.routes })),
     pluginUi: loadedPlugins.plugins,
@@ -60043,6 +62235,7 @@ async function main() {
         streamRegistry.closeAll(1001, "restart");
         streamRegistry.stop();
         broadcaster.stop();
+        telemetry.stop();
         pluginChannels.stop();
       }
     ],