@cursor/july 0.1.16 → 0.1.18

package/dist/evals/loaders.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Fixture loaders for dataset-driven evals.
+ *
+ * Eval modules are ESM, so top-level `await` can load a dataset and fan one
+ * file out over it:
+ *
+ * ```ts
+ * // evals/sql.eval.ts
+ * import { defineEval } from "@cursor/july/evals";
+ * import { loadYaml } from "@cursor/july/evals/loaders";
+ * import { equals } from "@cursor/july/evals";
+ *
+ * const rows = await loadYaml<{ task: string; prompt: string; sql: string }[]>(
+ *   "evals/data/cases.yaml"
+ * );
+ *
+ * export default rows.map((row) =>
+ *   defineEval({
+ *     description: row.task,
+ *     async test(t) {
+ *       await t.send(row.prompt);
+ *       t.succeeded();
+ *       t.check(t.reply, equals(row.sql));
+ *     },
+ *   })
+ * );
+ * ```
+ *
+ * Paths resolve from the app root (the directory holding `agent/` and
+ * `evals/`), not from the eval file, so a fixture path reads the same however
+ * deep the eval sits. These loaders are for fixtures — do not use them for
+ * runtime agent code.
+ */
+/**
+ * App root used to resolve relative fixture paths.
+ *
+ * `eval` sets `AGENT_SERVE_EVAL_ROOT` to the project it discovered, which keeps
+ * fixture paths stable no matter what cwd the CLI was invoked from. Falls back
+ * to the process cwd.
+ */
+export declare const EVAL_ROOT_ENV = "AGENT_SERVE_EVAL_ROOT";
+export declare function evalFixtureRoot(): string;
+/** Resolve a fixture path against the app root. */
+export declare function resolveFixturePath(path: string): string;
+/** Load a JSON fixture. */
+export declare function loadJson<T = unknown>(path: string): Promise<T>;
+/** Load a newline-delimited JSON fixture, skipping blank lines. */
+export declare function loadJsonl<T = unknown>(path: string): Promise<T[]>;
+/** Load a YAML fixture. */
+export declare function loadYaml<T = unknown>(path: string): Promise<T>;
+//# sourceMappingURL=loaders.d.ts.map

package/dist/evals/loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loaders.d.ts","sourceRoot":"","sources":["../../src/evals/loaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,0BAA0B,CAAC;AAErD,wBAAgB,eAAe,IAAI,MAAM,CAGxC;AAED,mDAAmD;AACnD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAYD,2BAA2B;AAC3B,wBAAsB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAQpE;AAED,mEAAmE;AACnE,wBAAsB,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAoBvE;AAED,2BAA2B;AAC3B,wBAAsB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAWpE"}

package/dist/evals/loaders.js

