braintrust 1.0.2 → 1.0.3

package/dist/browser.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15;var __defProp = Object.defineProperty;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19;var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -24,7 +24,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;
 
@@ -1054,6 +1056,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 = _optionalChain([options, 'optionalAccess', _12 => _12.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 (_optionalChain([options, 'optionalAccess', _13 => _13.strict])) {
+    slug = slug.replace(/[^A-Za-z0-9\s]/g, "");
+  }
+  if (trim) {
+    slug = slug.trim();
+  }
+  slug = slug.replace(/\s+/g, replacement);
+  if (_optionalChain([options, 'optionalAccess', _14 => _14.lower])) {
+    slug = slug.toLowerCase();
+  }
+  return slug;
+}
 
 // util/span_identifier_v4.ts
 
@@ -1294,6 +1383,15 @@ function prettifyXact(valueString) {
   const encoded = modularMultiply(value, COPRIME);
   return encoded.toString(16).padStart(16, "0");
 }
+function loadPrettyXact(encodedHex) {
+  if (encodedHex.length !== 16) {
+    return encodedHex;
+  }
+  const value = BigInt(`0x${encodedHex}`);
+  const multipliedInverse = modularMultiply(value, COPRIME_INVERSE);
+  const withTopBits = TOP_BITS | multipliedInverse;
+  return withTopBits.toString();
+}
 
 // util/zod_util.ts
 
@@ -2709,10 +2807,10 @@ var BraintrustStream = class _BraintrustStream {
     if (this.memoizedFinalValue) {
       return this.memoizedFinalValue;
     }
-    this.memoizedFinalValue = new Promise((resolve, reject) => {
-      this.stream.pipeThrough(createFinalValuePassThroughStream(resolve, reject), {
+    this.memoizedFinalValue = new Promise((resolve, reject2) => {
+      this.stream.pipeThrough(createFinalValuePassThroughStream(resolve, reject2), {
         signal: this.signal
-      }).pipeTo(devNullWritableStream(), { signal: this.signal }).catch(reject);
+      }).pipeTo(devNullWritableStream(), { signal: this.signal }).catch(reject2);
     });
     return this.memoizedFinalValue;
   }
@@ -3145,7 +3243,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 = (_class2 = class {
@@ -3210,6 +3308,12 @@ function addAzureBlobHeaders(headers, url) {
     headers["x-ms-blob-type"] = "BlockBlob";
   }
 }
+var InternalAbortError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InternalAbortError";
+  }
+};
 function filterFrom(record, keys) {
   const out = {};
   for (const k of Object.keys(record)) {
@@ -3346,7 +3450,7 @@ var NoopSpan = (_class4 = class {
     return this;
   }
   end(args) {
-    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _12 => _12.endTime]), () => ( getCurrentUnixTimestamp()));
+    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _15 => _15.endTime]), () => ( getCurrentUnixTimestamp()));
   }
   async export() {
     return "";
@@ -3551,8 +3655,8 @@ var BraintrustState = (_class5 = class _BraintrustState {
   setFetch(fetch2) {
     this.loginParams.fetch = fetch2;
     this.fetch = fetch2;
-    _optionalChain([this, 'access', _13 => _13._apiConn, 'optionalAccess', _14 => _14.setFetch, 'call', _15 => _15(fetch2)]);
-    _optionalChain([this, 'access', _16 => _16._appConn, 'optionalAccess', _17 => _17.setFetch, 'call', _18 => _18(fetch2)]);
+    _optionalChain([this, 'access', _16 => _16._apiConn, 'optionalAccess', _17 => _17.setFetch, 'call', _18 => _18(fetch2)]);
+    _optionalChain([this, 'access', _19 => _19._appConn, 'optionalAccess', _20 => _20.setFetch, 'call', _21 => _21(fetch2)]);
   }
   setMaskingFunction(maskingFunction) {
     this.bgLogger().setMaskingFunction(maskingFunction);
@@ -3564,7 +3668,7 @@ var BraintrustState = (_class5 = 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);
@@ -3664,7 +3768,7 @@ function useTestBackgroundLogger() {
   return logger;
 }
 function clearTestBackgroundLogger() {
-  _optionalChain([_internalGetGlobalState, 'call', _19 => _19(), 'optionalAccess', _20 => _20.setOverrideBgLogger, 'call', _21 => _21(null)]);
+  _optionalChain([_internalGetGlobalState, 'call', _22 => _22(), 'optionalAccess', _23 => _23.setOverrideBgLogger, 'call', _24 => _24(null)]);
 }
 function initTestExperiment(experimentName, projectName) {
   setInitialTestState();
@@ -4229,7 +4333,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"
     );
@@ -4242,7 +4346,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,
@@ -4261,7 +4365,7 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
     });
     state.bgLogger().log([record]);
   }
-  if (!isEmpty(comment)) {
+  if (!isEmpty2(comment)) {
     const record = new LazyValue(async () => {
       return {
         id: _uuid.v4.call(void 0, ),
@@ -4375,9 +4479,9 @@ async function permalink(slug, opts) {
   if (slug === "") {
     return NOOP_SPAN_PERMALINK;
   }
-  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _22 => _22.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _25 => _25.state]), () => ( _globalState));
   const getOrgName = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _23 => _23.orgName])) {
+    if (_optionalChain([opts, 'optionalAccess', _26 => _26.orgName])) {
       return opts.orgName;
     }
     await state.login({});
@@ -4387,7 +4491,7 @@ async function permalink(slug, opts) {
     return state.orgName;
   };
   const getAppUrl = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _24 => _24.appUrl])) {
+    if (_optionalChain([opts, 'optionalAccess', _27 => _27.appUrl])) {
       return opts.appUrl;
     }
     await state.login({});
@@ -4520,7 +4624,7 @@ var Logger = (_class6 = class {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _25 => _25.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _28 => _28.allowConcurrentWithSpans])) {
       throw new Error(
         "Cannot run toplevel `log` method while using spans. To log to the span, call `logger.traced` and then log with `span.log`"
       );
@@ -4588,12 +4692,12 @@ var Logger = (_class6 = class {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _26 => _26.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _29 => _29.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: this.computeMetadataArgs,
-        parentSpanIds: _optionalChain([args, 'optionalAccess', _27 => _27.parentSpanIds]),
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _28 => _28.propagatedEvent])
+        parentSpanIds: _optionalChain([args, 'optionalAccess', _30 => _30.parentSpanIds]),
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _31 => _31.propagatedEvent])
       }),
       defaultRootType: "task" /* TASK */
     });
@@ -4838,7 +4942,7 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
       this.queue.clear();
       return;
     }
-    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _29 => _29.batchSize]), () => ( this.defaultBatchSize));
+    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _32 => _32.batchSize]), () => ( this.defaultBatchSize));
     const wrappedItems = this.queue.drain();
     if (wrappedItems.length === 0) {
       return;
@@ -5103,10 +5207,10 @@ Error: ${errorText}`;
         } catch (err) {
           if (err instanceof AggregateError) {
             for (const e of err.errors) {
-              _optionalChain([this, 'access', _30 => _30.onFlushError, 'optionalCall', _31 => _31(e)]);
+              _optionalChain([this, 'access', _33 => _33.onFlushError, 'optionalCall', _34 => _34(e)]);
             }
           } else {
-            _optionalChain([this, 'access', _32 => _32.onFlushError, 'optionalCall', _33 => _33(err)]);
+            _optionalChain([this, 'access', _35 => _35.onFlushError, 'optionalCall', _36 => _36(err)]);
           }
           this.activeFlushError = err;
         } finally {
@@ -5173,7 +5277,7 @@ function init(projectOrOptions, optionalOptions) {
   const state = _nullishCoalesce(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(
@@ -5412,7 +5516,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
@@ -5425,7 +5529,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
     });
@@ -5506,9 +5610,9 @@ async function loadPrompt({
     );
   }
   if (id) {
-  } else if (isEmpty(projectName) && isEmpty(projectId)) {
+  } else if (isEmpty2(projectName) && isEmpty2(projectId)) {
     throw new Error("Must specify either projectName or projectId");
-  } else if (isEmpty(slug)) {
+  } else if (isEmpty2(slug)) {
     throw new Error("Must specify slug");
   }
   const state = _nullishCoalesce(stateArg, () => ( _globalState));
@@ -5610,7 +5714,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\``
         );
@@ -5719,24 +5823,24 @@ async function summarize(options = {}) {
   return await e.summarize(options);
 }
 function currentExperiment(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _34 => _34.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _37 => _37.state]), () => ( _globalState));
   return state.currentExperiment;
 }
 function currentLogger(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _35 => _35.state]), () => ( _globalState));
-  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _36 => _36.asyncFlush]));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _38 => _38.state]), () => ( _globalState));
+  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _39 => _39.asyncFlush]));
 }
 function currentSpan(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _37 => _37.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.state]), () => ( _globalState));
   return _nullishCoalesce(state.contextManager.getCurrentSpan(), () => ( NOOP_SPAN));
 }
 function getSpanParentObject(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _38 => _38.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _41 => _41.state]), () => ( _globalState));
   const parentSpan = currentSpan({ state });
   if (!Object.is(parentSpan, NOOP_SPAN)) {
     return parentSpan;
   }
-  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _39 => _39.parent]), () => ( state.currentParent.getStore()));
+  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _42 => _42.parent]), () => ( state.currentParent.getStore()));
   if (parentStr) return getSpanComponentsClass().fromStr(parentStr);
   const experiment = currentExperiment();
   if (experiment) {
@@ -5765,7 +5869,7 @@ function traced(callback, args) {
   const { span, isSyncFlushLogger } = startSpanAndIsLogger(args);
   const ret = runCatchFinally(
     () => {
-      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _40 => _40.setCurrent]), () => ( true))) {
+      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _43 => _43.setCurrent]), () => ( true))) {
         return withCurrent(span, callback);
       } else {
         return callback(span);
@@ -5777,7 +5881,7 @@ function traced(callback, args) {
     },
     () => span.end()
   );
-  if (_optionalChain([args, 'optionalAccess', _41 => _41.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _42 => _42.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _44 => _44.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _45 => _45.asyncFlush])) {
     return ret;
   } else {
     return (async () => {
@@ -5901,14 +6005,14 @@ function wrapTraced(fn, args) {
   };
   const hasExplicitInput = args && args.event && "input" in args.event && args.event.input !== void 0;
   const hasExplicitOutput = args && args.event && args.event.output !== void 0;
-  const noTraceIO = _optionalChain([args, 'optionalAccess', _43 => _43.noTraceIO]) || hasExplicitInput || hasExplicitOutput;
+  const noTraceIO = _optionalChain([args, 'optionalAccess', _46 => _46.noTraceIO]) || hasExplicitInput || hasExplicitOutput;
   if (isGeneratorFunction(fn)) {
     return wrapTracedSyncGenerator(fn, spanArgs, !!noTraceIO);
   }
   if (isAsyncGeneratorFunction(fn)) {
     return wrapTracedAsyncGenerator(fn, spanArgs, !!noTraceIO);
   }
-  if (_optionalChain([args, 'optionalAccess', _44 => _44.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _47 => _47.asyncFlush])) {
     return ((...fnArgs) => traced((span) => {
       if (!hasExplicitInput) {
         span.log({ input: fnArgs });
@@ -5946,17 +6050,17 @@ function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
 async function flush(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _48 => _48.state]), () => ( _globalState));
   return await state.bgLogger().flush();
 }
 function setFetch(fetch2) {
   _globalState.setFetch(fetch2);
 }
 function startSpanAndIsLogger(args) {
-  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _46 => _46.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _49 => _49.state]), () => ( _globalState));
   const parentObject = getSpanParentObject({
-    asyncFlush: _optionalChain([args, 'optionalAccess', _47 => _47.asyncFlush]),
-    parent: _optionalChain([args, 'optionalAccess', _48 => _48.parent]),
+    asyncFlush: _optionalChain([args, 'optionalAccess', _50 => _50.asyncFlush]),
+    parent: _optionalChain([args, 'optionalAccess', _51 => _51.parent]),
     state
   });
   if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
@@ -5973,14 +6077,14 @@ function startSpanAndIsLogger(args) {
       ),
       parentComputeObjectMetadataArgs: _nullishCoalesce(parentObject.data.compute_object_metadata_args, () => ( void 0)),
       parentSpanIds,
-      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _49 => _49.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _52 => _52.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       (_nullishCoalesce(parentObject.data.propagated_event, () => ( void 0)))))
     });
     return {
       span,
       isSyncFlushLogger: parentObject.data.object_type === 2 /* PROJECT_LOGS */ && // Since there's no parent logger here, we're free to choose the async flush
       // behavior, and therefore propagate along whatever we get from the arguments
-      _optionalChain([args, 'optionalAccess', _50 => _50.asyncFlush]) === false
+      _optionalChain([args, 'optionalAccess', _53 => _53.asyncFlush]) === false
     };
   } else {
     const span = parentObject.startSpan(args);
@@ -6172,10 +6276,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _51 => _51.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (_optionalChain([value, 'optionalAccess', _54 => _54.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _52 => _52.reference, 'optionalAccess', _53 => _53.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _54 => _54.uploader])) {
+    if (_optionalChain([value, 'optionalAccess', _55 => _55.reference, 'optionalAccess', _56 => _56.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _57 => _57.uploader])) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -6219,15 +6323,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) {
@@ -6326,7 +6430,7 @@ var ObjectFetcher = (_class9 = class {
       }
       return;
     }
-    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _55 => _55.batchSize]))) {
+    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _58 => _58.batchSize]))) {
       yield record;
     }
   }
@@ -6336,7 +6440,7 @@ var ObjectFetcher = (_class9 = class {
   async fetchedData(options) {
     if (this._fetchedData === void 0) {
       const data = [];
-      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _56 => _56.batchSize]))) {
+      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _59 => _59.batchSize]))) {
         data.push(record);
       }
       this._fetchedData = data;
@@ -6431,7 +6535,7 @@ var Experiment2 = (_class10 = class extends ObjectFetcher {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _57 => _57.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _60 => _60.allowConcurrentWithSpans])) {
       throw new Error(
         "Cannot run toplevel `log` method while using spans. To log to the span, call `experiment.traced` and then log with `span.log`"
       );
@@ -6484,12 +6588,12 @@ var Experiment2 = (_class10 = class extends ObjectFetcher {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _58 => _58.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _61 => _61.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: void 0,
         parentSpanIds: void 0,
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _59 => _59.propagatedEvent])
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _62 => _62.propagatedEvent])
       }),
       defaultRootType: "eval" /* EVAL */
     });
@@ -6827,10 +6931,10 @@ var SpanImpl = (_class11 = class _SpanImpl {
       ...serializableInternalData,
       [IS_MERGE_FIELD]: this.isMerge
     });
-    if (_optionalChain([partialRecord, 'access', _60 => _60.metrics, 'optionalAccess', _61 => _61.end])) {
-      this.loggedEndTime = _optionalChain([partialRecord, 'access', _62 => _62.metrics, 'optionalAccess', _63 => _63.end]);
+    if (_optionalChain([partialRecord, 'access', _63 => _63.metrics, 'optionalAccess', _64 => _64.end])) {
+      this.loggedEndTime = _optionalChain([partialRecord, 'access', _65 => _65.metrics, 'optionalAccess', _66 => _66.end]);
     }
-    if ((_nullishCoalesce(partialRecord.tags, () => ( []))).length > 0 && _optionalChain([this, 'access', _64 => _64._spanParents, 'optionalAccess', _65 => _65.length])) {
+    if ((_nullishCoalesce(partialRecord.tags, () => ( []))).length > 0 && _optionalChain([this, 'access', _67 => _67._spanParents, 'optionalAccess', _68 => _68.length])) {
       throw new Error("Tags can only be logged to the root span");
     }
     const computeRecord = async () => ({
@@ -6875,18 +6979,18 @@ var SpanImpl = (_class11 = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _66 => _66.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _69 => _69.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this._state,
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _67 => _67.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _70 => _70.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _68 => _68.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _71 => _71.propagatedEvent]), () => ( this.propagatedEvent))
       })
     });
   }
@@ -6900,12 +7004,12 @@ var SpanImpl = (_class11 = class _SpanImpl {
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _69 => _69.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _72 => _72.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _70 => _70.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _73 => _73.propagatedEvent]), () => ( this.propagatedEvent))
       }),
       spanId
     });
