@omnicross/core 0.1.9 → 0.1.10

package/dist/chunk-QUSEZNYS.cjs

@@ -0,0 +1,150 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;// 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 = class {
+  __init() {this.samples = []}
+  /** Index of the oldest live sample; slots before it are consumed. */
+  __init2() {this.head = 0}
+  
+  /** Newest ts dropped by the sample CAP (not by retention). Null when none. */
+  __init3() {this.evictedThroughTs = null}
+  constructor(now = Date.now()) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this.startedAt = now;
+  }
+  /** Record one served request. O(1) amortised; never touches disk. */
+  record(input, now = Date.now()) {
+    this.samples.push({
+      ts: _nullishCoalesce(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;
+  }
+}, _class);
+var sharedTracker = null;
+function getSharedUsageThroughputTracker() {
+  if (!sharedTracker) sharedTracker = new UsageThroughputTracker();
+  return sharedTracker;
+}
+function setSharedUsageThroughputTracker(instance) {
+  sharedTracker = instance;
+}
+function __resetSharedUsageThroughputTrackerForTests() {
+  sharedTracker = null;
+}
+
+
+
+
+
+
+
+
+
+
+exports.THROUGHPUT_RETENTION_MS = THROUGHPUT_RETENTION_MS; exports.THROUGHPUT_SAMPLE_LIMIT = THROUGHPUT_SAMPLE_LIMIT; exports.THROUGHPUT_WINDOWS_MS = THROUGHPUT_WINDOWS_MS; exports.THROUGHPUT_BUCKET_COUNT = THROUGHPUT_BUCKET_COUNT; exports.UsageThroughputTracker = UsageThroughputTracker; exports.getSharedUsageThroughputTracker = getSharedUsageThroughputTracker; exports.setSharedUsageThroughputTracker = setSharedUsageThroughputTracker; exports.__resetSharedUsageThroughputTrackerForTests = __resetSharedUsageThroughputTrackerForTests;