omnigateway 0.9.2 → 0.10.1

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,145 @@ var anthropicDescriptor = {
   }
 };
 
+// packages/providers/src/antigravity/models.ts
+var MAX_OUTPUT_TOKENS = 65536;
+var PRO_MAX_OUTPUT_TOKENS = 65535;
+var NO_CACHE_WRITE = { cacheWrite5m: 0, cacheWrite1h: 0 };
+var FREE = { input: 0, output: 0, cacheRead: 0, ...NO_CACHE_WRITE };
+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: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.8-flash-medium",
+      label: "Gemini 3.8 Flash (Medium)",
+      pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.8-flash-low",
+      label: "Gemini 3.8 Flash (Low)",
+      pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.7-flash-high",
+      label: "Gemini 3.7 Flash (High)",
+      pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.7-flash-medium",
+      label: "Gemini 3.7 Flash (Medium)",
+      pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.7-flash-low",
+      label: "Gemini 3.7 Flash (Low)",
+      pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.6-flash-high",
+      label: "Gemini 3.6 Flash (High)",
+      pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.6-flash-medium",
+      label: "Gemini 3.6 Flash (Medium)",
+      pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.6-flash-low",
+      label: "Gemini 3.6 Flash (Low)",
+      pricing: { input: 1.5, output: 7.5, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3-flash-agent",
+      label: "Gemini 3.5 Flash (High)",
+      pricing: { input: 1.5, output: 9, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.5-flash-low",
+      label: "Gemini 3.5 Flash (Medium)",
+      pricing: { input: 1.5, output: 9, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      limits: FLASH_LIMITS
+    },
+    {
+      id: "gemini-3.5-flash-extra-low",
+      label: "Gemini 3.5 Flash (Low)",
+      pricing: { input: 1.5, output: 9, cacheRead: 0.15, ...NO_CACHE_WRITE },
+      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: { input: 0.3, output: 2.5, cacheRead: 0.03, ...NO_CACHE_WRITE },
+      limits: PRO_LIMITS
+    },
+    {
+      id: "gemini-pro-agent",
+      label: "Gemini 3.1 Pro (High)",
+      pricing: { input: 2, output: 12, cacheRead: 0.2, ...NO_CACHE_WRITE },
+      limits: PRO_LIMITS
+    },
+    {
+      id: "gemini-3.1-pro-low",
+      label: "Gemini 3.1 Pro (Low)",
+      pricing: { input: 2, output: 12, cacheRead: 0.2, ...NO_CACHE_WRITE },
+      limits: PRO_LIMITS
+    },
+    {
+      id: "gemini-3.1-flash-lite",
+      label: "Gemini 3.1 Flash Lite",
+      pricing: { input: 0.25, output: 1.5, cacheRead: 0.025, ...NO_CACHE_WRITE },
+      limits: PRO_LIMITS
+    },
+    {
+      id: "gemini-2.5-pro",
+      label: "Gemini 2.5 Pro",
+      pricing: { input: 1.25, output: 10, cacheRead: 0.125, ...NO_CACHE_WRITE },
+      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 +29125,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 +29450,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 +29571,8 @@ var PROVIDER_DESCRIPTORS = {
   kimi: kimiDescriptor,
   kilo: kiloDescriptor,
   grok: grokDescriptor,
+  antigravity: antigravityDescriptor,
+  muse: museDescriptor,
   custom: customDescriptor
 };
 Object.setPrototypeOf(PROVIDER_DESCRIPTORS, null);
@@ -29909,6 +30111,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 = [];
@@ -30030,6 +30264,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");
@@ -30086,6 +30357,8 @@ var BODY_ORDER = {
   kimi: kimiBodyOrder,
   kilo: kiloBodyOrder,
   grok: grokBodyOrder,
+  antigravity: antigravityBodyOrder,
+  muse: museBodyOrder,
   custom: customBodyOrder
 };
 Object.setPrototypeOf(BODY_ORDER, null);
@@ -30179,6 +30452,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);
@@ -30209,6 +30484,8 @@ var PROFILES = {
   kimi: kimiProfile,
   kilo: kiloProfile,
   grok: grokProfile,
+  antigravity: antigravityProfile,
+  muse: museProfile,
   custom: customProfile
 };
 Object.setPrototypeOf(PROFILES, null);
@@ -31493,6 +31770,1114 @@ var anthropicOAuthFlow = {
     return parseAnthropicUsage(parsed(res.body), now());
   }
 };
+// packages/providers/src/antigravity/codec.ts
+import { createHash as createHash2 } from "crypto";
+
+// packages/providers/src/antigravity/cloak.ts
+var FUNCTION_NAME = /^[A-Za-z_][A-Za-z0-9_.-]{0,127}$/;
+var MAX_NAME = 128;
+var SUFFIX_LENGTH2 = 6;
+function aliasFor2(name) {
+  let base = name.replace(/[^A-Za-z0-9_.-]+/g, "_");
+  if (!/^[A-Za-z_]/.test(base))
+    base = `_${base}`;
+  if (base === "_")
+    return { base: "_tool", forced: true };
+  if (base.length > MAX_NAME) {
+    return { base: base.slice(0, MAX_NAME - SUFFIX_LENGTH2), forced: true };
+  }
+  return { base, forced: false };
+}
+function clientToolNames2(request2) {
+  const renamable = new Set;
+  const reserved = new Set;
+  const add = (name) => {
+    (FUNCTION_NAME.test(name) ? reserved : renamable).add(name);
+  };
+  const called = new Set;
+  for (const message of request2.messages) {
+    for (const block of message.content) {
+      if (block.type === "toolUse")
+        called.add(block.id);
+    }
+  }
+  for (const tool of request2.tools ?? []) {
+    if (tool.kind === "portable")
+      add(tool.name);
+  }
+  for (const message of request2.messages) {
+    for (const block of message.content) {
+      if (block.type === "toolUse")
+        add(block.name);
+      if (block.type === "toolResult" && !called.has(block.toolUseId))
+        add(block.toolUseId);
+    }
+  }
+  if (request2.toolChoice?.type === "tool")
+    add(request2.toolChoice.name);
+  return { renamable: [...renamable], reserved: [...reserved] };
+}
+function suffixFor2(name) {
+  const digest = Bun.hash.xxHash64(Buffer.from(name, "utf8")) & 0xffffffn;
+  return digest.toString(16).padStart(SUFFIX_LENGTH2, "0");
+}
+function buildToolCloak2(request2) {
+  const { renamable, reserved } = clientToolNames2(request2);
+  const claims = new Map;
+  const claim2 = (name) => {
+    claims.set(name, (claims.get(name) ?? 0) + 1);
+  };
+  for (const name of reserved)
+    claim2(name);
+  const bases = new Map;
+  for (const name of renamable) {
+    const derived = aliasFor2(name);
+    bases.set(name, derived);
+    claim2(derived.base);
+  }
+  const toWire2 = new Map;
+  const fromWire = new Map;
+  for (const [name, { base, forced }] of bases) {
+    const alias = forced || (claims.get(base) ?? 0) > 1 ? base + suffixFor2(name) : base;
+    toWire2.set(name, alias);
+    fromWire.set(alias, name);
+  }
+  return toWire2.size === 0 ? null : { toWire: toWire2, fromWire };
+}
+function cloakName2(cloak, name) {
+  return cloak?.toWire.get(name) ?? name;
+}
+function uncloakName2(cloak, name) {
+  return cloak?.fromWire.get(name) ?? name;
+}
+
+// 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, opts = {}) {
+  const cloak = opts.cloak ?? null;
+  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: uncloakName2(cloak, 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;
+}
+function openingTurn(contents, note) {
+  const first = contents[0];
+  if (first === undefined)
+    return contents;
+  const opensOnTool = first.role === "model" || first.parts[0] !== undefined && "functionResponse" in first.parts[0];
+  if (!opensOnTool)
+    return contents;
+  note("antigravity:opening-turn-added");
+  return [{ role: "user", parts: [{ text: "" }] }, ...contents];
+}
+function closingTurn(contents, note) {
+  if (contents[contents.length - 1]?.role !== "model")
+    return contents;
+  note("antigravity:closing-turn-added");
+  return [...contents, { role: "user", parts: [{ text: " " }] }];
+}
+var hasCacheControl = (block) => ("cacheControl" in block) && block.cacheControl !== undefined;
+var PRUNED = "antigravity:tool-schema-pruned";
+var MAX_STOP_SEQUENCES = 5;
+var MAX_THINKING_BUDGET = 65535;
+function scalarValue(kind, value) {
+  const numeric = (v, whole) => {
+    if (typeof v === "number")
+      return Number.isFinite(v) && (!whole || Number.isInteger(v));
+    if (typeof v !== "string")
+      return false;
+    if (whole)
+      return /^-?\d+$/.test(v);
+    return v.trim().length > 0 && Number.isFinite(Number(v));
+  };
+  switch (kind) {
+    case "free":
+      return value;
+    case "text":
+      return typeof value === "string" ? value : undefined;
+    case "texts": {
+      if (typeof value === "string")
+        return value;
+      if (!Array.isArray(value))
+        return;
+      const members2 = value.filter((m) => typeof m === "string");
+      return members2.length === 0 ? undefined : members2;
+    }
+    case "int":
+      return numeric(value, true) ? value : undefined;
+    case "double":
+      return numeric(value, false) ? value : undefined;
+    case "walked":
+      return value;
+  }
+}
+var SCHEMA_FIELDS = new Map([
+  ["type", "walked"],
+  ["items", "walked"],
+  ["properties", "walked"],
+  ["anyOf", "walked"],
+  ["allOf", "walked"],
+  ["additionalProperties", "walked"],
+  ["format", "text"],
+  ["title", "text"],
+  ["description", "text"],
+  ["pattern", "text"],
+  ["enum", "texts"],
+  ["required", "texts"],
+  ["propertyOrdering", "texts"],
+  ["minItems", "int"],
+  ["maxItems", "int"],
+  ["minLength", "int"],
+  ["maxLength", "int"],
+  ["minProperties", "int"],
+  ["maxProperties", "int"],
+  ["minimum", "double"],
+  ["maximum", "double"],
+  ["default", "free"],
+  ["example", "free"],
+  ["nullable", "free"]
+]);
+var SCHEMA_TYPES = new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "array",
+  "object",
+  "null",
+  "type_unspecified"
+]);
+var MAX_SCHEMA_DEPTH = 24;
+var isSchema = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function pruneSchema(node2, note, depth = 0) {
+  const out = {};
+  const drop = () => note(PRUNED);
+  const sub = (v) => {
+    if (!isSchema(v) || depth >= MAX_SCHEMA_DEPTH) {
+      drop();
+      return;
+    }
+    return pruneSchema(v, note, depth + 1);
+  };
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "const") {
+      drop();
+      if (typeof value === "string" && !Object.hasOwn(node2, "enum"))
+        out.enum = [value];
+      continue;
+    }
+    const kind = SCHEMA_FIELDS.get(key);
+    if (kind === undefined) {
+      drop();
+      continue;
+    }
+    switch (key) {
+      case "type": {
+        if (typeof value === "string") {
+          if (SCHEMA_TYPES.has(value.toLowerCase()))
+            out.type = value;
+          else
+            drop();
+          break;
+        }
+        const named = Array.isArray(value) ? value.filter((t) => typeof t === "string" && SCHEMA_TYPES.has(t.toLowerCase())) : [];
+        const real = named.filter((t) => t.toLowerCase() !== "null");
+        if (!Array.isArray(value) || named.length !== value.length || real.length !== 1)
+          drop();
+        if (real[0] !== undefined)
+          out.type = real[0];
+        if (named.length !== real.length)
+          out.nullable = true;
+        break;
+      }
+      case "properties": {
+        if (!isSchema(value)) {
+          drop();
+          break;
+        }
+        const entries = [];
+        for (const [name, member] of Object.entries(value)) {
+          if (name.length === 0) {
+            drop();
+            continue;
+          }
+          const pruned = sub(member);
+          if (pruned !== undefined)
+            entries.push([name, pruned]);
+        }
+        out.properties = Object.fromEntries(entries);
+        break;
+      }
+      case "items": {
+        if (Array.isArray(value)) {
+          drop();
+          const first = sub(value[0]);
+          if (first !== undefined)
+            out.items = first;
+          break;
+        }
+        const pruned = sub(value);
+        if (pruned !== undefined)
+          out.items = pruned;
+        break;
+      }
+      case "anyOf":
+      case "allOf": {
+        if (!Array.isArray(value)) {
+          drop();
+          break;
+        }
+        const arms = [];
+        for (const arm of value) {
+          const pruned = sub(arm);
+          if (pruned !== undefined)
+            arms.push(pruned);
+        }
+        out[key] = arms;
+        break;
+      }
+      case "additionalProperties": {
+        if (typeof value === "boolean") {
+          out[key] = value;
+          break;
+        }
+        const pruned = sub(value);
+        if (pruned !== undefined)
+          out[key] = pruned;
+        break;
+      }
+      default: {
+        const kept = scalarValue(kind, value);
+        if (kept === undefined)
+          drop();
+        else {
+          if (Array.isArray(kept) && Array.isArray(value) && kept.length !== value.length)
+            drop();
+          out[key] = kept;
+        }
+      }
+    }
+  }
+  const declared = typeof out.type === "string" ? out.type.toLowerCase() : undefined;
+  const agree = (want, fields) => {
+    if (!fields.some((f) => out[f] !== undefined))
+      return;
+    if (declared === want)
+      return;
+    if (declared === undefined) {
+      out.type = want;
+      return;
+    }
+    drop();
+    for (const f of fields)
+      delete out[f];
+  };
+  agree("object", ["properties", "required", "propertyOrdering"]);
+  agree("array", ["items"]);
+  for (const key of ["required", "propertyOrdering"]) {
+    const names = out[key];
+    if (!Array.isArray(names))
+      continue;
+    const known = isSchema(out.properties) ? out.properties : {};
+    const kept = names.filter((n) => typeof n === "string" && Object.hasOwn(known, n));
+    if (kept.length === names.length)
+      continue;
+    drop();
+    if (kept.length === 0)
+      delete out[key];
+    else
+      out[key] = kept;
+  }
+  if (out.type === "array" && out.items === undefined) {
+    drop();
+    delete out.type;
+  }
+  return out;
+}
+function encodeToolChoice2(choice, cloak) {
+  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: [cloakName2(cloak, choice.name)]
+        }
+      };
+  }
+}
+function toAntigravityWire(req, model, identity) {
+  const cloak = identity.cloak ?? null;
+  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: cloakName2(cloak, 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: cloakName2(cloak, 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: closingTurn(openingTurn(mergeSameRole(contents), note), note)
+  };
+  const system = systemText(req.system, "antigravity", note);
+  if (system !== undefined && system.length > 0) {
+    request2.systemInstruction = { parts: [{ text: system }] };
+  }
+  const generationConfig = {};
+  if (req.maxTokens !== undefined) {
+    if (req.maxTokens > 0)
+      generationConfig.maxOutputTokens = req.maxTokens;
+    else
+      note("antigravity:max-tokens-dropped");
+  }
+  if (req.temperature !== undefined) {
+    const clamped = Math.min(Math.max(req.temperature, 0), 2);
+    if (clamped !== req.temperature)
+      note("antigravity:temperature-clamped");
+    generationConfig.temperature = clamped;
+  }
+  if (req.stopSequences !== undefined) {
+    generationConfig.stopSequences = req.stopSequences.slice(0, MAX_STOP_SEQUENCES);
+    if (req.stopSequences.length > MAX_STOP_SEQUENCES)
+      note("antigravity:stop-sequences-dropped");
+  }
+  if (req.reasoning !== undefined) {
+    switch (req.reasoning.mode) {
+      case "off":
+        generationConfig.thinkingConfig = { thinkingBudget: 0, includeThoughts: false };
+        break;
+      case "budget":
+        {
+          const asked = req.reasoning.budgetTokens;
+          const budget2 = Math.min(Math.max(asked, -1), MAX_THINKING_BUDGET);
+          if (budget2 !== asked)
+            note("antigravity:thinking-budget-clamped");
+          generationConfig.thinkingConfig = {
+            thinkingBudget: budget2,
+            includeThoughts: budget2 !== 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");
+    const seen = new Set;
+    const named = [];
+    for (const tool of portable) {
+      const name = cloakName2(cloak, tool.name);
+      if (seen.has(name)) {
+        note("antigravity:duplicate-tool-dropped");
+        continue;
+      }
+      seen.add(name);
+      named.push({ name, description: tool.description, inputSchema: tool.inputSchema });
+    }
+    if (cloak !== null && cloak.toWire.size > 0)
+      note("antigravity:tool-name-renamed");
+    if (named.length > 0) {
+      request2.tools = [
+        {
+          functionDeclarations: named.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: pruneSchema(t.inputSchema, note)
+          }))
+        }
+      ];
+    }
+  }
+  if (req.toolChoice !== undefined)
+    request2.toolConfig = encodeToolChoice2(req.toolChoice, cloak);
+  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;
+}
+function cloakOf2(state) {
+  if (state === null || typeof state !== "object")
+    return null;
+  const cloak = state.cloak;
+  if (cloak === null || cloak === undefined || typeof cloak !== "object")
+    return null;
+  const { toWire: toWire2, fromWire } = cloak;
+  return toWire2 instanceof Map && fromWire instanceof Map ? cloak : null;
+}
+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 cloak = buildToolCloak2(input2.request);
+    const { body, degradations } = toAntigravityWire(input2.request, input2.model, {
+      project,
+      requestId,
+      cloak
+    });
+    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)
+      },
+      decodeState: { cloak },
+      degradations,
+      ...cloak === null ? {} : { cloakedTools: cloak.toWire.size }
+    };
+  },
+  decode({ body, decodeState }) {
+    return decodeAntigravityStream(parseSse(body), { cloak: cloakOf2(decodeState) });
+  }
+};
+
+// 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() {
@@ -31506,10 +32891,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",
@@ -31555,7 +32940,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 {
@@ -31571,15 +32956,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()
@@ -31588,7 +32973,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");
   }
