@omnicross/core 0.1.9 → 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-FX325I5Q.cjs

@@ -0,0 +1,320 @@
+"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 _chunkAEOZIDEBcjs = require('./chunk-AEOZIDEB.cjs');
+
+
+var _chunkHCOQQAZEcjs = require('./chunk-HCOQQAZE.cjs');
+
+
+var _chunkXSVNC2UDcjs = require('./chunk-XSVNC2UD.cjs');
+
+// src/outbound-api/auditCapture.ts
+var _crypto = require('crypto');
+
+// src/outbound-api/auditSseCompact.ts
+var MERGED_FRAMES_FIELD = "_omnicrossMergedFrames";
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function scalar(value) {
+  return typeof value === "string" || typeof value === "number" ? String(value) : "";
+}
+function classify(payload) {
+  const type = scalar(payload["type"]);
+  if (type === "content_block_delta") {
+    const delta = asObject(payload["delta"]);
+    const deltaType = scalar(_optionalChain([delta, 'optionalAccess', _ => _["type"]]));
+    const field = deltaType === "text_delta" ? "text" : deltaType === "thinking_delta" ? "thinking" : deltaType === "input_json_delta" ? "partial_json" : null;
+    if (!delta || !field || typeof delta[field] !== "string") return null;
+    return {
+      channel: "anthropic:" + scalar(payload["index"]) + ":" + deltaType,
+      text: delta[field],
+      payload,
+      textPath: ["delta", field]
+    };
+  }
+  if (type.endsWith(".delta") && typeof payload["delta"] === "string") {
+    const channel = [
+      "responses",
+      type,
+      scalar(payload["item_id"]),
+      scalar(payload["output_index"]),
+      scalar(payload["content_index"])
+    ].join(":");
+    return { channel, text: payload["delta"], payload, textPath: ["delta"] };
+  }
+  const choices = payload["choices"];
+  if (Array.isArray(choices) && choices.length === 1) {
+    const choice = asObject(choices[0]);
+    const delta = asObject(_optionalChain([choice, 'optionalAccess', _2 => _2["delta"]]));
+    if (choice && delta && typeof delta["content"] === "string" && choice["finish_reason"] == null && delta["tool_calls"] === void 0 && delta["function_call"] === void 0) {
+      return {
+        channel: "chat:" + scalar(choice["index"]),
+        text: delta["content"],
+        payload,
+        textPath: ["choices", "0", "delta", "content"]
+      };
+    }
+  }
+  return null;
+}
+function withMergedText(frame, text, mergedCount) {
+  const clone = JSON.parse(JSON.stringify(frame.payload));
+  let cursor = clone;
+  for (let i = 0; i < frame.textPath.length - 1; i += 1) {
+    const step = frame.textPath[i];
+    const next = Array.isArray(cursor) ? cursor[Number(step)] : cursor[step];
+    if (next === null || typeof next !== "object") return clone;
+    cursor = next;
+  }
+  const leaf = frame.textPath[frame.textPath.length - 1];
+  if (Array.isArray(cursor)) cursor[Number(leaf)] = text;
+  else cursor[leaf] = text;
+  clone[MERGED_FRAMES_FIELD] = mergedCount;
+  return clone;
+}
+function splitBlocks(text, nl) {
+  const blocks = [];
+  let head = [];
+  let data = null;
+  let raw = [];
+  const flush = () => {
+    if (raw.length === 0) return;
+    blocks.push({ head, data, raw: raw.join(nl) });
+    head = [];
+    data = null;
+    raw = [];
+  };
+  for (const line of text.split(nl)) {
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+    raw.push(line);
+    if (line.startsWith("data:")) {
+      const payload = line.slice("data:".length).trimStart();
+      data = data === null ? payload : data + nl + payload;
+    } else {
+      head.push(line);
+    }
+  }
+  flush();
+  return blocks;
+}
+function compactSseBody(text) {
+  if (!text || !text.includes("data:")) return text;
+  const nl = "\n";
+  const blocks = splitBlocks(text, nl);
+  if (blocks.length === 0) return text;
+  const out = [];
+  let runFrame = null;
+  let runBlock = null;
+  let runText = "";
+  let runCount = 0;
+  let merged = 0;
+  const flushRun = () => {
+    if (runFrame === null || runBlock === null) return;
+    if (runCount === 1) {
+      out.push(runBlock.raw);
+    } else {
+      const payload = withMergedText(runFrame, runText, runCount);
+      out.push([...runBlock.head, "data: " + JSON.stringify(payload)].join(nl));
+      merged += runCount;
+    }
+    runFrame = null;
+    runBlock = null;
+    runText = "";
+    runCount = 0;
+  };
+  for (const block of blocks) {
+    let frame = null;
+    if (block.data !== null && block.data !== "[DONE]") {
+      try {
+        const parsed = asObject(JSON.parse(block.data));
+        if (parsed) frame = classify(parsed);
+      } catch (e) {
+        frame = null;
+      }
+    }
+    if (frame === null) {
+      flushRun();
+      out.push(block.raw);
+      continue;
+    }
+    const open = runFrame;
+    if (open !== null && open.channel === frame.channel) {
+      runText += frame.text;
+      runCount += 1;
+      continue;
+    }
+    flushRun();
+    runFrame = frame;
+    runBlock = block;
+    runText = frame.text;
+    runCount = 1;
+  }
+  flushRun();
+  if (merged === 0) return text;
+  const trailer = /\s$/.test(text) ? nl + nl : "";
+  return out.join(nl + nl) + trailer;
+}
+
+// src/outbound-api/auditCapture.ts
+function completeUtf8PrefixLength(buf) {
+  if (buf.length === 0) return 0;
+  let leadIndex = buf.length - 1;
+  while (leadIndex >= 0 && (buf[leadIndex] & 192) === 128) leadIndex -= 1;
+  if (leadIndex < 0) return 0;
+  const lead = buf[leadIndex];
+  let expectedLength = 1;
+  if ((lead & 224) === 192) expectedLength = 2;
+  else if ((lead & 240) === 224) expectedLength = 3;
+  else if ((lead & 248) === 240) expectedLength = 4;
+  return buf.length - leadIndex < expectedLength ? leadIndex : buf.length;
+}
+function truncateToBytes(text, maxBytes) {
+  if (maxBytes < 0) return text;
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return text;
+  const head = buf.subarray(0, maxBytes);
+  return head.subarray(0, completeUtf8PrefixLength(head)).toString("utf8");
+}
+function decodeCapturedBody(body, truncated) {
+  if (!truncated) return body.toString("utf8");
+  return body.subarray(0, completeUtf8PrefixLength(body)).toString("utf8");
+}
+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 = _optionalChain([raw, 'access', _3 => _3.split, 'call', _4 => _4(","), 'access', _5 => _5[0], 'optionalAccess', _6 => _6.trim, 'call', _7 => _7()]);
+      if (first) return first;
+    }
+  }
+  return _nullishCoalesce(_optionalChain([req, 'access', _8 => _8.socket, 'optionalAccess', _9 => _9.remoteAddress]), () => ( void 0));
+}
+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 (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 (captureBodies && !bodiesSuppressed) {
+    installResponseCapture(res, {
+      push(chunk) {
+        if (bodiesSuppressed) return;
+        if (config.maxBodyBytes < 0) {
+          responseChunks.push(chunk);
+          responseBytes += chunk.length;
+          return;
+        }
+        const remaining = config.maxBodyBytes - responseBytes;
+        if (remaining <= 0) {
+          responseTruncated = true;
+          return;
+        }
+        if (chunk.length > remaining) {
+          responseChunks.push(chunk.subarray(0, remaining));
+          responseBytes += remaining;
+          responseTruncated = true;
+          return;
+        }
+        responseChunks.push(chunk);
+        responseBytes += chunk.length;
+      }
+    });
+  }
+  const finalize = () => {
+    if (finished) return;
+    finished = true;
+    try {
+      const record = {
+        id: _crypto.randomUUID.call(void 0, ),
+        ts: now,
+        method: _nullishCoalesce(req.method, () => ( "")),
+        path: _nullishCoalesce((_nullishCoalesce(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 = _chunkXSVNC2UDcjs.readAuditUsage.call(void 0, 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 = _chunkHCOQQAZEcjs.redactAuditText.call(void 0, ctx.error);
+      if (ctx.sessionKey) record.sessionKey = ctx.sessionKey;
+      if (captureBodies && !bodiesSuppressed) {
+        if (requestBody != null && requestBody.length > 0) {
+          record.requestBody = requestBody;
+        }
+        if (responseChunks.length > 0) {
+          const captured = Buffer.concat(responseChunks, responseBytes);
+          const decoded = decodeCapturedBody(captured, responseTruncated);
+          const body = config.compactStreamingBodies ? compactSseBody(decoded) : decoded;
+          record.responseBody = truncateToBytes(_chunkHCOQQAZEcjs.redactAuditText.call(void 0, body), config.maxBodyBytes);
+        }
+        if (record.requestBody !== void 0 || record.responseBody !== void 0) {
+          record.hasBody = true;
+        }
+      }
+      _chunkAEOZIDEBcjs.recordAudit.call(void 0, record);
+    } catch (e2) {
+    }
+  };
+  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);
+  });
+}
+
+
+
+exports.beginAuditCapture = beginAuditCapture;

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;