@omnicross/core 0.1.4 → 0.1.6

package/dist/chunk-HVBBDBS3.cjs

@@ -0,0 +1,350 @@
+"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;// src/pipeline/AccountAllowanceStore.ts
+var DEFAULT_CODEX_ALLOWANCE_FRESH_MS = 15 * 6e4;
+var DEFAULT_ALLOWANCE_MAX_SNAPSHOTS = 256;
+var MAX_WINDOWS_PER_SNAPSHOT = 8;
+var MAX_TEXT_LENGTH = 200;
+function snapshotKey(providerId, accountId) {
+  return `${providerId}\0${accountId}`;
+}
+function cloneWindow(window) {
+  return {
+    id: window.id,
+    label: window.label,
+    scope: window.scope,
+    ...window.modelFamily === void 0 ? {} : { modelFamily: window.modelFamily },
+    usedPercent: window.usedPercent,
+    ...window.windowMinutes === void 0 ? {} : { windowMinutes: window.windowMinutes },
+    ...window.resetsAt === void 0 ? {} : { resetsAt: window.resetsAt },
+    ...window.remainingSeconds === void 0 ? {} : { remainingSeconds: window.remainingSeconds },
+    state: window.state
+  };
+}
+function cloneSnapshot(snapshot) {
+  return {
+    providerId: snapshot.providerId,
+    accountId: snapshot.accountId,
+    source: snapshot.source,
+    observedAt: snapshot.observedAt,
+    ...snapshot.expiresAt === void 0 ? {} : { expiresAt: snapshot.expiresAt },
+    windows: snapshot.windows.map(cloneWindow),
+    ...snapshot.lastErrorCode === void 0 ? {} : { lastErrorCode: snapshot.lastErrorCode },
+    ...snapshot.primaryOverSecondaryLimitPercent === void 0 ? {} : { primaryOverSecondaryLimitPercent: snapshot.primaryOverSecondaryLimitPercent }
+  };
+}
+function finiteNumber(value) {
+  if (value === null || value === void 0 || value === "") return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function boundedText(value, max = MAX_TEXT_LENGTH) {
+  return typeof value === "string" && value.length > 0 && value.length <= max ? value : void 0;
+}
+function finitePercent(value) {
+  if (value === null) return null;
+  if (value === void 0 || value === "") return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 && parsed <= 100 ? parsed : void 0;
+}
+function finiteNonNegativeInteger(value) {
+  const parsed = finiteNumber(value);
+  return parsed === void 0 ? void 0 : Math.floor(parsed);
+}
+function normalizedInstant(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : void 0;
+}
+function isAllowanceProvider(value) {
+  return value === "claude" || value === "codex" || value === "gemini" || value === "opencodego";
+}
+function isWindowState(value) {
+  return value === "fresh" || value === "stale" || value === "unavailable" || value === "unsupported";
+}
+function normalizeAccountAllowanceSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  const providerId = raw.providerId;
+  const accountId = boundedText(raw.accountId);
+  const source = raw.source;
+  const observedAt = normalizedInstant(raw.observedAt);
+  if (!isAllowanceProvider(providerId) || !accountId || source !== "oauth-usage-api" && source !== "response-headers" || !observedAt || !Array.isArray(raw.windows) || raw.windows.length > MAX_WINDOWS_PER_SNAPSHOT) return null;
+  const windows = [];
+  for (const item of raw.windows) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+    const window = item;
+    const id = boundedText(window.id);
+    const label = boundedText(window.label);
+    const scope = window.scope;
+    const state = window.state;
+    const usedPercent = finitePercent(window.usedPercent);
+    if (!id || !label || scope !== "all" && scope !== "model-family" || !isWindowState(state) || window.usedPercent !== void 0 && usedPercent === void 0) return null;
+    const modelFamily = boundedText(window.modelFamily, 80);
+    if (scope === "model-family" && !modelFamily) return null;
+    const windowMinutes = window.windowMinutes === void 0 ? void 0 : finiteNonNegativeInteger(window.windowMinutes);
+    const remainingSeconds2 = window.remainingSeconds === void 0 ? void 0 : finiteNonNegativeInteger(window.remainingSeconds);
+    if (window.windowMinutes !== void 0 && windowMinutes === void 0 || window.remainingSeconds !== void 0 && remainingSeconds2 === void 0) return null;
+    const resetsAt = window.resetsAt === void 0 ? void 0 : normalizedInstant(window.resetsAt);
+    if (window.resetsAt !== void 0 && !resetsAt) return null;
+    windows.push({
+      id,
+      label,
+      scope,
+      ...scope === "model-family" ? { modelFamily } : {},
+      usedPercent: _nullishCoalesce(usedPercent, () => ( null)),
+      ...windowMinutes === void 0 ? {} : { windowMinutes },
+      ...resetsAt === void 0 ? {} : { resetsAt },
+      ...remainingSeconds2 === void 0 ? {} : { remainingSeconds: remainingSeconds2 },
+      state
+    });
+  }
+  const expiresAt = raw.expiresAt === void 0 ? void 0 : normalizedInstant(raw.expiresAt);
+  if (raw.expiresAt !== void 0 && !expiresAt) return null;
+  const lastErrorCode = raw.lastErrorCode === void 0 ? void 0 : typeof raw.lastErrorCode === "string" && /^[a-z0-9][a-z0-9_.-]{0,63}$/.test(raw.lastErrorCode) ? raw.lastErrorCode : void 0;
+  if (raw.lastErrorCode !== void 0 && lastErrorCode === void 0) return null;
+  let primaryOverSecondaryLimitPercent;
+  if (raw.primaryOverSecondaryLimitPercent !== void 0) {
+    if (raw.primaryOverSecondaryLimitPercent === null) return null;
+    const parsed = finitePercent(raw.primaryOverSecondaryLimitPercent);
+    if (parsed === void 0 || parsed === null) return null;
+    primaryOverSecondaryLimitPercent = parsed;
+  }
+  return {
+    providerId,
+    accountId,
+    source,
+    observedAt,
+    ...expiresAt === void 0 ? {} : { expiresAt },
+    windows,
+    ...lastErrorCode === void 0 ? {} : { lastErrorCode },
+    ...primaryOverSecondaryLimitPercent === void 0 ? {} : { primaryOverSecondaryLimitPercent }
+  };
+}
+function headerValue(headers, name) {
+  const getter = headers.get;
+  if (typeof getter === "function") return getter.call(headers, name);
+  const record = headers;
+  const wanted = name.toLowerCase();
+  for (const [key, value] of Object.entries(record)) {
+    if (key.toLowerCase() !== wanted) continue;
+    return Array.isArray(value) ? value[0] : value;
+  }
+  return void 0;
+}
+function parseWindow(headers, prefix) {
+  const usedPercent = _nullishCoalesce(finitePercent(headerValue(headers, `x-codex-${prefix}-used-percent`)), () => ( void 0));
+  const resetAfterSeconds = finiteNumber(
+    headerValue(headers, `x-codex-${prefix}-reset-after-seconds`)
+  );
+  const windowMinutes = finiteNumber(headerValue(headers, `x-codex-${prefix}-window-minutes`));
+  if (usedPercent === void 0 && resetAfterSeconds === void 0 && windowMinutes === void 0) {
+    return void 0;
+  }
+  return { usedPercent, resetAfterSeconds, windowMinutes };
+}
+function parseCodexAllowanceHeaders(headers) {
+  const primary = parseWindow(headers, "primary");
+  const secondary = parseWindow(headers, "secondary");
+  const primaryOverSecondaryLimitPercent = _nullishCoalesce(finitePercent(
+    headerValue(headers, "x-codex-primary-over-secondary-limit-percent")
+  ), () => ( void 0));
+  if (!primary && !secondary && primaryOverSecondaryLimitPercent === void 0) return null;
+  return { primary, secondary, primaryOverSecondaryLimitPercent };
+}
+function durationLabel(minutes) {
+  if (minutes === void 0) return void 0;
+  if (minutes % (7 * 24 * 60) === 0) {
+    const weeks = minutes / (7 * 24 * 60);
+    return `${weeks} week${weeks === 1 ? "" : "s"}`;
+  }
+  if (minutes % (24 * 60) === 0) {
+    const days = minutes / (24 * 60);
+    return `${days} day${days === 1 ? "" : "s"}`;
+  }
+  if (minutes % 60 === 0) {
+    const hours = minutes / 60;
+    return `${hours} hour${hours === 1 ? "" : "s"}`;
+  }
+  return `${minutes} minutes`;
+}
+function codexLabel(id, minutes) {
+  const base = id === "primary" ? "Primary" : "Secondary";
+  const duration = durationLabel(minutes);
+  return duration ? `${base} \xB7 ${duration}` : base;
+}
+function resetAt(observedMs, seconds) {
+  if (seconds === void 0) return void 0;
+  return new Date(observedMs + seconds * 1e3).toISOString();
+}
+function remainingSeconds(resetsAt, now) {
+  if (!resetsAt) return void 0;
+  const resetMs = Date.parse(resetsAt);
+  if (!Number.isFinite(resetMs)) return void 0;
+  return Math.max(0, Math.floor((resetMs - now) / 1e3));
+}
+function mergeCodexWindow(id, observation, existing, observedMs) {
+  const windowMinutes = _nullishCoalesce(_optionalChain([observation, 'optionalAccess', _ => _.windowMinutes]), () => ( _optionalChain([existing, 'optionalAccess', _2 => _2.windowMinutes])));
+  const nextResetAt = _optionalChain([observation, 'optionalAccess', _3 => _3.resetAfterSeconds]) !== void 0 ? resetAt(observedMs, observation.resetAfterSeconds) : _optionalChain([existing, 'optionalAccess', _4 => _4.resetsAt]);
+  const hasExistingData = !!existing && (existing.usedPercent !== null || existing.windowMinutes !== void 0 || existing.resetsAt !== void 0);
+  return {
+    id,
+    label: codexLabel(id, windowMinutes),
+    scope: "all",
+    usedPercent: _nullishCoalesce(_nullishCoalesce(_optionalChain([observation, 'optionalAccess', _5 => _5.usedPercent]), () => ( _optionalChain([existing, 'optionalAccess', _6 => _6.usedPercent]))), () => ( null)),
+    windowMinutes,
+    resetsAt: nextResetAt,
+    remainingSeconds: remainingSeconds(nextResetAt, observedMs),
+    state: observation ? "fresh" : hasExistingData ? "stale" : "unavailable"
+  };
+}
+function projectSnapshot(snapshot, now) {
+  const expiredAt = snapshot.expiresAt ? Date.parse(snapshot.expiresAt) : Number.POSITIVE_INFINITY;
+  const expired = Number.isFinite(expiredAt) && expiredAt <= now;
+  return {
+    ...snapshot,
+    windows: snapshot.windows.map((window) => ({
+      ...window,
+      state: expired && window.state === "fresh" ? "stale" : window.state,
+      remainingSeconds: remainingSeconds(window.resetsAt, now)
+    }))
+  };
+}
+var AccountAllowanceStore = (_class = class {
+  constructor(now = Date.now, codexFreshMs = DEFAULT_CODEX_ALLOWANCE_FRESH_MS, persistence, maxSnapshots = DEFAULT_ALLOWANCE_MAX_SNAPSHOTS) {;_class.prototype.__init.call(this);
+    this.now = now;
+    this.codexFreshMs = codexFreshMs;
+    this.persistence = persistence;
+    this.maxSnapshots = Number.isFinite(maxSnapshots) && maxSnapshots > 0 ? Math.floor(maxSnapshots) : DEFAULT_ALLOWANCE_MAX_SNAPSHOTS;
+    this.loadPersisted();
+  }
+  
+  
+  
+  __init() {this.snapshots = /* @__PURE__ */ new Map()}
+  
+  set(snapshot) {
+    const normalized = normalizeAccountAllowanceSnapshot(snapshot);
+    if (!normalized) return;
+    this.snapshots.set(
+      snapshotKey(normalized.providerId, normalized.accountId),
+      normalized
+    );
+    while (this.snapshots.size > this.maxSnapshots) {
+      const oldest = this.snapshots.keys().next().value;
+      if (oldest === void 0) break;
+      this.snapshots.delete(oldest);
+    }
+    this.persist();
+  }
+  delete(providerId, accountId) {
+    if (this.snapshots.delete(snapshotKey(providerId, accountId))) this.persist();
+  }
+  /** Remove rows that no longer correspond to a configured account. */
+  pruneToKnownAccounts(accounts) {
+    const known = /* @__PURE__ */ new Set();
+    for (const account of accounts) {
+      if (account.accountId) known.add(snapshotKey(account.providerId, account.accountId));
+    }
+    let removed = 0;
+    for (const key of this.snapshots.keys()) {
+      if (!known.has(key)) {
+        this.snapshots.delete(key);
+        removed += 1;
+      }
+    }
+    if (removed > 0) this.persist();
+    return removed;
+  }
+  get(providerId, accountId, now = this.now()) {
+    const snapshot = this.snapshots.get(snapshotKey(providerId, accountId));
+    return snapshot ? projectSnapshot(cloneSnapshot(snapshot), now) : null;
+  }
+  list(filter = {}, now = this.now()) {
+    const out = [];
+    for (const snapshot of this.snapshots.values()) {
+      if (filter.providerId && snapshot.providerId !== filter.providerId) continue;
+      if (filter.accountId && snapshot.accountId !== filter.accountId) continue;
+      out.push(projectSnapshot(cloneSnapshot(snapshot), now));
+    }
+    return out.sort(
+      (a, b) => a.providerId.localeCompare(b.providerId) || a.accountId.localeCompare(b.accountId)
+    );
+  }
+  /**
+   * Merge one real Codex upstream response into the selected account's snapshot.
+   * A response with no recognized headers is a strict no-op, and a partial header
+   * set preserves previous values while marking untouched windows stale.
+   */
+  recordCodexHeaders(accountId, headers, observedMs = this.now()) {
+    if (!accountId) return null;
+    const observation = parseCodexAllowanceHeaders(headers);
+    if (!observation) return this.get("codex", accountId, observedMs);
+    const previous = this.snapshots.get(snapshotKey("codex", accountId));
+    const previousPrimary = _optionalChain([previous, 'optionalAccess', _7 => _7.source]) === "response-headers" ? previous.windows.find((window) => window.id === "primary") : void 0;
+    const previousSecondary = _optionalChain([previous, 'optionalAccess', _8 => _8.source]) === "response-headers" ? previous.windows.find((window) => window.id === "secondary") : void 0;
+    const observedAt = new Date(observedMs).toISOString();
+    const snapshot = {
+      providerId: "codex",
+      accountId,
+      source: "response-headers",
+      observedAt,
+      expiresAt: new Date(observedMs + this.codexFreshMs).toISOString(),
+      windows: [
+        mergeCodexWindow("primary", observation.primary, previousPrimary, observedMs),
+        mergeCodexWindow("secondary", observation.secondary, previousSecondary, observedMs)
+      ],
+      primaryOverSecondaryLimitPercent: _nullishCoalesce(observation.primaryOverSecondaryLimitPercent, () => ( _optionalChain([previous, 'optionalAccess', _9 => _9.primaryOverSecondaryLimitPercent])))
+    };
+    this.set(snapshot);
+    return this.get("codex", accountId, observedMs);
+  }
+  clear() {
+    if (this.snapshots.size === 0) return;
+    this.snapshots.clear();
+    this.persist();
+  }
+  loadPersisted() {
+    if (!this.persistence) return;
+    let payload;
+    try {
+      payload = this.persistence.load();
+    } catch (e) {
+      return;
+    }
+    if (!Array.isArray(payload)) return;
+    for (const value of payload) {
+      const snapshot = normalizeAccountAllowanceSnapshot(value);
+      if (!snapshot) continue;
+      this.snapshots.set(snapshotKey(snapshot.providerId, snapshot.accountId), snapshot);
+      if (this.snapshots.size >= this.maxSnapshots) break;
+    }
+  }
+  persist() {
+    if (!this.persistence) return;
+    try {
+      this.persistence.save(Array.from(this.snapshots.values(), cloneSnapshot));
+    } catch (e2) {
+    }
+  }
+}, _class);
+var sharedAllowanceStore = null;
+function getSharedAccountAllowanceStore() {
+  if (!sharedAllowanceStore) sharedAllowanceStore = new AccountAllowanceStore();
+  return sharedAllowanceStore;
+}
+function setSharedAccountAllowanceStore(store) {
+  sharedAllowanceStore = store;
+}
+function __resetSharedAccountAllowanceStoreForTests() {
+  sharedAllowanceStore = null;
+}
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_CODEX_ALLOWANCE_FRESH_MS = DEFAULT_CODEX_ALLOWANCE_FRESH_MS; exports.DEFAULT_ALLOWANCE_MAX_SNAPSHOTS = DEFAULT_ALLOWANCE_MAX_SNAPSHOTS; exports.normalizeAccountAllowanceSnapshot = normalizeAccountAllowanceSnapshot; exports.parseCodexAllowanceHeaders = parseCodexAllowanceHeaders; exports.AccountAllowanceStore = AccountAllowanceStore; exports.getSharedAccountAllowanceStore = getSharedAccountAllowanceStore; exports.setSharedAccountAllowanceStore = setSharedAccountAllowanceStore; exports.__resetSharedAccountAllowanceStoreForTests = __resetSharedAccountAllowanceStoreForTests;

