@omnicross/core 0.1.5 → 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-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-JWVTXXPX.cjs → chunk-KBM2W6UY.cjs}

@@ -792,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
@@ -843,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;
@@ -893,14 +897,14 @@ function transformRequestOut(request) {
         } else if ("inlineData" in part || "file_data" in part) {
           const inline = part.inlineData;
           const fileData = part.file_data;
-          if (_optionalChain([inline, 'optionalAccess', _122 => _122.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', _123 => _123.file_uri])) {
+          } else if (_optionalChain([fileData, 'optionalAccess', _124 => _124.file_uri])) {
             contentParts.push({
               type: "image_url",
               image_url: { url: fileData.file_uri },
@@ -920,7 +924,7 @@ function transformRequestOut(request) {
         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', _124 => _124.result]);
+        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: "tool",

package/dist/{chunk-PG7PS2NN.cjs → chunk-KCVJWJST.cjs}

@@ -4,6 +4,9 @@
 
 var _chunk3Z5BQZFMcjs = require('./chunk-3Z5BQZFM.cjs');
 
+
+var _chunkHVBBDBS3cjs = require('./chunk-HVBBDBS3.cjs');
+
 // src/pipeline/upstreamFetch.ts
 var _undici = require('undici');
 var _socks = require('socks');
@@ -102,8 +105,17 @@ function resolveUpstreamDispatcher(ctx) {
 function fetchUpstream(url, init, ctx) {
   const dispatcher = resolveUpstreamDispatcher({ ..._nullishCoalesce(ctx, () => ( {})), url });
   const doFetch = dispatcher ? () => fetch(url, { ...init, dispatcher }) : () => fetch(url, init);
+  const doFetchWithAllowanceTap = () => doFetch().then((response) => {
+    if (_optionalChain([ctx, 'optionalAccess', _3 => _3.providerId]) === "codex" && ctx.accountId) {
+      try {
+        _chunkHVBBDBS3cjs.getSharedAccountAllowanceStore.call(void 0, ).recordCodexHeaders(ctx.accountId, response.headers);
+      } catch (e4) {
+      }
+    }
+    return response;
+  });
   const tracePath = _chunk3Z5BQZFMcjs.getUpstreamTracePath.call(void 0, );
-  if (!tracePath || !_optionalChain([ctx, 'optionalAccess', _3 => _3.providerId])) return doFetch();
+  if (!tracePath || !_optionalChain([ctx, 'optionalAccess', _4 => _4.providerId])) return doFetchWithAllowanceTap();
   const startedAt = Date.now();
   const method = typeof init.method === "string" ? init.method : "GET";
   const requestHeaders = _chunk3Z5BQZFMcjs.redactHeaders.call(void 0, 
@@ -112,7 +124,7 @@ function fetchUpstream(url, init, ctx) {
   const requestBody = typeof init.body === "string" ? init.body : null;
   const providerId = ctx.providerId;
   const accountId = ctx.accountId;
-  return doFetch().then((res) => {
+  return doFetchWithAllowanceTap().then((res) => {
     const clone = res.clone();
     const status = res.status;
     const statusText = res.statusText;

package/dist/chunk-LB6EBS6Y.js

@@ -0,0 +1,69 @@
+// src/transformer/transformers/OpenAITransformer.ts
+var FOREIGN_MESSAGE_KEYS = ["cache_control", "thinking"];
+var FOREIGN_BODY_KEYS = ["meta", "reasoning", "thinking"];
+function normalizeContent(content) {
+  if (!Array.isArray(content)) return content;
+  const cleaned = content.map((block) => {
+    if (block && typeof block === "object" && "cache_control" in block) {
+      const { cache_control: _dropped, ...rest } = block;
+      return rest;
+    }
+    return block;
+  });
+  if (cleaned.length === 1) {
+    const only = cleaned[0];
+    if (only?.type === "text" && typeof only.text === "string") return only.text;
+  }
+  return cleaned;
+}
+var OpenAITransformer = class {
+  static TransformerName = "openai";
+  name = "openai";
+  endPoint = "/v1/chat/completions";
+  logger;
+  /**
+   * Unified → OpenAI Chat Completions.
+   */
+  async transformRequestIn(request, _provider, _context) {
+    const source = request;
+    const out = {};
+    for (const key of Object.keys(source)) {
+      if (FOREIGN_BODY_KEYS.includes(key)) continue;
+      out[key] = source[key];
+    }
+    if (Array.isArray(request.messages)) {
+      out.messages = request.messages.map((message) => {
+        const src = message;
+        const encoded = {};
+        for (const key of Object.keys(src)) {
+          if (FOREIGN_MESSAGE_KEYS.includes(key)) continue;
+          encoded[key] = src[key];
+        }
+        if (message.content !== void 0) {
+          encoded.content = normalizeContent(message.content);
+        }
+        const thinkingContent = message.thinking?.content;
+        if (typeof thinkingContent === "string" && thinkingContent.length > 0) {
+          encoded.reasoning_content = thinkingContent;
+        }
+        return encoded;
+      });
+    }
+    const effort = request.reasoning?.effort;
+    if (typeof effort === "string" && effort !== "none") {
+      out.reasoning_effort = effort;
+    }
+    return out;
+  }
+  /**
+   * OpenAI Chat Completions → Unified. Identity — see the module JSDoc for why
+   * `reasoning_content` is NOT rewritten here.
+   */
+  async transformResponseOut(response, _context) {
+    return response;
+  }
+};
+
+export {
+  OpenAITransformer
+};

package/dist/{chunk-IWQAX3CS.js → chunk-LVUCAWMK.js}

@@ -3,7 +3,7 @@ import {
   transformRequestOut,
   transformResponseIn,
   transformResponseOut
-} from "./chunk-6QZGDLL4.js";
+} from "./chunk-TOVPMMHM.js";
 
 // src/transformer/transformers/GeminiTransformer.ts
 var GeminiTransformer = class {