@m4trix/evals 0.19.0 → 0.21.0

package/dist/index.cjs

@@ -738,6 +738,8 @@ function createDiffString(expected, actual, diffOptions) {
 function formatLogMessage(msg) {
   if (typeof msg === "string")
     return msg;
+  if (msg instanceof Error)
+    return msg.stack ?? msg.message;
   try {
     if (msg !== null && typeof msg === "object") {
       return JSON.stringify(msg, null, 2);
@@ -1084,6 +1086,7 @@ function toNumericScore(value) {
 }
 
 // src/runner/execution.ts
+var evaluatorErrorLogEntryKey = "__m4trixEvaluatorLogEntry";
 function computeEvaluatorPassed(evaluator, result, scores) {
   const scoresWithPassed = scores.filter((s) => "passed" in s && s.passed !== void 0);
   if (scoresWithPassed.length > 0) {
@@ -1125,13 +1128,27 @@ function createArtifactPath(artifactDirectory, datasetId, runId) {
     `${datasetId}_${runId}_${nowIsoForFile()}.jsonl`
   );
 }
-function processOneTestCase(task, testCaseItem, totalEvaluations, publishEvent, persistenceQueue, updateSnapshot, completedRef, passedRef, failedRef) {
+function processOneTestCase(task, testCaseItem, totalEvaluations, publishEvent, persistenceQueue, updateSnapshot, startedRef, completedRef, passedRef, failedRef) {
   return effect.Effect.gen(function* () {
     const reruns = typeof testCaseItem.testCase.getReruns === "function" ? testCaseItem.testCase.getReruns() : 1;
     const rerunPassed = [];
     for (let r = 0; r < reruns; r++) {
       const evaluatorRunId = `run-${crypto.randomUUID()}`;
       const started = Date.now();
+      const startedEvaluations = yield* effect.Ref.modify(startedRef, (n) => [
+        n + 1,
+        n + 1
+      ]);
+      yield* publishEvent({
+        type: "TestCaseStarted",
+        runId: task.runId,
+        testCaseId: testCaseItem.id,
+        testCaseName: testCaseItem.testCase.getName(),
+        startedTestCases: startedEvaluations,
+        totalTestCases: totalEvaluations,
+        rerunIndex: r + 1,
+        rerunTotal: reruns
+      });
       const evaluatorScores = [];
       let testCaseError;
       const output = readOutput(testCaseItem.testCase);
@@ -1140,20 +1157,26 @@ function processOneTestCase(task, testCaseItem, totalEvaluations, publishEvent,
         if (!evaluateFn) {
           continue;
         }
+        const logs = [];
+        const logDiff = (expected, actual, options) => {
+          logs.push(createDiffLogEntry(expected, actual, options));
+        };
+        const log = (message, options) => {
+          logs.push(createLogEntry(message, options));
+        };
+        const createError = (message, options) => {
+          const entry = createLogEntry(message, options);
+          const error = message instanceof Error ? message : new Error(entry.message);
+          error[evaluatorErrorLogEntryKey] = entry;
+          return error;
+        };
         try {
-          const logs = [];
-          const logDiff = (expected, actual, options) => {
-            logs.push(createDiffLogEntry(expected, actual, options));
-          };
-          const log = (message, options) => {
-            logs.push(createLogEntry(message, options));
-          };
           const ctx = yield* effect.Effect.promise(
             () => Promise.resolve(evaluator.resolveContext())
           );
           const result = yield* effect.Effect.promise(
-            () => Promise.resolve(
-              evaluateFn({
+            () => Promise.resolve().then(
+              () => evaluateFn({
                 input: testCaseItem.testCase.getInput(),
                 ctx,
                 output,
@@ -1163,10 +1186,24 @@ function processOneTestCase(task, testCaseItem, totalEvaluations, publishEvent,
                   datasetId: task.datasetId
                 },
                 logDiff,
-                log
+                log,
+                createError
               })
             )
           );
+          if (result instanceof Error) {
+            const evaluatorError = result;
+            const taggedEntry = evaluatorError[evaluatorErrorLogEntryKey];
+            logs.push(taggedEntry ?? createLogEntry(result));
+            testCaseError = result.message;
+            evaluatorScores.push({
+              evaluatorId,
+              scores: [],
+              passed: false,
+              logs: logs.length > 0 ? logs : void 0
+            });
+            continue;
+          }
           const { scores, metrics } = normalizeResult(result);
           const passed2 = computeEvaluatorPassed(evaluator, result, scores);
           evaluatorScores.push({
@@ -1177,11 +1214,16 @@ function processOneTestCase(task, testCaseItem, totalEvaluations, publishEvent,
             logs: logs.length > 0 ? logs : void 0
           });
         } catch (error) {
+          if (error instanceof Error) {
+            const taggedEntry = error[evaluatorErrorLogEntryKey];
+            logs.push(taggedEntry ?? createLogEntry(error));
+          }
           testCaseError = error instanceof Error ? error.message : "Evaluator execution failed";
           evaluatorScores.push({
             evaluatorId,
             scores: [],
-            passed: false
+            passed: false,
+            logs: logs.length > 0 ? logs : void 0
           });
         }
       }
@@ -1252,6 +1294,7 @@ var executeRunTask = (task, publishEvent, persistenceQueue, updateSnapshot) => e
   );
   const maxConcurrency = Math.max(1, task.maxConcurrency ?? 1);
   const completedRef = yield* effect.Ref.make(0);
+  const startedRef = yield* effect.Ref.make(0);
   const passedRef = yield* effect.Ref.make(0);
   const failedRef = yield* effect.Ref.make(0);
   const processTestCase = (testCaseItem) => processOneTestCase(
@@ -1261,6 +1304,7 @@ var executeRunTask = (task, publishEvent, persistenceQueue, updateSnapshot) => e
     publishEvent,
     persistenceQueue,
     updateSnapshot,
+    startedRef,
     completedRef,
     passedRef,
     failedRef