@@ -6914,7 +7018,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
     let endTime;
     let internalData = {};
     if (!this.loggedEndTime) {
-      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _71 => _71.endTime]), () => ( getCurrentUnixTimestamp()));
+      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _74 => _74.endTime]), () => ( getCurrentUnixTimestamp()));
       internalData = { metrics: { end: endTime } };
     } else {
       endTime = this.loggedEndTime;
@@ -6957,8 +7061,8 @@ var SpanImpl = (_class11 = class _SpanImpl {
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
       case 2 /* PROJECT_LOGS */: {
-        const projectID = _optionalChain([args, 'optionalAccess', _72 => _72.project_id]) || this.parentObjectId.getSync().value;
-        const projectName = _optionalChain([args, 'optionalAccess', _73 => _73.project_name]);
+        const projectID = _optionalChain([args, 'optionalAccess', _75 => _75.project_id]) || this.parentObjectId.getSync().value;
+        const projectName = _optionalChain([args, 'optionalAccess', _76 => _76.project_name]);
         if (projectID) {
           return `${baseUrl}/object?object_type=project_logs&object_id=${projectID}&id=${this._id}`;
         } else if (projectName) {
@@ -6968,7 +7072,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
         }
       }
       case 1 /* EXPERIMENT */: {
-        const expID = _optionalChain([args, 'optionalAccess', _74 => _74.experiment_id]) || _optionalChain([this, 'access', _75 => _75.parentObjectId, 'optionalAccess', _76 => _76.getSync, 'call', _77 => _77(), 'optionalAccess', _78 => _78.value]);
+        const expID = _optionalChain([args, 'optionalAccess', _77 => _77.experiment_id]) || _optionalChain([this, 'access', _78 => _78.parentObjectId, 'optionalAccess', _79 => _79.getSync, 'call', _80 => _80(), 'optionalAccess', _81 => _81.value]);
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
         } else {
@@ -7023,14 +7127,14 @@ function splitLoggingData({
     if (value instanceof BraintrustStream) {
       const streamCopy = value.copy();
       lazyInternalData[key] = new LazyValue(async () => {
-        return await new Promise((resolve, reject) => {
-          streamCopy.toReadableStream().pipeThrough(createFinalValuePassThroughStream(resolve, reject)).pipeTo(devNullWritableStream());
+        return await new Promise((resolve, reject2) => {
+          streamCopy.toReadableStream().pipeThrough(createFinalValuePassThroughStream(resolve, reject2)).pipeTo(devNullWritableStream());
         });
       });
     } else if (value instanceof ReadableStream) {
       lazyInternalData[key] = new LazyValue(async () => {
-        return await new Promise((resolve, reject) => {
-          value.pipeThrough(createFinalValuePassThroughStream(resolve, reject)).pipeTo(devNullWritableStream());
+        return await new Promise((resolve, reject2) => {
+          value.pipeThrough(createFinalValuePassThroughStream(resolve, reject2)).pipeTo(devNullWritableStream());
         });
       });
     } else {
@@ -7287,7 +7391,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) };
@@ -7324,7 +7428,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),
@@ -7424,13 +7528,13 @@ var Prompt2 = (_class13 = class _Prompt {
     return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
   }
   get prompt() {
-    return _optionalChain([this, 'access', _79 => _79.getParsedPromptData, 'call', _80 => _80(), 'optionalAccess', _81 => _81.prompt]);
+    return _optionalChain([this, 'access', _82 => _82.getParsedPromptData, 'call', _83 => _83(), 'optionalAccess', _84 => _84.prompt]);
   }
   get version() {
     return this.metadata[TRANSACTION_ID_FIELD];
   }
   get options() {
-    return _optionalChain([this, 'access', _82 => _82.getParsedPromptData, 'call', _83 => _83(), 'optionalAccess', _84 => _84.options]) || {};
+    return _optionalChain([this, 'access', _85 => _85.getParsedPromptData, 'call', _86 => _86(), 'optionalAccess', _87 => _87.options]) || {};
   }
   get promptData() {
     return this.getParsedPromptData();
@@ -7473,11 +7577,11 @@ var Prompt2 = (_class13 = 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"
       );
@@ -7581,7 +7685,7 @@ var Prompt2 = (_class13 = class _Prompt {
       return {
         type: "chat",
         messages,
-        ..._optionalChain([prompt, 'access', _85 => _85.tools, 'optionalAccess', _86 => _86.trim, 'call', _87 => _87()]) ? {
+        ..._optionalChain([prompt, 'access', _88 => _88.tools, 'optionalAccess', _89 => _89.trim, 'call', _90 => _90()]) ? {
           tools: render(prompt.tools)
         } : void 0
       };
@@ -7691,9 +7795,9 @@ async function getPromptVersions(projectId, promptId) {
     );
   }
   const result = await response.json();
-  return _optionalChain([result, 'access', _88 => _88.data, 'optionalAccess', _89 => _89.filter, 'call', _90 => _90(
-    (entry) => ["upsert", "merge"].includes(_optionalChain([entry, 'access', _91 => _91.audit_data, 'optionalAccess', _92 => _92.action]))
-  ), 'access', _93 => _93.map, 'call', _94 => _94((entry) => prettifyXact(entry._xact_id))]) || [];
+  return _optionalChain([result, 'access', _91 => _91.data, 'optionalAccess', _92 => _92.filter, 'call', _93 => _93(
+    (entry) => ["upsert", "merge"].includes(_optionalChain([entry, 'access', _94 => _94.audit_data, 'optionalAccess', _95 => _95.action]))
+  ), 'access', _96 => _96.map, 'call', _97 => _97((entry) => prettifyXact(entry._xact_id))]) || [];
 }
 function resetIdGenStateForTests() {
   const state = _internalGetGlobalState();
@@ -7747,18 +7851,24 @@ function configureBrowser() {
   browserConfigured = true;
 }
 
-// src/exports-browser.ts
-var exports_browser_exports = {};
-__export(exports_browser_exports, {
+// src/exports.ts
+var exports_exports = {};
+__export(exports_exports, {
   Attachment: () => Attachment,
+  AttachmentReference: () => AttachmentReference,
   BaseAttachment: () => BaseAttachment,
+  BaseExperiment: () => BaseExperiment,
   BraintrustMiddleware: () => BraintrustMiddleware,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
+  CodeFunction: () => CodeFunction,
+  CodePrompt: () => CodePrompt,
   ContextManager: () => ContextManager,
   DEFAULT_FETCH_BATCH_SIZE: () => DEFAULT_FETCH_BATCH_SIZE,
   Dataset: () => Dataset2,
   ERR_PERMALINK: () => ERR_PERMALINK,
+  Eval: () => Eval,
+  EvalResultWithSummary: () => EvalResultWithSummary,
   Experiment: () => Experiment2,
   ExternalAttachment: () => ExternalAttachment,
   FailedHTTPResponse: () => FailedHTTPResponse,
@@ -7771,22 +7881,30 @@ __export(exports_browser_exports, {
   NOOP_SPAN: () => NOOP_SPAN,
   NOOP_SPAN_PERMALINK: () => NOOP_SPAN_PERMALINK,
   NoopSpan: () => NoopSpan,
+  Project: () => Project2,
+  ProjectNameIdMap: () => ProjectNameIdMap,
   Prompt: () => Prompt2,
+  PromptBuilder: () => PromptBuilder,
   ReadonlyAttachment: () => ReadonlyAttachment,
   ReadonlyExperiment: () => ReadonlyExperiment,
+  Reporter: () => Reporter,
+  ScorerBuilder: () => ScorerBuilder,
   SpanImpl: () => SpanImpl,
   TestBackgroundLogger: () => TestBackgroundLogger,
+  ToolBuilder: () => ToolBuilder,
   UUIDGenerator: () => UUIDGenerator,
   X_CACHED_HEADER: () => X_CACHED_HEADER,
   _exportsForTestingOnly: () => _exportsForTestingOnly,
   _internalGetGlobalState: () => _internalGetGlobalState,
   _internalSetInitialState: () => _internalSetInitialState,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
+  buildLocalSummary: () => buildLocalSummary,
   createFinalValuePassThroughStream: () => createFinalValuePassThroughStream,
   currentExperiment: () => currentExperiment,
   currentLogger: () => currentLogger,
   currentSpan: () => currentSpan,
   deepCopyEvent: () => deepCopyEvent,
+  defaultErrorScoreHandler: () => defaultErrorScoreHandler,
   deserializePlainStringAsJSON: () => deserializePlainStringAsJSON,
   devNullWritableStream: () => devNullWritableStream,
   evaluatorDefinitionSchema: () => evaluatorDefinitionSchema,
@@ -7811,13 +7929,21 @@ __export(exports_browser_exports, {
   newId: () => newId,
   parseCachedHeader: () => parseCachedHeader,
   permalink: () => permalink,
+  projects: () => projects,
+  promptContentsSchema: () => promptContentsSchema,
+  promptDefinitionSchema: () => promptDefinitionSchema,
+  promptDefinitionToPromptData: () => promptDefinitionToPromptData,
+  promptDefinitionWithToolsSchema: () => promptDefinitionWithToolsSchema,
   renderMessage: () => renderMessage,
   renderPromptParams: () => renderPromptParams,
+  reportFailures: () => reportFailures,
+  runEvaluator: () => runEvaluator,
   setFetch: () => setFetch,
   setMaskingFunction: () => setMaskingFunction,
   spanComponentsToObjectId: () => spanComponentsToObjectId,
   startSpan: () => startSpan,
   summarize: () => summarize,
+  toolFunctionDefinitionSchema: () => ToolFunctionDefinition,
   traceable: () => traceable,
   traced: () => traced,
   updateSpan: () => updateSpan,
@@ -7827,6 +7953,7 @@ __export(exports_browser_exports, {
   withLogger: () => withLogger,
   withParent: () => withParent,
   wrapAISDK: () => wrapAISDK,
+  wrapAISDKModel: () => wrapAISDKModel,
   wrapAnthropic: () => wrapAnthropic,
   wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
@@ -7973,7 +8100,7 @@ function parseSpanFromResponseCreateParams(params) {
 }
 function parseEventFromResponseCreateResult(result) {
   const data = {};
-  if (_optionalChain([result, 'optionalAccess', _95 => _95.output]) !== void 0) {
+  if (_optionalChain([result, 'optionalAccess', _98 => _98.output]) !== void 0) {
     data.output = processImagesInOutput(result.output);
   }
   if (result) {
@@ -7982,7 +8109,7 @@ function parseEventFromResponseCreateResult(result) {
       data.metadata = metadata;
     }
   }
-  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _96 => _96.usage]));
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _99 => _99.usage]));
   return data;
 }
 function processImagesInOutput(output) {
@@ -8036,7 +8163,7 @@ function parseSpanFromResponseParseParams(params) {
 }
 function parseEventFromResponseParseResult(result) {
   const data = {};
-  if (_optionalChain([result, 'optionalAccess', _97 => _97.output]) !== void 0) {
+  if (_optionalChain([result, 'optionalAccess', _100 => _100.output]) !== void 0) {
     data.output = processImagesInOutput(result.output);
   }
   if (result) {
@@ -8045,7 +8172,7 @@ function parseEventFromResponseParseResult(result) {
       data.metadata = metadata;
     }
   }
-  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _98 => _98.usage]));
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _101 => _101.usage]));
   return data;
 }
 function traceResponseCreateStream(stream, timedSpan) {
@@ -8062,7 +8189,7 @@ function traceResponseCreateStream(stream, timedSpan) {
       return result;
     }
     const item = result.value;
-    if (!item || !_optionalChain([item, 'optionalAccess', _99 => _99.type]) || !_optionalChain([item, 'optionalAccess', _100 => _100.response])) {
+    if (!item || !_optionalChain([item, 'optionalAccess', _102 => _102.type]) || !_optionalChain([item, 'optionalAccess', _103 => _103.response])) {
       return result;
     }
     const event = parseLogFromItem(item);
@@ -8073,14 +8200,14 @@ function traceResponseCreateStream(stream, timedSpan) {
   };
 }
 function parseLogFromItem(item) {
-  if (!item || !_optionalChain([item, 'optionalAccess', _101 => _101.type]) || !_optionalChain([item, 'optionalAccess', _102 => _102.response])) {
+  if (!item || !_optionalChain([item, 'optionalAccess', _104 => _104.type]) || !_optionalChain([item, 'optionalAccess', _105 => _105.response])) {
     return {};
   }
   const response = item.response;
   switch (item.type) {
     case "response.completed":
       const data = {};
-      if (_optionalChain([response, 'optionalAccess', _103 => _103.output]) !== void 0) {
+      if (_optionalChain([response, 'optionalAccess', _106 => _106.output]) !== void 0) {
         data.output = processImagesInOutput(response.output);
       }
       if (response) {
@@ -8089,7 +8216,7 @@ function parseLogFromItem(item) {
           data.metadata = metadata;
         }
       }
-      data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _104 => _104.usage]));
+      data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _107 => _107.usage]));
       return data;
     default:
       return {};
@@ -8286,8 +8413,8 @@ function wrapOpenAIv4(openai) {
   const embeddingProxy = createEndpointProxy(openai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(openai.moderations, wrapModerations);
   let betaProxy2;
-  if (_optionalChain([openai, 'access', _105 => _105.beta, 'optionalAccess', _106 => _106.chat, 'optionalAccess', _107 => _107.completions, 'optionalAccess', _108 => _108.stream])) {
-    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _109 => _109.beta, 'optionalAccess', _110 => _110.chat, 'access', _111 => _111.completions]), {
+  if (_optionalChain([openai, 'access', _108 => _108.beta, 'optionalAccess', _109 => _109.chat, 'optionalAccess', _110 => _110.completions, 'optionalAccess', _111 => _111.stream])) {
+    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _112 => _112.beta, 'optionalAccess', _113 => _113.chat, 'access', _114 => _114.completions]), {
       get(target, name, receiver) {
         const baseVal = Reflect.get(target, name, receiver);
         if (name === "parse") {
@@ -8335,7 +8462,7 @@ function wrapOpenAIv4(openai) {
   });
 }
 function logCompletionResponse(startTime, response, span) {
-  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _112 => _112.usage]));
+  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _115 => _115.usage]));
   metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
   span.log({
     output: response.choices,
@@ -8408,13 +8535,13 @@ function wrapBetaChatCompletionStream(completion) {
 var LEGACY_CACHED_HEADER = "x-cached";
 var X_CACHED_HEADER = "x-bt-cached";
 function parseCachedHeader(value) {
-  return isEmpty(value) ? void 0 : ["true", "hit"].includes(value.toLowerCase()) ? 1 : 0;
+  return isEmpty2(value) ? void 0 : ["true", "hit"].includes(value.toLowerCase()) ? 1 : 0;
 }
 function logHeaders(response, span) {
   const cachedHeader = response.headers.get(X_CACHED_HEADER);
-  if (isEmpty(cachedHeader)) {
+  if (isEmpty2(cachedHeader)) {
     const legacyCacheHeader = response.headers.get(LEGACY_CACHED_HEADER);
-    if (!isEmpty(legacyCacheHeader)) {
+    if (!isEmpty2(legacyCacheHeader)) {
       span.log({
         metrics: {
           cached: parseCachedHeader(legacyCacheHeader)
@@ -8565,7 +8692,7 @@ function parseChatCompletionParams(params) {
 function processEmbeddingResponse(result, span) {
   span.log({
     output: { embedding_length: result.data[0].embedding.length },
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _113 => _113.usage]))
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _116 => _116.usage]))
   });
 }
 function processModerationResponse(result, span) {
@@ -8595,10 +8722,10 @@ function postprocessStreamingResults(allResults) {
     if (result.usage) {
       metrics = {
         ...metrics,
-        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _114 => _114.usage]))
+        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _117 => _117.usage]))
       };
     }
-    const delta = _optionalChain([result, 'access', _115 => _115.choices, 'optionalAccess', _116 => _116[0], 'optionalAccess', _117 => _117.delta]);
+    const delta = _optionalChain([result, 'access', _118 => _118.choices, 'optionalAccess', _119 => _119[0], 'optionalAccess', _120 => _120.delta]);
     if (!delta) {
       continue;
     }
@@ -8924,7 +9051,7 @@ var resolveModel = (model, ai) => {
   if (typeof model !== "string") {
     return model;
   }
-  const provider = _nullishCoalesce(_nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( _optionalChain([ai, 'optionalAccess', _118 => _118.gateway]))), () => ( null));
+  const provider = _nullishCoalesce(_nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( _optionalChain([ai, 'optionalAccess', _121 => _121.gateway]))), () => ( null));
   if (provider && typeof provider.languageModel === "function") {
     return provider.languageModel(model);
   }
@@ -8939,7 +9066,7 @@ var wrapModel = (model, ai) => {
     return resolvedModel;
   }
   const originalDoGenerate = resolvedModel.doGenerate.bind(resolvedModel);
-  const originalDoStream = _optionalChain([resolvedModel, 'access', _119 => _119.doStream, 'optionalAccess', _120 => _120.bind, 'call', _121 => _121(resolvedModel)]);
+  const originalDoStream = _optionalChain([resolvedModel, 'access', _122 => _122.doStream, 'optionalAccess', _123 => _123.bind, 'call', _124 => _124(resolvedModel)]);
   const wrappedDoGenerate = async (options) => {
     return traced(
       async (span) => {
@@ -9022,9 +9149,9 @@ var wrapModel = (model, ai) => {
           case "raw":
             if (chunk.rawValue) {
               const rawVal = chunk.rawValue;
-              if (_optionalChain([rawVal, 'access', _122 => _122.delta, 'optionalAccess', _123 => _123.content])) {
+              if (_optionalChain([rawVal, 'access', _125 => _125.delta, 'optionalAccess', _126 => _126.content])) {
                 text += rawVal.delta.content;
-              } else if (_optionalChain([rawVal, 'access', _124 => _124.choices, 'optionalAccess', _125 => _125[0], 'optionalAccess', _126 => _126.delta, 'optionalAccess', _127 => _127.content])) {
+              } else if (_optionalChain([rawVal, 'access', _127 => _127.choices, 'optionalAccess', _128 => _128[0], 'optionalAccess', _129 => _129.delta, 'optionalAccess', _130 => _130.content])) {
                 text += rawVal.choices[0].delta.content;
               } else if (typeof rawVal.text === "string") {
                 text += rawVal.text;
@@ -9146,10 +9273,10 @@ var makeStreamTextWrapper = (name, options, streamText, aiSDK) => {
                 }
               });
             }
-            _optionalChain([params, 'access', _128 => _128.onChunk, 'optionalCall', _129 => _129(chunk)]);
+            _optionalChain([params, 'access', _131 => _131.onChunk, 'optionalCall', _132 => _132(chunk)]);
           },
           onFinish: async (event) => {
-            _optionalChain([params, 'access', _130 => _130.onFinish, 'optionalCall', _131 => _131(event)]);
+            _optionalChain([params, 'access', _133 => _133.onFinish, 'optionalCall', _134 => _134(event)]);
             span.log({
               output: await processOutput(event, options.denyOutputPaths),
               metrics: extractTokenMetrics(event)
@@ -9157,7 +9284,7 @@ var makeStreamTextWrapper = (name, options, streamText, aiSDK) => {
             span.end();
           },
           onError: async (err) => {
-            _optionalChain([params, 'access', _132 => _132.onError, 'optionalCall', _133 => _133(err)]);
+            _optionalChain([params, 'access', _135 => _135.onError, 'optionalCall', _136 => _136(err)]);
             span.log({
               error: serializeError(err)
             });
@@ -9244,10 +9371,10 @@ var wrapStreamObject = (streamObject, options = {}, aiSDK) => {
                 }
               });
             }
-            _optionalChain([params, 'access', _134 => _134.onChunk, 'optionalCall', _135 => _135(chunk)]);
+            _optionalChain([params, 'access', _137 => _137.onChunk, 'optionalCall', _138 => _138(chunk)]);
           },
           onFinish: async (event) => {
-            _optionalChain([params, 'access', _136 => _136.onFinish, 'optionalCall', _137 => _137(event)]);
+            _optionalChain([params, 'access', _139 => _139.onFinish, 'optionalCall', _140 => _140(event)]);
             span.log({
               output: await processOutput(event, options.denyOutputPaths),
               metrics: extractTokenMetrics(event)
@@ -9255,7 +9382,7 @@ var wrapStreamObject = (streamObject, options = {}, aiSDK) => {
             span.end();
           },
           onError: async (err) => {
-            _optionalChain([params, 'access', _138 => _138.onError, 'optionalCall', _139 => _139(err)]);
+            _optionalChain([params, 'access', _141 => _141.onError, 'optionalCall', _142 => _142(err)]);
             span.log({
               error: serializeError(err)
             });
@@ -9303,7 +9430,7 @@ var wrapStreamObject = (streamObject, options = {}, aiSDK) => {
 };
 var wrapTools = (tools) => {
   if (!tools) return tools;
-  const inferName = (tool, fallback) => tool && (tool.name || tool.toolName || tool.id) || fallback;
+  const inferName = (tool, fallback2) => tool && (tool.name || tool.toolName || tool.id) || fallback2;
   if (Array.isArray(tools)) {
     return tools.map((tool, idx) => {
       const name = inferName(tool, `tool[${idx}]`);
@@ -9392,7 +9519,7 @@ var serializeError = (error) => {
   return String(error);
 };
 var serializeModel = (model) => {
-  return typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _140 => _140.modelId]);
+  return typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _143 => _143.modelId]);
 };
 var isZodSchema = (value) => {
   return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
@@ -9539,7 +9666,7 @@ var convertImageToAttachment = (image, explicitMimeType) => {
   try {
     if (typeof image === "string" && image.startsWith("data:")) {
       const [mimeTypeSection, base64Data] = image.split(",");
-      const mimeType = _optionalChain([mimeTypeSection, 'access', _141 => _141.match, 'call', _142 => _142(/data:(.*?);/), 'optionalAccess', _143 => _143[1]]);
+      const mimeType = _optionalChain([mimeTypeSection, 'access', _144 => _144.match, 'call', _145 => _145(/data:(.*?);/), 'optionalAccess', _146 => _146[1]]);
       if (mimeType && base64Data) {
         const blob = convertDataToBlob(base64Data, mimeType);
         if (blob) {
@@ -9698,7 +9825,7 @@ var convertFileToAttachment = (file, index) => {
 };
 function extractTokenMetrics(result) {
   const metrics = {};
-  const usage = _optionalChain([result, 'optionalAccess', _144 => _144.usage]);
+  const usage = _optionalChain([result, 'optionalAccess', _147 => _147.usage]);
   if (!usage) {
     return metrics;
   }
@@ -9815,6 +9942,279 @@ var omit = (obj, paths) => {
   return result;
 };
 
+// src/wrappers/ai-sdk/deprecated/wrapAISDKModel.ts
+function wrapAISDKModel(model) {
+  const m = model;
+  if (_optionalChain([m, 'optionalAccess', _148 => _148.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _149 => _149.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _150 => _150.modelId]) === "string") {
+    return new BraintrustLanguageModelWrapper(m);
+  } else {
+    console.warn("Unsupported AI SDK model. Not wrapping.");
+    return model;
+  }
+}
+var BraintrustLanguageModelWrapper = class {
+  constructor(model) {
+    this.model = model;
+    if (typeof this.model.supportsUrl === "function") {
+      this.supportsUrl = (url) => this.model.supportsUrl(url);
+    }
+  }
+  
+  get specificationVersion() {
+    return this.model.specificationVersion;
+  }
+  get provider() {
+    return this.model.provider;
+  }
+  get modelId() {
+    return this.model.modelId;
+  }
+  get defaultObjectGenerationMode() {
+    return this.model.defaultObjectGenerationMode;
+  }
+  get supportsImageUrls() {
+    return this.model.supportsImageUrls;
+  }
+  get supportsStructuredOutputs() {
+    return this.model.supportsStructuredOutputs;
+  }
+  // For the first cut, do not support custom span_info arguments. We can
+  // propagate those via async local storage
+  async doGenerate(options) {
+    const span = startSpan({
+      name: "Chat Completion",
+      spanAttributes: {
+        type: "llm"
+      }
+    });
+    const { prompt, mode, ...rest } = options;
+    const startTime = getCurrentUnixTimestamp();
+    try {
+      const ret = await this.model.doGenerate(options);
+      span.log({
+        input: postProcessPrompt(prompt),
+        metadata: {
+          model: this.modelId,
+          ...rest,
+          ..."tools" in mode && mode.tools ? { tools: convertTools(mode.tools) } : "tool" in mode && mode.tool ? { tools: convertTools([mode.tool]) } : {}
+        },
+        output: postProcessOutput(ret.text, ret.toolCalls, ret.finishReason),
+        metrics: {
+          time_to_first_token: getCurrentUnixTimestamp() - startTime,
+          tokens: !isEmpty2(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
+          prompt_tokens: _optionalChain([ret, 'access', _151 => _151.usage, 'optionalAccess', _152 => _152.promptTokens]),
+          completion_tokens: _optionalChain([ret, 'access', _153 => _153.usage, 'optionalAccess', _154 => _154.completionTokens]),
+          cached: parseCachedHeader(
+            _nullishCoalesce(_optionalChain([ret, 'access', _155 => _155.rawResponse, 'optionalAccess', _156 => _156.headers, 'optionalAccess', _157 => _157[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _158 => _158.rawResponse, 'optionalAccess', _159 => _159.headers, 'optionalAccess', _160 => _160[LEGACY_CACHED_HEADER]])))
+          )
+        }
+      });
+      return ret;
+    } finally {
+      span.end();
+    }
+  }
+  async doStream(options) {
+    const { prompt, mode, ...rest } = options;
+    const startTime = getCurrentUnixTimestamp();
+    const span = startSpan({
+      name: "Chat Completion",
+      spanAttributes: {
+        type: "llm"
+      }
+    });
+    span.log({
+      input: postProcessPrompt(prompt),
+      metadata: {
+        model: this.modelId,
+        ...rest,
+        ..."tools" in mode && mode.tools ? { tools: convertTools(mode.tools) } : "tool" in mode && mode.tool ? { tools: convertTools([mode.tool]) } : {}
+      }
+    });
+    let ended = false;
+    const end = () => {
+      if (!ended) {
+        span.end();
+        ended = true;
+      }
+    };
+    try {
+      const ret = await this.model.doStream(options);
+      let time_to_first_token = void 0;
+      let usage = void 0;
+      let fullText = void 0;
+      const toolCalls = {};
+      let finishReason = void 0;
+      return {
+        ...ret,
+        stream: ret.stream.pipeThrough(
+          new TransformStream({
+            transform(chunk, controller) {
+              if (time_to_first_token === void 0) {
+                time_to_first_token = getCurrentUnixTimestamp() - startTime;
+                span.log({ metrics: { time_to_first_token } });
+              }
+              switch (chunk.type) {
+                case "text-delta":
+                  if (fullText === void 0) {
+                    fullText = "";
+                  }
+                  fullText += chunk.textDelta;
+                  break;
+                case "tool-call":
+                  toolCalls[chunk.toolCallId] = {
+                    toolCallType: chunk.toolCallType,
+                    toolCallId: chunk.toolCallId,
+                    toolName: chunk.toolName,
+                    args: chunk.args
+                  };
+                  break;
+                case "tool-call-delta":
+                  if (toolCalls[chunk.toolCallId] === void 0) {
+                    toolCalls[chunk.toolCallId] = {
+                      toolCallType: chunk.toolCallType,
+                      toolCallId: chunk.toolCallId,
+                      toolName: chunk.toolName,
+                      args: ""
+                    };
+                  }
+                  toolCalls[chunk.toolCallId].args += chunk.argsTextDelta;
+                  break;
+                case "finish":
+                  usage = chunk.usage;
+                  finishReason = chunk.finishReason;
+                  break;
+              }
+              controller.enqueue(chunk);
+            },
+            async flush(controller) {
+              span.log({
+                output: postProcessOutput(
+                  fullText,
+                  Object.keys(toolCalls).length > 0 ? Object.values(toolCalls) : void 0,
+                  finishReason
+                ),
+                metrics: {
+                  time_to_first_token,
+                  tokens: !isEmpty2(usage) ? usage.promptTokens + usage.completionTokens : void 0,
+                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _161 => _161.promptTokens]),
+                  completion_tokens: _optionalChain([usage, 'optionalAccess', _162 => _162.completionTokens]),
+                  cached: parseCachedHeader(
+                    _nullishCoalesce(_optionalChain([ret, 'access', _163 => _163.rawResponse, 'optionalAccess', _164 => _164.headers, 'optionalAccess', _165 => _165[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _166 => _166.rawResponse, 'optionalAccess', _167 => _167.headers, 'optionalAccess', _168 => _168[LEGACY_CACHED_HEADER]])))
+                  )
+                }
+              });
+              end();
+              controller.terminate();
+            }
+          })
+        )
+      };
+    } finally {
+      end();
+    }
+  }
+};
+function convertTools(tools) {
+  return tools.map((tool) => {
+    const { type: _, ...rest } = tool;
+    return {
+      type: tool.type,
+      function: rest
+    };
+  });
+}
+function postProcessPrompt(prompt) {
+  return prompt.flatMap((message) => {
+    switch (message.role) {
+      case "system":
+        return [
+          {
+            role: "system",
+            content: message.content
+          }
+        ];
+      case "assistant":
+        const textPart = message.content.find(
+          (part) => part.type === "text"
+        );
+        const toolCallParts = message.content.filter(
+          (part) => part.type === "tool-call"
+        );
+        return [
+          {
+            role: "assistant",
+            content: _optionalChain([textPart, 'optionalAccess', _169 => _169.text]),
+            ...toolCallParts.length > 0 ? {
+              tool_calls: toolCallParts.map((part) => ({
+                id: part.toolCallId,
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.args)
+                },
+                type: "function"
+              }))
+            } : {}
+          }
+        ];
+      case "user":
+        return [
+          {
+            role: "user",
+            content: message.content.map((part) => {
+              switch (part.type) {
+                case "text":
+                  return {
+                    type: "text",
+                    text: part.text,
+                    ...part.providerMetadata ? { providerMetadata: part.providerMetadata } : {}
+                  };
+                case "image":
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.image.toString(),
+                      ...part.providerMetadata ? { providerMetadata: part.providerMetadata } : {}
+                    }
+                  };
+                default:
+                  return part;
+              }
+            })
+          }
+        ];
+      case "tool":
+        return message.content.map((part) => ({
+          role: "tool",
+          tool_call_id: part.toolCallId,
+          content: JSON.stringify(part.result)
+        }));
+    }
+  });
+}
+function postProcessOutput(text, toolCalls, finishReason) {
+  return [
+    {
+      index: 0,
+      message: {
+        role: "assistant",
+        content: _nullishCoalesce(text, () => ( "")),
+        ...toolCalls && toolCalls.length > 0 ? {
+          tool_calls: toolCalls.map((toolCall) => ({
+            id: toolCall.toolCallId,
+            function: {
+              name: toolCall.toolName,
+              arguments: toolCall.args
+            },
+            type: "function"
+          }))
+        } : {}
+      },
+      finish_reason: finishReason
+    }
+  ];
+}
+
 // src/wrappers/anthropic-tokens-util.ts
 function finalizeAnthropicTokens(metrics) {
   const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + (metrics.prompt_cache_creation_tokens || 0);
@@ -9837,23 +10237,23 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
 
 // src/wrappers/ai-sdk/deprecated/BraintrustMiddleware.ts
 function detectProviderFromResult(result) {
-  if (!_optionalChain([result, 'optionalAccess', _145 => _145.providerMetadata])) {
+  if (!_optionalChain([result, 'optionalAccess', _170 => _170.providerMetadata])) {
     return void 0;
   }
   const keys = Object.keys(result.providerMetadata);
-  return _optionalChain([keys, 'optionalAccess', _146 => _146.at, 'call', _147 => _147(0)]);
+  return _optionalChain([keys, 'optionalAccess', _171 => _171.at, 'call', _172 => _172(0)]);
 }
 function extractModelFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _148 => _148.response, 'optionalAccess', _149 => _149.modelId])) {
+  if (_optionalChain([result, 'optionalAccess', _173 => _173.response, 'optionalAccess', _174 => _174.modelId])) {
     return result.response.modelId;
   }
-  if (_optionalChain([result, 'optionalAccess', _150 => _150.request, 'optionalAccess', _151 => _151.body, 'optionalAccess', _152 => _152.model])) {
+  if (_optionalChain([result, 'optionalAccess', _175 => _175.request, 'optionalAccess', _176 => _176.body, 'optionalAccess', _177 => _177.model])) {
     return result.request.body.model;
   }
   return void 0;
 }
 function extractModelFromWrapGenerateCallback(model) {
-  return _optionalChain([model, 'optionalAccess', _153 => _153.modelId]);
+  return _optionalChain([model, 'optionalAccess', _178 => _178.modelId]);
 }
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
@@ -9898,7 +10298,7 @@ function normalizeUsageMetrics(usage, provider, providerMetadata) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
   if (provider === "anthropic") {
-    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _154 => _154.anthropic]);
+    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _179 => _179.anthropic]);
     if (anthropicMetadata) {
       const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
       const cacheCreationTokens = getNumberProperty(
@@ -9924,7 +10324,7 @@ function buildAssistantOutputWithToolCalls(result, toolCalls) {
     {
       index: 0,
       logprobs: null,
-      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _155 => _155.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
+      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _180 => _180.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
       message: {
         role: "assistant",
         tool_calls: toolCalls.length > 0 ? toolCalls : void 0
@@ -9937,7 +10337,7 @@ function extractToolCallsFromSteps(steps) {
   if (!Array.isArray(steps)) return toolCalls;
   let idx = 0;
   for (const step of steps) {
-    const blocks = _optionalChain([step, 'optionalAccess', _156 => _156.content]);
+    const blocks = _optionalChain([step, 'optionalAccess', _181 => _181.content]);
     if (!Array.isArray(blocks)) continue;
     for (const block of blocks) {
       if (block && typeof block === "object" && block.type === "tool-call") {
@@ -9960,7 +10360,7 @@ function extractToolCallsFromBlocks(blocks) {
   return extractToolCallsFromSteps([{ content: blocks }]);
 }
 function extractInput(params) {
-  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _157 => _157.prompt]), () => ( _optionalChain([params, 'optionalAccess', _158 => _158.messages]))), () => ( _optionalChain([params, 'optionalAccess', _159 => _159.system])));
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _182 => _182.prompt]), () => ( _optionalChain([params, 'optionalAccess', _183 => _183.messages]))), () => ( _optionalChain([params, 'optionalAccess', _184 => _184.system])));
 }
 var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
   "prompt",
@@ -9984,16 +10384,16 @@ function BraintrustMiddleware(config = {}) {
       const rawInput = extractInput(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
-        name: _optionalChain([config, 'access', _160 => _160.spanInfo, 'optionalAccess', _161 => _161.name]) || "ai-sdk.doGenerate",
+        name: _optionalChain([config, 'access', _185 => _185.spanInfo, 'optionalAccess', _186 => _186.name]) || "ai-sdk.doGenerate",
         spanAttributes: {
           type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _162 => _162.spanInfo, 'optionalAccess', _163 => _163.spanAttributes]) || {}
+          ..._optionalChain([config, 'access', _187 => _187.spanInfo, 'optionalAccess', _188 => _188.spanAttributes]) || {}
         },
         event: {
           input: processedInput,
           metadata: {
             ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _164 => _164.spanInfo, 'optionalAccess', _165 => _165.metadata]) || {}
+            ..._optionalChain([config, 'access', _189 => _189.spanInfo, 'optionalAccess', _190 => _190.metadata]) || {}
           }
         }
       };
@@ -10019,12 +10419,12 @@ function BraintrustMiddleware(config = {}) {
             metadata.model = modelId;
           }
         }
-        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _166 => _166.steps]));
+        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _191 => _191.steps]));
         if (!toolCalls || toolCalls.length === 0) {
-          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _167 => _167.content]));
+          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _192 => _192.content]));
         }
         span.log({
-          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _168 => _168.content]),
+          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _193 => _193.content]),
           metadata,
           metrics: normalizeUsageMetrics(
             result.usage,
@@ -10046,16 +10446,16 @@ function BraintrustMiddleware(config = {}) {
       const rawInput = extractInput(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
-        name: _optionalChain([config, 'access', _169 => _169.spanInfo, 'optionalAccess', _170 => _170.name]) || "ai-sdk.doStream",
+        name: _optionalChain([config, 'access', _194 => _194.spanInfo, 'optionalAccess', _195 => _195.name]) || "ai-sdk.doStream",
         spanAttributes: {
           type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _171 => _171.spanInfo, 'optionalAccess', _172 => _172.spanAttributes]) || {}
+          ..._optionalChain([config, 'access', _196 => _196.spanInfo, 'optionalAccess', _197 => _197.spanAttributes]) || {}
         },
         event: {
           input: processedInput,
           metadata: {
             ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _173 => _173.spanInfo, 'optionalAccess', _174 => _174.metadata]) || {}
+            ..._optionalChain([config, 'access', _198 => _198.spanInfo, 'optionalAccess', _199 => _199.metadata]) || {}
           }
         }
       };
