@omnicross/core 0.1.10 → 0.2.0

package/dist/{chunk-WNKWAEUR.js → chunk-EYGBM2VC.js}

@@ -30,6 +30,7 @@ var TransformerChainExecutor = class {
       providerName: provider.name
     };
     let requestBody = request;
+    let endpointRequest;
     let config = {};
     let bypass = false;
     bypass = this.shouldBypassTransformers(
@@ -60,6 +61,7 @@ var TransformerChainExecutor = class {
         this.logger.error(`transformRequestOut error: ${this.getErrorMessage(error)}`);
         throw error;
       }
+      endpointRequest = requestBody;
     }
     if (!bypass && chain.providerTransformers.length > 0) {
       this.logger.debug(`Executing ${chain.providerTransformers.length} provider transformers`);
@@ -118,7 +120,7 @@ var TransformerChainExecutor = class {
         true
       );
     }
-    return { requestBody, config, bypass };
+    return { requestBody, endpointRequest, config, bypass };
   }
   /**
    * Execute the response transformation chain

package/dist/{chunk-NGYOO5TO.js → chunk-FJNKXOWE.js}

@@ -1,18 +1,18 @@
-import {
-  AnthropicTransformer
-} from "./chunk-HKB656B4.js";
-import {
-  GeminiTransformer
-} from "./chunk-55FMGZ3L.js";
 import {
   OpenAIResponseTransformer
-} from "./chunk-45FHEOKW.js";
+} from "./chunk-V53ZEFXC.js";
 import {
   OpenAITransformer
-} from "./chunk-CCVRRJOX.js";
+} from "./chunk-7PIUVCKK.js";
+import {
+  AnthropicTransformer
+} from "./chunk-6OC3ORW6.js";
+import {
+  GeminiTransformer
+} from "./chunk-HN74IGEO.js";
 import {
   GeminiCodeAssistTransformer
-} from "./chunk-2UTGX6FM.js";
+} from "./chunk-4VVCXVB7.js";
 
 // src/transformer/transformers/index.ts
 var BuiltinTransformers = {

package/dist/{chunk-UWDW6PN3.cjs → chunk-FX325I5Q.cjs}

@@ -1,10 +1,10 @@
 "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 _chunkFCR77GYMcjs = require('./chunk-FCR77GYM.cjs');
 
+var _chunkAEOZIDEBcjs = require('./chunk-AEOZIDEB.cjs');
 
 
-var _chunkAEOZIDEBcjs = require('./chunk-AEOZIDEB.cjs');
+var _chunkHCOQQAZEcjs = require('./chunk-HCOQQAZE.cjs');
 
 
 var _chunkXSVNC2UDcjs = require('./chunk-XSVNC2UD.cjs');
@@ -195,24 +195,35 @@ function resolveClientIp(req, trustForwardedFor) {
   }
   return _nullishCoalesce(_optionalChain([req, 'access', _8 => _8.socket, 'optionalAccess', _9 => _9.remoteAddress]), () => ( void 0));
 }
-function beginAuditCapture(req, res, now) {
+function beginAuditCapture(req, res, now, options) {
   const config = _chunkAEOZIDEBcjs.getAuditCaptureConfig.call(void 0, );
   if (!config) return null;
+  const captureBodies = config.captureBodies;
   let requestBody;
   const responseChunks = [];
   let responseBytes = 0;
   let responseTruncated = false;
+  let bodiesSuppressed = _optionalChain([options, 'optionalAccess', _10 => _10.suppressBodies]) === true;
   let finished = false;
   const ctx = {
     setRequestBody(raw) {
-      if (config.captureBodies) {
-        requestBody = truncateToBytes(_chunkFCR77GYMcjs.redactAuditText.call(void 0, raw), config.maxBodyBytes);
+      if (captureBodies && !bodiesSuppressed) {
+        requestBody = truncateToBytes(_chunkHCOQQAZEcjs.redactAuditText.call(void 0, raw), config.maxBodyBytes);
       }
+    },
+    suppressBodies() {
+      if (bodiesSuppressed) return;
+      bodiesSuppressed = true;
+      requestBody = void 0;
+      responseChunks.length = 0;
+      responseBytes = 0;
+      responseTruncated = false;
     }
   };
-  if (config.captureBodies) {
+  if (captureBodies && !bodiesSuppressed) {
     installResponseCapture(res, {
       push(chunk) {
+        if (bodiesSuppressed) return;
         if (config.maxBodyBytes < 0) {
           responseChunks.push(chunk);
           responseBytes += chunk.length;
@@ -261,9 +272,9 @@ function beginAuditCapture(req, res, now) {
         if (!record.model && usage.model) record.model = usage.model;
         if (!record.provider && usage.provider) record.provider = usage.provider;
       }
-      if (ctx.error) record.error = _chunkFCR77GYMcjs.redactAuditText.call(void 0, ctx.error);
+      if (ctx.error) record.error = _chunkHCOQQAZEcjs.redactAuditText.call(void 0, ctx.error);
       if (ctx.sessionKey) record.sessionKey = ctx.sessionKey;
-      if (config.captureBodies) {
+      if (captureBodies && !bodiesSuppressed) {
         if (requestBody != null && requestBody.length > 0) {
           record.requestBody = requestBody;
         }
@@ -271,7 +282,7 @@ function beginAuditCapture(req, res, now) {
           const captured = Buffer.concat(responseChunks, responseBytes);
           const decoded = decodeCapturedBody(captured, responseTruncated);
           const body = config.compactStreamingBodies ? compactSseBody(decoded) : decoded;
-          record.responseBody = truncateToBytes(_chunkFCR77GYMcjs.redactAuditText.call(void 0, body), config.maxBodyBytes);
+          record.responseBody = truncateToBytes(_chunkHCOQQAZEcjs.redactAuditText.call(void 0, body), config.maxBodyBytes);
         }
         if (record.requestBody !== void 0 || record.responseBody !== void 0) {
           record.hasBody = true;

package/dist/chunk-G4CZIUIB.cjs

@@ -0,0 +1,200 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class; var _class2; var _class3;// src/openai-operation/openAIOperation.ts
+var OPERATIONS = {
+  "chat.completions.create": {
+    id: "chat.completions.create",
+    policyFamily: "chat",
+    routeFamily: "chat",
+    owner: "builtin",
+    bodyKind: "json",
+    requestedModelSource: "request"
+  },
+  "responses.create": {
+    id: "responses.create",
+    policyFamily: "responses",
+    routeFamily: "responses",
+    owner: "builtin",
+    bodyKind: "json",
+    requestedModelSource: "request"
+  },
+  "responses.compact": {
+    id: "responses.compact",
+    policyFamily: "responses",
+    routeFamily: "responses",
+    owner: "extension",
+    bodyKind: "json",
+    requestedModelSource: "request"
+  },
+  "images.generate": {
+    id: "images.generate",
+    policyFamily: "images",
+    routeFamily: "images",
+    owner: "extension",
+    bodyKind: "json",
+    requestedModelSource: "configured"
+  },
+  "images.edit": {
+    id: "images.edit",
+    policyFamily: "images",
+    routeFamily: "images",
+    owner: "extension",
+    bodyKind: "multipart",
+    requestedModelSource: "configured"
+  }
+};
+var MATCH_ORDER = [
+  { id: "responses.compact", suffix: ["responses", "compact"] },
+  { id: "images.generate", suffix: ["images", "generations"] },
+  { id: "images.edit", suffix: ["images", "edits"] },
+  { id: "chat.completions.create", suffix: ["chat", "completions"] },
+  { id: "responses.create", suffix: ["responses"] }
+];
+function getOpenAIOperation(id) {
+  return OPERATIONS[id];
+}
+function pathSegments(url) {
+  const queryIndex = url.indexOf("?");
+  const path = queryIndex >= 0 ? url.slice(0, queryIndex) : url;
+  return path.split("/").filter(Boolean);
+}
+function hasExactSuffix(segments, suffix) {
+  if (segments.length < suffix.length) return false;
+  const offset = segments.length - suffix.length;
+  return suffix.every((segment, index) => segments[offset + index] === segment);
+}
+function classifyOpenAIOperation(method, url) {
+  if (method !== "POST" || !url) return null;
+  const segments = pathSegments(url);
+  for (const candidate of MATCH_ORDER) {
+    if (hasExactSuffix(segments, candidate.suffix)) return OPERATIONS[candidate.id];
+  }
+  return null;
+}
+
+// src/openai-operation/openAIOperationRegistry.ts
+var OpenAIOperationRegistrationError = (_class = class extends Error {
+  constructor(code, message) {
+    super(message);_class.prototype.__init.call(this);;
+    this.code = code;
+  }
+  
+  __init() {this.name = "OpenAIOperationRegistrationError"}
+}, _class);
+var OpenAIOperationError = (_class2 = class extends Error {
+  __init2() {this.name = "OpenAIOperationError"}
+  
+  
+  
+  
+  constructor(init) {
+    super(init.message);_class2.prototype.__init2.call(this);;
+    this.status = init.status;
+    this.code = init.code;
+    this.retryable = _nullishCoalesce(init.retryable, () => ( false));
+    this.headers = _nullishCoalesce(init.headers, () => ( {}));
+  }
+}, _class2);
+var SAFE_LOCAL_ERROR_HEADERS = /* @__PURE__ */ new Set(["retry-after", "x-request-id"]);
+function safeErrorHeaders(headers) {
+  const safe = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (SAFE_LOCAL_ERROR_HEADERS.has(name.toLowerCase())) safe[name] = value;
+  }
+  return safe;
+}
+function writeOpenAIOperationError(res, error) {
+  if (res.headersSent || res.writableEnded) return false;
+  res.writeHead(error.status, {
+    "Content-Type": "application/json",
+    ...safeErrorHeaders(error.headers)
+  });
+  res.end(JSON.stringify({
+    error: {
+      type: "openai_operation_error",
+      code: error.code,
+      message: error.message,
+      retryable: error.retryable
+    }
+  }));
+  return true;
+}
+function unsupportedOpenAIOperation(operation) {
+  return new OpenAIOperationError({
+    status: 501,
+    code: "unsupported_capability",
+    message: `Operation '${operation.id}' is not available`
+  });
+}
+var OpenAIOperationRegistry = (_class3 = class {constructor() { _class3.prototype.__init3.call(this); }
+  __init3() {this.handlers = /* @__PURE__ */ new Map()}
+  register(operationId, handler) {
+    const operation = getOpenAIOperation(operationId);
+    if (operation.owner !== "extension") {
+      throw new OpenAIOperationRegistrationError(
+        "builtin_operation",
+        `Operation '${operationId}' is owned by a built-in ingress`
+      );
+    }
+    if (this.handlers.has(operationId)) {
+      throw new OpenAIOperationRegistrationError(
+        "duplicate_operation_handler",
+        `Operation '${operationId}' already has a handler`
+      );
+    }
+    this.handlers.set(operationId, handler);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      if (this.handlers.get(operationId) === handler) this.handlers.delete(operationId);
+    };
+  }
+  has(operationId) {
+    return this.handlers.has(operationId);
+  }
+  async dispatch(context) {
+    const handler = this.handlers.get(context.operation.id);
+    if (!handler) return false;
+    const controller = new AbortController();
+    const abort = () => {
+      if (!controller.signal.aborted) controller.abort();
+    };
+    const onRequestClose = () => {
+      if (context.request.aborted || !context.request.complete) abort();
+    };
+    const onResponseClose = () => {
+      if (!context.response.writableEnded) abort();
+    };
+    context.request.once("aborted", abort);
+    context.request.once("close", onRequestClose);
+    context.response.once("close", onResponseClose);
+    if (context.request.aborted || context.response.destroyed) abort();
+    try {
+      await handler({ ...context, signal: controller.signal });
+      return true;
+    } catch (error) {
+      const publicError = error instanceof OpenAIOperationError ? error : new OpenAIOperationError({
+        status: 500,
+        code: "operation_handler_failed",
+        message: `Operation '${context.operation.id}' handler failed`
+      });
+      if (!writeOpenAIOperationError(context.response, publicError)) {
+        throw new Error(publicError.message);
+      }
+      return true;
+    } finally {
+      context.request.removeListener("aborted", abort);
+      context.request.removeListener("close", onRequestClose);
+      context.response.removeListener("close", onResponseClose);
+    }
+  }
+}, _class3);
+
+
+
+
+
+
+
+
+
+exports.getOpenAIOperation = getOpenAIOperation; exports.classifyOpenAIOperation = classifyOpenAIOperation; exports.OpenAIOperationRegistrationError = OpenAIOperationRegistrationError; exports.OpenAIOperationError = OpenAIOperationError; exports.writeOpenAIOperationError = writeOpenAIOperationError; exports.unsupportedOpenAIOperation = unsupportedOpenAIOperation; exports.OpenAIOperationRegistry = OpenAIOperationRegistry;

