braintrust 1.0.2 → 1.0.3

package/dev/dist/index.mjs

@@ -26,7 +26,9 @@ var iso = {
   getCallerLocation: () => void 0,
   newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
   processOn: (_0, _1) => {
-  }
+  },
+  basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
+  writeln: (text) => console.log(text)
 };
 var isomorph_default = iso;
 
@@ -119,7 +121,7 @@ async function getPastNAncestors(n = 1e3, remote = void 0) {
     return [];
   }
   const commits = await git.log({ from: ancestor, to: "HEAD", maxCount: n });
-  return commits.all.map((c) => c.hash);
+  return commits.all.slice(0, n).map((c) => c.hash);
 }
 async function attempt(fn) {
   try {
@@ -962,11 +964,11 @@ function mergeDictsWithPaths({
 function mergeDictsWithPathsHelper({
   mergeInto,
   mergeFrom,
-  path: path3,
+  path: path2,
   mergePaths
 }) {
   Object.entries(mergeFrom).forEach(([k, mergeFromV]) => {
-    const fullPath = path3.concat([k]);
+    const fullPath = path2.concat([k]);
     const fullPathSerialized = JSON.stringify(fullPath);
     const mergeIntoV = recordFind(mergeInto, k);
     if (isObject(mergeIntoV) && isObject(mergeFromV) && !mergePaths.has(fullPathSerialized)) {
@@ -997,9 +999,9 @@ function mapAt(m, k) {
 function recordFind(m, k) {
   return m[k];
 }
-function getObjValueByPath(row, path3) {
+function getObjValueByPath(row, path2) {
   let curr = row;
-  for (const p of path3) {
+  for (const p of path2) {
     if (!isObjectOrArray(curr)) {
       return null;
     }
@@ -1274,6 +1276,93 @@ function _urljoin(...parts) {
     (x, i) => x.replace(/^\//, "").replace(i < parts.length - 1 ? /\/$/ : "", "")
   ).filter((x) => x.trim() !== "").join("/");
 }
+function slugify(text, options) {
+  if (typeof text !== "string") {
+    throw new Error("slugify: string argument expected");
+  }
+  const charMap = {
+    // Currency and symbols
+    $: "dollar",
+    "%": "percent",
+    "&": "and",
+    // Latin characters
+    \u00C0: "A",
+    \u00C1: "A",
+    \u00C2: "A",
+    \u00C3: "A",
+    \u00C4: "A",
+    \u00C5: "A",
+    \u00C6: "AE",
+    \u00C7: "C",
+    \u00C8: "E",
+    \u00C9: "E",
+    \u00CA: "E",
+    \u00CB: "E",
+    \u00CC: "I",
+    \u00CD: "I",
+    \u00CE: "I",
+    \u00CF: "I",
+    \u00D1: "N",
+    \u00D2: "O",
+    \u00D3: "O",
+    \u00D4: "O",
+    \u00D5: "O",
+    \u00D6: "O",
+    \u00D8: "O",
+    \u00D9: "U",
+    \u00DA: "U",
+    \u00DB: "U",
+    \u00DC: "U",
+    \u00DD: "Y",
+    \u00E0: "a",
+    \u00E1: "a",
+    \u00E2: "a",
+    \u00E3: "a",
+    \u00E4: "a",
+    \u00E5: "a",
+    \u00E6: "ae",
+    \u00E7: "c",
+    \u00E8: "e",
+    \u00E9: "e",
+    \u00EA: "e",
+    \u00EB: "e",
+    \u00EC: "i",
+    \u00ED: "i",
+    \u00EE: "i",
+    \u00EF: "i",
+    \u00F1: "n",
+    \u00F2: "o",
+    \u00F3: "o",
+    \u00F4: "o",
+    \u00F5: "o",
+    \u00F6: "o",
+    \u00F8: "o",
+    \u00F9: "u",
+    \u00FA: "u",
+    \u00FB: "u",
+    \u00FC: "u",
+    \u00FD: "y",
+    \u00FF: "y"
+  };
+  const replacement = "-";
+  const trim = options?.trim !== false;
+  let slug = text.normalize().split("").reduce((result, ch) => {
+    const mapped = charMap[ch] || ch;
+    const appendChar = mapped === replacement ? " " : mapped;
+    return result + appendChar.replace(/[^\w\s$*_+~.()'"!\-:@]+/g, "");
+  }, "");
+  if (options?.strict) {
+    slug = slug.replace(/[^A-Za-z0-9\s]/g, "");
+  }
+  if (trim) {
+    slug = slug.trim();
+  }
+  slug = slug.replace(/\s+/g, replacement);
+  if (options?.lower) {
+    slug = slug.toLowerCase();
+  }
+  return slug;
+}
 
 // util/span_identifier_v4.ts
 import { z as z4 } from "zod/v3";
@@ -2925,9 +3014,9 @@ var BraintrustStream = class _BraintrustStream {
         reader.releaseLock();
         return { done: true, value: void 0 };
       },
-      async throw(error2) {
+      async throw(error) {
         reader.releaseLock();
-        throw error2;
+        throw error;
       }
     };
   }
@@ -3241,10 +3330,10 @@ var DiskCache = class {
       return;
     }
     const stats = await Promise.all(
-      paths.map(async (path3) => {
-        const stat2 = await isomorph_default.stat(path3);
+      paths.map(async (path2) => {
+        const stat2 = await isomorph_default.stat(path2);
         return {
-          path: path3,
+          path: path2,
           mtime: stat2.mtime.getTime()
         };
       })
@@ -3385,7 +3474,7 @@ function runCatchFinally(f, catchF, finallyF) {
 function getCurrentUnixTimestamp() {
   return (/* @__PURE__ */ new Date()).getTime() / 1e3;
 }
-function isEmpty(a) {
+function isEmpty2(a) {
   return a === void 0 || a === null;
 }
 var LazyValue = class {
@@ -3510,8 +3599,8 @@ var MaskingError = class {
 function applyMaskingToField(maskingFunction, data, fieldName) {
   try {
     return maskingFunction(data);
-  } catch (error2) {
-    const errorType = error2 instanceof Error ? error2.constructor.name : "Error";
+  } catch (error) {
+    const errorType = error instanceof Error ? error.constructor.name : "Error";
     if (fieldName === "scores" || fieldName === "metrics") {
       return new MaskingError(fieldName, errorType);
     }
@@ -3798,7 +3887,7 @@ var BraintrustState = class _BraintrustState {
     const newState = await loginToState({
       ...this.loginParams,
       ...Object.fromEntries(
-        Object.entries(loginParams).filter(([k, v]) => !isEmpty(v))
+        Object.entries(loginParams).filter(([k, v]) => !isEmpty2(v))
       )
     });
     this.copyLoginInfo(newState);
@@ -3963,9 +4052,9 @@ var HTTPConnection = class _HTTPConnection {
       this.headers["Authorization"] = `Bearer ${this.token}`;
     }
   }
-  async get(path3, params = void 0, config) {
+  async get(path2, params = void 0, config) {
     const { headers, ...rest } = config || {};
-    const url = new URL(_urljoin(this.base_url, path3));
+    const url = new URL(_urljoin(this.base_url, path2));
     url.search = new URLSearchParams(
       params ? Object.entries(params).filter(([_, v]) => v !== void 0).flatMap(
         ([k, v]) => v !== void 0 ? typeof v === "string" ? [[k, v]] : v.map((x) => [k, x]) : []
@@ -3986,13 +4075,13 @@ var HTTPConnection = class _HTTPConnection {
       })
     );
   }
-  async post(path3, params, config) {
+  async post(path2, params, config) {
     const { headers, ...rest } = config || {};
     const this_fetch = this.fetch;
     const this_base_url = this.base_url;
     const this_headers = this.headers;
     return await checkResponse(
-      await this_fetch(_urljoin(this_base_url, path3), {
+      await this_fetch(_urljoin(this_base_url, path2), {
         method: "POST",
         headers: {
           Accept: "application/json",
@@ -4144,12 +4233,12 @@ var Attachment = class extends BaseAttachment {
           signedUrl: z8.string().url(),
           headers: z8.record(z8.string())
         }).parse(await metadataResponse.json()));
-      } catch (error2) {
-        if (error2 instanceof ZodError) {
-          const errorStr = JSON.stringify(error2.flatten());
+      } catch (error) {
+        if (error instanceof ZodError) {
+          const errorStr = JSON.stringify(error.flatten());
           throw new Error(`Invalid response from API server: ${errorStr}`);
         }
-        throw error2;
+        throw error;
       }
       addAzureBlobHeaders(headers, signedUrl);
       let objectStoreResponse;
@@ -4161,13 +4250,13 @@ var Attachment = class extends BaseAttachment {
             body: data
           })
         );
-      } catch (error2) {
-        if (error2 instanceof FailedHTTPResponse) {
+      } catch (error) {
+        if (error instanceof FailedHTTPResponse) {
           throw new Error(
-            `Failed to upload attachment to object store: ${error2.status} ${error2.text} ${error2.data}`
+            `Failed to upload attachment to object store: ${error.status} ${error.text} ${error.data}`
           );
         }
-        throw error2;
+        throw error;
       }
       return { signedUrl, metadataResponse, objectStoreResponse };
     };
@@ -4179,9 +4268,9 @@ var Attachment = class extends BaseAttachment {
       const orgId = state.orgId ?? "";
       try {
         await doUpload(conn, orgId);
-      } catch (error2) {
+      } catch (error) {
         status.upload_status = "error";
-        status.error_message = error2 instanceof Error ? error2.message : JSON.stringify(error2);
+        status.error_message = error instanceof Error ? error.message : JSON.stringify(error);
       }
       const requestParams = {
         key: this.reference.key,
@@ -4313,8 +4402,8 @@ var ReadonlyAttachment = class {
       }
       const objResponse = await fetch(downloadUrl);
       if (objResponse.status !== 200) {
-        const error2 = await objResponse.text();
-        throw new Error(`Couldn't download attachment: ${error2}`);
+        const error = await objResponse.text();
+        throw new Error(`Couldn't download attachment: ${error}`);
       }
       return await objResponse.blob();
     };
@@ -4334,7 +4423,7 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
   if (!VALID_SOURCES.includes(source)) {
     throw new Error(`source must be one of ${VALID_SOURCES}`);
   }
-  if (isEmpty(scores) && isEmpty(expected) && isEmpty(tags) && isEmpty(comment)) {
+  if (isEmpty2(scores) && isEmpty2(expected) && isEmpty2(tags) && isEmpty2(comment)) {
     throw new Error(
       "At least one of scores, expected, tags, or comment must be specified"
     );
@@ -4347,7 +4436,7 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
   });
   let { metadata, ...updateEvent } = deepCopyEvent(validatedEvent);
   updateEvent = Object.fromEntries(
-    Object.entries(updateEvent).filter(([_, v]) => !isEmpty(v))
+    Object.entries(updateEvent).filter(([_, v]) => !isEmpty2(v))
   );
   const parentIds = async () => new SpanComponentsV3({
     object_type: parentObjectType,
@@ -4366,7 +4455,7 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
     });
     state.bgLogger().log([record]);
   }
-  if (!isEmpty(comment)) {
+  if (!isEmpty2(comment)) {
     const record = new LazyValue(async () => {
       return {
         id: uuidv42(),
@@ -4931,8 +5020,8 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
         if (result.upload_status === "error") {
           throw new Error(result.error_message);
         }
-      } catch (error2) {
-        attachmentErrors.push(error2);
+      } catch (error) {
+        attachmentErrors.push(error);
       }
     }
     if (attachmentErrors.length === 1) {
@@ -5015,22 +5104,22 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
     }
     for (let i = 0; i < this.numTries; i++) {
       const startTime = now();
-      let error2 = void 0;
+      let error = void 0;
       try {
         await conn.post_json("logs3", dataStr);
       } catch (e) {
-        error2 = e;
+        error = e;
       }
-      if (error2 === void 0) {
+      if (error === void 0) {
         return;
       }
       const isRetrying = i + 1 < this.numTries;
       const retryingText = isRetrying ? "" : " Retrying";
       const errorText = (() => {
-        if (error2 instanceof FailedHTTPResponse) {
-          return `${error2.status} (${error2.text}): ${error2.data}`;
+        if (error instanceof FailedHTTPResponse) {
+          return `${error.status} (${error.text}): ${error.data}`;
         } else {
-          return `${error2}`;
+          return `${error}`;
         }
       })();
       const errMsg = `log request failed. Elapsed time: ${(now() - startTime) / 1e3} seconds. Payload size: ${dataStr.length}.${retryingText}
@@ -5206,7 +5295,7 @@ function init(projectOrOptions, optionalOptions) {
   const state = stateArg ?? _globalState;
   state.enforceQueueSizeLimit(false);
   if (open) {
-    if (isEmpty(experiment)) {
+    if (isEmpty2(experiment)) {
       throw new Error(`Cannot open an experiment without specifying its name`);
     }
     const lazyMetadata2 = new LazyValue(
@@ -5409,7 +5498,7 @@ async function computeLoggerMetadata(state, {
 }) {
   await state.login({});
   const org_id = state.orgId;
-  if (isEmpty(project_id)) {
+  if (isEmpty2(project_id)) {
     const response = await state.appConn().post_json("api/project/register", {
       project_name: project_name || GLOBAL_PROJECT,
       org_id
@@ -5422,7 +5511,7 @@ async function computeLoggerMetadata(state, {
         fullInfo: response.project
       }
     };
-  } else if (isEmpty(project_name)) {
+  } else if (isEmpty2(project_name)) {
     const response = await state.appConn().get_json("api/project", {
       id: project_id
     });
@@ -5445,7 +5534,7 @@ async function login(options = {}) {
   const { forceLogin = false } = options || {};
   if (_globalState.loggedIn && !forceLogin) {
     let checkUpdatedParam2 = function(varname, arg, orig) {
-      if (!isEmpty(arg) && !isEmpty(orig) && arg !== orig) {
+      if (!isEmpty2(arg) && !isEmpty2(orig) && arg !== orig) {
         throw new Error(
           `Re-logging in with different ${varname} (${arg}) than original (${orig}). To force re-login, pass \`forceLogin: true\``
         );
@@ -5563,14 +5652,14 @@ function getSpanParentObject(options) {
   }
   return NOOP_SPAN;
 }
-function logError(span, error2) {
+function logError(span, error) {
   let errorMessage = "<error>";
   let stackTrace = "";
-  if (error2 instanceof Error) {
-    errorMessage = error2.message;
-    stackTrace = error2.stack || "";
+  if (error instanceof Error) {
+    errorMessage = error.message;
+    stackTrace = error.stack || "";
   } else {
-    errorMessage = String(error2);
+    errorMessage = String(error);
   }
   span.log({ error: `${errorMessage}
 
@@ -5832,15 +5921,15 @@ async function resolveAttachmentsToBase64(event, state) {
   return event;
 }
 function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
-  if ("input" in event && !isEmpty(event.input) && "inputs" in event && !isEmpty(event.inputs) || !("input" in event) && !("inputs" in event)) {
+  if ("input" in event && !isEmpty2(event.input) && "inputs" in event && !isEmpty2(event.inputs) || !("input" in event) && !("inputs" in event)) {
     throw new Error(
       "Exactly one of input or inputs (deprecated) must be specified. Prefer input."
     );
   }
-  if (isEmpty(event.output)) {
+  if (isEmpty2(event.output)) {
     throw new Error("output must be specified");
   }
-  if (isEmpty(event.scores)) {
+  if (isEmpty2(event.scores)) {
     throw new Error("scores must be specified");
   }
   if (hasDataset && event.datasetRecordId === void 0) {
@@ -6900,7 +6989,7 @@ function renderMessage(render, message) {
   return {
     ...message,
     ..."content" in message ? {
-      content: isEmpty(message.content) ? void 0 : typeof message.content === "string" ? render(message.content) : message.content.map((c) => {
+      content: isEmpty2(message.content) ? void 0 : typeof message.content === "string" ? render(message.content) : message.content.map((c) => {
         switch (c.type) {
           case "text":
             return { ...c, text: render(c.text) };
@@ -6937,7 +7026,7 @@ function renderMessage(render, message) {
       })
     } : {},
     ..."tool_calls" in message ? {
-      tool_calls: isEmpty(message.tool_calls) ? void 0 : message.tool_calls.map((t) => {
+      tool_calls: isEmpty2(message.tool_calls) ? void 0 : message.tool_calls.map((t) => {
         return {
           type: t.type,
           id: render(t.id),
@@ -7086,11 +7175,11 @@ var Prompt2 = class _Prompt {
           ([k, _v]) => !BRAINTRUST_PARAMS.includes(k)
         )
       ),
-      ...!isEmpty(this.options.model) ? {
+      ...!isEmpty2(this.options.model) ? {
         model: this.options.model
       } : {}
     };
-    if (!("model" in params) || isEmpty(params.model)) {
+    if (!("model" in params) || isEmpty2(params.model)) {
       throw new Error(
         "No model specified. Either specify it in the prompt or as a default"
       );
@@ -7254,6 +7343,8 @@ function configureNode() {
   isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };
+  isomorph_default.basename = path.basename;
+  isomorph_default.writeln = (text) => process.stdout.write(text + "\n");
   isomorph_default.pathJoin = path.join;
   isomorph_default.pathDirname = path.dirname;
   isomorph_default.mkdir = fs.mkdir;
@@ -7331,9 +7422,9 @@ function handlePromise(promise, callback) {
     invokeCallback(callback, err && (err instanceof Error || err.message) ? err : new Error(err));
   });
 }
-function invokeCallback(callback, error2, value) {
+function invokeCallback(callback, error, value) {
   try {
-    callback(error2, value);
+    callback(error, value);
   } catch (err) {
     setImmediate$1((e) => {
       throw e;
@@ -8255,7 +8346,7 @@ function sortBy(coll, iteratee, callback) {
 }
 var sortBy$1 = awaitify(sortBy, 3);
 function tryEach(tasks, callback) {
-  var error2 = null;
+  var error = null;
   var result;
   return eachSeries$1(tasks, (task, taskCb) => {
     wrapAsync(task)((err, ...args) => {
@@ -8265,10 +8356,10 @@ function tryEach(tasks, callback) {
       } else {
         result = args;
       }
-      error2 = err;
+      error = err;
       taskCb(err ? null : {});
     });
-  }, () => callback(error2, result));
+  }, () => callback(error, result));
 }
 var tryEach$1 = awaitify(tryEach);
 function whilst(test, iteratee, callback) {
@@ -8311,53 +8402,16 @@ function waterfall(tasks, callback) {
 }
 var waterfall$1 = awaitify(waterfall);
 
-// src/framework.ts
-import chalk2 from "chalk";
-import { terminalLink } from "termi-link";
-import boxen from "boxen";
-import pluralize from "pluralize";
-import Table from "cli-table3";
-
-// src/progress.ts
-import chalk from "chalk";
-import * as cliProgress from "cli-progress";
-var MAX_NAME_LENGTH = 40;
-function fitNameToSpaces(name, length) {
-  const padded = name.padEnd(length);
-  if (padded.length <= length) {
-    return padded;
-  }
-  return padded.substring(0, length - 3) + "...";
-}
-var BarProgressReporter = class {
-  multiBar;
-  bars = {};
-  constructor() {
-    this.multiBar = new cliProgress.MultiBar(
-      {
-        // clearOnComplete: true,
-        format: `${chalk.blueBright("{bar}")} ${chalk.blue("{evaluator}")} {percentage}% ${chalk.gray("{value}/{total} {eta_formatted}")}`,
-        // autopadding: true,
-        hideCursor: true,
-        barsize: 10
-      },
-      cliProgress.Presets.shades_grey
-    );
-  }
-  start(name, total) {
-    const bar = this.multiBar.create(total, 0);
-    this.bars[name] = bar;
+// src/reporters/progress.ts
+var SimpleProgressReporter = class {
+  start(name, _total) {
+    console.log(`Running evaluator ${name}`);
   }
   stop() {
-    this.multiBar.stop();
   }
-  increment(name) {
-    this.bars[name].increment({
-      evaluator: fitNameToSpaces(name, MAX_NAME_LENGTH)
-    });
+  increment(_name) {
   }
-  setTotal(name, total) {
-    this.bars[name].setTotal(total);
+  setTotal(_name, _total) {
   }
 };
 
@@ -8365,9 +8419,8 @@ var BarProgressReporter = class {
 import { z as z10 } from "zod/v3";
 
 // src/framework2.ts
-import path2 from "path";
-import slugifyLib from "slugify";
 import { z as z9 } from "zod/v3";
+var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
 var ProjectBuilder = class {
   create(opts) {
     return new Project2(opts);
@@ -8439,12 +8492,12 @@ var ToolBuilder = class {
     const { handler, name, slug, parameters, returns, ...rest } = opts;
     let resolvedName = name ?? handler.name;
     if (resolvedName.trim().length === 0) {
-      resolvedName = `Tool ${path2.basename(__filename)} ${this.taskCounter}`;
+      resolvedName = `Tool ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
     }
     const tool = new CodeFunction(this.project, {
       handler,
       name: resolvedName,
-      slug: slug ?? slugifyLib(resolvedName, { lower: true, strict: true }),
+      slug: slug ?? slugify(resolvedName, { lower: true, strict: true }),
       type: "tool",
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
       parameters,
@@ -8468,9 +8521,9 @@ var ScorerBuilder = class {
       resolvedName = opts.handler.name;
     }
     if (!resolvedName || resolvedName.trim().length === 0) {
-      resolvedName = `Scorer ${path2.basename(__filename)} ${this.taskCounter}`;
+      resolvedName = `Scorer ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
     }
-    const slug = opts.slug ?? slugifyLib(resolvedName, { lower: true, strict: true });
+    const slug = opts.slug ?? slugify(resolvedName, { lower: true, strict: true });
     if ("handler" in opts) {
       const scorer = new CodeFunction(this.project, {
         ...opts,
@@ -8641,7 +8694,7 @@ var PromptBuilder = class {
         rawTools.push(tool);
       }
     }
-    const slug = opts.slug ?? slugifyLib(opts.name, { lower: true, strict: true });
+    const slug = opts.slug ?? slugify(opts.name, { lower: true, strict: true });
     const promptData = promptDefinitionToPromptData(opts, rawTools);
     const promptRow = {
       id: opts.id,
@@ -8766,8 +8819,11 @@ var EvalResultWithSummary = class {
     this.summary = summary;
     this.results = results;
   }
+  /**
+   * @deprecated Use `summary` instead.
+   */
   toString() {
-    return formatExperimentSummary(this.summary);
+    return JSON.stringify(this.summary);
   }
   [Symbol.for("nodejs.util.inspect.custom")]() {
     return `EvalResultWithSummary(summary="...", results=[...])`;
@@ -8820,7 +8876,7 @@ function _initializeSpanContext() {
   globalThis._spanContext = { currentSpan, withCurrent, startSpan, NOOP_SPAN };
 }
 async function Eval(name, evaluator, reporterOrOpts) {
-  const options = isEmpty(reporterOrOpts) ? {} : typeof reporterOrOpts === "string" ? { reporter: reporterOrOpts } : "name" in reporterOrOpts ? { reporter: reporterOrOpts } : reporterOrOpts;
+  const options = isEmpty2(reporterOrOpts) ? {} : typeof reporterOrOpts === "string" ? { reporter: reporterOrOpts } : "name" in reporterOrOpts ? { reporter: reporterOrOpts } : reporterOrOpts;
   let evalName = makeEvalName(name, evaluator.experimentName);
   if (globalThis._evals.evaluators[evalName]) {
     evalName = `${evalName}_${Object.keys(_evals).length}`;
@@ -8846,7 +8902,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
       []
     );
   }
-  const progressReporter = options.progress ?? new BarProgressReporter();
+  const progressReporter = options.progress ?? new SimpleProgressReporter();
   const shouldCollectResults = options.returnResults ?? true;
   if (typeof options.reporter === "string") {
     throw new Error(
@@ -8936,8 +8992,8 @@ function serializeJSONWithPlainString(v) {
   }
 }
 function evaluateFilter(object, filter2) {
-  const { path: path3, pattern } = filter2;
-  const key = path3.reduce(
+  const { path: path2, pattern } = filter2;
+  const key = path2.reduce(
     (acc, p) => typeof acc === "object" && acc !== null ? (
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       acc[p]
@@ -8979,7 +9035,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       );
     }
     let name = dataResult.name;
-    if (isEmpty(name)) {
+    if (isEmpty2(name)) {
       const baseExperiment = await experiment.fetchBaseExperiment();
       if (!baseExperiment) {
         throw new Error("BaseExperiment() failed to fetch base experiment");
@@ -9048,7 +9104,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         };
         const expected = "expected" in datum ? datum.expected : void 0;
         let output = void 0;
-        let error2 = void 0;
+        let error = void 0;
         let tags = [...datum.tags ?? []];
         const scores = {};
         const scorerNames = evaluator.scores.map(scorerName);
@@ -9112,7 +9168,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   }
                   if (Array.isArray(scoreValue)) {
                     for (const s of scoreValue) {
-                      if (!(typeof s === "object" && !isEmpty(s))) {
+                      if (!(typeof s === "object" && !isEmpty2(s))) {
                         throw new Error(
                           `When returning an array of scores, each score must be a non-empty object. Got: ${JSON.stringify(
                             s
@@ -9121,7 +9177,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                       }
                     }
                   }
-                  const results2 = Array.isArray(scoreValue) ? scoreValue : typeof scoreValue === "object" && !isEmpty(scoreValue) ? [scoreValue] : [
+                  const results2 = Array.isArray(scoreValue) ? scoreValue : typeof scoreValue === "object" && !isEmpty2(scoreValue) ? [scoreValue] : [
                     {
                       name: scorerNames[score_idx],
                       score: scoreValue
@@ -9179,9 +9235,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           unhandledScores = null;
           if (failingScorersAndResults.length) {
             const scorerErrors = Object.fromEntries(
-              failingScorersAndResults.map(({ name, error: error3 }) => [
+              failingScorersAndResults.map(({ name, error: error2 }) => [
                 name,
-                error3 instanceof Error ? error3.stack : `${error3}`
+                error2 instanceof Error ? error2.stack : `${error2}`
               ])
             );
             metadata["scorer_errors"] = scorerErrors;
@@ -9198,7 +9254,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           }
         } catch (e) {
           logError(rootSpan, e);
-          error2 = e;
+          error = e;
         } finally {
           progressReporter.increment(evaluator.evalName);
         }
@@ -9221,7 +9277,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             tags: tags.length ? tags : void 0,
             metadata,
             scores: mergedScores,
-            error: error2,
+            error,
             origin: baseEvent.event?.origin
           });
         }
@@ -9268,7 +9324,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       }
       let timeoutId;
       let abortHandler;
-      const rejectOnce = (error2) => {
+      const rejectOnce = (error) => {
         if (cancelled) {
           return;
         }
@@ -9280,7 +9336,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         if (abortHandler && evaluator.signal) {
           evaluator.signal.removeEventListener("abort", abortHandler);
         }
-        reject2(error2);
+        reject2(error);
       };
       if (evaluator.timeout) {
         timeoutId = setTimeout(() => {
@@ -9307,7 +9363,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
   } catch (e) {
     q.kill();
     if (e instanceof InternalAbortError) {
-      if (process.env.BRAINTRUST_VERBOSE) {
+      if (isomorph_default.getEnv("BRAINTRUST_VERBOSE")) {
         console.warn("Evaluator cancelled:", e.message);
       }
     }
@@ -9327,8 +9383,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     collectResults ? collectedResults : []
   );
 }
-var error = chalk2.red;
-var warning = chalk2.yellow;
+var warning = (text) => `Warning: ${text}`;
 function logError2(e, verbose) {
   if (!verbose) {
     console.error(`${e}`);
@@ -9377,11 +9432,7 @@ function reportFailures(evaluator, failingResults, { verbose, jsonl }) {
   if (failingResults.length > 0) {
     console.error(
       warning(
-        `Evaluator ${evaluator.evalName} failed with ${pluralize(
-          "error",
-          failingResults.length,
-          true
-        )}. This evaluation ("${evaluator.evalName}") will not be fully logged.`
+        `Evaluator ${evaluator.evalName} failed with ${failingResults.length} error${failingResults.length === 1 ? "" : "s"}. This evaluation ("${evaluator.evalName}") will not be fully logged.`
       )
     );
     if (jsonl) {
@@ -9413,124 +9464,84 @@ var defaultReporter = {
     if (failingResults.length > 0) {
       reportFailures(evaluator, failingResults, { verbose, jsonl });
     }
-    process.stdout.write(
-      jsonl ? JSON.stringify(summary) : formatExperimentSummary(summary)
-    );
-    process.stdout.write("\n");
+    if (jsonl) {
+      isomorph_default.writeln(JSON.stringify(summary));
+    } else {
+      isomorph_default.writeln("Experiment summary");
+      isomorph_default.writeln("==================");
+      if (summary.comparisonExperimentName) {
+        isomorph_default.writeln(
+          `${summary.comparisonExperimentName} (baseline) <- ${summary.experimentName} (comparison)`
+        );
+        isomorph_default.writeln("");
+      }
+      const hasScores = Object.keys(summary.scores).length > 0;
+      const hasMetrics = Object.keys(summary.metrics ?? {}).length > 0;
+      const hasComparison = !!summary.comparisonExperimentName;
+      if (hasScores || hasMetrics) {
+        if (hasComparison) {
+          isomorph_default.writeln(
+            "Name                Value      Change     Improvements Regressions"
+          );
+          isomorph_default.writeln(
+            "----------------------------------------------------------------"
+          );
+        }
+        for (const score of Object.values(summary.scores)) {
+          const scorePercent = (score.score * 100).toFixed(2);
+          const scoreValue = `${scorePercent}%`;
+          if (hasComparison) {
+            let diffString = "-";
+            if (!isEmpty2(score.diff)) {
+              const diffPercent = (score.diff * 100).toFixed(2);
+              const diffSign = score.diff > 0 ? "+" : "";
+              diffString = `${diffSign}${diffPercent}%`;
+            }
+            const improvements = score.improvements > 0 ? score.improvements.toString() : "-";
+            const regressions = score.regressions > 0 ? score.regressions.toString() : "-";
+            isomorph_default.writeln(
+              `${score.name.padEnd(18)} ${scoreValue.padStart(10)} ${diffString.padStart(10)} ${improvements.padStart(12)} ${regressions.padStart(11)}`
+            );
+          } else {
+            isomorph_default.writeln(`${score.name.padEnd(20)} ${scoreValue.padStart(15)}`);
+          }
+        }
+        for (const metric of Object.values(summary.metrics ?? {})) {
+          const fractionDigits = Number.isInteger(metric.metric) ? 0 : 2;
+          const formattedValue = metric.metric.toFixed(fractionDigits);
+          const metricValue = metric.unit === "$" ? `${metric.unit}${formattedValue}` : `${formattedValue}${metric.unit}`;
+          if (hasComparison) {
+            let diffString = "-";
+            if (!isEmpty2(metric.diff)) {
+              const diffPercent = (metric.diff * 100).toFixed(2);
+              const diffSign = metric.diff > 0 ? "+" : "";
+              diffString = `${diffSign}${diffPercent}%`;
+            }
+            const improvements = metric.improvements > 0 ? metric.improvements.toString() : "-";
+            const regressions = metric.regressions > 0 ? metric.regressions.toString() : "-";
+            isomorph_default.writeln(
+              `${metric.name.padEnd(18)} ${metricValue.padStart(10)} ${diffString.padStart(10)} ${improvements.padStart(12)} ${regressions.padStart(11)}`
+            );
+          } else {
+            isomorph_default.writeln(
+              `${metric.name.padEnd(20)} ${metricValue.padStart(15)}`
+            );
+          }
+        }
+      }
+      if (summary.experimentUrl) {
+        isomorph_default.writeln("");
+        isomorph_default.writeln(`View results for ${summary.experimentName}`);
+        isomorph_default.writeln(`See results at ${summary.experimentUrl}`);
+      }
+    }
+    isomorph_default.writeln("");
     return failingResults.length === 0;
   },
   async reportRun(evalReports) {
     return evalReports.every((r) => r);
   }
 };
-function formatExperimentSummary(summary) {
-  let comparisonLine = "";
-  if (summary.comparisonExperimentName) {
-    comparisonLine = `${summary.comparisonExperimentName} ${chalk2.gray("(baseline)")} \u2190 ${summary.experimentName} ${chalk2.gray("(comparison)")}
-
-`;
-  }
-  const tableParts = [];
-  const hasScores = Object.keys(summary.scores).length > 0;
-  const hasMetrics = Object.keys(summary.metrics ?? {}).length > 0;
-  const hasComparison = !!summary.comparisonExperimentName;
-  if (hasScores || hasMetrics) {
-    const headers = [chalk2.gray("Name"), chalk2.gray("Value")];
-    if (hasComparison) {
-      headers.push(
-        chalk2.gray("Change"),
-        chalk2.gray("Improvements"),
-        chalk2.gray("Regressions")
-      );
-    }
-    const combinedTable = new Table({
-      head: hasComparison ? headers : [],
-      style: { head: [], "padding-left": 0, "padding-right": 0, border: [] },
-      chars: {
-        top: "",
-        "top-mid": "",
-        "top-left": "",
-        "top-right": "",
-        bottom: "",
-        "bottom-mid": "",
-        "bottom-left": "",
-        "bottom-right": "",
-        left: "",
-        "left-mid": "",
-        mid: "",
-        "mid-mid": "",
-        right: "",
-        "right-mid": "",
-        middle: " "
-      },
-      colWidths: hasComparison ? [18, 10, 10, 13, 12] : [20, 15],
-      colAligns: hasComparison ? ["left", "right", "right", "right", "right"] : ["left", "right"],
-      wordWrap: false
-    });
-    const scoreValues = Object.values(summary.scores);
-    for (let i = 0; i < scoreValues.length; i++) {
-      const score = scoreValues[i];
-      const scorePercent = (score.score * 100).toFixed(2);
-      const scoreValue = chalk2.white(`${scorePercent}%`);
-      let diffString = "";
-      if (!isEmpty(score.diff)) {
-        const diffPercent = (score.diff * 100).toFixed(2);
-        const diffSign = score.diff > 0 ? "+" : "";
-        const diffColor = score.diff > 0 ? chalk2.green : chalk2.red;
-        diffString = diffColor(`${diffSign}${diffPercent}%`);
-      } else {
-        diffString = chalk2.gray("-");
-      }
-      const improvements = score.improvements > 0 ? chalk2.dim.green(score.improvements) : chalk2.gray("-");
-      const regressions = score.regressions > 0 ? chalk2.dim.red(score.regressions) : chalk2.gray("-");
-      const row = [`${chalk2.blue("\u25EF")} ${score.name}`, scoreValue];
-      if (hasComparison) {
-        row.push(diffString, improvements, regressions);
-      }
-      combinedTable.push(row);
-    }
-    const metricValues = Object.values(summary.metrics ?? {});
-    for (let i = 0; i < metricValues.length; i++) {
-      const metric = metricValues[i];
-      const fractionDigits = Number.isInteger(metric.metric) ? 0 : 2;
-      const formattedValue = metric.metric.toFixed(fractionDigits);
-      const metricValue = chalk2.white(
-        metric.unit === "$" ? `${metric.unit}${formattedValue}` : `${formattedValue}${metric.unit}`
-      );
-      let diffString = "";
-      if (!isEmpty(metric.diff)) {
-        const diffPercent = (metric.diff * 100).toFixed(2);
-        const diffSign = metric.diff > 0 ? "+" : "";
-        const diffColor = metric.diff > 0 ? chalk2.green : chalk2.red;
-        diffString = diffColor(`${diffSign}${diffPercent}%`);
-      } else {
-        diffString = chalk2.gray("-");
-      }
-      const improvements = metric.improvements > 0 ? chalk2.dim.green(metric.improvements) : chalk2.gray("-");
-      const regressions = metric.regressions > 0 ? chalk2.dim.red(metric.regressions) : chalk2.gray("-");
-      const row = [`${chalk2.magenta("\u25EF")} ${metric.name}`, metricValue];
-      if (hasComparison) {
-        row.push(diffString, improvements, regressions);
-      }
-      combinedTable.push(row);
-    }
-    tableParts.push(combinedTable.toString());
-  }
-  const content = [comparisonLine, ...tableParts].filter(Boolean).join("\n");
-  const footer = summary.experimentUrl ? terminalLink(
-    `View results for ${summary.experimentName}`,
-    summary.experimentUrl,
-    { fallback: () => `See results at ${summary.experimentUrl}` }
-  ) : "";
-  const boxContent = [content, footer].filter(Boolean).join("\n\n");
-  return "\n" + boxen(boxContent, {
-    title: chalk2.gray("Experiment summary"),
-    titleAlignment: "left",
-    padding: 0.5,
-    borderColor: "gray",
-    borderStyle: "round"
-  });
-}
 
 // dev/errorHandler.ts
 import { z as z11 } from "zod/v3";