@omnicross/core 0.1.3 → 0.1.5

package/dist/chunk-IFXJ2BG7.js

@@ -0,0 +1,109 @@
+import {
+  redactAuditText
+} from "./chunk-K5NM7VAH.js";
+import {
+  getAuditCaptureConfig,
+  recordAudit
+} from "./chunk-WNY4WMRF.js";
+import {
+  readAuditUsage
+} from "./chunk-OZFM4X3S.js";
+
+// src/outbound-api/auditCapture.ts
+import { randomUUID } from "crypto";
+function resolveClientIp(req, trustForwardedFor) {
+  if (trustForwardedFor) {
+    const xff = req.headers["x-forwarded-for"];
+    const raw = Array.isArray(xff) ? xff[0] : xff;
+    if (typeof raw === "string" && raw.trim()) {
+      const first = raw.split(",")[0]?.trim();
+      if (first) return first;
+    }
+  }
+  return req.socket?.remoteAddress ?? void 0;
+}
+function beginAuditCapture(req, res, now) {
+  const config = getAuditCaptureConfig();
+  if (!config) return null;
+  let rawRequestBody;
+  const responseChunks = [];
+  let finished = false;
+  const ctx = {
+    setRequestBody(raw) {
+      if (config.captureBodies) rawRequestBody = raw;
+    }
+  };
+  if (config.captureBodies) {
+    installResponseCapture(res, {
+      push(chunk) {
+        responseChunks.push(chunk);
+      }
+    });
+  }
+  const finalize = () => {
+    if (finished) return;
+    finished = true;
+    try {
+      const record = {
+        id: randomUUID(),
+        ts: now,
+        method: req.method ?? "",
+        path: (req.url ?? "").split("?")[0] ?? "",
+        status: res.statusCode,
+        latencyMs: Math.max(0, Date.now() - now)
+      };
+      if (ctx.keyId != null) record.keyId = ctx.keyId;
+      const ip = resolveClientIp(req, config.trustForwardedFor);
+      if (ip) record.ip = ip;
+      const ua = req.headers["user-agent"];
+      if (typeof ua === "string" && ua) record.ua = ua;
+      if (ctx.model) record.model = ctx.model;
+      if (ctx.provider) record.provider = ctx.provider;
+      const usage = readAuditUsage(res);
+      if (usage) {
+        if (typeof usage.inputTokens === "number") record.inputTokens = usage.inputTokens;
+        if (typeof usage.outputTokens === "number") record.outputTokens = usage.outputTokens;
+        if (typeof usage.costUsd === "number") record.costUsd = usage.costUsd;
+        if (!record.model && usage.model) record.model = usage.model;
+        if (!record.provider && usage.provider) record.provider = usage.provider;
+      }
+      if (ctx.error) record.error = redactAuditText(ctx.error);
+      if (config.captureBodies) {
+        if (rawRequestBody != null && rawRequestBody.length > 0) {
+          record.requestBody = redactAuditText(rawRequestBody);
+        }
+        if (responseChunks.length > 0) {
+          const body = Buffer.concat(responseChunks).toString("utf8");
+          record.responseBody = redactAuditText(body);
+        }
+      }
+      recordAudit(record);
+    } catch {
+    }
+  };
+  res.once("close", finalize);
+  return ctx;
+}
+function installResponseCapture(res, sink) {
+  const capture = (chunk) => {
+    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;
+    sink.push(buf);
+  };
+  const originalWrite = res.write.bind(res);
+  const originalEnd = res.end.bind(res);
+  res.write = ((chunk, ...args) => {
+    if (chunk != null) capture(chunk);
+    return originalWrite(chunk, ...args);
+  });
+  res.end = ((chunk, ...args) => {
+    if (chunk != null && typeof chunk !== "function") capture(chunk);
+    return originalEnd(chunk, ...args);
+  });
+}
+
+export {
+  beginAuditCapture
+};

package/dist/{chunk-JO5NLTLY.js → chunk-IK3KE3AU.js}

