@cortexkit/pi-antigravity-auth 1.0.1 → 2.0.0

package/dist/index.js

@@ -1,1499 +1,10 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// ../core/src/logger.ts
-var ENV_CONSOLE_LOG = "ANTIGRAVITY_CORE_CONSOLE_LOG";
-var _sink = null;
-function isTruthyFlag(flag) {
-  return flag === "1" || flag?.toLowerCase() === "true";
-}
-function isConsoleLogEnabled() {
-  return isTruthyFlag(process.env[ENV_CONSOLE_LOG]);
-}
-function writeConsoleLog(level, ...args) {
-  switch (level) {
-    case "debug":
-      console.debug(...args);
-      break;
-    case "info":
-      console.info(...args);
-      break;
-    case "warn":
-      console.warn(...args);
-      break;
-    case "error":
-      console.error(...args);
-      break;
-  }
-}
-function createLogger(module) {
-  const service = `antigravity.${module}`;
-  const log3 = (level, message, extra) => {
-    if (_sink) {
-      try {
-        _sink({ service, level, message, extra });
-      } catch {
-      }
-    }
-    if (isConsoleLogEnabled()) {
-      const prefix = `[${service}]`;
-      const args = extra ? [prefix, message, extra] : [prefix, message];
-      writeConsoleLog(level, ...args);
-    }
-  };
-  return {
-    debug: (message, extra) => log3("debug", message, extra),
-    info: (message, extra) => log3("info", message, extra),
-    warn: (message, extra) => log3("warn", message, extra),
-    error: (message, extra) => log3("error", message, extra)
-  };
-}
-
-// ../core/src/constants.ts
-var ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
-var ANTIGRAVITY_CLIENT_SECRET = "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";
-var ANTIGRAVITY_SCOPES = [
-  "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"
-];
-var ANTIGRAVITY_REDIRECT_URI = "http://localhost:51121/oauth-callback";
-var ANTIGRAVITY_ENDPOINT_DAILY = "https://daily-cloudcode-pa.googleapis.com";
-var ANTIGRAVITY_ENDPOINT_PROD = "https://cloudcode-pa.googleapis.com";
-var ANTIGRAVITY_ENDPOINT_FALLBACKS = [
-  ANTIGRAVITY_ENDPOINT_DAILY,
-  ANTIGRAVITY_ENDPOINT_PROD
-];
-var ANTIGRAVITY_LOAD_ENDPOINTS = [
-  ANTIGRAVITY_ENDPOINT_DAILY,
-  ANTIGRAVITY_ENDPOINT_PROD
-];
-var ANTIGRAVITY_ENDPOINT = ANTIGRAVITY_ENDPOINT_DAILY;
-var ANTIGRAVITY_DEFAULT_PROJECT_ID = "rising-fact-p41fc";
-var ANTIGRAVITY_VERSION_FALLBACK = "1.18.3";
-var ANTIGRAVITY_VERSION = ANTIGRAVITY_VERSION_FALLBACK;
-var ANTIGRAVITY_HEADERS = {
-  "User-Agent": `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Antigravity/${ANTIGRAVITY_VERSION} Chrome/138.0.7204.235 Electron/37.3.1 Safari/537.36`,
-  "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
-  "Client-Metadata": `{"ideType":"ANTIGRAVITY","platform":"${process.platform === "win32" ? "WINDOWS" : "MACOS"}","pluginType":"GEMINI"}`
-};
-var GEMINI_CLI_HEADERS = {
-  "User-Agent": "google-api-nodejs-client/9.15.1",
-  "X-Goog-Api-Client": "gl-node/22.17.0",
-  "Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI"
-};
-
-// ../core/src/auth.ts
-var ACCESS_TOKEN_EXPIRY_BUFFER_MS = 60 * 1e3;
-function parseRefreshParts(refresh) {
-  const [refreshToken = "", projectId = "", managedProjectId = ""] = (refresh ?? "").split("|");
-  return {
-    refreshToken,
-    projectId: projectId || void 0,
-    managedProjectId: managedProjectId || void 0
-  };
-}
-function formatRefreshParts(parts) {
-  const projectSegment = parts.projectId ?? "";
-  const base = `${parts.refreshToken}|${projectSegment}`;
-  return parts.managedProjectId ? `${base}|${parts.managedProjectId}` : base;
-}
-function calculateTokenExpiry(requestTimeMs, expiresInSeconds) {
-  const seconds = typeof expiresInSeconds === "number" ? expiresInSeconds : 3600;
-  if (isNaN(seconds) || seconds <= 0) {
-    return requestTimeMs;
-  }
-  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";
-import { Buffer as Buffer2 } from "node:buffer";
-import { PassThrough, Readable, Transform } from "node:stream";
-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;
-  const normalized = new Headers(headers);
-  normalized.forEach((value, key) => {
-    result[key.toLowerCase()] = value;
-  });
-  return result;
-}
-function getHeader(headers, name) {
-  return headers[name.toLowerCase()];
-}
-function bodyToBuffer(body) {
-  if (body == null) return Buffer2.alloc(0);
-  if (typeof body === "string") return Buffer2.from(body);
-  if (body instanceof Uint8Array) return Buffer2.from(body);
-  if (body instanceof ArrayBuffer) return Buffer2.from(body);
-  throw new Error("agy transport only supports string/byte request bodies");
-}
-function shouldUseChunkedBody(url) {
-  return url.pathname.includes(":streamGenerateContent");
-}
-function buildAgyCliHeaderPairs(url, init = {}) {
-  const parsedUrl = new URL(url);
-  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 authorization = getHeader(headers, "Authorization");
-  const contentType = getHeader(headers, "Content-Type") ?? "application/json";
-  const acceptEncoding = getHeader(headers, "Accept-Encoding") ?? "gzip";
-  const chunked = shouldUseChunkedBody(parsedUrl);
-  const pairs = [
-    ["Host", host],
-    ["User-Agent", userAgent]
-  ];
-  if (chunked) {
-    pairs.push(["Transfer-Encoding", "chunked"]);
-  } else {
-    pairs.push(["Content-Length", String(body.byteLength)]);
-  }
-  if (authorization) {
-    pairs.push(["Authorization", authorization]);
-  }
-  pairs.push(["Content-Type", contentType]);
-  pairs.push(["Accept-Encoding", acceptEncoding]);
-  return pairs;
-}
-function noProxyIncludes(hostname) {
-  const raw = process.env.NO_PROXY || process.env.no_proxy || "";
-  if (!raw) return false;
-  const host = hostname.toLowerCase();
-  return raw.split(",").map((entry) => entry.trim().toLowerCase()).some((entry) => {
-    if (!entry) return false;
-    if (entry === "*") return true;
-    if (entry.startsWith(".")) return host.endsWith(entry);
-    return host === entry || host.endsWith(`.${entry}`);
-  });
-}
-function getHttpsProxy(url) {
-  if (url.protocol !== "https:" || noProxyIncludes(url.hostname)) return void 0;
-  const rawProxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.ALL_PROXY || process.env.all_proxy;
-  if (!rawProxy) return void 0;
-  try {
-    return new URL(rawProxy);
-  } catch {
-    return void 0;
-  }
-}
-function waitForHead(socket, timeoutMs, onTimeout) {
-  return new Promise((resolve, reject) => {
-    let buffer = Buffer2.alloc(0);
-    const timeout = setTimeout(() => {
-      onTimeout();
-      cleanup(() => reject(new Error(`Antigravity request timed out waiting for response headers after ${timeoutMs}ms`)));
-    }, timeoutMs);
-    const cleanup = (finish) => {
-      socket.off("data", onData);
-      socket.off("error", onError);
-      clearTimeout(timeout);
-      finish();
-    };
-    const onError = (error) => cleanup(() => reject(error));
-    const onData = (chunk) => {
-      buffer = Buffer2.concat([buffer, chunk]);
-      const marker = buffer.indexOf("\r\n\r\n");
-      if (marker === -1) return;
-      const head = buffer.subarray(0, marker).toString("latin1");
-      const leftover = buffer.subarray(marker + 4);
-      cleanup(() => resolve({ head, leftover }));
-    };
-    socket.on("data", onData);
-    socket.once("error", onError);
-  });
-}
-async function connectViaProxy(proxyUrl, targetUrl, timeoutMs, onDebug) {
-  const proxySocket = net.connect({
-    host: proxyUrl.hostname,
-    port: Number(proxyUrl.port || DEFAULT_PROXY_PORT)
-  });
-  await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      onDebug?.(`agy transport proxy connect timeout after ${timeoutMs}ms`);
-      proxySocket.destroy();
-      reject(new Error(`Antigravity request timed out connecting to HTTPS proxy after ${timeoutMs}ms`));
-    }, timeoutMs);
-    const cleanup = () => clearTimeout(timeout);
-    proxySocket.once("connect", () => {
-      cleanup();
-      resolve();
-    });
-    proxySocket.once("error", (error) => {
-      cleanup();
-      reject(error);
-    });
-  });
-  const targetHost = targetUrl.hostname;
-  const targetPort = Number(targetUrl.port || DEFAULT_HTTPS_PORT);
-  const auth = proxyUrl.username ? `Proxy-Authorization: Basic ${Buffer2.from(`${decodeURIComponent(proxyUrl.username)}:${decodeURIComponent(proxyUrl.password)}`).toString("base64")}\r
-` : "";
-  proxySocket.write(
-    `CONNECT ${targetHost}:${targetPort} HTTP/1.1\r
-Host: ${targetHost}:${targetPort}\r
-` + auth + "\r\n"
-  );
-  const { head, leftover } = await waitForHead(proxySocket, timeoutMs, () => {
-    onDebug?.(`agy transport proxy CONNECT response timeout after ${timeoutMs}ms`);
-    proxySocket.destroy();
-  });
-  if (!/^HTTP\/1\.[01] 2\d\d\b/.test(head)) {
-    proxySocket.destroy();
-    throw new Error(`Proxy CONNECT failed: ${head.split("\r\n")[0] ?? "unknown"}`);
-  }
-  if (leftover.length > 0) {
-    proxySocket.unshift(leftover);
-  }
-  return await new Promise((resolve, reject) => {
-    const tlsSocket = tls.connect({ socket: proxySocket, servername: targetHost });
-    const timeout = setTimeout(() => {
-      onDebug?.(`agy transport proxy TLS handshake timeout after ${timeoutMs}ms`);
-      tlsSocket.destroy();
-      reject(new Error(`Antigravity request timed out during proxy TLS handshake after ${timeoutMs}ms`));
-    }, timeoutMs);
-    const cleanup = () => clearTimeout(timeout);
-    tlsSocket.once("secureConnect", () => {
-      cleanup();
-      resolve(tlsSocket);
-    });
-    tlsSocket.once("error", (error) => {
-      cleanup();
-      reject(error);
-    });
-  });
-}
-async function connectDirect(targetUrl, timeoutMs, onDebug) {
-  return await new Promise((resolve, reject) => {
-    const socket = tls.connect({
-      host: targetUrl.hostname,
-      port: Number(targetUrl.port || DEFAULT_HTTPS_PORT),
-      servername: targetUrl.hostname
-    });
-    const timeout = setTimeout(() => {
-      onDebug?.(`agy transport TLS connect timeout after ${timeoutMs}ms`);
-      socket.destroy();
-      reject(new Error(`Antigravity request timed out connecting after ${timeoutMs}ms`));
-    }, timeoutMs);
-    const cleanup = () => clearTimeout(timeout);
-    socket.once("secureConnect", () => {
-      cleanup();
-      resolve(socket);
-    });
-    socket.once("error", (error) => {
-      cleanup();
-      reject(error);
-    });
-  });
-}
-async function connectTls(targetUrl, timeoutMs, onDebug) {
-  const proxyUrl = getHttpsProxy(targetUrl);
-  return proxyUrl ? await connectViaProxy(proxyUrl, targetUrl, timeoutMs, onDebug) : await connectDirect(targetUrl, timeoutMs, onDebug);
-}
-function serializeRequest(url, init, body) {
-  const method = init.method ?? "POST";
-  const path = `${url.pathname}${url.search}`;
-  const headerLines = buildAgyCliHeaderPairs(url.toString(), init).map(([key, value]) => `${key}: ${value}`).join("\r\n");
-  const head = Buffer2.from(`${method} ${path} HTTP/1.1\r
-${headerLines}\r
-\r
-`);
-  if (body.byteLength === 0) {
-    return head;
-  }
-  if (!shouldUseChunkedBody(url)) {
-    return Buffer2.concat([head, body]);
-  }
-  return Buffer2.concat([
-    head,
-    Buffer2.from(`${body.byteLength.toString(16)}\r
-`),
-    body,
-    Buffer2.from("\r\n0\r\n\r\n")
-  ]);
-}
-function parseResponseHead(head) {
-  const lines = head.split("\r\n");
-  const statusLine = lines.shift() ?? "";
-  const match = /^HTTP\/1\.[01]\s+(\d{3})\s*(.*)$/.exec(statusLine);
-  if (!match) {
-    throw new Error(`Invalid HTTP response: ${statusLine}`);
-  }
-  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;
-    const key = line.slice(0, index);
-    const value = line.slice(index + 1).trim();
-    const lowerKey = key.toLowerCase();
-    const lowerValue = value.toLowerCase();
-    if (lowerKey === "transfer-encoding" && lowerValue.includes("chunked")) {
-      chunked = true;
-      continue;
-    }
-    if (lowerKey === "content-encoding" && lowerValue.includes("gzip")) {
-      gzip = true;
-      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);
-  }
-  return {
-    status: Number(match[1]),
-    statusText: match[2] ?? "",
-    headers,
-    chunked,
-    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) {
-    this.buffer = Buffer2.concat([this.buffer, chunk]);
-    try {
-      this.flushAvailableChunks();
-      callback();
-    } catch (error) {
-      callback(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-  _flush(callback) {
-    try {
-      this.flushAvailableChunks();
-      callback();
-    } catch (error) {
-      callback(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-  flushAvailableChunks() {
-    while (true) {
-      const lineEnd = this.buffer.indexOf("\r\n");
-      if (lineEnd === -1) return;
-      const sizeLine = this.buffer.subarray(0, lineEnd).toString("latin1");
-      const sizeText = sizeLine.split(";", 1)[0]?.trim() ?? "";
-      const size = Number.parseInt(sizeText, 16);
-      if (!Number.isFinite(size)) {
-        throw new Error(`Invalid chunk size: ${sizeLine}`);
-      }
-      const chunkStart = lineEnd + 2;
-      const chunkEnd = chunkStart + size;
-      const nextOffset = chunkEnd + 2;
-      if (this.buffer.length < nextOffset) return;
-      if (size === 0) {
-        this.buffer = Buffer2.alloc(0);
-        this.push(null);
-        return;
-      }
-      this.push(this.buffer.subarray(chunkStart, chunkEnd));
-      this.buffer = this.buffer.subarray(nextOffset);
-    }
-  }
-};
-function buildResponseStream(socket, leftover, head, signal, idleTimeoutMs, onDebug) {
-  const source = new PassThrough();
-  if (leftover.length > 0) {
-    source.write(leftover);
-  }
-  socket.pipe(source);
-  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 = () => {
-    clearIdle();
-    socket.off("data", armIdle);
-    signal?.removeEventListener("abort", abort);
-  };
-  if (signal?.aborted) {
-    abort();
-  } else {
-    signal?.addEventListener("abort", abort, { once: true });
-  }
-  responseBody.once("end", () => {
-    cleanup();
-    socket.destroy();
-  });
-  responseBody.once("error", () => {
-    cleanup();
-    socket.destroy();
-  });
-  responseBody.once("close", cleanup);
-  return Readable.toWeb(responseBody);
-}
-async function fetchWithAgyCliTransport(url, init = {}, options = {}) {
-  const parsedUrl = new URL(url);
-  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 connectTlsWithAbort(parsedUrl, timeoutMs, options.signal, options.onDebug);
-  const abort = () => {
-    socket.destroy(new DOMException("The operation was aborted", "AbortError"));
-  };
-  try {
-    options.signal?.addEventListener("abort", abort, { once: true });
-    socket.write(requestBytes);
-    options.onDebug?.(`agy transport request dispatched (${requestBytes.byteLength} bytes)`);
-    const { head, leftover } = await waitForHead(socket, timeoutMs, () => {
-      options.onDebug?.(`agy transport response header timeout after ${timeoutMs}ms`);
-      socket.destroy();
-    });
-    const parsedHead = parseResponseHead(head);
-    options.onDebug?.(`agy transport response headers received: ${parsedHead.status} ${parsedHead.statusText}`);
-    const bodyStream = buildResponseStream(socket, leftover, parsedHead, options.signal, idleTimeoutMs, options.onDebug);
-    return new Response(bodyStream, {
-      status: parsedHead.status,
-      statusText: parsedHead.statusText,
-      headers: parsedHead.headers
-    });
-  } catch (error) {
-    socket.destroy();
-    throw error;
-  } finally {
-    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/project.ts
-var log = createLogger("project");
-var PROJECT_CONTEXT_CACHE_TTL_MS = 30 * 60 * 1e3;
-var projectContextResultCache = /* @__PURE__ */ new Map();
-var projectContextPendingCache = /* @__PURE__ */ new Map();
-var provisionFailedKeys = /* @__PURE__ */ new Set();
-function buildBootstrapRequestBody(extra = {}) {
-  return {
-    ...extra,
-    metadata: buildAntigravityLoadCodeAssistMetadata()
-  };
-}
-function getDefaultTierId(allowedTiers) {
-  if (!allowedTiers || allowedTiers.length === 0) {
-    return void 0;
-  }
-  for (const tier of allowedTiers) {
-    if (tier?.isDefault) {
-      return tier.id;
-    }
-  }
-  return allowedTiers[0]?.id;
-}
-function wait(ms) {
-  return new Promise(function(resolve) {
-    setTimeout(resolve, ms);
-  });
-}
-function extractManagedProjectId(payload) {
-  if (!payload) {
-    return void 0;
-  }
-  if (typeof payload.cloudaicompanionProject === "string") {
-    return payload.cloudaicompanionProject;
-  }
-  if (payload.cloudaicompanionProject && typeof payload.cloudaicompanionProject.id === "string") {
-    return payload.cloudaicompanionProject.id;
-  }
-  return void 0;
-}
-function getCacheKey(auth) {
-  const refresh = auth.refresh?.trim();
-  return refresh ? refresh : void 0;
-}
-async function loadManagedProject(accessToken, _projectId) {
-  const requestBody = buildBootstrapRequestBody();
-  const loadHeaders = buildAntigravityHarnessBootstrapHeaders(accessToken);
-  const loadEndpoints = Array.from(
-    /* @__PURE__ */ new Set([...ANTIGRAVITY_LOAD_ENDPOINTS, ...ANTIGRAVITY_ENDPOINT_FALLBACKS])
-  );
-  for (const baseEndpoint of loadEndpoints) {
-    try {
-      const response = await fetchWithAgyCliTransport(
-        `${baseEndpoint}/v1internal:loadCodeAssist`,
-        {
-          method: "POST",
-          headers: loadHeaders,
-          body: JSON.stringify(requestBody)
-        }
-      );
-      if (!response.ok) {
-        continue;
-      }
-      return await response.json();
-    } catch (error) {
-      log.debug("Failed to load managed project", { endpoint: baseEndpoint, error: String(error) });
-      continue;
-    }
-  }
-  return null;
-}
-async function onboardManagedProject(accessToken, tierId, projectId, attempts = 10, delayMs = 5e3) {
-  const requestBody = { tierId };
-  const onboardEndpoints = Array.from(
-    /* @__PURE__ */ new Set([ANTIGRAVITY_ENDPOINT_PROD, ...ANTIGRAVITY_LOAD_ENDPOINTS, ...ANTIGRAVITY_ENDPOINT_FALLBACKS])
-  );
-  for (const baseEndpoint of onboardEndpoints) {
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-      try {
-        const response = await fetchWithAgyCliTransport(
-          `${baseEndpoint}/v1internal:onboardUser`,
-          {
-            method: "POST",
-            headers: buildAntigravityHarnessBootstrapHeaders(accessToken),
-            body: JSON.stringify(requestBody)
-          }
-        );
-        if (!response.ok) {
-          log.debug("Onboard request failed", {
-            endpoint: baseEndpoint,
-            status: response.status,
-            statusText: response.statusText
-          });
-          break;
-        }
-        const payload = await response.json();
-        const managedProjectId = payload.response?.cloudaicompanionProject?.id;
-        if (payload.done && managedProjectId) {
-          return managedProjectId;
-        }
-        if (payload.done && projectId) {
-          return projectId;
-        }
-      } catch (error) {
-        log.debug("Failed to onboard managed project", { endpoint: baseEndpoint, error: String(error) });
-        break;
-      }
-      await wait(delayMs);
-    }
-  }
-  return void 0;
-}
-async function ensureProjectContext(auth) {
-  const accessToken = auth.access;
-  if (!accessToken) {
-    return { auth, effectiveProjectId: "" };
-  }
-  const cacheKey = getCacheKey(auth);
-  if (cacheKey) {
-    const cached = projectContextResultCache.get(cacheKey);
-    if (cached && Date.now() - cached.cachedAt < PROJECT_CONTEXT_CACHE_TTL_MS) {
-      return cached.result;
-    }
-    if (cached) {
-      projectContextResultCache.delete(cacheKey);
-    }
-    const pending = projectContextPendingCache.get(cacheKey);
-    if (pending) {
-      return pending;
-    }
-  }
-  const resolveContext = async () => {
-    const parts = parseRefreshParts(auth.refresh);
-    if (parts.managedProjectId) {
-      return { auth, effectiveProjectId: parts.managedProjectId };
-    }
-    const fallbackProjectId = ANTIGRAVITY_DEFAULT_PROJECT_ID;
-    if (cacheKey && provisionFailedKeys.has(cacheKey)) {
-      const effectiveProjectId = parts.projectId || fallbackProjectId;
-      return { auth, effectiveProjectId };
-    }
-    const persistManagedProject = async (managedProjectId) => {
-      const updatedAuth = {
-        ...auth,
-        refresh: formatRefreshParts({
-          refreshToken: parts.refreshToken,
-          projectId: parts.projectId,
-          managedProjectId
-        })
-      };
-      return { auth: updatedAuth, effectiveProjectId: managedProjectId };
-    };
-    const loadPayload = await loadManagedProject(accessToken, parts.projectId ?? fallbackProjectId);
-    const resolvedManagedProjectId = extractManagedProjectId(loadPayload);
-    if (resolvedManagedProjectId) {
-      return persistManagedProject(resolvedManagedProjectId);
-    }
-    const tierId = getDefaultTierId(loadPayload?.allowedTiers) ?? "free-tier";
-    log.debug("Auto-provisioning managed project", { tierId, projectId: parts.projectId });
-    const provisionedProjectId = await onboardManagedProject(
-      accessToken,
-      tierId,
-      parts.projectId
-    );
-    if (provisionedProjectId) {
-      log.debug("Successfully provisioned managed project", { provisionedProjectId });
-      return persistManagedProject(provisionedProjectId);
-    }
-    log.warn("Failed to provision managed project - account may not work correctly", {
-      hasProjectId: !!parts.projectId
-    });
-    if (cacheKey) {
-      provisionFailedKeys.add(cacheKey);
-    }
-    if (parts.projectId) {
-      return { auth, effectiveProjectId: parts.projectId };
-    }
-    return { auth, effectiveProjectId: fallbackProjectId };
-  };
-  if (!cacheKey) {
-    return resolveContext();
-  }
-  const promise = resolveContext().then((result) => {
-    const nextKey = getCacheKey(result.auth) ?? cacheKey;
-    projectContextPendingCache.delete(cacheKey);
-    projectContextResultCache.set(nextKey, { result, cachedAt: Date.now() });
-    if (nextKey !== cacheKey) {
-      projectContextResultCache.delete(cacheKey);
-    }
-    return result;
-  }).catch((error) => {
-    projectContextPendingCache.delete(cacheKey);
-    throw error;
-  });
-  projectContextPendingCache.set(cacheKey, promise);
-  return promise;
-}
-
-// ../core/src/model-registry.ts
-var DEFAULT_MODALITIES = {
-  input: ["text", "image", "pdf"],
-  output: ["text"]
-};
-var MODEL_RELEASE_DATE = "";
-var DEFAULT_COST = { input: 0, output: 0 };
-var DEFAULT_OPTIONS = {};
-function defineModel(id, model) {
-  return {
-    id,
-    release_date: MODEL_RELEASE_DATE,
-    attachment: model.modalities.input.some((modality) => modality !== "text"),
-    temperature: true,
-    tool_call: true,
-    cost: { ...DEFAULT_COST },
-    options: { ...DEFAULT_OPTIONS },
-    ...model
-  };
-}
-var ALL_MODEL_DEFINITIONS = {
-  "antigravity-gemini-3.1-pro": defineModel("antigravity-gemini-3.1-pro", {
-    name: "Gemini 3.1 Pro (Antigravity)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65535 },
-    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,
-    limit: { context: 1048576, output: 65536 },
-    modalities: DEFAULT_MODALITIES,
-    variants: {
-      low: { thinkingLevel: "low" },
-      high: { thinkingLevel: "high" }
-    }
-  }),
-  "antigravity-claude-sonnet-4-6-thinking": defineModel("antigravity-claude-sonnet-4-6-thinking", {
-    name: "Claude Sonnet 4.6 Thinking (Antigravity)",
-    reasoning: true,
-    limit: { context: 25e4, output: 64e3 },
-    modalities: DEFAULT_MODALITIES,
-    variants: {
-      low: { disabled: true },
-      high: { disabled: true }
-    }
-  }),
-  "antigravity-claude-opus-4-6-thinking": defineModel("antigravity-claude-opus-4-6-thinking", {
-    name: "Claude Opus 4.6 Thinking (Antigravity)",
-    reasoning: true,
-    limit: { context: 25e4, output: 64e3 },
-    modalities: DEFAULT_MODALITIES,
-    variants: {
-      low: { disabled: true },
-      high: { disabled: true }
-    }
-  }),
-  "antigravity-gemini-3.1-flash-image": defineModel("antigravity-gemini-3.1-flash-image", {
-    name: "Gemini 3.1 Flash Image (Antigravity)",
-    reasoning: false,
-    limit: { context: 66e3, output: 33e3 },
-    modalities: {
-      input: ["text", "image"],
-      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: {}
-    }
-  }),
-  "gemini-2.5-flash": defineModel("gemini-2.5-flash", {
-    name: "Gemini 2.5 Flash (Gemini CLI)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65536 },
-    modalities: DEFAULT_MODALITIES
-  }),
-  "gemini-2.5-pro": defineModel("gemini-2.5-pro", {
-    name: "Gemini 2.5 Pro (Gemini CLI)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65536 },
-    modalities: DEFAULT_MODALITIES
-  }),
-  "gemini-3-flash-preview": defineModel("gemini-3-flash-preview", {
-    name: "Gemini 3 Flash Preview (Gemini CLI)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65536 },
-    modalities: DEFAULT_MODALITIES
-  }),
-  "gemini-3.1-pro-preview": defineModel("gemini-3.1-pro-preview", {
-    name: "Gemini 3.1 Pro Preview (Gemini CLI)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65535 },
-    modalities: DEFAULT_MODALITIES
-  }),
-  "gemini-3.5-flash-preview": defineModel("gemini-3.5-flash-preview", {
-    name: "Gemini 3.5 Flash Preview (Gemini CLI)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65536 },
-    modalities: DEFAULT_MODALITIES
-  }),
-  "gemini-3.1-flash-image": defineModel("gemini-3.1-flash-image", {
-    name: "Gemini 3.1 Flash Image (Gemini CLI)",
-    reasoning: false,
-    limit: { context: 66e3, output: 33e3 },
-    modalities: {
-      input: ["text", "image"],
-      output: ["text", "image"]
-    }
-  }),
-  "gemini-3.1-flash-image-preview": defineModel("gemini-3.1-flash-image-preview", {
-    name: "Gemini 3.1 Flash Image Preview (Gemini CLI)",
-    reasoning: false,
-    limit: { context: 66e3, output: 33e3 },
-    modalities: {
-      input: ["text", "image"],
-      output: ["text", "image"]
-    }
-  }),
-  "gemini-3.1-pro-preview-customtools": defineModel("gemini-3.1-pro-preview-customtools", {
-    name: "Gemini 3.1 Pro Preview Custom Tools (Gemini CLI)",
-    reasoning: true,
-    limit: { context: 1048576, output: 65535 },
-    modalities: DEFAULT_MODALITIES
-  })
-};
-var RESOLVER_ALIASES = {
-  "gemini-3.1-pro-low": "gemini-3.1-pro",
-  "gemini-3.1-pro-high": "gemini-3.1-pro",
-  "gemini-3-flash-low": "gemini-3-flash",
-  "gemini-3-flash-medium": "gemini-3-flash",
-  "gemini-3-flash-high": "gemini-3-flash",
-  "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-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",
-  "gemini-claude-sonnet-4-6-thinking-low": "claude-sonnet-4-6",
-  "gemini-claude-sonnet-4-6-thinking-medium": "claude-sonnet-4-6",
-  "gemini-claude-sonnet-4-6-thinking-high": "claude-sonnet-4-6",
-  "gemini-claude-sonnet-4-6": "claude-sonnet-4-6",
-  "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"
-};
-var GEMINI_35_FLASH_ROUTES = {
-  antigravity: {
-    defaultModel: "gemini-3-flash-agent",
-    byTier: {
-      low: "gemini-3.5-flash-extra-low",
-      medium: "gemini-3.5-flash-low",
-      high: "gemini-3-flash-agent"
-    }
-  },
-  geminiCliFallbackModel: "gemini-3-flash-preview"
-};
-var ANTIGRAVITY_OPENCODE_MODEL_IDS = [
-  "antigravity-gemini-3.5-flash",
-  "antigravity-gemini-3.1-pro",
-  "antigravity-claude-sonnet-4-6-thinking",
-  "antigravity-claude-opus-4-6-thinking"
-];
-function pickModelDefinitions(ids) {
-  return Object.fromEntries(ids.map((id) => [id, ALL_MODEL_DEFINITIONS[id]]));
-}
-var OPENCODE_MODEL_DEFINITIONS = pickModelDefinitions(ANTIGRAVITY_OPENCODE_MODEL_IDS);
-function getPublicModelDefinitions() {
-  return OPENCODE_MODEL_DEFINITIONS;
-}
-function getResolverAliasMap() {
-  return RESOLVER_ALIASES;
-}
-function getGemini35FlashAntigravityModel(tier) {
-  if (!tier) {
-    return GEMINI_35_FLASH_ROUTES.antigravity.defaultModel;
-  }
-  return GEMINI_35_FLASH_ROUTES.antigravity.byTier[tier] ?? GEMINI_35_FLASH_ROUTES.antigravity.defaultModel;
-}
-function getGemini35FlashGeminiCliFallbackModel() {
-  return GEMINI_35_FLASH_ROUTES.geminiCliFallbackModel;
-}
-
-// ../core/src/transform/model-resolver.ts
-var THINKING_TIER_BUDGETS = {
-  claude: { low: 8192, medium: 16384, high: 32768 },
-  "gemini-2.5-pro": { low: 8192, medium: 16384, high: 32768 },
-  "gemini-2.5-flash": { low: 6144, medium: 12288, high: 24576 },
-  default: { low: 4096, medium: 8192, high: 16384 }
-};
-var MODEL_ALIASES = getResolverAliasMap();
-var TIER_REGEX = /-(minimal|low|medium|high)$/;
-var QUOTA_PREFIX_REGEX = /^antigravity-/i;
-var GEMINI_3_PRO_REGEX = /^gemini-3(?:\.\d+)?-pro/i;
-var GEMINI_3_FLASH_REGEX = /^gemini-3(?:\.\d+)?-flash/i;
-var IMAGE_GENERATION_MODELS = /image|imagen/i;
-function supportsThinkingTiers(model) {
-  const lower = model.toLowerCase();
-  return lower.includes("gemini-3") || lower.includes("gemini-2.5") || lower.includes("claude") && lower.includes("thinking");
-}
-function extractThinkingTierFromModel(model) {
-  if (!supportsThinkingTiers(model)) {
-    return void 0;
-  }
-  const tierMatch = model.match(TIER_REGEX);
-  return tierMatch?.[1];
-}
-function getBudgetFamily(model) {
-  if (model.includes("claude")) {
-    return "claude";
-  }
-  if (model.includes("gemini-2.5-pro")) {
-    return "gemini-2.5-pro";
-  }
-  if (model.includes("gemini-2.5-flash")) {
-    return "gemini-2.5-flash";
-  }
-  return "default";
-}
-function isThinkingCapableModel(model) {
-  const lower = model.toLowerCase();
-  return lower.includes("thinking") || lower.includes("gemini-3") || lower.includes("gemini-2.5");
-}
-function isGemini3ProModel(model) {
-  return GEMINI_3_PRO_REGEX.test(model);
-}
-function isGemini3FlashModel(model) {
-  return GEMINI_3_FLASH_REGEX.test(model);
-}
-function isGemini35FlashModel(model) {
-  return /^gemini-3\.5-flash/i.test(model);
-}
-function resolveGemini35FlashAntigravityModel(tier) {
-  return getGemini35FlashAntigravityModel(tier);
-}
-function getAgyGemini35FlashThinkingBudget(tier) {
-  switch (tier) {
-    case "low":
-      return 1e3;
-    case "high":
-      return 1e4;
-    case "medium":
-    default:
-      return 4e3;
-  }
-}
-function getAgyGemini31ProModel(tier) {
-  return tier === "high" ? "gemini-pro-agent" : "gemini-3.1-pro-low";
-}
-function getAgyGemini31ProThinkingBudget(tier) {
-  return tier === "high" ? 10001 : 1001;
-}
-function resolveModelWithTier(requestedModel, options = {}) {
-  const isAntigravity = QUOTA_PREFIX_REGEX.test(requestedModel);
-  const modelWithoutQuota = requestedModel.replace(QUOTA_PREFIX_REGEX, "");
-  const tier = extractThinkingTierFromModel(modelWithoutQuota);
-  const baseName = tier ? modelWithoutQuota.replace(TIER_REGEX, "") : modelWithoutQuota;
-  const isImageModel = IMAGE_GENERATION_MODELS.test(modelWithoutQuota);
-  const isClaudeModel2 = modelWithoutQuota.toLowerCase().includes("claude");
-  const preferGeminiCli = options.cli_first === true && !isAntigravity && !isImageModel && !isClaudeModel2;
-  const quotaPreference = preferGeminiCli ? "gemini-cli" : "antigravity";
-  const explicitQuota = isAntigravity || isImageModel;
-  const isGemini3 = modelWithoutQuota.toLowerCase().startsWith("gemini-3");
-  const skipAlias = isAntigravity && isGemini3;
-  const isGemini3Pro = isGemini3ProModel(modelWithoutQuota);
-  const isGemini3Flash = isGemini3FlashModel(modelWithoutQuota);
-  const isGemini31Pro = /^gemini-3\.1-pro/i.test(baseName);
-  const isGemini35Flash = /^gemini-3\.5-flash/i.test(baseName);
-  if (isGemini31Pro && quotaPreference === "antigravity") {
-    return {
-      actualModel: getAgyGemini31ProModel(tier),
-      thinkingBudget: getAgyGemini31ProThinkingBudget(tier),
-      tier,
-      isThinkingModel: true,
-      quotaPreference,
-      explicitQuota
-    };
-  }
-  if (isGemini35Flash && quotaPreference === "antigravity") {
-    return {
-      actualModel: resolveGemini35FlashAntigravityModel(tier ?? "medium"),
-      thinkingBudget: getAgyGemini35FlashThinkingBudget(tier),
-      tier: tier ?? "medium",
-      isThinkingModel: true,
-      quotaPreference,
-      explicitQuota
-    };
-  }
-  let antigravityModel = modelWithoutQuota;
-  if (skipAlias) {
-    if ((isGemini3Pro || isGemini3Flash) && !tier && !isImageModel) {
-      const defaultTier = isGemini3Pro ? "low" : "medium";
-      antigravityModel = `${modelWithoutQuota}-${defaultTier}`;
-    }
-  }
-  const actualModel = skipAlias ? antigravityModel : MODEL_ALIASES[modelWithoutQuota] || MODEL_ALIASES[baseName] || baseName;
-  const resolvedModel = actualModel;
-  const isThinking = isThinkingCapableModel(resolvedModel);
-  if (isImageModel) {
-    return {
-      actualModel: resolvedModel,
-      isThinkingModel: false,
-      isImageModel: true,
-      quotaPreference,
-      explicitQuota
-    };
-  }
-  const isEffectiveGemini3 = resolvedModel.toLowerCase().includes("gemini-3");
-  const lowerModelWithoutQuota = modelWithoutQuota.toLowerCase();
-  const isClaudeThinking = resolvedModel.toLowerCase().includes("claude") && resolvedModel.toLowerCase().includes("thinking") || lowerModelWithoutQuota.includes("claude") && lowerModelWithoutQuota.includes("thinking") || lowerModelWithoutQuota === "gemini-claude-sonnet-4-6";
-  if (!tier) {
-    if (isEffectiveGemini3) {
-      return {
-        actualModel: resolvedModel,
-        thinkingLevel: isGemini35Flash ? "medium" : "low",
-        isThinkingModel: true,
-        quotaPreference,
-        explicitQuota
-      };
-    }
-    if (isClaudeThinking) {
-      return {
-        actualModel: resolvedModel,
-        thinkingBudget: 1024,
-        isThinkingModel: true,
-        quotaPreference,
-        explicitQuota
-      };
-    }
-    return { actualModel: resolvedModel, isThinkingModel: isThinking, quotaPreference, explicitQuota };
-  }
-  if (isEffectiveGemini3) {
-    return {
-      actualModel: resolvedModel,
-      thinkingLevel: tier,
-      tier,
-      isThinkingModel: true,
-      quotaPreference,
-      explicitQuota
-    };
-  }
-  if (isClaudeThinking) {
-    return {
-      actualModel: resolvedModel,
-      thinkingBudget: 1024,
-      tier,
-      isThinkingModel: true,
-      quotaPreference,
-      explicitQuota
-    };
-  }
-  const budgetFamily = getBudgetFamily(resolvedModel);
-  const budgets = THINKING_TIER_BUDGETS[budgetFamily];
-  const thinkingBudget = budgets[tier];
-  return {
-    actualModel: resolvedModel,
-    thinkingBudget,
-    tier,
-    isThinkingModel: isThinking,
-    quotaPreference,
-    explicitQuota
-  };
-}
-function resolveModelForHeaderStyle(requestedModel, headerStyle) {
-  const lower = requestedModel.toLowerCase();
-  const isGemini3 = lower.includes("gemini-3");
-  if (!isGemini3) {
-    return resolveModelWithTier(requestedModel);
-  }
-  if (headerStyle === "antigravity") {
-    let transformedModel = requestedModel.replace(/-preview-customtools$/i, "").replace(/-preview$/i, "").replace(/^antigravity-/i, "");
-    const isGemini3Pro = isGemini3ProModel(transformedModel);
-    const isGemini3Flash = isGemini3FlashModel(transformedModel);
-    const hasTierSuffix = /-(minimal|low|medium|high)$/i.test(transformedModel);
-    const isImageModel = IMAGE_GENERATION_MODELS.test(transformedModel);
-    const isGemini35Flash = isGemini35FlashModel(transformedModel.replace(TIER_REGEX, ""));
-    if ((isGemini3Pro || isGemini3Flash) && !isGemini35Flash && !hasTierSuffix && !isImageModel) {
-      const defaultTier = isGemini3Pro ? "low" : "medium";
-      transformedModel = `${transformedModel}-${defaultTier}`;
-    }
-    const prefixedModel = `antigravity-${transformedModel}`;
-    return resolveModelWithTier(prefixedModel);
-  }
-  if (headerStyle === "gemini-cli") {
-    const requestedTier = extractThinkingTierFromModel(requestedModel.replace(/^antigravity-/i, ""));
-    let transformedModel = requestedModel.replace(/^antigravity-/i, "").replace(/-(minimal|low|medium|high)$/i, "");
-    const hasPreviewSuffix = /-preview($|-)/i.test(transformedModel);
-    const isGemini35Flash = isGemini35FlashModel(transformedModel);
-    if (isGemini35Flash) {
-      transformedModel = getGemini35FlashGeminiCliFallbackModel();
-    } else if (!hasPreviewSuffix) {
-      transformedModel = `${transformedModel}-preview`;
-    }
-    const resolved = resolveModelWithTier(transformedModel, { cli_first: true });
-    return {
-      ...resolved,
-      thinkingLevel: requestedTier ?? resolved.thinkingLevel,
-      tier: requestedTier ?? resolved.tier,
-      quotaPreference: "gemini-cli"
-    };
-  }
-  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"
-]);
-function toGeminiSchema(schema) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-    return schema;
-  }
-  const inputSchema = schema;
-  const result = {};
-  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);
-      }
-      result[key] = props;
-    } else if (key === "items" && typeof value === "object") {
-      result[key] = toGeminiSchema(value);
-    } else if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
-      result[key] = value.map((item) => toGeminiSchema(item));
-    } else if (key === "enum" && Array.isArray(value)) {
-      result[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 (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";
-
-// ../../node_modules/jose/dist/node/esm/lib/buffer_utils.js
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-var MAX_INT32 = 2 ** 32;
-
-// ../../node_modules/jose/dist/node/esm/runtime/base64url.js
-function normalize(input) {
-  let encoded = input;
-  if (encoded instanceof Uint8Array) {
-    encoded = decoder.decode(encoded);
-  }
-  return encoded;
-}
-var encode = (input) => Buffer3.from(input).toString("base64url");
-var decode = (input) => new Uint8Array(Buffer3.from(normalize(input), "base64url"));
-
-// ../../node_modules/jose/dist/node/esm/util/base64url.js
-var base64url_exports = {};
-__export(base64url_exports, {
-  decode: () => decode2,
-  encode: () => encode2
-});
-var encode2 = encode;
-var decode2 = decode;
-
-// ../../node_modules/@openauthjs/openauth/dist/esm/pkce.js
-function generateVerifier(length) {
-  const buffer = new Uint8Array(length);
-  crypto.getRandomValues(buffer);
-  return base64url_exports.encode(buffer);
-}
-async function generateChallenge(verifier, method) {
-  if (method === "plain")
-    return verifier;
-  const encoder2 = new TextEncoder();
-  const data = encoder2.encode(verifier);
-  const hash = await crypto.subtle.digest("SHA-256", data);
-  return base64url_exports.encode(new Uint8Array(hash));
-}
-async function generatePKCE(length = 64) {
-  if (length < 43 || length > 128) {
-    throw new Error("Code verifier length must be between 43 and 128 characters");
-  }
-  const verifier = generateVerifier(length);
-  const challenge = await generateChallenge(verifier, "S256");
-  return {
-    verifier,
-    challenge,
-    method: "S256"
-  };
-}
-
-// ../core/src/antigravity/oauth.ts
-var log2 = createLogger("oauth");
-async function refreshAntigravityToken(refreshToken) {
-  const startTime = Date.now();
-  const response = await fetch("https://oauth2.googleapis.com/token", {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams({
-      grant_type: "refresh_token",
-      refresh_token: refreshToken,
-      client_id: ANTIGRAVITY_CLIENT_ID,
-      client_secret: ANTIGRAVITY_CLIENT_SECRET
-    })
-  });
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => "");
-    throw new Error(
-      `Antigravity token refresh failed (${response.status} ${response.statusText})${errorText ? ` - ${errorText}` : ""}`
-    );
-  }
-  const payload = await response.json();
-  return {
-    access: payload.access_token,
-    refresh: payload.refresh_token ?? refreshToken,
-    expires: calculateTokenExpiry(startTime, payload.expires_in)
-  };
-}
-function encodeState(payload) {
-  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
-}
-function decodeState(state) {
-  const normalized = state.replace(/-/g, "+").replace(/_/g, "/");
-  const padded = normalized.padEnd(normalized.length + (4 - normalized.length % 4) % 4, "=");
-  const json = Buffer.from(padded, "base64").toString("utf8");
-  const parsed = JSON.parse(json);
-  if (typeof parsed.verifier !== "string") {
-    throw new Error("Missing PKCE verifier in state");
-  }
-  return {
-    verifier: parsed.verifier,
-    projectId: typeof parsed.projectId === "string" ? parsed.projectId : ""
-  };
-}
-async function authorizeAntigravity(projectId = "") {
-  const pkce = await generatePKCE();
-  const url = new URL("https://accounts.google.com/o/oauth2/v2/auth");
-  url.searchParams.set("client_id", ANTIGRAVITY_CLIENT_ID);
-  url.searchParams.set("response_type", "code");
-  url.searchParams.set("redirect_uri", ANTIGRAVITY_REDIRECT_URI);
-  url.searchParams.set("scope", ANTIGRAVITY_SCOPES.join(" "));
-  url.searchParams.set("code_challenge", pkce.challenge);
-  url.searchParams.set("code_challenge_method", "S256");
-  url.searchParams.set(
-    "state",
-    encodeState({ verifier: pkce.verifier, projectId: projectId || "" })
-  );
-  url.searchParams.set("access_type", "offline");
-  url.searchParams.set("prompt", "consent");
-  return {
-    url: url.toString(),
-    verifier: pkce.verifier,
-    projectId: projectId || ""
-  };
-}
-async function fetchProjectID(accessToken) {
-  const errors = [];
-  const loadHeaders = buildAntigravityHarnessBootstrapHeaders(accessToken);
-  const loadEndpoints = Array.from(
-    /* @__PURE__ */ new Set([...ANTIGRAVITY_LOAD_ENDPOINTS, ...ANTIGRAVITY_ENDPOINT_FALLBACKS])
-  );
-  for (const baseEndpoint of loadEndpoints) {
-    try {
-      const url = `${baseEndpoint}/v1internal:loadCodeAssist`;
-      const response = await fetchWithAgyCliTransport(url, {
-        method: "POST",
-        headers: loadHeaders,
-        body: JSON.stringify({ metadata: buildAntigravityLoadCodeAssistMetadata() })
-      }, { timeoutMs: 1e4 });
-      if (!response.ok) {
-        const message = await response.text().catch(() => "");
-        errors.push(
-          `loadCodeAssist ${response.status} at ${baseEndpoint}${message ? `: ${message}` : ""}`
-        );
-        continue;
-      }
-      const data = await response.json();
-      if (typeof data.cloudaicompanionProject === "string" && data.cloudaicompanionProject) {
-        return data.cloudaicompanionProject;
-      }
-      if (data.cloudaicompanionProject && typeof data.cloudaicompanionProject.id === "string" && data.cloudaicompanionProject.id) {
-        return data.cloudaicompanionProject.id;
-      }
-      errors.push(`loadCodeAssist missing project id at ${baseEndpoint}`);
-    } catch (e) {
-      errors.push(
-        `loadCodeAssist error at ${baseEndpoint}: ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-  }
-  if (errors.length) {
-    log2.warn("Failed to resolve Antigravity project via loadCodeAssist", { errors: errors.join("; ") });
-  }
-  return "";
-}
-async function exchangeAntigravity(code, state) {
-  try {
-    const { verifier, projectId } = decodeState(state);
-    const startTime = Date.now();
-    const tokenResponse = await fetch("https://oauth2.googleapis.com/token", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
-        "Accept": "*/*",
-        "Accept-Encoding": "gzip, deflate, br",
-        "User-Agent": GEMINI_CLI_HEADERS["User-Agent"]
-      },
-      body: new URLSearchParams({
-        client_id: ANTIGRAVITY_CLIENT_ID,
-        client_secret: ANTIGRAVITY_CLIENT_SECRET,
-        code,
-        grant_type: "authorization_code",
-        redirect_uri: ANTIGRAVITY_REDIRECT_URI,
-        code_verifier: verifier
-      })
-    });
-    if (!tokenResponse.ok) {
-      const errorText = await tokenResponse.text();
-      return { type: "failed", error: errorText };
-    }
-    const tokenPayload = await tokenResponse.json();
-    const userInfoResponse = await fetch(
-      "https://www.googleapis.com/oauth2/v1/userinfo?alt=json",
-      {
-        headers: {
-          Authorization: `Bearer ${tokenPayload.access_token}`,
-          "User-Agent": GEMINI_CLI_HEADERS["User-Agent"]
-        }
-      }
-    );
-    const userInfo = userInfoResponse.ok ? await userInfoResponse.json() : {};
-    const refreshToken = tokenPayload.refresh_token;
-    if (!refreshToken) {
-      return { type: "failed", error: "Missing refresh token in response" };
-    }
-    let effectiveProjectId = projectId;
-    if (!effectiveProjectId) {
-      effectiveProjectId = await fetchProjectID(tokenPayload.access_token);
-    }
-    const storedRefresh = `${refreshToken}|${effectiveProjectId || ""}`;
-    return {
-      type: "success",
-      refresh: storedRefresh,
-      access: tokenPayload.access_token,
-      expires: calculateTokenExpiry(startTime, tokenPayload.expires_in),
-      email: userInfo.email,
-      projectId: effectiveProjectId || ""
-    };
-  } catch (error) {
-    return {
-      type: "failed",
-      error: error instanceof Error ? error.message : "Unknown error"
-    };
-  }
-}
+// src/index.ts
+import {
+  authorizeAntigravity,
+  exchangeAntigravity,
+  getPublicModelDefinitions,
+  refreshAntigravityToken
+} from "@cortexkit/antigravity-auth-core";
 
 // src/credential-cache.ts
 var packedRefreshByAccessToken = /* @__PURE__ */ new Map();
@@ -1513,12 +24,23 @@ function getPackedRefresh(accessToken) {
 }
 
 // src/stream.ts
+import {
+  AgyRequestSessionStore,
+  ANTIGRAVITY_ENDPOINT,
+  buildAgyAgentRequestMetadata,
+  buildAntigravityHarnessUserAgent,
+  ensureProjectContext,
+  fetchWithAgyCliTransport,
+  orderAgyRequestPayloadInPlace,
+  resolveModelForHeaderStyle
+} from "@cortexkit/antigravity-auth-core";
 import {
   calculateCost,
   createAssistantMessageEventStream
 } from "@earendil-works/pi-ai";
 
 // src/convert.ts
+import { toGeminiSchema } from "@cortexkit/antigravity-auth-core";
 function sanitize(text) {
   return text.replace(/[\uD800-\uDFFF]/gu, "\uFFFD");
 }
@@ -1533,18 +55,30 @@ function convertUserParts(content) {
   }
   return parts;
 }
-function convertAssistantParts(content) {
+function convertAssistantParts(message, preserveSignedHistory) {
   const parts = [];
-  for (const block of content) {
-    if (block.type === "text" && block.text.trim()) {
-      parts.push({ text: sanitize(block.text) });
+  for (const block of message.content) {
+    if (block.type === "thinking") {
+      if (preserveSignedHistory && block.thinking) {
+        parts.push({
+          text: sanitize(block.thinking),
+          thought: true,
+          ...block.thinkingSignature ? { thoughtSignature: block.thinkingSignature } : {}
+        });
+      }
+    } else if (block.type === "text" && block.text.trim()) {
+      parts.push({
+        text: sanitize(block.text),
+        ...preserveSignedHistory && block.textSignature ? { thoughtSignature: block.textSignature } : {}
+      });
     } else if (block.type === "toolCall") {
       parts.push({
         functionCall: {
           name: block.name,
-          args: block.arguments ?? {}
+          args: block.arguments ?? {},
+          id: block.id
         },
-        ...block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}
+        ...preserveSignedHistory && block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}
       });
     }
   }
@@ -1557,32 +91,53 @@ function toolResultResponse(message) {
   }
   return { output: text };
 }
-function convertMessages(messages) {
+function isSameTargetModel(message, options) {
+  if (!options?.provider || !options.model) return true;
+  return message.provider === options.provider && message.model === options.model;
+}
+function convertMessages(messages, options) {
   const contents = [];
+  const callMatchesTarget = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message?.role !== "assistant") continue;
+    const matchesTarget = isSameTargetModel(message, options);
+    for (const block of message.content) {
+      if (block.type === "toolCall") {
+        callMatchesTarget.set(block.id, matchesTarget);
+      }
+    }
+  }
   for (const message of messages) {
     if (!message) continue;
     if (message.role === "user") {
-      const parts = typeof message.content === "string" ? message.content.trim() ? [{ text: sanitize(message.content) }] : [] : convertUserParts(message.content);
+      const parts = typeof message.content === "string" ? message.content.trim() ? [{ text: sanitize(message.content) }] : [] : convertUserParts(
+        message.content
+      );
       if (parts.length) contents.push({ role: "user", parts });
       continue;
     }
     if (message.role === "assistant") {
-      const parts = convertAssistantParts(message.content);
+      const parts = convertAssistantParts(
+        message,
+        isSameTargetModel(message, options)
+      );
       if (parts.length) contents.push({ role: "model", parts });
       continue;
     }
     if (message.role === "toolResult") {
+      const role = callMatchesTarget.get(message.toolCallId) === true ? "model" : "user";
       const part = {
         functionResponse: {
           name: message.toolName,
-          response: toolResultResponse(message)
+          response: toolResultResponse(message),
+          id: message.toolCallId
         }
       };
       const last = contents[contents.length - 1];
-      if (last && last.role === "user" && last.parts.every((p) => "functionResponse" in p)) {
+      if (last && last.role === role && last.parts.every((p) => "functionResponse" in p)) {
         last.parts.push(part);
       } else {
-        contents.push({ role: "user", parts: [part] });
+        contents.push({ role, parts: [part] });
       }
     }
   }
@@ -1603,20 +158,41 @@ function convertTools(tools) {
     }
   ];
 }
-function buildGeminiRequest(context) {
+function buildGeminiRequest(context, options) {
   const request = {
-    contents: convertMessages(context.messages)
+    contents: convertMessages(context.messages, options)
   };
   const tools = convertTools(context.tools);
   if (tools) request.tools = tools;
   if (context.systemPrompt?.trim()) {
-    request.systemInstruction = { parts: [{ text: sanitize(context.systemPrompt) }] };
+    request.systemInstruction = {
+      parts: [{ text: sanitize(context.systemPrompt) }]
+    };
   }
   return request;
 }
 
 // src/stream.ts
 var STREAM_ACTION = "streamGenerateContent";
+var FALLBACK_SESSION_KEY = "__default__";
+var TRAILING_USAGE_TIMEOUT_MS = 1e3;
+var requestSessions = new AgyRequestSessionStore("");
+async function nextWithTimeout(iterator, timeoutMs, onTimeout) {
+  let timer;
+  try {
+    return await Promise.race([
+      iterator.next(),
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          onTimeout();
+          resolve(void 0);
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function mapFinishReason(reason) {
   switch (reason) {
     case "STOP":
@@ -1655,6 +231,21 @@ function unwrapChunk(raw) {
   }
   return raw;
 }
+function convertGeminiToolCallPart(part, state) {
+  if (part.thought && !part.text && part.thoughtSignature) {
+    state.pendingThoughtSignature = part.thoughtSignature;
+  }
+  if (!part.functionCall) return void 0;
+  const thoughtSignature = part.thoughtSignature ?? state.pendingThoughtSignature;
+  state.pendingThoughtSignature = void 0;
+  return {
+    type: "toolCall",
+    id: part.functionCall.id ?? `call_${crypto.randomUUID()}`,
+    name: part.functionCall.name ?? "",
+    arguments: part.functionCall.args ?? {},
+    ...thoughtSignature ? { thoughtSignature } : {}
+  };
+}
 function updateUsage(model, output, usage) {
   if (!usage) return;
   const cacheRead = usage.cachedContentTokenCount ?? output.usage.cacheRead;
@@ -1670,7 +261,7 @@ function updateUsage(model, output, usage) {
 async function* parseGeminiSse(response) {
   if (!response.body) return;
   const reader = response.body.getReader();
-  const decoder2 = new TextDecoder();
+  const decoder = new TextDecoder();
   let buffer = "";
   const parseFrame = function* (frame) {
     for (const line of frame.split("\n")) {
@@ -1687,7 +278,7 @@ async function* parseGeminiSse(response) {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-      buffer += decoder2.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+      buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
       let boundary = buffer.indexOf("\n\n");
       while (boundary !== -1) {
         const frame = buffer.slice(0, boundary);
@@ -1703,11 +294,44 @@ 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,
+    { stepCountMode: "cli" }
+  );
+  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({
@@ -1716,7 +340,10 @@ async function sendAntigravityRequest(options) {
     access: options.accessToken,
     expires: Date.now() + 6e4
   });
-  const request = buildGeminiRequest(options.context);
+  const request = buildGeminiRequest(options.context, {
+    provider: options.model.provider,
+    model: options.model.id
+  });
   const generationConfig = {};
   if (resolved.thinkingLevel) {
     generationConfig.thinkingConfig = {
@@ -1736,9 +363,15 @@ async function sendAntigravityRequest(options) {
   if (Object.keys(generationConfig).length > 0) {
     request.generationConfig = generationConfig;
   }
+  const requestScope = requestSessions.beginRequest(options.sessionKey);
+  const requestId = finalizePiAntigravityRequest(
+    request,
+    wireModel,
+    requestScope
+  );
   const envelope = {
     project: projectContext.effectiveProjectId,
-    requestId: buildRequestId(),
+    requestId,
     request,
     model: wireModel,
     userAgent: "antigravity",
@@ -1757,7 +390,7 @@ async function sendAntigravityRequest(options) {
       },
       body: JSON.stringify(envelope)
     },
-    { signal: options.streamOptions?.signal ?? null }
+    { signal: options.signal ?? options.streamOptions?.signal ?? null }
   );
 }
 function streamCortexKitAntigravity(model, context, options) {
@@ -1767,47 +400,155 @@ function streamCortexKitAntigravity(model, context, options) {
     stream.push({ type: "start", partial: output });
     try {
       const accessToken = options?.apiKey ?? "";
-      if (!accessToken) throw new Error("Missing Antigravity OAuth access token");
+      if (!accessToken)
+        throw new Error("Missing Antigravity OAuth access token");
+      const sessionKey = getRequestSessionKey(context, options);
+      const trailingUsageAbort = new AbortController();
+      const requestSignal = options?.signal ? AbortSignal.any([options.signal, trailingUsageAbort.signal]) : trailingUsageAbort.signal;
       const response = await sendAntigravityRequest({
         model,
         context,
         streamOptions: options,
-        accessToken
+        accessToken,
+        sessionKey,
+        signal: requestSignal
       });
       if (!response.ok) {
-        throw new Error(`Antigravity request failed: HTTP ${response.status} ${await response.text()}`);
+        throw new Error(
+          `Antigravity request failed: HTTP ${response.status} ${await response.text()}`
+        );
       }
       const content = output.content;
+      const toolCallState = {};
       let textIndex = -1;
-      let finished = false;
-      for await (const chunk of parseGeminiSse(response)) {
+      let thinkingIndex = -1;
+      let terminalSeen = false;
+      const closeText = () => {
+        if (textIndex === -1) return;
+        const block = content[textIndex];
+        if (block?.type === "text") {
+          stream.push({
+            type: "text_end",
+            contentIndex: textIndex,
+            content: block.text,
+            partial: output
+          });
+        }
+        textIndex = -1;
+      };
+      const closeThinking = () => {
+        if (thinkingIndex === -1) return;
+        const block = content[thinkingIndex];
+        if (block?.type === "thinking") {
+          stream.push({
+            type: "thinking_end",
+            contentIndex: thinkingIndex,
+            content: block.thinking,
+            partial: output
+          });
+        }
+        thinkingIndex = -1;
+      };
+      const chunkIterator = parseGeminiSse(response)[Symbol.asyncIterator]();
+      while (true) {
+        const next = terminalSeen ? await nextWithTimeout(
+          chunkIterator,
+          TRAILING_USAGE_TIMEOUT_MS,
+          () => trailingUsageAbort.abort()
+        ) : await chunkIterator.next();
+        if (!next) break;
+        if (next.done) break;
+        const chunk = next.value;
         updateUsage(model, output, chunk.usageMetadata);
+        if (terminalSeen) {
+          if (chunk.usageMetadata) break;
+          continue;
+        }
         const candidate = chunk.candidates?.[0];
         const parts = candidate?.content?.parts ?? [];
         for (const part of parts) {
-          if (part.functionCall) {
-            const toolCall = {
-              type: "toolCall",
-              id: `call_${crypto.randomUUID()}`,
-              name: part.functionCall.name ?? "",
-              arguments: part.functionCall.args ?? {},
-              ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
-            };
+          if (!part.thought && !part.functionCall && !part.text && part.thoughtSignature) {
+            const block = textIndex === -1 ? void 0 : content[textIndex];
+            if (block?.type === "text") {
+              block.textSignature = part.thoughtSignature;
+            } else {
+              toolCallState.pendingThoughtSignature = part.thoughtSignature;
+            }
+            continue;
+          }
+          const toolCall = convertGeminiToolCallPart(part, toolCallState);
+          if (toolCall) {
+            closeText();
+            closeThinking();
             content.push(toolCall);
             const idx = content.length - 1;
-            textIndex = -1;
-            stream.push({ type: "toolcall_start", contentIndex: idx, partial: output });
-            stream.push({ type: "toolcall_end", contentIndex: idx, toolCall, partial: output });
+            stream.push({
+              type: "toolcall_start",
+              contentIndex: idx,
+              partial: output
+            });
+            stream.push({
+              type: "toolcall_end",
+              contentIndex: idx,
+              toolCall,
+              partial: output
+            });
             output.stopReason = "toolUse";
-          } else if (typeof part.text === "string" && part.text.length > 0 && !part.thought) {
+            continue;
+          }
+          if (part.thought) {
+            if (typeof part.text !== "string" || part.text.length === 0)
+              continue;
+            closeText();
+            if (thinkingIndex === -1) {
+              content.push({
+                type: "thinking",
+                thinking: "",
+                ...part.thoughtSignature ? { thinkingSignature: part.thoughtSignature } : {}
+              });
+              thinkingIndex = content.length - 1;
+              stream.push({
+                type: "thinking_start",
+                contentIndex: thinkingIndex,
+                partial: output
+              });
+            }
+            const block = content[thinkingIndex];
+            if (block?.type === "thinking") {
+              block.thinking += part.text;
+              if (part.thoughtSignature)
+                block.thinkingSignature = part.thoughtSignature;
+              stream.push({
+                type: "thinking_delta",
+                contentIndex: thinkingIndex,
+                delta: part.text,
+                partial: output
+              });
+            }
+            continue;
+          }
+          if (typeof part.text === "string" && part.text.length > 0) {
+            closeThinking();
             if (textIndex === -1) {
-              content.push({ type: "text", text: "" });
+              const textSignature = part.thoughtSignature ?? toolCallState.pendingThoughtSignature;
+              toolCallState.pendingThoughtSignature = void 0;
+              content.push({
+                type: "text",
+                text: "",
+                ...textSignature ? { textSignature } : {}
+              });
               textIndex = content.length - 1;
-              stream.push({ type: "text_start", contentIndex: textIndex, partial: output });
+              stream.push({
+                type: "text_start",
+                contentIndex: textIndex,
+                partial: output
+              });
             }
             const block = content[textIndex];
-            if (block && block.type === "text") {
+            if (block?.type === "text") {
               block.text += part.text;
+              if (part.thoughtSignature)
+                block.textSignature = part.thoughtSignature;
               stream.push({
                 type: "text_delta",
                 contentIndex: textIndex,
@@ -1818,21 +559,22 @@ function streamCortexKitAntigravity(model, context, options) {
           }
         }
         if (candidate?.finishReason) {
-          if (textIndex !== -1) {
-            const block = content[textIndex];
-            if (block && block.type === "text") {
-              stream.push({ type: "text_end", contentIndex: textIndex, content: block.text, partial: output });
-            }
-            textIndex = -1;
-          }
+          closeText();
+          closeThinking();
           if (output.stopReason !== "toolUse") {
             output.stopReason = mapFinishReason(candidate.finishReason);
           }
-          finished = true;
-          break;
+          terminalSeen = true;
+          const needsTrailingUsage = model.id.toLowerCase().includes("gpt-oss") && !chunk.usageMetadata;
+          if (!needsTrailingUsage) break;
         }
       }
-      if (finished) {
+      if (terminalSeen) {
+        try {
+          await chunkIterator.return?.(void 0);
+        } catch (error) {
+          if (!trailingUsageAbort.signal.aborted) throw error;
+        }
         await response.body?.cancel().catch(() => {
         });
       }
@@ -1842,6 +584,9 @@ function streamCortexKitAntigravity(model, context, options) {
         reason: output.stopReason,
         message: output
       });
+      if (output.stopReason === "stop" || output.stopReason === "length") {
+        requestSessions.completeExecution(sessionKey);
+      }
       stream.end();
     } catch (error) {
       output.stopReason = options?.signal?.aborted ? "aborted" : "error";
@@ -1896,7 +641,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,