@omnicross/core 0.1.2 → 0.1.4

package/dist/chunk-6RPZADX3.cjs

@@ -0,0 +1,92 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/provider-proxy/identity/fingerprintHeaders.ts
+var STAINLESS_PREFIX = "x-stainless-";
+var FINGERPRINT_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "user-agent",
+  "anthropic-beta",
+  "anthropic-version",
+  "anthropic-dangerous-direct-browser-access",
+  "x-app"
+]);
+var EXCLUDED_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "authorization",
+  "x-api-key",
+  "cookie",
+  "proxy-authorization",
+  "set-cookie"
+]);
+var PROTECTED_OUTBOUND = /* @__PURE__ */ new Set(["authorization", "content-type"]);
+function isStainless(name) {
+  return name.toLowerCase().startsWith(STAINLESS_PREFIX);
+}
+function extractFingerprintHeaders(reqHeaders) {
+  const out = {};
+  for (const [rawKey, rawVal] of Object.entries(reqHeaders)) {
+    if (rawVal === void 0) continue;
+    const key = rawKey.toLowerCase();
+    if (EXCLUDED_HEADER_NAMES.has(key)) continue;
+    const whitelisted = FINGERPRINT_HEADER_NAMES.has(key) || key.startsWith(STAINLESS_PREFIX);
+    if (!whitelisted) continue;
+    const value = Array.isArray(rawVal) ? rawVal.filter((v) => typeof v === "string").join(", ") : rawVal;
+    if (typeof value === "string" && value.length > 0) out[key] = value;
+  }
+  return out;
+}
+function captureCallerIdentity(store, reqHeaders) {
+  if (!store.isEnabled()) return void 0;
+  return extractFingerprintHeaders(reqHeaders);
+}
+function sanitizeFrozenHeaders(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (typeof v !== "string" || v.length === 0) continue;
+    const lower = k.toLowerCase();
+    if (EXCLUDED_HEADER_NAMES.has(lower) || PROTECTED_OUTBOUND.has(lower)) continue;
+    out[lower] = v;
+  }
+  return out;
+}
+function refreshNonStainless(frozen, incoming) {
+  const out = {};
+  for (const [k, v] of Object.entries(frozen)) {
+    if (isStainless(k)) out[k] = v;
+  }
+  const nonStainlessKeys = /* @__PURE__ */ new Set();
+  for (const k of Object.keys(frozen)) if (!isStainless(k)) nonStainlessKeys.add(k);
+  for (const k of Object.keys(incoming)) if (!isStainless(k)) nonStainlessKeys.add(k);
+  for (const k of nonStainlessKeys) {
+    const v = _nullishCoalesce(incoming[k], () => ( frozen[k]));
+    if (typeof v === "string" && v.length > 0) out[k] = v;
+  }
+  return out;
+}
+function mergeFrozenIdentity(headers, identity) {
+  const present = new Set(Object.keys(headers).map((k) => k.toLowerCase()));
+  for (const [k, v] of Object.entries(identity)) {
+    const lower = k.toLowerCase();
+    if (PROTECTED_OUTBOUND.has(lower)) continue;
+    if (present.has(lower)) continue;
+    headers[k] = v;
+  }
+}
+function applyFingerprint(store, headers, providerId, accountId, callerIdentity, now) {
+  if (!store.isEnabled() || !accountId) return;
+  if (callerIdentity) store.capture(providerId, accountId, callerIdentity, now);
+  const identity = store.replay(providerId, accountId);
+  if (identity) {
+    mergeFrozenIdentity(headers, identity);
+    return;
+  }
+  const ua = store.uaBaseline();
+  if (ua) mergeFrozenIdentity(headers, { "user-agent": ua });
+}
+
+
+
+
+
+
+
+
+
+
+exports.STAINLESS_PREFIX = STAINLESS_PREFIX; exports.isStainless = isStainless; exports.extractFingerprintHeaders = extractFingerprintHeaders; exports.captureCallerIdentity = captureCallerIdentity; exports.sanitizeFrozenHeaders = sanitizeFrozenHeaders; exports.refreshNonStainless = refreshNonStainless; exports.mergeFrozenIdentity = mergeFrozenIdentity; exports.applyFingerprint = applyFingerprint;

