@cortexkit/pi-antigravity-auth 1.0.0

package/dist/index.js

@@ -0,0 +1,1748 @@
+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;
+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;
+  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 (gzip && lowerKey === "content-length") {
+      continue;
+    }
+    headers.append(key, value);
+  }
+  return {
+    status: Number(match[1]),
+    statusText: match[2] ?? "",
+    headers,
+    chunked,
+    gzip
+  };
+}
+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) {
+  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());
+  }
+  if (head.gzip) {
+    responseBody = responseBody.pipe(createGunzip());
+  }
+  const abort = () => socket.destroy(new DOMException("The operation was aborted", "AbortError"));
+  const cleanup = () => 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}`);
+  }
+  const body = bodyToBuffer(init.body);
+  const requestBytes = serializeRequest(parsedUrl, init, body);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_AGY_RESPONSE_HEADER_TIMEOUT_MS;
+  options.onDebug?.(`agy transport connecting to ${parsedUrl.hostname} with header timeout ${timeoutMs}ms`);
+  const socket = await connectTls(parsedUrl, timeoutMs, 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);
+    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);
+  }
+}
+
+// ../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);
+}
+
+// ../../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/stream.ts
+import {
+  calculateCost,
+  createAssistantMessageEventStream
+} from "@earendil-works/pi-ai";
+
+// src/convert.ts
+function sanitize(text) {
+  return text.replace(/[\uD800-\uDFFF]/gu, "\uFFFD");
+}
+function convertUserParts(content) {
+  const parts = [];
+  for (const item of content) {
+    if (item.type === "text") {
+      if (item.text) parts.push({ text: sanitize(item.text) });
+    } else if (item.type === "image" && item.data) {
+      parts.push({ inlineData: { mimeType: item.mimeType, data: item.data } });
+    }
+  }
+  return parts;
+}
+function convertAssistantParts(content) {
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text.trim()) {
+      parts.push({ text: sanitize(block.text) });
+    } else if (block.type === "toolCall") {
+      parts.push({
+        functionCall: {
+          name: block.name,
+          args: block.arguments ?? {}
+        },
+        ...block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}
+      });
+    }
+  }
+  return parts;
+}
+function toolResultResponse(message) {
+  const text = message.content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+  if (message.isError) {
+    return { error: text || "Error" };
+  }
+  return { output: text };
+}
+function convertMessages(messages) {
+  const contents = [];
+  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);
+      if (parts.length) contents.push({ role: "user", parts });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const parts = convertAssistantParts(message.content);
+      if (parts.length) contents.push({ role: "model", parts });
+      continue;
+    }
+    if (message.role === "toolResult") {
+      const part = {
+        functionResponse: {
+          name: message.toolName,
+          response: toolResultResponse(message)
+        }
+      };
+      const last = contents[contents.length - 1];
+      if (last && last.role === "user" && last.parts.every((p) => "functionResponse" in p)) {
+        last.parts.push(part);
+      } else {
+        contents.push({ role: "user", parts: [part] });
+      }
+    }
+  }
+  return contents;
+}
+function convertTools(tools) {
+  if (!tools?.length) return void 0;
+  return [
+    {
+      functionDeclarations: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parametersJsonSchema: tool.parameters
+      }))
+    }
+  ];
+}
+function buildGeminiRequest(context) {
+  const request = {
+    contents: convertMessages(context.messages)
+  };
+  const tools = convertTools(context.tools);
+  if (tools) request.tools = tools;
+  if (context.systemPrompt?.trim()) {
+    request.systemInstruction = { parts: [{ text: sanitize(context.systemPrompt) }] };
+  }
+  return request;
+}
+
+// src/stream.ts
+var STREAM_ACTION = "streamGenerateContent";
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    default:
+      return reason ? "stop" : "stop";
+  }
+}
+function createOutput(model) {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
+}
+function unwrapChunk(raw) {
+  if (raw && typeof raw === "object" && "response" in raw) {
+    const inner = raw.response;
+    if (inner && typeof inner === "object") {
+      return inner;
+    }
+  }
+  return raw;
+}
+function updateUsage(model, output, usage) {
+  if (!usage) return;
+  const cacheRead = usage.cachedContentTokenCount ?? output.usage.cacheRead;
+  const promptTotal = usage.promptTokenCount ?? output.usage.input + output.usage.cacheRead;
+  output.usage.input = Math.max(0, promptTotal - cacheRead);
+  if (usage.candidatesTokenCount !== void 0 || usage.thoughtsTokenCount !== void 0) {
+    output.usage.output = (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0);
+  }
+  output.usage.cacheRead = cacheRead;
+  output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+  calculateCost(model, output.usage);
+}
+async function* parseGeminiSse(response) {
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder2 = new TextDecoder();
+  let buffer = "";
+  const parseFrame = function* (frame) {
+    for (const line of frame.split("\n")) {
+      if (!line.startsWith("data:")) continue;
+      const data = line.slice(5).trim();
+      if (!data || data === "[DONE]") continue;
+      try {
+        yield unwrapChunk(JSON.parse(data));
+      } catch {
+      }
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder2.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        const frame = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        boundary = buffer.indexOf("\n\n");
+        yield* parseFrame(frame);
+      }
+    }
+    if (buffer.trim()) {
+      yield* parseFrame(buffer);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function buildRequestId() {
+  return `agent/${crypto.randomUUID()}/${Date.now()}/${crypto.randomUUID()}/2`;
+}
+async function sendAntigravityRequest(options) {
+  const resolved = resolveModelForHeaderStyle(options.model.id, "antigravity");
+  const wireModel = resolved.actualModel;
+  const projectContext = await ensureProjectContext({
+    type: "oauth",
+    refresh: "",
+    access: options.accessToken,
+    expires: Date.now() + 6e4
+  });
+  const request = buildGeminiRequest(options.context);
+  const generationConfig = {};
+  if (resolved.thinkingLevel) {
+    generationConfig.thinkingConfig = {
+      includeThoughts: true,
+      thinkingLevel: resolved.thinkingLevel
+    };
+  } else if (typeof resolved.thinkingBudget === "number") {
+    generationConfig.thinkingConfig = {
+      includeThoughts: true,
+      thinkingBudget: resolved.thinkingBudget
+    };
+  }
+  const maxTokens = options.streamOptions?.maxTokens ?? options.model.maxTokens;
+  if (typeof maxTokens === "number") {
+    generationConfig.maxOutputTokens = maxTokens;
+  }
+  if (Object.keys(generationConfig).length > 0) {
+    request.generationConfig = generationConfig;
+  }
+  const envelope = {
+    project: projectContext.effectiveProjectId,
+    requestId: buildRequestId(),
+    request,
+    model: wireModel,
+    userAgent: "antigravity",
+    requestType: "agent"
+  };
+  const url = `${ANTIGRAVITY_ENDPOINT}/v1internal:${STREAM_ACTION}?alt=sse`;
+  return fetchWithAgyCliTransport(
+    url,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${options.accessToken}`,
+        "Content-Type": "application/json",
+        "User-Agent": buildAntigravityHarnessUserAgent(),
+        "Accept-Encoding": "gzip"
+      },
+      body: JSON.stringify(envelope)
+    },
+    { signal: options.streamOptions?.signal ?? null }
+  );
+}
+function streamCortexKitAntigravity(model, context, options) {
+  const stream = createAssistantMessageEventStream();
+  void (async () => {
+    const output = createOutput(model);
+    stream.push({ type: "start", partial: output });
+    try {
+      const accessToken = options?.apiKey ?? "";
+      if (!accessToken) throw new Error("Missing Antigravity OAuth access token");
+      const response = await sendAntigravityRequest({
+        model,
+        context,
+        streamOptions: options,
+        accessToken
+      });
+      if (!response.ok) {
+        throw new Error(`Antigravity request failed: HTTP ${response.status} ${await response.text()}`);
+      }
+      const content = output.content;
+      let textIndex = -1;
+      let finished = false;
+      for await (const chunk of parseGeminiSse(response)) {
+        updateUsage(model, output, chunk.usageMetadata);
+        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 } : {}
+            };
+            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 });
+            output.stopReason = "toolUse";
+          } else if (typeof part.text === "string" && part.text.length > 0 && !part.thought) {
+            if (textIndex === -1) {
+              content.push({ type: "text", text: "" });
+              textIndex = content.length - 1;
+              stream.push({ type: "text_start", contentIndex: textIndex, partial: output });
+            }
+            const block = content[textIndex];
+            if (block && block.type === "text") {
+              block.text += part.text;
+              stream.push({
+                type: "text_delta",
+                contentIndex: textIndex,
+                delta: part.text,
+                partial: output
+              });
+            }
+          }
+        }
+        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;
+          }
+          if (output.stopReason !== "toolUse") {
+            output.stopReason = mapFinishReason(candidate.finishReason);
+          }
+          finished = true;
+          break;
+        }
+      }
+      if (finished) {
+        await response.body?.cancel().catch(() => {
+        });
+      }
+      if (options?.signal?.aborted) throw new Error("Request was aborted");
+      stream.push({
+        type: "done",
+        reason: output.stopReason,
+        message: output
+      });
+      stream.end();
+    } catch (error) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = error instanceof Error ? error.message : String(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    }
+  })();
+  return stream;
+}
+
+// src/index.ts
+var ANTIGRAVITY_PROVIDER_ID = "google-antigravity";
+function textImageInput() {
+  return ["text", "image"];
+}
+async function loginAntigravity(callbacks) {
+  const auth = await authorizeAntigravity();
+  callbacks.onAuth({ url: auth.url });
+  const code = await callbacks.onPrompt({
+    message: "Paste the Antigravity OAuth callback URL or code:"
+  });
+  const authState = new URL(auth.url).searchParams.get("state") ?? "";
+  let rawCode = code.trim();
+  let state = authState;
+  try {
+    const url = new URL(rawCode);
+    const codeParam = url.searchParams.get("code");
+    const stateParam = url.searchParams.get("state");
+    if (codeParam) rawCode = codeParam;
+    if (stateParam) state = stateParam;
+  } catch {
+  }
+  const result = await exchangeAntigravity(rawCode, state);
+  if (result.type !== "success") {
+    throw new Error(`Antigravity OAuth exchange failed: ${result.error}`);
+  }
+  return {
+    refresh: result.refresh,
+    access: result.access,
+    expires: result.expires
+  };
+}
+async function refreshAntigravityCredentials(credentials) {
+  const refreshToken = credentials.refresh.split("|")[0] ?? credentials.refresh;
+  const refreshed = await refreshAntigravityToken(refreshToken);
+  const projectSegments = credentials.refresh.includes("|") ? credentials.refresh.slice(credentials.refresh.indexOf("|")) : "";
+  return {
+    refresh: `${refreshed.refresh}${projectSegments}`,
+    access: refreshed.access,
+    expires: refreshed.expires
+  };
+}
+function cortexKitPiAntigravityAuth(pi) {
+  const models = Object.values(getPublicModelDefinitions()).map((model) => ({
+    id: model.id,
+    name: model.name,
+    reasoning: model.reasoning,
+    input: textImageInput(),
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: model.limit.context,
+    maxTokens: model.limit.output
+  }));
+  pi.registerProvider(ANTIGRAVITY_PROVIDER_ID, {
+    name: "Google Antigravity (CortexKit OAuth)",
+    baseUrl: "https://cloudcode-pa.googleapis.com",
+    api: "google-generative-ai",
+    models,
+    oauth: {
+      name: "Google Antigravity (CortexKit)",
+      login: loginAntigravity,
+      refreshToken: refreshAntigravityCredentials,
+      getApiKey: (credentials) => credentials.access
+    },
+    streamSimple: streamCortexKitAntigravity
+  });
+}
+export {
+  cortexKitPiAntigravityAuth as default
+};
+//# sourceMappingURL=index.js.map