@@ -31598,7 +32983,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,
@@ -31620,9 +33005,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);
@@ -31636,19 +33021,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);
   }
 };
 
@@ -31808,9 +33193,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"]);
@@ -31864,7 +33249,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);
@@ -31895,7 +33280,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,
@@ -31950,17 +33335,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)
@@ -31976,13 +33361,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) {
@@ -31998,20 +33595,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,
@@ -32020,22 +33617,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: {
@@ -32093,11 +33690,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");
@@ -32112,17 +33709,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)
@@ -32145,7 +33742,9 @@ function builtinOAuthFlows() {
     ["openai", openaiOAuthFlow],
     ["kimi", kimiOAuthFlow],
     ["kilo", kiloOAuthFlow],
-    ["grok", grokOAuthFlow]
+    ["grok", grokOAuthFlow],
+    ["antigravity", antigravityOAuthFlow],
+    ["muse", museOAuthFlow]
   ];
 }
 // packages/providers/src/custom/decode.ts
@@ -32173,7 +33772,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;
@@ -32195,7 +33794,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)) {
@@ -32353,7 +33952,7 @@ async function* decodeCustomResponses(messages) {
       };
       return;
     }
-    const d = json3(msg.data);
+    const d = json4(msg.data);
     if (d === null)
       continue;
     switch (msg.event) {
@@ -32741,10 +34340,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",
@@ -32778,7 +34377,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;
@@ -32813,7 +34412,7 @@ async function* decodeGrokResponses(messages) {
       };
       return;
     }
