braintrust 2.2.0 → 2.2.1

package/dev/dist/index.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(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; } async function _asyncOptionalChain(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 = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await 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;// src/node.ts
+"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(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; } async function _asyncOptionalChain(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 = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await 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 _class20;// src/node.ts
 var _async_hooks = require('async_hooks');
 var _path = require('path'); var path = _interopRequireWildcard(_path);
 var _promises = require('fs/promises'); var fs = _interopRequireWildcard(_promises);
@@ -326,11 +326,19 @@ function getIdGenerator() {
 
 // util/db_fields.ts
 var TRANSACTION_ID_FIELD = "_xact_id";
+var OBJECT_DELETE_FIELD = "_object_delete";
 var IS_MERGE_FIELD = "_is_merge";
 var AUDIT_SOURCE_FIELD = "_audit_source";
 var AUDIT_METADATA_FIELD = "_audit_metadata";
 var VALID_SOURCES = ["app", "api", "external"];
-var PARENT_ID_FIELD = "_parent_id";
+var OBJECT_ID_KEYS = [
+  "experiment_id",
+  "dataset_id",
+  "prompt_session_id",
+  "project_id",
+  "log_id",
+  "function_data"
+];
 
 // util/span_identifier_v3.ts
 
@@ -1005,13 +1013,6 @@ function mergeDictsWithPathsHelper({
 function mergeDicts(mergeInto, mergeFrom) {
   return mergeDictsWithPaths({ mergeInto, mergeFrom, mergePaths: [] });
 }
-function mapAt(m, k) {
-  const ret = m.get(k);
-  if (ret === void 0) {
-    throw new Error(`Map does not contain key ${k}`);
-  }
-  return ret;
-}
 function recordFind(m, k) {
   return m[k];
 }
@@ -1026,72 +1027,8 @@ function getObjValueByPath(row, path2) {
   return curr;
 }
 
-// util/graph_util.ts
-function depthFirstSearch(args) {
-  const { graph, firstVisitF, lastVisitF } = args;
-  for (const vs of graph.values()) {
-    for (const v of vs.values()) {
-      if (!graph.has(v)) {
-        throw new Error(`Outgoing vertex ${v} must be a key in the graph`);
-      }
-    }
-  }
-  const firstVisitedVertices = /* @__PURE__ */ new Set();
-  const visitationOrder = _nullishCoalesce(args.visitationOrder, () => ( [...graph.keys()]));
-  const events = visitationOrder.map((vertex) => ({ eventType: "first", vertex, extras: {} })).reverse();
-  while (events.length) {
-    const { eventType, vertex, extras } = events.pop();
-    if (eventType === "last") {
-      _optionalChain([lastVisitF, 'optionalCall', _17 => _17(vertex)]);
-      continue;
-    }
-    if (firstVisitedVertices.has(vertex)) {
-      continue;
-    }
-    firstVisitedVertices.add(vertex);
-    _optionalChain([firstVisitF, 'optionalCall', _18 => _18(vertex, { parentVertex: extras.parentVertex })]);
-    events.push({ eventType: "last", vertex, extras: {} });
-    mapAt(graph, vertex).forEach((child) => {
-      events.push({
-        eventType: "first",
-        vertex: child,
-        extras: { parentVertex: vertex }
-      });
-    });
-  }
-}
-function undirectedConnectedComponents(graph) {
-  const directedGraph = new Map(
-    [...graph.vertices].map((v) => [v, /* @__PURE__ */ new Set()])
-  );
-  for (const [i, j] of graph.edges) {
-    mapAt(directedGraph, i).add(j);
-    mapAt(directedGraph, j).add(i);
-  }
-  let labelCounter = 0;
-  const vertexLabels = /* @__PURE__ */ new Map();
-  const firstVisitF = (vertex, args) => {
-    const label = _optionalChain([args, 'optionalAccess', _19 => _19.parentVertex]) !== void 0 ? mapAt(vertexLabels, _optionalChain([args, 'optionalAccess', _20 => _20.parentVertex])) : labelCounter++;
-    vertexLabels.set(vertex, label);
-  };
-  depthFirstSearch({ graph: directedGraph, firstVisitF });
-  const output = Array.from({ length: labelCounter }).map(() => []);
-  for (const [vertex, label] of vertexLabels.entries()) {
-    output[label].push(vertex);
-  }
-  return output;
-}
-function topologicalSort(graph, visitationOrder) {
-  const reverseOrdering = [];
-  const lastVisitF = (vertex) => {
-    reverseOrdering.push(vertex);
-  };
-  depthFirstSearch({ graph, lastVisitF, visitationOrder });
-  return reverseOrdering.reverse();
-}
-
 // util/merge_row_batch.ts
-function generateMergedRowKey(row, useParentIdForId) {
+function generateMergedRowKey(row) {
   return JSON.stringify(
     [
       "org_id",
@@ -1100,7 +1037,7 @@ function generateMergedRowKey(row, useParentIdForId) {
       "dataset_id",
       "prompt_session_id",
       "log_id",
-      _nullishCoalesce(useParentIdForId, () => ( false)) ? PARENT_ID_FIELD : "id"
+      "id"
     ].map((k) => row[k])
   );
 }
@@ -1154,96 +1091,34 @@ function mergeRowBatch(rows) {
       rowGroups.set(key, row);
     }
   }
-  const merged = [...rowGroups.values()];
-  const rowToLabel = new Map(
-    merged.map((r, i) => [generateMergedRowKey(r), i])
-  );
-  const graph = new Map(
-    Array.from({ length: merged.length }).map((_, i) => [i, /* @__PURE__ */ new Set()])
-  );
-  merged.forEach((r, i) => {
-    const parentId = r[PARENT_ID_FIELD];
-    if (!parentId) {
-      return;
-    }
-    const parentRowKey = generateMergedRowKey(
-      r,
-      true
-      /* useParentIdForId */
-    );
-    const parentLabel = rowToLabel.get(parentRowKey);
-    if (parentLabel !== void 0) {
-      mapAt(graph, parentLabel).add(i);
-    }
-  });
-  const connectedComponents = undirectedConnectedComponents({
-    vertices: new Set(graph.keys()),
-    edges: new Set(
-      [...graph.entries()].flatMap(
-        ([k, vs]) => [...vs].map((v) => {
-          const ret = [k, v];
-          return ret;
-        })
-      )
-    )
-  });
-  const buckets = connectedComponents.map(
-    (cc) => topologicalSort(
-      graph,
-      cc
-      /* visitationOrder */
-    )
-  );
-  return buckets.map((bucket) => bucket.map((i) => merged[i]));
+  return [...rowGroups.values()];
 }
 function batchItems(args) {
-  let { items } = args;
+  const { items } = args;
   const batchMaxNumItems = _nullishCoalesce(args.batchMaxNumItems, () => ( Number.POSITIVE_INFINITY));
   const batchMaxNumBytes = _nullishCoalesce(args.batchMaxNumBytes, () => ( Number.POSITIVE_INFINITY));
+  const getByteSize = args.getByteSize;
   const output = [];
-  let nextItems = [];
-  let batchSet = [];
   let batch = [];
   let batchLen = 0;
   function addToBatch(item) {
     batch.push(item);
-    batchLen += item.length;
+    batchLen += getByteSize(item);
   }
   function flushBatch() {
-    batchSet.push(batch);
+    output.push(batch);
     batch = [];
     batchLen = 0;
   }
-  while (items.length) {
-    for (const bucket of items) {
-      let i = 0;
-      for (const item of bucket) {
-        if (batch.length === 0 || item.length + batchLen < batchMaxNumBytes && batch.length < batchMaxNumItems) {
-          addToBatch(item);
-        } else if (i === 0) {
-          flushBatch();
-          addToBatch(item);
-        } else {
-          break;
-        }
-        ++i;
-      }
-      if (i < bucket.length) {
-        nextItems.push(bucket.slice(i));
-      }
-      if (batchLen >= batchMaxNumBytes || batch.length > batchMaxNumItems) {
-        flushBatch();
-      }
-    }
-    if (batch.length) {
+  for (const item of items) {
+    const itemSize = getByteSize(item);
+    if (batch.length > 0 && !(itemSize + batchLen < batchMaxNumBytes && batch.length < batchMaxNumItems)) {
       flushBatch();
     }
-    if (batchSet.length) {
-      output.push(batchSet);
-      batchSet = [];
-    }
-    items = nextItems;
-    nextItems = [];
+    addToBatch(item);
+  }
+  if (batch.length > 0) {
+    flushBatch();
   }
   return output;
 }
@@ -1361,20 +1236,20 @@ function slugify(text, options) {
     \u00FF: "y"
   };
   const replacement = "-";
-  const trim = _optionalChain([options, 'optionalAccess', _21 => _21.trim]) !== false;
+  const trim = _optionalChain([options, 'optionalAccess', _17 => _17.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', _22 => _22.strict])) {
+  if (_optionalChain([options, 'optionalAccess', _18 => _18.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', _23 => _23.lower])) {
+  if (_optionalChain([options, 'optionalAccess', _19 => _19.lower])) {
     slug = slug.toLowerCase();
   }
   return slug;
@@ -1841,10 +1716,15 @@ var FunctionTypeEnum = _v3.z.enum([
   "preprocessor",
   "facet",
   "classifier",
-  "tag"
+  "tag",
+  "parameters"
 ]);
 var NullableSavedFunctionId = _v3.z.union([
-  _v3.z.object({ type: _v3.z.literal("function"), id: _v3.z.string() }),
+  _v3.z.object({
+    type: _v3.z.literal("function"),
+    id: _v3.z.string(),
+    version: _v3.z.string().optional()
+  }),
   _v3.z.object({
     type: _v3.z.literal("global"),
     name: _v3.z.string(),
@@ -1852,6 +1732,67 @@ var NullableSavedFunctionId = _v3.z.union([
   }),
   _v3.z.null()
 ]);
+var TopicMapReport = _v3.z.object({
+  version: _v3.z.literal(1),
+  created_at: _v3.z.string().optional(),
+  settings: _v3.z.object({
+    algorithm: _v3.z.enum(["hdbscan", "kmeans", "hierarchical"]),
+    dimension_reduction: _v3.z.enum(["umap", "pca", "none"]),
+    vector_field: _v3.z.string(),
+    embedding_model: _v3.z.string(),
+    n_clusters: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+    umap_dimensions: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+    min_cluster_size: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+    min_samples: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional()
+  }),
+  query_settings: _v3.z.object({
+    hierarchy_threshold: _v3.z.union([_v3.z.number(), _v3.z.null()]),
+    auto_naming: _v3.z.boolean(),
+    skip_cache: _v3.z.boolean(),
+    viz_mode: _v3.z.enum(["bar", "scatter"]),
+    naming_model: _v3.z.string()
+  }).partial(),
+  clusters: _v3.z.array(
+    _v3.z.object({
+      cluster_id: _v3.z.number(),
+      parent_cluster_id: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+      topic_id: _v3.z.string(),
+      count: _v3.z.number(),
+      sample_texts: _v3.z.array(_v3.z.string()),
+      samples: _v3.z.array(
+        _v3.z.object({
+          id: _v3.z.string(),
+          text: _v3.z.string(),
+          root_span_id: _v3.z.string(),
+          span_id: _v3.z.string()
+        })
+      ),
+      name: _v3.z.string().optional(),
+      description: _v3.z.string().optional(),
+      keywords: _v3.z.array(_v3.z.string()).optional(),
+      centroid: _v3.z.array(_v3.z.number()).optional(),
+      parent_id: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+      is_leaf: _v3.z.boolean().optional(),
+      depth: _v3.z.number().optional()
+    })
+  ),
+  embedding_points: _v3.z.array(
+    _v3.z.object({
+      x: _v3.z.number(),
+      y: _v3.z.number(),
+      cluster: _v3.z.number(),
+      text: _v3.z.string().optional()
+    })
+  ).optional()
+});
+var TopicMapData = _v3.z.object({
+  type: _v3.z.literal("topic_map"),
+  source_facet: _v3.z.string(),
+  embedding_model: _v3.z.string(),
+  bundle_key: _v3.z.string(),
+  distance_threshold: _v3.z.number().optional(),
+  report: TopicMapReport.optional()
+});
 var BatchedFacetData = _v3.z.object({
   type: _v3.z.literal("batched_facet"),
   preprocessor: NullableSavedFunctionId.and(_v3.z.unknown()).optional(),
@@ -1860,9 +1801,17 @@ var BatchedFacetData = _v3.z.object({
       name: _v3.z.string(),
       prompt: _v3.z.string(),
       model: _v3.z.string().optional(),
+      embedding_model: _v3.z.string().optional(),
       no_match_pattern: _v3.z.string().optional()
     })
-  )
+  ),
+  topic_maps: _v3.z.record(
+    _v3.z.object({
+      function_name: _v3.z.string(),
+      topic_map_id: _v3.z.string().optional(),
+      topic_map_data: TopicMapData
+    })
+  ).optional()
 });
 var BraintrustModelParams = _v3.z.object({
   use_cache: _v3.z.boolean(),
@@ -2073,6 +2022,18 @@ var ObjectReferenceNullish = _v3.z.union([
   }),
   _v3.z.null()
 ]);
+var SavedFunctionId = _v3.z.union([
+  _v3.z.object({
+    type: _v3.z.literal("function"),
+    id: _v3.z.string(),
+    version: _v3.z.string().optional()
+  }),
+  _v3.z.object({
+    type: _v3.z.literal("global"),
+    name: _v3.z.string(),
+    function_type: FunctionTypeEnum.optional().default("scorer")
+  })
+]);
 var DatasetEvent = _v3.z.object({
   id: _v3.z.string(),
   _xact_id: _v3.z.string(),
@@ -2092,7 +2053,36 @@ var DatasetEvent = _v3.z.object({
   is_root: _v3.z.union([_v3.z.boolean(), _v3.z.null()]).optional(),
   origin: ObjectReferenceNullish.optional(),
   comments: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
-  audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional()
+  audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
+  facets: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+  classifications: _v3.z.union([
+    _v3.z.record(
+      _v3.z.array(
+        _v3.z.object({
+          id: _v3.z.string(),
+          label: _v3.z.string().optional(),
+          confidence: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+          metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            _v3.z.union([
+              _v3.z.object({
+                type: _v3.z.literal("function"),
+                id: _v3.z.string(),
+                version: _v3.z.string().optional()
+              }),
+              _v3.z.object({
+                type: _v3.z.literal("global"),
+                name: _v3.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              _v3.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    _v3.z.null()
+  ]).optional()
 });
 var EnvVar = _v3.z.object({
   id: _v3.z.string().uuid(),
@@ -2169,7 +2159,8 @@ var SpanType = _v3.z.union([
     "automation",
     "facet",
     "preprocessor",
-    "classifier"
+    "classifier",
+    "review"
   ]),
   _v3.z.null()
 ]);
@@ -2210,10 +2201,43 @@ var ExperimentEvent = _v3.z.object({
   is_root: _v3.z.union([_v3.z.boolean(), _v3.z.null()]).optional(),
   origin: ObjectReferenceNullish.optional(),
   comments: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
-  audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional()
+  audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
+  facets: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+  classifications: _v3.z.union([
+    _v3.z.record(
+      _v3.z.array(
+        _v3.z.object({
+          id: _v3.z.string(),
+          label: _v3.z.string().optional(),
+          confidence: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+          metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            _v3.z.union([
+              _v3.z.object({
+                type: _v3.z.literal("function"),
+                id: _v3.z.string(),
+                version: _v3.z.string().optional()
+              }),
+              _v3.z.object({
+                type: _v3.z.literal("global"),
+                name: _v3.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              _v3.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    _v3.z.null()
+  ]).optional()
 });
 var ExtendedSavedFunctionId = _v3.z.union([
-  _v3.z.object({ type: _v3.z.literal("function"), id: _v3.z.string() }),
+  _v3.z.object({
+    type: _v3.z.literal("function"),
+    id: _v3.z.string(),
+    version: _v3.z.string().optional()
+  }),
   _v3.z.object({
     type: _v3.z.literal("global"),
     name: _v3.z.string(),
@@ -2230,6 +2254,7 @@ var FacetData = _v3.z.object({
   preprocessor: NullableSavedFunctionId.and(_v3.z.unknown()).optional(),
   prompt: _v3.z.string(),
   model: _v3.z.string().optional(),
+  embedding_model: _v3.z.string().optional(),
   no_match_pattern: _v3.z.string().optional()
 });
 var PromptBlockDataNullish = _v3.z.union([
@@ -2319,14 +2344,6 @@ var PromptParserNullish = _v3.z.union([
   }),
   _v3.z.null()
 ]);
-var SavedFunctionId = _v3.z.union([
-  _v3.z.object({ type: _v3.z.literal("function"), id: _v3.z.string() }),
-  _v3.z.object({
-    type: _v3.z.literal("global"),
-    name: _v3.z.string(),
-    function_type: FunctionTypeEnum.optional().default("scorer")
-  })
-]);
 var PromptDataNullish = _v3.z.union([
   _v3.z.object({
     prompt: PromptBlockDataNullish,
@@ -2377,7 +2394,8 @@ var FunctionTypeEnumNullish = _v3.z.union([
     "preprocessor",
     "facet",
     "classifier",
-    "tag"
+    "tag",
+    "parameters"
   ]),
   _v3.z.null()
 ]);
@@ -2469,7 +2487,8 @@ var FunctionData = _v3.z.union([
     type: _v3.z.literal("remote_eval"),
     endpoint: _v3.z.string(),
     eval_name: _v3.z.string(),
-    parameters: _v3.z.object({}).partial().passthrough()
+    parameters: _v3.z.object({}).partial().passthrough(),
+    parameters_version: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional()
   }),
   _v3.z.object({
     type: _v3.z.literal("global"),
@@ -2478,7 +2497,18 @@ var FunctionData = _v3.z.union([
     config: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional()
   }),
   FacetData,
-  BatchedFacetData
+  BatchedFacetData,
+  _v3.z.object({
+    type: _v3.z.literal("parameters"),
+    data: _v3.z.object({}).partial().passthrough(),
+    __schema: _v3.z.object({
+      type: _v3.z.literal("object"),
+      properties: _v3.z.record(_v3.z.object({}).partial().passthrough()),
+      required: _v3.z.array(_v3.z.string()).optional(),
+      additionalProperties: _v3.z.boolean().optional()
+    })
+  }),
+  TopicMapData.and(_v3.z.unknown())
 ]);
 var Function = _v3.z.object({
   id: _v3.z.string().uuid(),
@@ -2508,7 +2538,13 @@ var Function = _v3.z.object({
     _v3.z.null()
   ]).optional()
 });
-var FunctionFormat = _v3.z.enum(["llm", "code", "global", "graph"]);
+var FunctionFormat = _v3.z.enum([
+  "llm",
+  "code",
+  "global",
+  "graph",
+  "topic_map"
+]);
 var PromptData = _v3.z.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
@@ -2591,13 +2627,14 @@ var FunctionObjectType = _v3.z.enum([
   "custom_view",
   "preprocessor",
   "facet",
-  "classifier"
+  "classifier",
+  "parameters"
 ]);
 var FunctionOutputType = _v3.z.enum([
   "completion",
   "score",
   "facet",
-  "tag",
+  "classification",
   "any"
 ]);
 var GitMetadataSettings = _v3.z.object({
@@ -2633,6 +2670,10 @@ var GroupScope = _v3.z.object({
   idle_seconds: _v3.z.number().optional()
 });
 var IfExists = _v3.z.enum(["error", "ignore", "replace"]);
+var ImageRenderingMode = _v3.z.union([
+  _v3.z.enum(["auto", "click_to_load", "blocked"]),
+  _v3.z.null()
+]);
 var InvokeParent = _v3.z.union([
   _v3.z.object({
     object_type: _v3.z.enum(["project_logs", "experiment", "playground_logs"]),
@@ -2725,7 +2766,8 @@ var Organization = _v3.z.object({
   is_universal_api: _v3.z.union([_v3.z.boolean(), _v3.z.null()]).optional(),
   proxy_url: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   realtime_url: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
-  created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional()
+  created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  image_rendering_mode: ImageRenderingMode.optional()
 });
 var ProjectSettings = _v3.z.union([
   _v3.z.object({
@@ -2866,7 +2908,36 @@ var ProjectLogsEvent = _v3.z.object({
   origin: ObjectReferenceNullish.optional(),
   comments: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
   audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
-  _async_scoring_state: _v3.z.unknown().optional()
+  _async_scoring_state: _v3.z.unknown().optional(),
+  facets: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+  classifications: _v3.z.union([
+    _v3.z.record(
+      _v3.z.array(
+        _v3.z.object({
+          id: _v3.z.string(),
+          label: _v3.z.string().optional(),
+          confidence: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+          metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            _v3.z.union([
+              _v3.z.object({
+                type: _v3.z.literal("function"),
+                id: _v3.z.string(),
+                version: _v3.z.string().optional()
+              }),
+              _v3.z.object({
+                type: _v3.z.literal("global"),
+                name: _v3.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              _v3.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    _v3.z.null()
+  ]).optional()
 });
 var ProjectScoreType = _v3.z.enum([
   "slider",
@@ -3168,12 +3239,15 @@ var View = _v3.z.object({
     "datasets",
     "dataset",
     "prompts",
+    "parameters",
     "tools",
     "scorers",
     "classifiers",
     "logs",
     "monitor",
-    "for_review"
+    "for_review_project_log",
+    "for_review_experiments",
+    "for_review_datasets"
   ]),
   name: _v3.z.string(),
   created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
@@ -3906,6 +3980,52 @@ var PromptCache = class {
   }
 };
 
+// src/prompt-cache/parameters-cache.ts
+function createCacheKey2(key) {
+  if (key.id) {
+    return `parameters:id:${key.id}`;
+  }
+  const prefix = _nullishCoalesce(key.projectId, () => ( key.projectName));
+  if (!prefix) {
+    throw new Error("Either projectId or projectName must be provided");
+  }
+  if (!key.slug) {
+    throw new Error("Slug must be provided when not using ID");
+  }
+  return `parameters:${prefix}:${key.slug}:${_nullishCoalesce(key.version, () => ( "latest"))}`;
+}
+var ParametersCache = class {
+  
+  
+  constructor(options) {
+    this.memoryCache = options.memoryCache;
+    this.diskCache = options.diskCache;
+  }
+  async get(key) {
+    const cacheKey = createCacheKey2(key);
+    const memoryParams = this.memoryCache.get(cacheKey);
+    if (memoryParams !== void 0) {
+      return memoryParams;
+    }
+    if (this.diskCache) {
+      const diskParams = await this.diskCache.get(cacheKey);
+      if (!diskParams) {
+        return void 0;
+      }
+      this.memoryCache.set(cacheKey, diskParams);
+      return diskParams;
+    }
+    return void 0;
+  }
+  async set(key, value) {
+    const cacheKey = createCacheKey2(key);
+    this.memoryCache.set(cacheKey, value);
+    if (this.diskCache) {
+      await this.diskCache.set(cacheKey, value);
+    }
+  }
+};
+
 // src/span-cache.ts
 var activeCaches = /* @__PURE__ */ new Set();
 var exitHandlersRegistered = false;
@@ -3927,7 +4047,7 @@ var SpanCache = (_class4 = class {
   // Small in-memory index tracking which rootSpanIds have data
   __init12() {this.rootSpanIndex = /* @__PURE__ */ new Set()}
   constructor(options) {;_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);_class4.prototype.__init11.call(this);_class4.prototype.__init12.call(this);_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);
-    this._explicitlyDisabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _24 => _24.disabled]), () => ( false));
+    this._explicitlyDisabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.disabled]), () => ( false));
   }
   /**
    * Disable the cache at runtime. This is called automatically when
@@ -4196,7 +4316,24 @@ var SpanCache = (_class4 = class {
 // src/logger.ts
 var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
+var LOGS3_OVERFLOW_REFERENCE_TYPE = "logs3_overflow";
 var BRAINTRUST_PARAMS = Object.keys(BraintrustModelParams.shape);
+var DEFAULT_MAX_REQUEST_SIZE = 6 * 1024 * 1024;
+var parametersRowSchema = _v3.z.object({
+  id: _v3.z.string().uuid(),
+  _xact_id: _v3.z.string(),
+  project_id: _v3.z.string().uuid(),
+  name: _v3.z.string(),
+  slug: _v3.z.string(),
+  description: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  function_type: _v3.z.literal("parameters"),
+  function_data: _v3.z.object({
+    type: _v3.z.literal("parameters"),
+    data: _v3.z.record(_v3.z.unknown()).optional(),
+    __schema: _v3.z.record(_v3.z.unknown())
+  }),
+  metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional()
+});
 var LoginInvalidOrgError = class extends Error {
   constructor(message) {
     super(message);
@@ -4294,7 +4431,7 @@ var NoopSpan = (_class5 = class {
     return this;
   }
   end(args) {
-    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _25 => _25.endTime]), () => ( getCurrentUnixTimestamp()));
+    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _21 => _21.endTime]), () => ( getCurrentUnixTimestamp()));
   }
   async export() {
     return "";
@@ -4373,6 +4510,17 @@ var BraintrustState = (_class6 = class _BraintrustState {
       max: _nullishCoalesce(Number(isomorph_default.getEnv("BRAINTRUST_PROMPT_CACHE_DISK_MAX")), () => ( 1 << 20))
     }) : void 0;
     this.promptCache = new PromptCache({ memoryCache, diskCache });
+    const parametersMemoryCache = new LRUCache({
+      max: _nullishCoalesce(Number(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX")), () => ( 1 << 10))
+    });
+    const parametersDiskCache = canUseDiskCache() ? new DiskCache({
+      cacheDir: _nullishCoalesce(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_DIR"), () => ( `${_nullishCoalesce(isomorph_default.getEnv("HOME"), () => ( isomorph_default.homedir()))}/.braintrust/parameters_cache`)),
+      max: _nullishCoalesce(Number(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_DISK_MAX")), () => ( 1 << 20))
+    }) : void 0;
+    this.parametersCache = new ParametersCache({
+      memoryCache: parametersMemoryCache,
+      diskCache: parametersDiskCache
+    });
     this.spanCache = new SpanCache({ disabled: loginParams.disableSpanCache });
   }
   
@@ -4403,6 +4551,7 @@ var BraintrustState = (_class6 = class _BraintrustState {
   __init29() {this._proxyConn = null}
   
   
+  
   __init30() {this._idGenerator = null}
   __init31() {this._contextManager = null}
   __init32() {this._otelFlushCallback = null}
@@ -4518,8 +4667,8 @@ var BraintrustState = (_class6 = class _BraintrustState {
   setFetch(fetch2) {
     this.loginParams.fetch = fetch2;
     this.fetch = fetch2;
-    _optionalChain([this, 'access', _26 => _26._apiConn, 'optionalAccess', _27 => _27.setFetch, 'call', _28 => _28(fetch2)]);
-    _optionalChain([this, 'access', _29 => _29._appConn, 'optionalAccess', _30 => _30.setFetch, 'call', _31 => _31(fetch2)]);
+    _optionalChain([this, 'access', _22 => _22._apiConn, 'optionalAccess', _23 => _23.setFetch, 'call', _24 => _24(fetch2)]);
+    _optionalChain([this, 'access', _25 => _25._appConn, 'optionalAccess', _26 => _26.setFetch, 'call', _27 => _27(fetch2)]);
   }
   setMaskingFunction(maskingFunction) {
     this.bgLogger().setMaskingFunction(maskingFunction);
@@ -5196,8 +5345,8 @@ function _getOrgName(orgName) {
   return orgName || isomorph_default.getEnv("BRAINTRUST_ORG_NAME") || void 0;
 }
 function _getLinkBaseUrl(state, linkArgs) {
-  const appUrl = _getAppUrl(state.appUrl || _optionalChain([linkArgs, 'optionalAccess', _32 => _32.app_url]));
-  const orgName = _getOrgName(state.orgName || _optionalChain([linkArgs, 'optionalAccess', _33 => _33.org_name]));
+  const appUrl = _getAppUrl(state.appUrl || _optionalChain([linkArgs, 'optionalAccess', _28 => _28.app_url]));
+  const orgName = _getOrgName(state.orgName || _optionalChain([linkArgs, 'optionalAccess', _29 => _29.org_name]));
   if (!orgName) {
     return null;
   }
@@ -5207,9 +5356,9 @@ async function permalink(slug, opts) {
   if (slug === "") {
     return NOOP_SPAN_PERMALINK;
   }
-  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _34 => _34.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _30 => _30.state]), () => ( _globalState));
   const getOrgName = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _35 => _35.orgName])) {
+    if (_optionalChain([opts, 'optionalAccess', _31 => _31.orgName])) {
       return opts.orgName;
     }
     await state.login({});
@@ -5219,7 +5368,7 @@ async function permalink(slug, opts) {
     return state.orgName;
   };
   const getAppUrl = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _36 => _36.appUrl])) {
+    if (_optionalChain([opts, 'optionalAccess', _32 => _32.appUrl])) {
       return opts.appUrl;
     }
     await state.login({});
@@ -5354,7 +5503,7 @@ var Logger = (_class7 = class {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _37 => _37.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _33 => _33.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`"
       );
@@ -5422,12 +5571,12 @@ var Logger = (_class7 = class {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _38 => _38.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _34 => _34.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: this.computeMetadataArgs,
-        parentSpanIds: _optionalChain([args, 'optionalAccess', _39 => _39.parentSpanIds]),
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _40 => _40.propagatedEvent])
+        parentSpanIds: _optionalChain([args, 'optionalAccess', _35 => _35.parentSpanIds]),
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _36 => _36.propagatedEvent])
       }),
       defaultRootType: "task" /* TASK */
     });
@@ -5503,8 +5652,100 @@ function castLogger(logger, asyncFlush) {
   }
   return logger;
 }
+var logs3OverflowUploadSchema = _v3.z.object({
+  method: _v3.z.enum(["PUT", "POST"]),
+  signedUrl: _v3.z.string().url(),
+  headers: _v3.z.record(_v3.z.string()).optional(),
+  fields: _v3.z.record(_v3.z.string()).optional(),
+  key: _v3.z.string().min(1)
+});
 function constructLogs3Data(items) {
-  return `{"rows": ${constructJsonArray(items)}, "api_version": 2}`;
+  return `{"rows": ${constructJsonArray(items.map((i) => i.str))}, "api_version": 2}`;
+}
+function constructLogs3OverflowRequest(key) {
+  return {
+    rows: {
+      type: LOGS3_OVERFLOW_REFERENCE_TYPE,
+      key
+    },
+    api_version: 2
+  };
+}
+function pickLogs3OverflowObjectIds(row) {
+  const objectIds = {};
+  for (const key of OBJECT_ID_KEYS) {
+    if (key in row) {
+      objectIds[key] = row[key];
+    }
+  }
+  return objectIds;
+}
+async function uploadLogs3OverflowPayload(upload, payload, fetchFn = fetch) {
+  if (upload.method === "POST") {
+    if (!upload.fields) {
+      throw new Error("Missing logs3 overflow upload fields");
+    }
+    if (typeof FormData === "undefined" || typeof Blob === "undefined") {
+      throw new Error("FormData is not available for logs3 overflow upload");
+    }
+    const form = new FormData();
+    for (const [key, value] of Object.entries(upload.fields)) {
+      form.append(key, value);
+    }
+    const contentType = _nullishCoalesce(upload.fields["Content-Type"], () => ( "application/json"));
+    form.append("file", new Blob([payload], { type: contentType }));
+    const headers2 = {};
+    for (const [key, value] of Object.entries(_nullishCoalesce(upload.headers, () => ( {})))) {
+      if (key.toLowerCase() !== "content-type") {
+        headers2[key] = value;
+      }
+    }
+    const response2 = await fetchFn(upload.signedUrl, {
+      method: "POST",
+      headers: headers2,
+      body: form
+    });
+    if (!response2.ok) {
+      const responseText = await response2.text().catch(() => "");
+      throw new Error(
+        `Failed to upload logs3 overflow payload: ${response2.status} ${responseText}`
+      );
+    }
+    return;
+  }
+  const headers = { ..._nullishCoalesce(upload.headers, () => ( {})) };
+  addAzureBlobHeaders(headers, upload.signedUrl);
+  const response = await fetchFn(upload.signedUrl, {
+    method: "PUT",
+    headers,
+    body: payload
+  });
+  if (!response.ok) {
+    const responseText = await response.text().catch(() => "");
+    throw new Error(
+      `Failed to upload logs3 overflow payload: ${response.status} ${responseText}`
+    );
+  }
+}
+function stringifyWithOverflowMeta(item) {
+  const str = JSON.stringify(item);
+  const record = item;
+  return {
+    str,
+    overflowMeta: {
+      object_ids: pickLogs3OverflowObjectIds(record),
+      is_delete: record[OBJECT_DELETE_FIELD] === true,
+      input_row: {
+        byte_size: utf8ByteLength(str)
+      }
+    }
+  };
+}
+function utf8ByteLength(value) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(value).length;
+  }
+  return value.length;
 }
 function now() {
   return (/* @__PURE__ */ new Date()).getTime();
@@ -5519,21 +5760,21 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
   
   __init37() {this.maskingFunction = null}
   __init38() {this.syncFlush = false}
-  // 6 MB for the AWS lambda gateway (from our own testing).
-  __init39() {this.maxRequestSize = 6 * 1024 * 1024}
-  __init40() {this.defaultBatchSize = 100}
-  __init41() {this.numTries = 3}
-  __init42() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
-  __init43() {this.queueDropLoggingPeriod = 60}
-  __init44() {this.failedPublishPayloadsDir = void 0}
-  __init45() {this.allPublishPayloadsDir = void 0}
-  __init46() {this.flushChunkSize = 25}
-  __init47() {this._disabled = false}
-  __init48() {this.queueDropLoggingState = {
+  __init39() {this.maxRequestSizeOverride = null}
+  __init40() {this._maxRequestSizePromise = null}
+  __init41() {this.defaultBatchSize = 100}
+  __init42() {this.numTries = 3}
+  __init43() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
+  __init44() {this.queueDropLoggingPeriod = 60}
+  __init45() {this.failedPublishPayloadsDir = void 0}
+  __init46() {this.allPublishPayloadsDir = void 0}
+  __init47() {this.flushChunkSize = 25}
+  __init48() {this._disabled = false}
+  __init49() {this.queueDropLoggingState = {
     numDropped: 0,
     lastLoggedTimestamp: 0
   }}
-  constructor(apiConn, opts) {;_class8.prototype.__init34.call(this);_class8.prototype.__init35.call(this);_class8.prototype.__init36.call(this);_class8.prototype.__init37.call(this);_class8.prototype.__init38.call(this);_class8.prototype.__init39.call(this);_class8.prototype.__init40.call(this);_class8.prototype.__init41.call(this);_class8.prototype.__init42.call(this);_class8.prototype.__init43.call(this);_class8.prototype.__init44.call(this);_class8.prototype.__init45.call(this);_class8.prototype.__init46.call(this);_class8.prototype.__init47.call(this);_class8.prototype.__init48.call(this);
+  constructor(apiConn, opts) {;_class8.prototype.__init34.call(this);_class8.prototype.__init35.call(this);_class8.prototype.__init36.call(this);_class8.prototype.__init37.call(this);_class8.prototype.__init38.call(this);_class8.prototype.__init39.call(this);_class8.prototype.__init40.call(this);_class8.prototype.__init41.call(this);_class8.prototype.__init42.call(this);_class8.prototype.__init43.call(this);_class8.prototype.__init44.call(this);_class8.prototype.__init45.call(this);_class8.prototype.__init46.call(this);_class8.prototype.__init47.call(this);_class8.prototype.__init48.call(this);_class8.prototype.__init49.call(this);
     opts = _nullishCoalesce(opts, () => ( {}));
     this.apiConn = apiConn;
     const syncFlushEnv = Number(isomorph_default.getEnv("BRAINTRUST_SYNC_FLUSH"));
@@ -5548,7 +5789,7 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
     }
     const maxRequestSizeEnv = Number(isomorph_default.getEnv("BRAINTRUST_MAX_REQUEST_SIZE"));
     if (!isNaN(maxRequestSizeEnv)) {
-      this.maxRequestSize = maxRequestSizeEnv;
+      this.maxRequestSizeOverride = maxRequestSizeEnv;
     }
     const numTriesEnv = Number(isomorph_default.getEnv("BRAINTRUST_NUM_RETRIES"));
     if (!isNaN(numTriesEnv)) {
@@ -5610,6 +5851,30 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
       }
     }
   }
+  getMaxRequestSize() {
+    if (!this._maxRequestSizePromise) {
+      this._maxRequestSizePromise = (async () => {
+        let serverLimit = null;
+        try {
+          const conn = await this.apiConn.get();
+          const versionInfo = await conn.get_json("version");
+          serverLimit = _nullishCoalesce(_v3.z.object({ logs3_payload_max_bytes: _v3.z.number().nullish() }).parse(versionInfo).logs3_payload_max_bytes, () => ( null));
+        } catch (e) {
+          console.warn("Failed to fetch version info for payload limit:", e);
+        }
+        const validServerLimit = serverLimit !== null && serverLimit > 0 ? serverLimit : null;
+        const canUseOverflow = validServerLimit !== null;
+        let maxRequestSize = DEFAULT_MAX_REQUEST_SIZE;
+        if (this.maxRequestSizeOverride !== null) {
+          maxRequestSize = validServerLimit !== null ? Math.min(this.maxRequestSizeOverride, validServerLimit) : this.maxRequestSizeOverride;
+        } else if (validServerLimit !== null) {
+          maxRequestSize = validServerLimit;
+        }
+        return { maxRequestSize, canUseOverflow };
+      })();
+    }
+    return this._maxRequestSizePromise;
+  }
   async flush() {
     if (this.syncFlush) {
       this.triggerActiveFlush();
@@ -5628,7 +5893,7 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
       this.queue.clear();
       return;
     }
-    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _41 => _41.batchSize]), () => ( this.defaultBatchSize));
+    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _37 => _37.batchSize]), () => ( this.defaultBatchSize));
     const wrappedItems = this.queue.drain();
     if (wrappedItems.length === 0) {
       return;
@@ -5653,33 +5918,33 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
     if (allItems.length === 0) {
       return;
     }
-    const allItemsStr = allItems.map(
-      (bucket) => bucket.map((item) => JSON.stringify(item))
+    const allItemsWithMeta = allItems.map(
+      (item) => stringifyWithOverflowMeta(item)
     );
-    const batchSets = batchItems({
-      items: allItemsStr,
+    const maxRequestSizeResult = await this.getMaxRequestSize();
+    const batches = batchItems({
+      items: allItemsWithMeta,
       batchMaxNumItems: batchSize,
-      batchMaxNumBytes: this.maxRequestSize / 2
+      batchMaxNumBytes: maxRequestSizeResult.maxRequestSize / 2,
+      getByteSize: (item) => item.str.length
     });
-    for (const batchSet of batchSets) {
-      const postPromises = batchSet.map(
-        (batch) => (async () => {
-          try {
-            await this.submitLogsRequest(batch);
-            return { type: "success" };
-          } catch (e) {
-            return { type: "error", value: e };
-          }
-        })()
+    const postPromises = batches.map(
+      (batch) => (async () => {
+        try {
+          await this.submitLogsRequest(batch, maxRequestSizeResult);
+          return { type: "success" };
+        } catch (e) {
+          return { type: "error", value: e };
+        }
+      })()
+    );
+    const results = await Promise.all(postPromises);
+    const failingResultErrors = results.map((r) => r.type === "success" ? void 0 : r.value).filter((r) => r !== void 0);
+    if (failingResultErrors.length) {
+      throw new AggregateError(
+        failingResultErrors,
+        `Encountered the following errors while logging:`
       );
-      const results = await Promise.all(postPromises);
-      const failingResultErrors = results.map((r) => r.type === "success" ? void 0 : r.value).filter((r) => r !== void 0);
-      if (failingResultErrors.length) {
-        throw new AggregateError(
-          failingResultErrors,
-          `Encountered the following errors while logging:`
-        );
-      }
     }
     const attachmentErrors = [];
     for (const attachment of attachments) {
@@ -5709,32 +5974,30 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
         items.forEach((item) => extractAttachments(item, attachments));
         let mergedItems = mergeRowBatch(items);
         if (this.maskingFunction) {
-          mergedItems = mergedItems.map(
-            (batch) => batch.map((item) => {
-              const maskedItem = { ...item };
-              for (const field of REDACTION_FIELDS) {
-                if (item[field] !== void 0) {
-                  const maskedValue = applyMaskingToField(
-                    this.maskingFunction,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    item[field],
-                    field
-                  );
-                  if (maskedValue instanceof MaskingError) {
-                    delete maskedItem[field];
-                    if (maskedItem.error) {
-                      maskedItem.error = `${maskedItem.error}; ${maskedValue.errorMsg}`;
-                    } else {
-                      maskedItem.error = maskedValue.errorMsg;
-                    }
+          mergedItems = mergedItems.map((item) => {
+            const maskedItem = { ...item };
+            for (const field of REDACTION_FIELDS) {
+              if (item[field] !== void 0) {
+                const maskedValue = applyMaskingToField(
+                  this.maskingFunction,
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  item[field],
+                  field
+                );
+                if (maskedValue instanceof MaskingError) {
+                  delete maskedItem[field];
+                  if (maskedItem.error) {
+                    maskedItem.error = `${maskedItem.error}; ${maskedValue.errorMsg}`;
                   } else {
-                    maskedItem[field] = maskedValue;
+                    maskedItem.error = maskedValue.errorMsg;
                   }
+                } else {
+                  maskedItem[field] = maskedValue;
                 }
               }
-              return maskedItem;
-            })
-          );
+            }
+            return maskedItem;
+          });
         }
         return [mergedItems, attachments];
       } catch (e) {
@@ -5761,20 +6024,73 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
     }
     throw new Error("Impossible");
   }
-  async submitLogsRequest(items) {
+  async requestLogs3OverflowUpload(conn, args) {
+    let response;
+    try {
+      response = await conn.post_json("logs3/overflow", {
+        content_type: "application/json",
+        size_bytes: args.sizeBytes,
+        rows: args.rows
+      });
+    } catch (error) {
+      const errorStr = JSON.stringify(error);
+      throw new Error(
+        `Failed to request logs3 overflow upload URL: ${errorStr}`
+      );
+    }
+    try {
+      return logs3OverflowUploadSchema.parse(response);
+    } catch (error) {
+      if (error instanceof _v3.ZodError) {
+        const errorStr = JSON.stringify(error.flatten());
+        throw new Error(`Invalid response from API server: ${errorStr}`);
+      }
+      throw error;
+    }
+  }
+  async _uploadLogs3OverflowPayload(conn, upload, payload) {
+    await uploadLogs3OverflowPayload(upload, payload, conn.fetch.bind(conn));
+  }
+  async submitLogsRequest(items, {
+    maxRequestSize,
+    canUseOverflow
+  }) {
     const conn = await this.apiConn.get();
     const dataStr = constructLogs3Data(items);
+    const payloadBytes = utf8ByteLength(dataStr);
+    const useOverflow = canUseOverflow && payloadBytes > maxRequestSize;
     if (this.allPublishPayloadsDir) {
       await _HTTPBackgroundLogger.writePayloadToDir({
         payloadDir: this.allPublishPayloadsDir,
         payload: dataStr
       });
     }
+    let overflowUpload = null;
+    const overflowRows = useOverflow ? items.map((item) => item.overflowMeta) : null;
     for (let i = 0; i < this.numTries; i++) {
       const startTime = now();
       let error = void 0;
       try {
-        await conn.post_json("logs3", dataStr);
+        if (overflowRows) {
+          if (!overflowUpload) {
+            const currentUpload = await this.requestLogs3OverflowUpload(conn, {
+              rows: overflowRows,
+              sizeBytes: payloadBytes
+            });
+            await this._uploadLogs3OverflowPayload(
+              conn,
+              currentUpload,
+              dataStr
+            );
+            overflowUpload = currentUpload;
+          }
+          await conn.post_json(
+            "logs3",
+            constructLogs3OverflowRequest(overflowUpload.key)
+          );
+        } else {
+          await conn.post_json("logs3", dataStr);
+        }
       } catch (e) {
         error = e;
       }
@@ -5790,7 +6106,7 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
           return `${error}`;
         }
       })();
-      const errMsg = `log request failed. Elapsed time: ${(now() - startTime) / 1e3} seconds. Payload size: ${dataStr.length}.${retryingText}
+      const errMsg = `log request failed. Elapsed time: ${(now() - startTime) / 1e3} seconds. Payload size: ${payloadBytes}.${retryingText}
 Error: ${errorText}`;
       if (!isRetrying && this.failedPublishPayloadsDir) {
         await _HTTPBackgroundLogger.writePayloadToDir({
@@ -5844,7 +6160,7 @@ Error: ${errorText}`;
     try {
       const [allItems, allAttachments] = await this.unwrapLazyValues(wrappedItems);
       const dataStr = constructLogs3Data(
-        allItems.map((x) => JSON.stringify(x))
+        allItems.map((x) => stringifyWithOverflowMeta(x))
       );
       const attachmentStr = JSON.stringify(
         allAttachments.map((a) => a.debugInfo())
@@ -5893,10 +6209,10 @@ Error: ${errorText}`;
         } catch (err) {
           if (err instanceof AggregateError) {
             for (const e of err.errors) {
-              _optionalChain([this, 'access', _42 => _42.onFlushError, 'optionalCall', _43 => _43(e)]);
+              _optionalChain([this, 'access', _38 => _38.onFlushError, 'optionalCall', _39 => _39(e)]);
             }
           } else {
-            _optionalChain([this, 'access', _44 => _44.onFlushError, 'optionalCall', _45 => _45(err)]);
+            _optionalChain([this, 'access', _40 => _40.onFlushError, 'optionalCall', _41 => _41(err)]);
           }
           this.activeFlushError = err;
         } finally {
@@ -6302,24 +6618,24 @@ async function loginToState(options = {}) {
   return state;
 }
 function currentExperiment(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _42 => _42.state]), () => ( _globalState));
   return state.currentExperiment;
 }
 function currentLogger(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _47 => _47.state]), () => ( _globalState));
-  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _48 => _48.asyncFlush]));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _43 => _43.state]), () => ( _globalState));
+  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _44 => _44.asyncFlush]));
 }
 function currentSpan(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _49 => _49.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.state]), () => ( _globalState));
   return _nullishCoalesce(state.contextManager.getCurrentSpan(), () => ( NOOP_SPAN));
 }
 function getSpanParentObject(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _50 => _50.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.state]), () => ( _globalState));
   const parentSpan = currentSpan({ state });
   if (!Object.is(parentSpan, NOOP_SPAN)) {
     return parentSpan;
   }
-  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.parent]), () => ( state.currentParent.getStore()));
+  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _47 => _47.parent]), () => ( state.currentParent.getStore()));
   if (parentStr) return getSpanComponentsClass().fromStr(parentStr);
   const experiment = currentExperiment();
   if (experiment) {
@@ -6348,7 +6664,7 @@ function traced(callback, args) {
   const { span, isSyncFlushLogger } = startSpanAndIsLogger(args);
   const ret = runCatchFinally(
     () => {
-      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _52 => _52.setCurrent]), () => ( true))) {
+      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _48 => _48.setCurrent]), () => ( true))) {
         return withCurrent(span, callback);
       } else {
         return callback(span);
@@ -6360,7 +6676,7 @@ function traced(callback, args) {
     },
     () => span.end()
   );
-  if (_optionalChain([args, 'optionalAccess', _53 => _53.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _54 => _54.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _49 => _49.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _50 => _50.asyncFlush])) {
     return ret;
   } else {
     return (async () => {
@@ -6376,14 +6692,14 @@ function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
 async function flush(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _55 => _55.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.state]), () => ( _globalState));
   return await state.bgLogger().flush();
 }
 function startSpanAndIsLogger(args) {
-  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _56 => _56.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _52 => _52.state]), () => ( _globalState));
   const parentObject = getSpanParentObject({
-    asyncFlush: _optionalChain([args, 'optionalAccess', _57 => _57.asyncFlush]),
-    parent: _optionalChain([args, 'optionalAccess', _58 => _58.parent]),
+    asyncFlush: _optionalChain([args, 'optionalAccess', _53 => _53.asyncFlush]),
+    parent: _optionalChain([args, 'optionalAccess', _54 => _54.parent]),
     state
   });
   if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
@@ -6400,14 +6716,14 @@ function startSpanAndIsLogger(args) {
       ),
       parentComputeObjectMetadataArgs: _nullishCoalesce(parentObject.data.compute_object_metadata_args, () => ( void 0)),
       parentSpanIds,
-      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _59 => _59.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _55 => _55.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', _60 => _60.asyncFlush]) === false
+      _optionalChain([args, 'optionalAccess', _56 => _56.asyncFlush]) === false
     };
   } else {
     const span = parentObject.startSpan(args);
@@ -6553,10 +6869,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _61 => _61.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (_optionalChain([value, 'optionalAccess', _57 => _57.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _62 => _62.reference, 'optionalAccess', _63 => _63.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _64 => _64.uploader])) {
+    if (_optionalChain([value, 'optionalAccess', _58 => _58.reference, 'optionalAccess', _59 => _59.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _60 => _60.uploader])) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -6623,13 +6939,13 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
 var DEFAULT_FETCH_BATCH_SIZE = 1e3;
 var MAX_BTQL_ITERATIONS = 1e4;
 var ObjectFetcher = (_class9 = class {
-  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class9.prototype.__init49.call(this);
+  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class9.prototype.__init50.call(this);
     this.objectType = objectType;
     this.pinnedVersion = pinnedVersion;
     this.mutateRecord = mutateRecord;
     this._internal_btql = _internal_btql;
   }
-  __init49() {this._fetchedData = void 0}
+  __init50() {this._fetchedData = void 0}
   get id() {
     throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
   }
@@ -6707,7 +7023,7 @@ var ObjectFetcher = (_class9 = class {
       }
       return;
     }
-    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _65 => _65.batchSize]))) {
+    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _61 => _61.batchSize]))) {
       yield record;
     }
   }
@@ -6717,7 +7033,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', _66 => _66.batchSize]))) {
+      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _62 => _62.batchSize]))) {
         data.push(record);
       }
       this._fetchedData = data;
@@ -6750,9 +7066,9 @@ var Experiment2 = (_class10 = class extends ObjectFetcher {
   
   
   // For type identification.
-  __init50() {this.kind = "experiment"}
+  __init51() {this.kind = "experiment"}
   constructor(state, lazyMetadata, dataset) {
-    super("experiment", void 0, (r) => enrichAttachments(r, state));_class10.prototype.__init50.call(this);;
+    super("experiment", void 0, (r) => enrichAttachments(r, state));_class10.prototype.__init51.call(this);;
     this.lazyMetadata = lazyMetadata;
     this.dataset = dataset;
     this.lastStartTime = getCurrentUnixTimestamp();
@@ -6812,7 +7128,7 @@ var Experiment2 = (_class10 = class extends ObjectFetcher {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _67 => _67.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _63 => _63.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`"
       );
@@ -6865,12 +7181,12 @@ var Experiment2 = (_class10 = class extends ObjectFetcher {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _68 => _68.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _64 => _64.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: void 0,
         parentSpanIds: void 0,
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _69 => _69.propagatedEvent])
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _65 => _65.propagatedEvent])
       }),
       defaultRootType: "eval" /* EVAL */
     });
@@ -7105,8 +7421,8 @@ var SpanImpl = (_class11 = class _SpanImpl {
   
   
   
-  __init51() {this.kind = "span"}
-  constructor(args) {;_class11.prototype.__init51.call(this);
+  __init52() {this.kind = "span"}
+  constructor(args) {;_class11.prototype.__init52.call(this);
     this._state = args.state;
     const spanAttributes = _nullishCoalesce(args.spanAttributes, () => ( {}));
     const rawEvent = _nullishCoalesce(args.event, () => ( {}));
@@ -7208,8 +7524,8 @@ var SpanImpl = (_class11 = class _SpanImpl {
       ...serializableInternalData,
       [IS_MERGE_FIELD]: this.isMerge
     });
-    if (_optionalChain([partialRecord, 'access', _70 => _70.metrics, 'optionalAccess', _71 => _71.end])) {
-      this.loggedEndTime = _optionalChain([partialRecord, 'access', _72 => _72.metrics, 'optionalAccess', _73 => _73.end]);
+    if (_optionalChain([partialRecord, 'access', _66 => _66.metrics, 'optionalAccess', _67 => _67.end])) {
+      this.loggedEndTime = _optionalChain([partialRecord, 'access', _68 => _68.metrics, 'optionalAccess', _69 => _69.end]);
     }
     if (this.parentObjectType === 1 /* EXPERIMENT */) {
       const cachedSpan = {
@@ -7268,18 +7584,18 @@ var SpanImpl = (_class11 = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _74 => _74.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _70 => _70.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this._state,
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _75 => _75.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _71 => _71.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _76 => _76.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _72 => _72.propagatedEvent]), () => ( this.propagatedEvent))
       })
     });
   }
@@ -7293,12 +7609,12 @@ var SpanImpl = (_class11 = class _SpanImpl {
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _77 => _77.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _73 => _73.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _78 => _78.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _74 => _74.propagatedEvent]), () => ( this.propagatedEvent))
       }),
       spanId
     });
@@ -7307,7 +7623,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
     let endTime;
     let internalData = {};
     if (!this.loggedEndTime) {
-      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _79 => _79.endTime]), () => ( getCurrentUnixTimestamp()));
+      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _75 => _75.endTime]), () => ( getCurrentUnixTimestamp()));
       internalData = { metrics: { end: endTime } };
     } else {
       endTime = this.loggedEndTime;
@@ -7358,8 +7674,8 @@ var SpanImpl = (_class11 = class _SpanImpl {
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
       case 2 /* PROJECT_LOGS */: {
-        const projectID = _optionalChain([args, 'optionalAccess', _80 => _80.project_id]) || this.parentObjectId.getSync().value;
-        const projectName = _optionalChain([args, 'optionalAccess', _81 => _81.project_name]);
+        const projectID = _optionalChain([args, 'optionalAccess', _76 => _76.project_id]) || this.parentObjectId.getSync().value;
+        const projectName = _optionalChain([args, 'optionalAccess', _77 => _77.project_name]);
         if (projectID) {
           return `${baseUrl}/object?object_type=project_logs&object_id=${projectID}&id=${this._id}`;
         } else if (projectName) {
@@ -7369,7 +7685,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
         }
       }
       case 1 /* EXPERIMENT */: {
-        const expID = _optionalChain([args, 'optionalAccess', _82 => _82.experiment_id]) || _optionalChain([this, 'access', _83 => _83.parentObjectId, 'optionalAccess', _84 => _84.getSync, 'call', _85 => _85(), 'optionalAccess', _86 => _86.value]);
+        const expID = _optionalChain([args, 'optionalAccess', _78 => _78.experiment_id]) || _optionalChain([this, 'access', _79 => _79.parentObjectId, 'optionalAccess', _80 => _80.getSync, 'call', _81 => _81(), 'optionalAccess', _82 => _82.value]);
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
         } else {
@@ -7459,13 +7775,13 @@ var Dataset2 = (_class12 = class extends ObjectFetcher {
         )
       ),
       _internal_btql
-    );_class12.prototype.__init52.call(this);_class12.prototype.__init53.call(this);;
+    );_class12.prototype.__init53.call(this);_class12.prototype.__init54.call(this);;
     this.state = state;
     this.lazyMetadata = lazyMetadata;
   }
   
-  __init52() {this.__braintrust_dataset_marker = true}
-  __init53() {this.newRecords = 0}
+  __init53() {this.__braintrust_dataset_marker = true}
+  __init54() {this.newRecords = 0}
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).dataset.id;
@@ -7819,14 +8135,14 @@ function renderPromptParams(params, args, options = {}) {
   return params;
 }
 var Prompt2 = (_class13 = class _Prompt {
-  constructor(metadata, defaults, noTrace) {;_class13.prototype.__init54.call(this);_class13.prototype.__init55.call(this);
+  constructor(metadata, defaults, noTrace) {;_class13.prototype.__init55.call(this);_class13.prototype.__init56.call(this);
     this.metadata = metadata;
     this.defaults = defaults;
     this.noTrace = noTrace;
   }
   
-  __init54() {this.hasParsedPromptData = false}
-  __init55() {this.__braintrust_prompt_marker = true}
+  __init55() {this.hasParsedPromptData = false}
+  __init56() {this.__braintrust_prompt_marker = true}
   get id() {
     return this.metadata.id;
   }
@@ -7840,16 +8156,16 @@ var Prompt2 = (_class13 = class _Prompt {
     return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
   }
   get prompt() {
-    return _optionalChain([this, 'access', _87 => _87.getParsedPromptData, 'call', _88 => _88(), 'optionalAccess', _89 => _89.prompt]);
+    return _optionalChain([this, 'access', _83 => _83.getParsedPromptData, 'call', _84 => _84(), 'optionalAccess', _85 => _85.prompt]);
   }
   get version() {
     return this.metadata[TRANSACTION_ID_FIELD];
   }
   get options() {
-    return _optionalChain([this, 'access', _90 => _90.getParsedPromptData, 'call', _91 => _91(), 'optionalAccess', _92 => _92.options]) || {};
+    return _optionalChain([this, 'access', _86 => _86.getParsedPromptData, 'call', _87 => _87(), 'optionalAccess', _88 => _88.options]) || {};
   }
   get templateFormat() {
-    return _optionalChain([this, 'access', _93 => _93.getParsedPromptData, 'call', _94 => _94(), 'optionalAccess', _95 => _95.template_format]);
+    return _optionalChain([this, 'access', _89 => _89.getParsedPromptData, 'call', _90 => _90(), 'optionalAccess', _91 => _91.template_format]);
   }
   get promptData() {
     return this.getParsedPromptData();
@@ -8009,7 +8325,7 @@ var Prompt2 = (_class13 = class _Prompt {
       return {
         type: "chat",
         messages,
-        ..._optionalChain([prompt, 'access', _96 => _96.tools, 'optionalAccess', _97 => _97.trim, 'call', _98 => _98()]) ? {
+        ..._optionalChain([prompt, 'access', _92 => _92.tools, 'optionalAccess', _93 => _93.trim, 'call', _94 => _94()]) ? {
           tools: render(prompt.tools)
         } : void 0
       };
@@ -8054,18 +8370,67 @@ var Prompt2 = (_class13 = class _Prompt {
     );
   }
 }, _class13);
-var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
-
-// src/node.ts
-var _util = require('util');
-var _zlib = require('zlib'); var zlib = _interopRequireWildcard(_zlib);
-function configureNode() {
-  isomorph_default.getRepoInfo = getRepoInfo;
-  isomorph_default.getPastNAncestors = getPastNAncestors;
-  isomorph_default.getEnv = (name) => process.env[name];
-  isomorph_default.getCallerLocation = getCallerLocation;
-  isomorph_default.newAsyncLocalStorage = () => new (0, _async_hooks.AsyncLocalStorage)();
-  isomorph_default.processOn = (event, handler) => {
+var RemoteEvalParameters = (_class14 = class {
+  constructor(metadata) {;_class14.prototype.__init57.call(this);
+    this.metadata = metadata;
+  }
+  __init57() {this.__braintrust_parameters_marker = true}
+  get id() {
+    return this.metadata.id;
+  }
+  get projectId() {
+    return this.metadata.project_id;
+  }
+  get name() {
+    return this.metadata.name;
+  }
+  get slug() {
+    return this.metadata.slug;
+  }
+  get version() {
+    return this.metadata[TRANSACTION_ID_FIELD];
+  }
+  get schema() {
+    return this.metadata.function_data.__schema;
+  }
+  get data() {
+    return _nullishCoalesce(this.metadata.function_data.data, () => ( {}));
+  }
+  validate(data) {
+    if (typeof data !== "object" || data === null) {
+      return false;
+    }
+    const schemaProps = this.schema.properties;
+    if (typeof schemaProps !== "object" || schemaProps === null) {
+      return true;
+    }
+    for (const key of Object.keys(schemaProps)) {
+      if (!(key in data)) {
+        const required = Array.isArray(this.schema.required) ? this.schema.required : [];
+        if (required.includes(key)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  static isParameters(x) {
+    return typeof x === "object" && x !== null && "__braintrust_parameters_marker" in x && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    x.__braintrust_parameters_marker === true;
+  }
+}, _class14);
+var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
+
+// src/node.ts
+var _util = require('util');
+var _zlib = require('zlib'); var zlib = _interopRequireWildcard(_zlib);
+function configureNode() {
+  isomorph_default.getRepoInfo = getRepoInfo;
+  isomorph_default.getPastNAncestors = getPastNAncestors;
+  isomorph_default.getEnv = (name) => process.env[name];
+  isomorph_default.getCallerLocation = getCallerLocation;
+  isomorph_default.newAsyncLocalStorage = () => new (0, _async_hooks.AsyncLocalStorage)();
+  isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };
   isomorph_default.basename = path.basename;
@@ -9133,6 +9498,85 @@ function waterfall(tasks, callback) {
 }
 var waterfall$1 = awaitify(waterfall);
 
+// src/functions/invoke.ts
+async function invoke(args) {
+  const {
+    orgName,
+    apiKey,
+    appUrl,
+    forceLogin,
+    fetch: fetch2,
+    input,
+    messages,
+    parent: parentArg,
+    metadata,
+    tags,
+    state: stateArg,
+    stream,
+    mode,
+    schema,
+    strict,
+    projectId,
+    ...functionIdArgs
+  } = args;
+  const state = _nullishCoalesce(stateArg, () => ( _internalGetGlobalState()));
+  await state.login({
+    orgName,
+    apiKey,
+    appUrl,
+    forceLogin,
+    fetch: fetch2
+  });
+  const parent = parentArg ? typeof parentArg === "string" ? parentArg : await parentArg.export() : await getSpanParentObject().export();
+  const functionId = FunctionId.safeParse({
+    function_id: functionIdArgs.function_id,
+    project_name: functionIdArgs.projectName,
+    slug: functionIdArgs.slug,
+    global_function: functionIdArgs.globalFunction,
+    function_type: functionIdArgs.functionType,
+    prompt_session_id: functionIdArgs.promptSessionId,
+    prompt_session_function_id: functionIdArgs.promptSessionFunctionId,
+    version: functionIdArgs.version
+  });
+  if (!functionId.success) {
+    throw new Error(
+      `Invalid function ID arguments: ${functionId.error.message}`
+    );
+  }
+  const request = {
+    ...functionId.data,
+    input,
+    messages,
+    parent,
+    metadata,
+    tags,
+    stream,
+    mode,
+    strict
+  };
+  const headers = {
+    Accept: stream ? "text/event-stream" : "application/json"
+  };
+  if (projectId) {
+    headers["x-bt-project-id"] = projectId;
+  }
+  if (orgName) {
+    headers["x-bt-org-name"] = orgName;
+  }
+  const resp = await state.proxyConn().post(`function/invoke`, request, {
+    headers
+  });
+  if (stream) {
+    if (!resp.body) {
+      throw new Error("Received empty stream body");
+    }
+    return new BraintrustStream(resp.body);
+  } else {
+    const data = await resp.json();
+    return schema ? schema.parse(data) : data;
+  }
+}
+
 // src/trace.ts
 var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
   constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter) {
@@ -9188,11 +9632,11 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
     return this._state;
   }
 };
-var CachedSpanFetcher = (_class14 = class {
-  __init56() {this.spanCache = /* @__PURE__ */ new Map()}
-  __init57() {this.allFetched = false}
+var CachedSpanFetcher = (_class15 = class {
+  __init58() {this.spanCache = /* @__PURE__ */ new Map()}
+  __init59() {this.allFetched = false}
   
-  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class14.prototype.__init56.call(this);_class14.prototype.__init57.call(this);
+  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class15.prototype.__init58.call(this);_class15.prototype.__init59.call(this);
     if (typeof objectTypeOrFetchFn === "function") {
       this.fetchFn = objectTypeOrFetchFn;
     } else {
@@ -9207,7 +9651,7 @@ var CachedSpanFetcher = (_class14 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _99 => _99.span_attributes, 'optionalAccess', _100 => _100.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _95 => _95.span_attributes, 'optionalAccess', _96 => _96.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -9241,7 +9685,7 @@ var CachedSpanFetcher = (_class14 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _101 => _101.span_attributes, 'optionalAccess', _102 => _102.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _97 => _97.span_attributes, 'optionalAccess', _98 => _98.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -9258,23 +9702,24 @@ var CachedSpanFetcher = (_class14 = class {
     }
     return result;
   }
-}, _class14);
-var LocalTrace = (_class15 = class {
+}, _class15);
+var LocalTrace = (_class16 = class {
   
   
   
   
   
-  __init58() {this.spansFlushed = false}
-  __init59() {this.spansFlushPromise = null}
+  __init60() {this.spansFlushed = false}
+  __init61() {this.spansFlushPromise = null}
   
+  __init62() {this.threadCache = /* @__PURE__ */ new Map()}
   constructor({
     objectType,
     objectId,
     rootSpanId,
     ensureSpansFlushed,
     state
-  }) {;_class15.prototype.__init58.call(this);_class15.prototype.__init59.call(this);
+  }) {;_class16.prototype.__init60.call(this);_class16.prototype.__init61.call(this);_class16.prototype.__init62.call(this);
     this.objectType = objectType;
     this.objectId = objectId;
     this.rootSpanId = rootSpanId;
@@ -9320,11 +9765,11 @@ var LocalTrace = (_class15 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _103 => _103.span_attributes, 'optionalAccess', _104 => _104.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _99 => _99.span_attributes, 'optionalAccess', _100 => _100.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _105 => _105.span_attributes, 'optionalAccess', _106 => _106.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _101 => _101.span_attributes, 'optionalAccess', _102 => _102.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -9338,6 +9783,36 @@ var LocalTrace = (_class15 = class {
     }
     return this.cachedFetcher.getSpans({ spanType });
   }
+  /**
+   * Get the thread (preprocessed messages) for this trace.
+   * Calls the API with the project_default preprocessor (which falls back to "thread").
+   */
+  async getThread(options) {
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _103 => _103.preprocessor]), () => ( "project_default"));
+    if (!this.threadCache.has(cacheKey)) {
+      const promise = this.fetchThread(options);
+      this.threadCache.set(cacheKey, promise);
+    }
+    return this.threadCache.get(cacheKey);
+  }
+  async fetchThread(options) {
+    await this.ensureSpansReady();
+    await this.state.login({});
+    const result = await invoke({
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _104 => _104.preprocessor]), () => ( "project_default")),
+      functionType: "preprocessor",
+      input: {
+        trace_ref: {
+          object_type: this.objectType,
+          object_id: this.objectId,
+          root_span_id: this.rootSpanId
+        }
+      },
+      mode: "json",
+      state: this.state
+    });
+    return Array.isArray(result) ? result : [];
+  }
   async ensureSpansReady() {
     if (this.spansFlushed || !this.ensureSpansFlushed) {
       return;
@@ -9355,7 +9830,7 @@ var LocalTrace = (_class15 = class {
     }
     await this.spansFlushPromise;
   }
-}, _class15);
+}, _class16);
 
 // src/reporters/progress.ts
 var SimpleProgressReporter = class {
@@ -9372,662 +9847,385 @@ var SimpleProgressReporter = class {
 
 // src/eval-parameters.ts
 
+var _ajv = require('ajv'); var _ajv2 = _interopRequireDefault(_ajv);
 
-// src/framework2.ts
+// src/prompt-schemas.ts
 
-var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
-var ProjectBuilder = class {
-  create(opts) {
-    return new Project2(opts);
+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(),
+    templateFormat: _v3.z.enum(["mustache", "nunjucks", "none"]).optional()
+  })
+);
+var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
+  _v3.z.object({
+    tools: _v3.z.array(ToolFunctionDefinition).optional()
+  })
+);
+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
+    },
+    ...promptDefinition.templateFormat ? { template_format: promptDefinition.templateFormat } : {}
+  };
+}
+
+// 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
+  ])
+);
+async function validateParameters(parameters, parameterSchema) {
+  let resolvedSchema = parameterSchema;
+  if (resolvedSchema instanceof Promise) {
+    resolvedSchema = await resolvedSchema;
+  }
+  if (resolvedSchema === void 0 || resolvedSchema === null) {
+    return parameters;
+  }
+  if (RemoteEvalParameters.isParameters(resolvedSchema)) {
+    const mergedParameters = parameters && Object.keys(parameters).length > 0 ? {
+      ...resolvedSchema.data,
+      ...parameters
+    } : resolvedSchema.data;
+    return validateParametersWithJsonSchema(
+      mergedParameters,
+      resolvedSchema.schema
+    );
   }
-};
-var projects = new ProjectBuilder();
-var Project2 = (_class16 = class {
-  
-  
-  
-  
-  
-  __init60() {this._publishableCodeFunctions = []}
-  __init61() {this._publishablePrompts = []}
-  constructor(args) {;_class16.prototype.__init60.call(this);_class16.prototype.__init61.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);
+  return validateParametersWithZod(
+    parameters,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    resolvedSchema
+  );
+}
+function validateParametersWithZod(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)}`
+        );
+      }
+    })
+  );
+}
+function validateParametersWithJsonSchema(parameters, schema) {
+  const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
+  const validate = ajv.compile(schema);
+  if (!validate(parameters)) {
+    const errorMessages = _optionalChain([validate, 'access', _105 => _105.errors, 'optionalAccess', _106 => _106.map, 'call', _107 => _107((err) => {
+      const path2 = err.instancePath || "root";
+      return `${path2}: ${err.message}`;
+    }), 'access', _108 => _108.join, 'call', _109 => _109(", ")]);
+    throw Error(`Invalid parameters: ${errorMessages}`);
   }
-  addPrompt(prompt) {
-    this._publishablePrompts.push(prompt);
-    if (globalThis._lazy_load) {
-      globalThis._evals.prompts.push(prompt);
-    }
+  return parameters;
+}
+
+// src/framework.ts
+var EvalResultWithSummary = class {
+  constructor(summary, results) {
+    this.summary = summary;
+    this.results = results;
   }
-  addCodeFunction(fn) {
-    this._publishableCodeFunctions.push(fn);
-    if (globalThis._lazy_load) {
-      globalThis._evals.functions.push(fn);
-    }
+  /**
+   * @deprecated Use `summary` instead.
+   */
+  toString() {
+    return JSON.stringify(this.summary);
   }
-  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
-    });
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `EvalResultWithSummary(summary="...", results=[...])`;
   }
-}, _class16);
-var ToolBuilder = (_class17 = class {
-  constructor(project) {;_class17.prototype.__init62.call(this);
-    this.project = project;
+  toJSON() {
+    return {
+      summary: this.summary,
+      results: this.results
+    };
   }
-  __init62() {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;
+};
+function makeEvalName(projectName, experimentName) {
+  let out = projectName;
+  if (experimentName) {
+    out += ` [experimentName=${experimentName}]`;
   }
-}, _class17);
-var ScorerBuilder = (_class18 = class {
-  constructor(project) {;_class18.prototype.__init63.call(this);
-    this.project = project;
+  return out;
+}
+function initExperiment(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;
   }
-  __init63() {this.taskCounter = 0}
-  create(opts) {
-    this.taskCounter++;
-    let resolvedName = opts.name;
-    if (!resolvedName && "handler" in opts) {
-      resolvedName = opts.handler.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: [],
+  parameters: [],
+  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 : initExperiment(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 (!resolvedName || resolvedName.trim().length === 0) {
-      resolvedName = `Scorer ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+    if (experiment && options.onStart) {
+      const summary = await experiment.summarize({ summarizeScores: false });
+      options.onStart(summary);
     }
-    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
-        }
+    try {
+      const evalDef = {
+        evalName,
+        projectName: name,
+        ...evaluator,
+        data
       };
-      const codePrompt = new CodePrompt(
-        this.project,
-        promptData,
-        [],
-        {
-          ...opts,
-          name: resolvedName,
-          slug
-        },
-        "scorer"
-      );
-      this.project.addPrompt(codePrompt);
+      const enableCache = _nullishCoalesce(options.enableCache, () => ( true));
+      let ret;
+      if (options.parent) {
+        ret = await withParent(
+          options.parent,
+          () => runEvaluator(
+            null,
+            evalDef,
+            progressReporter,
+            [],
+            options.stream,
+            options.parameters,
+            shouldCollectResults,
+            enableCache
+          ),
+          evaluator.state
+        );
+      } else {
+        ret = await runEvaluator(
+          experiment,
+          evalDef,
+          progressReporter,
+          [],
+          options.stream,
+          options.parameters,
+          shouldCollectResults,
+          enableCache
+        );
+      }
+      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();
   }
-}, _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");
-    }
+}
+function serializeJSONWithPlainString(v) {
+  if (typeof v === "string") {
+    return v;
+  } else {
+    return JSON.stringify(v);
   }
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  key() {
-    return JSON.stringify([
-      _nullishCoalesce(this.project.id, () => ( "")),
-      _nullishCoalesce(this.project.name, () => ( "")),
-      this.slug
-    ]);
+}
+function evaluateFilter(object, filter2) {
+  const { path: path2, pattern } = filter2;
+  const key = path2.reduce(
+    (acc, p) => typeof acc === "object" && acc !== null ? (
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      acc[p]
+    ) : void 0,
+    object
+  );
+  if (key === void 0) {
+    return false;
   }
-};
-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(),
-    templateFormat: _v3.z.enum(["mustache", "nunjucks", "none"]).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
-    },
-    ...promptDefinition.templateFormat ? { template_format: promptDefinition.templateFormat } : {}
-  };
+  return pattern.test(serializeJSONWithPlainString(key));
 }
-var ProjectNameIdMap = (_class19 = class {constructor() { _class19.prototype.__init64.call(this);_class19.prototype.__init65.call(this); }
-  __init64() {this.nameToId = {}}
-  __init65() {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];
+function scorerName(scorer, scorer_idx) {
+  return scorer.name || `scorer_${scorer_idx}`;
+}
+async function runEvaluator(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults = true, enableCache = true) {
+  return await runEvaluatorInternal(
+    experiment,
+    evaluator,
+    progressReporter,
+    filters,
+    stream,
+    parameters,
+    collectResults,
+    enableCache
+  );
+}
+async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
+  if (enableCache) {
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _110 => _110.spanCache, 'optionalAccess', _111 => _111.start, 'call', _112 => _112()]);
   }
-  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;
+  try {
+    if (typeof evaluator.data === "string") {
+      throw new Error("Unimplemented: string data paths");
     }
-    return this.idToName[projectId];
-  }
-  async resolve(project) {
-    if (project.id) {
-      return project.id;
+    let dataResult = typeof evaluator.data === "function" ? evaluator.data() : evaluator.data;
+    parameters = await validateParameters(
+      _nullishCoalesce(parameters, () => ( {})),
+      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 = initExperiment(evaluator.state, {
+        ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: evaluator.projectName },
+        experiment: name,
+        open: true
+      }).asDataset();
     }
-    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`);
+    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;
           }
-          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
-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 initExperiment(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 : initExperiment(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
-      };
-      const enableCache = _nullishCoalesce(options.enableCache, () => ( true));
-      let ret;
-      if (options.parent) {
-        ret = await withParent(
-          options.parent,
-          () => runEvaluator(
-            null,
-            evalDef,
-            progressReporter,
-            [],
-            options.stream,
-            options.parameters,
-            shouldCollectResults,
-            enableCache
-          ),
-          evaluator.state
-        );
-      } else {
-        ret = await runEvaluator(
-          experiment,
-          evalDef,
-          progressReporter,
-          [],
-          options.stream,
-          options.parameters,
-          shouldCollectResults,
-          enableCache
-        );
-      }
-      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 serializeJSONWithPlainString(v) {
-  if (typeof v === "string") {
-    return v;
-  } else {
-    return JSON.stringify(v);
-  }
-}
-function evaluateFilter(object, filter2) {
-  const { path: path2, pattern } = filter2;
-  const key = path2.reduce(
-    (acc, p) => typeof acc === "object" && acc !== null ? (
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      acc[p]
-    ) : 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, enableCache = true) {
-  return await runEvaluatorInternal(
-    experiment,
-    evaluator,
-    progressReporter,
-    filters,
-    stream,
-    parameters,
-    collectResults,
-    enableCache
-  );
-}
-async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
-  if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _107 => _107.spanCache, 'optionalAccess', _108 => _108.start, 'call', _109 => _109()]);
-  }
-  try {
-    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 = initExperiment(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"
@@ -10093,7 +10291,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _110 => _110.data, 'access', async _111 => _111.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _113 => _113.data, 'access', async _114 => _114.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -10119,10 +10317,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _112 => _112({
+                    _optionalChain([stream, 'optionalCall', _115 => _115({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _113 => _113.event, 'optionalAccess', _114 => _114.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _116 => _116.event, 'optionalAccess', _117 => _117.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -10150,6 +10348,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             } else {
               rootSpan.log({ output, metadata, expected });
             }
+            if (evaluator.flushBeforeScoring) {
+              await rootSpan.flush();
+            }
             const scoringArgs = {
               input: datum.input,
               expected: "expected" in datum ? datum.expected : void 0,
@@ -10283,7 +10484,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _115 => _115.event, 'optionalAccess', _116 => _116.origin])
+              origin: _optionalChain([baseEvent, 'access', _118 => _118.event, 'optionalAccess', _119 => _119.origin])
             });
           }
         };
@@ -10316,7 +10517,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _117 => _117.setTotal, 'optionalCall', _118 => _118(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _120 => _120.setTotal, 'optionalCall', _121 => _121(evaluator.evalName, scheduledTrials)]);
           q.push({ datum, trialIndex });
         }
       }
@@ -10378,427 +10579,918 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         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 : []
-    );
-  } finally {
-    if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _119 => _119.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _120 => _120.dispose, 'call', _121 => _121()]);
-      _optionalChain([spanCache, 'optionalAccess', _122 => _122.stop, 'call', _123 => _123()]);
+    const summary = experiment ? await experiment.summarize({
+      summarizeScores: evaluator.summarizeScores
+    }) : buildLocalSummary(
+      evaluator,
+      collectResults ? collectedResults : [],
+      _nullishCoalesce(localScoreAccumulator, () => ( void 0))
+    );
+    return new EvalResultWithSummary(
+      summary,
+      collectResults ? collectedResults : []
+    );
+  } finally {
+    if (enableCache) {
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _122 => _122.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _123 => _123.dispose, 'call', _124 => _124()]);
+      _optionalChain([spanCache, 'optionalAccess', _125 => _125.stop, 'call', _126 => _126()]);
+    }
+  }
+}
+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/errorHandler.ts
+
+var errorHandler = (err, req, res, next) => {
+  if ("status" in err) {
+    res.status(err.status).json({
+      error: {
+        message: err.message,
+        status: err.status
+      }
+    });
+    return;
+  }
+  if (err instanceof _v3.z.ZodError) {
+    res.status(400).json({
+      error: {
+        message: "Invalid request",
+        errors: err.errors
+      }
+    });
+    return;
+  }
+  console.error("Internal server error", err);
+  res.status(500).json({
+    error: {
+      message: "Internal server error",
+      status: 500
+    }
+  });
+};
+
+// dev/authorize.ts
+var _httperrors = require('http-errors'); var _httperrors2 = _interopRequireDefault(_httperrors);
+function authorizeRequest(req, res, next) {
+  try {
+    const ctx = {
+      appOrigin: extractAllowedOrigin(req.headers[ORIGIN_HEADER]),
+      token: void 0,
+      state: void 0,
+      projectId: parseHeader(req.headers, PROJECT_ID_HEADER)
+    };
+    if (req.headers.authorization || req.headers[BRAINTRUST_AUTH_TOKEN_HEADER]) {
+      const tokenText = parseBraintrustAuthHeader(req.headers);
+      if (!tokenText) {
+        return next(_httperrors2.default.call(void 0, 400, "Invalid authorization token format"));
+      }
+      ctx.token = tokenText.toLowerCase() === "null" ? void 0 : tokenText;
+    }
+    req.ctx = ctx;
+    next();
+  } catch (e) {
+    next(e);
+  }
+}
+var loginCache = new LRUCache({
+  max: 32
+  // TODO: Make this configurable
+});
+async function cachedLogin(options) {
+  const key = JSON.stringify(options);
+  const cached = loginCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const state = await loginToState(options);
+  loginCache.set(key, state);
+  return state;
+}
+function makeCheckAuthorized(allowedOrgName) {
+  return async (req, _res, next) => {
+    if (!_optionalChain([req, 'access', _127 => _127.ctx, 'optionalAccess', _128 => _128.token])) {
+      return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
+    }
+    try {
+      const orgName = parseHeader(req.headers, "x-bt-org-name");
+      if (!orgName) {
+        return next(_httperrors2.default.call(void 0, 400, "Missing x-bt-org-name header"));
+      }
+      if (allowedOrgName && allowedOrgName !== orgName) {
+        const errorMessage = `Org '${orgName}' is not allowed. Only org '${allowedOrgName}' is allowed.`;
+        return next(_httperrors2.default.call(void 0, 403, errorMessage));
+      }
+      const state = await cachedLogin({
+        apiKey: _optionalChain([req, 'access', _129 => _129.ctx, 'optionalAccess', _130 => _130.token]),
+        orgName
+      });
+      req.ctx.state = state;
+      next();
+    } catch (e) {
+      console.error("Authorization error:", e);
+      return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
+    }
+  };
+}
+function parseBraintrustAuthHeader(headers) {
+  const tokenString = parseHeader(headers, BRAINTRUST_AUTH_TOKEN_HEADER);
+  return _nullishCoalesce(_nullishCoalesce(tokenString, () => ( parseAuthHeader(headers))), () => ( void 0));
+}
+function parseHeader(headers, headerName) {
+  const token = headers[headerName];
+  let tokenString;
+  if (typeof token === "string") {
+    tokenString = token;
+  } else if (Array.isArray(token) && token.length > 0) {
+    tokenString = token[0];
+  }
+  return tokenString;
+}
+function checkOrigin(requestOrigin, callback) {
+  if (!requestOrigin) {
+    return callback(null, true);
+  }
+  for (const origin of WHITELISTED_ORIGINS || []) {
+    if (origin instanceof RegExp && origin.test(requestOrigin) || origin === requestOrigin) {
+      return callback(null, requestOrigin);
+    }
+  }
+  return callback(null, false);
+}
+var BRAINTRUST_AUTH_TOKEN_HEADER = "x-bt-auth-token";
+var ORIGIN_HEADER = "origin";
+var PROJECT_ID_HEADER = "x-bt-project-id";
+function extractAllowedOrigin(originHeader) {
+  let allowedOrigin = MAIN_ORIGIN;
+  checkOrigin(originHeader, (err, origin) => {
+    if (!err && originHeader && origin) {
+      allowedOrigin = originHeader;
+    }
+  });
+  return allowedOrigin;
+}
+var MAIN_ORIGIN = "https://www.braintrust.dev";
+var WHITELISTED_ORIGINS = [
+  MAIN_ORIGIN,
+  "https://www.braintrustdata.com",
+  new RegExp("https://.*.preview.braintrust.dev")
+].concat(
+  process.env.WHITELISTED_ORIGIN ? [process.env.WHITELISTED_ORIGIN] : []
+).concat(
+  process.env.BRAINTRUST_APP_URL ? [process.env.BRAINTRUST_APP_URL] : []
+);
+function parseAuthHeader(headers) {
+  const authHeader = headers["authorization"];
+  let authValue = null;
+  if (Array.isArray(authHeader)) {
+    authValue = authHeader[authHeader.length - 1];
+  } else {
+    authValue = authHeader;
+  }
+  if (!authValue) {
+    return null;
+  }
+  const parts = authValue.split(" ");
+  if (parts.length !== 2) {
+    return null;
+  }
+  return parts[1];
+}
+var baseAllowedHeaders = [
+  "Content-Type",
+  "X-Amz-Date",
+  "Authorization",
+  "X-Api-Key",
+  "X-Amz-Security-Token",
+  "x-bt-auth-token",
+  "x-bt-parent",
+  // These are eval-specific
+  "x-bt-org-name",
+  "x-bt-project-id",
+  "x-bt-stream-fmt",
+  "x-bt-use-cache",
+  "x-stainless-os",
+  "x-stainless-lang",
+  "x-stainless-package-version",
+  "x-stainless-runtime",
+  "x-stainless-runtime-version",
+  "x-stainless-arch"
+];
+
+// dev/stream.ts
+function serializeSSEEvent(event) {
+  return Object.entries(event).filter(([_key, value]) => value !== void 0).map(([key, value]) => `${key}: ${value}`).join("\n") + "\n\n";
+}
+
+// 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 staticParametersSchema = _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()),
+      default: _v3.z.unknown().optional(),
+      description: _v3.z.string().optional()
+    })
+  ])
+);
+var parametersSchema = _v3.z.object({
+  type: _v3.z.literal("object"),
+  properties: _v3.z.record(_v3.z.string(), _v3.z.record(_v3.z.unknown())),
+  required: _v3.z.array(_v3.z.string()).optional(),
+  additionalProperties: _v3.z.boolean().optional()
+});
+var parametersSourceSchema = _v3.z.object({
+  parametersId: _v3.z.string().optional(),
+  slug: _v3.z.string(),
+  name: _v3.z.string(),
+  projectId: _v3.z.string().optional(),
+  version: _v3.z.string().optional()
+});
+var parametersContainerSchema = _v3.z.object({
+  type: _v3.z.literal("braintrust.parameters"),
+  schema: parametersSchema,
+  source: parametersSourceSchema
+});
+var staticParametersContainerSchema = _v3.z.object({
+  type: _v3.z.literal("braintrust.staticParameters"),
+  schema: staticParametersSchema,
+  source: _v3.z.null()
+});
+var serializedParametersContainerSchema = _v3.z.union([
+  parametersContainerSchema,
+  staticParametersContainerSchema,
+  // keeping this type here since old versions of the SDK will still pass the unwrapped schema and we need to handle this in the app
+  staticParametersSchema
+]);
+var evaluatorDefinitionSchema = _v3.z.object({
+  parameters: serializedParametersContainerSchema.optional(),
+  scores: _v3.z.array(_v3.z.object({ name: _v3.z.string() })).optional()
+});
+var evaluatorDefinitionsSchema = _v3.z.record(
+  _v3.z.string(),
+  evaluatorDefinitionSchema
+);
+
+// dev/server.ts
+
+
+
+// src/framework2.ts
+
+
+// src/zod/utils.ts
+var _zodtojsonschema = require('zod-to-json-schema');
+var _v4 = require('zod/v4'); var z42 = _interopRequireWildcard(_v4);
+function isZodV4(zodObject) {
+  return typeof zodObject === "object" && zodObject !== null && "_zod" in zodObject && zodObject._zod !== void 0;
+}
+function zodToJsonSchema(schema) {
+  if (isZodV4(schema)) {
+    return z42.toJSONSchema(schema, {
+      target: "draft-7"
+    });
+  }
+  return _zodtojsonschema.zodToJsonSchema.call(void 0, schema);
+}
+
+// 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 = (_class17 = class {
+  
+  
+  
+  
+  
+  
+  __init63() {this._publishableCodeFunctions = []}
+  __init64() {this._publishablePrompts = []}
+  __init65() {this._publishableParameters = []}
+  constructor(args) {;_class17.prototype.__init63.call(this);_class17.prototype.__init64.call(this);_class17.prototype.__init65.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.parameters = new ParametersBuilder(this);
+    this.scorers = new ScorerBuilder(this);
+  }
+  addPrompt(prompt) {
+    this._publishablePrompts.push(prompt);
+    if (globalThis._lazy_load) {
+      globalThis._evals.prompts.push(prompt);
+    }
+  }
+  addParameters(parameters) {
+    this._publishableParameters.push(parameters);
+    if (globalThis._lazy_load) {
+      if (globalThis._evals.parameters == null)
+        globalThis._evals.parameters = [];
+      globalThis._evals.parameters.push(parameters);
     }
   }
-}
-var warning = (text) => `Warning: ${text}`;
-function logError2(e, verbose) {
-  if (!verbose) {
-    console.error(`${e}`);
-  } else {
-    console.error(e);
+  addCodeFunction(fn) {
+    this._publishableCodeFunctions.push(fn);
+    if (globalThis._lazy_load) {
+      globalThis._evals.functions.push(fn);
+    }
   }
-}
-function accumulateScores(accumulator, scores) {
-  for (const [name, score] of Object.entries(scores)) {
-    if (score === null || score === void 0) {
-      continue;
+  async publish() {
+    if (globalThis._lazy_load) {
+      console.warn("publish() is a no-op when running `braintrust push`.");
+      return;
     }
-    const existing = _nullishCoalesce(accumulator[name], () => ( { total: 0, count: 0 }));
-    accumulator[name] = {
-      total: existing.total + score,
-      count: existing.count + 1
-    };
+    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
+    });
   }
-}
-function ensureScoreAccumulator(results) {
-  const accumulator = {};
-  for (const result of results) {
-    accumulateScores(accumulator, result.scores);
+}, _class17);
+var ToolBuilder = (_class18 = class {
+  constructor(project) {;_class18.prototype.__init66.call(this);
+    this.project = project;
   }
-  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
+  __init66() {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;
+  }
+}, _class18);
+var ScorerBuilder = (_class19 = class {
+  constructor(project) {;_class19.prototype.__init67.call(this);
+    this.project = project;
+  }
+  __init67() {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
         }
-      ])
-    )
-  };
-}
-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}`
-          )
-        })
+      };
+      const codePrompt = new CodePrompt(
+        this.project,
+        promptData,
+        [],
+        {
+          ...opts,
+          name: resolvedName,
+          slug
+        },
+        "scorer"
       );
-    } else {
-      for (const result of failingResults) {
-        logError2(result.error, verbose);
-      }
+      this.project.addPrompt(codePrompt);
     }
-    if (!verbose && !jsonl) {
-      console.error(warning("Add --verbose to see full stack traces."));
+  }
+}, _class19);
+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");
     }
   }
-}
-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)}`
-            );
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  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 {
-            isomorph_default.writeln(
-              `${metric.name.padEnd(20)} ${metricValue.padStart(15)}`
-            );
+            return fn;
           }
-        }
-      }
-      if (summary.experimentUrl) {
-        isomorph_default.writeln("");
-        isomorph_default.writeln(`View results for ${summary.experimentName}`);
-        isomorph_default.writeln(`See results at ${summary.experimentUrl}`);
-      }
+        })
+      );
+      prompt_data.tool_functions = // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      resolvableToolFunctions;
     }
-    isomorph_default.writeln("");
-    return failingResults.length === 0;
-  },
-  async reportRun(evalReports) {
-    return evalReports.every((r) => r);
+    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
+    };
   }
 };
-
-// dev/errorHandler.ts
-
-var errorHandler = (err, req, res, next) => {
-  if ("status" in err) {
-    res.status(err.status).json({
-      error: {
-        message: err.message,
-        status: err.status
-      }
-    });
-    return;
+var PromptBuilder = class {
+  constructor(project) {
+    this.project = project;
   }
-  if (err instanceof _v3.z.ZodError) {
-    res.status(400).json({
-      error: {
-        message: "Invalid request",
-        errors: err.errors
+  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
     });
-    return;
+    this.project.addPrompt(codePrompt);
+    return prompt;
   }
-  console.error("Internal server error", err);
-  res.status(500).json({
-    error: {
-      message: "Internal server error",
-      status: 500
-    }
-  });
 };
-
-// dev/authorize.ts
-var _httperrors = require('http-errors'); var _httperrors2 = _interopRequireDefault(_httperrors);
-function authorizeRequest(req, res, next) {
-  try {
-    const ctx = {
-      appOrigin: extractAllowedOrigin(req.headers[ORIGIN_HEADER]),
-      token: void 0,
-      state: void 0,
-      projectId: parseHeader(req.headers, PROJECT_ID_HEADER)
+var CodeParameters = class {
+  
+  
+  
+  
+  
+  
+  
+  constructor(project, opts) {
+    this.project = project;
+    this.name = opts.name;
+    this.slug = opts.slug;
+    this.description = opts.description;
+    this.schema = opts.schema;
+    this.ifExists = opts.ifExists;
+    this.metadata = opts.metadata;
+  }
+  async toFunctionDefinition(projectNameToId) {
+    return {
+      project_id: await projectNameToId.resolve(this.project),
+      name: this.name,
+      slug: this.slug,
+      description: _nullishCoalesce(this.description, () => ( "")),
+      function_type: "parameters",
+      function_data: {
+        type: "parameters",
+        data: {},
+        __schema: serializeEvalParameterstoParametersSchema(this.schema)
+      },
+      if_exists: this.ifExists,
+      metadata: this.metadata
     };
-    if (req.headers.authorization || req.headers[BRAINTRUST_AUTH_TOKEN_HEADER]) {
-      const tokenText = parseBraintrustAuthHeader(req.headers);
-      if (!tokenText) {
-        return next(_httperrors2.default.call(void 0, 400, "Invalid authorization token format"));
-      }
-      ctx.token = tokenText.toLowerCase() === "null" ? void 0 : tokenText;
-    }
-    req.ctx = ctx;
-    next();
-  } catch (e) {
-    next(e);
   }
-}
-var loginCache = new LRUCache({
-  max: 32
-  // TODO: Make this configurable
-});
-async function cachedLogin(options) {
-  const key = JSON.stringify(options);
-  const cached = loginCache.get(key);
-  if (cached) {
-    return cached;
+};
+var ParametersBuilder = class {
+  constructor(project) {
+    this.project = project;
   }
-  const state = await loginToState(options);
-  loginCache.set(key, state);
-  return state;
+  create(opts) {
+    const slug = _nullishCoalesce(opts.slug, () => ( slugify(opts.name, { lower: true, strict: true })));
+    const codeParameters = new CodeParameters(this.project, {
+      name: opts.name,
+      slug,
+      description: opts.description,
+      schema: opts.schema,
+      ifExists: opts.ifExists,
+      metadata: opts.metadata
+    });
+    this.project.addParameters(codeParameters);
+    return opts.schema;
+  }
+};
+function serializeEvalParametersToStaticParametersSchema(parameters) {
+  return Object.fromEntries(
+    Object.entries(parameters).map(([name, value]) => {
+      if ("type" in value && value.type === "prompt") {
+        return [
+          name,
+          {
+            type: "prompt",
+            default: value.default ? promptDefinitionToPromptData(value.default) : void 0,
+            description: value.description
+          }
+        ];
+      } else {
+        const schemaObj = zodToJsonSchema(value);
+        return [
+          name,
+          {
+            type: "data",
+            schema: schemaObj,
+            default: schemaObj.default,
+            description: schemaObj.description
+          }
+        ];
+      }
+    })
+  );
 }
-function makeCheckAuthorized(allowedOrgName) {
-  return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _124 => _124.ctx, 'optionalAccess', _125 => _125.token])) {
-      return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
-    }
-    try {
-      const orgName = parseHeader(req.headers, "x-bt-org-name");
-      if (!orgName) {
-        return next(_httperrors2.default.call(void 0, 400, "Missing x-bt-org-name header"));
+function serializeEvalParameterstoParametersSchema(parameters) {
+  const properties = {};
+  const required = [];
+  for (const [name, value] of Object.entries(parameters)) {
+    if ("type" in value && value.type === "prompt") {
+      const defaultPromptData = value.default ? promptDefinitionToPromptData(value.default) : void 0;
+      properties[name] = {
+        type: "object",
+        "x-bt-type": "prompt",
+        ...value.description ? { description: value.description } : {},
+        ...defaultPromptData ? { default: defaultPromptData } : {}
+      };
+      if (!defaultPromptData) {
+        required.push(name);
       }
-      if (allowedOrgName && allowedOrgName !== orgName) {
-        const errorMessage = `Org '${orgName}' is not allowed. Only org '${allowedOrgName}' is allowed.`;
-        return next(_httperrors2.default.call(void 0, 403, errorMessage));
+    } else {
+      const schemaObj = zodToJsonSchema(value);
+      properties[name] = schemaObj;
+      if (!("default" in schemaObj)) {
+        required.push(name);
       }
-      const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _126 => _126.ctx, 'optionalAccess', _127 => _127.token]),
-        orgName
-      });
-      req.ctx.state = state;
-      next();
-    } catch (e) {
-      console.error("Authorization error:", e);
-      return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    additionalProperties: true
   };
 }
-function parseBraintrustAuthHeader(headers) {
-  const tokenString = parseHeader(headers, BRAINTRUST_AUTH_TOKEN_HEADER);
-  return _nullishCoalesce(_nullishCoalesce(tokenString, () => ( parseAuthHeader(headers))), () => ( void 0));
-}
-function parseHeader(headers, headerName) {
-  const token = headers[headerName];
-  let tokenString;
-  if (typeof token === "string") {
-    tokenString = token;
-  } else if (Array.isArray(token) && token.length > 0) {
-    tokenString = token[0];
+function serializeRemoteEvalParametersContainer(parameters) {
+  if (RemoteEvalParameters.isParameters(parameters)) {
+    return {
+      type: "braintrust.parameters",
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      schema: parameters.schema,
+      source: {
+        parametersId: parameters.id,
+        slug: parameters.slug,
+        name: parameters.name,
+        projectId: parameters.projectId,
+        version: parameters.version
+      }
+    };
   }
-  return tokenString;
+  return {
+    type: "braintrust.staticParameters",
+    schema: serializeEvalParametersToStaticParametersSchema(parameters),
+    source: null
+  };
 }
-function checkOrigin(requestOrigin, callback) {
-  if (!requestOrigin) {
-    return callback(null, true);
-  }
-  for (const origin of WHITELISTED_ORIGINS || []) {
-    if (origin instanceof RegExp && origin.test(requestOrigin) || origin === requestOrigin) {
-      return callback(null, requestOrigin);
+var ProjectNameIdMap = (_class20 = class {constructor() { _class20.prototype.__init68.call(this);_class20.prototype.__init69.call(this); }
+  __init68() {this.nameToId = {}}
+  __init69() {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];
   }
-  return callback(null, false);
-}
-var BRAINTRUST_AUTH_TOKEN_HEADER = "x-bt-auth-token";
-var ORIGIN_HEADER = "origin";
-var PROJECT_ID_HEADER = "x-bt-project-id";
-function extractAllowedOrigin(originHeader) {
-  let allowedOrigin = MAIN_ORIGIN;
-  checkOrigin(originHeader, (err, origin) => {
-    if (!err && originHeader && origin) {
-      allowedOrigin = originHeader;
+  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 allowedOrigin;
-}
-var MAIN_ORIGIN = "https://www.braintrust.dev";
-var WHITELISTED_ORIGINS = [
-  MAIN_ORIGIN,
-  "https://www.braintrustdata.com",
-  new RegExp("https://.*.preview.braintrust.dev")
-].concat(
-  process.env.WHITELISTED_ORIGIN ? [process.env.WHITELISTED_ORIGIN] : []
-).concat(
-  process.env.BRAINTRUST_APP_URL ? [process.env.BRAINTRUST_APP_URL] : []
-);
-function parseAuthHeader(headers) {
-  const authHeader = headers["authorization"];
-  let authValue = null;
-  if (Array.isArray(authHeader)) {
-    authValue = authHeader[authHeader.length - 1];
-  } else {
-    authValue = authHeader;
-  }
-  if (!authValue) {
-    return null;
-  }
-  const parts = authValue.split(" ");
-  if (parts.length !== 2) {
-    return null;
+    return this.idToName[projectId];
   }
-  return parts[1];
-}
-var baseAllowedHeaders = [
-  "Content-Type",
-  "X-Amz-Date",
-  "Authorization",
-  "X-Api-Key",
-  "X-Amz-Security-Token",
-  "x-bt-auth-token",
-  "x-bt-parent",
-  // These are eval-specific
-  "x-bt-org-name",
-  "x-bt-project-id",
-  "x-bt-stream-fmt",
-  "x-bt-use-cache",
-  "x-stainless-os",
-  "x-stainless-lang",
-  "x-stainless-package-version",
-  "x-stainless-runtime",
-  "x-stainless-runtime-version",
-  "x-stainless-arch"
-];
-
-// dev/stream.ts
-function serializeSSEEvent(event) {
-  return Object.entries(event).filter(([_key, value]) => value !== void 0).map(([key, value]) => `${key}: ${value}`).join("\n") + "\n\n";
-}
-
-// 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
-);
-
-// dev/server.ts
-
-
-// src/zod/utils.ts
-var _zodtojsonschema = require('zod-to-json-schema');
-var _v4 = require('zod/v4'); var z42 = _interopRequireWildcard(_v4);
-function isZodV4(zodObject) {
-  return typeof zodObject === "object" && zodObject !== null && "_zod" in zodObject && zodObject._zod !== void 0;
-}
-function zodToJsonSchema(schema) {
-  if (isZodV4(schema)) {
-    return z42.toJSONSchema(schema, {
-      target: "draft-7"
-    });
+  async resolve(project) {
+    if (project.id) {
+      return project.id;
+    }
+    return this.getId(project.name);
   }
-  return _zodtojsonschema.zodToJsonSchema.call(void 0, schema);
-}
+}, _class20);
 
 // dev/server.ts
 function runDevServer(evaluators, opts) {
@@ -10835,20 +11527,27 @@ function runDevServer(evaluators, opts) {
   app.get("/", (req, res) => {
     res.send("Hello, world!");
   });
-  app.get("/list", checkAuthorized, (req, res) => {
-    const evalDefs = Object.fromEntries(
-      Object.entries(allEvaluators).map(([name, evaluator]) => [
-        name,
-        {
-          parameters: evaluator.parameters ? makeEvalParametersSchema(evaluator.parameters) : void 0,
+  app.get(
+    "/list",
+    checkAuthorized,
+    asyncHandler(async (req, res) => {
+      const evalDefs = {};
+      for (const [name, evaluator] of Object.entries(allEvaluators)) {
+        let parameters;
+        if (evaluator.parameters) {
+          const resolvedParams = await Promise.resolve(evaluator.parameters);
+          parameters = serializeRemoteEvalParametersContainer(resolvedParams);
+        }
+        evalDefs[name] = {
+          parameters,
           scores: evaluator.scores.map((score, idx) => ({
             name: scorerName(score, idx)
           }))
-        }
-      ])
-    );
-    res.json(evalDefs);
-  });
+        };
+      }
+      res.json(evalDefs);
+    })
+  );
   app.post(
     "/eval",
     checkAuthorized,
@@ -10863,7 +11562,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _128 => _128.ctx, 'optionalAccess', _129 => _129.state])) {
+      if (!_optionalChain([req, 'access', _131 => _131.ctx, 'optionalAccess', _132 => _132.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -10873,18 +11572,12 @@ function runDevServer(evaluators, opts) {
         res.status(404).json({ error: `Evaluator '${name}' not found` });
         return;
       }
-      if (evaluator.parameters && Object.keys(evaluator.parameters).length > 0) {
+      if (evaluator.parameters) {
         try {
-          if (!evaluator.parameters) {
-            res.status(400).json({
-              error: `Evaluator '${name}' does not accept parameters`
-            });
-            return;
-          }
-          validateParameters(_nullishCoalesce(parameters, () => ( {})), evaluator.parameters);
+          await validateParameters(_nullishCoalesce(parameters, () => ( {})), evaluator.parameters);
         } catch (e) {
           console.error("Error validating parameters", e);
-          if (e instanceof _v3.z.ZodError || e instanceof Error) {
+          if (e instanceof _v3.z.ZodError || e instanceof _ajv.ValidationError || e instanceof Error) {
             res.status(400).json({
               error: e.message
             });
@@ -10920,12 +11613,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: evaluator.scores.concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _130 => _130.map, 'call', _131 => _131(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _133 => _133.map, 'call', _134 => _134(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _132 => _132.ctx, 'optionalAccess', _133 => _133.projectId])
+                  _optionalChain([req, 'access', _135 => _135.ctx, 'optionalAccess', _136 => _136.projectId])
                 )
               )]), () => ( []))
             ),
@@ -11077,33 +11770,6 @@ function makeScorer(state, name, score, projectId) {
   });
   return ret;
 }
-function makeEvalParametersSchema(parameters) {
-  return Object.fromEntries(
-    Object.entries(parameters).map(([name, value]) => {
-      if ("type" in value && value.type === "prompt") {
-        return [
-          name,
-          {
-            type: "prompt",
-            default: value.default ? promptDefinitionToPromptData(value.default) : void 0,
-            description: value.description
-          }
-        ];
-      } else {
-        const schemaObj = zodToJsonSchema(value);
-        return [
-          name,
-          {
-            type: "data",
-            schema: schemaObj,
-            default: schemaObj.default,
-            description: schemaObj.description
-          }
-        ];
-      }
-    })
-  );
-}
 
 // dev/index.ts
 configureNode();