@omnicross/core 0.1.9 → 0.1.10

package/dist/{chunk-EPN67EGP.cjs → chunk-5UK3KLE2.cjs}

@@ -10,12 +10,14 @@ var UsageRecorder = class {
     this.logger = logger;
     this.defer = _nullishCoalesce(options.defer, () => ( ((fn) => setTimeout(fn, 0))));
     this.onRecord = options.onRecord;
+    this.onEvent = options.onEvent;
   }
   
   
   
   
   
+  
   /**
    * Record one LLM request. Returns immediately — the actual store insert is
    * deferred so the caller's response path is unblocked.
@@ -85,6 +87,12 @@ var UsageRecorder = class {
       ...input.cacheKeySource !== void 0 ? { cacheKeySource: input.cacheKeySource } : {},
       ...input.cacheKeyInjected !== void 0 ? { cacheKeyInjected: input.cacheKeyInjected } : {}
     };
+    if (this.onEvent) {
+      try {
+        this.onEvent(row, Date.now());
+      } catch (e3) {
+      }
+    }
     try {
       return await this.store.insert(row);
     } catch (err) {
@@ -118,7 +126,7 @@ var UsageRecorder = class {
 var safeStringify = (value) => {
   try {
     return JSON.stringify(value);
-  } catch (e3) {
+  } catch (e4) {
     return "";
   }
 };

package/dist/chunk-6D4W22P4.js

@@ -0,0 +1,150 @@
+// src/usage/throughputTracker.ts
+var THROUGHPUT_RETENTION_MS = 15 * 6e4;
+var THROUGHPUT_SAMPLE_LIMIT = 2e4;
+var THROUGHPUT_WINDOWS_MS = [6e4, 3e5, 9e5];
+var THROUGHPUT_BUCKET_COUNT = 30;
+var COMPACT_THRESHOLD = 1024;
+var UsageThroughputTracker = class {
+  samples = [];
+  /** Index of the oldest live sample; slots before it are consumed. */
+  head = 0;
+  startedAt;
+  /** Newest ts dropped by the sample CAP (not by retention). Null when none. */
+  evictedThroughTs = null;
+  constructor(now = Date.now()) {
+    this.startedAt = now;
+  }
+  /** Record one served request. O(1) amortised; never touches disk. */
+  record(input, now = Date.now()) {
+    this.samples.push({
+      ts: input.ts ?? now,
+      inputTokens: input.inputTokens,
+      outputTokens: input.outputTokens,
+      cacheReadTokens: input.cacheReadTokens,
+      cacheCreationTokens: input.cacheCreationTokens,
+      reasoningTokens: input.reasoningTokens,
+      costUsd: input.costUsd
+    });
+    this.prune(now);
+  }
+  /** Aggregate every reported window plus the shared trend series. */
+  snapshot(now = Date.now()) {
+    this.prune(now);
+    return {
+      available: true,
+      collectedAt: now,
+      startedAt: this.startedAt,
+      retentionMs: THROUGHPUT_RETENTION_MS,
+      bucketMs: THROUGHPUT_RETENTION_MS / THROUGHPUT_BUCKET_COUNT,
+      windows: THROUGHPUT_WINDOWS_MS.map((windowMs) => this.window(windowMs, now)),
+      buckets: this.buckets(now)
+    };
+  }
+  /** Drop all samples (tests / teardown). `startedAt` is unchanged. */
+  clear() {
+    this.samples = [];
+    this.head = 0;
+    this.evictedThroughTs = null;
+  }
+  /**
+   * Drop samples past the retention horizon, then enforce the sample cap.
+   *
+   * Retention pruning uses the CALLER's `now`, which is never later than a
+   * subsequent snapshot's `now`, so it can only ever keep MORE than the widest
+   * window needs — it can never shave data off the 15-minute window.
+   */
+  prune(now) {
+    const cutoff = now - THROUGHPUT_RETENTION_MS;
+    while (this.head < this.samples.length && this.samples[this.head].ts < cutoff) {
+      this.head += 1;
+    }
+    while (this.samples.length - this.head > THROUGHPUT_SAMPLE_LIMIT) {
+      const dropped = this.samples[this.head];
+      this.evictedThroughTs = this.evictedThroughTs === null ? dropped.ts : Math.max(this.evictedThroughTs, dropped.ts);
+      this.head += 1;
+    }
+    if (this.head >= COMPACT_THRESHOLD) {
+      this.samples = this.samples.slice(this.head);
+      this.head = 0;
+    }
+  }
+  window(windowMs, now) {
+    const startTs = now - windowMs;
+    const row = {
+      windowMs,
+      requests: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      reasoningTokens: 0,
+      totalTokens: 0,
+      costUsd: 0,
+      requestsPerMinute: 0,
+      tokensPerMinute: 0,
+      inputTokensPerMinute: 0,
+      outputTokensPerMinute: 0,
+      costUsdPerMinute: 0,
+      complete: this.evictedThroughTs === null || this.evictedThroughTs < startTs
+    };
+    for (let i = this.head; i < this.samples.length; i += 1) {
+      const sample = this.samples[i];
+      if (sample.ts < startTs) continue;
+      row.requests += 1;
+      row.inputTokens += sample.inputTokens;
+      row.outputTokens += sample.outputTokens;
+      row.cacheReadTokens += sample.cacheReadTokens;
+      row.cacheCreationTokens += sample.cacheCreationTokens;
+      row.reasoningTokens += sample.reasoningTokens;
+      row.costUsd += sample.costUsd;
+    }
+    row.totalTokens = row.inputTokens + row.outputTokens + row.cacheReadTokens + row.cacheCreationTokens;
+    const minutes = windowMs / 6e4;
+    row.requestsPerMinute = row.requests / minutes;
+    row.tokensPerMinute = row.totalTokens / minutes;
+    row.inputTokensPerMinute = row.inputTokens / minutes;
+    row.outputTokensPerMinute = row.outputTokens / minutes;
+    row.costUsdPerMinute = row.costUsd / minutes;
+    return row;
+  }
+  buckets(now) {
+    const bucketMs = THROUGHPUT_RETENTION_MS / THROUGHPUT_BUCKET_COUNT;
+    const endTs = Math.floor(now / bucketMs) * bucketMs + bucketMs;
+    const startTs = endTs - THROUGHPUT_RETENTION_MS;
+    const out = [];
+    for (let i = 0; i < THROUGHPUT_BUCKET_COUNT; i += 1) {
+      out.push({ startTs: startTs + i * bucketMs, requests: 0, tokens: 0 });
+    }
+    for (let i = this.head; i < this.samples.length; i += 1) {
+      const sample = this.samples[i];
+      if (sample.ts < startTs || sample.ts >= endTs) continue;
+      const bucket = out[Math.floor((sample.ts - startTs) / bucketMs)];
+      if (!bucket) continue;
+      bucket.requests += 1;
+      bucket.tokens += sample.inputTokens + sample.outputTokens + sample.cacheReadTokens + sample.cacheCreationTokens;
+    }
+    return out;
+  }
+};
+var sharedTracker = null;
+function getSharedUsageThroughputTracker() {
+  if (!sharedTracker) sharedTracker = new UsageThroughputTracker();
+  return sharedTracker;
+}
+function setSharedUsageThroughputTracker(instance) {
+  sharedTracker = instance;
+}
+function __resetSharedUsageThroughputTrackerForTests() {
+  sharedTracker = null;
+}
+
+export {
+  THROUGHPUT_RETENTION_MS,
+  THROUGHPUT_SAMPLE_LIMIT,
+  THROUGHPUT_WINDOWS_MS,
+  THROUGHPUT_BUCKET_COUNT,
+  UsageThroughputTracker,
+  getSharedUsageThroughputTracker,
+  setSharedUsageThroughputTracker,
+  __resetSharedUsageThroughputTrackerForTests
+};

