@omnicross/core 0.1.9 → 0.2.0

package/dist/{chunk-HKB656B4.js → chunk-6OC3ORW6.js}

@@ -1,6 +1,9 @@
 import {
   anthropicUsageToChatUsage
 } from "./chunk-FU7EAR73.js";
+import {
+  convertOpenAIStreamToAnthropic
+} from "./chunk-LFEH7CEO.js";
 import {
   flattenToolResultContent,
   formatBase64,
@@ -9,8 +12,9 @@ import {
 import {
   extractReasoningIntent,
   normalizeThinkLevel,
+  recordDroppedField,
   resolveReasoningPlan
-} from "./chunk-N2EIM2XJ.js";
+} from "./chunk-ZLNHPUFA.js";
 
 // src/transformer/transformers/AnthropicToolHandling.ts
 function isServerSideTool(tool) {
@@ -155,6 +159,14 @@ function buildAnthropicRequestBody(request, provider) {
   if (request.temperature !== void 0) {
     body.temperature = request.temperature;
   }
+  if (request.stop !== void 0 && request.stop.length > 0) {
+    body.stop_sequences = request.stop;
+  }
+  if (request.top_p !== void 0) body.top_p = request.top_p;
+  if (request.top_k !== void 0) body.top_k = request.top_k;
+  if (request.metadata_user_id !== void 0) {
+    body.metadata = { user_id: request.metadata_user_id };
+  }
   if (systemContent !== void 0) {
     body.system = systemContent;
   }
@@ -325,6 +337,7 @@ function convertOpenAIResponseToAnthropic(openaiResponse) {
 function transformAnthropicRequestToUnified(request) {
   const anthropicRequest = request;
   const messages = [];
+  let redactedSeen = false;
   if (anthropicRequest.system) {
     if (typeof anthropicRequest.system === "string") {
       messages.push({
@@ -419,15 +432,40 @@ function transformAnthropicRequestToUnified(request) {
             }
           }));
         }
-        const thinkingPart = msg.content.find(
-          (c) => c.type === "thinking"
-        );
-        if (thinkingPart?.thinking) {
+        let thinkingText = "";
+        let firstSignature;
+        let sawRedacted = false;
+        for (const block of msg.content) {
+          if (block.type === "thinking") {
+            const t = block.thinking;
+            if (typeof t === "string" && t.length > 0) {
+              if (thinkingText.length > 0) thinkingText += "\n";
+              thinkingText += t;
+            }
+            const signature = block.signature;
+            if (signature) {
+              if (firstSignature === void 0) {
+                firstSignature = signature;
+              } else if (typeof t === "string" && t.length > 0) {
+                thinkingText += `
+[signature: ${signature}]`;
+              }
+            }
+          } else if (block.type === "redacted_thinking") {
+            sawRedacted = true;
+            if (thinkingText.length > 0) thinkingText += "\n";
+            thinkingText += "[redacted thinking omitted]";
+          }
+        }
+        if (thinkingText.length > 0) {
           assistantMessage.thinking = {
-            content: thinkingPart.thinking,
-            signature: thinkingPart.signature
+            content: thinkingText,
+            signature: firstSignature
           };
         }
+        if (sawRedacted) {
+          redactedSeen = true;
+        }
         messages.push(assistantMessage);
       }
     }
@@ -443,6 +481,16 @@ function transformAnthropicRequestToUnified(request) {
     stream: anthropicRequest.stream,
     tools: functionTools?.length ? functionTools : void 0
   };
+  const raw = anthropicRequest;
+  if (Array.isArray(raw.stop_sequences)) {
+    result.stop = raw.stop_sequences.filter((s) => typeof s === "string");
+  }
+  if (typeof raw.top_p === "number") result.top_p = raw.top_p;
+  if (typeof raw.top_k === "number") result.top_k = raw.top_k;
+  if (typeof raw.metadata?.user_id === "string") result.metadata_user_id = raw.metadata.user_id;
+  if (redactedSeen) {
+    recordDroppedField(result, "redacted_thinking", "unified");
+  }
   if (serverSideTools.length > 0) {
     result._serverSideTools = serverSideTools;
   }
@@ -644,286 +692,6 @@ ${formatted}` },
   });
 }
 
-// src/transformer/transformers/AnthropicOpenAIToAnthropicStream.ts
-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();
-  return new ReadableStream({
-    start: async (controller) => {
-      const 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;
-          }
-        }
-      };
-      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 {
-        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",
-                  message: { type: "api_error", message: JSON.stringify(chunk.error) }
-                })}
-
-`);
-                continue;
-              }
-              model = chunk.model || model;
-              if (!hasStarted) {
-                hasStarted = true;
-                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: { input_tokens: 0, output_tokens: 0 }
-                  }
-                })}
-
-`);
-              }
-              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) {
-                const stopReasonMapping = {
-                  stop: "end_turn",
-                  length: "max_tokens",
-                  tool_calls: "tool_use",
-                  content_filter: "stop_sequence"
-                };
-                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);
-            }
-          }
-        }
-      } catch (e) {
-        if (!isClosed) {
-          controller.error(e);
-        }
-      } finally {
-        safeClose();
-        reader.releaseLock();
-      }
-    }
-  });
-}
-
 // src/transformer/transformers/AnthropicTransformer.ts
 var AnthropicTransformer = class {
   static TransformerName = "anthropic";

package/dist/chunk-6OKXH2TW.js

@@ -0,0 +1,320 @@
+import {
+  getAuditCaptureConfig,
+  recordAudit
+} from "./chunk-WNY4WMRF.js";
+import {
+  redactAuditText
+} from "./chunk-N76KU6F5.js";
+import {
+  readAuditUsage
+} from "./chunk-OZFM4X3S.js";
+
+// src/outbound-api/auditCapture.ts
+import { randomUUID } from "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(delta?.["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(choice?.["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 {
+        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 = raw.split(",")[0]?.trim();
+      if (first) return first;
+    }
+  }
+  return req.socket?.remoteAddress ?? void 0;
+}
+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 (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 (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: 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 (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(redactAuditText(body), config.maxBodyBytes);
+        }
+        if (record.requestBody !== void 0 || record.responseBody !== void 0) {
+          record.hasBody = true;
+        }
+      }
+      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
+};