@omnicross/core 0.1.10 → 0.2.0

package/dist/chunk-LFEH7CEO.js

@@ -0,0 +1,384 @@
+// 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 = 0;
+}
+function noteContentFilterRemap(logger) {
+  stopReasonContentFilterCount += 1;
+  console.warn(
+    `[AnthropicStream] upstream finish_reason=content_filter remapped to stop_reason=refusal (count ${stopReasonContentFilterCount})`
+  );
+  logger?.warn?.("upstream finish_reason=content_filter remapped to stop_reason=refusal");
+}
+function sniffErrorType(error) {
+  let text;
+  try {
+    text = JSON.stringify(error) ?? "";
+  } catch {
+    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 [e?.status, e?.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);
+        pingTimer.unref?.();
+      };
+      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" && chunk.response?.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) - (chunk.usage.prompt_tokens_details?.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 = chunk.choices?.[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) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
+                    output_tokens: chunk.usage.completion_tokens || 0,
+                    cache_read_input_tokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0
+                  }
+                };
+              }
+              if (choice.delta?.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 (choice.delta?.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 (choice.delta?.tool_calls) {
+                for (const toolCall of choice.delta.tool_calls) {
+                  const toolCallIndex = 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: toolCall.function?.name || `tool_${toolCallIndex}`,
+                        input: {}
+                      }
+                    })}
+
+`);
+                    currentContentBlockIndex = newBlockIndex;
+                  }
+                  if (toolCall.function?.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: (chunk.usage?.prompt_tokens || 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens || 0),
+                    output_tokens: chunk.usage?.completion_tokens || 0,
+                    cache_read_input_tokens: chunk.usage?.prompt_tokens_details?.cached_tokens || 0
+                  }
+                };
+              }
+            } catch (e) {
+              logger?.error("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 reader?.cancel();
+      } catch (_e) {
+      }
+    }
+  });
+}
+
+export {
+  DEFAULT_ANTHROPIC_PING_HEARTBEAT_MS,
+  setAnthropicPingHeartbeatMs,
+  getAnthropicPingHeartbeatMs,
+  stopReasonContentFilterCount,
+  __resetStopReasonContentFilterCountForTests,
+  convertOpenAIStreamToAnthropic
+};

package/dist/chunk-N76KU6F5.js

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