@omnicross/core 0.4.1 → 0.4.3

package/dist/chunk-X6GHTNDL.cjs

@@ -0,0 +1,482 @@
+"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 _chunkE5RCCGE7cjs = require('./chunk-E5RCCGE7.cjs');
+
+
+var _chunkKSMK45RDcjs = require('./chunk-KSMK45RD.cjs');
+
+
+var _chunkNDIBVTBZcjs = require('./chunk-NDIBVTBZ.cjs');
+
+
+
+var _chunkN3MGNLCUcjs = require('./chunk-N3MGNLCU.cjs');
+
+
+
+
+var _chunk4NAMH4UEcjs = require('./chunk-4NAMH4UE.cjs');
+
+
+
+
+var _chunkIUL4VWNUcjs = require('./chunk-IUL4VWNU.cjs');
+
+// src/transformer/transformers/AntigravityTransformer.ts
+var _crypto = require('crypto');
+
+// src/transformer/transformers/utils/ccaLegacySchema.ts
+function appendHint(description, hint) {
+  if (!hint) return _nullishCoalesce(description, () => ( ""));
+  if (!description) return hint;
+  return `${description} (${hint})`;
+}
+function refHint(refValue) {
+  const name = refValue.slice(refValue.lastIndexOf("/") + 1);
+  return name ? `See: ${name}` : "";
+}
+var CONSTRAINT_KEYS = [
+  "minLength",
+  "maxLength",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "pattern",
+  "minItems",
+  "maxItems"
+];
+function normalizeType(typeValue) {
+  if (typeof typeValue === "string" && typeValue) return { type: typeValue, hint: "" };
+  if (!Array.isArray(typeValue) || typeValue.length === 0) return { type: "", hint: "" };
+  const raw = typeValue.map((t) => t == null ? "" : String(t)).filter(Boolean);
+  const hasNull = raw.includes("null");
+  const nonNull = raw.filter((t) => t !== "null");
+  const primary = nonNull[0] || "string";
+  const hints = [];
+  if (nonNull.length > 1) hints.push(`Accepts: ${nonNull.join(" | ")}`);
+  if (hasNull) hints.push("nullable");
+  return { type: primary, hint: hints.join("; ") };
+}
+function schemaScore(schema) {
+  if (!schema || typeof schema !== "object") return 0;
+  const s = schema;
+  const t = typeof s["type"] === "string" ? s["type"] : "";
+  if (t === "object" || s["properties"] && typeof s["properties"] === "object") return 3;
+  if (t === "array" || s["items"]) return 2;
+  if (t && t !== "null") return 1;
+  return 0;
+}
+function cleanSchemaForCcaLegacyParameters(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return { type: "object", properties: {} };
+  }
+  const s = schema;
+  const ref = s["$ref"];
+  if (typeof ref === "string" && ref) {
+    return {
+      type: "object",
+      description: appendHint(
+        typeof s["description"] === "string" ? s["description"] : void 0,
+        refHint(ref)
+      ),
+      properties: {}
+    };
+  }
+  const alternatives = Array.isArray(s["anyOf"]) ? s["anyOf"] : Array.isArray(s["oneOf"]) ? s["oneOf"] : null;
+  if (alternatives && alternatives.length > 0) {
+    let best = alternatives[0];
+    let bestScore = -1;
+    const types = [];
+    for (const alternative of alternatives) {
+      const score = schemaScore(alternative);
+      const normalized = normalizeType(_optionalChain([alternative, 'optionalAccess', _ => _["type"]]));
+      if (normalized.type) types.push(normalized.type);
+      if (score > bestScore) {
+        bestScore = score;
+        best = alternative;
+      }
+    }
+    const cleaned = cleanSchemaForCcaLegacyParameters(best);
+    const typeHint2 = types.length > 1 ? `Accepts: ${[...new Set(types)].join(" || ")}` : "";
+    return {
+      ...cleaned,
+      description: appendHint(
+        appendHint(cleaned.description, typeof s["description"] === "string" ? s["description"] : void 0),
+        typeHint2
+      )
+    };
+  }
+  if (Array.isArray(s["allOf"]) && s["allOf"].length > 0) {
+    const merged = {};
+    let mergedDescription = typeof s["description"] === "string" ? s["description"] : void 0;
+    const required = /* @__PURE__ */ new Set();
+    const properties = {};
+    for (const branch of s["allOf"]) {
+      const cleaned = cleanSchemaForCcaLegacyParameters(branch);
+      if (cleaned.description) mergedDescription = appendHint(mergedDescription, cleaned.description);
+      for (const key of _nullishCoalesce(cleaned.required, () => ( []))) required.add(key);
+      Object.assign(properties, _nullishCoalesce(cleaned.properties, () => ( {})));
+      if (cleaned.type && !merged.type) merged.type = cleaned.type;
+      if (cleaned.items && !merged.items) merged.items = cleaned.items;
+      if (cleaned.enum && !merged.enum) merged.enum = cleaned.enum;
+    }
+    if (Object.keys(properties).length > 0) {
+      merged.type = _nullishCoalesce(merged.type, () => ( "object"));
+      merged.properties = properties;
+      const validRequired = [...required].filter((key) => key in properties);
+      if (validRequired.length > 0) merged.required = validRequired;
+    }
+    if (mergedDescription) merged.description = mergedDescription;
+    return cleanSchemaForCcaLegacyParameters(merged);
+  }
+  const result = {};
+  const constraintHints = [];
+  if (typeof s["description"] === "string") result.description = s["description"];
+  for (const key of CONSTRAINT_KEYS) {
+    const value = s[key];
+    if (value === void 0 || value === null || typeof value === "object") continue;
+    constraintHints.push(`${key}: ${String(value)}`);
+  }
+  if (s["const"] !== void 0 && !Array.isArray(s["enum"])) {
+    result.enum = [s["const"]];
+  }
+  if (Array.isArray(s["enum"])) {
+    const values = s["enum"].filter(
+      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean"
+    );
+    if (values.length > 0) result.enum = values;
+    if (result.enum && result.enum.length > 1 && result.enum.length <= 10) {
+      result.description = appendHint(
+        result.description,
+        `Allowed: ${result.enum.map(String).join(", ")}`
+      );
+    }
+  }
+  const { type: normalizedType, hint: typeHint } = normalizeType(s["type"]);
+  if (normalizedType) result.type = normalizedType;
+  if (typeHint) result.description = appendHint(result.description, typeHint);
+  if (constraintHints.length > 0) {
+    result.description = appendHint(result.description, constraintHints.join(", "));
+  }
+  if (s["additionalProperties"] === false) {
+    result.description = appendHint(result.description, "No extra properties allowed");
+  }
+  if (s["properties"] && typeof s["properties"] === "object" && !Array.isArray(s["properties"])) {
+    const properties = {};
+    for (const [name, property] of Object.entries(s["properties"])) {
+      properties[name] = cleanSchemaForCcaLegacyParameters(property);
+    }
+    result.type = _nullishCoalesce(result.type, () => ( "object"));
+    result.properties = properties;
+  }
+  if (s["items"] !== void 0) {
+    result.type = _nullishCoalesce(result.type, () => ( "array"));
+    result.items = cleanSchemaForCcaLegacyParameters(s["items"]);
+  }
+  if (Array.isArray(s["required"]) && result.properties) {
+    const required = s["required"].filter(
+      (key) => typeof key === "string" && !!key && key in result.properties
+    );
+    if (required.length > 0) result.required = required;
+  }
+  if (!result.type) {
+    result.type = result.properties ? "object" : result.items !== void 0 ? "array" : "object";
+  }
+  if (result.type === "object" && !result.properties) {
+    result.properties = {};
+  }
+  return result;
+}
+
+// src/transformer/transformers/AntigravityTransformer.ts
+var ANTIGRAVITY_FORCED_TOOL_DIRECTIVE = "TOOL-ONLY TURN. This turn accepts a tool call and nothing else; a text reply here is discarded unread and you will be re-prompted. Emit the tool call now.";
+var ANTIGRAVITY_FORCED_TOOL_ASSET_VERSION = "2.8.0";
+var CLAUDE_THINKING_BETA_HEADER = "interleaved-thinking-2025-05-14";
+var forcedToolDriftLogged = false;
+function checkForcedToolAssetDrift(currentVersion, log) {
+  if (forcedToolDriftLogged || currentVersion === ANTIGRAVITY_FORCED_TOOL_ASSET_VERSION) return;
+  forcedToolDriftLogged = true;
+  const message = `[AntigravityTransformer] UA version ${currentVersion} differs from the frozen forced-tool asset version ${ANTIGRAVITY_FORCED_TOOL_ASSET_VERSION} \u2014 review whether the upstream directive changed (the asset does not auto-follow).`;
+  (_nullishCoalesce(log, () => ( ((line) => console.warn(line)))))(message);
+}
+var ANTIGRAVITY_VARIANT_ROUTES = {
+  // Gemini ≥3.6 flash (google-level): minimal|low → -low, medium → -medium, high → -high.
+  "gemini-3.6-flash": {
+    default: "gemini-3.6-flash-low",
+    minimal: "gemini-3.6-flash-low",
+    low: "gemini-3.6-flash-low",
+    medium: "gemini-3.6-flash-medium",
+    high: "gemini-3.6-flash-high"
+  },
+  "gemini-3.7-flash": {
+    default: "gemini-3.7-flash-low",
+    minimal: "gemini-3.7-flash-low",
+    low: "gemini-3.7-flash-low",
+    medium: "gemini-3.7-flash-medium",
+    high: "gemini-3.7-flash-high"
+  },
+  "gemini-3.8-flash": {
+    default: "gemini-3.8-flash-low",
+    minimal: "gemini-3.8-flash-low",
+    low: "gemini-3.8-flash-low",
+    medium: "gemini-3.8-flash-medium",
+    high: "gemini-3.8-flash-high"
+  },
+  // Gemini 3.5 flash (budget transport; `gemini-3-flash` is its alias):
+  // minimal|low → extra-low, medium → -low, high → the agent id.
+  "gemini-3.5-flash": {
+    default: "gemini-3.5-flash-extra-low",
+    off: "gemini-3.5-flash-extra-low",
+    minimal: "gemini-3.5-flash-extra-low",
+    low: "gemini-3.5-flash-extra-low",
+    medium: "gemini-3.5-flash-low",
+    high: "gemini-3-flash-agent"
+  },
+  "gemini-3-flash": {
+    default: "gemini-3.5-flash-extra-low",
+    off: "gemini-3.5-flash-extra-low",
+    minimal: "gemini-3.5-flash-extra-low",
+    low: "gemini-3.5-flash-extra-low",
+    medium: "gemini-3.5-flash-low",
+    high: "gemini-3-flash-agent"
+  },
+  // Gemini 3.1 pro: low → -low, high → the pro-agent id.
+  "gemini-3.1-pro": {
+    default: "gemini-3.1-pro-low",
+    off: "gemini-3.1-pro-low",
+    low: "gemini-3.1-pro-low",
+    high: "gemini-pro-agent"
+  },
+  // Gemini 3 pro (google-level): low → -low, high → -high.
+  "gemini-3-pro": {
+    default: "gemini-3-pro-low",
+    off: "gemini-3-pro-low",
+    low: "gemini-3-pro-low",
+    high: "gemini-3-pro-high"
+  },
+  // gpt-oss 120b: every effort level rides the -medium wire id.
+  "gpt-oss-120b": {
+    default: "gpt-oss-120b-medium",
+    minimal: "gpt-oss-120b-medium",
+    low: "gpt-oss-120b-medium",
+    medium: "gpt-oss-120b-medium",
+    high: "gpt-oss-120b-medium"
+  },
+  // Claude 4.5: thinking is a separate wire id; off rides the base id.
+  "claude-opus-4-5": {
+    off: "claude-opus-4-5",
+    minimal: "claude-opus-4-5-thinking",
+    low: "claude-opus-4-5-thinking",
+    medium: "claude-opus-4-5-thinking",
+    high: "claude-opus-4-5-thinking"
+  },
+  "claude-sonnet-4-5": {
+    off: "claude-sonnet-4-5",
+    minimal: "claude-sonnet-4-5-thinking",
+    low: "claude-sonnet-4-5-thinking",
+    medium: "claude-sonnet-4-5-thinking",
+    high: "claude-sonnet-4-5-thinking"
+  },
+  // Claude opus 4.6: the BASE id is retired upstream — every request (off or
+  // not) rides the thinking wire id.
+  "claude-opus-4-6": {
+    default: "claude-opus-4-6-thinking",
+    off: "claude-opus-4-6-thinking",
+    minimal: "claude-opus-4-6-thinking",
+    low: "claude-opus-4-6-thinking",
+    medium: "claude-opus-4-6-thinking",
+    high: "claude-opus-4-6-thinking"
+  },
+  // Claude sonnet 4.6: the THINKING variant is retired upstream — always base.
+  "claude-sonnet-4-6": {
+    default: "claude-sonnet-4-6"
+  },
+  // Gemini 2.5 flash/lite: thinking rides the -thinking wire id.
+  "gemini-2.5-flash": {
+    off: "gemini-2.5-flash",
+    minimal: "gemini-2.5-flash-thinking",
+    low: "gemini-2.5-flash-thinking",
+    medium: "gemini-2.5-flash-thinking",
+    high: "gemini-2.5-flash-thinking"
+  },
+  "gemini-2.5-flash-lite": {
+    off: "gemini-2.5-flash-lite",
+    minimal: "gemini-2.5-flash-lite-thinking",
+    low: "gemini-2.5-flash-lite-thinking",
+    medium: "gemini-2.5-flash-lite-thinking",
+    high: "gemini-2.5-flash-lite-thinking"
+  }
+};
+function resolveAntigravityWireModelId(logicalModelId, request, provider) {
+  const routes = ANTIGRAVITY_VARIANT_ROUTES[logicalModelId];
+  const intent = _chunkIUL4VWNUcjs.extractReasoningIntent.call(void 0, { model: logicalModelId, reasoning: request.reasoning });
+  const capabilities = _chunkIUL4VWNUcjs.resolveTargetModelCapabilities.call(void 0, logicalModelId, provider);
+  const reasoningCapable = !!_optionalChain([capabilities, 'access', _2 => _2.thinkingLevels, 'optionalAccess', _3 => _3.some, 'call', _4 => _4((level) => level !== "none")]) || capabilities.reasoning === true;
+  if (!routes || !_optionalChain([intent, 'optionalAccess', _5 => _5.effort])) {
+    return { wireModelId: _nullishCoalesce(_optionalChain([routes, 'optionalAccess', _6 => _6.default]), () => ( logicalModelId)), variantEngaged: false, effort: _optionalChain([intent, 'optionalAccess', _7 => _7.effort]) };
+  }
+  const effort = intent.effort === "none" ? "none" : reasoningCapable ? _chunkIUL4VWNUcjs.resolveReasoningEffort.call(void 0, intent.effort, logicalModelId, provider) : "none";
+  if (effort === "none") {
+    return { wireModelId: _nullishCoalesce(_nullishCoalesce(routes.off, () => ( routes.default)), () => ( logicalModelId)), variantEngaged: true, effort };
+  }
+  const routed = routes[effort];
+  if (routed) {
+    return { wireModelId: routed, variantEngaged: true, effort };
+  }
+  return { wireModelId: _nullishCoalesce(routes.default, () => ( logicalModelId)), variantEngaged: false, effort };
+}
+var ANTIGRAVITY_ENDPOINT = _chunkNDIBVTBZcjs.ANTIGRAVITY_CODE_ASSIST_ENDPOINT;
+function buildAntigravityUrl(stream, base = ANTIGRAVITY_ENDPOINT) {
+  return _chunkN3MGNLCUcjs.buildCcaMethodUrl.call(void 0, base, "v1internal", stream);
+}
+var INT63_MASK = (1n << 63n) - 1n;
+function deriveAntigravitySessionId(text) {
+  const digest = _crypto.createHash.call(void 0, "sha256").update(text).digest();
+  let value = 0n;
+  for (let index = 0; index < 8; index += 1) {
+    value = value << 8n | BigInt(_nullishCoalesce(digest[index], () => ( 0)));
+  }
+  return `-${(value & INT63_MASK).toString()}`;
+}
+function firstUserText(request) {
+  for (const message of request.messages) {
+    if (message.role !== "user") continue;
+    if (typeof message.content === "string") return message.content;
+    if (Array.isArray(message.content)) {
+      const firstText = message.content.find((part) => part.type === "text");
+      return _optionalChain([firstText, 'optionalAccess', _8 => _8.text]);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+var AntigravityTransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  static __initStatic() {this.TransformerName = "antigravity"}
+  __init() {this.name = "antigravity"}
+  
+  /** The URL is built per-request (colon-method, no fixed endpoint pattern). */
+  __init2() {this.endPoint = void 0}
+  async transformRequestIn(request, provider, _context) {
+    void _chunkE5RCCGE7cjs.ensureAntigravityVersion.call(void 0, ).catch(() => void 0);
+    checkForcedToolAssetDrift(_chunkE5RCCGE7cjs.getAntigravityVersion.call(void 0, ), _optionalChain([this, 'access', _9 => _9.logger, 'optionalAccess', _10 => _10.warn, 'optionalAccess', _11 => _11.bind, 'call', _12 => _12(this.logger)]));
+    const family = _nullishCoalesce(_chunkKSMK45RDcjs.antigravityModelFamily.call(void 0, request.model), () => ( "gemini"));
+    const { wireModelId, variantEngaged } = resolveAntigravityWireModelId(request.model, request, provider);
+    const inner = _chunk4NAMH4UEcjs.buildRequestBody.call(void 0, { ...request, model: wireModelId }, provider);
+    const generationConfig = { ..._nullishCoalesce(inner["generationConfig"], () => ( {})) };
+    if (variantEngaged) {
+      delete generationConfig["thinkingConfig"];
+    }
+    const profile = _chunkE5RCCGE7cjs.getAntigravityModelWireProfile.call(void 0, wireModelId);
+    if (profile) {
+      generationConfig["maxOutputTokens"] = profile.maxOutputTokens;
+    }
+    const tools = inner["tools"];
+    const decoratedTools = family === "claude" && tools ? tools.map((tool) => legacyParametersTool(tool)) : tools;
+    const contents = inner["contents"];
+    let toolConfig = inner["toolConfig"];
+    let forcedToolInjected = false;
+    const hasTools = !!_optionalChain([decoratedTools, 'optionalAccess', _13 => _13.some, 'call', _14 => _14((tool) => (_nullishCoalesce(_optionalChain([tool, 'access', _15 => _15.functionDeclarations, 'optionalAccess', _16 => _16.length]), () => ( 0))) > 0)]);
+    if (_optionalChain([toolConfig, 'optionalAccess', _17 => _17.functionCallingConfig, 'access', _18 => _18.mode]) === "none") {
+      toolConfig = { functionCallingConfig: { mode: "NONE" } };
+    } else if (_optionalChain([toolConfig, 'optionalAccess', _19 => _19.functionCallingConfig, 'access', _20 => _20.mode]) === "any") {
+      toolConfig = {
+        functionCallingConfig: {
+          mode: "ANY",
+          ...toolConfig.functionCallingConfig.allowedFunctionNames ? { allowedFunctionNames: toolConfig.functionCallingConfig.allowedFunctionNames } : {}
+        }
+      };
+      if (family !== "claude") {
+        contents.push({ role: "user", parts: [{ text: ANTIGRAVITY_FORCED_TOOL_DIRECTIVE }] });
+        forcedToolInjected = true;
+      }
+    } else if (hasTools || family === "claude") {
+      toolConfig = { functionCallingConfig: { mode: "VALIDATED" } };
+    } else {
+      toolConfig = void 0;
+    }
+    void forcedToolInjected;
+    const anchor = firstUserText(request);
+    const sessionId = anchor && anchor.trim().length > 0 ? deriveAntigravitySessionId(anchor) : `-${Date.now()}`;
+    const trajectoryId = _crypto.randomUUID.call(void 0, );
+    const step = request.messages.filter((message) => message.role === "assistant").length + 2;
+    const requestId = `agent/${_crypto.randomUUID.call(void 0, )}/${Date.now()}/${trajectoryId}/${step}`;
+    const labels = {
+      last_step_index: String(step - 1),
+      // Anthropic ids carry no model_enum token (the backend does not require it).
+      ...family !== "claude" && _optionalChain([profile, 'optionalAccess', _21 => _21.modelEnum]) !== void 0 ? { model_enum: profile.modelEnum } : {},
+      trajectory_id: trajectoryId,
+      used_claude: String(family === "claude"),
+      used_claude_conservative: String(family === "claude")
+    };
+    const innerRequest = {
+      ...inner,
+      contents,
+      ...decoratedTools ? { tools: decoratedTools } : {},
+      ...toolConfig ? { toolConfig } : {},
+      ...Object.keys(generationConfig).length > 0 ? { generationConfig } : {},
+      sessionId,
+      labels
+    };
+    const envelope = {
+      project: provider.geminiProject,
+      requestId,
+      model: wireModelId,
+      userAgent: "antigravity",
+      requestType: "agent",
+      request: innerRequest
+    };
+    const url = buildAntigravityUrl(Boolean(request.stream));
+    const headers = {
+      "x-goog-api-key": void 0,
+      "X-Goog-Api-Key": void 0,
+      "User-Agent": _chunkE5RCCGE7cjs.getAntigravityUserAgent.call(void 0, ),
+      // Claude thinking models ride the interleaved-thinking beta (the CCA
+      // backend needs it to return thinking blocks for Anthropic ids).
+      ...family === "claude" ? { "anthropic-beta": CLAUDE_THINKING_BETA_HEADER } : {}
+    };
+    return {
+      body: envelope,
+      config: { url, headers }
+    };
+  }
+  /** antigravity request → unified (endpoint-decode parity with the gemini one). */
+  async transformRequestOut(request, _context) {
+    const r = request;
+    const inner = r && typeof r === "object" && "request" in r ? r.request : r;
+    if (inner && typeof inner === "object" && !("model" in inner) && "model" in r) {
+      inner.model = r.model;
+    }
+    return _chunk4NAMH4UEcjs.transformRequestOut.call(void 0, inner);
+  }
+  /** antigravity response → OpenAI-compatible: peel `.response`, delegate. */
+  async transformResponseOut(response, _context) {
+    const unwrapped = await _chunkN3MGNLCUcjs.unwrapCcaResponse.call(void 0, response);
+    return _chunk4NAMH4UEcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
+  }
+}, _class.__initStatic(), _class);
+function legacyParametersTool(tool) {
+  if (!tool.functionDeclarations) return tool;
+  return {
+    functionDeclarations: tool.functionDeclarations.map((declaration) => {
+      if ("parameters" in declaration) return declaration;
+      const { parametersJsonSchema, ...rest } = declaration;
+      return {
+        ...rest,
+        parameters: cleanSchemaForCcaLegacyParameters(parametersJsonSchema)
+      };
+    })
+  };
+}
+
+
+
+
+
+
+
+
+
+
+exports.ANTIGRAVITY_FORCED_TOOL_DIRECTIVE = ANTIGRAVITY_FORCED_TOOL_DIRECTIVE; exports.ANTIGRAVITY_FORCED_TOOL_ASSET_VERSION = ANTIGRAVITY_FORCED_TOOL_ASSET_VERSION; exports.checkForcedToolAssetDrift = checkForcedToolAssetDrift; exports.resolveAntigravityWireModelId = resolveAntigravityWireModelId; exports.ANTIGRAVITY_ENDPOINT = ANTIGRAVITY_ENDPOINT; exports.buildAntigravityUrl = buildAntigravityUrl; exports.deriveAntigravitySessionId = deriveAntigravitySessionId; exports.AntigravityTransformer = AntigravityTransformer;

package/dist/chunk-XBQTVRMK.js

@@ -0,0 +1,45 @@
+// 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 = (bucketId ?? "").toLowerCase();
+  const group = (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 [];
+}
+
+export {
+  ANTIGRAVITY_COUNTER_TO_MODEL_FAMILY,
+  ANTIGRAVITY_MODEL_TO_COUNTER_FAMILY,
+  ANTIGRAVITY_COUNTER_FAMILY_KEYS,
+  antigravityModelFamily,
+  antigravityCounterFamilyForModel,
+  antigravityCounterFamiliesForBucketId
+};

package/dist/{chunk-R4VCO2CB.js → chunk-YEHQ5FXZ.js}

@@ -246,6 +246,13 @@ async function transformResponseIn(response, logger) {
 }
 
 // src/transformer/transformers/utils/gemini.stream.ts
+function inlineDataToDataUrl(part) {
+  const inline = part.inlineData ?? part.inline_data;
+  const data = inline?.data;
+  if (typeof data !== "string" || !data) return null;
+  const mime = inline?.mimeType ?? inline?.mime_type ?? "image/png";
+  return `data:${mime};base64,${data}`;
+}
 async function transformResponseOut(response, providerName, logger) {
   const contentType = response.headers.get("Content-Type") ?? "";
   if (contentType.includes("application/json")) {
@@ -279,6 +286,7 @@ async function handleJsonResponse(response, providerName, logger) {
     }
   }));
   const textContent = nonThinkingParts.filter((part) => part.text).map((part) => part.text).join("\n");
