omnigateway 0.10.0 → 0.10.2

package/bin/omni.js

@@ -23530,7 +23530,8 @@ var anthropicDescriptor = {
 // packages/providers/src/antigravity/models.ts
 var MAX_OUTPUT_TOKENS = 65536;
 var PRO_MAX_OUTPUT_TOKENS = 65535;
-var FREE = { input: 0, output: 0, cacheRead: 0, cacheWrite5m: 0, cacheWrite1h: 0 };
+var 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 = {
@@ -23540,73 +23541,73 @@ var ANTIGRAVITY_MODELS = {
     {
       id: "gemini-3.8-flash-high",
       label: "Gemini 3.8 Flash (High)",
-      pricing: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      pricing: { input: 1.5, output: 9, cacheRead: 0.15, ...NO_CACHE_WRITE },
       limits: FLASH_LIMITS
     },
     {
@@ -23618,31 +23619,31 @@ var ANTIGRAVITY_MODELS = {
     {
       id: "gemini-3.5-flash-lite",
       label: "Gemini 3.5 Flash Lite",
-      pricing: FREE,
+      pricing: { input: 0.3, output: 2.5, cacheRead: 0.03, ...NO_CACHE_WRITE },
       limits: PRO_LIMITS
     },
     {
-      id: "gemini-3.1-pro-high",
+      id: "gemini-pro-agent",
       label: "Gemini 3.1 Pro (High)",
-      pricing: FREE,
+      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: FREE,
+      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: FREE,
+      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: FREE,
+      pricing: { input: 1.25, output: 10, cacheRead: 0.125, ...NO_CACHE_WRITE },
       limits: PRO_LIMITS
     }
   ]
@@ -23655,13 +23656,13 @@ var antigravityDescriptor = {
   writeOverInput: { fiveMinute: 0, oneHour: 0 },
   catalog: ANTIGRAVITY_MODELS,
   modelPrefixes: ["gemini-"],
-  callback: { uri: "http://127.0.0.1:51121/callback", label: "Antigravity" },
+  callback: { uri: "https://antigravity.google/oauth-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."
+    pasteHint: "Approve in any browser, then paste the whole URL it lands on. A code shown on its own works too."
   }
 };
 
@@ -26205,6 +26206,84 @@ var anthropicOAuthFlow = {
 // 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",
@@ -26239,7 +26318,8 @@ function count(value) {
 function usageOf(meta3) {
   return usageFromPromptTotal(count(meta3?.promptTokenCount), count(meta3?.candidatesTokenCount) + count(meta3?.thoughtsTokenCount), count(meta3?.cachedContentTokenCount));
 }
-async function* decodeAntigravityStream(messages) {
+async function* decodeAntigravityStream(messages, opts = {}) {
+  const cloak = opts.cloak ?? null;
   let started = false;
   let terminal = false;
   let nextIndex = 0;
@@ -26315,7 +26395,7 @@ async function* decodeAntigravityStream(messages) {
           block: {
             type: "toolUse",
             id: typeof call.id === "string" && call.id.length > 0 ? call.id : `fc_${toolCalls}`,
-            name: call.name
+            name: uncloakName2(cloak, call.name)
           }
         };
         yield {
@@ -26407,8 +26487,241 @@ function mergeSameRole(contents) {
   }
   return merged;
 }
+function openingTurn(contents, note2) {
+  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;
+  note2("antigravity:opening-turn-added");
+  return [{ role: "user", parts: [{ text: "" }] }, ...contents];
+}
+function closingTurn(contents, note2) {
+  if (contents[contents.length - 1]?.role !== "model")
+    return contents;
+  note2("antigravity:closing-turn-added");
+  return [...contents, { role: "user", parts: [{ text: " " }] }];
+}
 var hasCacheControl = (block) => ("cacheControl" in block) && block.cacheControl !== undefined;
-function encodeToolChoice2(choice) {
+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, note2, depth = 0) {
+  const out = {};
+  const drop = () => note2(PRUNED);
+  const sub = (v) => {
+    if (!isSchema(v) || depth >= MAX_SCHEMA_DEPTH) {
+      drop();
+      return;
+    }
+    return pruneSchema(v, note2, 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, fields2) => {
+    if (!fields2.some((f) => out[f] !== undefined))
+      return;
+    if (declared === want)
+      return;
+    if (declared === undefined) {
+      out.type = want;
+      return;
+    }
+    drop();
+    for (const f of fields2)
+      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" } };
@@ -26417,10 +26730,16 @@ function encodeToolChoice2(choice) {
     case "none":
       return { functionCallingConfig: { mode: "NONE" } };
     case "tool":
-      return { functionCallingConfig: { mode: "ANY", allowedFunctionNames: [choice.name] } };
+      return {
+        functionCallingConfig: {
+          mode: "ANY",
+          allowedFunctionNames: [cloakName2(cloak, choice.name)]
+        }
+      };
   }
 }
 function toAntigravityWire(req, model, identity) {
+  const cloak = identity.cloak ?? null;
   const degradations = [];
   const note2 = (d) => {
     if (!degradations.includes(d))
@@ -26449,7 +26768,7 @@ function toAntigravityWire(req, model, identity) {
         case "toolUse":
           parts.push({
             thoughtSignature: SIGNATURE_BYPASS,
-            functionCall: { name: block.name, args: block.input }
+            functionCall: { name: cloakName2(cloak, block.name), args: block.input }
           });
           break;
         case "toolResult": {
@@ -26460,7 +26779,7 @@ function toAntigravityWire(req, model, identity) {
             note2("antigravity:tool-result-error-flag-dropped");
           parts.push({
             functionResponse: {
-              name: name ?? block.toolUseId,
+              name: cloakName2(cloak, name ?? block.toolUseId),
               response: { output: block.content }
             }
           });
@@ -26475,28 +26794,47 @@ function toAntigravityWire(req, model, identity) {
     if (parts.length > 0)
       contents.push({ role, parts });
   }
-  const request2 = { contents: mergeSameRole(contents) };
+  const request2 = {
+    contents: closingTurn(openingTurn(mergeSameRole(contents), note2), note2)
+  };
   const system = systemText(req.system, "antigravity", note2);
   if (system !== undefined && system.length > 0) {
     request2.systemInstruction = { parts: [{ text: system }] };
   }
   const generationConfig = {};
-  if (req.maxTokens !== undefined)
-    generationConfig.maxOutputTokens = req.maxTokens;
-  if (req.temperature !== undefined)
-    generationConfig.temperature = req.temperature;
-  if (req.stopSequences !== undefined)
-    generationConfig.stopSequences = req.stopSequences;
+  if (req.maxTokens !== undefined) {
+    if (req.maxTokens > 0)
+      generationConfig.maxOutputTokens = req.maxTokens;
+    else
+      note2("antigravity:max-tokens-dropped");
+  }
+  if (req.temperature !== undefined) {
+    const clamped = Math.min(Math.max(req.temperature, 0), 2);
+    if (clamped !== req.temperature)
+      note2("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)
+      note2("antigravity:stop-sequences-dropped");
+  }
   if (req.reasoning !== undefined) {
     switch (req.reasoning.mode) {
       case "off":
         generationConfig.thinkingConfig = { thinkingBudget: 0, includeThoughts: false };
         break;
       case "budget":
-        generationConfig.thinkingConfig = {
-          thinkingBudget: req.reasoning.budgetTokens,
-          includeThoughts: req.reasoning.budgetTokens !== 0
-        };
+        {
+          const asked = req.reasoning.budgetTokens;
+          const budget2 = Math.min(Math.max(asked, -1), MAX_THINKING_BUDGET);
+          if (budget2 !== asked)
+            note2("antigravity:thinking-budget-clamped");
+          generationConfig.thinkingConfig = {
+            thinkingBudget: budget2,
+            includeThoughts: budget2 !== 0
+          };
+        }
         break;
       case "adaptive":
         generationConfig.thinkingConfig = {
@@ -26525,20 +26863,33 @@ function toAntigravityWire(req, model, identity) {
     const portable = req.tools.filter((t) => t.kind === "portable");
     if (portable.length !== req.tools.length)
       note2("antigravity:provider-tool-dropped");
-    if (portable.length > 0) {
+    const seen = new Set;
+    const named = [];
+    for (const tool of portable) {
+      const name = cloakName2(cloak, tool.name);
+      if (seen.has(name)) {
+        note2("antigravity:duplicate-tool-dropped");
+        continue;
+      }
+      seen.add(name);
+      named.push({ name, description: tool.description, inputSchema: tool.inputSchema });
+    }
+    if (cloak !== null && cloak.toWire.size > 0)
+      note2("antigravity:tool-name-renamed");
+    if (named.length > 0) {
       request2.tools = [
         {
-          functionDeclarations: portable.map((t) => ({
+          functionDeclarations: named.map((t) => ({
             name: t.name,
             description: t.description,
-            parameters: t.inputSchema
+            parameters: pruneSchema(t.inputSchema, note2)
           }))
         }
       ];
     }
   }
   if (req.toolChoice !== undefined)
-    request2.toolConfig = encodeToolChoice2(req.toolChoice);
+    request2.toolConfig = encodeToolChoice2(req.toolChoice, cloak);
   Object.assign(request2, req.vendor?.antigravity ?? {});
   return {
     body: {
@@ -26575,6 +26926,15 @@ function projectOf(input2) {
   }
   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;
@@ -26583,9 +26943,11 @@ var antigravityCodec = {
     }
     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
+      requestId,
+      cloak
     });
     const protocol = [["Authorization", `Bearer ${accessToken}`]];
     const headers = orderHeaders(mergeHeaders(antigravityProfile.headers, protocol), antigravityProfile.order);
@@ -26596,11 +26958,13 @@ var antigravityCodec = {
         headers,
         body: JSON.stringify(body)
       },
-      degradations
+      decodeState: { cloak },
+      degradations,
+      ...cloak === null ? {} : { cloakedTools: cloak.toWire.size }
     };
   },
-  decode({ body }) {
-    return decodeAntigravityStream(parseSse(body));
+  decode({ body, decodeState }) {
+    return decodeAntigravityStream(parseSse(body), { cloak: cloakOf2(decodeState) });
   }
 };
 
@@ -26890,8 +27254,9 @@ function parseAntigravityQuota(value, now) {
 var antigravityOAuthFlow = {
   kind: "pkce",
   supportsManualPaste: true,
-  async* start({ redirectUri, randomState }) {
+  async* start({ redirectUri, randomState, pkce }) {
     const state = randomState();
+    const { verifier, challenge } = pkce();
     const url2 = new URL(AUTHORIZE_URL2);
     url2.searchParams.set("client_id", CLIENT_ID2);
     url2.searchParams.set("response_type", "code");
@@ -26900,9 +27265,11 @@ var antigravityOAuthFlow = {
     url2.searchParams.set("state", state);
     url2.searchParams.set("access_type", "offline");
     url2.searchParams.set("prompt", "consent");
+    url2.searchParams.set("code_challenge", challenge);
+    url2.searchParams.set("code_challenge_method", "S256");
     return {
       authorizeUrl: url2.toString(),
-      pending: { verifier: "", challenge: "", state, redirectUri }
+      pending: { verifier, challenge, state, redirectUri }
     };
   },
   async* exchange({ code, pending, fail, now }) {
@@ -26915,7 +27282,8 @@ var antigravityOAuthFlow = {
       client_id: CLIENT_ID2,
       client_secret: CLIENT_SECRET,
       code: (rawCode ?? "").trim(),
-      redirect_uri: pending.redirectUri
+      redirect_uri: pending.redirectUri,
+      code_verifier: pending.verifier
     }, fail);
     const email3 = yield* readEmail(token.accessToken);
     const { projectId, tier } = yield* bootstrapProject(token.accessToken);
@@ -35375,7 +35743,7 @@ function createServiceDeps(input2) {
 }
 
 // apps/cli/src/version.ts
-var VERSION = "0.10.0";
+var VERSION = "0.10.2";
 
 // apps/cli/src/commands/service.ts
 function gatewayArgv(root) {