package/dist/{chunk-7Y47UCF2.js → chunk-IFXJ2BG7.js}

@@ -11,11 +11,6 @@ import {
 
 // src/outbound-api/auditCapture.ts
 import { randomUUID } from "crypto";
-function isStreamingContentType(res) {
-  const ct = res.getHeader("content-type");
-  const value = Array.isArray(ct) ? ct.join(";") : String(ct ?? "");
-  return value.toLowerCase().includes("text/event-stream");
-}
 function resolveClientIp(req, trustForwardedFor) {
   if (trustForwardedFor) {
     const xff = req.headers["x-forwarded-for"];
@@ -27,18 +22,11 @@ function resolveClientIp(req, trustForwardedFor) {
   }
   return req.socket?.remoteAddress ?? void 0;
 }
-function truncateToBytes(text, maxBytes) {
-  const buf = Buffer.from(text, "utf8");
-  if (buf.length <= maxBytes) return text;
-  return buf.subarray(0, maxBytes).toString("utf8");
-}
 function beginAuditCapture(req, res, now) {
   const config = getAuditCaptureConfig();
   if (!config) return null;
   let rawRequestBody;
   const responseChunks = [];
-  let responseBytes = 0;
-  let streamDetected = false;
   let finished = false;
   const ctx = {
     setRequestBody(raw) {
@@ -46,19 +34,9 @@ function beginAuditCapture(req, res, now) {
     }
   };
   if (config.captureBodies) {
-    installResponseCapture(res, config.maxBodyBytes, {
+    installResponseCapture(res, {
       push(chunk) {
-        responseBytes += chunk.length;
         responseChunks.push(chunk);
-      },
-      get bytes() {
-        return responseBytes;
-      },
-      markStream() {
-        streamDetected = true;
-      },
-      get isStream() {
-        return streamDetected;
       }
     });
   }
@@ -92,9 +70,9 @@ function beginAuditCapture(req, res, now) {
       if (ctx.error) record.error = redactAuditText(ctx.error);
       if (config.captureBodies) {
         if (rawRequestBody != null && rawRequestBody.length > 0) {
-          record.requestBody = redactAuditText(truncateToBytes(rawRequestBody, config.maxBodyBytes));
+          record.requestBody = redactAuditText(rawRequestBody);
         }
-        if (!streamDetected && responseChunks.length > 0) {
+        if (responseChunks.length > 0) {
           const body = Buffer.concat(responseChunks).toString("utf8");
           record.responseBody = redactAuditText(body);
         }
@@ -106,24 +84,13 @@ function beginAuditCapture(req, res, now) {
   res.once("close", finalize);
   return ctx;
 }
-function installResponseCapture(res, maxBodyBytes, sink) {
-  let contentTypeChecked = false;
+function installResponseCapture(res, sink) {
   const capture = (chunk) => {
-    if (sink.isStream) return;
-    if (!contentTypeChecked) {
-      contentTypeChecked = true;
-      if (isStreamingContentType(res)) {
-        sink.markStream();
-        return;
-      }
-    }
-    if (sink.bytes >= maxBodyBytes) return;
     let buf = null;
     if (Buffer.isBuffer(chunk)) buf = chunk;
     else if (typeof chunk === "string") buf = Buffer.from(chunk, "utf8");
     if (!buf || buf.length === 0) return;
-    const remaining = maxBodyBytes - sink.bytes;
-    sink.push(buf.length > remaining ? buf.subarray(0, remaining) : buf);
+    sink.push(buf);
   };
   const originalWrite = res.write.bind(res);
   const originalEnd = res.end.bind(res);

package/dist/{chunk-46ZIFWYG.cjs → chunk-IIRPUVPH.cjs}

@@ -134,7 +134,13 @@ var TransformerChainExecutor = class {
     const { endpointTransformer } = options;
     const context = {
       logger: this.logger,
-      providerName: provider.name
+      providerName: provider.name,
+      // The unified REQUEST this response answers. Response encoders need it to
+      // restore request-scoped protocol state that the chat wire cannot carry —
+      // e.g. which codex tools were declared `custom` (see
+      // `UnifiedChatRequestMeta.codexTools`), which decides whether a tool call
+      // is encoded back as a `function_call` or a `custom_tool_call` item.
+      req: request
     };
     let finalResponse = response;
     const bypass = this.shouldBypassTransformers(chain, endpointTransformer, request);

package/dist/{chunk-YGXJGRFI.cjs → chunk-KBM2W6UY.cjs}

@@ -321,6 +321,7 @@ function handleStreamResponse(response, providerName, logger) {
   let pendingContent = "";
   let contentIndex = 0;
   let toolCallIndex = -1;
+  let textBuffered = false;
   const stream = new ReadableStream({
     async start(controller) {
       const reader = response.body.getReader();
@@ -338,6 +339,7 @@ function handleStreamResponse(response, providerName, logger) {
           }
           const candidate = chunk.candidates[0];
           const parts = _optionalChain([candidate, 'access', _59 => _59.content, 'optionalAccess', _60 => _60.parts]) || [];
+          textBuffered = false;
           parts.filter((part) => part.text && part.thought === true).forEach((part) => {
             hasThinkingContent = true;
             const thinkingChunk = createChunk({
@@ -415,7 +417,7 @@ function handleStreamResponse(response, providerName, logger) {
           if (hasThinkingContent && textContent && !signatureSent) {
             if (_optionalChain([chunk, 'access', _70 => _70.modelVersion, 'optionalAccess', _71 => _71.includes, 'call', _72 => _72("3")])) {
               pendingContent += textContent;
-              return;
+              textBuffered = true;
             } else {
               const signatureChunk = createChunk({
                 responseId: chunk.responseId,
@@ -433,7 +435,7 @@ function handleStreamResponse(response, providerName, logger) {
               signatureSent = true;
             }
           }
-          if (textContent) {
+          if (textContent && !textBuffered) {
             if (!pendingContent) contentIndex++;
             const contentChunk = createChunk({
               responseId: chunk.responseId,
@@ -790,6 +792,9 @@ function buildRequestBody(request) {
     }
   });
   const generationConfig = {};
+  if (request.max_tokens !== void 0) {
+    generationConfig.maxOutputTokens = request.max_tokens;
+  }
   if (_optionalChain([request, 'access', _117 => _117.reasoning, 'optionalAccess', _118 => _118.effort]) && request.reasoning.effort !== "none") {
     generationConfig.thinkingConfig = {
       includeThoughts: true
@@ -841,7 +846,8 @@ function transformRequestOut(request) {
   const contents = request.contents;
   const tools = request.tools;
   const model = request.model;
-  const maxTokens = request.max_tokens;
+  const generationConfig = request.generationConfig;
+  const maxTokens = _nullishCoalesce(_optionalChain([generationConfig, 'optionalAccess', _122 => _122.maxOutputTokens]), () => ( request.max_tokens));
   const temperature = request.temperature;
   const stream = request.stream;
   const toolChoice = request.tool_choice;
@@ -854,35 +860,116 @@ function transformRequestOut(request) {
     tool_choice: toolChoice
   };
   if (Array.isArray(contents)) {
+    const toolCallIdsByName = /* @__PURE__ */ new Map();
     for (const content of contents) {
       if (typeof content === "string") {
-        unifiedRequest.messages.push({
-          role: "user",
-          content
-        });
-      } else if ("text" in content && typeof content.text === "string") {
+        unifiedRequest.messages.push({ role: "user", content });
+        continue;
+      }
+      if (content && typeof content === "object" && "text" in content && typeof content.text === "string" && !("parts" in content)) {
         unifiedRequest.messages.push({
           role: "user",
           content: content.text || null
         });
-      } else if ("role" in content && content.role === "user") {
-        const geminiContent = content;
-        unifiedRequest.messages.push({
-          role: "user",
-          content: _optionalChain([geminiContent, 'access', _122 => _122.parts, 'optionalAccess', _123 => _123.map, 'call', _124 => _124((part) => ({
-            type: "text",
-            text: part.text || ""
-          }))]) || []
-        });
-      } else if (content.role === "model") {
+        continue;
+      }
+      if (!content || typeof content !== "object" || !("role" in content)) {
+        continue;
+      }
+      const geminiContent = content;
+      const isModel = geminiContent.role === "model";
+      const role = isModel ? "assistant" : "user";
+      const parts = _nullishCoalesce(geminiContent.parts, () => ( []));
+      const functionResponses = [];
+      const functionCalls = [];
+      const textParts = [];
+      const contentParts = [];
+      let thinkingText = "";
+      let signature;
+      for (const part of parts) {
+        if ("thoughtSignature" in part) {
+          signature = part.thoughtSignature;
+        }
+        if ("functionResponse" in part) {
+          functionResponses.push(part);
+        } else if ("functionCall" in part) {
+          functionCalls.push(part);
+        } else if ("inlineData" in part || "file_data" in part) {
+          const inline = part.inlineData;
+          const fileData = part.file_data;
+          if (_optionalChain([inline, 'optionalAccess', _123 => _123.data])) {
+            const mime = inline.mime_type || "image/png";
+            contentParts.push({
+              type: "image_url",
+              image_url: { url: `data:${mime};base64,${inline.data}` },
+              media_type: mime
+            });
+          } else if (_optionalChain([fileData, 'optionalAccess', _124 => _124.file_uri])) {
+            contentParts.push({
+              type: "image_url",
+              image_url: { url: fileData.file_uri },
+              media_type: fileData.mime_type
+            });
+          }
+        } else if ("text" in part) {
+          if (part.thought === true) {
+            thinkingText += _nullishCoalesce(part.text, () => ( ""));
+          } else {
+            textParts.push(part);
+          }
+        }
+      }
+      for (const fr of functionResponses) {
+        const fnName = _nullishCoalesce(fr.functionResponse.name, () => ( ""));
+        const queue = toolCallIdsByName.get(fnName);
+        const id = queue && queue.length > 0 ? queue.shift() : `tool_${Math.random().toString(36).substring(2, 15)}`;
+        const response = fr.functionResponse.response;
+        const result = _optionalChain([response, 'optionalAccess', _125 => _125.result]);
+        const toolContent = typeof result === "string" ? result : result !== void 0 ? JSON.stringify(result) : response !== void 0 ? JSON.stringify(response) : "";
         unifiedRequest.messages.push({
-          role: "assistant",
-          content: _optionalChain([content, 'access', _125 => _125.parts, 'optionalAccess', _126 => _126.map, 'call', _127 => _127((part) => ({
-            type: "text",
-            text: part.text || ""
-          }))]) || []
+          role: "tool",
+          tool_call_id: id,
+          content: toolContent
         });
       }
+      const toolCalls = functionCalls.map((p) => {
+        const id = p.functionCall.id || `tool_${Math.random().toString(36).substring(2, 15)}`;
+        if (p.functionCall.name) {
+          const arr = _nullishCoalesce(toolCallIdsByName.get(p.functionCall.name), () => ( []));
+          arr.push(id);
+          toolCallIdsByName.set(p.functionCall.name, arr);
+        }
+        return {
+          id,
+          type: "function",
+          function: {
+            name: p.functionCall.name,
+            arguments: JSON.stringify(_nullishCoalesce(p.functionCall.args, () => ( {})))
+          }
+        };
+      });
+      const onlyToolResults = functionResponses.length > 0 && textParts.length === 0 && functionCalls.length === 0 && contentParts.length === 0 && !thinkingText && !signature;
+      if (onlyToolResults) continue;
+      let messageContent;
+      if (contentParts.length > 0) {
+        messageContent = [
+          ...textParts.map((p) => ({ type: "text", text: p.text })),
+          ...contentParts
+        ];
+      } else {
+        messageContent = textParts.map((p) => p.text).join("\n") || null;
+      }
+      const message = {
+        role,
+        content: messageContent
+      };
+      if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+      }
+      if (signature || thinkingText) {
+        message.thinking = { content: thinkingText || "", signature };
+      }
+      unifiedRequest.messages.push(message);
     }
   }
   if (Array.isArray(tools)) {
@@ -895,7 +982,7 @@ function transformRequestOut(request) {
             function: {
               name: funcDecl.name,
               description: _nullishCoalesce(funcDecl.description, () => ( "")),
-              parameters: _nullishCoalesce(funcDecl.parameters, () => ( {}))
+              parameters: _nullishCoalesce(_nullishCoalesce(funcDecl.parameters, () => ( funcDecl.parametersJsonSchema)), () => ( {}))
             }
           });
         }