@omnicross/core 0.4.2 → 0.4.4

package/dist/{chunk-C3NPMQTK.js → chunk-JHJRZ75C.js}

@@ -1,6 +1,9 @@
+import {
+  antigravityModelFamily
+} from "./chunk-XBQTVRMK.js";
 import {
   getSharedAccountAllowanceStore
-} from "./chunk-PF7YQBKX.js";
+} from "./chunk-FYPKKMB3.js";
 
 // src/pipeline/AccountAllowanceScheduling.ts
 var DEFAULT_POLICY = {
@@ -30,8 +33,9 @@ function isAccountAllowanceExhaustedError(error) {
   const value = error;
   return value.code === "account_allowance_exhausted" && value.status === 429;
 }
-function freshWorstWindow(snapshot) {
-  return snapshot.windows.filter((window) => window.state === "fresh" && typeof window.usedPercent === "number").sort((left, right) => (right.usedPercent ?? -1) - (left.usedPercent ?? -1))[0];
+function freshWorstWindow(snapshot, resolvedModel) {
+  const family = snapshot.providerId === "antigravity" && resolvedModel ? antigravityModelFamily(resolvedModel) : void 0;
+  return snapshot.windows.filter((window) => window.state === "fresh" && (typeof window.usedPercent === "number" || window.disabled === true) && (!resolvedModel || snapshot.providerId !== "antigravity" || window.scope === "all" || window.modelFamily === family)).map((window) => window.disabled === true ? { ...window, usedPercent: 100 } : window).sort((left, right) => (right.usedPercent ?? -1) - (left.usedPercent ?? -1))[0];
 }
 var AccountAllowanceScheduling = class {
   constructor(store = getSharedAccountAllowanceStore(), now = Date.now) {
@@ -49,8 +53,8 @@ var AccountAllowanceScheduling = class {
   getConfig() {
     return { ...this.config };
   }
-  evaluate(providerId, accountId, basePriority, now = this.now()) {
-    const decision = this.decide(providerId, accountId, basePriority, now);
+  evaluate(providerId, accountId, basePriority, now = this.now(), resolvedModel) {
+    const decision = this.decide(providerId, accountId, basePriority, now, resolvedModel);
     this.recordApplied(decision);
     return decision;
   }
@@ -59,10 +63,10 @@ var AccountAllowanceScheduling = class {
    * Admin/read-model callers use this so polling an account list never creates
    * synthetic demotion/pause history entries.
    */
-  preview(providerId, accountId, basePriority, now = this.now()) {
-    return this.decide(providerId, accountId, basePriority, now);
+  preview(providerId, accountId, basePriority, now = this.now(), resolvedModel) {
+    return this.decide(providerId, accountId, basePriority, now, resolvedModel);
   }
-  decide(providerId, accountId, basePriority, now) {
+  decide(providerId, accountId, basePriority, now, resolvedModel) {
     const decidedAt = new Date(now).toISOString();
     const base = {
       providerId,
@@ -73,12 +77,12 @@ var AccountAllowanceScheduling = class {
       decidedAt
     };
     if (!this.config.enabled) return { ...base, action: "ignore", reason: "policy-disabled" };
-    if (providerId !== "claude" && providerId !== "codex" && providerId !== "kimi" && providerId !== "opencodego" && providerId !== "grok" && providerId !== "copilot") {
+    if (providerId !== "claude" && providerId !== "codex" && providerId !== "kimi" && providerId !== "opencodego" && providerId !== "grok" && providerId !== "copilot" && providerId !== "antigravity") {
       return { ...base, action: "ignore", reason: "provider-unsupported" };
     }
     const snapshot = this.store.get(providerId, accountId, now);
     if (!snapshot) return { ...base, action: "ignore", reason: "snapshot-missing" };
-    const worst = freshWorstWindow(snapshot);
+    const worst = freshWorstWindow(snapshot, resolvedModel);
     if (!worst || worst.usedPercent === null) {
       return { ...base, action: "ignore", reason: "snapshot-not-fresh", observedAt: snapshot.observedAt };
     }

package/dist/chunk-K6J2RIEX.js

@@ -0,0 +1,67 @@
+import {
+  ANTIGRAVITY_ENDPOINT
+} from "./chunk-ZJJBITUN.js";
+
+// src/transformer/transformers/antigravityFailover.ts
+var ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+var sandboxFailoverEnabled = false;
+function setAntigravitySandboxFailover(enabled) {
+  sandboxFailoverEnabled = enabled;
+}
+function isAntigravitySandboxFailoverEnabled() {
+  return sandboxFailoverEnabled;
+}
+function __resetAntigravityFailoverState() {
+  sandboxFailoverEnabled = false;
+}
+function isAntigravityRetryableFailure(status, bodyText) {
+  if (status === null) return true;
+  if (status === 429 || status >= 500) return true;
+  if (status === 400 || status === 404) {
+    const message = (bodyText ?? "").toLowerCase();
+    return message.includes("requested model is currently unavailable") || message.includes("requested entity was not found") || message.includes("not found") || message.includes("tool_use") || message.includes("tool_result");
+  }
+  return false;
+}
+function maybeAntigravityFailoverUrl(failedUrl, status, bodyText, methodPath) {
+  if (!sandboxFailoverEnabled) return null;
+  if (!isAntigravityRetryableFailure(status, bodyText)) return null;
+  let parsed;
+  try {
+    parsed = new URL(failedUrl);
+  } catch {
+    return null;
+  }
+  if (parsed.origin !== ANTIGRAVITY_ENDPOINT) return null;
+  const tail = methodPath ?? `${parsed.pathname}${parsed.search}`;
+  return `${ANTIGRAVITY_SANDBOX_ENDPOINT}${tail.startsWith("/") ? tail : `/${tail}`}`;
+}
+async function fetchWithAntigravityFailover(url, fetcher, signal) {
+  signal?.throwIfAborted();
+  let response;
+  try {
+    response = await fetcher(url);
+  } catch (error) {
+    signal?.throwIfAborted();
+    const fallback2 = maybeAntigravityFailoverUrl(url, null);
+    if (!fallback2) throw error;
+    return fetcher(fallback2);
+  }
+  if (!sandboxFailoverEnabled || response.ok) return response;
+  const body = response.status === 400 || response.status === 404 ? await response.clone().text().catch(() => "") : void 0;
+  const fallback = maybeAntigravityFailoverUrl(url, response.status, body);
+  if (!fallback) return response;
+  await response.body?.cancel().catch(() => void 0);
+  signal?.throwIfAborted();
+  return fetcher(fallback);
+}
+
+export {
+  ANTIGRAVITY_SANDBOX_ENDPOINT,
+  setAntigravitySandboxFailover,
+  isAntigravitySandboxFailoverEnabled,
+  __resetAntigravityFailoverState,
+  isAntigravityRetryableFailure,
+  maybeAntigravityFailoverUrl,
+  fetchWithAntigravityFailover
+};

package/dist/chunk-KSMK45RD.cjs

@@ -0,0 +1,45 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/pipeline/antigravityQuotaFamily.ts
+var ANTIGRAVITY_COUNTER_TO_MODEL_FAMILY = {
+  google: "gemini",
+  anthropic: "claude",
+  openai: "gpt-oss"
+};
+var ANTIGRAVITY_MODEL_TO_COUNTER_FAMILY = {
+  gemini: "google",
+  claude: "anthropic",
+  "gpt-oss": "openai"
+};
+var ANTIGRAVITY_COUNTER_FAMILY_KEYS = [
+  "google",
+  "anthropic",
+  "openai"
+];
+function antigravityModelFamily(modelId) {
+  if (!modelId) return void 0;
+  if (modelId.startsWith("claude-")) return "claude";
+  if (modelId.startsWith("gpt-oss-")) return "gpt-oss";
+  if (modelId.startsWith("gemini-") || modelId.startsWith("tab_")) return "gemini";
+  return void 0;
+}
+function antigravityCounterFamilyForModel(modelId) {
+  const family = antigravityModelFamily(modelId);
+  return family ? ANTIGRAVITY_MODEL_TO_COUNTER_FAMILY[family] : void 0;
+}
+function antigravityCounterFamiliesForBucketId(bucketId, groupName) {
+  const bucket = (_nullishCoalesce(bucketId, () => ( ""))).toLowerCase();
+  const group = (_nullishCoalesce(groupName, () => ( ""))).toLowerCase();
+  if (bucket.startsWith("gemini-") || group.includes("gemini")) return ["google"];
+  if (bucket.startsWith("3p-") || group.includes("claude") || group.includes("gpt") || group.includes("third party")) {
+    return ["anthropic", "openai"];
+  }
+  return [];
+}
+
+
+
+
+
+
+
+
+exports.ANTIGRAVITY_COUNTER_TO_MODEL_FAMILY = ANTIGRAVITY_COUNTER_TO_MODEL_FAMILY; exports.ANTIGRAVITY_MODEL_TO_COUNTER_FAMILY = ANTIGRAVITY_MODEL_TO_COUNTER_FAMILY; exports.ANTIGRAVITY_COUNTER_FAMILY_KEYS = ANTIGRAVITY_COUNTER_FAMILY_KEYS; exports.antigravityModelFamily = antigravityModelFamily; exports.antigravityCounterFamilyForModel = antigravityCounterFamilyForModel; exports.antigravityCounterFamiliesForBucketId = antigravityCounterFamiliesForBucketId;

package/dist/chunk-LL3MZ7O5.cjs

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/outbound-api/types.ts
+var IMAGE_PROVIDER_IDS = [
+  "codex-subscription",
+  "antigravity-subscription"
+];
+var DEFAULT_IMAGE_MODEL_ROUTES = Object.freeze({
+  "gpt-image-2": "codex-subscription",
+  "gpt-image-2-5": "codex-subscription",
+  "gemini-2.5-flash-image": "antigravity-subscription",
+  "gemini-2.5-flash-image-preview": "antigravity-subscription",
+  "gemini-3.1-flash-image": "antigravity-subscription",
+  "gemini-3.1-flash-image-preview": "antigravity-subscription",
+  "gemini-3-pro-image-preview": "antigravity-subscription"
+});
+var ENDPOINT_MODEL_KINDS = {
+  messages: ["fable", "opus", "sonnet", "haiku"],
+  responses: ["codex", "mini"]
+};
+
+
+
+
+
+exports.IMAGE_PROVIDER_IDS = IMAGE_PROVIDER_IDS; exports.DEFAULT_IMAGE_MODEL_ROUTES = DEFAULT_IMAGE_MODEL_ROUTES; exports.ENDPOINT_MODEL_KINDS = ENDPOINT_MODEL_KINDS;

package/dist/{chunk-PAXJGABW.js → chunk-MPFOC7AT.js}

@@ -1,6 +1,3 @@
-import {
-  GeminiTransformer
-} from "./chunk-HN74IGEO.js";
 import {
   OpenAIResponseTransformer
 } from "./chunk-V53ZEFXC.js";
@@ -9,16 +6,23 @@ import {
 } from "./chunk-7PIUVCKK.js";
 import {
   AnthropicTransformer
-} from "./chunk-EUZRH544.js";
+} from "./chunk-TKZ3DZS5.js";
+import {
+  AntigravityTransformer
+} from "./chunk-ZJJBITUN.js";
+import {
+  GeminiTransformer
+} from "./chunk-OXBGNEYR.js";
 import {
   GeminiCodeAssistTransformer
-} from "./chunk-5GXOYVLB.js";
+} from "./chunk-QSOHEDKO.js";
 
 // src/transformer/transformers/index.ts
 var BuiltinTransformers = {
   OpenAITransformer,
   GeminiTransformer,
   GeminiCodeAssistTransformer,
+  AntigravityTransformer,
   AnthropicTransformer,
   OpenAIResponseTransformer
 };
@@ -29,6 +33,7 @@ var BUILTIN_TRANSFORMER_NAMES = [
   "openai",
   "gemini",
   "gemini-code-assist",
+  "antigravity",
   "anthropic",
   "openai-response"
 ];

package/dist/{chunk-DKBXDV5U.cjs → chunk-N3MGNLCU.cjs}

@@ -3,48 +3,16 @@
 
 
 
-var _chunkWX2E2G7Hcjs = require('./chunk-WX2E2G7H.cjs');
+var _chunk4NAMH4UEcjs = require('./chunk-4NAMH4UE.cjs');
 
-// src/transformer/transformers/GeminiCodeAssistTransformer.ts
-var DEFAULT_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
-var DEFAULT_CODE_ASSIST_API_VERSION = "v1internal";
-function resolveCodeAssistEndpoint() {
-  return (process.env.CODE_ASSIST_ENDPOINT || DEFAULT_CODE_ASSIST_ENDPOINT).replace(/\/+$/, "");
-}
-function resolveCodeAssistApiVersion() {
-  return process.env.CODE_ASSIST_API_VERSION || DEFAULT_CODE_ASSIST_API_VERSION;
-}
-var DEFAULT_GEMINI_CLI_VERSION = "0.46.0";
-function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview") {
-  const version = process.env.GEMINI_CLI_VERSION || DEFAULT_GEMINI_CLI_VERSION;
-  const platform = process.platform === "win32" ? "win32" : process.platform;
-  const arch = process.arch === "x64" ? "x64" : process.arch;
-  return `GeminiCLI/${version}/${modelId} (${platform}; ${arch}; terminal)`;
-}
-function getGeminiCliIdentityHeaders(modelId) {
-  return {
-    "User-Agent": getGeminiCliUserAgent(modelId),
-    "Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI"
-  };
-}
-function buildCodeAssistUrl(stream) {
-  const base = resolveCodeAssistEndpoint();
-  const version = resolveCodeAssistApiVersion();
-  const method = stream ? "streamGenerateContent?alt=sse" : "generateContent";
-  return `${base}/${version}:${method}`;
-}
-function generateUserPromptId() {
-  const c = globalThis.crypto;
-  if (_optionalChain([c, 'optionalAccess', _ => _.randomUUID])) return c.randomUUID();
-  return `omnicross-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-}
-function peelResponseEnvelope(parsed) {
+// src/transformer/transformers/ccaEnvelope.ts
+function peelCcaResponseEnvelope(parsed) {
   if (parsed && typeof parsed === "object" && "response" in parsed) {
     return parsed.response;
   }
   return parsed;
 }
-async function unwrapCodeAssistResponse(response) {
+async function unwrapCcaResponse(response) {
   const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
   if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
     const sourceBody = response.body;
@@ -69,7 +37,7 @@ async function unwrapCodeAssistResponse(response) {
           }
           try {
             const parsed = JSON.parse(payload);
-            const inner2 = peelResponseEnvelope(parsed);
+            const inner2 = peelCcaResponseEnvelope(parsed);
             controller.enqueue(encoder.encode(`data: ${JSON.stringify(inner2)}
 `));
           } catch (e) {
@@ -103,13 +71,48 @@ async function unwrapCodeAssistResponse(response) {
     });
   }
   const raw = await response.json().catch(() => null);
-  const inner = peelResponseEnvelope(raw);
+  const inner = peelCcaResponseEnvelope(raw);
   return new Response(JSON.stringify(inner), {
     status: response.status,
     statusText: response.statusText,
     headers: response.headers
   });
 }
+function buildCcaMethodUrl(base, version, stream) {
+  const method = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+  return `${base}/${version}:${method}`;
+}
+
+// src/transformer/transformers/GeminiCodeAssistTransformer.ts
+var DEFAULT_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+var DEFAULT_CODE_ASSIST_API_VERSION = "v1internal";
+function resolveCodeAssistEndpoint() {
+  return (process.env.CODE_ASSIST_ENDPOINT || DEFAULT_CODE_ASSIST_ENDPOINT).replace(/\/+$/, "");
+}
+function resolveCodeAssistApiVersion() {
+  return process.env.CODE_ASSIST_API_VERSION || DEFAULT_CODE_ASSIST_API_VERSION;
+}
+var DEFAULT_GEMINI_CLI_VERSION = "0.46.0";
+function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview") {
+  const version = process.env.GEMINI_CLI_VERSION || DEFAULT_GEMINI_CLI_VERSION;
+  const platform = process.platform === "win32" ? "win32" : process.platform;
+  const arch = process.arch === "x64" ? "x64" : process.arch;
+  return `GeminiCLI/${version}/${modelId} (${platform}; ${arch}; terminal)`;
+}
+function getGeminiCliIdentityHeaders(modelId) {
+  return {
+    "User-Agent": getGeminiCliUserAgent(modelId),
+    "Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI"
+  };
+}
+function buildCodeAssistUrl(stream) {
+  return buildCcaMethodUrl(resolveCodeAssistEndpoint(), resolveCodeAssistApiVersion(), stream);
+}
+function generateUserPromptId() {
+  const c = globalThis.crypto;
+  if (_optionalChain([c, 'optionalAccess', _ => _.randomUUID])) return c.randomUUID();
+  return `omnicross-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
 var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
   static __initStatic() {this.TransformerName = "gemini-code-assist"}
   __init() {this.name = "gemini-code-assist"}
@@ -130,7 +133,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
    * openaiResponsesIngress). `undefined` is the valid fresh free-tier value.
    */
   async transformRequestIn(request, provider, _context) {
-    const inner = _chunkWX2E2G7Hcjs.buildRequestBody.call(void 0, request, provider);
+    const inner = _chunk4NAMH4UEcjs.buildRequestBody.call(void 0, request, provider);
     const envelope = {
       model: request.model,
       project: provider.geminiProject,
@@ -161,15 +164,15 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
     if (inner && typeof inner === "object" && !("model" in inner) && "model" in r) {
       inner.model = r.model;
     }
-    return _chunkWX2E2G7Hcjs.transformRequestOut.call(void 0, inner);
+    return _chunk4NAMH4UEcjs.transformRequestOut.call(void 0, inner);
   }
   /**
    * Code Assist response → OpenAI-compatible. PEEL the `.response` envelope from
    * the body / each SSE chunk, then DELEGATE to the existing gemini parser.
    */
   async transformResponseOut(response, _context) {
-    const unwrapped = await unwrapCodeAssistResponse(response);
-    return _chunkWX2E2G7Hcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
+    const unwrapped = await unwrapCcaResponse(response);
+    return _chunk4NAMH4UEcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
   }
   /**
    * OpenAI-compatible response → Code Assist (endpoint-encode parity). Re-wraps
@@ -178,7 +181,7 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
    * `transformResponseOut`'s peel.
    */
   async transformResponseIn(response, _context) {
-    const geminiResponse = await _chunkWX2E2G7Hcjs.transformResponseIn.call(void 0, response, this.logger);
+    const geminiResponse = await _chunk4NAMH4UEcjs.transformResponseIn.call(void 0, response, this.logger);
     const contentType = _nullishCoalesce(geminiResponse.headers.get("Content-Type"), () => ( ""));
     if (contentType.includes("text/event-stream")) {
       return geminiResponse;
@@ -199,4 +202,6 @@ var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.protot
 
 
 
-exports.resolveCodeAssistEndpoint = resolveCodeAssistEndpoint; exports.resolveCodeAssistApiVersion = resolveCodeAssistApiVersion; exports.getGeminiCliUserAgent = getGeminiCliUserAgent; exports.getGeminiCliIdentityHeaders = getGeminiCliIdentityHeaders; exports.buildCodeAssistUrl = buildCodeAssistUrl; exports.GeminiCodeAssistTransformer = GeminiCodeAssistTransformer;
+
+
+exports.unwrapCcaResponse = unwrapCcaResponse; exports.buildCcaMethodUrl = buildCcaMethodUrl; exports.resolveCodeAssistEndpoint = resolveCodeAssistEndpoint; exports.resolveCodeAssistApiVersion = resolveCodeAssistApiVersion; exports.getGeminiCliUserAgent = getGeminiCliUserAgent; exports.getGeminiCliIdentityHeaders = getGeminiCliIdentityHeaders; exports.buildCodeAssistUrl = buildCodeAssistUrl; exports.GeminiCodeAssistTransformer = GeminiCodeAssistTransformer;

package/dist/chunk-NCZDUBC2.js

@@ -0,0 +1,44 @@
+import {
+  flattenHeaderValue
+} from "./chunk-ONTTXSRL.js";
+
+// src/provider-proxy/identity/openCodeGoHeaders.ts
+var OPENCODE_SESSION_HEADER = "x-opencode-session";
+var configuredUserAgent;
+function setOpenCodeGoUserAgent(userAgent) {
+  const trimmed = typeof userAgent === "string" ? userAgent.trim() : "";
+  configuredUserAgent = trimmed.length > 0 ? trimmed : void 0;
+}
+function getOpenCodeGoUserAgent() {
+  if (configuredUserAgent) return configuredUserAgent;
+  const version = true ? "0.4.4" : "0.0.0-dev";
+  return `omnicross/${version}`;
+}
+function extractOpenCodeSessionHeader(reqHeaders) {
+  for (const [rawKey, rawVal] of Object.entries(reqHeaders)) {
+    if (rawKey.toLowerCase() !== OPENCODE_SESSION_HEADER) continue;
+    const value = flattenHeaderValue(rawVal);
+    if (value === void 0) continue;
+    const trimmed = value.trim();
+    if (trimmed.length > 0) return trimmed;
+  }
+  return void 0;
+}
+function resolveOpenCodeSessionHeader(callerSession, sessionKey) {
+  const caller = typeof callerSession === "string" ? callerSession.trim() : "";
+  if (caller.length > 0) return caller;
+  if (typeof sessionKey === "string" && sessionKey.trim().length > 0) return sessionKey;
+  return void 0;
+}
+function __resetOpenCodeGoHeadersForTests() {
+  configuredUserAgent = void 0;
+}
+
+export {
+  OPENCODE_SESSION_HEADER,
+  setOpenCodeGoUserAgent,
+  getOpenCodeGoUserAgent,
+  extractOpenCodeSessionHeader,
+  resolveOpenCodeSessionHeader,
+  __resetOpenCodeGoHeadersForTests
+};

package/dist/chunk-NDIBVTBZ.cjs

@@ -0,0 +1,230 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+var _chunkN3MGNLCUcjs = require('./chunk-N3MGNLCU.cjs');
+
+
+var _chunkVFFCV4J6cjs = require('./chunk-VFFCV4J6.cjs');
+
+// src/auth/GeminiCodeAssistProjectResolver.ts
+var FREE_TIER_ID = "free-tier";
+var LEGACY_TIER_ID = "legacy-tier";
+var ONBOARD_POLL_INTERVAL_MS = 5e3;
+var ONBOARD_MAX_POLLS = 24;
+var GeminiCodeAssistHandshakeError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "GeminiCodeAssistHandshakeError";
+  }
+  
+  
+};
+var ANTIGRAVITY_CODE_ASSIST_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+var GeminiCodeAssistProjectResolver = (_class = class {
+  /** account access token → resolved project id (undefined = free-tier, no project). */
+  __init() {this.cache = /* @__PURE__ */ new Map()}
+  /** In-flight handshakes so concurrent callers share one round-trip. */
+  __init2() {this.inflight = /* @__PURE__ */ new Map()}
+  
+  
+  // upstream-proxy: the Code Assist handshake is upstream egress → honor the
+  // dialect's proxy layer by default (still injectable for tests).
+  constructor(fetchImpl, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.dialect = _nullishCoalesce(options.dialect, () => ( "gemini-cli"));
+    this.endpoint = options.endpoint;
+    const providerId = _nullishCoalesce(options.proxyProviderId, () => ( "gemini"));
+    this.fetchImpl = _nullishCoalesce(fetchImpl, () => ( ((url, init) => _chunkVFFCV4J6cjs.fetchUpstream.call(void 0, url, init, { providerId }))));
+  }
+  
+  /** Test/diagnostic helper — clear the cached resolution for an account. */
+  clearCache() {
+    this.cache.clear();
+    this.inflight.clear();
+  }
+  /**
+   * Resolve (and cache) the Code Assist project for the given access token.
+   * Runs the handshake at most once per token. Returns `undefined` for a
+   * brand-new free-tier account (valid — the envelope sends no project).
+   */
+  async resolveProject(accessToken) {
+    if (this.cache.has(accessToken)) {
+      return this.cache.get(accessToken);
+    }
+    const existing = this.inflight.get(accessToken);
+    if (existing) return existing;
+    const run = this.runHandshake(accessToken).then((project) => {
+      this.cache.set(accessToken, project);
+      return project;
+    }).finally(() => {
+      this.inflight.delete(accessToken);
+    });
+    this.inflight.set(accessToken, run);
+    return run;
+  }
+  codeAssistUrl(method) {
+    const base = _nullishCoalesce(this.endpoint, () => ( _chunkN3MGNLCUcjs.resolveCodeAssistEndpoint.call(void 0, )));
+    return `${base}/${_chunkN3MGNLCUcjs.resolveCodeAssistApiVersion.call(void 0, )}:${method}`;
+  }
+  /** The client metadata the dialect's upstream expects on the handshake calls. */
+  handshakeMetadata(project) {
+    if (this.dialect === "antigravity") {
+      return { ideType: "ANTIGRAVITY" };
+    }
+    return {
+      ideType: "IDE_UNSPECIFIED",
+      platform: "PLATFORM_UNSPECIFIED",
+      pluginType: "GEMINI",
+      duetProject: project
+    };
+  }
+  /** The tier id used when `allowedTiers` carries no default. */
+  get fallbackTierId() {
+    return this.dialect === "antigravity" ? FREE_TIER_ID : LEGACY_TIER_ID;
+  }
+  /** Seed project id from env; reject a purely-numeric value (project NUMBER). */
+  seedProjectId() {
+    const seed = process.env.GOOGLE_CLOUD_PROJECT || process.env.GOOGLE_CLOUD_PROJECT_ID || "";
+    if (seed && /^\d+$/.test(seed.trim())) return "";
+    return seed.trim();
+  }
+  async runHandshake(accessToken) {
+    const seededProject = this.seedProjectId();
+    const load = await this.postCodeAssist("loadCodeAssist", accessToken, {
+      cloudaicompanionProject: seededProject || void 0,
+      metadata: this.handshakeMetadata(seededProject || void 0)
+    });
+    if (_optionalChain([load, 'access', _ => _.currentTier, 'optionalAccess', _2 => _2.id])) {
+      return this.settleProject(load.cloudaicompanionProject || void 0);
+    }
+    const defaultTier = _optionalChain([load, 'access', _3 => _3.allowedTiers, 'optionalAccess', _4 => _4.find, 'call', _5 => _5((t) => t.isDefault)]);
+    const tierId = _nullishCoalesce(_optionalChain([defaultTier, 'optionalAccess', _6 => _6.id]), () => ( this.fallbackTierId));
+    const isFreeish = tierId === FREE_TIER_ID || tierId === LEGACY_TIER_ID;
+    const onboardProject = isFreeish ? void 0 : seededProject || void 0;
+    let lro = await this.postCodeAssist("onboardUser", accessToken, {
+      tierId,
+      cloudaicompanionProject: onboardProject,
+      metadata: this.handshakeMetadata(onboardProject)
+    });
+    let polls = 0;
+    while (!lro.done && polls < ONBOARD_MAX_POLLS) {
+      await delay(ONBOARD_POLL_INTERVAL_MS);
+      polls++;
+      lro = await this.getOperation(accessToken, lro.name);
+    }
+    if (lro.error) {
+      throw new GeminiCodeAssistHandshakeError(
+        `Code Assist onboardUser failed: ${_nullishCoalesce(lro.error.message, () => ( "unknown"))}`,
+        _nullishCoalesce(lro.error.code, () => ( 500))
+      );
+    }
+    return this.settleProject(_optionalChain([lro, 'access', _7 => _7.response, 'optionalAccess', _8 => _8.cloudaicompanionProject, 'optionalAccess', _9 => _9.id]) || void 0);
+  }
+  /**
+   * Final project settlement per dialect: gemini-cli treats `undefined` as the
+   * valid fresh free-tier value; antigravity ALWAYS carries a project (its
+   * envelope is rejected without one), so an absent project is a hard error.
+   */
+  settleProject(project) {
+    if (project === void 0 && this.dialect === "antigravity") {
+      throw new GeminiCodeAssistHandshakeError(
+        "Code Assist loadCodeAssist did not return a cloudaicompanionProject (antigravity requires one)",
+        502
+      );
+    }
+    return project;
+  }
+  /** POST a Code Assist method, surfacing the documented hard failures clearly. */
+  async postCodeAssist(method, accessToken, body) {
+    const url = this.codeAssistUrl(method);
+    const res = await this.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      await this.throwForStatus(res, method);
+    }
+    return await res.json();
+  }
+  async getOperation(accessToken, name) {
+    const url = this.codeAssistUrl("getOperation");
+    const res = await this.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ name })
+    });
+    if (!res.ok) {
+      await this.throwForStatus(res, "getOperation");
+    }
+    return await res.json();
+  }
+  /** Map a non-2xx Code Assist response to a clear, surfaced error. */
+  async throwForStatus(res, method) {
+    let detailCode;
+    let detailMessage = "";
+    try {
+      const errBody = await res.json();
+      detailCode = _optionalChain([errBody, 'access', _10 => _10.error, 'optionalAccess', _11 => _11.status]);
+      detailMessage = _nullishCoalesce(_optionalChain([errBody, 'access', _12 => _12.error, 'optionalAccess', _13 => _13.message]), () => ( ""));
+    } catch (e) {
+    }
+    if (res.status === 403) {
+      throw new GeminiCodeAssistHandshakeError(
+        `Code Assist ${method} denied (403 ${_nullishCoalesce(detailCode, () => ( "PERMISSION_DENIED"))}): ${detailMessage || "enable the Cloud AI Companion API and grant the required role"}`,
+        403,
+        detailCode
+      );
+    }
+    if (res.status === 429) {
+      throw new GeminiCodeAssistHandshakeError(
+        `Code Assist ${method} rate-limited (429): ${detailMessage || "quota exceeded, retry later"}`,
+        429,
+        detailCode
+      );
+    }
+    throw new GeminiCodeAssistHandshakeError(
+      `Code Assist ${method} failed (${res.status}): ${detailMessage || res.statusText}`,
+      res.status,
+      detailCode
+    );
+  }
+}, _class);
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var _resolverSingleton = null;
+function getGeminiCodeAssistProjectResolver() {
+  if (!_resolverSingleton) {
+    _resolverSingleton = new GeminiCodeAssistProjectResolver();
+  }
+  return _resolverSingleton;
+}
+var _antigravityResolverSingleton = null;
+function getAntigravityProjectResolver() {
+  if (!_antigravityResolverSingleton) {
+    _antigravityResolverSingleton = new GeminiCodeAssistProjectResolver(void 0, {
+      endpoint: ANTIGRAVITY_CODE_ASSIST_ENDPOINT,
+      dialect: "antigravity",
+      proxyProviderId: "antigravity"
+    });
+  }
+  return _antigravityResolverSingleton;
+}
+
+
+
+
+
+
+
+exports.GeminiCodeAssistHandshakeError = GeminiCodeAssistHandshakeError; exports.ANTIGRAVITY_CODE_ASSIST_ENDPOINT = ANTIGRAVITY_CODE_ASSIST_ENDPOINT; exports.GeminiCodeAssistProjectResolver = GeminiCodeAssistProjectResolver; exports.getGeminiCodeAssistProjectResolver = getGeminiCodeAssistProjectResolver; exports.getAntigravityProjectResolver = getAntigravityProjectResolver;