package/dist/chunk-7Y47UCF2.js

@@ -0,0 +1,142 @@
+import {
+  redactAuditText
+} from "./chunk-K5NM7VAH.js";
+import {
+  getAuditCaptureConfig,
+  recordAudit
+} from "./chunk-WNY4WMRF.js";
+import {
+  readAuditUsage
+} from "./chunk-OZFM4X3S.js";
+
+// src/outbound-api/auditCapture.ts
+import { randomUUID } from "crypto";
+function isStreamingContentType(res) {
+  const ct = res.getHeader("content-type");
+  const value = Array.isArray(ct) ? ct.join(";") : String(ct ?? "");
+  return value.toLowerCase().includes("text/event-stream");
+}
+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 truncateToBytes(text, maxBytes) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return text;
+  return buf.subarray(0, maxBytes).toString("utf8");
+}
+function beginAuditCapture(req, res, now) {
+  const config = getAuditCaptureConfig();
+  if (!config) return null;
+  let rawRequestBody;
+  const responseChunks = [];
+  let responseBytes = 0;
+  let streamDetected = false;
+  let finished = false;
+  const ctx = {
+    setRequestBody(raw) {
+      if (config.captureBodies) rawRequestBody = raw;
+    }
+  };
+  if (config.captureBodies) {
+    installResponseCapture(res, config.maxBodyBytes, {
+      push(chunk) {
+        responseBytes += chunk.length;
+        responseChunks.push(chunk);
+      },
+      get bytes() {
+        return responseBytes;
+      },
+      markStream() {
+        streamDetected = true;
+      },
+      get isStream() {
+        return streamDetected;
+      }
+    });
+  }
+  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 (config.captureBodies) {
+        if (rawRequestBody != null && rawRequestBody.length > 0) {
+          record.requestBody = redactAuditText(truncateToBytes(rawRequestBody, config.maxBodyBytes));
+        }
+        if (!streamDetected && responseChunks.length > 0) {
+          const body = Buffer.concat(responseChunks).toString("utf8");
+          record.responseBody = redactAuditText(body);
+        }
+      }
+      recordAudit(record);
+    } catch {
+    }
+  };
+  res.once("close", finalize);
+  return ctx;
+}
+function installResponseCapture(res, maxBodyBytes, sink) {
+  let contentTypeChecked = false;
+  const capture = (chunk) => {
+    if (sink.isStream) return;
+    if (!contentTypeChecked) {
+      contentTypeChecked = true;
+      if (isStreamingContentType(res)) {
+        sink.markStream();
+        return;
+      }
+    }
+    if (sink.bytes >= maxBodyBytes) return;
+    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;
+    const remaining = maxBodyBytes - sink.bytes;
+    sink.push(buf.length > remaining ? buf.subarray(0, remaining) : 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
+};

package/dist/chunk-AEOZIDEB.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/pipeline/auditSink.ts
+var sink = null;
+var captureConfig = null;
+function setAuditSink(fn) {
+  sink = fn;
+}
+function setAuditCaptureConfig(config) {
+  captureConfig = config && config.enabled ? config : null;
+}
+function getAuditCaptureConfig() {
+  return captureConfig;
+}
+function recordAudit(record) {
+  const active = sink;
+  if (!active) return;
+  try {
+    active(record);
+  } catch (e) {
+  }
+}
+function __resetAuditSinkForTests() {
+  sink = null;
+  captureConfig = null;
+}
+
+
+
+
+
+
+
+exports.setAuditSink = setAuditSink; exports.setAuditCaptureConfig = setAuditCaptureConfig; exports.getAuditCaptureConfig = getAuditCaptureConfig; exports.recordAudit = recordAudit; exports.__resetAuditSinkForTests = __resetAuditSinkForTests;

package/dist/chunk-APYG5QD7.cjs

@@ -0,0 +1,50 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkL74VDN4Acjs = require('./chunk-L74VDN4A.cjs');
+
+
+var _chunkXSVNC2UDcjs = require('./chunk-XSVNC2UD.cjs');
+
+// src/outbound-api/billingCapture.ts
+var _crypto = require('crypto');
+var defaultDefer = (fn) => {
+  setTimeout(fn, 0);
+};
+function beginBillingCapture(_req, res, now, defer = defaultDefer) {
+  if (!_chunkL74VDN4Acjs.getBillingCaptureConfig.call(void 0, )) return null;
+  const ctx = {};
+  let finished = false;
+  const finalize = () => {
+    if (finished) return;
+    finished = true;
+    const status = res.statusCode;
+    defer(() => {
+      try {
+        const usage = _chunkXSVNC2UDcjs.readAuditUsage.call(void 0, res);
+        if (!usage) return;
+        const event = {
+          id: _crypto.randomUUID.call(void 0, ),
+          ts: now,
+          model: _nullishCoalesce(_nullishCoalesce(ctx.model, () => ( usage.model)), () => ( "")),
+          authMode: _nullishCoalesce(ctx.authMode, () => ( "byo")),
+          inputTokens: _nullishCoalesce(usage.inputTokens, () => ( 0)),
+          outputTokens: _nullishCoalesce(usage.outputTokens, () => ( 0)),
+          costUsd: _nullishCoalesce(usage.costUsd, () => ( 0)),
+          status
+        };
+        if (ctx.keyId != null) event.keyId = ctx.keyId;
+        const provider = _nullishCoalesce(ctx.provider, () => ( usage.provider));
+        if (provider) event.provider = provider;
+        _chunkL74VDN4Acjs.publishBillingEvent.call(void 0, event);
+      } catch (e) {
+      }
+    });
+  };
+  res.once("close", finalize);
+  return ctx;
+}
+
+
+
+exports.beginBillingCapture = beginBillingCapture;

package/dist/{chunk-MNYKI4CI.js → chunk-BPKCU575.js}

@@ -1,3 +1,7 @@
+import {
+  stashAuditUsage
+} from "./chunk-OZFM4X3S.js";
+
 // src/usage/usage-recorder.ts
 var UsageRecorder = class {
   constructor(store, pricing, logger, options = {}) {
@@ -5,11 +9,13 @@ var UsageRecorder = class {
     this.pricing = pricing;
     this.logger = logger;
     this.defer = options.defer ?? ((fn) => setTimeout(fn, 0));
+    this.onRecord = options.onRecord;
   }
   store;
   pricing;
   logger;
   defer;
+  onRecord;
   /**
    * Record one LLM request. Returns immediately — the actual store insert is
    * deferred so the caller's response path is unblocked.
@@ -17,6 +23,14 @@ var UsageRecorder = class {
    * Errors during the insert are logged but never thrown.
    */
   record(input) {
+    if (input.auditResponse) {
+      stashAuditUsage(input.auditResponse, {
+        inputTokens: input.usage.inputTokens,
+        outputTokens: input.usage.outputTokens,
+        model: input.model,
+        provider: input.providerId
+      });
+    }
     this.defer(() => {
       void this.recordAsync(input).catch((err) => {
         this.logger.warn("[UsageRecorder] failed to persist usage event", {
@@ -35,6 +49,18 @@ var UsageRecorder = class {
       input.model,
       input.usage
     );
+    if (input.auditResponse) {
+      try {
+        stashAuditUsage(input.auditResponse, { costUsd });
+      } catch {
+      }
+    }
+    if (this.onRecord && input.apiKeyId) {
+      try {
+        this.onRecord(input.apiKeyId, costUsd, Date.now());
+      } catch {
+      }
+    }
     const row = {
       messageId: input.messageId ?? null,
       parentMessageId: input.parentMessageId ?? null,
@@ -73,6 +99,9 @@ var UsageRecorder = class {
   getByApiKey(range) {
     return this.store.getByApiKey(range);
   }
+  getTimeSeries(range, bucket) {
+    return this.store.getTimeSeries(range, bucket);
+  }
   getMessagesForSession(sessionId) {
     return this.store.getMessagesForSession(sessionId);
   }