+  const images = nonThinkingParts.map((part) => inlineDataToDataUrl(part)).filter((url) => url !== null);
   const openAIResponse = {
     id: jsonResponse.responseId ?? "",
     choices: [
@@ -288,6 +296,7 @@ async function handleJsonResponse(response, providerName, logger) {
         message: {
           content: textContent,
           role: "assistant",
+          images: images.length > 0 ? images : void 0,
           tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
           ...thinkingSignature && {
             thinking: {
@@ -445,6 +454,7 @@ function handleStreamResponse(response, providerName, logger) {
               signatureSent = true;
             }
           }
+          const images = parts.map((part) => inlineDataToDataUrl(part)).filter((url) => url !== null);
           if (textContent && !textBuffered) {
             if (!pendingContent) contentIndex++;
             const contentChunk = createChunk({
@@ -458,6 +468,21 @@ function handleStreamResponse(response, providerName, logger) {
             });
             controller.enqueue(encoder.encode(`data: ${JSON.stringify(contentChunk)}
 
+`));
+            contentSent = true;
+          }
+          if (images.length > 0) {
+            const imageChunk = createChunk({
+              responseId: chunk.responseId,
+              modelVersion: chunk.modelVersion,
+              contentIndex,
+              delta: { role: "assistant", images },
+              finishReason: candidate.finishReason,
+              usageMetadata: chunk.usageMetadata,
+              groundingMetadata: candidate.groundingMetadata
+            });
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(imageChunk)}
+
 `));
             contentSent = true;
           }
@@ -832,6 +857,9 @@ function buildRequestBody(request, provider, preserveNativeEffort = false) {
       thinkingBudget: reasoningPlan.budgetTokens
     };
   }
+  if (!generationConfig.responseModalities && typeof request.model === "string" && request.model.startsWith("gemini") && request.model.includes("-image")) {
+    generationConfig.responseModalities = ["TEXT", "IMAGE"];
+  }
   const body = {
     contents,
     tools: tools.length > 0 ? tools : void 0,

package/dist/{chunk-HDXSPXIN.js → chunk-ZBDDPWVQ.js}

@@ -1,12 +1,12 @@
 import {
   serializeError
 } from "./chunk-AVYJ4YBN.js";
-import {
-  isAccountAllowanceExhaustedError
-} from "./chunk-C3NPMQTK.js";
 import {
   isBoundAccountSelectionError
 } from "./chunk-2JYRIADS.js";
+import {
+  isAccountAllowanceExhaustedError
+} from "./chunk-JHJRZ75C.js";
 
 // src/pipeline/SubscriptionAuthSource.ts
 function stripAuthHeaders(headers) {
@@ -39,6 +39,7 @@ var SubscriptionAuthSource = class {
         upstreamUrl: hints.upstreamUrl,
         resolvedModel: hints.model,
         sessionKey: hints.sessionKey,
+        callerOpenCodeSession: hints.callerOpenCodeSession,
         reportSelection: hints.reportSelection,
         preferredAccountId: hints.preferredAccountId,
         preferredAccountGroup: hints.preferredAccountGroup,