@@ -23,6 +23,9 @@ async function executeProviderCall(ctx) {
   const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
   const url = resolveUrl(config);
   const headers = buildHeaders(config);
+  if (!headers["content-type"] && !headers["Content-Type"]) {
+    headers["content-type"] = "application/json";
+  }
   const fetched = await fetchFn(url, headers, finalBody);
   let response = fetched;
   if (runResponseChain) {

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

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

package/dist/{chunk-YGXJGRFI.cjs → chunk-JWVTXXPX.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,
@@ -854,35 +856,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', _122 => _122.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])) {
+            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', _124 => _124.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 +978,7 @@ function transformRequestOut(request) {
             function: {
               name: funcDecl.name,
               description: _nullishCoalesce(funcDecl.description, () => ( "")),
-              parameters: _nullishCoalesce(funcDecl.parameters, () => ( {}))
+              parameters: _nullishCoalesce(_nullishCoalesce(funcDecl.parameters, () => ( funcDecl.parametersJsonSchema)), () => ( {}))
             }
           });
         }

package/dist/{chunk-7YN22L2H.cjs → chunk-K52THW2C.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkYGXJGRFIcjs = require('./chunk-YGXJGRFI.cjs');
+var _chunkJWVTXXPXcjs = require('./chunk-JWVTXXPX.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 = _chunkYGXJGRFIcjs.buildRequestBody.call(void 0, request);
+    const body = _chunkJWVTXXPXcjs.buildRequestBody.call(void 0, request);
     const action = request.stream ? "streamGenerateContent?alt=sse" : "generateContent";
     const url = new URL(`./${request.model}:${action}`, provider.baseUrl);
     const headers = {};
@@ -65,20 +65,20 @@ var GeminiTransformer = (_class = class {
    * (For requests coming into the Gemini endpoint)
    */
   async transformRequestOut(request, _context) {
-    return _chunkYGXJGRFIcjs.transformRequestOut.call(void 0, request);
+    return _chunkJWVTXXPXcjs.transformRequestOut.call(void 0, request);
   }
   /**
    * Transform Gemini response to OpenAI-compatible format
    */
   async transformResponseOut(response, _context) {
-    return _chunkYGXJGRFIcjs.transformResponseOut.call(void 0, response, this.name, this.logger);
+    return _chunkJWVTXXPXcjs.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 _chunkYGXJGRFIcjs.transformResponseIn.call(void 0, response, this.logger);
+    return _chunkJWVTXXPXcjs.transformResponseIn.call(void 0, response, this.logger);
   }
 }, _class.__initStatic(), _class);
 

package/dist/chunk-K5NM7VAH.js

@@ -0,0 +1,33 @@
+// 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 redactAuditText(text) {
+  if (typeof text !== "string" || text.length === 0) return text ?? "";
+  let out = text;
+  for (const { re, replace } of RULES) {
+    out = out.replace(re, replace);
+  }
+  return out;
+}
+
+export {
+  AUDIT_REDACTED,
+  redactAuditText
+};

package/dist/{chunk-Y6OM7EV7.cjs → chunk-KFI44N2R.cjs}

@@ -33,7 +33,8 @@ var SubscriptionAuthSource = class {
         upstreamUrl: hints.upstreamUrl,
         resolvedModel: hints.model,
         sessionKey: hints.sessionKey,
-        reportSelection: hints.reportSelection
+        reportSelection: hints.reportSelection,
+        preferredAccountId: hints.preferredAccountId
       });
     } catch (err) {
       console.warn("[SubscriptionAuthSource] authStrategy.applyHeaders threw:", _chunkSVNDB62Dcjs.serializeError.call(void 0, err));

package/dist/{chunk-Z7Y2NPHY.js → chunk-MFZ5437A.js}

@@ -3,7 +3,7 @@ import {
   transformRequestOut,
   transformResponseIn,
   transformResponseOut
-} from "./chunk-S4WBV25P.js";
+} from "./chunk-6QZGDLL4.js";
 
 // src/transformer/transformers/GeminiCodeAssistTransformer.ts
 var DEFAULT_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";

package/dist/chunk-OE6TDIWW.js

@@ -0,0 +1,22 @@
+// src/pipeline/webhookEmit.ts
+var sink = null;
+function setWebhookSink(fn) {
+  sink = fn;
+}
+function emitWebhookEvent(event) {
+  const active = sink;
+  if (!active) return;
+  try {
+    active(event);
+  } catch {
+  }
+}
+function __resetWebhookSinkForTests() {
+  sink = null;
+}
+
+export {
+  setWebhookSink,
+  emitWebhookEvent,
+  __resetWebhookSinkForTests
+};

package/dist/{chunk-MQNDWYPN.js → chunk-OQWKZCXP.js}

