@botpress/evals 1.19.0-beta.14 → 1.19.0-beta.16

package/dist/stores/vortex-eval-store-entry.js

@@ -1,664 +0,0 @@
-// src/stores/vortex-eval-store.ts
-var OUTCOME_TURN_INDEX = -1;
-function vortexEntryToEvalReport(entry) {
-  const outcomeAssertions = entry.results.filter((r) => r.turnIndex === OUTCOME_TURN_INDEX).map((r) => ({
-    assertion: r.graderName,
-    pass: r.passed,
-    expected: r.evidence?.expected ?? "",
-    actual: r.evidence?.actual ?? ""
-  }));
-  const resultsByTurn = /* @__PURE__ */ new Map();
-  for (const r of entry.results) {
-    if (r.turnIndex === OUTCOME_TURN_INDEX) continue;
-    const existing = resultsByTurn.get(r.turnIndex) ?? [];
-    existing.push(r);
-    resultsByTurn.set(r.turnIndex, existing);
-  }
-  const turns = [...resultsByTurn.entries()].sort(([a], [b]) => a - b).map(([turnIndex, results]) => {
-    const assertions = results.map((r) => ({
-      assertion: r.graderName,
-      pass: r.passed,
-      expected: r.evidence?.expected ?? "",
-      actual: r.evidence?.actual ?? ""
-    }));
-    const first = results[0];
-    return {
-      turnIndex,
-      userMessage: first.userMessage,
-      botResponse: first.botResponse,
-      assertions,
-      pass: assertions.every((a) => a.pass),
-      botDuration: first.botDurationMs ?? 0,
-      evalDuration: first.graderDurationMs ?? 0
-    };
-  });
-  return {
-    name: entry.evalName,
-    description: entry.description || void 0,
-    type: entry.evalType,
-    tags: entry.tags,
-    turns,
-    outcomeAssertions,
-    pass: entry.passed ?? false,
-    duration: entry.durationMs ?? 0,
-    error: entry.error ?? void 0
-  };
-}
-async function mapWithConcurrency(items, concurrency, fn) {
-  const results = new Array(items.length);
-  let next = 0;
-  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-    while (next < items.length) {
-      const i = next++;
-      results[i] = await fn(items[i]);
-    }
-  });
-  await Promise.all(workers);
-  return results;
-}
-function turnToResultRows(turn) {
-  return graderResultsToRows(turn.assertions, {
-    turnIndex: turn.turnIndex,
-    userMessage: turn.userMessage,
-    botResponse: turn.botResponse,
-    botDurationMs: turn.botDuration,
-    graderDurationMs: turn.evalDuration
-  });
-}
-function outcomeToResultRows(assertions) {
-  return graderResultsToRows(assertions, {
-    turnIndex: OUTCOME_TURN_INDEX,
-    userMessage: "",
-    botResponse: "",
-    botDurationMs: 0,
-    graderDurationMs: 0
-  });
-}
-function graderResultsToRows(assertions, context) {
-  return assertions.map((assertion) => ({
-    ...context,
-    graderName: assertion.assertion,
-    passed: assertion.pass,
-    evidence: { expected: assertion.expected, actual: assertion.actual }
-  }));
-}
-function runMatchesWatchOptions(run, options) {
-  if (options.runId && run.id !== options.runId) return false;
-  if (options.workflowId && run.metadata?.workflowId !== options.workflowId) return false;
-  return true;
-}
-function vortexRunToReport(run) {
-  const evals = run.entries.map(vortexEntryToEvalReport);
-  return {
-    id: run.id,
-    timestamp: run.createdAt,
-    evals,
-    passed: evals.filter((e) => e.pass).length,
-    failed: evals.filter((e) => !e.pass).length,
-    total: evals.length,
-    duration: evals.reduce((s, e) => s + e.duration, 0)
-  };
-}
-function vortexRunToSummary(run) {
-  const startMs = run.startedAt ? new Date(run.startedAt).getTime() : 0;
-  const endMs = run.completedAt ? new Date(run.completedAt).getTime() : 0;
-  if (run.entries) {
-    const evals = run.entries.map(vortexEntryToEvalReport);
-    return {
-      id: run.id,
-      timestamp: run.createdAt,
-      passed: evals.filter((e) => e.pass).length,
-      failed: evals.filter((e) => !e.pass).length,
-      total: evals.length,
-      duration: evals.reduce((s, e) => s + e.duration, 0),
-      botDuration: evals.reduce((s, e) => e.turns.reduce((ts, t) => ts + t.botDuration, s), 0),
-      evalDuration: evals.reduce((s, e) => e.turns.reduce((ts, t) => ts + t.evalDuration, s), 0),
-      evalNames: evals.map((e) => e.name),
-      aborted: false
-    };
-  }
-  return {
-    id: run.id,
-    timestamp: run.createdAt,
-    passed: 0,
-    failed: 0,
-    total: 0,
-    duration: startMs && endMs ? endMs - startMs : 0,
-    botDuration: 0,
-    evalDuration: 0,
-    evalNames: [],
-    aborted: false
-  };
-}
-var VortexEvalStore = class {
-  url;
-  botId;
-  workspaceId;
-  token;
-  _evalManifestId;
-  _loadEvalDefinitions;
-  constructor(config) {
-    this.url = config.url.replace(/\/$/, "");
-    this.botId = config.botId;
-    if (config.workspaceId) this.workspaceId = config.workspaceId;
-    if (config.token) this.token = config.token;
-    this._evalManifestId = config.evalManifestId;
-    this._loadEvalDefinitions = config.loadEvalDefinitions;
-  }
-  // ── Eval definitions (from Files API manifest) ───────────────────────
-  async listEvals(filter) {
-    const defs = await this.getEvalDefinitions();
-    const filtered = defs.filter((e) => {
-      if (filter?.names && !filter.names.includes(e.name)) return false;
-      if (filter?.type && e.type !== filter.type) return false;
-      if (filter?.tags && !filter.tags.every((tag) => e.tags?.includes(tag))) return false;
-      return true;
-    });
-    return filtered.map((e) => ({
-      name: e.name,
-      description: e.description,
-      tags: e.tags || [],
-      type: e.type || "capability",
-      turnCount: e.conversation.length,
-      hasOutcome: !!e.outcome
-    }));
-  }
-  async getEval(name) {
-    const defs = await this.getEvalDefinitions();
-    return defs.find((e) => e.name === name) ?? null;
-  }
-  // ── Run lifecycle — write ───────────────────────────────────────────
-  async createRun(runType = "scheduled", metadata) {
-    if (!this.workspaceId) {
-      throw new Error("workspaceId is required to create Vortex eval runs");
-    }
-    const triggerType = runType === "manual" ? "manual" : "scheduled";
-    const res = await this.fetch(`/v1/evals/bot/${this.botId}/runs`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        evalManifestId: (typeof this._evalManifestId === "function" ? this._evalManifestId() : this._evalManifestId) ?? "",
-        workspaceId: this.workspaceId,
-        triggerType,
-        ...metadata ? { metadata } : {}
-      })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex create run failed: ${res.status} ${text}`);
-    }
-    const { id } = await res.json();
-    return id;
-  }
-  async addRunResults(runId, evalReport) {
-    const entry = {
-      evalName: evalReport.name,
-      evalType: evalReport.type ?? "capability",
-      description: evalReport.description ?? "",
-      tags: evalReport.tags ?? [],
-      passed: evalReport.pass,
-      durationMs: evalReport.duration,
-      error: evalReport.error,
-      results: [...evalReport.turns.flatMap(turnToResultRows), ...outcomeToResultRows(evalReport.outcomeAssertions)]
-    };
-    const res = await this.fetch(`/v1/evals/runs/${runId}/entries`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ entries: [entry] })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex ingest entries failed: ${res.status} ${text}`);
-    }
-  }
-  async completeRun(runId, report) {
-    const hasRunError = report.aborted === true || report.evals.some((e) => e.error !== void 0);
-    const res = await this.fetch(`/v1/evals/runs/${runId}/entries`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        entries: [],
-        completed: !hasRunError,
-        failed: hasRunError
-      })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex complete run failed: ${res.status} ${text}`);
-    }
-  }
-  // ── Per-turn incremental lifecycle (Option B) ──
-  //
-  // The eval-runner workflow builds each entry up as the eval runs (rather than
-  // writing it whole at the end), so the dev console can stream turn-by-turn
-  // progress. This is the prod ingestion path and requires Vortex to provide:
-  //   startEntry        POST  /runs/{runId}/entries                    → { entries:[{ id }] }  (passed:null, in-progress)
-  //   appendTurnResults POST  /runs/{runId}/entries/{entryId}/results  (idempotent upsert by turnIndex+graderName)
-  //   finalizeEntry     PATCH /runs/{runId}/entries/{entryId}          (sets the verdict)
-  //   markRunComplete   POST  /runs/{runId}/complete                   (status → completed|failed)
-  /** Create an in-progress entry (metadata only, no results) and return its server id. */
-  async startEntry(runId, meta) {
-    const res = await this.fetch(`/v1/evals/runs/${runId}/entries`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        entries: [
-          {
-            evalName: meta.evalName,
-            evalType: meta.evalType ?? "capability",
-            description: meta.description ?? "",
-            tags: meta.tags ?? []
-          }
-        ]
-      })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex start entry failed: ${res.status} ${text}`);
-    }
-    const data = await res.json();
-    const entryId = data.entries?.[0]?.id ?? data.id;
-    if (!entryId) {
-      throw new Error("Vortex start entry returned no entry id");
-    }
-    return entryId;
-  }
-  /** Append one turn's grader results to an existing entry. */
-  async appendTurnResults(runId, entryId, turn) {
-    const res = await this.fetch(`/v1/evals/runs/${runId}/entries/${entryId}/results`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ results: turnToResultRows(turn) })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex append results failed: ${res.status} ${text}`);
-    }
-  }
-  /** Append outcome-level grader results to an existing entry. */
-  async appendOutcomeResults(runId, entryId, assertions) {
-    if (assertions.length === 0) return;
-    const res = await this.fetch(`/v1/evals/runs/${runId}/entries/${entryId}/results`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ results: outcomeToResultRows(assertions) })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex append results failed: ${res.status} ${text}`);
-    }
-  }
-  /** Set the verdict on an entry once its eval finishes. */
-  async finalizeEntry(runId, entryId, verdict) {
-    const res = await this.fetch(`/v1/evals/runs/${runId}/entries/${entryId}`, {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        passed: verdict.passed,
-        ...verdict.durationMs !== void 0 ? { durationMs: verdict.durationMs } : {},
-        ...verdict.error !== void 0 ? { error: verdict.error } : {}
-      })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex finalize entry failed: ${res.status} ${text}`);
-    }
-  }
-  /** Flip the run to its terminal status (replaces completeRun's empty-entries hack). */
-  async markRunComplete(runId, opts = {}) {
-    const res = await this.fetch(`/v1/evals/runs/${runId}/complete`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ ...opts.failed !== void 0 ? { failed: opts.failed } : {} })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex complete run failed: ${res.status} ${text}`);
-    }
-  }
-  // ── Run results — read ─────────────────────────────────────────────
-  async loadRunResult(runId) {
-    const data = await this.fetchJson(`/v1/evals/runs/${runId}`);
-    return vortexRunToReport(data);
-  }
-  async getLatestRun() {
-    const data = await this.fetchJson(`/v1/evals/bot/${this.botId}/runs`, { limit: "1" });
-    if (!data.runs.length) return null;
-    const latest = data.runs[0];
-    return this.loadRunResult(latest.id);
-  }
-  async listRunSummaries(opts) {
-    const runs = await this.fetchRunsWithEntries(opts?.limit ?? 50, opts?.since);
-    return runs.map(vortexRunToSummary);
-  }
-  async listEvalReportsByName(evalName, opts) {
-    const limit = opts?.limit ?? 20;
-    const runs = await this.fetchRunsWithEntries(50, opts?.since);
-    const entries = [];
-    for (const run of runs) {
-      if (entries.length >= limit) break;
-      const entry = run.entries.find((e) => e.evalName === evalName);
-      if (entry) {
-        entries.push({
-          runId: run.id,
-          timestamp: run.createdAt,
-          report: vortexEntryToEvalReport(entry),
-          totalEvalsInRun: run.entries.length
-        });
-      }
-    }
-    return entries;
-  }
-  async listEvalReportsBulk(opts) {
-    const per = opts?.perEval ?? 20;
-    const runs = await this.fetchRunsWithEntries(50, opts?.since);
-    const grouped = {};
-    for (const run of runs) {
-      for (const entry of run.entries) {
-        if (!grouped[entry.evalName]) grouped[entry.evalName] = [];
-        if (grouped[entry.evalName].length < per) {
-          grouped[entry.evalName].push({
-            runId: run.id,
-            timestamp: run.createdAt,
-            report: vortexEntryToEvalReport(entry),
-            totalEvalsInRun: run.entries.length
-          });
-        }
-      }
-    }
-    return grouped;
-  }
-  // ── Live run tracking ──────────────────────────────────────────────
-  async *watchRun(signal, options = {}) {
-    const POLL_INTERVAL = 1500;
-    const POLL_TIMEOUT = 60 * 60 * 1e3;
-    const start = Date.now();
-    const hasExpectedRun = !!options.runId || !!options.workflowId;
-    let baselineRunId = null;
-    if (!hasExpectedRun) {
-      try {
-        const initial = await this.fetchJson(`/v1/evals/bot/${this.botId}/runs`, {
-          limit: "1"
-        });
-        baselineRunId = initial.runs[0]?.id ?? null;
-      } catch {
-      }
-    }
-    const evalMeta = await this.loadEvalMeta();
-    const startedEvals = /* @__PURE__ */ new Set();
-    const seenTurns = /* @__PURE__ */ new Set();
-    const startedTurns = /* @__PURE__ */ new Set();
-    const finalizedEvals = /* @__PURE__ */ new Set();
-    while (!signal?.aborted && Date.now() - start < POLL_TIMEOUT) {
-      try {
-        const data = await this.fetchJson(`/v1/evals/bot/${this.botId}/runs`, {
-          limit: hasExpectedRun ? "20" : "1"
-        });
-        let latest = null;
-        let raw = null;
-        for (const candidate of data.runs) {
-          if (options.runId && candidate.id !== options.runId) continue;
-          if (options.workflowId && candidate.metadata?.workflowId !== options.workflowId) {
-            const candidateRaw = await this.fetchJson(`/v1/evals/runs/${candidate.id}`);
-            if (!runMatchesWatchOptions(candidateRaw, options)) continue;
-            raw = candidateRaw;
-          }
-          latest = candidate;
-          break;
-        }
-        if (!latest || !hasExpectedRun && latest.id === baselineRunId) {
-          await new Promise((r) => setTimeout(r, POLL_INTERVAL));
-          continue;
-        }
-        raw ??= await this.fetchJson(`/v1/evals/runs/${latest.id}`);
-        const terminal = raw.status === "completed" || raw.status === "failed";
-        for (let i = 0; i < raw.entries.length; i++) {
-          const entry = raw.entries[i];
-          const evalReport = vortexEntryToEvalReport(entry);
-          const meta = evalMeta.get(entry.evalName);
-          const totalTurns = meta?.totalTurns ?? evalReport.turns.length;
-          if (!startedEvals.has(entry.evalName)) {
-            startedEvals.add(entry.evalName);
-            yield { type: "eval_start", evalName: entry.evalName, index: i, totalTurns };
-          }
-          for (const turn of evalReport.turns) {
-            const turnKey = `${entry.evalName}::${turn.turnIndex}`;
-            if (seenTurns.has(turnKey)) continue;
-            seenTurns.add(turnKey);
-            yield {
-              type: "turn_complete",
-              evalName: entry.evalName,
-              evalIndex: i,
-              turnIndex: turn.turnIndex,
-              totalTurns,
-              turnReport: turn
-            };
-          }
-          if (entry.passed != null && !finalizedEvals.has(entry.evalName)) {
-            finalizedEvals.add(entry.evalName);
-            yield { type: "eval_complete", evalName: entry.evalName, index: i, report: evalReport };
-          } else if (entry.passed == null && !terminal) {
-            const nextTurnIndex = evalReport.turns.length;
-            const startKey = `${entry.evalName}::${nextTurnIndex}`;
-            if (nextTurnIndex < totalTurns && !startedTurns.has(startKey)) {
-              startedTurns.add(startKey);
-              yield {
-                type: "turn_start",
-                evalName: entry.evalName,
-                evalIndex: i,
-                turnIndex: nextTurnIndex,
-                totalTurns,
-                userMessage: meta?.userMessages[nextTurnIndex] ?? ""
-              };
-            }
-          }
-        }
-        if (terminal) {
-          const finalReport = vortexRunToReport(raw);
-          for (let i = 0; i < finalReport.evals.length; i++) {
-            const evalReport = finalReport.evals[i];
-            if (finalizedEvals.has(evalReport.name)) continue;
-            finalizedEvals.add(evalReport.name);
-            yield { type: "eval_complete", evalName: evalReport.name, index: i, report: evalReport };
-          }
-          yield {
-            type: "suite_complete",
-            report: finalReport,
-            error: raw.status === "failed" ? "Eval run failed" : void 0
-          };
-          return;
-        }
-      } catch {
-      }
-      await new Promise((r) => setTimeout(r, POLL_INTERVAL));
-    }
-    if (!signal?.aborted) {
-      yield {
-        type: "suite_complete",
-        report: {
-          id: "timeout",
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          evals: [],
-          passed: 0,
-          failed: 0,
-          total: 0,
-          duration: 0
-        },
-        error: "Eval run timed out"
-      };
-    }
-  }
-  // ── Runner state ───────────────────────────────────────────────────
-  async getRunnerState() {
-    try {
-      const data = await this.fetchJson(`/v1/evals/bot/${this.botId}/runs`, {
-        status: "running",
-        limit: "1"
-      });
-      const active = data.runs[0] ?? null;
-      return { running: !!active, runId: active?.id ?? null };
-    } catch {
-      return { running: false, runId: null };
-    }
-  }
-  // ── Internal helpers ───────────────────────────────────────────────
-  async getEvalDefinitions() {
-    if (!this._loadEvalDefinitions) return [];
-    return this._loadEvalDefinitions();
-  }
-  /**
-   * evalName → { totalTurns, userMessages } from the eval definitions, so
-   * watchRun can report `totalTurns` and synthesize `turn_start` events (with
-   * the turn's user message) for the in-flight turn — matching the dev SSE
-   * experience where the pending turn is visible before its results land.
-   */
-  async loadEvalMeta() {
-    try {
-      const defs = await this.getEvalDefinitions();
-      return new Map(
-        defs.map((d) => [
-          d.name,
-          { totalTurns: d.conversation.length, userMessages: d.conversation.map((t) => t.user ?? "") }
-        ])
-      );
-    } catch {
-      return /* @__PURE__ */ new Map();
-    }
-  }
-  async fetchRunsWithEntries(limit, since) {
-    const data = await this.fetchJson(`/v1/evals/bot/${this.botId}/runs`, {
-      limit: String(limit)
-    });
-    let runs = data.runs;
-    if (since) {
-      runs = runs.filter((r) => new Date(r.createdAt).getTime() >= since);
-    }
-    return mapWithConcurrency(runs, 8, (r) => this.fetchJson(`/v1/evals/runs/${r.id}`));
-  }
-  async fetch(path, init) {
-    const target = new URL(`${this.url}${path}`);
-    const headers = new Headers(init?.headers);
-    if (this.token) headers.set("Authorization", `Bearer ${this.token}`);
-    return globalThis.fetch(target, { ...init, headers });
-  }
-  async fetchJson(path, params) {
-    const target = new URL(`${this.url}${path}`);
-    if (params) {
-      for (const [k, v] of Object.entries(params)) target.searchParams.set(k, v);
-    }
-    const headers = new Headers();
-    if (this.token) headers.set("Authorization", `Bearer ${this.token}`);
-    const res = await globalThis.fetch(target, { headers });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Vortex ${res.status}: ${text}`);
-    }
-    return res.json();
-  }
-};
-
-// src/loader.ts
-import { readdirSync, existsSync } from "fs";
-import { resolve } from "path";
-
-// src/definition.ts
-var Eval = class {
-  name;
-  description;
-  tags;
-  type;
-  setup;
-  conversation;
-  outcome;
-  options;
-  constructor(def) {
-    this.name = def.name;
-    this.conversation = def.conversation;
-    if (def.description !== void 0) this.description = def.description;
-    if (def.tags !== void 0) this.tags = def.tags;
-    if (def.type !== void 0) this.type = def.type;
-    if (def.setup !== void 0) this.setup = def.setup;
-    if (def.outcome !== void 0) this.outcome = def.outcome;
-    if (def.options !== void 0) this.options = def.options;
-  }
-};
-
-// src/errors.ts
-import { AdkError } from "@botpress/analytics";
-var EvalRunnerError = class extends AdkError {
-};
-
-// src/loader.ts
-function isEvalDefinition(value) {
-  return value !== null && typeof value === "object" && typeof value.name === "string" && value.name !== "" && Array.isArray(value.conversation);
-}
-async function loadEvalFile(filePath) {
-  const absPath = resolve(filePath);
-  let mod;
-  try {
-    mod = await import(absPath);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new EvalRunnerError({
-      code: "EVAL_LOAD_FAILED",
-      message: `Failed to load eval file ${filePath}: ${msg}
-
-Make sure your eval file:
-  - Has no syntax or type errors
-  - Exports one or more \`new Eval({...})\` instances
-  - Has all dependencies installed (\`bun install\`)`,
-      expected: true,
-      cause: err
-    });
-  }
-  const results = [];
-  for (const [key, value] of Object.entries(mod)) {
-    if (key === "__esModule") continue;
-    if (value instanceof Eval || isEvalDefinition(value)) {
-      results.push(value);
-    }
-  }
-  if (results.length === 0) {
-    throw new EvalRunnerError({
-      code: "EVAL_FILE_EMPTY",
-      message: `Invalid eval file ${filePath}: no valid evals found. Export one or more \`new Eval({...})\` instances (as default or named exports).`,
-      expected: true
-    });
-  }
-  return results;
-}
-async function loadEvalsFromDir(dirPath) {
-  const absDir = resolve(dirPath);
-  if (!existsSync(absDir)) {
-    return [];
-  }
-  const files = readdirSync(absDir).filter((f) => f.endsWith(".eval.ts"));
-  const evals = [];
-  for (const f of files) {
-    const defs = await loadEvalFile(`${absDir}/${f}`);
-    evals.push(...defs);
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const e of evals) {
-    if (seen.has(e.name)) {
-      throw new EvalRunnerError({
-        code: "EVAL_DUPLICATE_NAME",
-        message: `Duplicate eval name "${e.name}" found in ${dirPath} \u2014 names must be unique across the evals directory.`,
-        expected: true,
-        details: { name: e.name }
-      });
-    }
-    seen.add(e.name);
-  }
-  return evals;
-}
-
-// src/stores/eval-definition-loader.ts
-function createDiskEvalLoader(evalsDir) {
-  return () => loadEvalsFromDir(evalsDir);
-}
-export {
-  VortexEvalStore,
-  createDiskEvalLoader
-};
-//# sourceMappingURL=vortex-eval-store-entry.js.map