@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/eval-run-store.js

@@ -7,15 +7,6 @@
  * Runs against the live mount's loopback URL so case sessions appear in
  * the playground session list.
  */
-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 { randomUUID } from "node:crypto";
 import { resolveEvalMaxPlaygroundRuns, } from "../evals.js";
 import { discoverEvals, filterDiscoveredEvals, runDiscoveredEvals, } from "./eval-runner.js";
@@ -34,122 +25,126 @@ export class EvalRunStore {
         this.abortByRunId = new Map();
         this.hydrated = false;
     }
-    list() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.hydrate();
-            const { evals, config } = yield discoverEvals(this.projectRoot);
-            return {
-                evals: evals.map(e => (Object.assign(Object.assign({ id: e.id, fileId: e.fileId }, (e.definition.description === undefined
+    async list() {
+        await this.hydrate();
+        const { evals, config } = await discoverEvals(this.projectRoot);
+        return {
+            evals: evals.map(e => ({
+                id: e.id,
+                fileId: e.fileId,
+                ...(e.definition.description === undefined
                     ? {}
-                    : { description: e.definition.description })), (e.definition.tags === undefined ? {} : { tags: e.definition.tags })))),
-                config: snapshotListConfig(config, this.storage !== undefined),
-            };
-        });
+                    : { description: e.definition.description }),
+                ...(e.definition.tags === undefined ? {} : { tags: e.definition.tags }),
+            })),
+            config: snapshotListConfig(config, this.storage !== undefined),
+        };
     }
-    get(runId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.hydrate();
-            return this.runs.get(runId);
-        });
+    async get(runId) {
+        await this.hydrate();
+        return this.runs.get(runId);
     }
     /** Newest-first snapshots for playground rehydrate after navigation/reload. */
-    listRuns() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.hydrate();
-            return this.sortedRuns();
-        });
+    async listRuns() {
+        await this.hydrate();
+        return this.sortedRuns();
     }
     /**
      * Atomic snapshot of newest-first runs + the in-flight batch id (if any).
      * Prefer this over pairing {@link listRuns} with {@link getActiveRunId}
      * across an await boundary.
      */
-    listRunsWithActive() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.hydrate();
-            const activeRunId = this.activeRunId;
-            return Object.assign({ runs: this.sortedRuns() }, (activeRunId === undefined ? {} : { activeRunId }));
-        });
+    async listRunsWithActive() {
+        await this.hydrate();
+        const activeRunId = this.activeRunId;
+        return {
+            runs: this.sortedRuns(),
+            ...(activeRunId === undefined ? {} : { activeRunId }),
+        };
     }
     getActiveRunId() {
         return this.activeRunId;
     }