@@ -1,21 +1,21 @@
 import {
   OpenCodeGoTransformer
-} from "./chunk-Z7LUNECE.js";
+} from "./chunk-IB3FDI4O.js";
 import {
   ReasoningTransformer
 } from "./chunk-ZJZAOKI7.js";
 import {
   AnthropicTransformer
-} from "./chunk-FTQ7IQUC.js";
+} from "./chunk-C6OV7GCC.js";
 import {
   GeminiTransformer
-} from "./chunk-C7PSERMH.js";
+} from "./chunk-IWQAX3CS.js";
 import {
   OpenAIResponseTransformer
-} from "./chunk-5HTVET6E.js";
+} from "./chunk-BODMAL6G.js";
 import {
   GeminiCodeAssistTransformer
-} from "./chunk-Z7Y2NPHY.js";
+} from "./chunk-MFZ5437A.js";
 
 // src/transformer/transformers/DeepseekTransformer.ts
 var DeepseekTransformer = class {
@@ -32,7 +32,14 @@ var DeepseekTransformer = class {
       this.logger?.debug("DeepSeek: Limiting max_tokens from %d to 8192", request.max_tokens);
       request.max_tokens = 8192;
     }
-    return request;
+    const sanitizedMessages = (request.messages ?? []).map((m) => {
+      const out = { role: m.role };
+      if (m.content !== void 0) out.content = m.content;
+      if (m.tool_calls) out.tool_calls = m.tool_calls;
+      if (m.tool_call_id) out.tool_call_id = m.tool_call_id;
+      return out;
+    });
+    return { ...request, messages: sanitizedMessages };
   }
   /**
    * Transform response: convert reasoning_content to thinking blocks

package/dist/chunk-OZFM4X3S.js

@@ -0,0 +1,18 @@
+// src/pipeline/auditUsageStash.ts
+var stash = /* @__PURE__ */ new WeakMap();
+function stashAuditUsage(key, detail) {
+  const existing = stash.get(key);
+  stash.set(key, existing ? { ...existing, ...detail } : { ...detail });
+}
+function readAuditUsage(key) {
+  return stash.get(key);
+}
+function __clearAuditUsageForTests(key) {
+  stash.delete(key);
+}
+
+export {
+  stashAuditUsage,
+  readAuditUsage,
+  __clearAuditUsageForTests
+};

package/dist/chunk-PG7PS2NN.cjs