@@ -10327,9 +10727,9 @@ function streamNextProxy(stream, sspan) {
       return result;
     }
     const item = result.value;
-    switch (_optionalChain([item, 'optionalAccess', _175 => _175.type])) {
+    switch (_optionalChain([item, 'optionalAccess', _200 => _200.type])) {
       case "message_start":
-        const msg = _optionalChain([item, 'optionalAccess', _176 => _176.message]);
+        const msg = _optionalChain([item, 'optionalAccess', _201 => _201.message]);
         if (msg) {
           const event = parseEventFromMessage(msg);
           totals = { ...totals, ...event.metrics };
@@ -10342,20 +10742,20 @@ function streamNextProxy(stream, sspan) {
         }
         break;
       case "content_block_delta":
-        if (_optionalChain([item, 'access', _177 => _177.delta, 'optionalAccess', _178 => _178.type]) === "text_delta") {
-          const text = _optionalChain([item, 'optionalAccess', _179 => _179.delta, 'optionalAccess', _180 => _180.text]);
+        if (_optionalChain([item, 'access', _202 => _202.delta, 'optionalAccess', _203 => _203.type]) === "text_delta") {
+          const text = _optionalChain([item, 'optionalAccess', _204 => _204.delta, 'optionalAccess', _205 => _205.text]);
           if (text) {
             deltas.push(text);
           }
         }
         break;
       case "message_delta":
-        const usage = _optionalChain([item, 'optionalAccess', _181 => _181.usage]);
+        const usage = _optionalChain([item, 'optionalAccess', _206 => _206.usage]);
         if (usage) {
           const metrics = parseMetricsFromUsage2(usage);
           totals = { ...totals, ...metrics };
         }
-        const delta = _optionalChain([item, 'optionalAccess', _182 => _182.delta]);
+        const delta = _optionalChain([item, 'optionalAccess', _207 => _207.delta]);
         if (delta) {
           metadata = { ...metadata, ...delta };
         }
@@ -10368,7 +10768,7 @@ function streamNextProxy(stream, sspan) {
 }
 function parseEventFromMessage(message) {
   const output = message ? { role: message.role, content: message.content } : null;
-  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _183 => _183.usage]));
+  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _208 => _208.usage]));
   const metas = ["stop_reason", "stop_sequence"];
   const metadata = {};
   for (const m of metas) {
@@ -10515,7 +10915,7 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
           finalResults.push(finalMessageContent);
         }
         const lastMessage = currentMessages[currentMessages.length - 1];
