@tangle-network/agent-eval 0.128.2 → 0.129.0

package/dist/{chunk-EOSZT7PL.js → chunk-U4L7JRPZ.js}

@@ -29,7 +29,7 @@ import {
   canonicalize,
   hashJson,
   validateRunRecord
-} from "./chunk-2JX3CFMB.js";
+} from "./chunk-56TAVBOK.js";
 import {
   ReplayError
 } from "./chunk-ONWEPEDO.js";
@@ -787,299 +787,6 @@ function modelHasSnapshot(model) {
   return false;
 }
 
-// src/trace/store.ts
-var InMemoryTraceStore = class {
-  runs = /* @__PURE__ */ new Map();
-  allSpans = [];
-  allEvents = [];
-  allArtifacts = [];
-  allBudget = [];
-  async appendRun(run) {
-    if (this.runs.has(run.runId)) throw new Error(`run ${run.runId} already exists`);
-    this.runs.set(run.runId, { ...run });
-  }
-  async updateRun(runId, patch) {
-    const existing = this.runs.get(runId);
-    if (!existing) throw new Error(`run ${runId} not found`);
-    this.runs.set(runId, { ...existing, ...patch });
-  }
-  async appendSpan(span) {
-    this.allSpans.push({ ...span });
-  }
-  async updateSpan(spanId, patch) {
-    const idx = this.allSpans.findIndex((s) => s.spanId === spanId);
-    if (idx < 0) throw new Error(`span ${spanId} not found`);
-    this.allSpans[idx] = { ...this.allSpans[idx], ...patch };
-  }
-  async appendEvent(event) {
-    this.allEvents.push({ ...event });
-  }
-  async appendArtifact(artifact) {
-    this.allArtifacts.push({ ...artifact });
-  }
-  async appendBudgetEntry(entry) {
-    this.allBudget.push({ ...entry });
-  }
-  async getRun(runId) {
-    const r = this.runs.get(runId);
-    return r ? { ...r } : void 0;
-  }
-  async listRuns(filter = {}) {
-    return [...this.runs.values()].filter((r) => matchesRun(r, filter));
-  }
-  async spans(filter = {}) {
-    return this.allSpans.filter((s) => matchesSpan(s, filter)).map((s) => ({ ...s }));
-  }
-  async events(filter = {}) {
-    return this.allEvents.filter((e) => matchesEvent(e, filter)).map((e) => ({ ...e }));
-  }
-  async budget(runId) {
-    return this.allBudget.filter((b) => b.runId === runId).map((b) => ({ ...b }));
-  }
-  async artifacts(runId) {
-    return this.allArtifacts.filter((a) => a.runId === runId).map((a) => ({ ...a }));
-  }
-};
-function matchesRun(r, f) {
-  if (f.scenarioId && r.scenarioId !== f.scenarioId) return false;
-  if (f.variantId && r.variantId !== f.variantId) return false;
-  if (f.status && r.status !== f.status) return false;
-  if (f.since !== void 0 && r.startedAt < f.since) return false;
-  if (f.until !== void 0 && r.startedAt > f.until) return false;
-  if (f.tag && r.tags?.[f.tag.key] !== f.tag.value) return false;
-  if (f.parentRunId && r.parentRunId !== f.parentRunId) return false;
-  if (f.projectId && r.projectId !== f.projectId) return false;
-  if (f.chatId && r.chatId !== f.chatId) return false;
-  if (f.layer && r.layer !== f.layer) return false;
-  return true;
-}
-function matchesSpan(s, f) {
-  if (f.runId && s.runId !== f.runId) return false;
-  if (f.parentSpanId && s.parentSpanId !== f.parentSpanId) return false;
-  if (f.kind && s.kind !== f.kind) return false;
-  if (f.name && s.name !== f.name) return false;
-  if (f.toolName && (s.kind !== "tool" || s.toolName !== f.toolName)) return false;
-  if (f.judgeId && (s.kind !== "judge" || s.judgeId !== f.judgeId)) return false;
-  if (f.since !== void 0 && s.startedAt < f.since) return false;
-  if (f.until !== void 0 && s.startedAt > f.until) return false;
-  return true;
-}
-function matchesEvent(e, f) {
-  if (f.runId && e.runId !== f.runId) return false;
-  if (f.spanId && e.spanId !== f.spanId) return false;
-  if (f.kind && e.kind !== f.kind) return false;
-  if (f.since !== void 0 && e.timestamp < f.since) return false;
-  if (f.until !== void 0 && e.timestamp > f.until) return false;
-  return true;
-}
-var FileSystemTraceStore = class {
-  dir;
-  maxBytes;
-  /** Lazy in-memory index for queries — populated on first read. */
-  index;
-  /** Memoized index build — concurrent first reads share one build, and an
-   *  append racing an in-flight load awaits this so its row isn't lost. */
-  indexPromise;
-  /** Strictly-increasing rollover stamp. Date.now() alone collides when two
-   *  rollovers land in the same millisecond, overwriting a rolled file. */
-  lastRolloverStamp = 0;
-  /**
-   * Per-file append serialization. stat → conditional-rename → appendFile is a
-   * read-modify-write on the active file; without a lock two concurrent appends
-   * to the same `name` can both pass the size check (exceeding maxBytes) or one
-   * can append to a file the other just renamed away. Each entry chains the
-   * next append behind the prior one for that file.
-   */
-  appendLocks = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.dir = options.dir;
-    this.maxBytes = options.maxBytes ?? 32 * 1024 * 1024;
-  }
-  async ensureDir() {
-    const fs = await import("fs/promises");
-    await fs.mkdir(this.dir, { recursive: true });
-  }
-  async append(name, record) {
-    if (this.indexPromise) await this.indexPromise;
-    const prior = this.appendLocks.get(name) ?? Promise.resolve();
-    const result = prior.then(() => this.appendLocked(name, record));
-    const tail = result.then(
-      () => {
-      },
-      () => {
-      }
-    );
-    this.appendLocks.set(name, tail);
-    try {
-      await result;
-    } finally {
-      if (this.appendLocks.get(name) === tail) this.appendLocks.delete(name);
-    }
-  }
-  async appendLocked(name, record) {
-    await this.ensureDir();
-    const fs = await import("fs/promises");
-    const path = await import("path");
-    const active = path.join(this.dir, `${name}.ndjson`);
-    try {
-      const stat = await fs.stat(active);
-      if (stat.size >= this.maxBytes) {
-        const stamp = Math.max(Date.now(), this.lastRolloverStamp + 1);
-        this.lastRolloverStamp = stamp;
-        const rolled = path.join(this.dir, `${name}.${stamp}.ndjson`);
-        await fs.rename(active, rolled);
-      }
-    } catch {
-    }
-    await fs.appendFile(active, `${JSON.stringify(record)}
-`, "utf8");
-    if (this.index && !record?._update) {
-      await this.insertInto(name, record);
-    }
-  }
-  async insertInto(name, record) {
-    if (!this.index) return;
-    switch (name) {
-      case "runs":
-        await this.index.appendRun(record);
-        break;
-      case "spans":
-        await this.index.appendSpan(record);
-        break;
-      case "events":
-        await this.index.appendEvent(record);
-        break;
-      case "artifacts":
-        await this.index.appendArtifact(record);
-        break;
-      case "budget":
-        await this.index.appendBudgetEntry(record);
-        break;
-    }
-  }
-  load() {
-    this.indexPromise ??= this.buildIndex();
-    return this.indexPromise;
-  }
-  async buildIndex() {
-    const fs = await import("fs/promises");
-    const path = await import("path");
-    const store = new InMemoryTraceStore();
-    let entries;
-    try {
-      entries = await fs.readdir(this.dir);
-    } catch {
-      this.index = store;
-      return store;
-    }
-    entries.sort((a, b) => {
-      const baseA = a.split(".")[0];
-      const baseB = b.split(".")[0];
-      if (baseA !== baseB) return baseA < baseB ? -1 : 1;
-      const ta = a.match(/^[^.]+\.(\d+)\.ndjson$/);
-      const tb = b.match(/^[^.]+\.(\d+)\.ndjson$/);
-      const tsA = ta ? Number(ta[1]) : Number.POSITIVE_INFINITY;
-      const tsB = tb ? Number(tb[1]) : Number.POSITIVE_INFINITY;
-      return tsA - tsB;
-    });
-    {
-      const runUpdates = [];
-      const spanUpdates = [];
-      for (const file of entries) {
-        if (!file.endsWith(".ndjson")) continue;
-        const full = path.join(this.dir, file);
-        const content = await fs.readFile(full, "utf8");
-        const base = file.split(".")[0];
-        const lines = content.split("\n");
-        for (let ln = 0; ln < lines.length; ln++) {
-          const line = lines[ln];
-          if (!line.trim()) continue;
-          let record;
-          try {
-            record = JSON.parse(line);
-          } catch (err) {
-            throw new Error(
-              `FileSystemTraceStore: corrupt NDJSON in ${file} line ${ln + 1}: ${err instanceof Error ? err.message : String(err)} \u2014 ${line.slice(0, 120)}`
-            );
-          }
-          if (base === "runs") {
-            if (record?._update) {
-              runUpdates.push(record);
-              continue;
-            }
-            try {
-              await store.appendRun(record);
-            } catch {
-              await store.updateRun(record.runId, record);
-            }
-          } else if (base === "spans") {
-            if (record?._update) {
-              spanUpdates.push(record);
-              continue;
-            }
-            await store.appendSpan(record);
-          } else if (base === "events") {
-            await store.appendEvent(record);
-          } else if (base === "artifacts") {
-            await store.appendArtifact(record);
-          } else if (base === "budget") {
-            await store.appendBudgetEntry(record);
-          }
-        }
-      }
-      for (const record of runUpdates) {
-        await store.updateRun(record.runId, record);
-      }
-      for (const record of spanUpdates) {
-        await store.updateSpan(record.spanId, record);
-      }
-    }
-    this.index = store;
-    return store;
-  }
-  async appendRun(run) {
-    await this.append("runs", run);
-  }
-  async updateRun(runId, patch) {
-    await this.append("runs", { runId, ...patch, _update: true });
-    if (this.index) await this.index.updateRun(runId, patch);
-  }
-  async appendSpan(span) {
-    await this.append("spans", span);
-  }
-  async updateSpan(spanId, patch) {
-    await this.append("spans", { spanId, ...patch, _update: true });
-    if (this.index) await this.index.updateSpan(spanId, patch);
-  }
-  async appendEvent(event) {
-    await this.append("events", event);
-  }
-  async appendArtifact(artifact) {
-    await this.append("artifacts", artifact);
-  }
-  async appendBudgetEntry(entry) {
-    await this.append("budget", entry);
-  }
-  async getRun(runId) {
-    return (await this.load()).getRun(runId);
-  }
-  async listRuns(filter) {
-    return (await this.load()).listRuns(filter);
-  }
-  async spans(filter) {
-    return (await this.load()).spans(filter);
-  }
-  async events(filter) {
-    return (await this.load()).events(filter);
-  }
-  async budget(runId) {
-    return (await this.load()).budget(runId);
-  }
-  async artifacts(runId) {
-    return (await this.load()).artifacts(runId);
-  }
-};
-
 // src/trace/capture-fetch.ts
 var DEFAULT_BODY_CAP = 2 * 1024 * 1024;
 function headersToRecord(headers) {
@@ -1984,8 +1691,6 @@ export {
   otlpRowsToRunRecords,
   otlpToTraceRunRecords,
   otlpRowsToTraceRunRecords,
-  InMemoryTraceStore,
-  FileSystemTraceStore,
   captureFetchToRawSink,
   OTEL_AGENT_EVAL_SCOPE,
   exportRunAsOtlp,
@@ -1998,4 +1703,4 @@ export {
   createReplayFetch,
   iterateRawCalls
 };
-//# sourceMappingURL=chunk-EOSZT7PL.js.map
+//# sourceMappingURL=chunk-U4L7JRPZ.js.map