package/dist/{chunk-UAPBLNN2.js → chunk-AQDON6MB.js}

@@ -10,12 +10,14 @@ var UsageRecorder = class {
     this.logger = logger;
     this.defer = options.defer ?? ((fn) => setTimeout(fn, 0));
     this.onRecord = options.onRecord;
+    this.onEvent = options.onEvent;
   }
   store;
   pricing;
   logger;
   defer;
   onRecord;
+  onEvent;
   /**
    * Record one LLM request. Returns immediately — the actual store insert is
    * deferred so the caller's response path is unblocked.
@@ -85,6 +87,12 @@ var UsageRecorder = class {
       ...input.cacheKeySource !== void 0 ? { cacheKeySource: input.cacheKeySource } : {},
       ...input.cacheKeyInjected !== void 0 ? { cacheKeyInjected: input.cacheKeyInjected } : {}
     };
+    if (this.onEvent) {
+      try {
+        this.onEvent(row, Date.now());
+      } catch {
+      }
+    }
     try {
       return await this.store.insert(row);
     } catch (err) {

package/dist/{chunk-CQIJCPMF.js → chunk-FEBAQI5A.js}

@@ -33,9 +33,11 @@ import {
   captureCallerIdentity
 } from "./chunk-XX6NQJMA.js";
 import {
+  MATCH_TEXT_PER_MESSAGE_CAP,
   collectMatchText,
   deriveGatewaySessionKey,
-  deriveSubscriptionSessionKey
+  deriveSubscriptionSessionKey,
+  flattenMatchText
 } from "./chunk-GFIZ6LQI.js";
 import {
   emitWebhookEvent
@@ -104,7 +106,7 @@ import {
 } from "./chunk-H5JUT3KV.js";
 import {
   beginAuditCapture
-} from "./chunk-7C7DET6S.js";
+} from "./chunk-GXEZ2R3E.js";
 import {
   convertAnthropicToOpenAI,
   convertOpenAIToAnthropic
@@ -3664,6 +3666,7 @@ function normalizeAudit(raw) {
     retentionDays: Math.trunc(
       clampNumber(a?.retentionDays, 1, 365, DEFAULT_AUDIT_CONFIG.retentionDays)
     ),
+    compactStreamingBodies: a?.compactStreamingBodies === true,
     trustForwardedFor: a?.trustForwardedFor === true
   };
 }
@@ -4131,8 +4134,62 @@ function mergeServerConfig(current, patch) {
   });
 }
 
+// src/outbound-api/auditSessionKey.ts
+import { createHash as createHash2 } from "crypto";
+var EXPLICIT_ID_SOURCES = /* @__PURE__ */ new Set([
+  "session-header",
+  "thread-header",
+  "body-session-id",
+  "body-thread-id",
+  "prompt-cache-key"
+]);
+var ANTHROPIC_SESSION_RE = /_session_([A-Za-z0-9][A-Za-z0-9_-]{7,})/;
+var DIGEST_HEX = 32;
+function stableDigest(value) {
+  return createHash2("sha256").update(value, "utf8").digest("hex").slice(0, DIGEST_HEX);
+}
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function anthropicSessionId(body) {
+  const userId = asObject(body["metadata"])?.["user_id"];
+  if (typeof userId !== "string" || !userId) return void 0;
+  const matched = ANTHROPIC_SESSION_RE.exec(userId);
+  return matched?.[1];
+}
+function anthropicContentFingerprint(body) {
+  const messages = body["messages"];
+  if (!Array.isArray(messages) || messages.length === 0) return void 0;
+  const parts = [];
+  const system = flattenMatchText(body["system"]).trim();
+  if (system) parts.push(system.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  let firstUser = "";
+  for (const entry of messages) {
+    const message = asObject(entry);
+    if (!message || message["role"] !== "user") continue;
+    const text = flattenMatchText(message["content"]).trim();
+    if (!text) continue;
+    firstUser = text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+    break;
+  }
+  if (parts.length === 0 && !firstUser) return void 0;
+  return `${parts.join("\0")}\0${firstUser}`;
+}
+function deriveAuditSessionKey(body, headers = {}, options = {}) {
+  const anthropicSession = anthropicSessionId(body);
+  if (anthropicSession) return stableDigest(`anthropic-session\0${anthropicSession}`);
+  const gateway = deriveGatewaySessionKey(body, headers, {
+    ...options.fallbackKey !== void 0 ? { fallbackKey: options.fallbackKey } : {},
+    ...options.endpoint !== void 0 ? { endpoint: options.endpoint } : {}
+  });
+  if (EXPLICIT_ID_SOURCES.has(gateway.source)) return gateway.key;
+  const fingerprint = anthropicContentFingerprint(body);
+  if (fingerprint) return stableDigest(`anthropic-content\0${fingerprint}`);
+  return gateway.key;
+}
+
 // src/outbound-api/outboundApiKeyAuth.ts
-import { createHash as createHash2, randomBytes as randomBytes4 } from "crypto";
+import { createHash as createHash3, randomBytes as randomBytes4 } from "crypto";
 
 // src/outbound-api/keyPolicy.ts
 var DAY_MS = 864e5;
@@ -4197,7 +4254,7 @@ function generateSecret() {
   return KEY_PREFIX + randomBase62(SECRET_BYTES);
 }
 function hashKey(secret) {
-  return createHash2("sha256").update(secret, "utf8").digest("hex");
+  return createHash3("sha256").update(secret, "utf8").digest("hex");
 }
 function keyPrefix(secret) {
   return secret.slice(0, PREFIX_LEN);
@@ -4525,7 +4582,7 @@ var OutboundRateLimiter = class {
 function asArray(v) {
   return Array.isArray(v) ? v : [];
 }
-function asObject(v) {
+function asObject2(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
 }
 function last(arr) {
@@ -4533,13 +4590,13 @@ function last(arr) {
 }
 function isUserMessageAnthropic(body) {
   const messages = asArray(body["messages"]);
-  const lastMsg = asObject(last(messages));
+  const lastMsg = asObject2(last(messages));
   if (!lastMsg || lastMsg["role"] !== "user") return false;
   const content = lastMsg["content"];
   if (typeof content === "string") return true;
   if (Array.isArray(content)) {
     const hasToolResult = content.some(
-      (block) => asObject(block)?.["type"] === "tool_result"
+      (block) => asObject2(block)?.["type"] === "tool_result"
     );
     return !hasToolResult;
   }
@@ -4549,7 +4606,7 @@ function isUserMessageResponses(body) {
   const input = body["input"];
   if (typeof input === "string") return input.length > 0;
   if (Array.isArray(input)) {
-    const lastItem = asObject(last(input));
+    const lastItem = asObject2(last(input));
     if (!lastItem) return false;
     if (lastItem["type"] === "function_call_output") return false;
     return lastItem["role"] === "user";
@@ -4558,22 +4615,22 @@ function isUserMessageResponses(body) {
 }
 function isUserMessageChat(body) {
   const messages = asArray(body["messages"]);
-  const lastMsg = asObject(last(messages));
+  const lastMsg = asObject2(last(messages));
   if (!lastMsg) return false;
   return lastMsg["role"] === "user";
 }
 function isUserMessageGemini(body) {
   const contents = asArray(body["contents"]);
-  const lastContent = asObject(last(contents));
+  const lastContent = asObject2(last(contents));
   if (!lastContent || lastContent["role"] !== "user") return false;
   const parts = asArray(lastContent["parts"]);
   const hasFunctionResponse = parts.some(
-    (part) => asObject(part)?.["functionResponse"] !== void 0
+    (part) => asObject2(part)?.["functionResponse"] !== void 0
   );
   return !hasFunctionResponse;
 }
 function isUserMessageRequest(endpoint, parsedBody) {
-  const body = asObject(parsedBody);
+  const body = asObject2(parsedBody);
   if (!body) return false;
   switch (endpoint) {
     case "messages":
@@ -4723,7 +4780,7 @@ var UserMessageSerialQueue = class {
 };
 
 // src/outbound-api/voucher.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var CODE_ENTROPY_CHARS = 32;
 var CODE_PREFIX = "CC_";
 var DISPLAY_PREFIX_LEN = 8;
@@ -4732,7 +4789,7 @@ function generateVoucherCode() {
   return CODE_PREFIX + randomBase62(CODE_ENTROPY_CHARS);
 }
 function hashVoucherCode(code) {
-  return createHash3("sha256").update(code, "utf8").digest("hex");
+  return createHash4("sha256").update(code, "utf8").digest("hex");
 }
 function voucherCodePrefix(code) {
   return code.slice(0, DISPLAY_PREFIX_LEN);
@@ -5185,7 +5242,13 @@ async function handleOutboundRequest(req, res, deps, config, rateLimiter, serial
       writeJsonError(res, 400, "Invalid JSON in request body");
       return;
     }
-    if (audit) audit.setRequestBody(rawBody);
+    if (audit) {
+      audit.setRequestBody(rawBody);
+      audit.sessionKey = deriveAuditSessionKey(parsedBody, req.headers, {
+        fallbackKey: verified.id,
+        endpoint
+      });
+    }
     if (endpoint === "gemini" && typeof parsedBody["model"] !== "string") {
       const urlModel = extractGeminiModelFromUrl(req.url);
       if (urlModel) parsedBody["model"] = urlModel;

package/dist/{chunk-7C7DET6S.js → chunk-GXEZ2R3E.js}

@@ -11,6 +11,156 @@ import {
 
 // 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;
@@ -112,15 +262,20 @@ function beginAuditCapture(req, res, now) {
         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 (config.captureBodies) {
         if (requestBody != null && requestBody.length > 0) {
           record.requestBody = requestBody;
         }
         if (responseChunks.length > 0) {
           const captured = Buffer.concat(responseChunks, responseBytes);
-          const body = decodeCapturedBody(captured, responseTruncated);
+          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 {