-        if (_optionalChain([lastMessage, 'optionalAccess', _184 => _184.message, 'optionalAccess', _185 => _185.usage])) {
+        if (_optionalChain([lastMessage, 'optionalAccess', _209 => _209.message, 'optionalAccess', _210 => _210.usage])) {
           const outputTokens = getNumberProperty2(lastMessage.message.usage, "output_tokens") || 0;
           accumulatedOutputTokens += outputTokens;
         }
@@ -10530,20 +10930,20 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
           );
           for await (const message of generator) {
             const currentTime = getCurrentUnixTimestamp();
-            const messageId = _optionalChain([message, 'access', _186 => _186.message, 'optionalAccess', _187 => _187.id]);
+            const messageId = _optionalChain([message, 'access', _211 => _211.message, 'optionalAccess', _212 => _212.id]);
             if (messageId && messageId !== currentMessageId) {
               await createLLMSpan();
               currentMessageId = messageId;
               currentMessageStartTime = currentTime;
             }
-            if (message.type === "assistant" && _optionalChain([message, 'access', _188 => _188.message, 'optionalAccess', _189 => _189.usage])) {
+            if (message.type === "assistant" && _optionalChain([message, 'access', _213 => _213.message, 'optionalAccess', _214 => _214.usage])) {
               currentMessages.push(message);
             }
             if (message.type === "result" && message.usage) {
               finalUsageMetrics = _extractUsageFromMessage(message);
               if (currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
                 const lastMessage = currentMessages[currentMessages.length - 1];
-                if (_optionalChain([lastMessage, 'optionalAccess', _190 => _190.message, 'optionalAccess', _191 => _191.usage])) {
+                if (_optionalChain([lastMessage, 'optionalAccess', _215 => _215.message, 'optionalAccess', _216 => _216.usage])) {
                   const adjustedTokens = finalUsageMetrics.completion_tokens - accumulatedOutputTokens;
                   if (adjustedTokens >= 0) {
                     lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -10624,7 +11024,7 @@ function _extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _192 => _192.message, 'optionalAccess', _193 => _193.usage]);
+    usage = _optionalChain([message, 'access', _217 => _217.message, 'optionalAccess', _218 => _218.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -10656,14 +11056,14 @@ function _extractUsageFromMessage(message) {
 async function _createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
   if (messages.length === 0) return void 0;
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _194 => _194.message, 'optionalAccess', _195 => _195.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _219 => _219.message, 'optionalAccess', _220 => _220.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
   const usage = _extractUsageFromMessage(lastMessage);
   const input = _buildLLMInput(prompt, conversationHistory);
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _196 => _196.message, 'optionalAccess', _197 => _197.content]) && _optionalChain([m, 'access', _198 => _198.message, 'optionalAccess', _199 => _199.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _221 => _221.message, 'optionalAccess', _222 => _222.content]) && _optionalChain([m, 'access', _223 => _223.message, 'optionalAccess', _224 => _224.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter((c) => c !== void 0);
   await traced(
     (llmSpan) => {
@@ -10683,7 +11083,7 @@ async function _createLLMSpanForMessages(messages, prompt, conversationHistory,
       parent: parentSpan
     }
   );
-  return _optionalChain([lastMessage, 'access', _200 => _200.message, 'optionalAccess', _201 => _201.content]) && _optionalChain([lastMessage, 'access', _202 => _202.message, 'optionalAccess', _203 => _203.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _225 => _225.message, 'optionalAccess', _226 => _226.content]) && _optionalChain([lastMessage, 'access', _227 => _227.message, 'optionalAccess', _228 => _228.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 function wrapClaudeAgentSDK(sdk) {
   const cache = /* @__PURE__ */ new Map();
@@ -10973,7 +11373,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _204 => _204.config, 'optionalAccess', _205 => _205.tools])) {
+  if (!_optionalChain([params, 'access', _229 => _229.config, 'optionalAccess', _230 => _230.tools])) {
     return null;
   }
   try {
@@ -11056,7 +11456,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _206 => _206.content, 'optionalAccess', _207 => _207.parts])) {
+        if (_optionalChain([candidate, 'access', _231 => _231.content, 'optionalAccess', _232 => _232.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -11087,7 +11487,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _208 => _208.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _233 => _233.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -11434,51 +11834,2272 @@ function unescapePath(path) {
 }
 var graph_framework_default = { createGraph };
 
-// dev/types.ts
-
-var evalBodySchema = _v3.z.object({
-  name: _v3.z.string(),
-  parameters: _v3.z.record(_v3.z.string(), _v3.z.unknown()).nullish(),
-  data: RunEval.shape.data,
-  scores: _v3.z.array(
-    _v3.z.object({
-      function_id: FunctionId,
-      name: _v3.z.string()
-    })
-  ).nullish(),
-  experiment_name: _v3.z.string().nullish(),
-  project_id: _v3.z.string().nullish(),
-  parent: InvokeParent.optional(),
-  stream: _v3.z.boolean().optional()
-});
-var evalParametersSerializedSchema = _v3.z.record(
-  _v3.z.string(),
-  _v3.z.union([
-    _v3.z.object({
-      type: _v3.z.literal("prompt"),
-      default: PromptData.optional(),
-      description: _v3.z.string().optional()
-    }),
-    _v3.z.object({
-      type: _v3.z.literal("data"),
-      schema: _v3.z.record(_v3.z.unknown()),
-      // JSON Schema
-      default: _v3.z.unknown().optional(),
-      description: _v3.z.string().optional()
-    })
-  ])
-);
-var evaluatorDefinitionSchema = _v3.z.object({
-  parameters: evalParametersSerializedSchema.optional()
-});
-var evaluatorDefinitionsSchema = _v3.z.record(
-  _v3.z.string(),
-  evaluatorDefinitionSchema
-);
-
-// src/browser.ts
-configureBrowser();
-var browser_default = exports_browser_exports;
+// ../node_modules/async/dist/async.mjs
+function initialParams(fn) {
+  return function(...args) {
+    var callback = args.pop();
+    return fn.call(this, args, callback);
+  };
+}
+var hasQueueMicrotask = typeof queueMicrotask === "function" && queueMicrotask;
+var hasSetImmediate = typeof setImmediate === "function" && setImmediate;
+var hasNextTick = typeof process === "object" && typeof process.nextTick === "function";
+function fallback(fn) {
+  setTimeout(fn, 0);
+}
+function wrap(defer) {
+  return (fn, ...args) => defer(() => fn(...args));
+}
+var _defer$1;
+if (hasQueueMicrotask) {
+  _defer$1 = queueMicrotask;
+} else if (hasSetImmediate) {
+  _defer$1 = setImmediate;
+} else if (hasNextTick) {
+  _defer$1 = process.nextTick;
+} else {
+  _defer$1 = fallback;
+}
+var setImmediate$1 = wrap(_defer$1);
+function asyncify(func) {
+  if (isAsync(func)) {
+    return function(...args) {
+      const callback = args.pop();
+      const promise = func.apply(this, args);
+      return handlePromise(promise, callback);
+    };
+  }
+  return initialParams(function(args, callback) {
+    var result;
+    try {
+      result = func.apply(this, args);
+    } catch (e) {
+      return callback(e);
+    }
+    if (result && typeof result.then === "function") {
+      return handlePromise(result, callback);
+    } else {
+      callback(null, result);
+    }
+  });
+}
+function handlePromise(promise, callback) {
+  return promise.then((value) => {
+    invokeCallback(callback, null, value);
+  }, (err) => {
+    invokeCallback(callback, err && (err instanceof Error || err.message) ? err : new Error(err));
+  });
+}
+function invokeCallback(callback, error, value) {
+  try {
+    callback(error, value);
+  } catch (err) {
+    setImmediate$1((e) => {
+      throw e;
+    }, err);
+  }
+}
+function isAsync(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
+}
+function isAsyncGenerator(fn) {
+  return fn[Symbol.toStringTag] === "AsyncGenerator";
+}
+function isAsyncIterable(obj) {
+  return typeof obj[Symbol.asyncIterator] === "function";
+}
+function wrapAsync(asyncFn) {
+  if (typeof asyncFn !== "function") throw new Error("expected a function");
+  return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;
+}
+function awaitify(asyncFn, arity) {
+  if (!arity) arity = asyncFn.length;
+  if (!arity) throw new Error("arity is undefined");
+  function awaitable(...args) {
+    if (typeof args[arity - 1] === "function") {
+      return asyncFn.apply(this, args);
+    }
+    return new Promise((resolve, reject2) => {
+      args[arity - 1] = (err, ...cbArgs) => {
+        if (err) return reject2(err);
+        resolve(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
+      };
+      asyncFn.apply(this, args);
+    });
+  }
+  return awaitable;
+}
+function applyEach$1(eachfn) {
+  return function applyEach2(fns, ...callArgs) {
+    const go = awaitify(function(callback) {
+      var that = this;
+      return eachfn(fns, (fn, cb) => {
+        wrapAsync(fn).apply(that, callArgs.concat(cb));
+      }, callback);
+    });
+    return go;
+  };
+}
+function _asyncMap(eachfn, arr, iteratee, callback) {
+  arr = arr || [];
+  var results = [];
+  var counter = 0;
+  var _iteratee = wrapAsync(iteratee);
+  return eachfn(arr, (value, _, iterCb) => {
+    var index = counter++;
+    _iteratee(value, (err, v) => {
+      results[index] = v;
+      iterCb(err);
+    });
+  }, (err) => {
+    callback(err, results);
+  });
+}
+function isArrayLike(value) {
+  return value && typeof value.length === "number" && value.length >= 0 && value.length % 1 === 0;
+}
+var breakLoop = {};
+function once(fn) {
+  function wrapper(...args) {
+    if (fn === null) return;
+    var callFn = fn;
+    fn = null;
+    callFn.apply(this, args);
+  }
+  Object.assign(wrapper, fn);
+  return wrapper;
+}
+function getIterator(coll) {
+  return coll[Symbol.iterator] && coll[Symbol.iterator]();
+}
+function createArrayIterator(coll) {
+  var i = -1;
+  var len = coll.length;
+  return function next() {
+    return ++i < len ? { value: coll[i], key: i } : null;
+  };
+}
+function createES2015Iterator(iterator) {
+  var i = -1;
+  return function next() {
+    var item = iterator.next();
+    if (item.done)
+      return null;
+    i++;
+    return { value: item.value, key: i };
+  };
+}
+function createObjectIterator(obj) {
+  var okeys = obj ? Object.keys(obj) : [];
+  var i = -1;
+  var len = okeys.length;
+  return function next() {
+    var key = okeys[++i];
+    if (key === "__proto__") {
+      return next();
+    }
+    return i < len ? { value: obj[key], key } : null;
+  };
+}
+function createIterator(coll) {
+  if (isArrayLike(coll)) {
+    return createArrayIterator(coll);
+  }
+  var iterator = getIterator(coll);
+  return iterator ? createES2015Iterator(iterator) : createObjectIterator(coll);
+}
+function onlyOnce(fn) {
+  return function(...args) {
+    if (fn === null) throw new Error("Callback was already called.");
+    var callFn = fn;
+    fn = null;
+    callFn.apply(this, args);
+  };
+}
+function asyncEachOfLimit(generator, limit, iteratee, callback) {
+  let done = false;
+  let canceled = false;
+  let awaiting = false;
+  let running = 0;
+  let idx = 0;
+  function replenish() {
+    if (running >= limit || awaiting || done) return;
+    awaiting = true;
+    generator.next().then(({ value, done: iterDone }) => {
+      if (canceled || done) return;
+      awaiting = false;
+      if (iterDone) {
+        done = true;
+        if (running <= 0) {
+          callback(null);
+        }
+        return;
+      }
+      running++;
+      iteratee(value, idx, iterateeCallback);
+      idx++;
+      replenish();
+    }).catch(handleError);
+  }
+  function iterateeCallback(err, result) {
+    running -= 1;
+    if (canceled) return;
+    if (err) return handleError(err);
+    if (err === false) {
+      done = true;
+      canceled = true;
+      return;
+    }
+    if (result === breakLoop || done && running <= 0) {
+      done = true;
+      return callback(null);
+    }
+    replenish();
+  }
+  function handleError(err) {
+    if (canceled) return;
+    awaiting = false;
+    done = true;
+    callback(err);
+  }
+  replenish();
+}
+var eachOfLimit$2 = (limit) => {
+  return (obj, iteratee, callback) => {
+    callback = once(callback);
+    if (limit <= 0) {
+      throw new RangeError("concurrency limit cannot be less than 1");
+    }
+    if (!obj) {
+      return callback(null);
+    }
+    if (isAsyncGenerator(obj)) {
+      return asyncEachOfLimit(obj, limit, iteratee, callback);
+    }
+    if (isAsyncIterable(obj)) {
+      return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
+    }
+    var nextElem = createIterator(obj);
+    var done = false;
+    var canceled = false;
+    var running = 0;
+    var looping = false;
+    function iterateeCallback(err, value) {
+      if (canceled) return;
+      running -= 1;
+      if (err) {
+        done = true;
+        callback(err);
+      } else if (err === false) {
+        done = true;
+        canceled = true;
+      } else if (value === breakLoop || done && running <= 0) {
+        done = true;
+        return callback(null);
+      } else if (!looping) {
+        replenish();
+      }
+    }
+    function replenish() {
+      looping = true;
+      while (running < limit && !done) {
+        var elem = nextElem();
+        if (elem === null) {
+          done = true;
+          if (running <= 0) {
+            callback(null);
+          }
+          return;
+        }
+        running += 1;
+        iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));
+      }
+      looping = false;
+    }
+    replenish();
+  };
+};
+function eachOfLimit(coll, limit, iteratee, callback) {
+  return eachOfLimit$2(limit)(coll, wrapAsync(iteratee), callback);
+}
+var eachOfLimit$1 = awaitify(eachOfLimit, 4);
+function eachOfArrayLike(coll, iteratee, callback) {
+  callback = once(callback);
+  var index = 0, completed = 0, { length } = coll, canceled = false;
+  if (length === 0) {
+    callback(null);
+  }
+  function iteratorCallback(err, value) {
+    if (err === false) {
+      canceled = true;
+    }
+    if (canceled === true) return;
+    if (err) {
+      callback(err);
+    } else if (++completed === length || value === breakLoop) {
+      callback(null);
+    }
+  }
+  for (; index < length; index++) {
+    iteratee(coll[index], index, onlyOnce(iteratorCallback));
+  }
+}
+function eachOfGeneric(coll, iteratee, callback) {
+  return eachOfLimit$1(coll, Infinity, iteratee, callback);
+}
+function eachOf(coll, iteratee, callback) {
+  var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;
+  return eachOfImplementation(coll, wrapAsync(iteratee), callback);
+}
+var eachOf$1 = awaitify(eachOf, 3);
+function map(coll, iteratee, callback) {
+  return _asyncMap(eachOf$1, coll, iteratee, callback);
+}
+var map$1 = awaitify(map, 3);
+var applyEach = applyEach$1(map$1);
+function eachOfSeries(coll, iteratee, callback) {
+  return eachOfLimit$1(coll, 1, iteratee, callback);
+}
+var eachOfSeries$1 = awaitify(eachOfSeries, 3);
+function mapSeries(coll, iteratee, callback) {
+  return _asyncMap(eachOfSeries$1, coll, iteratee, callback);
+}
+var mapSeries$1 = awaitify(mapSeries, 3);
+var applyEachSeries = applyEach$1(mapSeries$1);
+var PROMISE_SYMBOL = Symbol("promiseCallback");
+var DLL = class {
+  constructor() {
+    this.head = this.tail = null;
+    this.length = 0;
+  }
+  removeLink(node) {
+    if (node.prev) node.prev.next = node.next;
+    else this.head = node.next;
+    if (node.next) node.next.prev = node.prev;
+    else this.tail = node.prev;
+    node.prev = node.next = null;
+    this.length -= 1;
+    return node;
+  }
+  empty() {
+    while (this.head) this.shift();
+    return this;
+  }
+  insertAfter(node, newNode) {
+    newNode.prev = node;
+    newNode.next = node.next;
+    if (node.next) node.next.prev = newNode;
+    else this.tail = newNode;
+    node.next = newNode;
+    this.length += 1;
+  }
+  insertBefore(node, newNode) {
+    newNode.prev = node.prev;
+    newNode.next = node;
+    if (node.prev) node.prev.next = newNode;
+    else this.head = newNode;
+    node.prev = newNode;
+    this.length += 1;
+  }
+  unshift(node) {
+    if (this.head) this.insertBefore(this.head, node);
+    else setInitial(this, node);
+  }
+  push(node) {
+    if (this.tail) this.insertAfter(this.tail, node);
+    else setInitial(this, node);
+  }
+  shift() {
+    return this.head && this.removeLink(this.head);
+  }
+  pop() {
+    return this.tail && this.removeLink(this.tail);
+  }
+  toArray() {
+    return [...this];
+  }
+  *[Symbol.iterator]() {
+    var cur = this.head;
+    while (cur) {
+      yield cur.data;
+      cur = cur.next;
+    }
+  }
+  remove(testFn) {
+    var curr = this.head;
+    while (curr) {
+      var { next } = curr;
+      if (testFn(curr)) {
+        this.removeLink(curr);
+      }
+      curr = next;
+    }
+    return this;
+  }
+};
+function setInitial(dll, node) {
+  dll.length = 1;
+  dll.head = dll.tail = node;
+}
+function queue$1(worker, concurrency, payload) {
+  if (concurrency == null) {
+    concurrency = 1;
+  } else if (concurrency === 0) {
+    throw new RangeError("Concurrency must not be zero");
+  }
+  var _worker = wrapAsync(worker);
+  var numRunning = 0;
+  var workersList = [];
+  const events = {
+    error: [],
+    drain: [],
+    saturated: [],
+    unsaturated: [],
+    empty: []
+  };
+  function on(event, handler) {
+    events[event].push(handler);
+  }
+  function once2(event, handler) {
+    const handleAndRemove = (...args) => {
+      off(event, handleAndRemove);
+      handler(...args);
+    };
+    events[event].push(handleAndRemove);
+  }
+  function off(event, handler) {
+    if (!event) return Object.keys(events).forEach((ev) => events[ev] = []);
+    if (!handler) return events[event] = [];
+    events[event] = events[event].filter((ev) => ev !== handler);
+  }
+  function trigger(event, ...args) {
+    events[event].forEach((handler) => handler(...args));
+  }
+  var processingScheduled = false;
+  function _insert(data, insertAtFront, rejectOnError, callback) {
+    if (callback != null && typeof callback !== "function") {
+      throw new Error("task callback must be a function");
+    }
+    q.started = true;
+    var res, rej;
+    function promiseCallback(err, ...args) {
+      if (err) return rejectOnError ? rej(err) : res();
+      if (args.length <= 1) return res(args[0]);
+      res(args);
+    }
+    var item = q._createTaskItem(
+      data,
+      rejectOnError ? promiseCallback : callback || promiseCallback
+    );
+    if (insertAtFront) {
+      q._tasks.unshift(item);
+    } else {
+      q._tasks.push(item);
+    }
+    if (!processingScheduled) {
+      processingScheduled = true;
+      setImmediate$1(() => {
+        processingScheduled = false;
+        q.process();
+      });
+    }
+    if (rejectOnError || !callback) {
+      return new Promise((resolve, reject2) => {
+        res = resolve;
+        rej = reject2;
+      });
+    }
+  }
+  function _createCB(tasks) {
+    return function(err, ...args) {
+      numRunning -= 1;
+      for (var i = 0, l = tasks.length; i < l; i++) {
+        var task = tasks[i];
+        var index = workersList.indexOf(task);
+        if (index === 0) {
+          workersList.shift();
+        } else if (index > 0) {
+          workersList.splice(index, 1);
+        }
+        task.callback(err, ...args);
+        if (err != null) {
+          trigger("error", err, task.data);
+        }
+      }
+      if (numRunning <= q.concurrency - q.buffer) {
+        trigger("unsaturated");
+      }
+      if (q.idle()) {
+        trigger("drain");
+      }
+      q.process();
+    };
+  }
+  function _maybeDrain(data) {
+    if (data.length === 0 && q.idle()) {
+      setImmediate$1(() => trigger("drain"));
+      return true;
+    }
+    return false;
+  }
+  const eventMethod = (name) => (handler) => {
+    if (!handler) {
+      return new Promise((resolve, reject2) => {
+        once2(name, (err, data) => {
+          if (err) return reject2(err);
+          resolve(data);
+        });
+      });
+    }
+    off(name);
+    on(name, handler);
+  };
+  var isProcessing = false;
+  var q = {
+    _tasks: new DLL(),
+    _createTaskItem(data, callback) {
+      return {
+        data,
+        callback
+      };
+    },
+    *[Symbol.iterator]() {
+      yield* q._tasks[Symbol.iterator]();
+    },
+    concurrency,
+    payload,
+    buffer: concurrency / 4,
+    started: false,
+    paused: false,
+    push(data, callback) {
+      if (Array.isArray(data)) {
+        if (_maybeDrain(data)) return;
+        return data.map((datum) => _insert(datum, false, false, callback));
+      }
+      return _insert(data, false, false, callback);
+    },
+    pushAsync(data, callback) {
+      if (Array.isArray(data)) {
+        if (_maybeDrain(data)) return;
+        return data.map((datum) => _insert(datum, false, true, callback));
+      }
+      return _insert(data, false, true, callback);
+    },
+    kill() {
+      off();
+      q._tasks.empty();
+    },
+    unshift(data, callback) {
+      if (Array.isArray(data)) {
+        if (_maybeDrain(data)) return;
+        return data.map((datum) => _insert(datum, true, false, callback));
+      }
+      return _insert(data, true, false, callback);
+    },
+    unshiftAsync(data, callback) {
+      if (Array.isArray(data)) {
+        if (_maybeDrain(data)) return;
+        return data.map((datum) => _insert(datum, true, true, callback));
+      }
+      return _insert(data, true, true, callback);
+    },
+    remove(testFn) {
+      q._tasks.remove(testFn);
+    },
+    process() {
+      if (isProcessing) {
+        return;
+      }
+      isProcessing = true;
+      while (!q.paused && numRunning < q.concurrency && q._tasks.length) {
+        var tasks = [], data = [];
+        var l = q._tasks.length;
+        if (q.payload) l = Math.min(l, q.payload);
+        for (var i = 0; i < l; i++) {
+          var node = q._tasks.shift();
+          tasks.push(node);
+          workersList.push(node);
+          data.push(node.data);
+        }
+        numRunning += 1;
+        if (q._tasks.length === 0) {
+          trigger("empty");
+        }
+        if (numRunning === q.concurrency) {
+          trigger("saturated");
+        }
+        var cb = onlyOnce(_createCB(tasks));
+        _worker(data, cb);
+      }
+      isProcessing = false;
+    },
+    length() {
+      return q._tasks.length;
+    },
+    running() {
+      return numRunning;
+    },
+    workersList() {
+      return workersList;
+    },
+    idle() {
+      return q._tasks.length + numRunning === 0;
+    },
+    pause() {
+      q.paused = true;
+    },
+    resume() {
+      if (q.paused === false) {
+        return;
+      }
+      q.paused = false;
+      setImmediate$1(q.process);
+    }
+  };
+  Object.defineProperties(q, {
+    saturated: {
+      writable: false,
+      value: eventMethod("saturated")
+    },
+    unsaturated: {
+      writable: false,
+      value: eventMethod("unsaturated")
+    },
+    empty: {
+      writable: false,
+      value: eventMethod("empty")
+    },
+    drain: {
+      writable: false,
+      value: eventMethod("drain")
+    },
+    error: {
+      writable: false,
+      value: eventMethod("error")
+    }
+  });
+  return q;
+}
+function reduce(coll, memo, iteratee, callback) {
+  callback = once(callback);
+  var _iteratee = wrapAsync(iteratee);
+  return eachOfSeries$1(coll, (x, i, iterCb) => {
+    _iteratee(memo, x, (err, v) => {
+      memo = v;
+      iterCb(err);
+    });
+  }, (err) => callback(err, memo));
+}
+var reduce$1 = awaitify(reduce, 4);
+function mapLimit(coll, limit, iteratee, callback) {
+  return _asyncMap(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+var mapLimit$1 = awaitify(mapLimit, 4);
+function concatLimit(coll, limit, iteratee, callback) {
+  var _iteratee = wrapAsync(iteratee);
+  return mapLimit$1(coll, limit, (val, iterCb) => {
+    _iteratee(val, (err, ...args) => {
+      if (err) return iterCb(err);
+      return iterCb(err, args);
+    });
+  }, (err, mapResults) => {
+    var result = [];
+    for (var i = 0; i < mapResults.length; i++) {
+      if (mapResults[i]) {
+        result = result.concat(...mapResults[i]);
+      }
+    }
+    return callback(err, result);
+  });
+}
+var concatLimit$1 = awaitify(concatLimit, 4);
+function concat(coll, iteratee, callback) {
+  return concatLimit$1(coll, Infinity, iteratee, callback);
+}
+var concat$1 = awaitify(concat, 3);
+function concatSeries(coll, iteratee, callback) {
+  return concatLimit$1(coll, 1, iteratee, callback);
+}
+var concatSeries$1 = awaitify(concatSeries, 3);
+function _createTester(check, getResult) {
+  return (eachfn, arr, _iteratee, cb) => {
+    var testPassed = false;
+    var testResult;
+    const iteratee = wrapAsync(_iteratee);
+    eachfn(arr, (value, _, callback) => {
+      iteratee(value, (err, result) => {
+        if (err || err === false) return callback(err);
+        if (check(result) && !testResult) {
+          testPassed = true;
+          testResult = getResult(true, value);
+          return callback(null, breakLoop);
+        }
+        callback();
+      });
+    }, (err) => {
+      if (err) return cb(err);
+      cb(null, testPassed ? testResult : getResult(false));
+    });
+  };
+}
+function detect(coll, iteratee, callback) {
+  return _createTester((bool) => bool, (res, item) => item)(eachOf$1, coll, iteratee, callback);
+}
+var detect$1 = awaitify(detect, 3);
+function detectLimit(coll, limit, iteratee, callback) {
+  return _createTester((bool) => bool, (res, item) => item)(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+var detectLimit$1 = awaitify(detectLimit, 4);
+function detectSeries(coll, iteratee, callback) {
+  return _createTester((bool) => bool, (res, item) => item)(eachOfLimit$2(1), coll, iteratee, callback);
+}
+var detectSeries$1 = awaitify(detectSeries, 3);
+function consoleFunc(name) {
+  return (fn, ...args) => wrapAsync(fn)(...args, (err, ...resultArgs) => {
+    if (typeof console === "object") {
+      if (err) {
+        if (console.error) {
+          console.error(err);
+        }
+      } else if (console[name]) {
+        resultArgs.forEach((x) => console[name](x));
+      }
+    }
+  });
+}
+var dir = consoleFunc("dir");
+function doWhilst(iteratee, test, callback) {
+  callback = onlyOnce(callback);
+  var _fn = wrapAsync(iteratee);
+  var _test = wrapAsync(test);
+  var results;
+  function next(err, ...args) {
+    if (err) return callback(err);
+    if (err === false) return;
+    results = args;
+    _test(...args, check);
+  }
+  function check(err, truth) {
+    if (err) return callback(err);
+    if (err === false) return;
+    if (!truth) return callback(null, ...results);
+    _fn(next);
+  }
+  return check(null, true);
+}
+var doWhilst$1 = awaitify(doWhilst, 3);
+function _withoutIndex(iteratee) {
+  return (value, index, callback) => iteratee(value, callback);
+}
+function eachLimit$2(coll, iteratee, callback) {
+  return eachOf$1(coll, _withoutIndex(wrapAsync(iteratee)), callback);
+}
+var each = awaitify(eachLimit$2, 3);
+function eachLimit(coll, limit, iteratee, callback) {
+  return eachOfLimit$2(limit)(coll, _withoutIndex(wrapAsync(iteratee)), callback);
+}
+var eachLimit$1 = awaitify(eachLimit, 4);
+function eachSeries(coll, iteratee, callback) {
+  return eachLimit$1(coll, 1, iteratee, callback);
+}
+var eachSeries$1 = awaitify(eachSeries, 3);
+function ensureAsync(fn) {
+  if (isAsync(fn)) return fn;
+  return function(...args) {
+    var callback = args.pop();
+    var sync = true;
+    args.push((...innerArgs) => {
+      if (sync) {
+        setImmediate$1(() => callback(...innerArgs));
+      } else {
+        callback(...innerArgs);
+      }
+    });
+    fn.apply(this, args);
+    sync = false;
+  };
+}
+function every(coll, iteratee, callback) {
+  return _createTester((bool) => !bool, (res) => !res)(eachOf$1, coll, iteratee, callback);
+}
+var every$1 = awaitify(every, 3);
+function everyLimit(coll, limit, iteratee, callback) {
+  return _createTester((bool) => !bool, (res) => !res)(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+var everyLimit$1 = awaitify(everyLimit, 4);
+function everySeries(coll, iteratee, callback) {
+  return _createTester((bool) => !bool, (res) => !res)(eachOfSeries$1, coll, iteratee, callback);
+}
+var everySeries$1 = awaitify(everySeries, 3);
+function filterArray(eachfn, arr, iteratee, callback) {
+  var truthValues = new Array(arr.length);
+  eachfn(arr, (x, index, iterCb) => {
+    iteratee(x, (err, v) => {
+      truthValues[index] = !!v;
+      iterCb(err);
+    });
+  }, (err) => {
+    if (err) return callback(err);
+    var results = [];
+    for (var i = 0; i < arr.length; i++) {
+      if (truthValues[i]) results.push(arr[i]);
+    }
+    callback(null, results);
+  });
+}
+function filterGeneric(eachfn, coll, iteratee, callback) {
+  var results = [];
+  eachfn(coll, (x, index, iterCb) => {
+    iteratee(x, (err, v) => {
+      if (err) return iterCb(err);
+      if (v) {
+        results.push({ index, value: x });
+      }
+      iterCb(err);
+    });
+  }, (err) => {
+    if (err) return callback(err);
+    callback(null, results.sort((a, b) => a.index - b.index).map((v) => v.value));
+  });
+}
+function _filter(eachfn, coll, iteratee, callback) {
+  var filter2 = isArrayLike(coll) ? filterArray : filterGeneric;
+  return filter2(eachfn, coll, wrapAsync(iteratee), callback);
+}
+function filter(coll, iteratee, callback) {
+  return _filter(eachOf$1, coll, iteratee, callback);
+}
+var filter$1 = awaitify(filter, 3);
+function filterLimit(coll, limit, iteratee, callback) {
+  return _filter(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+var filterLimit$1 = awaitify(filterLimit, 4);
+function filterSeries(coll, iteratee, callback) {
+  return _filter(eachOfSeries$1, coll, iteratee, callback);
+}
+var filterSeries$1 = awaitify(filterSeries, 3);
+function forever(fn, errback) {
+  var done = onlyOnce(errback);
+  var task = wrapAsync(ensureAsync(fn));
+  function next(err) {
+    if (err) return done(err);
+    if (err === false) return;
+    task(next);
+  }
+  return next();
+}
+var forever$1 = awaitify(forever, 2);
+function groupByLimit(coll, limit, iteratee, callback) {
+  var _iteratee = wrapAsync(iteratee);
+  return mapLimit$1(coll, limit, (val, iterCb) => {
+    _iteratee(val, (err, key) => {
+      if (err) return iterCb(err);
+      return iterCb(err, { key, val });
+    });
+  }, (err, mapResults) => {
+    var result = {};
+    var { hasOwnProperty } = Object.prototype;
+    for (var i = 0; i < mapResults.length; i++) {
+      if (mapResults[i]) {
+        var { key } = mapResults[i];
+        var { val } = mapResults[i];
+        if (hasOwnProperty.call(result, key)) {
+          result[key].push(val);
+        } else {
+          result[key] = [val];
+        }
+      }
+    }
+    return callback(err, result);
+  });
+}
+var groupByLimit$1 = awaitify(groupByLimit, 4);
+var log2 = consoleFunc("log");
+function mapValuesLimit(obj, limit, iteratee, callback) {
+  callback = once(callback);
+  var newObj = {};
+  var _iteratee = wrapAsync(iteratee);
+  return eachOfLimit$2(limit)(obj, (val, key, next) => {
+    _iteratee(val, key, (err, result) => {
+      if (err) return next(err);
+      newObj[key] = result;
+      next(err);
+    });
+  }, (err) => callback(err, newObj));
+}
+var mapValuesLimit$1 = awaitify(mapValuesLimit, 4);
+var _defer;
+if (hasNextTick) {
+  _defer = process.nextTick;
+} else if (hasSetImmediate) {
+  _defer = setImmediate;
+} else {
+  _defer = fallback;
+}
+var nextTick = wrap(_defer);
+var _parallel = awaitify((eachfn, tasks, callback) => {
+  var results = isArrayLike(tasks) ? [] : {};
+  eachfn(tasks, (task, key, taskCb) => {
+    wrapAsync(task)((err, ...result) => {
+      if (result.length < 2) {
+        [result] = result;
+      }
+      results[key] = result;
+      taskCb(err);
+    });
+  }, (err) => callback(err, results));
+}, 3);
+function queue(worker, concurrency) {
+  var _worker = wrapAsync(worker);
+  return queue$1((items, cb) => {
+    _worker(items[0], cb);
+  }, concurrency, 1);
+}
+function race(tasks, callback) {
+  callback = once(callback);
+  if (!Array.isArray(tasks)) return callback(new TypeError("First argument to race must be an array of functions"));
+  if (!tasks.length) return callback();
+  for (var i = 0, l = tasks.length; i < l; i++) {
+    wrapAsync(tasks[i])(callback);
+  }
+}
+var race$1 = awaitify(race, 2);
+function reject$2(eachfn, arr, _iteratee, callback) {
+  const iteratee = wrapAsync(_iteratee);
+  return _filter(eachfn, arr, (value, cb) => {
+    iteratee(value, (err, v) => {
+      cb(err, !v);
+    });
+  }, callback);
+}
+function reject(coll, iteratee, callback) {
+  return reject$2(eachOf$1, coll, iteratee, callback);
+}
+var reject$1 = awaitify(reject, 3);
+function rejectLimit(coll, limit, iteratee, callback) {
+  return reject$2(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+var rejectLimit$1 = awaitify(rejectLimit, 4);
+function rejectSeries(coll, iteratee, callback) {
+  return reject$2(eachOfSeries$1, coll, iteratee, callback);
+}
+var rejectSeries$1 = awaitify(rejectSeries, 3);
+function some(coll, iteratee, callback) {
+  return _createTester(Boolean, (res) => res)(eachOf$1, coll, iteratee, callback);
+}
+var some$1 = awaitify(some, 3);
+function someLimit(coll, limit, iteratee, callback) {
+  return _createTester(Boolean, (res) => res)(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+var someLimit$1 = awaitify(someLimit, 4);
+function someSeries(coll, iteratee, callback) {
+  return _createTester(Boolean, (res) => res)(eachOfSeries$1, coll, iteratee, callback);
+}
+var someSeries$1 = awaitify(someSeries, 3);
+function sortBy(coll, iteratee, callback) {
+  var _iteratee = wrapAsync(iteratee);
+  return map$1(coll, (x, iterCb) => {
+    _iteratee(x, (err, criteria) => {
+      if (err) return iterCb(err);
+      iterCb(err, { value: x, criteria });
+    });
+  }, (err, results) => {
+    if (err) return callback(err);
+    callback(null, results.sort(comparator).map((v) => v.value));
+  });
+  function comparator(left, right) {
+    var a = left.criteria, b = right.criteria;
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+}
+var sortBy$1 = awaitify(sortBy, 3);
+function tryEach(tasks, callback) {
+  var error = null;
+  var result;
+  return eachSeries$1(tasks, (task, taskCb) => {
+    wrapAsync(task)((err, ...args) => {
+      if (err === false) return taskCb(err);
+      if (args.length < 2) {
+        [result] = args;
+      } else {
+        result = args;
+      }
+      error = err;
+      taskCb(err ? null : {});
+    });
+  }, () => callback(error, result));
+}
+var tryEach$1 = awaitify(tryEach);
+function whilst(test, iteratee, callback) {
+  callback = onlyOnce(callback);
+  var _fn = wrapAsync(iteratee);
+  var _test = wrapAsync(test);
+  var results = [];
+  function next(err, ...rest) {
+    if (err) return callback(err);
+    results = rest;
+    if (err === false) return;
+    _test(check);
+  }
+  function check(err, truth) {
+    if (err) return callback(err);
+    if (err === false) return;
+    if (!truth) return callback(null, ...results);
+    _fn(next);
+  }
+  return _test(check);
+}
+var whilst$1 = awaitify(whilst, 3);
+function waterfall(tasks, callback) {
+  callback = once(callback);
+  if (!Array.isArray(tasks)) return callback(new Error("First argument to waterfall must be an array of functions"));
+  if (!tasks.length) return callback();
+  var taskIndex = 0;
+  function nextTask(args) {
+    var task = wrapAsync(tasks[taskIndex++]);
+    task(...args, onlyOnce(next));
+  }
+  function next(err, ...args) {
+    if (err === false) return;
+    if (err || taskIndex === tasks.length) {
+      return callback(err, ...args);
+    }
+    nextTask(args);
+  }
+  nextTask([]);
+}
+var waterfall$1 = awaitify(waterfall);
+
+// src/reporters/progress.ts
+var SimpleProgressReporter = class {
+  start(name, _total) {
+    console.log(`Running evaluator ${name}`);
+  }
+  stop() {
+  }
+  increment(_name) {
+  }
+  setTotal(_name, _total) {
+  }
+};
+
+// src/eval-parameters.ts
+
+
+// src/framework2.ts
+
+var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
+var ProjectBuilder = class {
+  create(opts) {
+    return new Project2(opts);
+  }
+};
+var projects = new ProjectBuilder();
+var Project2 = (_class16 = class {
+  
+  
+  
+  
+  
+  __init52() {this._publishableCodeFunctions = []}
+  __init53() {this._publishablePrompts = []}
+  constructor(args) {;_class16.prototype.__init52.call(this);_class16.prototype.__init53.call(this);
+    _initializeSpanContext();
+    this.name = "name" in args ? args.name : void 0;
+    this.id = "id" in args ? args.id : void 0;
+    this.tools = new ToolBuilder(this);
+    this.prompts = new PromptBuilder(this);
+    this.scorers = new ScorerBuilder(this);
+  }
+  addPrompt(prompt) {
+    this._publishablePrompts.push(prompt);
+    if (globalThis._lazy_load) {
+      globalThis._evals.prompts.push(prompt);
+    }
+  }
+  addCodeFunction(fn) {
+    this._publishableCodeFunctions.push(fn);
+    if (globalThis._lazy_load) {
+      globalThis._evals.functions.push(fn);
+    }
+  }
+  async publish() {
+    if (globalThis._lazy_load) {
+      console.warn("publish() is a no-op when running `braintrust push`.");
+      return;
+    }
+    await login();
+    const projectMap = new ProjectNameIdMap();
+    const functionDefinitions = [];
+    if (this._publishableCodeFunctions.length > 0) {
+      console.warn(
+        "Code functions cannot be published directly. Use `braintrust push` instead."
+      );
+    }
+    if (this._publishablePrompts.length > 0) {
+      for (const prompt of this._publishablePrompts) {
+        const functionDefinition = await prompt.toFunctionDefinition(projectMap);
+        functionDefinitions.push(functionDefinition);
+      }
+    }
+    await _internalGetGlobalState().apiConn().post_json("insert-functions", {
+      functions: functionDefinitions
+    });
+  }
+}, _class16);
+var ToolBuilder = (_class17 = class {
+  constructor(project) {;_class17.prototype.__init54.call(this);
+    this.project = project;
+  }
+  __init54() {this.taskCounter = 0}
+  // This type definition is just a catch all so that the implementation can be
+  // less specific than the two more specific declarations above.
+  create(opts) {
+    this.taskCounter++;
+    opts = _nullishCoalesce(opts, () => ( {}));
+    const { handler, name, slug, parameters, returns, ...rest } = opts;
+    let resolvedName = _nullishCoalesce(name, () => ( handler.name));
+    if (resolvedName.trim().length === 0) {
+      resolvedName = `Tool ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+    }
+    const tool = new CodeFunction(this.project, {
+      handler,
+      name: resolvedName,
+      slug: _nullishCoalesce(slug, () => ( slugify(resolvedName, { lower: true, strict: true }))),
+      type: "tool",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
+      parameters,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
+      returns,
+      ...rest
+    });
+    this.project.addCodeFunction(tool);
+    return tool;
+  }
+}, _class17);
+var ScorerBuilder = (_class18 = class {
+  constructor(project) {;_class18.prototype.__init55.call(this);
+    this.project = project;
+  }
+  __init55() {this.taskCounter = 0}
+  create(opts) {
+    this.taskCounter++;
+    let resolvedName = opts.name;
+    if (!resolvedName && "handler" in opts) {
+      resolvedName = opts.handler.name;
+    }
+    if (!resolvedName || resolvedName.trim().length === 0) {
+      resolvedName = `Scorer ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+    }
+    const slug = _nullishCoalesce(opts.slug, () => ( slugify(resolvedName, { lower: true, strict: true })));
+    if ("handler" in opts) {
+      const scorer = new CodeFunction(this.project, {
+        ...opts,
+        name: resolvedName,
+        slug,
+        type: "scorer"
+      });
+      this.project.addCodeFunction(scorer);
+    } else {
+      const promptBlock = "messages" in opts ? {
+        type: "chat",
+        messages: opts.messages
+      } : {
+        type: "completion",
+        content: opts.prompt
+      };
+      const promptData = {
+        prompt: promptBlock,
+        options: {
+          model: opts.model,
+          params: opts.params
+        },
+        parser: {
+          type: "llm_classifier",
+          use_cot: opts.useCot,
+          choice_scores: opts.choiceScores
+        }
+      };
+      const codePrompt = new CodePrompt(
+        this.project,
+        promptData,
+        [],
+        {
+          ...opts,
+          name: resolvedName,
+          slug
+        },
+        "scorer"
+      );
+      this.project.addPrompt(codePrompt);
+    }
+  }
+}, _class18);
+var CodeFunction = class {
+  constructor(project, opts) {
+    this.project = project;
+    this.handler = opts.handler;
+    this.name = opts.name;
+    this.slug = opts.slug;
+    this.description = opts.description;
+    this.type = opts.type;
+    this.ifExists = opts.ifExists;
+    this.metadata = opts.metadata;
+    this.parameters = opts.parameters;
+    this.returns = opts.returns;
+    if (this.returns && !this.parameters) {
+      throw new Error("parameters are required if return type is defined");
+    }
+  }
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  key() {
+    return JSON.stringify([
+      _nullishCoalesce(this.project.id, () => ( "")),
+      _nullishCoalesce(this.project.name, () => ( "")),
+      this.slug
+    ]);
+  }
+};
+var CodePrompt = class {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  constructor(project, prompt, toolFunctions, opts, functionType) {
+    this.project = project;
+    this.name = opts.name;
+    this.slug = opts.slug;
+    this.prompt = prompt;
+    this.toolFunctions = toolFunctions;
+    this.ifExists = opts.ifExists;
+    this.description = opts.description;
+    this.id = opts.id;
+    this.functionType = functionType;
+    this.metadata = opts.metadata;
+  }
+  async toFunctionDefinition(projectNameToId) {
+    const prompt_data = {
+      ...this.prompt
+    };
+    if (this.toolFunctions.length > 0) {
+      const resolvableToolFunctions = await Promise.all(
+        this.toolFunctions.map(async (fn) => {
+          if ("slug" in fn) {
+            return {
+              type: "slug",
+              project_id: await projectNameToId.resolve(fn.project),
+              slug: fn.slug
+            };
+          } else {
+            return fn;
+          }
+        })
+      );
+      prompt_data.tool_functions = // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      resolvableToolFunctions;
+    }
+    return {
+      project_id: await projectNameToId.resolve(this.project),
+      name: this.name,
+      slug: this.slug,
+      description: _nullishCoalesce(this.description, () => ( "")),
+      function_data: {
+        type: "prompt"
+      },
+      function_type: this.functionType,
+      prompt_data,
+      if_exists: this.ifExists,
+      metadata: this.metadata
+    };
+  }
+};
+var promptContentsSchema = _v3.z.union([
+  _v3.z.object({
+    prompt: _v3.z.string()
+  }),
+  _v3.z.object({
+    messages: _v3.z.array(ChatCompletionMessageParam)
+  })
+]);
+var promptDefinitionSchema = promptContentsSchema.and(
+  _v3.z.object({
+    model: _v3.z.string(),
+    params: ModelParams.optional()
+  })
+);
+var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
+  _v3.z.object({
+    tools: _v3.z.array(ToolFunctionDefinition).optional()
+  })
+);
+var PromptBuilder = class {
+  constructor(project) {
+    this.project = project;
+  }
+  create(opts) {
+    const toolFunctions = [];
+    const rawTools = [];
+    for (const tool of _nullishCoalesce(opts.tools, () => ( []))) {
+      if (tool instanceof CodeFunction) {
+        toolFunctions.push(tool);
+      } else if ("type" in tool && !("function" in tool)) {
+        toolFunctions.push(tool);
+      } else {
+        rawTools.push(tool);
+      }
+    }
+    const slug = _nullishCoalesce(opts.slug, () => ( slugify(opts.name, { lower: true, strict: true })));
+    const promptData = promptDefinitionToPromptData(opts, rawTools);
+    const promptRow = {
+      id: opts.id,
+      _xact_id: opts.version ? loadPrettyXact(opts.version) : void 0,
+      name: opts.name,
+      slug,
+      prompt_data: promptData,
+      ...this.project.id !== void 0 ? { project_id: this.project.id } : {}
+    };
+    const prompt = new Prompt2(
+      promptRow,
+      {},
+      // It doesn't make sense to specify defaults here.
+      _nullishCoalesce(opts.noTrace, () => ( false))
+    );
+    const codePrompt = new CodePrompt(this.project, promptData, toolFunctions, {
+      ...opts,
+      slug
+    });
+    this.project.addPrompt(codePrompt);
+    return prompt;
+  }
+};
+function promptDefinitionToPromptData(promptDefinition, rawTools) {
+  const promptBlock = "messages" in promptDefinition ? {
+    type: "chat",
+    messages: promptDefinition.messages,
+    tools: rawTools && rawTools.length > 0 ? JSON.stringify(rawTools) : void 0
+  } : {
+    type: "completion",
+    content: promptDefinition.prompt
+  };
+  return {
+    prompt: promptBlock,
+    options: {
+      model: promptDefinition.model,
+      params: promptDefinition.params
+    }
+  };
+}
+var ProjectNameIdMap = (_class19 = class {constructor() { _class19.prototype.__init56.call(this);_class19.prototype.__init57.call(this); }
+  __init56() {this.nameToId = {}}
+  __init57() {this.idToName = {}}
+  async getId(projectName) {
+    if (!(projectName in this.nameToId)) {
+      const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
+        project_name: projectName
+      });
+      const result = _v3.z.object({
+        project: Project
+      }).parse(response);
+      const projectId = result.project.id;
+      this.nameToId[projectName] = projectId;
+      this.idToName[projectId] = projectName;
+    }
+    return this.nameToId[projectName];
+  }
+  async getName(projectId) {
+    if (!(projectId in this.idToName)) {
+      const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
+        id: projectId
+      });
+      const result = _v3.z.array(Project).nonempty().parse(response);
+      const projectName = result[0].name;
+      this.idToName[projectId] = projectName;
+      this.nameToId[projectName] = projectId;
+    }
+    return this.idToName[projectId];
+  }
+  async resolve(project) {
+    if (project.id) {
+      return project.id;
+    }
+    return this.getId(project.name);
+  }
+}, _class19);
+
+// src/eval-parameters.ts
+var evalParametersSchema = _v3.z.record(
+  _v3.z.string(),
+  _v3.z.union([
+    _v3.z.object({
+      type: _v3.z.literal("prompt"),
+      default: promptDefinitionWithToolsSchema.optional(),
+      description: _v3.z.string().optional()
+    }),
+    _v3.z.instanceof(_v3.z.ZodType)
+    // For Zod schemas
+  ])
+);
+function validateParameters(parameters, parameterSchema) {
+  return Object.fromEntries(
+    Object.entries(parameterSchema).map(([name, schema]) => {
+      const value = parameters[name];
+      try {
+        if ("type" in schema && schema.type === "prompt") {
+          const promptData = value ? PromptData.parse(value) : schema.default ? promptDefinitionToPromptData(
+            schema.default,
+            schema.default.tools
+          ) : void 0;
+          if (!promptData) {
+            throw new Error(`Parameter '${name}' is required`);
+          }
+          return [name, Prompt2.fromPromptData(name, promptData)];
+        } else {
+          const schemaCasted = schema;
+          return [name, schemaCasted.parse(value)];
+        }
+      } catch (e) {
+        console.error("Error validating parameter", name, e);
+        throw Error(
+          `Invalid parameter '${name}': ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    })
+  );
+}
+
+// src/framework.ts
+function BaseExperiment(options = {}) {
+  return { _type: "BaseExperiment", ...options };
+}
+var EvalResultWithSummary = class {
+  constructor(summary, results) {
+    this.summary = summary;
+    this.results = results;
+  }
+  /**
+   * @deprecated Use `summary` instead.
+   */
+  toString() {
+    return JSON.stringify(this.summary);
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `EvalResultWithSummary(summary="...", results=[...])`;
+  }
+  toJSON() {
+    return {
+      summary: this.summary,
+      results: this.results
+    };
+  }
+};
+function makeEvalName(projectName, experimentName) {
+  let out = projectName;
+  if (experimentName) {
+    out += ` [experimentName=${experimentName}]`;
+  }
+  return out;
+}
+function initExperiment2(state, options = {}) {
+  return init({
+    state,
+    ...options,
+    setCurrent: false
+  });
+}
+function callEvaluatorData(data) {
+  const dataResult = typeof data === "function" ? data() : data;
+  let baseExperiment = void 0;
+  if ("_type" in dataResult && dataResult._type === "BaseExperiment") {
+    baseExperiment = dataResult.name;
+  }
+  return {
+    data: dataResult,
+    baseExperiment
+  };
+}
+function isAsyncIterable2(value) {
+  return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
+}
+function isIterable(value) {
+  return typeof value === "object" && value !== null && typeof value[Symbol.iterator] === "function";
+}
+globalThis._evals = {
+  functions: [],
+  prompts: [],
+  evaluators: {},
+  reporters: {}
+};
+function _initializeSpanContext() {
+  globalThis._spanContext = { currentSpan, withCurrent, startSpan, NOOP_SPAN };
+}
+async function Eval(name, evaluator, 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}`;
+  }
+  if (globalThis._lazy_load) {
+    globalThis._evals.evaluators[evalName] = {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      evaluator: {
+        evalName,
+        projectName: name,
+        ...evaluator
+      },
+      reporter: options.reporter
+    };
+    _initializeSpanContext();
+    return new EvalResultWithSummary(
+      {
+        scores: {},
+        metrics: {},
+        projectName: "",
+        experimentName: ""
+      },
+      []
+    );
+  }
+  const progressReporter = _nullishCoalesce(options.progress, () => ( new SimpleProgressReporter()));
+  const shouldCollectResults = _nullishCoalesce(options.returnResults, () => ( true));
+  if (typeof options.reporter === "string") {
+    throw new Error(
+      "Must specify a reporter object, not a name. Can only specify reporter names when running 'braintrust eval'"
+    );
+  }
+  const resolvedReporter = options.reporter || defaultReporter;
+  try {
+    const { data, baseExperiment: defaultBaseExperiment } = callEvaluatorData(
+      evaluator.data
+    );
+    const experiment = options.parent || options.noSendLogs ? null : initExperiment2(evaluator.state, {
+      ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: name },
+      experiment: evaluator.experimentName,
+      description: evaluator.description,
+      metadata: evaluator.metadata,
+      isPublic: evaluator.isPublic,
+      update: evaluator.update,
+      baseExperiment: _nullishCoalesce(evaluator.baseExperimentName, () => ( defaultBaseExperiment)),
+      baseExperimentId: evaluator.baseExperimentId,
+      gitMetadataSettings: evaluator.gitMetadataSettings,
+      repoInfo: evaluator.repoInfo,
+      dataset: Dataset2.isDataset(data) ? data : void 0
+    });
+    if (experiment && typeof process !== "undefined" && globalThis.BRAINTRUST_CONTEXT_MANAGER !== void 0) {
+      await experiment._waitForId();
+    }
+    if (experiment && options.onStart) {
+      const summary = await experiment.summarize({ summarizeScores: false });
+      options.onStart(summary);
+    }
+    try {
+      const evalDef = {
+        evalName,
+        projectName: name,
+        ...evaluator,
+        data
+      };
+      let ret;
+      if (options.parent) {
+        ret = await withParent(
+          options.parent,
+          () => runEvaluator(
+            null,
+            evalDef,
+            progressReporter,
+            [],
+            options.stream,
+            options.parameters,
+            shouldCollectResults
+          ),
+          evaluator.state
+        );
+      } else {
+        ret = await runEvaluator(
+          experiment,
+          evalDef,
+          progressReporter,
+          [],
+          options.stream,
+          options.parameters,
+          shouldCollectResults
+        );
+      }
+      progressReporter.stop();
+      resolvedReporter.reportEval(evalDef, ret, {
+        verbose: true,
+        jsonl: false
+      });
+      return ret;
+    } finally {
+      if (experiment) {
+        await experiment.flush().catch(console.error);
+      } else if (options.parent) {
+        await flush().catch(console.error);
+      }
+    }
+  } finally {
+    progressReporter.stop();
+  }
+}
+function Reporter(name, reporter) {
+  const ret = { name, ...reporter };
+  if (_evals.reporters[name]) {
+    throw new Error(`Reporter ${name} already exists`);
+  }
+  if (globalThis._lazy_load) {
+    _evals.reporters[name] = ret;
+  }
+  return ret;
+}
+function serializeJSONWithPlainString(v) {
+  if (typeof v === "string") {
+    return v;
+  } else {
+    return JSON.stringify(v);
+  }
+}
+function evaluateFilter(object, filter2) {
+  const { path, pattern } = filter2;
+  const key = path.reduce(
+    (acc, p) => typeof acc === "object" && acc !== null ? (
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      acc[p]
+    ) : void 0,
+    object
+  );
+  if (key === void 0) {
+    return false;
+  }
+  return pattern.test(serializeJSONWithPlainString(key));
+}
+function scorerName(scorer, scorer_idx) {
+  return scorer.name || `scorer_${scorer_idx}`;
+}
+async function runEvaluator(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults = true) {
+  return await runEvaluatorInternal(
+    experiment,
+    evaluator,
+    progressReporter,
+    filters,
+    stream,
+    parameters,
+    collectResults
+  );
+}
+var defaultErrorScoreHandler = ({
+  rootSpan,
+  data: _,
+  unhandledScores
+}) => {
+  const scores = Object.fromEntries(unhandledScores.map((s) => [s, 0]));
+  rootSpan.log({ scores });
+  return scores;
+};
+async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults) {
+  if (typeof evaluator.data === "string") {
+    throw new Error("Unimplemented: string data paths");
+  }
+  let dataResult = typeof evaluator.data === "function" ? evaluator.data() : evaluator.data;
+  parameters = validateParameters(_nullishCoalesce(parameters, () => ( {})), _nullishCoalesce(evaluator.parameters, () => ( {})));
+  if ("_type" in dataResult) {
+    if (dataResult._type !== "BaseExperiment") {
+      throw new Error("Invalid _type");
+    }
+    if (!experiment) {
+      throw new Error(
+        "Cannot use BaseExperiment() without connecting to Braintrust (you most likely set --no-send-logs)"
+      );
+    }
+    let name = dataResult.name;
+    if (isEmpty2(name)) {
+      const baseExperiment = await experiment.fetchBaseExperiment();
+      if (!baseExperiment) {
+        throw new Error("BaseExperiment() failed to fetch base experiment");
+      }
+      name = baseExperiment.name;
+    }
+    dataResult = initExperiment2(evaluator.state, {
+      ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: evaluator.projectName },
+      experiment: name,
+      open: true
+    }).asDataset();
+  }
+  const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
+  const dataIterable = (() => {
+    if (isAsyncIterable2(resolvedDataResult)) {
+      return resolvedDataResult;
+    }
+    if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
+      const iterable = resolvedDataResult;
+      return (async function* () {
+        for (const datum of iterable) {
+          yield datum;
+        }
+      })();
+    }
+    throw new Error(
+      "Evaluator data must be an array, iterable, or async iterable"
+    );
+  })();
+  progressReporter.start(evaluator.evalName, 0);
+  const collectedResults = [];
+  const localScoreAccumulator = experiment ? null : {};
+  let cancelled = false;
+  let scheduledTrials = 0;
+  const q = queue(
+    async ({
+      datum,
+      trialIndex
+    }) => {
+      if (cancelled) {
+        return;
+      }
+      const eventDataset = experiment ? experiment.dataset : Dataset2.isDataset(evaluator.data) ? evaluator.data : void 0;
+      const baseEvent = {
+        name: "eval",
+        spanAttributes: {
+          type: "eval" /* EVAL */
+        },
+        event: {
+          input: datum.input,
+          expected: "expected" in datum ? datum.expected : void 0,
+          tags: datum.tags,
+          origin: eventDataset && datum.id && datum._xact_id ? {
+            object_type: "dataset",
+            object_id: await eventDataset.id,
+            id: datum.id,
+            created: datum.created,
+            _xact_id: datum._xact_id
+          } : void 0,
+          ...datum.upsert_id ? { id: datum.upsert_id } : {}
+        }
+      };
+      const callback = async (rootSpan) => {
+        let metadata = {
+          ..."metadata" in datum ? datum.metadata : {}
+        };
+        const expected = "expected" in datum ? datum.expected : void 0;
+        let output = void 0;
+        let error = void 0;
+        let tags = [..._nullishCoalesce(datum.tags, () => ( []))];
+        const scores = {};
+        const scorerNames = evaluator.scores.map(scorerName);
+        let unhandledScores = scorerNames;
+        try {
+          const meta = (o) => metadata = { ...metadata, ...o };
+          await rootSpan.traced(
+            async (span) => {
+              const hooksForTask = {
+                meta,
+                metadata,
+                expected,
+                span,
+                parameters: _nullishCoalesce(parameters, () => ( {})),
+                reportProgress: (event) => {
+                  _optionalChain([stream, 'optionalCall', _234 => _234({
+                    ...event,
+                    id: rootSpan.id,
+                    origin: _optionalChain([baseEvent, 'access', _235 => _235.event, 'optionalAccess', _236 => _236.origin]),
+                    name: evaluator.evalName,
+                    object_type: "task"
+                  })]);
+                },
+                trialIndex,
+                tags
+              };
+              const outputResult = evaluator.task(datum.input, hooksForTask);
+              if (outputResult instanceof Promise) {
+                output = await outputResult;
+              } else {
+                output = outputResult;
+              }
+              tags = _nullishCoalesce(hooksForTask.tags, () => ( []));
+              span.log({ output });
+            },
+            {
+              name: "task",
+              spanAttributes: { type: "task" /* TASK */ },
+              event: { input: datum.input }
+            }
+          );
+          if (tags.length) {
+            rootSpan.log({ output, metadata, expected, tags });
+          } else {
+            rootSpan.log({ output, metadata, expected });
+          }
+          const scoringArgs = {
+            input: datum.input,
+            expected: "expected" in datum ? datum.expected : void 0,
+            metadata,
+            output
+          };
+          const scoreResults = await Promise.all(
+            evaluator.scores.map(async (score, score_idx) => {
+              try {
+                const runScorer = async (span) => {
+                  const scoreResult = score(scoringArgs);
+                  const scoreValue = scoreResult instanceof Promise ? await scoreResult : scoreResult;
+                  if (scoreValue === null) {
+                    return null;
+                  }
+                  if (Array.isArray(scoreValue)) {
+                    for (const s of scoreValue) {
+                      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
+                          )}`
+                        );
+                      }
+                    }
+                  }
+                  const results2 = Array.isArray(scoreValue) ? scoreValue : typeof scoreValue === "object" && !isEmpty2(scoreValue) ? [scoreValue] : [
+                    {
+                      name: scorerNames[score_idx],
+                      score: scoreValue
+                    }
+                  ];
+                  const getOtherFields = (s) => {
+                    const { metadata: _metadata, name: _name, ...rest } = s;
+                    return rest;
+                  };
+                  const resultMetadata = results2.length === 1 ? results2[0].metadata : results2.reduce(
+                    (prev, s) => mergeDicts(prev, {
+                      [s.name]: s.metadata
+                    }),
+                    {}
+                  );
+                  const resultOutput = results2.length === 1 ? getOtherFields(results2[0]) : results2.reduce(
+                    (prev, s) => mergeDicts(prev, { [s.name]: getOtherFields(s) }),
+                    {}
+                  );
+                  const scores2 = results2.reduce(
+                    (prev, s) => mergeDicts(prev, { [s.name]: s.score }),
+                    {}
+                  );
+                  span.log({
+                    output: resultOutput,
+                    metadata: resultMetadata,
+                    scores: scores2
+                  });
+                  return results2;
+                };
+                const results = await rootSpan.traced(runScorer, {
+                  name: scorerNames[score_idx],
+                  spanAttributes: {
+                    type: "score" /* SCORE */
+                  },
+                  event: { input: scoringArgs }
+                });
+                return { kind: "score", value: results };
+              } catch (e) {
+                return { kind: "error", value: e };
+              }
+            })
+          );
+          const failingScorersAndResults = [];
+          scoreResults.forEach((results, i) => {
+            const name = scorerNames[i];
+            if (results.kind === "score") {
+              (results.value || []).forEach((result) => {
+                scores[result.name] = result.score;
+              });
+            } else {
+              failingScorersAndResults.push({ name, error: results.value });
+            }
+          });
+          unhandledScores = null;
+          if (failingScorersAndResults.length) {
+            const scorerErrors = Object.fromEntries(
+              failingScorersAndResults.map(({ name, error: error2 }) => [
+                name,
+                error2 instanceof Error ? error2.stack : `${error2}`
+              ])
+            );
+            metadata["scorer_errors"] = scorerErrors;
+            rootSpan.log({
+              metadata: { scorer_errors: scorerErrors }
+            });
+            const names = Object.keys(scorerErrors).join(", ");
+            const errors = failingScorersAndResults.map((item) => item.error);
+            unhandledScores = Object.keys(scorerErrors);
+            console.warn(
+              `Found exceptions for the following scorers: ${names}`,
+              errors
+            );
+          }
+        } catch (e) {
+          logError(rootSpan, e);
+          error = e;
+        } finally {
+          progressReporter.increment(evaluator.evalName);
+        }
+        const mergedScores = {
+          ...evaluator.errorScoreHandler && unhandledScores ? evaluator.errorScoreHandler({
+            rootSpan,
+            data: datum,
+            unhandledScores
+          }) : void 0,
+          ...scores
+        };
+        if (localScoreAccumulator) {
+          accumulateScores(localScoreAccumulator, mergedScores);
+        }
+        if (collectResults) {
+          collectedResults.push({
+            input: datum.input,
+            ..."expected" in datum ? { expected: datum.expected } : {},
+            output,
+            tags: tags.length ? tags : void 0,
+            metadata,
+            scores: mergedScores,
+            error,
+            origin: _optionalChain([baseEvent, 'access', _237 => _237.event, 'optionalAccess', _238 => _238.origin])
+          });
+        }
+      };
+      if (!experiment) {
+        return await traced(callback, {
+          ...baseEvent,
+          state: evaluator.state
+        });
+      } else {
+        const result = await experiment.traced(callback, baseEvent);
+        if (evaluator.maxConcurrency !== void 0) {
+          await experiment.flush();
+        }
+        return result;
+      }
+    },
+    Math.max(_nullishCoalesce(evaluator.maxConcurrency, () => ( Number.MAX_SAFE_INTEGER)), 1)
+  );
+  const enqueuePromise = (async () => {
+    for await (const datum of dataIterable) {
+      if (cancelled) {
+        break;
+      }
+      if (!filters.every((f) => evaluateFilter(datum, f))) {
+        continue;
+      }
+      const trialCount = _nullishCoalesce(evaluator.trialCount, () => ( 1));
+      for (let trialIndex = 0; trialIndex < trialCount; trialIndex++) {
+        if (cancelled) {
+          break;
+        }
+        scheduledTrials++;
+        _optionalChain([progressReporter, 'access', _239 => _239.setTotal, 'optionalCall', _240 => _240(evaluator.evalName, scheduledTrials)]);
+        q.push({ datum, trialIndex });
+      }
+    }
+  })();
+  const cancel = async () => {
+    await new Promise((_, reject2) => {
+      if (cancelled) {
+        reject2(new InternalAbortError("Evaluator already cancelled"));
+        return;
+      }
+      let timeoutId;
+      let abortHandler;
+      const rejectOnce = (error) => {
+        if (cancelled) {
+          return;
+        }
+        cancelled = true;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = void 0;
+        }
+        if (abortHandler && evaluator.signal) {
+          evaluator.signal.removeEventListener("abort", abortHandler);
+        }
+        reject2(error);
+      };
+      if (evaluator.timeout) {
+        timeoutId = setTimeout(() => {
+          rejectOnce(new InternalAbortError("Evaluator timed out"));
+        }, evaluator.timeout);
+      }
+      if (evaluator.signal) {
+        abortHandler = () => {
+          rejectOnce(new InternalAbortError("Evaluator aborted"));
+        };
+        evaluator.signal.addEventListener("abort", abortHandler);
+      }
+    });
+  };
+  const waitForQueue = (async () => {
+    await enqueuePromise;
+    if (q.idle()) {
+      return;
+    }
+    await q.drain();
+  })();
+  try {
+    await Promise.race([waitForQueue, cancel()]);
+  } catch (e) {
+    q.kill();
+    if (e instanceof InternalAbortError) {
+      if (isomorph_default.getEnv("BRAINTRUST_VERBOSE")) {
+        console.warn("Evaluator cancelled:", e.message);
+      }
+    }
+    throw e;
+  } finally {
+    if (!collectResults) {
+      collectedResults.length = 0;
+    }
+  }
+  const summary = experiment ? await experiment.summarize({ summarizeScores: evaluator.summarizeScores }) : buildLocalSummary(
+    evaluator,
+    collectResults ? collectedResults : [],
+    _nullishCoalesce(localScoreAccumulator, () => ( void 0))
+  );
+  return new EvalResultWithSummary(
+    summary,
+    collectResults ? collectedResults : []
+  );
+}
+var warning = (text) => `Warning: ${text}`;
+function logError2(e, verbose) {
+  if (!verbose) {
+    console.error(`${e}`);
+  } else {
+    console.error(e);
+  }
+}
+function accumulateScores(accumulator, scores) {
+  for (const [name, score] of Object.entries(scores)) {
+    if (score === null || score === void 0) {
+      continue;
+    }
+    const existing = _nullishCoalesce(accumulator[name], () => ( { total: 0, count: 0 }));
+    accumulator[name] = {
+      total: existing.total + score,
+      count: existing.count + 1
+    };
+  }
+}
+function ensureScoreAccumulator(results) {
+  const accumulator = {};
+  for (const result of results) {
+    accumulateScores(accumulator, result.scores);
+  }
+  return accumulator;
+}
+function buildLocalSummary(evaluator, results, precomputedScores) {
+  const scoresByName = _nullishCoalesce(precomputedScores, () => ( ensureScoreAccumulator(results)));
+  return {
+    projectName: evaluator.projectName,
+    experimentName: evaluator.evalName,
+    scores: Object.fromEntries(
+      Object.entries(scoresByName).map(([name, { total, count }]) => [
+        name,
+        {
+          name,
+          score: count === 0 ? 0 : total / count,
+          improvements: 0,
+          regressions: 0
+        }
+      ])
+    )
+  };
+}
+function reportFailures(evaluator, failingResults, { verbose, jsonl }) {
+  if (failingResults.length > 0) {
+    console.error(
+      warning(
+        `Evaluator ${evaluator.evalName} failed with ${failingResults.length} error${failingResults.length === 1 ? "" : "s"}. This evaluation ("${evaluator.evalName}") will not be fully logged.`
+      )
+    );
+    if (jsonl) {
+      console.log(
+        JSON.stringify({
+          evaluatorName: evaluator.evalName,
+          errors: failingResults.map(
+            (r) => `${r.error instanceof Error ? r.error.stack : r.error}`
+          )
+        })
+      );
+    } else {
+      for (const result of failingResults) {
+        logError2(result.error, verbose);
+      }
+    }
+    if (!verbose && !jsonl) {
+      console.error(warning("Add --verbose to see full stack traces."));
+    }
+  }
+}
+var defaultReporter = {
+  name: "Braintrust default reporter",
+  async reportEval(evaluator, result, { verbose, jsonl }) {
+    const { results, summary } = result;
+    const failingResults = results.filter(
+      (r) => r.error !== void 0
+    );
+    if (failingResults.length > 0) {
+      reportFailures(evaluator, failingResults, { verbose, jsonl });
+    }
+    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(_nullishCoalesce(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(_nullishCoalesce(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);
+  }
+};
+
+// dev/types.ts
+
+var evalBodySchema = _v3.z.object({
+  name: _v3.z.string(),
+  parameters: _v3.z.record(_v3.z.string(), _v3.z.unknown()).nullish(),
+  data: RunEval.shape.data,
+  scores: _v3.z.array(
+    _v3.z.object({
+      function_id: FunctionId,
+      name: _v3.z.string()
+    })
+  ).nullish(),
+  experiment_name: _v3.z.string().nullish(),
+  project_id: _v3.z.string().nullish(),
+  parent: InvokeParent.optional(),
+  stream: _v3.z.boolean().optional()
+});
+var evalParametersSerializedSchema = _v3.z.record(
+  _v3.z.string(),
+  _v3.z.union([
+    _v3.z.object({
+      type: _v3.z.literal("prompt"),
+      default: PromptData.optional(),
+      description: _v3.z.string().optional()
+    }),
+    _v3.z.object({
+      type: _v3.z.literal("data"),
+      schema: _v3.z.record(_v3.z.unknown()),
+      // JSON Schema
+      default: _v3.z.unknown().optional(),
+      description: _v3.z.string().optional()
+    })
+  ])
+);
+var evaluatorDefinitionSchema = _v3.z.object({
+  parameters: evalParametersSerializedSchema.optional()
+});
+var evaluatorDefinitionsSchema = _v3.z.record(
+  _v3.z.string(),
+  evaluatorDefinitionSchema
+);
+
+// src/browser.ts
+configureBrowser();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -11565,4 +14186,4 @@ var browser_default = exports_browser_exports;
 
 
 
-exports.Attachment = Attachment; exports.BaseAttachment = BaseAttachment; exports.BraintrustMiddleware = BraintrustMiddleware; exports.BraintrustState = BraintrustState; exports.BraintrustStream = BraintrustStream; exports.ContextManager = ContextManager; exports.DEFAULT_FETCH_BATCH_SIZE = DEFAULT_FETCH_BATCH_SIZE; exports.Dataset = Dataset2; exports.ERR_PERMALINK = ERR_PERMALINK; exports.Experiment = Experiment2; exports.ExternalAttachment = ExternalAttachment; exports.FailedHTTPResponse = FailedHTTPResponse; exports.IDGenerator = IDGenerator; exports.JSONAttachment = JSONAttachment; exports.LEGACY_CACHED_HEADER = LEGACY_CACHED_HEADER; exports.LazyValue = LazyValue; exports.Logger = Logger; exports.LoginInvalidOrgError = LoginInvalidOrgError; exports.NOOP_SPAN = NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = NOOP_SPAN_PERMALINK; exports.NoopSpan = NoopSpan; exports.Prompt = Prompt2; exports.ReadonlyAttachment = ReadonlyAttachment; exports.ReadonlyExperiment = ReadonlyExperiment; exports.SpanImpl = SpanImpl; exports.TestBackgroundLogger = TestBackgroundLogger; exports.UUIDGenerator = UUIDGenerator; exports.X_CACHED_HEADER = X_CACHED_HEADER; exports._exportsForTestingOnly = _exportsForTestingOnly; exports._internalGetGlobalState = _internalGetGlobalState; exports._internalSetInitialState = _internalSetInitialState; exports.braintrustStreamChunkSchema = braintrustStreamChunkSchema; exports.createFinalValuePassThroughStream = createFinalValuePassThroughStream; exports.currentExperiment = currentExperiment; exports.currentLogger = currentLogger; exports.currentSpan = currentSpan; exports.deepCopyEvent = deepCopyEvent; exports.default = browser_default; exports.deserializePlainStringAsJSON = deserializePlainStringAsJSON; exports.devNullWritableStream = devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.flush = flush; exports.getContextManager = getContextManager; exports.getIdGenerator = getIdGenerator; exports.getPromptVersions = getPromptVersions; exports.getSpanParentObject = getSpanParentObject; exports.graph = graph_framework_exports; exports.init = init; exports.initDataset = initDataset; exports.initExperiment = initExperiment; exports.initFunction = initFunction; exports.initLogger = initLogger; exports.invoke = invoke; exports.loadPrompt = loadPrompt; exports.log = log; exports.logError = logError; exports.login = login; exports.loginToState = loginToState; exports.newId = newId; exports.parseCachedHeader = parseCachedHeader; exports.permalink = permalink; exports.renderMessage = renderMessage; exports.renderPromptParams = renderPromptParams; exports.setFetch = setFetch; exports.setMaskingFunction = setMaskingFunction; exports.spanComponentsToObjectId = spanComponentsToObjectId; exports.startSpan = startSpan; exports.summarize = summarize; exports.traceable = traceable; exports.traced = traced; exports.updateSpan = updateSpan; exports.withCurrent = withCurrent; exports.withDataset = withDataset; exports.withExperiment = withExperiment; exports.withLogger = withLogger; exports.withParent = withParent; exports.wrapAISDK = wrapAISDK; exports.wrapAnthropic = wrapAnthropic; exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK; exports.wrapGoogleGenAI = wrapGoogleGenAI; exports.wrapMastraAgent = wrapMastraAgent; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapTraced = wrapTraced;
+exports.Attachment = Attachment; exports.AttachmentReference = AttachmentReference; exports.BaseAttachment = BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BraintrustMiddleware = BraintrustMiddleware; exports.BraintrustState = BraintrustState; exports.BraintrustStream = BraintrustStream; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; exports.ContextManager = ContextManager; exports.DEFAULT_FETCH_BATCH_SIZE = DEFAULT_FETCH_BATCH_SIZE; exports.Dataset = Dataset2; exports.ERR_PERMALINK = ERR_PERMALINK; exports.Eval = Eval; exports.EvalResultWithSummary = EvalResultWithSummary; exports.Experiment = Experiment2; exports.ExternalAttachment = ExternalAttachment; exports.FailedHTTPResponse = FailedHTTPResponse; exports.IDGenerator = IDGenerator; exports.JSONAttachment = JSONAttachment; exports.LEGACY_CACHED_HEADER = LEGACY_CACHED_HEADER; exports.LazyValue = LazyValue; exports.Logger = Logger; exports.LoginInvalidOrgError = LoginInvalidOrgError; exports.NOOP_SPAN = NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = NOOP_SPAN_PERMALINK; exports.NoopSpan = NoopSpan; exports.Project = Project2; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = Prompt2; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = ReadonlyAttachment; exports.ReadonlyExperiment = ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanImpl = SpanImpl; exports.TestBackgroundLogger = TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.UUIDGenerator = UUIDGenerator; exports.X_CACHED_HEADER = X_CACHED_HEADER; exports._exportsForTestingOnly = _exportsForTestingOnly; exports._internalGetGlobalState = _internalGetGlobalState; exports._internalSetInitialState = _internalSetInitialState; exports.braintrustStreamChunkSchema = braintrustStreamChunkSchema; exports.buildLocalSummary = buildLocalSummary; exports.createFinalValuePassThroughStream = createFinalValuePassThroughStream; exports.currentExperiment = currentExperiment; exports.currentLogger = currentLogger; exports.currentSpan = currentSpan; exports.deepCopyEvent = deepCopyEvent; exports.default = exports_exports; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.deserializePlainStringAsJSON = deserializePlainStringAsJSON; exports.devNullWritableStream = devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.flush = flush; exports.getContextManager = getContextManager; exports.getIdGenerator = getIdGenerator; exports.getPromptVersions = getPromptVersions; exports.getSpanParentObject = getSpanParentObject; exports.graph = graph_framework_exports; exports.init = init; exports.initDataset = initDataset; exports.initExperiment = initExperiment; exports.initFunction = initFunction; exports.initLogger = initLogger; exports.invoke = invoke; exports.loadPrompt = loadPrompt; exports.log = log; exports.logError = logError; exports.login = login; exports.loginToState = loginToState; exports.newId = newId; exports.parseCachedHeader = parseCachedHeader; exports.permalink = permalink; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.renderMessage = renderMessage; exports.renderPromptParams = renderPromptParams; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = setFetch; exports.setMaskingFunction = setMaskingFunction; exports.spanComponentsToObjectId = spanComponentsToObjectId; exports.startSpan = startSpan; exports.summarize = summarize; exports.toolFunctionDefinitionSchema = ToolFunctionDefinition; exports.traceable = traceable; exports.traced = traced; exports.updateSpan = updateSpan; exports.withCurrent = withCurrent; exports.withDataset = withDataset; exports.withExperiment = withExperiment; exports.withLogger = withLogger; exports.withParent = withParent; exports.wrapAISDK = wrapAISDK; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAnthropic = wrapAnthropic; exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK; exports.wrapGoogleGenAI = wrapGoogleGenAI; exports.wrapMastraAgent = wrapMastraAgent; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapTraced = wrapTraced;