-    start() {
-        return __awaiter(this, arguments, void 0, function* (input = {}) {
-            yield this.hydrate();
-            if (this.activeRunId !== undefined) {
-                const active = this.runs.get(this.activeRunId);
-                if (active !== undefined && active.status === "running") {
-                    throw new EvalRunConflictError(this.activeRunId);
-                }
+    async start(input = {}) {
+        await this.hydrate();
+        if (this.activeRunId !== undefined) {
+            const active = this.runs.get(this.activeRunId);
+            if (active !== undefined && active.status === "running") {
+                throw new EvalRunConflictError(this.activeRunId);
             }
-            const loopbackUrl = this.loopbackUrl;
-            if (loopbackUrl === undefined) {
-                throw new Error("Eval run store has no loopback URL yet (server not listening)");
-            }
-            const { evals, config } = yield discoverEvals(this.projectRoot);
-            const selected = filterDiscoveredEvals(evals, {
-                filterIds: input.filterIds,
-                tags: input.tags,
-            });
-            if (selected.length === 0) {
-                throw new EvalRunEmptyError();
-            }
-            const runId = `evalrun_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
-            const cases = selected.map(e => discoveredToPending(e));
-            const snapshot = {
-                runId,
-                status: "running",
-                startedAt: new Date().toISOString(),
-                summary: {
-                    passed: 0,
-                    failed: 0,
-                    scored: 0,
-                    skipped: 0,
-                    total: cases.length,
-                    done: 0,
-                },
-                cases,
-                config: snapshotRunConfig(config, this.storage !== undefined),
-            };
-            this.runs.set(runId, snapshot);
-            this.activeRunId = runId;
-            const abort = new AbortController();
-            this.abortByRunId.set(runId, abort);
-            this.pruneOldRuns(config);
-            this.persist(snapshot);
-            this.logger(`[bdk] eval run ${runId}: starting ${cases.length} case(s)`);
-            void this.execute(runId, Object.assign(Object.assign(Object.assign({ baseUrl: loopbackUrl, evals: selected, config, signal: abort.signal }, (input.bearerToken === undefined ? {} : { bearerToken: input.bearerToken })), (input.verbose === undefined ? {} : { verbose: input.verbose })), (input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs })));
-            return snapshot;
+        }
+        const loopbackUrl = this.loopbackUrl;
+        if (loopbackUrl === undefined) {
+            throw new Error("Eval run store has no loopback URL yet (server not listening)");
+        }
+        const { evals, config } = await discoverEvals(this.projectRoot);
+        const selected = filterDiscoveredEvals(evals, {
+            filterIds: input.filterIds,
+            tags: input.tags,
+        });
+        if (selected.length === 0) {
+            throw new EvalRunEmptyError();
+        }
+        const runId = `evalrun_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+        const cases = selected.map(e => discoveredToPending(e));
+        const snapshot = {
+            runId,
+            status: "running",
+            startedAt: new Date().toISOString(),
+            summary: {
+                passed: 0,
+                failed: 0,
+                scored: 0,
+                skipped: 0,
+                total: cases.length,
+                done: 0,
+            },
+            cases,
+            config: snapshotRunConfig(config, this.storage !== undefined),
+        };
+        this.runs.set(runId, snapshot);
+        this.activeRunId = runId;
+        const abort = new AbortController();
+        this.abortByRunId.set(runId, abort);
+        this.pruneOldRuns(config);
+        this.persist(snapshot);
+        this.logger(`[bdk] eval run ${runId}: starting ${cases.length} case(s)`);
+        void this.execute(runId, {
+            baseUrl: loopbackUrl,
+            evals: selected,
+            config,
+            signal: abort.signal,
+            ...(input.bearerToken === undefined ? {} : { bearerToken: input.bearerToken }),
+            ...(input.verbose === undefined ? {} : { verbose: input.verbose }),
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
         });
+        return snapshot;
     }
     /**
      * Cancel a running batch by Eval ID (`runId`). Stops starting new cases and
      * aborts in-flight turns. Idempotent when already cancelled.
      */
-    cancel(runId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.hydrate();
-            const run = this.runs.get(runId);
-            if (run === undefined) {
-                throw new EvalRunUnknownError(runId);
-            }
-            if (run.status === "cancelled") {
-                return run;
-            }
-            if (run.status !== "running") {
-                throw new EvalRunNotRunningError(runId, run.status);
-            }
-            const abort = this.abortByRunId.get(runId);
-            abort === null || abort === void 0 ? void 0 : abort.abort();
-            markCancelledRun(run);
-            this.persist(run);
-            if (this.activeRunId === runId) {
-                this.activeRunId = undefined;
-            }
-            this.logger(`[bdk] eval run ${runId}: cancelled`);
+    async cancel(runId) {
+        await this.hydrate();
+        const run = this.runs.get(runId);
+        if (run === undefined) {
+            throw new EvalRunUnknownError(runId);
+        }
+        if (run.status === "cancelled") {
             return run;
-        });
+        }
+        if (run.status !== "running") {
+            throw new EvalRunNotRunningError(runId, run.status);
+        }
+        const abort = this.abortByRunId.get(runId);
+        abort?.abort();
+        markCancelledRun(run);
+        this.persist(run);
+        if (this.activeRunId === runId) {
+            this.activeRunId = undefined;
+        }
+        this.logger(`[bdk] eval run ${runId}: cancelled`);
+        return run;
     }
     sortedRuns() {
         return [...this.runs.values()].sort((a, b) => b.startedAt.localeCompare(a.startedAt));
@@ -160,63 +155,58 @@ export class EvalRunStore {
      * restore — and lazily as a safety net by every read. Idempotent;
      * concurrent callers share one pass.
      */
-    hydrate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hydrated) {
+    async hydrate() {
+        if (this.hydrated) {
+            return;
+        }
+        if (this.hydratePromise === undefined) {
+            this.hydratePromise = this.hydrateFromStorage();
+        }
+        await this.hydratePromise;
+    }
+    async hydrateFromStorage() {
+        try {
+            if (this.storage === undefined) {
+                this.hydrated = true;
                 return;
             }
-            if (this.hydratePromise === undefined) {
-                this.hydratePromise = this.hydrateFromStorage();
-            }
-            yield this.hydratePromise;
-        });
-    }
-    hydrateFromStorage() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (this.storage === undefined) {
-                    this.hydrated = true;
-                    return;
-                }
-                const loaded = yield this.storage.list();
-                for (const run of loaded) {
-                    if (run === null ||
-                        typeof run !== "object" ||
-                        typeof run.runId !== "string" ||
-                        run.runId === "") {
-                        continue;
-                    }
-                    // Incomplete batches from a killed process should not block a new run.
-                    if (run.status === "running") {
-                        markInterruptedRun(run);
-                        this.persist(run);
-                    }
-                    this.runs.set(run.runId, run);
-                }
-                // Prune with the defaults even when eval discovery fails — loaded
-                // history must not stay unpruned for the process lifetime just
-                // because an eval file has a syntax error at boot.
-                let config = {};
-                try {
-                    config = (yield discoverEvals(this.projectRoot)).config;
+            const loaded = await this.storage.list();
+            for (const run of loaded) {
+                if (run === null ||
+                    typeof run !== "object" ||
+                    typeof run.runId !== "string" ||
+                    run.runId === "") {
+                    continue;
                 }
-                catch (error) {
-                    this.logger(`[bdk] eval discovery failed during hydrate (pruning with defaults): ${error instanceof Error ? error.message : String(error)}`);
+                // Incomplete batches from a killed process should not block a new run.
+                if (run.status === "running") {
+                    markInterruptedRun(run);
+                    this.persist(run);
                 }
-                this.pruneOldRuns(config);
-                this.logger(`[bdk] hydrated ${this.runs.size} playground eval run(s) from storage`);
+                this.runs.set(run.runId, run);
             }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                this.logger(`[bdk] failed to hydrate playground eval runs: ${message}`);
+            // Prune with the defaults even when eval discovery fails — loaded
+            // history must not stay unpruned for the process lifetime just
+            // because an eval file has a syntax error at boot.
+            let config = {};
+            try {
+                config = (await discoverEvals(this.projectRoot)).config;
             }
-            finally {
-                this.hydrated = true;
+            catch (error) {
+                this.logger(`[bdk] eval discovery failed during hydrate (pruning with defaults): ${error instanceof Error ? error.message : String(error)}`);
             }
-        });
+            this.pruneOldRuns(config);
+            this.logger(`[bdk] hydrated ${this.runs.size} playground eval run(s) from storage`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger(`[bdk] failed to hydrate playground eval runs: ${message}`);
+        }
+        finally {
+            this.hydrated = true;
+        }
     }
     pruneOldRuns(config) {
-        var _a;
         const limit = resolveEvalMaxPlaygroundRuns(config.maxPlaygroundRuns);
         const ordered = this.sortedRuns();
         if (ordered.length <= limit) {
@@ -227,13 +217,12 @@ export class EvalRunStore {
                 continue;
             }
             this.runs.delete(stale.runId);
-            (_a = this.storage) === null || _a === void 0 ? void 0 : _a.delete(stale.runId);
+            this.storage?.delete(stale.runId);
         }
     }
     /** Mirror the run onto durable storage (coordinator clones + serializes). */
     persist(run) {
-        var _a;
-        (_a = this.storage) === null || _a === void 0 ? void 0 : _a.save(run);
+        this.storage?.save(run);
     }
     /**
      * Serve is draining: durably mark any in-flight batch as interrupted
@@ -243,7 +232,6 @@ export class EvalRunStore {
      * completion write) until the next hydrate repairs it.
      */
     close() {
-        var _a;
         const activeRunId = this.activeRunId;
         if (activeRunId === undefined) {
             return;
@@ -252,103 +240,109 @@ export class EvalRunStore {
         if (run === undefined || run.status !== "running") {
             return;
         }
-        (_a = this.abortByRunId.get(activeRunId)) === null || _a === void 0 ? void 0 : _a.abort();
+        this.abortByRunId.get(activeRunId)?.abort();
         markInterruptedRun(run);
         this.persist(run);
         this.activeRunId = undefined;
         this.abortByRunId.delete(activeRunId);
     }
-    execute(runId, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.runs.get(runId) === undefined) {
+    async execute(runId, opts) {
+        if (this.runs.get(runId) === undefined) {
+            return;
+        }
+        try {
+            await runDiscoveredEvals({
+                projectRoot: this.projectRoot,
+                baseUrl: opts.baseUrl,
+                discovered: { evals: opts.evals, config: opts.config },
+                signal: opts.signal,
+                ...(opts.bearerToken === undefined ? {} : { bearerToken: opts.bearerToken }),
+                ...(opts.verbose === undefined ? {} : { verbose: opts.verbose }),
+                ...(opts.timeoutMs === undefined ? {} : { timeoutMs: opts.timeoutMs }),
+                onCaseStart: id => {
+                    const run = this.runs.get(runId);
+                    if (run === undefined || run.status === "cancelled") {
+                        return;
+                    }
+                    const c = run.cases.find(x => x.id === id);
+                    if (c !== undefined) {
+                        c.status = "running";
+                        c.inputs = [];
+                        c.toolCalls = [];
+                        c.finalText = undefined;
+                        c.metrics = undefined;
+                        c.logs = undefined;
+                        c.assertions = undefined;
+                        c.error = undefined;
+                    }
+                },
+                onCaseEvent: (id, event) => {
+                    const run = this.runs.get(runId);
+                    if (run === undefined) {
+                        return;
+                    }
+                    const c = run.cases.find(x => x.id === id);
+                    if (c === undefined) {
+                        return;
+                    }
+                    const sid = typeof event.sessionId === "string" && event.sessionId !== ""
+                        ? event.sessionId
+                        : undefined;
+                    if (sid !== undefined && c.sessionId === undefined) {
+                        c.sessionId = sid;
+                    }
+                    if (event.type === "message.received" && typeof event.data?.text === "string") {
+                        c.inputs = [...(c.inputs ?? []), event.data.text];
+                    }
+                    if (event.type === "message.completed" &&
+                        typeof event.data?.text === "string" &&
+                        event.data.parentCallId === undefined) {
+                        c.finalText = event.data.text;
+                    }
+                },
+                onCaseDone: result => {
+                    this.applyCaseResult(runId, result);
+                    const run = this.runs.get(runId);
+                    if (run !== undefined) {
+                        this.persist(run);
+                    }
+                },
+            });
+            const run = this.runs.get(runId);
+            if (run === undefined || run.status === "cancelled") {
                 return;
             }
-            try {
-                yield runDiscoveredEvals(Object.assign(Object.assign(Object.assign(Object.assign({ projectRoot: this.projectRoot, baseUrl: opts.baseUrl, discovered: { evals: opts.evals, config: opts.config }, signal: opts.signal }, (opts.bearerToken === undefined ? {} : { bearerToken: opts.bearerToken })), (opts.verbose === undefined ? {} : { verbose: opts.verbose })), (opts.timeoutMs === undefined ? {} : { timeoutMs: opts.timeoutMs })), { onCaseStart: id => {
-                        const run = this.runs.get(runId);
-                        if (run === undefined || run.status === "cancelled") {
-                            return;
-                        }
-                        const c = run.cases.find(x => x.id === id);
-                        if (c !== undefined) {
-                            c.status = "running";
-                            c.inputs = [];
-                            c.toolCalls = [];
-                            c.finalText = undefined;
-                            c.metrics = undefined;
-                            c.logs = undefined;
-                            c.assertions = undefined;
-                            c.error = undefined;
-                        }
-                    }, onCaseEvent: (id, event) => {
-                        var _a, _b;
-                        var _c;
-                        const run = this.runs.get(runId);
-                        if (run === undefined) {
-                            return;
-                        }
-                        const c = run.cases.find(x => x.id === id);
-                        if (c === undefined) {
-                            return;
-                        }
-                        const sid = typeof event.sessionId === "string" && event.sessionId !== ""
-                            ? event.sessionId
-                            : undefined;
-                        if (sid !== undefined && c.sessionId === undefined) {
-                            c.sessionId = sid;
-                        }
-                        if (event.type === "message.received" && typeof ((_a = event.data) === null || _a === void 0 ? void 0 : _a.text) === "string") {
-                            c.inputs = [...((_c = c.inputs) !== null && _c !== void 0 ? _c : []), event.data.text];
-                        }
-                        if (event.type === "message.completed" &&
-                            typeof ((_b = event.data) === null || _b === void 0 ? void 0 : _b.text) === "string" &&
-                            event.data.parentCallId === undefined) {
-                            c.finalText = event.data.text;
-                        }
-                    }, onCaseDone: result => {
-                        this.applyCaseResult(runId, result);
-                        const run = this.runs.get(runId);
-                        if (run !== undefined) {
-                            this.persist(run);
-                        }
-                    } }));
-                const run = this.runs.get(runId);
-                if (run === undefined || run.status === "cancelled") {
-                    return;
-                }
-                run.status = "completed";
-                run.finishedAt = new Date().toISOString();
-                this.persist(run);
-                this.logger(`[bdk] eval run ${runId}: done — ${run.summary.passed} passed, ${run.summary.failed} failed`);
+            run.status = "completed";
+            run.finishedAt = new Date().toISOString();
+            this.persist(run);
+            this.logger(`[bdk] eval run ${runId}: done — ${run.summary.passed} passed, ${run.summary.failed} failed`);
+        }
+        catch (error) {
+            const run = this.runs.get(runId);
+            if (run === undefined || run.status === "cancelled") {
+                return;
             }
-            catch (error) {
-                const run = this.runs.get(runId);
-                if (run === undefined || run.status === "cancelled") {
-                    return;
-                }
-                const message = error instanceof Error ? error.message : String(error);
-                if (opts.signal.aborted || message === "cancelled") {
-                    markCancelledRun(run);
-                    this.persist(run);
-                    this.logger(`[bdk] eval run ${runId}: cancelled`);
-                    return;
-                }
-                run.status = "failed";
-                run.finishedAt = new Date().toISOString();
-                run.error = message;
+            const message = error instanceof Error ? error.message : String(error);
+            if (opts.signal.aborted || message === "cancelled") {
+                markCancelledRun(run);
                 this.persist(run);
-                this.logger(`[bdk] eval run ${runId}: failed — ${run.error}`);
+                this.logger(`[bdk] eval run ${runId}: cancelled`);
+                return;
             }
-            finally {
-                this.abortByRunId.delete(runId);
-                if (this.activeRunId === runId) {
-                    this.activeRunId = undefined;
-                }
+            run.status = "failed";
+            run.finishedAt = new Date().toISOString();
+            run.error = message;
+            this.persist(run);
+            this.logger(`[bdk] eval run ${runId}: failed — ${run.error}`);
+        }
+        finally {
+            this.abortByRunId.delete(runId);
+            if (this.activeRunId === runId) {
+                this.activeRunId = undefined;
             }
-        });
+        }
     }
     applyCaseResult(runId, result) {
-        var _a, _b;
         const run = this.runs.get(runId);
         if (run === undefined) {
             return;
@@ -366,7 +360,7 @@ export class EvalRunStore {
         c.assertions = result.assertions;
         c.durationMs = result.durationMs;
         c.logs = result.logs;
-        c.metrics = Object.keys(result.metrics).length > 0 ? Object.assign({}, result.metrics) : undefined;
+        c.metrics = Object.keys(result.metrics).length > 0 ? { ...result.metrics } : undefined;
         c.inputs = result.inputs;
         if (result.toolCalls !== undefined) {
             c.toolCalls = result.toolCalls;
@@ -388,28 +382,26 @@ export class EvalRunStore {
             return;
         }
         run.summary.done += 1;
-        const verdict = (_a = result.verdict) !== null && _a !== void 0 ? _a : (result.ok ? "passed" : "failed");
-        run.summary[verdict] = ((_b = run.summary[verdict]) !== null && _b !== void 0 ? _b : 0) + 1;
+        const verdict = result.verdict ?? (result.ok ? "passed" : "failed");
+        run.summary[verdict] = (run.summary[verdict] ?? 0) + 1;
     }
 }
 function markInterruptedRun(run) {
-    var _a, _b, _c;
     run.status = "failed";
-    run.finishedAt = (_a = run.finishedAt) !== null && _a !== void 0 ? _a : new Date().toISOString();
-    run.error = (_b = run.error) !== null && _b !== void 0 ? _b : INTERRUPTED_BATCH_ERROR;
+    run.finishedAt = run.finishedAt ?? new Date().toISOString();
+    run.error = run.error ?? INTERRUPTED_BATCH_ERROR;
     for (const c of run.cases) {
         if (c.status === "pending" || c.status === "running") {
             c.status = "done";
             c.ok = false;
-            c.error = (_c = c.error) !== null && _c !== void 0 ? _c : INTERRUPTED_CASE_ERROR;
+            c.error = c.error ?? INTERRUPTED_CASE_ERROR;
         }
     }
     reconcileRunSummary(run);
 }
 function markCancelledRun(run) {
-    var _a;
     run.status = "cancelled";
-    run.finishedAt = (_a = run.finishedAt) !== null && _a !== void 0 ? _a : new Date().toISOString();
+    run.finishedAt = run.finishedAt ?? new Date().toISOString();
     run.error = CANCELLED_BATCH_ERROR;
     for (const c of run.cases) {
         if (c.status === "pending" || c.status === "running") {
@@ -421,22 +413,41 @@ function markCancelledRun(run) {
     reconcileRunSummary(run);
 }
 function reconcileRunSummary(run) {
-    var _a;
     const counts = { passed: 0, failed: 0, scored: 0, skipped: 0 };
     for (const c of run.cases) {
-        counts[(_a = c.verdict) !== null && _a !== void 0 ? _a : (c.ok === true ? "passed" : "failed")] += 1;
+        counts[c.verdict ?? (c.ok === true ? "passed" : "failed")] += 1;
     }
-    run.summary = Object.assign(Object.assign({}, counts), { total: run.cases.length, done: run.cases.length });
+    run.summary = {
+        ...counts,
+        total: run.cases.length,
+        done: run.cases.length,
+    };
 }
 function snapshotListConfig(config, durableRuns) {
-    return Object.assign(Object.assign(Object.assign({}, (config.maxConcurrency === undefined ? {} : { maxConcurrency: config.maxConcurrency })), (config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs })), { maxPlaygroundRuns: resolveEvalMaxPlaygroundRuns(config.maxPlaygroundRuns), durableRuns });
+    return {
+        ...(config.maxConcurrency === undefined ? {} : { maxConcurrency: config.maxConcurrency }),
+        ...(config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs }),
+        maxPlaygroundRuns: resolveEvalMaxPlaygroundRuns(config.maxPlaygroundRuns),
+        durableRuns,
+    };
 }
 function snapshotRunConfig(config, durableRuns) {
     const list = snapshotListConfig(config, durableRuns);
-    return Object.assign(Object.assign(Object.assign({}, (list.maxConcurrency === undefined ? {} : { maxConcurrency: list.maxConcurrency })), (list.timeoutMs === undefined ? {} : { timeoutMs: list.timeoutMs })), { maxPlaygroundRuns: list.maxPlaygroundRuns, durableRuns: list.durableRuns });
+    return {
+        ...(list.maxConcurrency === undefined ? {} : { maxConcurrency: list.maxConcurrency }),
+        ...(list.timeoutMs === undefined ? {} : { timeoutMs: list.timeoutMs }),
+        maxPlaygroundRuns: list.maxPlaygroundRuns,
+        durableRuns: list.durableRuns,
+    };
 }
 function discoveredToPending(e) {
-    return Object.assign(Object.assign({ id: e.id, fileId: e.fileId, status: "pending" }, (e.definition.description === undefined ? {} : { description: e.definition.description })), (e.definition.tags === undefined ? {} : { tags: e.definition.tags }));
+    return {
+        id: e.id,
+        fileId: e.fileId,
+        status: "pending",
+        ...(e.definition.description === undefined ? {} : { description: e.definition.description }),
+        ...(e.definition.tags === undefined ? {} : { tags: e.definition.tags }),
+    };
 }
 export class EvalRunConflictError extends Error {
     constructor(activeRunId) {