@@ -0,0 +1,124 @@
+/**
+ * Fixture loaders for dataset-driven evals.
+ *
+ * Eval modules are ESM, so top-level `await` can load a dataset and fan one
+ * file out over it:
+ *
+ * ```ts
+ * // evals/sql.eval.ts
+ * import { defineEval } from "@cursor/july/evals";
+ * import { loadYaml } from "@cursor/july/evals/loaders";
+ * import { equals } from "@cursor/july/evals";
+ *
+ * const rows = await loadYaml<{ task: string; prompt: string; sql: string }[]>(
+ *   "evals/data/cases.yaml"
+ * );
+ *
+ * export default rows.map((row) =>
+ *   defineEval({
+ *     description: row.task,
+ *     async test(t) {
+ *       await t.send(row.prompt);
+ *       t.succeeded();
+ *       t.check(t.reply, equals(row.sql));
+ *     },
+ *   })
+ * );
+ * ```
+ *
+ * Paths resolve from the app root (the directory holding `agent/` and
+ * `evals/`), not from the eval file, so a fixture path reads the same however
+ * deep the eval sits. These loaders are for fixtures — do not use them for
+ * runtime agent code.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+/**
+ * App root used to resolve relative fixture paths.
+ *
+ * `eval` sets `AGENT_SERVE_EVAL_ROOT` to the project it discovered, which keeps
+ * fixture paths stable no matter what cwd the CLI was invoked from. Falls back
+ * to the process cwd.
+ */
+export const EVAL_ROOT_ENV = "AGENT_SERVE_EVAL_ROOT";
+export function evalFixtureRoot() {
+    const root = process.env[EVAL_ROOT_ENV];
+    return root === undefined || root.trim() === "" ? process.cwd() : root;
+}
+/** Resolve a fixture path against the app root. */
+export function resolveFixturePath(path) {
+    return isAbsolute(path) ? path : resolve(evalFixtureRoot(), path);
+}
+function readFixture(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const absolute = resolveFixturePath(path);
+        try {
+            return yield readFile(absolute, "utf8");
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`failed to load eval fixture ${absolute}: ${detail}`);
+        }
+    });
+}
+/** Load a JSON fixture. */
+export function loadJson(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const text = yield readFixture(path);
+        try {
+            return JSON.parse(text);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`${resolveFixturePath(path)} is not valid JSON: ${detail}`);
+        }
+    });
+}
+/** Load a newline-delimited JSON fixture, skipping blank lines. */
+export function loadJsonl(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const text = yield readFixture(path);
+        const rows = [];
+        let lineNumber = 0;
+        for (const line of text.split("\n")) {
+            lineNumber++;
+            const trimmed = line.trim();
+            if (trimmed === "") {
+                continue;
+            }
+            try {
+                rows.push(JSON.parse(trimmed));
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                throw new Error(`${resolveFixturePath(path)}:${lineNumber} is not valid JSON: ${detail}`);
+            }
+        }
+        return rows;
+    });
+}
+/** Load a YAML fixture. */
+export function loadYaml(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const text = yield readFixture(path);
+        // Imported lazily so a project that only uses JSON fixtures never pays for
+        // the YAML parser at eval-discovery time.
+        const { load } = yield import("js-yaml");
+        try {
+            return load(text);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`${resolveFixturePath(path)} is not valid YAML: ${detail}`);
+        }
+    });
+}

