@omnicross/core 0.1.1 → 0.1.3

package/dist/chunk-Q27JY5RG.cjs

@@ -0,0 +1,126 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkA2YMUCBTcjs = require('./chunk-A2YMUCBT.cjs');
+
+
+
+var _chunkUNEFIWXIcjs = require('./chunk-UNEFIWXI.cjs');
+
+// src/completion/header-builder.ts
+function getProviderHeaders(provider, apiKey) {
+  const format = _chunkA2YMUCBTcjs.resolveApiFormat.call(void 0, provider);
+  let headers;
+  switch (format) {
+    case "anthropic":
+      headers = {
+        "Content-Type": "application/json",
+        // Third-party Anthropic-Messages relays often gate on a Bearer token
+        // rather than x-api-key; `provider.useBearer` opts into that.
+        ...provider.useBearer ? { Authorization: `Bearer ${apiKey}` } : { "x-api-key": apiKey },
+        "anthropic-version": "2025-01-10"
+        // Required for extended thinking feature
+      };
+      break;
+    case "google":
+      headers = {
+        "Content-Type": "application/json",
+        "x-goog-api-key": apiKey
+      };
+      break;
+    case "azure-openai":
+      headers = {
+        "Content-Type": "application/json",
+        "api-key": apiKey
+      };
+      break;
+    case "openai":
+    case "openai-response":
+    default:
+      headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      };
+      break;
+  }
+  if (_chunkUNEFIWXIcjs.isOpenRouterProvider.call(void 0, provider)) {
+    return { ...headers, ..._chunkUNEFIWXIcjs.OPENROUTER_APP_HEADERS };
+  }
+  return headers;
+}
+
+// src/pipeline/LlmConfigProviderAuth.ts
+function isReportableStatus(status) {
+  return status === 429 || status === 529 || status === 401 || status === 403;
+}
+var LlmConfigProviderAuth = class {
+  
+  
+  
+  
+  /**
+   * The current resolved key. Mutable so a Phase-3 caller can read the
+   * rotated key after `onResult`; this phase it is only set at construction
+   * and updated inside `onResult` (mirroring the inline re-point in
+   * `callWithPoolReporting`).
+   */
+  
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.apiKey = opts.apiKey;
+    this.apiKeyPool = _nullishCoalesce(opts.apiKeyPool, () => ( null));
+    this.providerId = opts.providerId;
+    this.sessionId = opts.sessionId;
+  }
+  /**
+   * Merge the provider auth headers (and content-type / OpenRouter app
+   * headers) into `headers`, exactly as a direct `getProviderHeaders` call
+   * would produce them. `hints` are accepted for contract symmetry but the
+   * provider-key path does not vary headers by URL/model.
+   */
+  applyHeaders(headers, _hints) {
+    const authHeaders = getProviderHeaders(this.provider, this.apiKey);
+    for (const [k, v] of Object.entries(authHeaders)) {
+      headers[k] = v;
+    }
+  }
+  /**
+   * React to the final HTTP status — the pool-rotation seam (design D5).
+   *
+   * Reproduces `callWithPoolReporting`'s reportable + success branches:
+   *  - reportable status (429/529/401/403) on a pool-backed request →
+   *    `reportError(providerId, sessionId, status)`; when it hands back a
+   *    `newKey` the session was re-bound, so we adopt it (`this.apiKey`) and
+   *    return `{ rebound: true, newKey }`. When no key is available it returns
+   *    `{ rebound: false }` (the session is still cooled/disabled by the report).
+   *  - success / any 2xx → `reportSuccess(sessionId)`; `{ rebound: false }`.
+   *  - non-reportable, non-success, or non-pool request → no-op
+   *    `{ rebound: false }`.
+   *
+   * NOTE: no caller invokes this in Phase 2; it is unit-tested in isolation.
+   */
+  async onResult(status) {
+    const pool = this.apiKeyPool;
+    const providerId = this.providerId;
+    const sessionId = this.sessionId;
+    if (!pool || !providerId || !sessionId) {
+      return { rebound: false };
+    }
+    if (isReportableStatus(status)) {
+      const newKey = await pool.reportError(providerId, sessionId, status);
+      if (newKey) {
+        this.apiKey = newKey;
+        return { rebound: true, newKey };
+      }
+      return { rebound: false };
+    }
+    if (status !== null && status >= 200 && status < 300) {
+      pool.reportSuccess(sessionId);
+    }
+    return { rebound: false };
+  }
+};
+
+
+
+
+exports.getProviderHeaders = getProviderHeaders; exports.LlmConfigProviderAuth = LlmConfigProviderAuth;

