@cortexkit/pi-antigravity-auth 1.0.0 → 1.1.0

package/dist/index.js

@@ -52,6 +52,41 @@ function createLogger(module) {
   };
 }
 
+// ../core/src/fingerprint.ts
+var AGY_CLI_VERSION = "1.1.5";
+function normalizeHarnessPlatform(platform = process.platform) {
+  return platform === "win32" ? "windows" : platform || "unknown";
+}
+function normalizeHarnessArch(arch = process.arch) {
+  switch (arch) {
+    case "x64":
+      return "amd64";
+    case "ia32":
+      return "386";
+    default:
+      return arch || "unknown";
+  }
+}
+function buildAntigravityHarnessUserAgent(version = AGY_CLI_VERSION, platform = process.platform, arch = process.arch, authMethod = "consumer") {
+  const osType = normalizeHarnessPlatform(platform);
+  const normalizedArch = normalizeHarnessArch(arch);
+  return `antigravity/cli/${version} (aidev_client; os_type=${osType}; arch=${normalizedArch}; auth_method=${authMethod})`;
+}
+function buildAntigravityHarnessLoadCodeAssistUserAgent(version = AGY_CLI_VERSION) {
+  return buildAntigravityHarnessUserAgent(version);
+}
+function buildAntigravityLoadCodeAssistMetadata() {
+  return { ideType: "ANTIGRAVITY" };
+}
+function buildAntigravityHarnessBootstrapHeaders(accessToken) {
+  return {
+    "User-Agent": buildAntigravityHarnessLoadCodeAssistUserAgent(),
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    "Accept-Encoding": "gzip"
+  };
+}
+
 // ../core/src/constants.ts
 var ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
 var ANTIGRAVITY_CLIENT_SECRET = "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";
@@ -111,42 +146,6 @@ function calculateTokenExpiry(requestTimeMs, expiresInSeconds) {
   return requestTimeMs + seconds * 1e3;
 }
 
-// ../core/src/fingerprint.ts
-var AGY_CLI_VERSION = "1.0.4";
-function normalizeHarnessPlatform(platform = process.platform) {
-  return platform === "win32" ? "windows" : platform || "unknown";
-}
-function normalizeHarnessArch(arch = process.arch) {
-  switch (arch) {
-    case "x64":
-      return "amd64";
-    case "ia32":
-      return "386";
-    default:
-      return arch || "unknown";
-  }
-}
-function buildAntigravityHarnessPlatformArch(platform = process.platform, arch = process.arch) {
-  return `${normalizeHarnessPlatform(platform)}/${normalizeHarnessArch(arch)}`;
-}
-function buildAntigravityHarnessUserAgent(version = AGY_CLI_VERSION, platform = process.platform, arch = process.arch) {
-  return `antigravity/cli/${version} ${buildAntigravityHarnessPlatformArch(platform, arch)}`;
-}
-function buildAntigravityHarnessLoadCodeAssistUserAgent(version = AGY_CLI_VERSION) {
-  return buildAntigravityHarnessUserAgent(version);
-}
-function buildAntigravityLoadCodeAssistMetadata() {
-  return { ideType: "ANTIGRAVITY" };
-}
-function buildAntigravityHarnessBootstrapHeaders(accessToken) {
-  return {
-    "User-Agent": buildAntigravityHarnessLoadCodeAssistUserAgent(),
-    Authorization: `Bearer ${accessToken}`,
-    "Content-Type": "application/json",
-    "Accept-Encoding": "gzip"
-  };
-}
-
 // ../core/src/agy-transport.ts
 import * as net from "node:net";
 import * as tls from "node:tls";
@@ -156,6 +155,7 @@ import { createGunzip } from "node:zlib";
 var DEFAULT_HTTPS_PORT = 443;
 var DEFAULT_PROXY_PORT = 8080;
 var DEFAULT_AGY_RESPONSE_HEADER_TIMEOUT_MS = 18e4;