@@ -0,0 +1,170 @@
+"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 _chunk3Z5BQZFMcjs = require('./chunk-3Z5BQZFM.cjs');
+
+// src/pipeline/upstreamFetch.ts
+var _undici = require('undici');
+var _socks = require('socks');
+var resolver = null;
+var generation = 0;
+var cache = /* @__PURE__ */ new Map();
+function setUpstreamProxyResolver(fn) {
+  resolver = fn;
+  bumpUpstreamProxyGeneration();
+}
+function bumpUpstreamProxyGeneration() {
+  generation += 1;
+  const old = cache;
+  cache = /* @__PURE__ */ new Map();
+  for (const dispatcher of old.values()) {
+    try {
+      void _optionalChain([dispatcher, 'access', _ => _.close, 'optionalCall', _2 => _2()]);
+    } catch (e) {
+    }
+  }
+}
+function normalizeProxy(cfg) {
+  if ("url" in cfg) {
+    let u;
+    try {
+      u = new URL(cfg.url);
+    } catch (e2) {
+      return void 0;
+    }
+    const proto = u.protocol.replace(/:$/, "").toLowerCase();
+    const kind2 = proto === "socks5" || proto === "socks" ? "socks5" : proto === "https" ? "https" : "http";
+    const port = u.port ? Number(u.port) : kind2 === "https" ? 443 : kind2 === "socks5" ? 1080 : 80;
+    if (!u.hostname || !Number.isFinite(port)) return void 0;
+    return {
+      kind: kind2,
+      host: u.hostname,
+      port,
+      username: u.username ? decodeURIComponent(u.username) : void 0,
+      password: u.password ? decodeURIComponent(u.password) : void 0
+    };
+  }
+  const kind = cfg.type === "socks5" ? "socks5" : cfg.type === "https" ? "https" : "http";
+  if (!cfg.host || !Number.isFinite(cfg.port)) return void 0;
+  return {
+    kind,
+    host: cfg.host,
+    port: cfg.port,
+    username: cfg.username || void 0,
+    password: cfg.password || void 0
+  };
+}
+function proxyKey(p) {
+  return `${p.kind}://${_nullishCoalesce(p.username, () => ( ""))}:${_nullishCoalesce(p.password, () => ( ""))}@${p.host}:${p.port}`;
+}
+function socksConnector(p) {
+  const base = _undici.buildConnector.call(void 0, {});
+  return ((options, callback) => {
+    const destPort = Number(options.port) || (options.protocol === "https:" ? 443 : 80);
+    _socks.SocksClient.createConnection({
+      proxy: { host: p.host, port: p.port, type: 5, userId: p.username, password: p.password },
+      command: "connect",
+      destination: { host: options.hostname, port: destPort }
+    }).then(({ socket }) => {
+      base({ ...options, httpSocket: socket }, callback);
+    }).catch((err) => callback(err, null));
+  });
+}
+function buildDispatcher(p) {
+  if (p.kind === "socks5") {
+    return new (0, _undici.Agent)({ connect: socksConnector(p) });
+  }
+  const auth = p.username != null ? `${encodeURIComponent(p.username)}:${encodeURIComponent(_nullishCoalesce(p.password, () => ( "")))}@` : "";
+  const uri = `${p.kind}://${auth}${p.host}:${p.port}`;
+  return new (0, _undici.ProxyAgent)({ uri });
+}
+function resolveUpstreamDispatcher(ctx) {
+  const active = resolver;
+  if (!active) return void 0;
+  let cfg;
+  try {
+    cfg = active(ctx);
+  } catch (e3) {
+    return void 0;
+  }
+  if (!cfg) return void 0;
+  const norm = normalizeProxy(cfg);
+  if (!norm) return void 0;
+  const key = `${generation}\0${proxyKey(norm)}`;
+  let dispatcher = cache.get(key);
+  if (!dispatcher) {
+    dispatcher = buildDispatcher(norm);
+    cache.set(key, dispatcher);
+  }
+  return dispatcher;
+}
+function fetchUpstream(url, init, ctx) {
+  const dispatcher = resolveUpstreamDispatcher({ ..._nullishCoalesce(ctx, () => ( {})), url });
+  const doFetch = dispatcher ? () => fetch(url, { ...init, dispatcher }) : () => fetch(url, init);
+  const tracePath = _chunk3Z5BQZFMcjs.getUpstreamTracePath.call(void 0, );
+  if (!tracePath || !_optionalChain([ctx, 'optionalAccess', _3 => _3.providerId])) return doFetch();
+  const startedAt = Date.now();
+  const method = typeof init.method === "string" ? init.method : "GET";
+  const requestHeaders = _chunk3Z5BQZFMcjs.redactHeaders.call(void 0, 
+    init.headers
+  );
+  const requestBody = typeof init.body === "string" ? init.body : null;
+  const providerId = ctx.providerId;
+  const accountId = ctx.accountId;
+  return doFetch().then((res) => {
+    const clone = res.clone();
+    const status = res.status;
+    const statusText = res.statusText;
+    const responseHeaders = _chunk3Z5BQZFMcjs.redactHeaders.call(void 0, res.headers);
+    void clone.text().then((body) => {
+      _chunk3Z5BQZFMcjs.writeUpstreamTrace.call(void 0, {
+        ts: startedAt,
+        durationMs: Date.now() - startedAt,
+        providerId,
+        accountId,
+        url,
+        method,
+        requestHeaders,
+        requestBody,
+        status,
+        statusText,
+        responseHeaders,
+        responseBody: body,
+        responseBytes: Buffer.byteLength(body, "utf8")
+      });
+    }).catch(() => {
+    });
+    return res;
+  }).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    _chunk3Z5BQZFMcjs.writeUpstreamTrace.call(void 0, {
+      ts: startedAt,
+      durationMs: Date.now() - startedAt,
+      providerId,
+      accountId,
+      url,
+      method,
+      requestHeaders,
+      requestBody,
+      status: 0,
+      statusText: "",
+      responseHeaders: {},
+      responseBody: `<UPSTREAM FETCH ERROR: ${msg}>`,
+      responseBytes: 0
+    });
+    throw err;
+  });
+}
+function __resetUpstreamProxyForTests() {
+  resolver = null;
+  bumpUpstreamProxyGeneration();
+}
+
+
+
+
+
+
+
+exports.setUpstreamProxyResolver = setUpstreamProxyResolver; exports.bumpUpstreamProxyGeneration = bumpUpstreamProxyGeneration; exports.resolveUpstreamDispatcher = resolveUpstreamDispatcher; exports.fetchUpstream = fetchUpstream; exports.__resetUpstreamProxyForTests = __resetUpstreamProxyForTests;