package/dist/evals/matchers.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Matcher mini-language shared by tool-call, subagent, and event assertions.
+ *
+ * A matcher is a literal, a RegExp, or a predicate:
+ *
+ * ```ts
+ * t.calledTool("bash", { input: { command: /^pwd/ }, count: 1 });
+ * t.calledTool("echo", { count: (n) => n >= 2 });
+ * t.calledTool("read", { output: (value) => String(value).includes("hello") });
+ * ```
+ *
+ * Object literals partial-deep-match, so `{ input: { city: "NYC" } }` matches a
+ * call whose args also carry unrelated keys. Nested values may themselves be
+ * matchers.
+ */
+/**
+ * Literal forms a matcher can take.
+ *
+ * Spelled out rather than written as `unknown` so the union keeps its function
+ * member: `unknown` would absorb it, and TypeScript could no longer infer the
+ * parameter type of an inline predicate. Nested values are matchers in turn, so
+ * a predicate buried in an object literal gets its parameter type too.
+ */
+export type EvalMatcherLiteral = string | number | boolean | null | Date | readonly EvalMatcher[] | {
+    readonly [key: string]: EvalMatcher | undefined;
+};
+/** A literal to partial-match, a RegExp to test, or a predicate. */
+export type EvalMatcher<T = unknown> = EvalMatcherLiteral | RegExp | ((value: T) => boolean);
+/** An exact count, or a predicate over the observed count. */
+export type EvalCountMatcher = number | ((count: number) => boolean);
+/** Lifecycle state of one tool call, derived from the session event stream. */
+export type EvalToolCallStatus = 
+/** `action.result` arrived without `isError`. */
+"completed"
+/** `action.result` arrived with `isError: true`. */
+ | "failed"
+/** Requested, no result yet (includes calls parked on human approval). */
+ | "pending"
+/** A human denied the approval request for this call. */
+ | "rejected";
+/** Constraints for {@link import("../evals.js").EvalAssertions.calledTool}. */
+export interface EvalToolCallMatcher {
+    /** Match the tool's arguments (partial-deep for object literals). */
+    input?: EvalMatcher;
+    /** Match the tool's result payload. */
+    output?: EvalMatcher;
+    /**
+     * Restrict to one lifecycle state. Omitted matches **any** state, which is
+     * request-based and therefore backwards compatible with `calledTool(name)`.
+     */
+    status?: EvalToolCallStatus;
+    /** Require an exact number of matching calls, or satisfy a predicate. */
+    count?: EvalCountMatcher;
+}
+/** Constraints for {@link import("../evals.js").EvalAssertions.calledSubagent}. */
+export interface EvalSubagentMatcher {
+    /** Match the delegating `task` call id. */
+    callId?: EvalMatcher<string>;
+    /** Match the subagent's final output text. */
+    output?: EvalMatcher;
+    /** `completed` once `subagent.completed` arrived, else `pending`. */
+    status?: "completed" | "pending";
+    count?: EvalCountMatcher;
+}
+/** Constraints for {@link import("../evals.js").EvalAssertions.event}. */
+export interface EvalEventMatcher {
+    /** Partial-deep match against the event's `data` payload. */
+    data?: EvalMatcher;
+    count?: EvalCountMatcher;
+}
+/** One entry of {@link import("../evals.js").EvalAssertions.eventOrder}. */
+export interface EvalEventOrderMatcher extends EvalEventMatcher {
+    type: string;
+}
+/** Stable string form used when a RegExp is tested against a non-string. */
+export declare function stringifyForMatch(value: unknown): string;
+/**
+ * Whether `actual` satisfies `matcher`.
+ *
+ * - `undefined` matcher matches anything (the constraint was not supplied).
+ * - A function is called with `actual`.
+ * - A RegExp is tested against {@link stringifyForMatch}.
+ * - An object or array literal partial-deep-matches, and its own values may be
+ *   matchers.
+ * - Anything else compares by deep equality.
+ */
+export declare function matchValue<T = unknown>(actual: T, matcher: EvalMatcher<T> | undefined): boolean;
+/** Whether an observed count satisfies a {@link EvalCountMatcher}. */
+export declare function matchCount(observed: number, matcher: EvalCountMatcher | undefined): boolean;
+/** Human-readable matcher summary for assertion names and failure details. */
+export declare function describeMatcher(matcher: EvalMatcher | undefined): string;
+/** Compact `{ input: …, count: 2 }` summary for assertion names. */
+export declare function describeMatcherObject(matcher: Record<string, unknown> | undefined): string;
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=matchers.d.ts.map

package/dist/evals/matchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../../src/evals/matchers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,IAAI,GACJ,SAAS,WAAW,EAAE,GACtB;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAA;CAAE,CAAC;AAExD,oEAAoE;AACpE,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,OAAO,IAC/B,kBAAkB,GAClB,MAAM,GACN,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC;AAE5B,8DAA8D;AAC9D,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;AAErE,+EAA+E;AAC/E,MAAM,MAAM,kBAAkB;AAC5B,iDAAiD;AAC/C,WAAW;AACb,oDAAoD;GAClD,QAAQ;AACV,0EAA0E;GACxE,SAAS;AACX,yDAAyD;GACvD,UAAU,CAAC;AAEf,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,uCAAuC;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,yEAAyE;IACzE,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B;AAED,mFAAmF;AACnF,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,8CAA8C;IAC9C,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,qEAAqE;IACrE,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACjC,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B;AAED,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,6DAA6D;IAC7D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B;AAED,4EAA4E;AAC5E,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC7D,IAAI,EAAE,MAAM,CAAC;CACd;AAYD,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAkBxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,GAAG,OAAO,EACpC,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,GAClC,OAAO,CA2BT;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,gBAAgB,GAAG,SAAS,GACpC,OAAO,CAQT;AAED,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAWxE;AAED,oEAAoE;AACpE,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC3C,MAAM,CAQR;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAwCzD"}