package/dist/chunk-HCOQQAZE.cjs

@@ -0,0 +1,123 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/outbound-api/auditRedact.ts
+var AUDIT_REDACTED = "***REDACTED***";
+var RULES = [
+  // `sk-…` family (Anthropic sk-ant-, omnicross sk-omnicross-, OpenAI sk-proj-/sk-).
+  { re: /\bsk-[A-Za-z0-9_-]{6,}/g, replace: AUDIT_REDACTED },
+  // Google API keys.
+  { re: /\bAIza[A-Za-z0-9_-]{10,}/g, replace: AUDIT_REDACTED },
+  // `Bearer <token>` (auth headers echoed into a body / SSE error).
+  { re: /\bBearer\s+[A-Za-z0-9._~+/=-]{6,}/gi, replace: `Bearer ${AUDIT_REDACTED}` },
+  // Inline `x-api-key` / `api-key` / `authorization` label followed by a value.
+  {
+    re: /\b(x-api-key|api[_-]?key|authorization)(["']?\s*[:=]\s*["']?)[A-Za-z0-9._~+/=-]{6,}/gi,
+    replace: `$1$2${AUDIT_REDACTED}`
+  },
+  // `x-goog-api-key` header echoed inline.
+  {
+    re: /\b(x-goog-api-key)(["']?\s*[:=]\s*["']?)[A-Za-z0-9._~+/=-]{6,}/gi,
+    replace: `$1$2${AUDIT_REDACTED}`
+  }
+];
+function redactEncryptedContentValue(value) {
+  if (!value || typeof value !== "object") return false;
+  if (Array.isArray(value)) {
+    let changed2 = false;
+    for (const item of value) changed2 = redactEncryptedContentValue(item) || changed2;
+    return changed2;
+  }
+  let changed = false;
+  const record = value;
+  for (const [key, nested] of Object.entries(record)) {
+    if (key === "encrypted_content") {
+      record[key] = AUDIT_REDACTED;
+      changed = true;
+    } else {
+      changed = redactEncryptedContentValue(nested) || changed;
+    }
+  }
+  return changed;
+}
+function redactJsonValue(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return redactEncryptedContentValue(parsed) ? JSON.stringify(parsed) : null;
+  } catch (e) {
+    return null;
+  }
+}
+function redactEncryptedContentSse(text) {
+  return text.replace(/^(\s*data:\s*)([^\r\n]*)(\r?)$/gm, (line, prefix, payload, cr) => {
+    if (!payload || payload.trim() === "[DONE]") return line;
+    const redacted = redactJsonValue(payload.trim());
+    return redacted === null ? line : `${prefix}${redacted}${cr}`;
+  });
+}
+function findJsonLikeValueEnd(text, start) {
+  const first = text[start];
+  if (first === '"' || first === "'") {
+    let escaped = false;
+    for (let index = start + 1; index < text.length; index += 1) {
+      const char = text[index];
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === first) return index + 1;
+    }
+    return text.length;
+  }
+  if (first === "{" || first === "[") {
+    const opening = first;
+    const closing = first === "{" ? "}" : "]";
+    let depth = 0;
+    let quote = "";
+    let escaped = false;
+    for (let index = start; index < text.length; index += 1) {
+      const char = text[index];
+      if (quote) {
+        if (escaped) escaped = false;
+        else if (char === "\\") escaped = true;
+        else if (char === quote) quote = "";
+        continue;
+      }
+      if (char === '"' || char === "'") quote = char;
+      else if (char === opening) depth += 1;
+      else if (char === closing && --depth === 0) return index + 1;
+    }
+    return text.length;
+  }
+  let end = start;
+  while (end < text.length && !/[\r\n,}\]]/.test(text[end])) end += 1;
+  return end;
+}
+function redactEncryptedContentText(text) {
+  const key = /["']encrypted_content["']\s*:\s*/g;
+  let output = "";
+  let cursor = 0;
+  for (; ; ) {
+    const match = key.exec(text);
+    if (!match) break;
+    const valueStart = match.index + match[0].length;
+    const valueEnd = findJsonLikeValueEnd(text, valueStart);
+    output += text.slice(cursor, valueStart) + JSON.stringify(AUDIT_REDACTED);
+    cursor = valueEnd;
+    key.lastIndex = valueEnd;
+  }
+  return cursor === 0 ? text : output + text.slice(cursor);
+}
+function redactEncryptedContent(text) {
+  const completeJson = redactJsonValue(text);
+  if (completeJson !== null) return completeJson;
+  return redactEncryptedContentText(redactEncryptedContentSse(text));
+}
+function redactAuditText(text) {
+  if (typeof text !== "string" || text.length === 0) return _nullishCoalesce(text, () => ( ""));
+  let out = redactEncryptedContent(text);
+  for (const { re, replace } of RULES) {
+    out = out.replace(re, replace);
+  }
+  return out;
+}
+
+
+
+
+exports.AUDIT_REDACTED = AUDIT_REDACTED; exports.redactAuditText = redactAuditText;

package/dist/{chunk-55FMGZ3L.js → chunk-HN74IGEO.js}

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

package/dist/{chunk-ZY6KU6P3.js → chunk-HOMUGKHR.js}

@@ -1,10 +1,10 @@
-import {
-  resolveApiFormat
-} from "./chunk-H5JUT3KV.js";
 import {
   OPENROUTER_APP_HEADERS,
   isOpenRouterProvider
 } from "./chunk-HUZZZ3JL.js";
+import {
+  resolveApiFormat
+} from "./chunk-H5JUT3KV.js";
 
 // src/completion/header-builder.ts
 function getProviderHeaders(provider, apiKey) {
@@ -17,8 +17,11 @@ function getProviderHeaders(provider, apiKey) {
         // 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
+        // Official documented version date (claude-api-protocol-fidelity, R5);
+        // the former non-official future-dated value was removed. The BYO
+        // same-format path additionally forwards the caller's own
+        // `anthropic-version` verbatim when present (see `runSameFormatFetch`).
+        "anthropic-version": "2023-06-01"
       };
       break;
     case "google":

package/dist/{chunk-AOFWNWLT.cjs → chunk-IUL4VWNU.cjs}

@@ -191,6 +191,27 @@ function resolveRequestReasoning(request, provider, options = {}) {
   return { ...intent, effort: plan.effort, enabled: plan.enabled };
 }
 
+// src/transformer/transformWarnings.ts
+var droppedFieldCounts = {};
+var warnedOnce = /* @__PURE__ */ new Set();
+function recordDroppedField(request, field, target) {
+  attachTransformWarnings(request).push({ field, target });
+  const key = `${field}\0${target}`;
+  droppedFieldCounts[key] = (_nullishCoalesce(droppedFieldCounts[key], () => ( 0))) + 1;
+  if (!warnedOnce.has(key)) {
+    warnedOnce.add(key);
+    console.warn(
+      `[transform] dropped_field: '${field}' has no representation on the '${target}' wire (counting; values never logged)`
+    );
+  }
+}
+function attachTransformWarnings(request) {
+  const holder = request;
+  holder._transformWarnings ??= [];
+  return holder._transformWarnings;
+}
+
+
 
 
 
@@ -200,4 +221,4 @@ function resolveRequestReasoning(request, provider, options = {}) {
 
 
 
-exports.THINK_LEVELS = THINK_LEVELS; exports.normalizeThinkLevel = normalizeThinkLevel; exports.extractReasoningIntent = extractReasoningIntent; exports.resolveTargetModelCapabilities = resolveTargetModelCapabilities; exports.resolveReasoningEffort = resolveReasoningEffort; exports.resolveReasoningTokenLimit = resolveReasoningTokenLimit; exports.resolveReasoningPlan = resolveReasoningPlan; exports.resolveRequestReasoning = resolveRequestReasoning;
+exports.THINK_LEVELS = THINK_LEVELS; exports.normalizeThinkLevel = normalizeThinkLevel; exports.extractReasoningIntent = extractReasoningIntent; exports.resolveTargetModelCapabilities = resolveTargetModelCapabilities; exports.resolveReasoningEffort = resolveReasoningEffort; exports.resolveReasoningTokenLimit = resolveReasoningTokenLimit; exports.resolveReasoningPlan = resolveReasoningPlan; exports.resolveRequestReasoning = resolveRequestReasoning; exports.recordDroppedField = recordDroppedField;

package/dist/{chunk-5LNYGCIW.cjs → chunk-KIQ2HA2A.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkRICPANBYcjs = require('./chunk-RICPANBY.cjs');
+var _chunkWX2E2G7Hcjs = require('./chunk-WX2E2G7H.cjs');
 
 // src/transformer/transformers/GeminiTransformer.ts
 var GeminiTransformer = (_class = class {
@@ -44,7 +44,7 @@ var GeminiTransformer = (_class = class {
    * Also builds the correct URL for the Gemini API
    */
   async transformRequestIn(request, provider, context) {
-    const body = _chunkRICPANBYcjs.buildRequestBody.call(void 0, 
+    const body = _chunkWX2E2G7Hcjs.buildRequestBody.call(void 0, 
       request,
       provider,
       context.reasoningSourceFormat === this.name
@@ -69,7 +69,7 @@ var GeminiTransformer = (_class = class {
    * (For requests coming into the Gemini endpoint)
    */
   async transformRequestOut(request, context) {
-    const unifiedRequest = _chunkRICPANBYcjs.transformRequestOut.call(void 0, request);
+    const unifiedRequest = _chunkWX2E2G7Hcjs.transformRequestOut.call(void 0, request);
     if (_optionalChain([unifiedRequest, 'access', _2 => _2.reasoning, 'optionalAccess', _3 => _3.effort])) {
       context.reasoningSourceFormat = this.name;
     }
@@ -79,14 +79,14 @@ var GeminiTransformer = (_class = class {
    * Transform Gemini response to OpenAI-compatible format
    */
   async transformResponseOut(response, _context) {
-    return _chunkRICPANBYcjs.transformResponseOut.call(void 0, response, this.name, this.logger);
+    return _chunkWX2E2G7Hcjs.transformResponseOut.call(void 0, response, this.name, this.logger);
   }
   /**
    * Transform OpenAI-compatible response back to Gemini format
    * (For endpoint mode — returning Gemini-format responses to the client)
    */
   async transformResponseIn(response, _context) {
-    return _chunkRICPANBYcjs.transformResponseIn.call(void 0, response, this.logger);
+    return _chunkWX2E2G7Hcjs.transformResponseIn.call(void 0, response, this.logger);
   }
 }, _class.__initStatic(), _class);
 

package/dist/{chunk-MUHWHQVM.cjs → chunk-KQBLZMP6.cjs}

@@ -12,9 +12,10 @@ async function executeProviderCall(ctx) {
     prepareBody,
     fetchFn,
     runResponseChain = false,
-    responseChainRequest
+    responseChainRequest,
+    preserveEndpointRequestForResponseChain = false
   } = ctx;
-  const { requestBody, config } = await executor.executeRequestChain(
+  const { requestBody, endpointRequest, config } = await executor.executeRequestChain(
     request,
     provider,
     chain,
@@ -34,7 +35,7 @@ async function executeProviderCall(ctx) {
       // unified ingresses → their pre-transform request. The caller supplies
       // it via `responseChainRequest`; fall back to `requestBody` (the proxy
       // shape) so the contract is never silently `undefined`.
-      _nullishCoalesce(responseChainRequest, () => ( requestBody)),
+      _nullishCoalesce(_nullishCoalesce(responseChainRequest, () => ( (preserveEndpointRequestForResponseChain ? endpointRequest : void 0))), () => ( requestBody)),
       fetched,
       provider,
       chain,