-    const d = json4(msg.data);
+    const d = json5(msg.data);
     if (d === null)
       continue;
     switch (msg.event) {
@@ -32916,7 +34515,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,
@@ -32940,9 +34539,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";
@@ -32956,7 +34555,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 = [];
@@ -33049,7 +34648,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");
@@ -33067,7 +34666,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),
@@ -33250,7 +34849,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;
@@ -33272,7 +34871,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)) {
@@ -33372,7 +34971,7 @@ async function* decodeKiloChat(messages) {
 }
 
 // packages/providers/src/kilo/wire.ts
-function encodeToolChoice3(c) {
+function encodeToolChoice4(c) {
   switch (c.type) {
     case "auto":
       return "auto";
@@ -33483,7 +35082,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 };
@@ -33542,7 +35141,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;
@@ -33564,7 +35163,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)) {
@@ -33648,7 +35247,7 @@ async function* decodeChat(messages) {
 }
 
 // packages/providers/src/kimi/wire.ts
-function encodeToolChoice4(c) {
+function encodeToolChoice5(c) {
   switch (c.type) {
     case "auto":
       return "auto";
@@ -33739,7 +35338,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] ?? {});
@@ -33779,8 +35378,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",
@@ -33815,7 +35414,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;
@@ -33823,7 +35422,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;
@@ -33846,12 +35445,12 @@ async function* decodeResponses(messages, options = {}) {
       yield {
         type: "error",
         code: "UPSTREAM",
-        message: `unrecognized OpenAI stream event "${msg.event}"`,
+        message: `unrecognized muse stream event "${msg.event}"`,
         retryable: false
       };
       return;
     }
-    const d = json7(msg.data);
+    const d = json8(msg.data);
     if (d === null)
       continue;
     switch (msg.event) {
@@ -33869,7 +35468,7 @@ async function* decodeResponses(messages, options = {}) {
           yield {
             type: "blockStart",
             index: irIndex(d.output_index ?? 0),
-            block: nativeReasoning ? { type: "providerNative", provider: "openai", blockType: "reasoning", data: {} } : { type: "thinking" }
+            block: nativeReasoning ? { type: "providerNative", provider: "muse", blockType: "reasoning", data: {} } : { type: "thinking" }
           };
         } else if (item.type === "function_call") {
           sawToolCall = true;
@@ -33904,7 +35503,7 @@ async function* decodeResponses(messages, options = {}) {
           index: irIndex(d.output_index ?? 0),
           delta: nativeReasoning ? {
             type: "providerNative",
-            provider: "openai",
+            provider: "muse",
             deltaType: "reasoning_summary_text.delta",
             data: { text: String(d.delta ?? "") }
           } : { type: "thinking", text: String(d.delta ?? "") }
@@ -33930,7 +35529,7 @@ async function* decodeResponses(messages, options = {}) {
               index: irIndex(outputIndex),
               delta: {
                 type: "providerNative",
-                provider: "openai",
+                provider: "muse",
                 deltaType: "response.output_item.done",
                 fold: "merge",
                 data: item
@@ -33955,7 +35554,7 @@ async function* decodeResponses(messages, options = {}) {
           yield {
             type: "error",
             code: "UPSTREAM",
-            message: reason !== undefined ? `unrecognized OpenAI incomplete reason "${String(reason)}"` : r.status !== undefined && r.status !== "incomplete" ? `OpenAI reported terminal response status "${String(r.status)}"` : "OpenAI reported the response incomplete without a reason",
+            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;
@@ -33972,7 +35571,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_CODE3, raw) ? ERROR_CODE3[raw] : undefined) ?? "UPSTREAM";
         yield {
           type: "error",
           code,
@@ -33995,8 +35594,8 @@ async function* decodeResponses(messages, options = {}) {
   }
 }
 
-// packages/providers/src/openai/wire.ts
-import { createHash as createHash4 } from "crypto";
+// 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"]) {
@@ -34008,7 +35607,7 @@ function suppliedKey(req) {
 }
 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 createHash4("sha256").update(stable).digest("hex").slice(0, 32);
+  return createHash5("sha256").update(stable).digest("hex").slice(0, 32);
 }
 function repairOrphanedCalls(input2) {
   const answered = new Set;
@@ -34027,7 +35626,407 @@ function repairOrphanedCalls(input2) {
     input2.splice(i + 1, 0, { type: "function_call_output", call_id: record2.call_id, output: "" });
   }
 }
-function encodeToolChoice5(c) {
+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",
+        message: `unrecognized OpenAI stream event "${msg.event}"`,
+        retryable: false
+      };
+      return;
+    }
+    const d = json9(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: "openai", 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: "openai",
+            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: "openai",
+                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 OpenAI incomplete reason "${String(reason)}"` : r.status !== undefined && r.status !== "incomplete" ? `OpenAI reported terminal response status "${String(r.status)}"` : "OpenAI 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_CODE4, raw) ? ERROR_CODE4[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/openai/wire.ts
+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];
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  return;
+}
+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 createHash6("sha256").update(stable).digest("hex").slice(0, 32);
+}
+function repairOrphanedCalls2(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 encodeToolChoice7(c) {
   switch (c.type) {
     case "auto":
       return "auto";
@@ -34109,7 +36108,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)
@@ -34138,7 +36137,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");
@@ -34147,7 +36146,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 };
@@ -34159,14 +36158,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 {
@@ -34201,6 +36200,8 @@ var ADAPTERS = {
   kimi: kimiAdapter,
   kilo: kiloAdapter,
   grok: grokAdapter,
+  antigravity: antigravityAdapter,
+  muse: museAdapter,
   custom: customAdapter
 };
 Object.setPrototypeOf(ADAPTERS, null);
@@ -35812,7 +37813,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",
@@ -36250,7 +38251,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) {
@@ -36261,7 +38262,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");
@@ -36279,19 +38280,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");
@@ -36302,11 +38303,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");
@@ -36322,13 +38323,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");
@@ -36340,7 +38341,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") {
@@ -37972,13 +39973,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;
@@ -37987,13 +39988,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;
@@ -38006,14 +40007,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));
@@ -38033,13 +40034,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`);
@@ -38809,8 +40810,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);
@@ -44279,7 +46280,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,
@@ -48852,7 +50853,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,
@@ -49125,7 +51126,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,
@@ -50608,12 +52609,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) {
@@ -50702,7 +52703,7 @@ var _Elysia = class _Elysia2 {
       scoped: [...this.standaloneValidator.scoped ?? []],
       global: [...this.standaloneValidator.global ?? []]
     };
-    const isSchema = typeof schemaOrRun == "object", sandbox = (isSchema ? run : schemaOrRun)(instance);
+    const isSchema2 = typeof schemaOrRun == "object", sandbox = (isSchema2 ? run : schemaOrRun)(instance);
     return this.singleton = mergeDeep(this.singleton, instance.singleton), this.definitions = mergeDeep(this.definitions, instance.definitions), sandbox.event.request?.length && (this.event.request = [
       ...this.event.request || [],
       ...sandbox.event.request || []
@@ -50710,7 +52711,7 @@ var _Elysia = class _Elysia2 {
       ...this.event.mapResponse || [],
       ...sandbox.event.mapResponse || []
     ]), this.model(sandbox.definitions.type), Object.values(instance.router.history).forEach(({ method, path, handler, hooks }) => {
-      if (path = (isSchema ? "" : this.config.prefix ?? "") + prefix + path, isSchema) {
+      if (path = (isSchema2 ? "" : this.config.prefix ?? "") + prefix + path, isSchema2) {
         const {
           body: body2,
           headers,
@@ -51575,9 +53576,9 @@ function createLoadRegistry(coord = memoryCoord()) {
     },
     counts() {
       const out = new Map(local);
-      for (const [key, count] of remote) {
-        if (count > (out.get(key) ?? 0))
-          out.set(key, count);
+      for (const [key, count2] of remote) {
+        if (count2 > (out.get(key) ?? 0))
+          out.set(key, count2);
       }
       return out;
     },
@@ -51587,8 +53588,8 @@ function createLoadRegistry(coord = memoryCoord()) {
     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);
+      for (const [key, count2] of held)
+        sample.set(key.slice(PREFIX6.length), count2);
       remote = sample;
     }
   };
@@ -51664,7 +53665,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",
@@ -51761,7 +53762,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,
@@ -51804,7 +53805,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,
@@ -52432,7 +54433,7 @@ function zodDetail(issue2) {
   }
   return issue2.message;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 function extraFields(body2, known) {
@@ -52567,7 +54568,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");
@@ -53807,10 +55808,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;
@@ -54032,12 +56033,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;
   }
 }
@@ -54096,8 +56097,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);
@@ -54421,8 +56422,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;
     }
   }
@@ -54445,12 +56446,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 };
 }
@@ -54470,12 +56471,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;
@@ -55153,8 +57154,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);
@@ -56807,10 +58808,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);
@@ -57105,7 +59106,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()
@@ -57171,7 +59172,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")
@@ -57181,7 +59182,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") {
@@ -57221,7 +59222,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) {
@@ -57277,7 +59278,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`);
   }
@@ -57286,7 +59287,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 : "";
@@ -57299,7 +59300,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;
     }
@@ -57314,10 +59315,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);
     }
   }
@@ -57956,11 +59957,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")
@@ -58166,16 +60167,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();
   };
@@ -58643,7 +60644,7 @@ function createRing(limits) {
 }
 
 // apps/gateway/src/version.ts
-var VERSION = "0.9.2";
+var VERSION = "0.10.1";
 
 // apps/gateway/src/app.ts
 var ADMIN_SESSION_TTL_MS = 12 * 60 * 60 * 1000;
@@ -59397,9 +61398,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") });
     });
@@ -59524,8 +61525,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) {
@@ -60367,9 +62368,9 @@ function createTelemetry(opts) {
     breaker(provider, before, after) {
       if (!opts.metricsEnabled || before === after)
         return;
-      const count = Math.max(0, (openBreakers.get(provider) ?? 0) + (after === "open" ? 1 : before === "open" ? -1 : 0));
-      openBreakers.set(provider, count);
-      registry2.set("omni_breaker_open", { provider }, count);
+      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)