+var DEFAULT_AGY_IDLE_TIMEOUT_MS = 18e4;
 function headersToRecord(headers) {
   const result = {};
   if (!headers) return result;
@@ -183,7 +183,7 @@ function buildAgyCliHeaderPairs(url, init = {}) {
   const headers = headersToRecord(init.headers);
   const body = bodyToBuffer(init.body);
   const host = parsedUrl.port ? `${parsedUrl.hostname}:${parsedUrl.port}` : parsedUrl.hostname;
-  const userAgent = getHeader(headers, "User-Agent") ?? "antigravity/cli/1.0.4 darwin/arm64";
+  const userAgent = getHeader(headers, "User-Agent") ?? buildAntigravityHarnessUserAgent();
   const authorization = getHeader(headers, "Authorization");
   const contentType = getHeader(headers, "Content-Type") ?? "application/json";
   const acceptEncoding = getHeader(headers, "Accept-Encoding") ?? "gzip";
@@ -369,6 +369,7 @@ function parseResponseHead(head) {
   const headers = new Headers();
   let chunked = false;
   let gzip = false;
+  let contentLength;
   for (const line of lines) {
     const index = line.indexOf(":");
     if (index <= 0) continue;
@@ -384,8 +385,12 @@ function parseResponseHead(head) {
       gzip = true;
       continue;
     }
-    if (gzip && lowerKey === "content-length") {
-      continue;
+    if (lowerKey === "content-length") {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isFinite(parsed) && parsed >= 0) {
+        contentLength = parsed;
+      }
+      if (gzip) continue;
     }
     headers.append(key, value);
   }
@@ -394,9 +399,34 @@ function parseResponseHead(head) {
     statusText: match[2] ?? "",
     headers,
     chunked,
-    gzip
+    gzip,
+    contentLength
   };
 }
+var ContentLengthStream = class extends Transform {
+  remaining;
+  constructor(contentLength) {
+    super();
+    this.remaining = contentLength;
+  }
+  _transform(chunk, _encoding, callback) {
+    if (this.remaining <= 0) {
+      callback();
+      return;
+    }
+    if (chunk.length <= this.remaining) {
+      this.remaining -= chunk.length;
+      this.push(chunk);
+    } else {
+      this.push(chunk.subarray(0, this.remaining));
+      this.remaining = 0;
+    }
+    if (this.remaining <= 0) {
+      this.push(null);
+    }
+    callback();
+  }
+};
 var ChunkedDecodeStream = class extends Transform {
   buffer = Buffer2.alloc(0);
   _transform(chunk, _encoding, callback) {
@@ -440,7 +470,7 @@ var ChunkedDecodeStream = class extends Transform {
     }
   }
 };
-function buildResponseStream(socket, leftover, head, signal) {
+function buildResponseStream(socket, leftover, head, signal, idleTimeoutMs, onDebug) {
   const source = new PassThrough();
   if (leftover.length > 0) {
     source.write(leftover);
@@ -449,12 +479,35 @@ function buildResponseStream(socket, leftover, head, signal) {
   let responseBody = source;
   if (head.chunked) {
     responseBody = responseBody.pipe(new ChunkedDecodeStream());
+  } else if (typeof head.contentLength === "number") {
+    responseBody = responseBody.pipe(new ContentLengthStream(head.contentLength));
   }
   if (head.gzip) {
     responseBody = responseBody.pipe(createGunzip());
   }
+  let idleTimer;
+  const clearIdle = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = void 0;
+    }
+  };
+  const armIdle = () => {
+    if (!idleTimeoutMs || idleTimeoutMs <= 0) return;
+    clearIdle();
+    idleTimer = setTimeout(() => {
+      onDebug?.(`agy transport idle timeout after ${idleTimeoutMs}ms with no body data`);
+      socket.destroy(new Error(`Antigravity response stalled: no data for ${idleTimeoutMs}ms`));
+    }, idleTimeoutMs);
+  };
+  socket.on("data", armIdle);
+  armIdle();
   const abort = () => socket.destroy(new DOMException("The operation was aborted", "AbortError"));
-  const cleanup = () => signal?.removeEventListener("abort", abort);
+  const cleanup = () => {
+    clearIdle();
+    socket.off("data", armIdle);
+    signal?.removeEventListener("abort", abort);
+  };
   if (signal?.aborted) {
     abort();
   } else {
@@ -476,11 +529,15 @@ async function fetchWithAgyCliTransport(url, init = {}, options = {}) {
   if (parsedUrl.protocol !== "https:") {
     throw new Error(`agy transport only supports https URLs: ${url}`);
   }
+  if (options.signal?.aborted) {
+    throw new DOMException("The operation was aborted", "AbortError");
+  }
   const body = bodyToBuffer(init.body);
   const requestBytes = serializeRequest(parsedUrl, init, body);
   const timeoutMs = options.timeoutMs ?? DEFAULT_AGY_RESPONSE_HEADER_TIMEOUT_MS;
+  const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_AGY_IDLE_TIMEOUT_MS;
   options.onDebug?.(`agy transport connecting to ${parsedUrl.hostname} with header timeout ${timeoutMs}ms`);
-  const socket = await connectTls(parsedUrl, timeoutMs, options.onDebug);
+  const socket = await connectTlsWithAbort(parsedUrl, timeoutMs, options.signal, options.onDebug);
   const abort = () => {
     socket.destroy(new DOMException("The operation was aborted", "AbortError"));
   };
@@ -494,7 +551,7 @@ async function fetchWithAgyCliTransport(url, init = {}, options = {}) {
     });
     const parsedHead = parseResponseHead(head);
     options.onDebug?.(`agy transport response headers received: ${parsedHead.status} ${parsedHead.statusText}`);
-    const bodyStream = buildResponseStream(socket, leftover, parsedHead, options.signal);
+    const bodyStream = buildResponseStream(socket, leftover, parsedHead, options.signal, idleTimeoutMs, options.onDebug);
     return new Response(bodyStream, {
       status: parsedHead.status,
       statusText: parsedHead.statusText,
@@ -507,6 +564,198 @@ async function fetchWithAgyCliTransport(url, init = {}, options = {}) {
     options.signal?.removeEventListener("abort", abort);
   }
 }
+async function connectTlsWithAbort(targetUrl, timeoutMs, signal, onDebug) {
+  if (!signal) {
+    return connectTls(targetUrl, timeoutMs, onDebug);
+  }
+  const connectPromise = connectTls(targetUrl, timeoutMs, onDebug);
+  let onAbort;
+  const abortPromise = new Promise((_, reject) => {
+    onAbort = () => reject(new DOMException("The operation was aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([connectPromise, abortPromise]);
+  } catch (error) {
+    void connectPromise.then((socket) => socket.destroy()).catch(() => {
+    });
+    throw error;
+  } finally {
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+
+// ../core/src/agy-request-metadata.ts
+import { Buffer as Buffer3 } from "node:buffer";
+import { randomUUID } from "node:crypto";
+var FNV1A_64_OFFSET_BASIS = 0xcbf29ce484222325n;
+var FNV1A_64_PRIME = 0x100000001b3n;
+var DEFAULT_SESSION_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_MAX_SESSION_STATES = 256;
+var AGY_REQUEST_FIELD_ORDER = [
+  "contents",
+  "systemInstruction",
+  "tools",
+  "toolConfig",
+  "labels",
+  "generationConfig",
+  "sessionId"
+];
+var AGY_MODEL_ENUM_BY_WIRE_MODEL = {
+  "gemini-3.5-flash-extra-low": "MODEL_PLACEHOLDER_M187",
+  "gemini-3.5-flash-low": "MODEL_PLACEHOLDER_M20",
+  "gemini-3-flash-agent": "MODEL_PLACEHOLDER_M84",
+  "gemini-3.6-flash-low": "MODEL_PLACEHOLDER_M266",
+  "gemini-3.6-flash-medium": "MODEL_PLACEHOLDER_M265",
+  "gemini-3.6-flash-high": "MODEL_PLACEHOLDER_M264",
+  "gemini-3.1-pro-low": "MODEL_PLACEHOLDER_M36",
+  "gemini-pro-agent": "MODEL_PLACEHOLDER_M16",
+  "claude-sonnet-4-6": "MODEL_PLACEHOLDER_M35",
+  "claude-opus-4-6-thinking": "MODEL_PLACEHOLDER_M26",
+  "gemini-3.1-flash-image": "MODEL_PLACEHOLDER_M21",
+  "gpt-oss-120b-medium": "MODEL_OPENAI_GPT_OSS_120B_MEDIUM"
+};
+function fnv1a64Signed(input) {
+  let hash = FNV1A_64_OFFSET_BASIS;
+  for (const byte of Buffer3.from(input, "utf8")) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * FNV1A_64_PRIME);
+  }
+  return BigInt.asIntN(64, hash).toString();
+}
+function createAgyRequestSessionContext(workspaceUri, ids = {}) {
+  return {
+    conversationId: ids.conversationId ?? randomUUID(),
+    trajectoryId: ids.trajectoryId ?? randomUUID(),
+    numericSessionId: fnv1a64Signed(workspaceUri)
+  };
+}
+var AgyRequestSessionStore = class {
+  entries = /* @__PURE__ */ new Map();
+  workspaceUri;
+  ttlMs;
+  maxEntries;
+  now;
+  constructor(workspaceUri, options = {}) {
+    this.workspaceUri = workspaceUri;
+    this.ttlMs = options.ttlMs ?? DEFAULT_SESSION_STATE_TTL_MS;
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_SESSION_STATES;
+    this.now = options.now ?? Date.now;
+  }
+  getOrCreate(key) {
+    const timestamp = this.now();
+    this.prune(timestamp, key);
+    const existing = this.entries.get(key);
+    if (existing) {
+      existing.lastAccessedAt = timestamp;
+      return existing.context;
+    }
+    const context = createAgyRequestSessionContext(this.workspaceUri);
+    this.entries.set(key, {
+      context,
+      lastAccessedAt: timestamp,
+      lastRequestTimestamp: 0
+    });
+    return context;
+  }
+  beginRequest(key) {
+    const session = this.getOrCreate(key);
+    const stored = this.entries.get(key);
+    const timestamp = Math.max(stored.lastAccessedAt, stored.lastRequestTimestamp + 1);
+    stored.lastRequestTimestamp = timestamp;
+    return { session, timestamp };
+  }
+  has(key) {
+    return this.entries.has(key);
+  }
+  delete(key) {
+    this.entries.delete(key);
+  }
+  get size() {
+    return this.entries.size;
+  }
+  prune(timestamp, preservedKey) {
+    const expiry = timestamp - this.ttlMs;
+    for (const [key, value] of this.entries) {
+      if (key !== preservedKey && value.lastAccessedAt < expiry) {
+        this.entries.delete(key);
+      }
+    }
+    while (this.entries.size >= this.maxEntries && !this.entries.has(preservedKey)) {
+      let oldestKey = null;
+      let oldestAccess = Number.POSITIVE_INFINITY;
+      for (const [key, value] of this.entries) {
+        if (key !== preservedKey && value.lastAccessedAt < oldestAccess) {
+          oldestKey = key;
+          oldestAccess = value.lastAccessedAt;
+        }
+      }
+      if (!oldestKey) {
+        break;
+      }
+      this.entries.delete(oldestKey);
+    }
+  }
+};
+function getAgyModelEnum(model) {
+  return AGY_MODEL_ENUM_BY_WIRE_MODEL[model.toLowerCase()];
+}
+function orderAgyRequestPayloadInPlace(payload) {
+  const ordered = {};
+  const remaining = new Set(Object.keys(payload));
+  for (const key of AGY_REQUEST_FIELD_ORDER) {
+    if (key in payload) {
+      ordered[key] = payload[key];
+      remaining.delete(key);
+    }
+  }
+  for (const key of remaining) {
+    ordered[key] = payload[key];
+  }
+  for (const key of Object.keys(payload)) {
+    delete payload[key];
+  }
+  Object.assign(payload, ordered);
+}
+function countAgyRequestSteps(payload) {
+  const contents = payload.contents;
+  if (!Array.isArray(contents)) {
+    return 1;
+  }
+  let partCount = 0;
+  for (const content of contents) {
+    if (!content || typeof content !== "object" || Array.isArray(content)) {
+      continue;
+    }
+    const parts = content.parts;
+    if (Array.isArray(parts)) {
+      partCount += parts.length;
+    }
+  }
+  return Math.max(1, partCount);
+}
+function buildAgyAgentRequestMetadata(session, payload, model, timestamp = Date.now()) {
+  const lastStepIndex = countAgyRequestSteps(payload);
+  const isClaude = model.toLowerCase().startsWith("claude-");
+  const isNonGemini = isClaude || model.toLowerCase().startsWith("gpt-");
+  session.usedClaude = session.usedClaude === true || isClaude;
+  session.usedNonGeminiModel = session.usedNonGeminiModel === true || isNonGemini;
+  const modelEnum = getAgyModelEnum(model);
+  const labels = {
+    last_step_index: String(lastStepIndex),
+    ...modelEnum ? { model_enum: modelEnum } : {},
+    trajectory_id: session.trajectoryId,
+    used_claude: session.usedClaude ? "true" : "false",
+    used_claude_conservative: session.usedClaude ? "true" : "false",
+    used_non_gemini_model: session.usedNonGeminiModel ? "true" : "false"
+  };
+  return {
+    requestId: `agent/${session.conversationId}/${timestamp}/${session.trajectoryId}/${lastStepIndex + 1}`,
+    sessionId: session.numericSessionId,
+    labels,
+    lastStepIndex
+  };
+}
 
 // ../core/src/project.ts
 var log = createLogger("project");
@@ -737,6 +986,16 @@ var ALL_MODEL_DEFINITIONS = {
       high: { thinkingLevel: "high" }
     }
   }),
+  "antigravity-gemini-3.6-flash": defineModel("antigravity-gemini-3.6-flash", {
+    name: "Gemini 3.6 Flash (Antigravity)",
+    reasoning: true,
+    limit: { context: 1048576, output: 65536 },
+    modalities: DEFAULT_MODALITIES,
+    variants: {
+      low: { thinkingLevel: "low" },
+      high: { thinkingLevel: "high" }
+    }
+  }),
   "antigravity-gemini-3.5-flash": defineModel("antigravity-gemini-3.5-flash", {
     name: "Gemini 3.5 Flash (Antigravity)",
     reasoning: true,
@@ -776,14 +1035,11 @@ var ALL_MODEL_DEFINITIONS = {
       output: ["text", "image"]
     }
   }),
-  "antigravity-gpt-oss-120b": defineModel("antigravity-gpt-oss-120b", {
-    name: "GPT-OSS 120B (Antigravity)",
-    reasoning: false,
-    limit: { context: 128e3, output: 16384 },
-    modalities: DEFAULT_MODALITIES,
-    variants: {
-      medium: {}
-    }
+  "antigravity-gpt-oss-120b-medium": defineModel("antigravity-gpt-oss-120b-medium", {
+    name: "GPT-OSS 120B Medium (Antigravity)",
+    reasoning: true,
+    limit: { context: 131072, output: 32768 },
+    modalities: DEFAULT_MODALITIES
   }),
   "gemini-2.5-flash": defineModel("gemini-2.5-flash", {
     name: "Gemini 2.5 Flash (Gemini CLI)",
@@ -849,6 +1105,9 @@ var RESOLVER_ALIASES = {
   "gemini-3.5-flash-low": "gemini-3.5-flash",
   "gemini-3.5-flash-medium": "gemini-3.5-flash",
   "gemini-3.5-flash-high": "gemini-3.5-flash",
+  "gemini-3.6-flash-low": "gemini-3.6-flash",
+  "gemini-3.6-flash-medium": "gemini-3.6-flash",
+  "gemini-3.6-flash-high": "gemini-3.6-flash",
   "gemini-claude-opus-4-6-thinking-low": "claude-opus-4-6-thinking",
   "gemini-claude-opus-4-6-thinking-medium": "claude-opus-4-6-thinking",
   "gemini-claude-opus-4-6-thinking-high": "claude-opus-4-6-thinking",
@@ -859,7 +1118,8 @@ var RESOLVER_ALIASES = {
   "claude-sonnet-4-6-thinking": "claude-sonnet-4-6",
   "claude-sonnet-4-6-thinking-low": "claude-sonnet-4-6",
   "claude-sonnet-4-6-thinking-medium": "claude-sonnet-4-6",
-  "claude-sonnet-4-6-thinking-high": "claude-sonnet-4-6"
+  "claude-sonnet-4-6-thinking-high": "claude-sonnet-4-6",
+  "gpt-oss-120b": "gpt-oss-120b-medium"
 };
 var GEMINI_35_FLASH_ROUTES = {
   antigravity: {
@@ -872,11 +1132,22 @@ var GEMINI_35_FLASH_ROUTES = {
   },
   geminiCliFallbackModel: "gemini-3-flash-preview"
 };
+var GEMINI_36_FLASH_ROUTES = {
+  defaultModel: "gemini-3.6-flash-medium",
+  byTier: {
+    low: "gemini-3.6-flash-low",
+    medium: "gemini-3.6-flash-medium",
+    high: "gemini-3.6-flash-high"
+  }
+};
 var ANTIGRAVITY_OPENCODE_MODEL_IDS = [
+  "antigravity-gemini-3.6-flash",
   "antigravity-gemini-3.5-flash",
   "antigravity-gemini-3.1-pro",
   "antigravity-claude-sonnet-4-6-thinking",
-  "antigravity-claude-opus-4-6-thinking"
+  "antigravity-claude-opus-4-6-thinking",
+  "antigravity-gemini-3.1-flash-image",
+  "antigravity-gpt-oss-120b-medium"
 ];
 function pickModelDefinitions(ids) {
   return Object.fromEntries(ids.map((id) => [id, ALL_MODEL_DEFINITIONS[id]]));
@@ -897,6 +1168,12 @@ function getGemini35FlashAntigravityModel(tier) {
 function getGemini35FlashGeminiCliFallbackModel() {
   return GEMINI_35_FLASH_ROUTES.geminiCliFallbackModel;
 }
+function getGemini36FlashAntigravityModel(tier) {
+  if (!tier) {
+    return GEMINI_36_FLASH_ROUTES.defaultModel;
+  }
+  return GEMINI_36_FLASH_ROUTES.byTier[tier] ?? GEMINI_36_FLASH_ROUTES.defaultModel;
+}
 
 // ../core/src/transform/model-resolver.ts
 var THINKING_TIER_BUDGETS = {
@@ -950,7 +1227,7 @@ function isGemini35FlashModel(model) {
 function resolveGemini35FlashAntigravityModel(tier) {
   return getGemini35FlashAntigravityModel(tier);
 }
-function getAgyGemini35FlashThinkingBudget(tier) {
+function getAgyGeminiFlashThinkingBudget(tier) {
   switch (tier) {
     case "low":
       return 1e3;
@@ -983,6 +1260,8 @@ function resolveModelWithTier(requestedModel, options = {}) {
   const isGemini3Flash = isGemini3FlashModel(modelWithoutQuota);
   const isGemini31Pro = /^gemini-3\.1-pro/i.test(baseName);
   const isGemini35Flash = /^gemini-3\.5-flash/i.test(baseName);
+  const isGemini36Flash = /^gemini-3\.6-flash/i.test(baseName);
+  const isGptOss120b = /^gpt-oss-120b(?:-medium)?$/i.test(baseName);
   if (isGemini31Pro && quotaPreference === "antigravity") {
     return {
       actualModel: getAgyGemini31ProModel(tier),
@@ -996,13 +1275,32 @@ function resolveModelWithTier(requestedModel, options = {}) {
   if (isGemini35Flash && quotaPreference === "antigravity") {
     return {
       actualModel: resolveGemini35FlashAntigravityModel(tier ?? "medium"),
-      thinkingBudget: getAgyGemini35FlashThinkingBudget(tier),
+      thinkingBudget: getAgyGeminiFlashThinkingBudget(tier),
+      tier: tier ?? "medium",
+      isThinkingModel: true,
+      quotaPreference,
+      explicitQuota
+    };
+  }
+  if (isGemini36Flash && quotaPreference === "antigravity") {
+    return {
+      actualModel: getGemini36FlashAntigravityModel(tier ?? "medium"),
+      thinkingBudget: getAgyGeminiFlashThinkingBudget(tier),
       tier: tier ?? "medium",
       isThinkingModel: true,
       quotaPreference,
       explicitQuota
     };
   }
+  if (isGptOss120b && quotaPreference === "antigravity") {
+    return {
+      actualModel: "gpt-oss-120b-medium",
+      thinkingBudget: 8192,
+      isThinkingModel: true,
+      quotaPreference,
+      explicitQuota
+    };
+  }
   let antigravityModel = modelWithoutQuota;
   if (skipAlias) {
     if ((isGemini3Pro || isGemini3Flash) && !tier && !isImageModel) {
@@ -1119,8 +1417,108 @@ function resolveModelForHeaderStyle(requestedModel, headerStyle) {
   return resolveModelWithTier(requestedModel);
 }
 
+// ../core/src/transform/gemini.ts
+var UNSUPPORTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+  "additionalProperties",
+  "$schema",
+  "$id",
+  "$comment",
+  "$ref",
+  "$defs",
+  "definitions",
+  "const",
+  "contentMediaType",
+  "contentEncoding",
+  "if",
+  "then",
+  "else",
+  "not",
+  "patternProperties",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "dependentRequired",
+  "dependentSchemas",
+  "propertyNames",
+  "minContains",
+  "maxContains"
+]);
+var NUMERIC_SCHEMA_CONSTRAINTS = /* @__PURE__ */ new Set([
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "minProperties",
+  "maxProperties",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf"
+]);
+function toGeminiSchema(schema, options = {}) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return schema;
+  }
+  const inputSchema = schema;
+  const result = {};
+  const numericConstraintHints = [];
+  const propertyNames = /* @__PURE__ */ new Set();
+  if (inputSchema.properties && typeof inputSchema.properties === "object") {
+    for (const propName of Object.keys(inputSchema.properties)) {
+      propertyNames.add(propName);
+    }
+  }
+  for (const [key, value] of Object.entries(inputSchema)) {
+    if (UNSUPPORTED_SCHEMA_FIELDS.has(key)) {
+      continue;
+    }
+    if (key === "type" && typeof value === "string") {
+      result[key] = value.toUpperCase();
+    } else if (key === "properties" && typeof value === "object" && value !== null) {
+      const props = {};
+      for (const [propName, propSchema] of Object.entries(value)) {
+        props[propName] = toGeminiSchema(propSchema, options);
+      }
+      result[key] = props;
+    } else if (key === "items" && typeof value === "object") {
+      result[key] = toGeminiSchema(value, options);
+    } else if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
+      result[key] = value.map((item) => toGeminiSchema(item, options));
+    } else if (key === "enum" && Array.isArray(value)) {
+      result[key] = value;
+    } else if (options.moveNumericConstraintsToDescription && NUMERIC_SCHEMA_CONSTRAINTS.has(key)) {
+      if (typeof value === "string" || typeof value === "number") {
+        numericConstraintHints.push(`${key}: ${value}`);
+      }
+    } else if (key === "default" || key === "examples") {
+      result[key] = value;
+    } else if (key === "required" && Array.isArray(value)) {
+      if (propertyNames.size > 0) {
+        const validRequired = value.filter(
+          (prop) => typeof prop === "string" && propertyNames.has(prop)
+        );
+        if (validRequired.length > 0) {
+          result[key] = validRequired;
+        }
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  if (numericConstraintHints.length > 0) {
+    const hint = numericConstraintHints.join(", ");
+    result.description = typeof result.description === "string" && result.description ? `${result.description} (${hint})` : hint;
+  }
+  if (result.type === "ARRAY" && !result.items) {
+    result.items = { type: "STRING" };
+  }
+  return result;
+}
+
 // ../../node_modules/jose/dist/node/esm/runtime/base64url.js
-import { Buffer as Buffer3 } from "node:buffer";
+import { Buffer as Buffer4 } from "node:buffer";
 
 // ../../node_modules/jose/dist/node/esm/lib/buffer_utils.js
 var encoder = new TextEncoder();
@@ -1135,8 +1533,8 @@ function normalize(input) {
   }
   return encoded;
 }
-var encode = (input) => Buffer3.from(input).toString("base64url");
-var decode = (input) => new Uint8Array(Buffer3.from(normalize(input), "base64url"));
+var encode = (input) => Buffer4.from(input).toString("base64url");
+var decode = (input) => new Uint8Array(Buffer4.from(normalize(input), "base64url"));
 
 // ../../node_modules/jose/dist/node/esm/util/base64url.js
 var base64url_exports = {};
@@ -1339,6 +1737,23 @@ async function exchangeAntigravity(code, state) {
   }
 }
 
+// src/credential-cache.ts
+var packedRefreshByAccessToken = /* @__PURE__ */ new Map();
+var MAX_ENTRIES = 4;
+function rememberPackedRefresh(accessToken, packedRefresh) {
+  if (!accessToken) return;
+  if (packedRefreshByAccessToken.has(accessToken)) {
+    packedRefreshByAccessToken.delete(accessToken);
+  } else if (packedRefreshByAccessToken.size >= MAX_ENTRIES) {
+    const oldest = packedRefreshByAccessToken.keys().next().value;
+    if (oldest !== void 0) packedRefreshByAccessToken.delete(oldest);
+  }
+  packedRefreshByAccessToken.set(accessToken, packedRefresh);
+}
+function getPackedRefresh(accessToken) {
+  return packedRefreshByAccessToken.get(accessToken);
+}
+
 // src/stream.ts
 import {
   calculateCost,
@@ -1419,10 +1834,13 @@ function convertTools(tools) {
   if (!tools?.length) return void 0;
   return [
     {
+      // Match the agy wire format (MITM-verified): field name is `parameters`
+      // (not `parametersJsonSchema`) and schemas are sanitized to Gemini shape
+      // (UPPERCASE types, unsupported keywords stripped) via core's toGeminiSchema.
       functionDeclarations: tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
-        parametersJsonSchema: tool.parameters
+        parameters: toGeminiSchema(tool.parameters)
       }))
     }
   ];
@@ -1441,6 +1859,8 @@ function buildGeminiRequest(context) {
 
 // src/stream.ts
 var STREAM_ACTION = "streamGenerateContent";
+var FALLBACK_SESSION_KEY = "__default__";
+var requestSessions = new AgyRequestSessionStore("");
 function mapFinishReason(reason) {
   switch (reason) {
     case "STOP":
@@ -1527,15 +1947,45 @@ async function* parseGeminiSse(response) {
     reader.releaseLock();
   }
 }
-function buildRequestId() {
-  return `agent/${crypto.randomUUID()}/${Date.now()}/${crypto.randomUUID()}/2`;
+function getRequestSessionKey(context, options) {
+  if (options?.sessionId) {
+    return options.sessionId;
+  }
+  const firstTimestamp = context.messages[0]?.timestamp;
+  return firstTimestamp !== void 0 ? `message:${firstTimestamp}` : FALLBACK_SESSION_KEY;
+}
+function finalizePiAntigravityRequest(request, wireModel, scope) {
+  if (Array.isArray(request.tools) && request.tools.length > 0) {
+    request.toolConfig = { functionCallingConfig: { mode: "VALIDATED" } };
+  }
+  const metadata = buildAgyAgentRequestMetadata(
+    scope.session,
+    request,
+    wireModel,
+    scope.timestamp
+  );
+  request.labels = metadata.labels;
+  request.sessionId = metadata.sessionId;
+  orderAgyRequestPayloadInPlace(request);
+  return metadata.requestId;
+}
+function resolvePiAntigravityModel(model, reasoning) {
+  const lower = model.id.toLowerCase();
+  const supportsAgyTiers = model.reasoning && (lower.includes("gemini-3") || lower.includes("claude") && lower.includes("thinking"));
+  if (!supportsAgyTiers || !reasoning) {
+    return resolveModelForHeaderStyle(model.id, "antigravity");
+  }
+  const tier = reasoning === "minimal" ? "low" : reasoning === "xhigh" ? "high" : reasoning;
+  const baseModel = model.id.replace(/-(minimal|low|medium|high|xhigh)$/i, "");
+  return resolveModelForHeaderStyle(`${baseModel}-${tier}`, "antigravity");
 }
 async function sendAntigravityRequest(options) {
-  const resolved = resolveModelForHeaderStyle(options.model.id, "antigravity");
+  const resolved = resolvePiAntigravityModel(options.model, options.streamOptions?.reasoning);
   const wireModel = resolved.actualModel;
+  const packedRefresh = getPackedRefresh(options.accessToken) ?? "";
   const projectContext = await ensureProjectContext({
     type: "oauth",
-    refresh: "",
+    refresh: packedRefresh,
     access: options.accessToken,
     expires: Date.now() + 6e4
   });
@@ -1559,9 +2009,13 @@ async function sendAntigravityRequest(options) {
   if (Object.keys(generationConfig).length > 0) {
     request.generationConfig = generationConfig;
   }
+  const requestScope = requestSessions.beginRequest(
+    getRequestSessionKey(options.context, options.streamOptions)
+  );
+  const requestId = finalizePiAntigravityRequest(request, wireModel, requestScope);
   const envelope = {
     project: projectContext.effectiveProjectId,
-    requestId: buildRequestId(),
+    requestId,
     request,
     model: wireModel,
     userAgent: "antigravity",
@@ -1719,7 +2173,7 @@ async function refreshAntigravityCredentials(credentials) {
   };
 }
 function cortexKitPiAntigravityAuth(pi) {
-  const models = Object.values(getPublicModelDefinitions()).map((model) => ({
+  const models = Object.values(getPublicModelDefinitions()).filter((model) => !model.modalities.output.includes("image")).map((model) => ({
     id: model.id,
     name: model.name,
     reasoning: model.reasoning,
@@ -1737,7 +2191,10 @@ function cortexKitPiAntigravityAuth(pi) {
       name: "Google Antigravity (CortexKit)",
       login: loginAntigravity,
       refreshToken: refreshAntigravityCredentials,
-      getApiKey: (credentials) => credentials.access
+      getApiKey: (credentials) => {
+        rememberPackedRefresh(credentials.access, credentials.refresh);
+        return credentials.access;
+      }
     },
     streamSimple: streamCortexKitAntigravity
   });