package/dist/chunk-QBZJ7P2T.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/outbound-api/subscriptionRegistryPort.ts
+var _registry = null;
+function setSubscriptionRegistryForOutbound(registry) {
+  _registry = registry;
+}
+function getSubscriptionRegistryForOutbound() {
+  return _registry;
+}
+
+
+
+
+exports.setSubscriptionRegistryForOutbound = setSubscriptionRegistryForOutbound; exports.getSubscriptionRegistryForOutbound = getSubscriptionRegistryForOutbound;

package/dist/chunk-QWBWGODS.cjs

@@ -0,0 +1,69 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/provider-proxy/matchText.ts
+var MATCH_TEXT_PER_MESSAGE_CAP = 8192;
+var MATCH_TEXT_RECENT_MESSAGES = 6;
+function flattenMatchText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const item of value) {
+      const text = flattenMatchText(item);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if (obj.type === "tool_result" && obj.content !== void 0) {
+      return flattenMatchText(obj.content);
+    }
+    if (typeof obj.text === "string") return obj.text;
+  }
+  return "";
+}
+function collectMatchText(anthropicBody) {
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  const slices = [];
+  const sys = flattenMatchText(anthropicBody.system).trim();
+  if (sys) slices.push(sys.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const recent = [];
+  for (let i = messages.length - 1; i >= 0 && recent.length < MATCH_TEXT_RECENT_MESSAGES; i--) {
+    const message = messages[i];
+    if (!message || typeof message !== "object") continue;
+    const role = message.role;
+    if (role !== "user" && role !== "system") continue;
+    const text = flattenMatchText(message.content).trim();
+    if (text) recent.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  for (let i = recent.length - 1; i >= 0; i--) slices.push(recent[i]);
+  return slices;
+}
+function deriveSubscriptionSessionKey(anthropicBody) {
+  const system = flattenMatchText(anthropicBody.system).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  let firstUser = "";
+  for (const message of messages) {
+    if (message && typeof message === "object" && message.role === "user") {
+      firstUser = flattenMatchText(message.content).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+      break;
+    }
+  }
+  const anchor = `${system}\0${firstUser}`;
+  if (!system && !firstUser) return void 0;
+  return fnv1a(anchor);
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+
+
+
+
+
+
+exports.MATCH_TEXT_PER_MESSAGE_CAP = MATCH_TEXT_PER_MESSAGE_CAP; exports.MATCH_TEXT_RECENT_MESSAGES = MATCH_TEXT_RECENT_MESSAGES; exports.flattenMatchText = flattenMatchText; exports.collectMatchText = collectMatchText; exports.deriveSubscriptionSessionKey = deriveSubscriptionSessionKey;

package/dist/chunk-QXD4MV2X.cjs

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/pipeline/resolveProviderChain.ts
+async function resolveProviderChain(llmConfig, providerId, model) {
+  const cachedChain = await llmConfig.resolveTransformerChain(providerId, model);
+  const mainTransformer = await llmConfig.getMainTransformer(providerId);
+  const chain = {
+    providerTransformers: [...cachedChain.providerTransformers],
+    modelTransformers: [...cachedChain.modelTransformers]
+  };
+  if (mainTransformer) {
+    const alreadyInChain = chain.providerTransformers.some(
+      (t) => t.name === mainTransformer.name
+    );
+    if (!alreadyInChain) {
+      chain.providerTransformers.unshift(mainTransformer);
+    }
+  }
+  const hasTransformers = chain.providerTransformers.length > 0 || chain.modelTransformers.length > 0;
+  return { chain, mainTransformer, hasTransformers };
+}
+
+
+
+exports.resolveProviderChain = resolveProviderChain;

package/dist/chunk-R3HK6R4B.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/ports/gemini-code-assist-resolver.ts
+var resolver = null;
+function setGeminiCodeAssistResolver(impl) {
+  resolver = impl;
+}
+function getGeminiCodeAssistResolver() {
+  return resolver;
+}
+
+
+
+
+exports.setGeminiCodeAssistResolver = setGeminiCodeAssistResolver; exports.getGeminiCodeAssistResolver = getGeminiCodeAssistResolver;

package/dist/chunk-RPII3E6Z.cjs

@@ -0,0 +1,145 @@
+"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 _chunk6RPZADX3cjs = require('./chunk-6RPZADX3.cjs');
+
+// src/provider-proxy/identity/SubscriptionIdentityStore.ts
+var CC_HEADER_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var KEY_SEP = "\0";
+function normalizeUa(ua) {
+  if (typeof ua !== "string") return void 0;
+  const trimmed = ua.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+var SubscriptionIdentityStore = (_class = class {
+  __init() {this.identities = /* @__PURE__ */ new Map()}
+  
+  
+  
+  
+  __init2() {this.persistence = null}
+  constructor(opts = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.now = _nullishCoalesce(opts.now, () => ( Date.now));
+    this.enabled = _nullishCoalesce(opts.enabled, () => ( false));
+    this.ua = normalizeUa(opts.ua);
+    this.ccHeaderTtlMs = _nullishCoalesce(opts.ccHeaderTtlMs, () => ( CC_HEADER_TTL_MS));
+  }
+  /** Whether capture/replay is engaged (config flag). */
+  isEnabled() {
+    return this.enabled;
+  }
+  /** The operator UA baseline (piece 4), or undefined when unset. */
+  uaBaseline() {
+    return this.ua;
+  }
+  /**
+   * Re-apply config to the LIVE shared instance (bootstrap, mirroring the health
+   * tracker's `configure`). Only defined fields override; `ua: null` clears the
+   * baseline.
+   */
+  configure(opts) {
+    if (opts.enabled !== void 0) this.enabled = opts.enabled;
+    if (opts.ua !== void 0) this.ua = normalizeUa(_nullishCoalesce(opts.ua, () => ( void 0)));
+  }
+  /** Install (or clear) the write-through persistence port (P2). */
+  setPersistence(port) {
+    this.persistence = port;
+  }
+  /**
+   * Boot seed (P2, D5): install a PERSISTED identity for an account, but NEVER
+   * over a live in-memory capture (a re-captured identity from this session wins).
+   * A no-op for an empty/absent identity. Does NOT write back through the port.
+   */
+  seed(providerId, accountId, identity) {
+    if (!accountId || !identity) return;
+    const headers = _chunk6RPZADX3cjs.sanitizeFrozenHeaders.call(void 0, _nullishCoalesce(identity.headers, () => ( {})));
+    if (Object.keys(headers).length === 0) return;
+    const key = this.key(providerId, accountId);
+    if (this.identities.has(key)) return;
+    this.identities.set(key, {
+      headers,
+      capturedAt: typeof identity.capturedAt === "number" ? identity.capturedAt : this.now()
+    });
+  }
+  /**
+   * Capture a real client's fingerprint headers for an account. First-seen ⇒
+   * FREEZE the whole (sanitized) bag. Already-frozen ⇒ within the TTL, no change
+   * (stable identity); past the TTL, refresh the NON-stainless headers from the
+   * new observation while keeping stainless frozen-stable (P2). An empty/absent
+   * account id or an empty sanitized bag is a no-op (so an account with no
+   * fingerprint headers never freezes an empty identity → the caller falls back
+   * to the UA baseline). Fires the persistence port on a freeze/refresh.
+   */
+  capture(providerId, accountId, incoming, now = this.now()) {
+    if (!accountId) return;
+    const clean = _chunk6RPZADX3cjs.sanitizeFrozenHeaders.call(void 0, incoming);
+    if (Object.keys(clean).length === 0) return;
+    const key = this.key(providerId, accountId);
+    const existing = this.identities.get(key);
+    if (!existing) {
+      const frozen = { headers: clean, capturedAt: now };
+      this.identities.set(key, frozen);
+      this.emitPersist(providerId, accountId, frozen);
+      return;
+    }
+    if (now - existing.capturedAt < this.ccHeaderTtlMs) return;
+    const refreshed = {
+      headers: _chunk6RPZADX3cjs.refreshNonStainless.call(void 0, existing.headers, clean),
+      capturedAt: now
+    };
+    this.identities.set(key, refreshed);
+    this.emitPersist(providerId, accountId, refreshed);
+  }
+  /**
+   * The frozen identity headers for an account, or `undefined` when none is
+   * frozen (or the frozen set is empty). Returns a COPY (the caller merges it into
+   * a mutable outbound header bag).
+   */
+  replay(providerId, accountId) {
+    if (!accountId) return void 0;
+    const frozen = this.identities.get(this.key(providerId, accountId));
+    if (!frozen || Object.keys(frozen.headers).length === 0) return void 0;
+    return { ...frozen.headers };
+  }
+  /** Whether an identity is frozen for an account (admin coarse status — D7). */
+  hasIdentity(providerId, accountId) {
+    const frozen = this.identities.get(this.key(providerId, accountId));
+    return !!frozen && Object.keys(frozen.headers).length > 0;
+  }
+  /** The freeze/refresh time for an account's identity (admin coarse status). */
+  capturedAt(providerId, accountId) {
+    return _optionalChain([this, 'access', _ => _.identities, 'access', _2 => _2.get, 'call', _3 => _3(this.key(providerId, accountId)), 'optionalAccess', _4 => _4.capturedAt]);
+  }
+  emitPersist(providerId, accountId, identity) {
+    if (!this.persistence) return;
+    try {
+      this.persistence.persist(providerId, accountId, {
+        headers: { ...identity.headers },
+        capturedAt: identity.capturedAt
+      });
+    } catch (e) {
+    }
+  }
+  key(providerId, accountId) {
+    return `${providerId}${KEY_SEP}${accountId}`;
+  }
+}, _class);
+var _shared = null;
+function getSharedIdentityStore() {
+  if (!_shared) _shared = new SubscriptionIdentityStore();
+  return _shared;
+}
+function setSharedIdentityStore(instance) {
+  _shared = instance;
+}
+function __resetSharedIdentityStoreForTests() {
+  _shared = null;
+}
+
+
+
+
+
+
+
+exports.CC_HEADER_TTL_MS = CC_HEADER_TTL_MS; exports.SubscriptionIdentityStore = SubscriptionIdentityStore; exports.getSharedIdentityStore = getSharedIdentityStore; exports.setSharedIdentityStore = setSharedIdentityStore; exports.__resetSharedIdentityStoreForTests = __resetSharedIdentityStoreForTests;

package/dist/chunk-RSJ3TWJQ.cjs

@@ -0,0 +1,186 @@
+"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 _chunkYGXJGRFIcjs = require('./chunk-YGXJGRFI.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;
+}
+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) {
+  if (parsed && typeof parsed === "object" && "response" in parsed) {
+    return parsed.response;
+  }
+  return parsed;
+}
+async function unwrapCodeAssistResponse(response) {
+  const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
+  if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
+    const sourceBody = response.body;
+    if (!sourceBody) return response;
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const peeled = new ReadableStream({
+      async start(controller) {
+        const reader = sourceBody.getReader();
+        let buffer = "";
+        const processLine = (line) => {
+          if (!line.startsWith("data:")) {
+            if (line.length > 0) controller.enqueue(encoder.encode(`${line}
+`));
+            return;
+          }
+          const payload = line.slice(line.indexOf(":") + 1).trim();
+          if (!payload || payload === "[DONE]") {
+            controller.enqueue(encoder.encode(`${line}
+`));
+            return;
+          }
+          try {
+            const parsed = JSON.parse(payload);
+            const inner2 = peelResponseEnvelope(parsed);
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(inner2)}
+`));
+          } catch (e) {
+            controller.enqueue(encoder.encode(`${line}
+`));
+          }
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (buffer) processLine(buffer);
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) processLine(line);
+          }
+        } catch (err) {
+          controller.error(err);
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(peeled, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  const raw = await response.json().catch(() => null);
+  const inner = peelResponseEnvelope(raw);
+  return new Response(JSON.stringify(inner), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+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"}
+  
+  /** Code Assist has no fixed `/models/:modelAndAction` endpoint pattern — the
+   *  URL is built per-request in `transformRequestIn`. Left undefined so the
+   *  TransformerService does NOT treat this as an endpoint (reverse) transformer. */
+  __init2() {this.endPoint = void 0}
+  /**
+   * unified → Code Assist envelope.
+   *
+   * Builds the inner public-Gemini body via the shared `buildRequestBody`, then
+   * wraps it as `{ model, project, user_prompt_id, request: <inner> }` and sets
+   * the Code Assist URL + Bearer-only headers.
+   *
+   * The resolved Code Assist `project` is threaded in via `provider.geminiProject`
+   * (stashed by the subscription dispatch seam — see SubscriptionDispatcher /
+   * openaiResponsesIngress). `undefined` is the valid fresh free-tier value.
+   */
+  async transformRequestIn(request, provider, _context) {
+    const inner = _chunkYGXJGRFIcjs.buildRequestBody.call(void 0, request);
+    const envelope = {
+      model: request.model,
+      project: provider.geminiProject,
+      user_prompt_id: generateUserPromptId(),
+      request: inner
+    };
+    const url = buildCodeAssistUrl(Boolean(request.stream));
+    const headers = {
+      "x-goog-api-key": void 0,
+      "X-Goog-Api-Key": void 0
+    };
+    return {
+      body: envelope,
+      config: { url, headers }
+    };
+  }
+  /**
+   * Code Assist request → unified (endpoint-decode parity with GeminiTransformer).
+   * Peels the top-level `request` envelope first, then delegates to the shared
+   * gemini request decoder. Not used on the subscription dispatch path (the
+   * endpoint transformer there is Anthropic/OpenAI-Response), but provided for
+   * completeness so this transformer is a drop-in for 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 _chunkYGXJGRFIcjs.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 _chunkYGXJGRFIcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
+  }
+  /**
+   * OpenAI-compatible response → Code Assist (endpoint-encode parity). Re-wraps
+   * the standard gemini response under the top-level `response` key after the
+   * shared gemini encoder produces a public-Gemini body. Symmetric with
+   * `transformResponseOut`'s peel.
+   */
+  async transformResponseIn(response, _context) {
+    const geminiResponse = await _chunkYGXJGRFIcjs.transformResponseIn.call(void 0, response, this.logger);
+    const contentType = _nullishCoalesce(geminiResponse.headers.get("Content-Type"), () => ( ""));
+    if (contentType.includes("text/event-stream")) {
+      return geminiResponse;
+    }
+    const data = await geminiResponse.json().catch(() => null);
+    return new Response(JSON.stringify({ response: data }), {
+      status: geminiResponse.status,
+      statusText: geminiResponse.statusText,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}, _class.__initStatic(), _class);
+
+
+
+
+
+
+exports.resolveCodeAssistEndpoint = resolveCodeAssistEndpoint; exports.resolveCodeAssistApiVersion = resolveCodeAssistApiVersion; exports.buildCodeAssistUrl = buildCodeAssistUrl; exports.GeminiCodeAssistTransformer = GeminiCodeAssistTransformer;