@omnicross/core 0.1.10 → 0.2.1

package/dist/chunk-6DDYNS2B.cjs

@@ -0,0 +1,384 @@
+"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; }// src/transformer/transformers/AnthropicOpenAIToAnthropicStream.ts
+var DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS = 2e4;
+var anthropicPingHeartbeatMs = DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS;
+function setAnthropicPingHeartbeatMs(ms) {
+  anthropicPingHeartbeatMs = typeof ms === "number" && Number.isFinite(ms) ? ms : DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS;
+}
+function getAnthropicPingHeartbeatMs() {
+  return anthropicPingHeartbeatMs;
+}
+var stopReasonContentFilterCount = 0;
+function __resetStopReasonContentFilterCountForTests() {
+  stopReasonContentFilterCount = exports.stopReasonContentFilterCount = 0;
+}
+function noteContentFilterRemap(logger) {
+  stopReasonContentFilterCount = exports.stopReasonContentFilterCount += 1;
+  console.warn(
+    `[AnthropicStream] upstream finish_reason=content_filter remapped to stop_reason=refusal (count ${stopReasonContentFilterCount})`
+  );
+  _optionalChain([logger, 'optionalAccess', _ => _.warn, 'optionalCall', _2 => _2("upstream finish_reason=content_filter remapped to stop_reason=refusal")]);
+}
+function sniffErrorType(error) {
+  let text;
+  try {
+    text = _nullishCoalesce(JSON.stringify(error), () => ( ""));
+  } catch (e2) {
+    text = String(error);
+  }
+  const lower = text.toLowerCase();
+  if (lower.includes("overload") || lower.includes("capacity") || lower.includes("server_error")) {
+    return "overloaded_error";
+  }
+  const e = error;
+  for (const raw of [_optionalChain([e, 'optionalAccess', _3 => _3.status]), _optionalChain([e, 'optionalAccess', _4 => _4.code])]) {
+    const n = typeof raw === "string" ? Number.parseInt(raw, 10) : raw;
+    if (typeof n === "number" && Number.isFinite(n) && n >= 500) return "overloaded_error";
+  }
+  return "api_error";
+}
+function convertOpenAIStreamToAnthropic(openaiStream, _context, logger) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let hasStarted = false;
+  let hasTextContentStarted = false;
+  let isThinkingStarted = false;
+  let contentIndex = 0;
+  let currentContentBlockIndex = -1;
+  const toolCallIndexToContentBlockIndex = /* @__PURE__ */ new Map();
+  let reader = null;
+  return new ReadableStream({
+    start: async (controller) => {
+      reader = openaiStream.getReader();
+      let buffer = "";
+      const messageId = `msg_${Date.now()}`;
+      let model = "unknown";
+      let isClosed = false;
+      let stopReasonDelta = null;
+      const safeEnqueue = (data) => {
+        if (!isClosed) {
+          try {
+            controller.enqueue(encoder.encode(data));
+          } catch (_e) {
+            isClosed = true;
+          }
+        }
+      };
+      let pingTimer = null;
+      const clearPing = () => {
+        if (pingTimer !== null) {
+          clearTimeout(pingTimer);
+          pingTimer = null;
+        }
+      };
+      const armPing = () => {
+        clearPing();
+        const interval = getAnthropicPingHeartbeatMs();
+        if (!(interval > 0)) return;
+        pingTimer = setTimeout(() => {
+          pingTimer = null;
+          safeEnqueue(`event: ping
+data: ${JSON.stringify({ type: "ping" })}
+
+`);
+          armPing();
+        }, interval);
+        _optionalChain([pingTimer, 'access', _5 => _5.unref, 'optionalCall', _6 => _6()]);
+      };
+      const assignContentBlockIndex = () => {
+        return contentIndex++;
+      };
+      const safeClose = () => {
+        if (isClosed) return;
+        if (currentContentBlockIndex >= 0) {
+          safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: currentContentBlockIndex
+          })}
+
+`);
+        }
+        if (stopReasonDelta) {
+          safeEnqueue(`event: message_delta
+data: ${JSON.stringify(stopReasonDelta)}
+
+`);
+        } else {
+          safeEnqueue(`event: message_delta
+data: ${JSON.stringify({
+            type: "message_delta",
+            delta: { stop_reason: "end_turn", stop_sequence: null },
+            usage: { input_tokens: 0, output_tokens: 0 }
+          })}
+
+`);
+        }
+        safeEnqueue(`event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`);
+        try {
+          controller.close();
+        } catch (_e) {
+        }
+        isClosed = true;
+      };
+      try {
+        armPing();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (isClosed) break;
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (data === "[DONE]") continue;
+            try {
+              const chunk = JSON.parse(data);
+              if (chunk.error) {
+                safeEnqueue(`event: error
+data: ${JSON.stringify({
+                  type: "error",
+                  error: {
+                    type: sniffErrorType(chunk.error),
+                    message: JSON.stringify(chunk.error)
+                  }
+                })}
+
+`);
+                continue;
+              }
+              if (chunk.type === "response.failed" && _optionalChain([chunk, 'access', _7 => _7.response, 'optionalAccess', _8 => _8.error])) {
+                safeEnqueue(`event: error
+data: ${JSON.stringify({
+                  type: "error",
+                  error: {
+                    type: sniffErrorType(chunk.response.error),
+                    message: JSON.stringify(chunk.response.error)
+                  }
+                })}
+
+`);
+                continue;
+              }
+              model = chunk.model || model;
+              if (!hasStarted) {
+                hasStarted = true;
+                const startUsage = chunk.usage ? {
+                  input_tokens: (chunk.usage.prompt_tokens || 0) - (_optionalChain([chunk, 'access', _9 => _9.usage, 'access', _10 => _10.prompt_tokens_details, 'optionalAccess', _11 => _11.cached_tokens]) || 0),
+                  output_tokens: chunk.usage.completion_tokens || 0
+                } : { input_tokens: 0, output_tokens: 0 };
+                safeEnqueue(`event: message_start
+data: ${JSON.stringify({
+                  type: "message_start",
+                  message: {
+                    id: messageId,
+                    type: "message",
+                    role: "assistant",
+                    content: [],
+                    model,
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: startUsage
+                  }
+                })}
+
+`);
+              }
+              const choice = _optionalChain([chunk, 'access', _12 => _12.choices, 'optionalAccess', _13 => _13[0]]);
+              if (!choice) continue;
+              if (chunk.usage) {
+                stopReasonDelta = {
+                  type: "message_delta",
+                  delta: { stop_reason: "end_turn", stop_sequence: null },
+                  usage: {
+                    input_tokens: (chunk.usage.prompt_tokens || 0) - (_optionalChain([chunk, 'access', _14 => _14.usage, 'access', _15 => _15.prompt_tokens_details, 'optionalAccess', _16 => _16.cached_tokens]) || 0),
+                    output_tokens: chunk.usage.completion_tokens || 0,
+                    cache_read_input_tokens: _optionalChain([chunk, 'access', _17 => _17.usage, 'access', _18 => _18.prompt_tokens_details, 'optionalAccess', _19 => _19.cached_tokens]) || 0
+                  }
+                };
+              }
+              if (_optionalChain([choice, 'access', _20 => _20.delta, 'optionalAccess', _21 => _21.thinking])) {
+                if (!isThinkingStarted) {
+                  const thinkingBlockIndex = assignContentBlockIndex();
+                  safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                    type: "content_block_start",
+                    index: thinkingBlockIndex,
+                    content_block: { type: "thinking", thinking: "" }
+                  })}
+
+`);
+                  currentContentBlockIndex = thinkingBlockIndex;
+                  isThinkingStarted = true;
+                }
+                if (choice.delta.thinking.signature) {
+                  safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: currentContentBlockIndex,
+                    delta: { type: "signature_delta", signature: choice.delta.thinking.signature }
+                  })}
+
+`);
+                  safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                    type: "content_block_stop",
+                    index: currentContentBlockIndex
+                  })}
+
+`);
+                  currentContentBlockIndex = -1;
+                } else if (choice.delta.thinking.content) {
+                  safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: currentContentBlockIndex,
+                    delta: { type: "thinking_delta", thinking: choice.delta.thinking.content }
+                  })}
+
+`);
+                }
+              }
+              if (_optionalChain([choice, 'access', _22 => _22.delta, 'optionalAccess', _23 => _23.content])) {
+                if (!hasTextContentStarted) {
+                  if (currentContentBlockIndex >= 0 && isThinkingStarted) {
+                    safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                      type: "content_block_stop",
+                      index: currentContentBlockIndex
+                    })}
+
+`);
+                  }
+                  hasTextContentStarted = true;
+                  const textBlockIndex = assignContentBlockIndex();
+                  safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                    type: "content_block_start",
+                    index: textBlockIndex,
+                    content_block: { type: "text", text: "" }
+                  })}
+
+`);
+                  currentContentBlockIndex = textBlockIndex;
+                }
+                safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                  type: "content_block_delta",
+                  index: currentContentBlockIndex,
+                  delta: { type: "text_delta", text: choice.delta.content }
+                })}
+
+`);
+              }
+              if (_optionalChain([choice, 'access', _24 => _24.delta, 'optionalAccess', _25 => _25.tool_calls])) {
+                for (const toolCall of choice.delta.tool_calls) {
+                  const toolCallIndex = _nullishCoalesce(toolCall.index, () => ( 0));
+                  if (!toolCallIndexToContentBlockIndex.has(toolCallIndex)) {
+                    if (currentContentBlockIndex >= 0) {
+                      safeEnqueue(`event: content_block_stop
+data: ${JSON.stringify({
+                        type: "content_block_stop",
+                        index: currentContentBlockIndex
+                      })}
+
+`);
+                      hasTextContentStarted = false;
+                    }
+                    const newBlockIndex = assignContentBlockIndex();
+                    toolCallIndexToContentBlockIndex.set(toolCallIndex, newBlockIndex);
+                    safeEnqueue(`event: content_block_start
+data: ${JSON.stringify({
+                      type: "content_block_start",
+                      index: newBlockIndex,
+                      content_block: {
+                        type: "tool_use",
+                        id: toolCall.id || `call_${Date.now()}_${toolCallIndex}`,
+                        name: _optionalChain([toolCall, 'access', _26 => _26.function, 'optionalAccess', _27 => _27.name]) || `tool_${toolCallIndex}`,
+                        input: {}
+                      }
+                    })}
+
+`);
+                    currentContentBlockIndex = newBlockIndex;
+                  }
+                  if (_optionalChain([toolCall, 'access', _28 => _28.function, 'optionalAccess', _29 => _29.arguments])) {
+                    const blockIndex = toolCallIndexToContentBlockIndex.get(toolCallIndex);
+                    if (blockIndex !== void 0) {
+                      safeEnqueue(`event: content_block_delta
+data: ${JSON.stringify({
+                        type: "content_block_delta",
+                        index: blockIndex,
+                        delta: { type: "input_json_delta", partial_json: toolCall.function.arguments }
+                      })}
+
+`);
+                    }
+                  }
+                }
+              }
+              if (choice.finish_reason) {
+                if (choice.finish_reason === "content_filter") {
+                  noteContentFilterRemap(logger);
+                }
+                const stopReasonMapping = {
+                  stop: "end_turn",
+                  length: "max_tokens",
+                  tool_calls: "tool_use",
+                  content_filter: "refusal",
+                  refusal: "refusal",
+                  pause_turn: "pause_turn"
+                };
+                stopReasonDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: stopReasonMapping[choice.finish_reason] || "end_turn",
+                    stop_sequence: null
+                  },
+                  usage: {
+                    input_tokens: (_optionalChain([chunk, 'access', _30 => _30.usage, 'optionalAccess', _31 => _31.prompt_tokens]) || 0) - (_optionalChain([chunk, 'access', _32 => _32.usage, 'optionalAccess', _33 => _33.prompt_tokens_details, 'optionalAccess', _34 => _34.cached_tokens]) || 0),
+                    output_tokens: _optionalChain([chunk, 'access', _35 => _35.usage, 'optionalAccess', _36 => _36.completion_tokens]) || 0,
+                    cache_read_input_tokens: _optionalChain([chunk, 'access', _37 => _37.usage, 'optionalAccess', _38 => _38.prompt_tokens_details, 'optionalAccess', _39 => _39.cached_tokens]) || 0
+                  }
+                };
+              }
+            } catch (e) {
+              _optionalChain([logger, 'optionalAccess', _40 => _40.error, 'call', _41 => _41("Error parsing stream chunk:", e)]);
+            }
+          }
+          armPing();
+        }
+      } catch (e) {
+        if (!isClosed) {
+          controller.error(e);
+        }
+      } finally {
+        clearPing();
+        safeClose();
+        reader.releaseLock();
+      }
+    },
+    // R6: client disconnect. Cancelling the upstream reader settles the pending
+    // read(), which unblocks the loop's `finally` → `clearPing` — the timer is
+    // cleared INDIRECTLY (pinned by the cancel-leak fake-timer test).
+    cancel: async () => {
+      try {
+        await _optionalChain([reader, 'optionalAccess', _42 => _42.cancel, 'call', _43 => _43()]);
+      } catch (_e) {
+      }
+    }
+  });
+}
+
+
+
+
+
+
+
+
+exports.DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS = DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS; exports.setAnthropicPingHeartbeatMs = setAnthropicPingHeartbeatMs; exports.getAnthropicPingHeartbeatMs = getAnthropicPingHeartbeatMs; exports.stopReasonContentFilterCount = stopReasonContentFilterCount; exports.__resetStopReasonContentFilterCountForTests = __resetStopReasonContentFilterCountForTests; exports.convertOpenAIStreamToAnthropic = convertOpenAIStreamToAnthropic;