package/dist/evals/matchers.js

@@ -0,0 +1,145 @@
+/**
+ * Matcher mini-language shared by tool-call, subagent, and event assertions.
+ *
+ * A matcher is a literal, a RegExp, or a predicate:
+ *
+ * ```ts
+ * t.calledTool("bash", { input: { command: /^pwd/ }, count: 1 });
+ * t.calledTool("echo", { count: (n) => n >= 2 });
+ * t.calledTool("read", { output: (value) => String(value).includes("hello") });
+ * ```
+ *
+ * Object literals partial-deep-match, so `{ input: { city: "NYC" } }` matches a
+ * call whose args also carry unrelated keys. Nested values may themselves be
+ * matchers.
+ */
+function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof RegExp) &&
+        !(value instanceof Date));
+}
+/** Stable string form used when a RegExp is tested against a non-string. */
+export function stringifyForMatch(value) {
+    var _a;
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === undefined) {
+        return "";
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "object") {
+        try {
+            return (_a = JSON.stringify(value)) !== null && _a !== void 0 ? _a : "";
+        }
+        catch (_b) {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+/**
+ * Whether `actual` satisfies `matcher`.
+ *
+ * - `undefined` matcher matches anything (the constraint was not supplied).
+ * - A function is called with `actual`.
+ * - A RegExp is tested against {@link stringifyForMatch}.
+ * - An object or array literal partial-deep-matches, and its own values may be
+ *   matchers.
+ * - Anything else compares by deep equality.
+ */
+export function matchValue(actual, matcher) {
+    if (matcher === undefined) {
+        return true;
+    }
+    if (typeof matcher === "function") {
+        return matcher(actual) === true;
+    }
+    if (matcher instanceof RegExp) {
+        return matcher.test(stringifyForMatch(actual));
+    }
+    if (Array.isArray(matcher)) {
+        if (!Array.isArray(actual) || actual.length !== matcher.length) {
+            return false;
+        }
+        return matcher.every((entry, index) => matchValue(actual[index], entry));
+    }
+    if (isPlainObject(matcher)) {
+        if (!isPlainObject(actual)) {
+            return false;
+        }
+        return Object.entries(matcher).every(([key, entry]) => matchValue(actual[key], entry));
+    }
+    return deepEqual(actual, matcher);
+}
+/** Whether an observed count satisfies a {@link EvalCountMatcher}. */
+export function matchCount(observed, matcher) {
+    if (matcher === undefined) {
+        return observed > 0;
+    }
+    if (typeof matcher === "function") {
+        return matcher(observed) === true;
+    }
+    return observed === matcher;
+}
+/** Human-readable matcher summary for assertion names and failure details. */
+export function describeMatcher(matcher) {
+    if (matcher === undefined) {
+        return "any";
+    }
+    if (typeof matcher === "function") {
+        return "predicate";
+    }
+    if (matcher instanceof RegExp) {
+        return String(matcher);
+    }
+    return stringifyForMatch(matcher);
+}
+/** Compact `{ input: …, count: 2 }` summary for assertion names. */
+export function describeMatcherObject(matcher) {
+    if (matcher === undefined) {
+        return "";
+    }
+    const parts = Object.entries(matcher)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => `${key}=${describeMatcher(value)}`);
+    return parts.length === 0 ? "" : `, {${parts.join(", ")}}`;
+}
+export function deepEqual(a, b) {
+    if (Object.is(a, b)) {
+        return true;
+    }
+    if (a instanceof RegExp && b instanceof RegExp) {
+        return String(a) === String(b);
+    }
+    if (typeof a !== "object" ||
+        typeof b !== "object" ||
+        a === null ||
+        b === null) {
+        return false;
+    }
+    if (Array.isArray(a) !== Array.isArray(b)) {
+        return false;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        return a.every((item, i) => deepEqual(item, b[i]));
+    }
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys) {
+        if (!deepEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/evals/reporters.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Built-in eval reporters.
+ *
+ * The CLI already prints a console summary; reporters add destinations on top.
+ * Attach them in `evals/evals.config.ts` to observe every case in the run, or
+ * on a single `defineEval({ reporters })` to scope a destination to that case.
+ *
+ * ```ts
+ * // evals/evals.config.ts
+ * import { defineEvalConfig } from "@cursor/july/evals";
+ * import { JUnit } from "@cursor/july/evals/reporters";
+ *
+ * export default defineEvalConfig({
+ *   maxConcurrency: 20,
+ *   reporters: [JUnit({ filePath: ".agent-serve/junit.xml" })],
+ * });
+ * ```
+ *
+ * `agentkit eval --junit <path>` and `--artifacts <dir>` attach these same two
+ * reporters without touching the eval files, which is usually the better fit:
+ * CI owns the output paths, not the eval author.
+ */
+import type { EvalReporter, EvalRunSummary } from "./results.js";
+export type { EvalReporter, EvalReporterEvalInfo, EvalReporterTarget, EvalRunResult, EvalRunSummary, } from "./results.js";
+export interface JUnitReporterOptions {
+    /** Where to write the XML. Relative paths resolve from the process cwd. */
+    filePath: string;
+    /** `<testsuite name>`; defaults to `agentkit-evals`. */
+    suiteName?: string;
+}
+/**
+ * Write JUnit XML so CI shows per-case annotations.
+ *
+ * Each case becomes one `<testcase>` named by its path-derived id. Failed gates
+ * and execution errors become `<failure>`, `t.skip(reason)` becomes `<skipped>`,
+ * and a soft threshold miss becomes a `<failure>` only under `--strict` (it is
+ * reported as a `<system-out>` score line otherwise).
+ */
+export declare function JUnit(options: JUnitReporterOptions): EvalReporter;
+/** Render a {@link EvalRunSummary} as JUnit XML. Exported for tests. */
+export declare function renderJUnitXml(summary: EvalRunSummary, suiteName: string): string;
+export interface ArtifactsReporterOptions {
+    /** Run directory. Relative paths resolve from the process cwd. */
+    dir: string;
+}
+/**
+ * Persist the full story of a run to disk.
+ *
+ * Console output stays tight on purpose; when a case fails, the artifact has
+ * everything — every assertion with its score, the captured event stream, the
+ * tool calls, and `t.log` lines.
+ *
+ * ```text
+ * <dir>/summary.json                 run totals + config
+ * <dir>/results.jsonl                one line per case, in completion order
+ * <dir>/evals/<case-id>.json         per-case detail
+ * ```
+ */
+export declare function Artifacts(options: ArtifactsReporterOptions): EvalReporter;
+/**
+ * Turn a case id into a safe relative path.
+ *
+ * Ids are already path-shaped (`weather/nyc`), and `defineEval` rejects `..` in
+ * case ids, but the artifact writer sanitizes anyway so a hand-built result can
+ * never escape the run directory.
+ */
+export declare function sanitizeCaseId(id: string): string;
+/** Fan one lifecycle call out to several reporters, isolating failures. */
+export declare function combineReporters(reporters: readonly EvalReporter[], onError?: (error: unknown) => void): EvalReporter;
+//# sourceMappingURL=reporters.d.ts.map

package/dist/evals/reporters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporters.d.ts","sourceRoot":"","sources":["../../src/evals/reporters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EACV,YAAY,EAIZ,cAAc,EACf,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,YAAY,EACZ,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,cAAc,GACf,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,oBAAoB,GAAG,YAAY,CAYjE;AAED,wEAAwE;AACxE,wBAAgB,cAAc,CAC5B,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,MAAM,GAChB,MAAM,CAiDR;AA8CD,MAAM,WAAW,wBAAwB;IACvC,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,wBAAwB,GAAG,YAAY,CA8CzE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,YAAY,EAAE,EAClC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,YAAY,CAmBd"}