package/dist/{chunk-GXEZ2R3E.js → chunk-6OKXH2TW.js}

@@ -1,10 +1,10 @@
-import {
-  redactAuditText
-} from "./chunk-K5NM7VAH.js";
 import {
   getAuditCaptureConfig,
   recordAudit
 } from "./chunk-WNY4WMRF.js";
+import {
+  redactAuditText
+} from "./chunk-N76KU6F5.js";
 import {
   readAuditUsage
 } from "./chunk-OZFM4X3S.js";
@@ -195,24 +195,35 @@ function resolveClientIp(req, trustForwardedFor) {
   }
   return req.socket?.remoteAddress ?? void 0;
 }
-function beginAuditCapture(req, res, now) {
+function beginAuditCapture(req, res, now, options) {
   const config = getAuditCaptureConfig();
   if (!config) return null;
+  const captureBodies = config.captureBodies;
   let requestBody;
   const responseChunks = [];
   let responseBytes = 0;
   let responseTruncated = false;
+  let bodiesSuppressed = options?.suppressBodies === true;
   let finished = false;
   const ctx = {
     setRequestBody(raw) {
-      if (config.captureBodies) {
+      if (captureBodies && !bodiesSuppressed) {
         requestBody = truncateToBytes(redactAuditText(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;
@@ -263,7 +274,7 @@ function beginAuditCapture(req, res, now) {
       }
       if (ctx.error) record.error = redactAuditText(ctx.error);
       if (ctx.sessionKey) record.sessionKey = ctx.sessionKey;
-      if (config.captureBodies) {
+      if (captureBodies && !bodiesSuppressed) {
         if (requestBody != null && requestBody.length > 0) {
           record.requestBody = requestBody;
         }

package/dist/{chunk-YWL7YZWS.cjs → chunk-7LRTPNFL.cjs}

@@ -104,6 +104,11 @@ var SubscriptionAccountHealth = (_class = class {
     const preExisting = this.records.get(key);
     const record = _nullishCoalesce(preExisting, () => ( {}));
     const status = input.status;
+    if (input.upstreamErrorType) {
+      console.info(
+        `[AccountHealth] upstream error type ${input.upstreamErrorType} (provider=${providerId} status=${String(status)})`
+      );
+    }
     const wasUnhealthyBefore = preExisting ? this.isUnhealthyAt(preExisting, now) : false;
     let anomalyState;
     let recovered = false;

package/dist/{chunk-CCVRRJOX.js → chunk-7PIUVCKK.js}

@@ -1,11 +1,12 @@
 import {
   extractReasoningIntent,
+  recordDroppedField,
   resolveReasoningPlan
-} from "./chunk-N2EIM2XJ.js";
+} from "./chunk-ZLNHPUFA.js";
 
 // src/transformer/transformers/OpenAITransformer.ts
 var FOREIGN_MESSAGE_KEYS = ["cache_control", "thinking"];
-var FOREIGN_BODY_KEYS = ["meta", "reasoning", "thinking"];
+var FOREIGN_BODY_KEYS = ["meta", "reasoning", "thinking", "top_k", "metadata_user_id", "_transformWarnings"];
 function normalizeContent(content) {
   if (!Array.isArray(content)) return content;
   const cleaned = content.map((block) => {
@@ -36,6 +37,12 @@ var OpenAITransformer = class {
       if (FOREIGN_BODY_KEYS.includes(key)) continue;
       out[key] = source[key];
     }
+    if (request.metadata_user_id !== void 0) {
+      out.user = request.metadata_user_id;
+    }
+    if (request.top_k !== void 0) {
+      recordDroppedField(request, "top_k", "openai-chat");
+    }
     if (Array.isArray(request.messages)) {
       out.messages = request.messages.map((message) => {
         const src = message;