braintrust 2.2.0 → 2.2.1

package/dist/cli.js

@@ -1275,7 +1275,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "2.2.0",
+      version: "2.2.1",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
@@ -1394,6 +1394,7 @@ var require_package = __commonJS({
         "@next/env": "^14.2.3",
         "@types/nunjucks": "^3.2.6",
         "@vercel/functions": "^1.0.2",
+        ajv: "^8.17.1",
         argparse: "^2.0.1",
         boxen: "^8.0.1",
         chalk: "^4.1.2",
@@ -1523,11 +1524,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
 var uuid3 = __toESM(require("uuid"));
@@ -2205,13 +2214,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];
 }
@@ -2226,72 +2228,8 @@ function getObjValueByPath(row, path8) {
   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 = 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") {
-      lastVisitF?.(vertex);
-      continue;
-    }
-    if (firstVisitedVertices.has(vertex)) {
-      continue;
-    }
-    firstVisitedVertices.add(vertex);
-    firstVisitF?.(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 = args?.parentVertex !== void 0 ? mapAt(vertexLabels, args?.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",
@@ -2300,7 +2238,7 @@ function generateMergedRowKey(row, useParentIdForId) {
       "dataset_id",
       "prompt_session_id",
       "log_id",
-      useParentIdForId ?? false ? PARENT_ID_FIELD : "id"
+      "id"
     ].map((k) => row[k])
   );
 }
@@ -2354,96 +2292,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 = args.batchMaxNumItems ?? Number.POSITIVE_INFINITY;
   const batchMaxNumBytes = 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;
 }
@@ -3050,10 +2926,15 @@ var FunctionTypeEnum = import_v36.z.enum([
   "preprocessor",
   "facet",
   "classifier",
-  "tag"
+  "tag",
+  "parameters"
 ]);
 var NullableSavedFunctionId = import_v36.z.union([
-  import_v36.z.object({ type: import_v36.z.literal("function"), id: import_v36.z.string() }),
+  import_v36.z.object({
+    type: import_v36.z.literal("function"),
+    id: import_v36.z.string(),
+    version: import_v36.z.string().optional()
+  }),
   import_v36.z.object({
     type: import_v36.z.literal("global"),
     name: import_v36.z.string(),
@@ -3061,6 +2942,67 @@ var NullableSavedFunctionId = import_v36.z.union([
   }),
   import_v36.z.null()
 ]);
+var TopicMapReport = import_v36.z.object({
+  version: import_v36.z.literal(1),
+  created_at: import_v36.z.string().optional(),
+  settings: import_v36.z.object({
+    algorithm: import_v36.z.enum(["hdbscan", "kmeans", "hierarchical"]),
+    dimension_reduction: import_v36.z.enum(["umap", "pca", "none"]),
+    vector_field: import_v36.z.string(),
+    embedding_model: import_v36.z.string(),
+    n_clusters: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+    umap_dimensions: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+    min_cluster_size: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+    min_samples: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional()
+  }),
+  query_settings: import_v36.z.object({
+    hierarchy_threshold: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]),
+    auto_naming: import_v36.z.boolean(),
+    skip_cache: import_v36.z.boolean(),
+    viz_mode: import_v36.z.enum(["bar", "scatter"]),
+    naming_model: import_v36.z.string()
+  }).partial(),
+  clusters: import_v36.z.array(
+    import_v36.z.object({
+      cluster_id: import_v36.z.number(),
+      parent_cluster_id: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+      topic_id: import_v36.z.string(),
+      count: import_v36.z.number(),
+      sample_texts: import_v36.z.array(import_v36.z.string()),
+      samples: import_v36.z.array(
+        import_v36.z.object({
+          id: import_v36.z.string(),
+          text: import_v36.z.string(),
+          root_span_id: import_v36.z.string(),
+          span_id: import_v36.z.string()
+        })
+      ),
+      name: import_v36.z.string().optional(),
+      description: import_v36.z.string().optional(),
+      keywords: import_v36.z.array(import_v36.z.string()).optional(),
+      centroid: import_v36.z.array(import_v36.z.number()).optional(),
+      parent_id: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+      is_leaf: import_v36.z.boolean().optional(),
+      depth: import_v36.z.number().optional()
+    })
+  ),
+  embedding_points: import_v36.z.array(
+    import_v36.z.object({
+      x: import_v36.z.number(),
+      y: import_v36.z.number(),
+      cluster: import_v36.z.number(),
+      text: import_v36.z.string().optional()
+    })
+  ).optional()
+});
+var TopicMapData = import_v36.z.object({
+  type: import_v36.z.literal("topic_map"),
+  source_facet: import_v36.z.string(),
+  embedding_model: import_v36.z.string(),
+  bundle_key: import_v36.z.string(),
+  distance_threshold: import_v36.z.number().optional(),
+  report: TopicMapReport.optional()
+});
 var BatchedFacetData = import_v36.z.object({
   type: import_v36.z.literal("batched_facet"),
   preprocessor: NullableSavedFunctionId.and(import_v36.z.unknown()).optional(),
@@ -3069,9 +3011,17 @@ var BatchedFacetData = import_v36.z.object({
       name: import_v36.z.string(),
       prompt: import_v36.z.string(),
       model: import_v36.z.string().optional(),
+      embedding_model: import_v36.z.string().optional(),
       no_match_pattern: import_v36.z.string().optional()
     })
-  )
+  ),
+  topic_maps: import_v36.z.record(
+    import_v36.z.object({
+      function_name: import_v36.z.string(),
+      topic_map_id: import_v36.z.string().optional(),
+      topic_map_data: TopicMapData
+    })
+  ).optional()
 });
 var BraintrustModelParams = import_v36.z.object({
   use_cache: import_v36.z.boolean(),
@@ -3282,6 +3232,18 @@ var ObjectReferenceNullish = import_v36.z.union([
   }),
   import_v36.z.null()
 ]);
+var SavedFunctionId = import_v36.z.union([
+  import_v36.z.object({
+    type: import_v36.z.literal("function"),
+    id: import_v36.z.string(),
+    version: import_v36.z.string().optional()
+  }),
+  import_v36.z.object({
+    type: import_v36.z.literal("global"),
+    name: import_v36.z.string(),
+    function_type: FunctionTypeEnum.optional().default("scorer")
+  })
+]);
 var DatasetEvent = import_v36.z.object({
   id: import_v36.z.string(),
   _xact_id: import_v36.z.string(),
@@ -3301,7 +3263,36 @@ var DatasetEvent = import_v36.z.object({
   is_root: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]).optional(),
   origin: ObjectReferenceNullish.optional(),
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
-  audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional()
+  audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
+  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  classifications: import_v36.z.union([
+    import_v36.z.record(
+      import_v36.z.array(
+        import_v36.z.object({
+          id: import_v36.z.string(),
+          label: import_v36.z.string().optional(),
+          confidence: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+          metadata: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            import_v36.z.union([
+              import_v36.z.object({
+                type: import_v36.z.literal("function"),
+                id: import_v36.z.string(),
+                version: import_v36.z.string().optional()
+              }),
+              import_v36.z.object({
+                type: import_v36.z.literal("global"),
+                name: import_v36.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              import_v36.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    import_v36.z.null()
+  ]).optional()
 });
 var EnvVar = import_v36.z.object({
   id: import_v36.z.string().uuid(),
@@ -3378,7 +3369,8 @@ var SpanType = import_v36.z.union([
     "automation",
     "facet",
     "preprocessor",
-    "classifier"
+    "classifier",
+    "review"
   ]),
   import_v36.z.null()
 ]);
@@ -3419,10 +3411,43 @@ var ExperimentEvent = import_v36.z.object({
   is_root: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]).optional(),
   origin: ObjectReferenceNullish.optional(),
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
-  audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional()
+  audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
+  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  classifications: import_v36.z.union([
+    import_v36.z.record(
+      import_v36.z.array(
+        import_v36.z.object({
+          id: import_v36.z.string(),
+          label: import_v36.z.string().optional(),
+          confidence: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+          metadata: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            import_v36.z.union([
+              import_v36.z.object({
+                type: import_v36.z.literal("function"),
+                id: import_v36.z.string(),
+                version: import_v36.z.string().optional()
+              }),
+              import_v36.z.object({
+                type: import_v36.z.literal("global"),
+                name: import_v36.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              import_v36.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    import_v36.z.null()
+  ]).optional()
 });
 var ExtendedSavedFunctionId = import_v36.z.union([
-  import_v36.z.object({ type: import_v36.z.literal("function"), id: import_v36.z.string() }),
+  import_v36.z.object({
+    type: import_v36.z.literal("function"),
+    id: import_v36.z.string(),
+    version: import_v36.z.string().optional()
+  }),
   import_v36.z.object({
     type: import_v36.z.literal("global"),
     name: import_v36.z.string(),
@@ -3439,6 +3464,7 @@ var FacetData = import_v36.z.object({
   preprocessor: NullableSavedFunctionId.and(import_v36.z.unknown()).optional(),
   prompt: import_v36.z.string(),
   model: import_v36.z.string().optional(),
+  embedding_model: import_v36.z.string().optional(),
   no_match_pattern: import_v36.z.string().optional()
 });
 var PromptBlockDataNullish = import_v36.z.union([
@@ -3528,14 +3554,6 @@ var PromptParserNullish = import_v36.z.union([
   }),
   import_v36.z.null()
 ]);
-var SavedFunctionId = import_v36.z.union([
-  import_v36.z.object({ type: import_v36.z.literal("function"), id: import_v36.z.string() }),
-  import_v36.z.object({
-    type: import_v36.z.literal("global"),
-    name: import_v36.z.string(),
-    function_type: FunctionTypeEnum.optional().default("scorer")
-  })
-]);
 var PromptDataNullish = import_v36.z.union([
   import_v36.z.object({
     prompt: PromptBlockDataNullish,
@@ -3586,7 +3604,8 @@ var FunctionTypeEnumNullish = import_v36.z.union([
     "preprocessor",
     "facet",
     "classifier",
-    "tag"
+    "tag",
+    "parameters"
   ]),
   import_v36.z.null()
 ]);
@@ -3678,7 +3697,8 @@ var FunctionData = import_v36.z.union([
     type: import_v36.z.literal("remote_eval"),
     endpoint: import_v36.z.string(),
     eval_name: import_v36.z.string(),
-    parameters: import_v36.z.object({}).partial().passthrough()
+    parameters: import_v36.z.object({}).partial().passthrough(),
+    parameters_version: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
   }),
   import_v36.z.object({
     type: import_v36.z.literal("global"),
@@ -3687,7 +3707,18 @@ var FunctionData = import_v36.z.union([
     config: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional()
   }),
   FacetData,
-  BatchedFacetData
+  BatchedFacetData,
+  import_v36.z.object({
+    type: import_v36.z.literal("parameters"),
+    data: import_v36.z.object({}).partial().passthrough(),
+    __schema: import_v36.z.object({
+      type: import_v36.z.literal("object"),
+      properties: import_v36.z.record(import_v36.z.object({}).partial().passthrough()),
+      required: import_v36.z.array(import_v36.z.string()).optional(),
+      additionalProperties: import_v36.z.boolean().optional()
+    })
+  }),
+  TopicMapData.and(import_v36.z.unknown())
 ]);
 var Function2 = import_v36.z.object({
   id: import_v36.z.string().uuid(),
@@ -3717,7 +3748,13 @@ var Function2 = import_v36.z.object({
     import_v36.z.null()
   ]).optional()
 });
-var FunctionFormat = import_v36.z.enum(["llm", "code", "global", "graph"]);
+var FunctionFormat = import_v36.z.enum([
+  "llm",
+  "code",
+  "global",
+  "graph",
+  "topic_map"
+]);
 var PromptData = import_v36.z.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
@@ -3800,13 +3837,14 @@ var FunctionObjectType = import_v36.z.enum([
   "custom_view",
   "preprocessor",
   "facet",
-  "classifier"
+  "classifier",
+  "parameters"
 ]);
 var FunctionOutputType = import_v36.z.enum([
   "completion",
   "score",
   "facet",
-  "tag",
+  "classification",
   "any"
 ]);
 var GitMetadataSettings = import_v36.z.object({
@@ -3842,6 +3880,10 @@ var GroupScope = import_v36.z.object({
   idle_seconds: import_v36.z.number().optional()
 });
 var IfExists = import_v36.z.enum(["error", "ignore", "replace"]);
+var ImageRenderingMode = import_v36.z.union([
+  import_v36.z.enum(["auto", "click_to_load", "blocked"]),
+  import_v36.z.null()
+]);
 var InvokeParent = import_v36.z.union([
   import_v36.z.object({
     object_type: import_v36.z.enum(["project_logs", "experiment", "playground_logs"]),
@@ -3934,7 +3976,8 @@ var Organization = import_v36.z.object({
   is_universal_api: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]).optional(),
   proxy_url: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   realtime_url: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
-  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
+  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  image_rendering_mode: ImageRenderingMode.optional()
 });
 var ProjectSettings = import_v36.z.union([
   import_v36.z.object({
@@ -4075,7 +4118,36 @@ var ProjectLogsEvent = import_v36.z.object({
   origin: ObjectReferenceNullish.optional(),
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
-  _async_scoring_state: import_v36.z.unknown().optional()
+  _async_scoring_state: import_v36.z.unknown().optional(),
+  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  classifications: import_v36.z.union([
+    import_v36.z.record(
+      import_v36.z.array(
+        import_v36.z.object({
+          id: import_v36.z.string(),
+          label: import_v36.z.string().optional(),
+          confidence: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+          metadata: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            import_v36.z.union([
+              import_v36.z.object({
+                type: import_v36.z.literal("function"),
+                id: import_v36.z.string(),
+                version: import_v36.z.string().optional()
+              }),
+              import_v36.z.object({
+                type: import_v36.z.literal("global"),
+                name: import_v36.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              import_v36.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    import_v36.z.null()
+  ]).optional()
 });
 var ProjectScoreType = import_v36.z.enum([
   "slider",
@@ -4377,12 +4449,15 @@ var View = import_v36.z.object({
     "datasets",
     "dataset",
     "prompts",
+    "parameters",
     "tools",
     "scorers",
     "classifiers",
     "logs",
     "monitor",
-    "for_review"
+    "for_review_project_log",
+    "for_review_experiments",
+    "for_review_datasets"
   ]),
   name: import_v36.z.string(),
   created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
@@ -5139,6 +5214,52 @@ var PromptCache = class {
   }
 };
 
+// src/prompt-cache/parameters-cache.ts
+function createCacheKey2(key) {
+  if (key.id) {
+    return `parameters:id:${key.id}`;
+  }
+  const prefix = 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}:${key.version ?? "latest"}`;
+}
+var ParametersCache = class {
+  memoryCache;
+  diskCache;
+  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;
@@ -5429,7 +5550,24 @@ var SpanCache = 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 = import_v38.z.object({
+  id: import_v38.z.string().uuid(),
+  _xact_id: import_v38.z.string(),
+  project_id: import_v38.z.string().uuid(),
+  name: import_v38.z.string(),
+  slug: import_v38.z.string(),
+  description: import_v38.z.union([import_v38.z.string(), import_v38.z.null()]).optional(),
+  function_type: import_v38.z.literal("parameters"),
+  function_data: import_v38.z.object({
+    type: import_v38.z.literal("parameters"),
+    data: import_v38.z.record(import_v38.z.unknown()).optional(),
+    __schema: import_v38.z.record(import_v38.z.unknown())
+  }),
+  metadata: import_v38.z.union([import_v38.z.object({}).partial().passthrough(), import_v38.z.null()]).optional()
+});
 var LoginInvalidOrgError = class extends Error {
   constructor(message) {
     super(message);
@@ -5606,6 +5744,17 @@ var BraintrustState = class _BraintrustState {
       max: Number(isomorph_default.getEnv("BRAINTRUST_PROMPT_CACHE_DISK_MAX")) ?? 1 << 20
     }) : void 0;
     this.promptCache = new PromptCache({ memoryCache, diskCache });
+    const parametersMemoryCache = new LRUCache({
+      max: Number(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX")) ?? 1 << 10
+    });
+    const parametersDiskCache = canUseDiskCache() ? new DiskCache({
+      cacheDir: isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_DIR") ?? `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/parameters_cache`,
+      max: 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 });
   }
   id;
@@ -5635,6 +5784,7 @@ var BraintrustState = class _BraintrustState {
   _apiConn = null;
   _proxyConn = null;
   promptCache;
+  parametersCache;
   spanCache;
   _idGenerator = null;
   _contextManager = null;
@@ -6736,8 +6886,100 @@ function castLogger(logger, asyncFlush) {
   }
   return logger;
 }
+var logs3OverflowUploadSchema = import_v38.z.object({
+  method: import_v38.z.enum(["PUT", "POST"]),
+  signedUrl: import_v38.z.string().url(),
+  headers: import_v38.z.record(import_v38.z.string()).optional(),
+  fields: import_v38.z.record(import_v38.z.string()).optional(),
+  key: import_v38.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 = upload.fields["Content-Type"] ?? "application/json";
+    form.append("file", new Blob([payload], { type: contentType }));
+    const headers2 = {};
+    for (const [key, value] of Object.entries(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 = { ...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();
@@ -6752,8 +6994,8 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
   onFlushError;
   maskingFunction = null;
   syncFlush = false;
-  // 6 MB for the AWS lambda gateway (from our own testing).
-  maxRequestSize = 6 * 1024 * 1024;
+  maxRequestSizeOverride = null;
+  _maxRequestSizePromise = null;
   defaultBatchSize = 100;
   numTries = 3;
   queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE;
@@ -6781,7 +7023,7 @@ var HTTPBackgroundLogger = 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)) {
@@ -6843,6 +7085,30 @@ var HTTPBackgroundLogger = 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 = import_v38.z.object({ logs3_payload_max_bytes: import_v38.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();
@@ -6886,33 +7152,33 @@ var HTTPBackgroundLogger = 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) {
@@ -6942,32 +7208,30 @@ var HTTPBackgroundLogger = 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) {
@@ -6994,20 +7258,73 @@ var HTTPBackgroundLogger = 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 (error2) {
+      const errorStr = JSON.stringify(error2);
+      throw new Error(
+        `Failed to request logs3 overflow upload URL: ${errorStr}`
+      );
+    }
+    try {
+      return logs3OverflowUploadSchema.parse(response);
+    } catch (error2) {
+      if (error2 instanceof import_v38.ZodError) {
+        const errorStr = JSON.stringify(error2.flatten());
+        throw new Error(`Invalid response from API server: ${errorStr}`);
+      }
+      throw error2;
+    }
+  }
+  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 error2 = 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) {
         error2 = e;
       }
@@ -7023,7 +7340,7 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
           return `${error2}`;
         }
       })();
-      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({
@@ -7077,7 +7394,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())
@@ -9287,22 +9604,71 @@ var Prompt2 = class _Prompt {
     );
   }
 };
-var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
-
-// src/cli/reporters/progress.ts
-var import_chalk = __toESM(require("chalk"));
-var cliProgress = __toESM(require("cli-progress"));
-
-// src/reporters/progress.ts
-var SimpleProgressReporter = class {
-  start(name, _total) {
-    console.log(`Running evaluator ${name}`);
+var RemoteEvalParameters = class {
+  constructor(metadata) {
+    this.metadata = metadata;
   }
-  stop() {
+  __braintrust_parameters_marker = true;
+  get id() {
+    return this.metadata.id;
   }
-  increment(_name) {
+  get projectId() {
+    return this.metadata.project_id;
   }
-  setTotal(_name, _total) {
+  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 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;
+  }
+};
+var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
+
+// src/cli/reporters/progress.ts
+var import_chalk = __toESM(require("chalk"));
+var cliProgress = __toESM(require("cli-progress"));
+
+// src/reporters/progress.ts
+var SimpleProgressReporter = class {
+  start(name, _total) {
+    console.log(`Running evaluator ${name}`);
+  }
+  stop() {
+  }
+  increment(_name) {
+  }
+  setTotal(_name, _total) {
   }
 };
 
@@ -10385,6 +10751,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 = 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) {
@@ -10520,6 +10965,7 @@ var LocalTrace = class {
   spansFlushed = false;
   spansFlushPromise = null;
   cachedFetcher;
+  threadCache = /* @__PURE__ */ new Map();
   constructor({
     objectType,
     objectId,
@@ -10590,6 +11036,36 @@ var LocalTrace = 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 = options?.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: options?.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;
@@ -10611,660 +11087,383 @@ var LocalTrace = class {
 
 // src/eval-parameters.ts
 var import_v310 = require("zod/v3");
+var import_ajv = __toESM(require("ajv"));
 
-// src/framework2.ts
+// src/prompt-schemas.ts
 var import_v39 = require("zod/v3");
-var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
-var ProjectBuilder = class {
-  create(opts) {
-    return new Project2(opts);
+var promptContentsSchema = import_v39.z.union([
+  import_v39.z.object({
+    prompt: import_v39.z.string()
+  }),
+  import_v39.z.object({
+    messages: import_v39.z.array(ChatCompletionMessageParam)
+  })
+]);
+var promptDefinitionSchema = promptContentsSchema.and(
+  import_v39.z.object({
+    model: import_v39.z.string(),
+    params: ModelParams.optional(),
+    templateFormat: import_v39.z.enum(["mustache", "nunjucks", "none"]).optional()
+  })
+);
+var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
+  import_v39.z.object({
+    tools: import_v39.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 = import_v310.z.record(
+  import_v310.z.string(),
+  import_v310.z.union([
+    import_v310.z.object({
+      type: import_v310.z.literal("prompt"),
+      default: promptDefinitionWithToolsSchema.optional(),
+      description: import_v310.z.string().optional()
+    }),
+    import_v310.z.instanceof(import_v310.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 = class {
-  name;
-  id;
-  tools;
-  prompts;
-  scorers;
-  _publishableCodeFunctions = [];
-  _publishablePrompts = [];
-  constructor(args) {
-    _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 import_ajv.default({ coerceTypes: true, useDefaults: true, strict: false });
+  const validate = ajv.compile(schema);
+  if (!validate(parameters)) {
+    const errorMessages = validate.errors?.map((err) => {
+      const path8 = err.instancePath || "root";
+      return `${path8}: ${err.message}`;
+    }).join(", ");
+    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=[...])`;
+  }
+  toJSON() {
+    return {
+      summary: this.summary,
+      results: this.results
+    };
   }
 };
-var ToolBuilder = class {
-  constructor(project) {
-    this.project = project;
+function makeEvalName(projectName, experimentName) {
+  let out = projectName;
+  if (experimentName) {
+    out += ` [experimentName=${experimentName}]`;
   }
-  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 = opts ?? {};
-    const { handler, name, slug, parameters, returns, ...rest } = opts;
-    let resolvedName = 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: 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;
+  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: [],
+  parameters: [],
+  evaluators: {},
+  reporters: {}
 };
-var ScorerBuilder = class {
-  constructor(project) {
-    this.project = project;
+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}`;
   }
-  taskCounter = 0;
-  create(opts) {
-    this.taskCounter++;
-    let resolvedName = opts.name;
-    if (!resolvedName && "handler" in opts) {
-      resolvedName = opts.handler.name;
+  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 = options.progress ?? new SimpleProgressReporter();
+  const shouldCollectResults = 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: 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 = 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 = 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();
   }
-};
-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);
   }
-  handler;
-  name;
-  slug;
-  type;
-  description;
-  parameters;
-  returns;
-  ifExists;
-  metadata;
-  key() {
-    return JSON.stringify([
-      this.project.id ?? "",
-      this.project.name ?? "",
-      this.slug
-    ]);
+}
+function deserializePlainStringAsJSON2(s) {
+  try {
+    return { value: JSON.parse(s), error: void 0 };
+  } catch (e) {
+    return { value: s, error: e };
   }
-};
-var CodePrompt = class {
-  project;
-  name;
-  slug;
-  prompt;
-  ifExists;
-  description;
-  id;
-  functionType;
-  toolFunctions;
-  metadata;
-  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;
+}
+function parseFilters(filters) {
+  const result = [];
+  for (const f of filters) {
+    const equalsIdx = f.indexOf("=");
+    if (equalsIdx === -1) {
+      throw new Error(`Invalid filter ${f}`);
     }
-    return {
-      project_id: await projectNameToId.resolve(this.project),
-      name: this.name,
-      slug: this.slug,
-      description: this.description ?? "",
-      function_data: {
-        type: "prompt"
-      },
-      function_type: this.functionType,
-      prompt_data,
-      if_exists: this.ifExists,
-      metadata: this.metadata
-    };
-  }
-};
-var promptContentsSchema = import_v39.z.union([
-  import_v39.z.object({
-    prompt: import_v39.z.string()
-  }),
-  import_v39.z.object({
-    messages: import_v39.z.array(ChatCompletionMessageParam)
-  })
-]);
-var promptDefinitionSchema = promptContentsSchema.and(
-  import_v39.z.object({
-    model: import_v39.z.string(),
-    params: ModelParams.optional(),
-    templateFormat: import_v39.z.enum(["mustache", "nunjucks", "none"]).optional()
-  })
-);
-var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
-  import_v39.z.object({
-    tools: import_v39.z.array(ToolFunctionDefinition).optional()
-  })
-);
-var PromptBuilder = class {
-  constructor(project) {
-    this.project = project;
-  }
-  create(opts) {
-    const toolFunctions = [];
-    const rawTools = [];
-    for (const tool of 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 [path8, value] = [f.slice(0, equalsIdx), f.slice(equalsIdx + 1)];
+    let deserializedValue = deserializePlainStringAsJSON2(value).value;
+    if (typeof deserializedValue !== "string") {
+      deserializedValue = value;
     }
-    const slug = 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.
-      opts.noTrace ?? false
-    );
-    const codePrompt = new CodePrompt(this.project, promptData, toolFunctions, {
-      ...opts,
-      slug
+    result.push({
+      path: path8.split("."),
+      pattern: new RegExp(deserializedValue)
     });
-    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 result;
 }
-var ProjectNameIdMap = class {
-  nameToId = {};
-  idToName = {};
-  async getId(projectName) {
-    if (!(projectName in this.nameToId)) {
-      const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
-        project_name: projectName
-      });
-      const result = import_v39.z.object({
-        project: Project
-      }).parse(response);
-      const projectId = result.project.id;
-      this.nameToId[projectName] = projectId;
-      this.idToName[projectId] = projectName;
-    }
-    return this.nameToId[projectName];
+function evaluateFilter(object, filter2) {
+  const { path: path8, pattern } = filter2;
+  const key = path8.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;
   }
-  async getName(projectId) {
-    if (!(projectId in this.idToName)) {
-      const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
-        id: projectId
-      });
-      const result = import_v39.z.array(Project).nonempty().parse(response);
-      const projectName = result[0].name;
-      this.idToName[projectId] = projectName;
-      this.nameToId[projectName] = projectId;
-    }
-    return this.idToName[projectId];
+  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) {
+    (evaluator.state ?? _internalGetGlobalState())?.spanCache?.start();
   }
-  async resolve(project) {
-    if (project.id) {
-      return project.id;
+  try {
+    if (typeof evaluator.data === "string") {
+      throw new Error("Unimplemented: string data paths");
     }
-    return this.getId(project.name);
-  }
-};
-
-// src/eval-parameters.ts
-var evalParametersSchema = import_v310.z.record(
-  import_v310.z.string(),
-  import_v310.z.union([
-    import_v310.z.object({
-      type: import_v310.z.literal("prompt"),
-      default: promptDefinitionWithToolsSchema.optional(),
-      description: import_v310.z.string().optional()
-    }),
-    import_v310.z.instanceof(import_v310.z.ZodType)
-    // For Zod schemas
-  ])
-);
-function validateParameters(parameters, parameterSchema) {
-  return Object.fromEntries(
-    Object.entries(parameterSchema).map(([name, schema]) => {
-      const value = parameters[name];
-      try {
-        if ("type" in schema && schema.type === "prompt") {
-          const promptData = value ? PromptData.parse(value) : schema.default ? promptDefinitionToPromptData(
-            schema.default,
-            schema.default.tools
-          ) : void 0;
-          if (!promptData) {
-            throw new Error(`Parameter '${name}' is required`);
-          }
-          return [name, Prompt2.fromPromptData(name, promptData)];
-        } else {
-          const schemaCasted = schema;
-          return [name, schemaCasted.parse(value)];
-        }
-      } catch (e) {
-        console.error("Error validating parameter", name, e);
-        throw Error(
-          `Invalid parameter '${name}': ${e instanceof Error ? e.message : String(e)}`
-        );
-      }
-    })
-  );
-}
-
-// src/framework.ts
-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 = options.progress ?? new SimpleProgressReporter();
-  const shouldCollectResults = 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: 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 = 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 deserializePlainStringAsJSON2(s) {
-  try {
-    return { value: JSON.parse(s), error: void 0 };
-  } catch (e) {
-    return { value: s, error: e };
-  }
-}
-function parseFilters(filters) {
-  const result = [];
-  for (const f of filters) {
-    const equalsIdx = f.indexOf("=");
-    if (equalsIdx === -1) {
-      throw new Error(`Invalid filter ${f}`);
-    }
-    const [path8, value] = [f.slice(0, equalsIdx), f.slice(equalsIdx + 1)];
-    let deserializedValue = deserializePlainStringAsJSON2(value).value;
-    if (typeof deserializedValue !== "string") {
-      deserializedValue = value;
-    }
-    result.push({
-      path: path8.split("."),
-      pattern: new RegExp(deserializedValue)
-    });
-  }
-  return result;
-}
-function evaluateFilter(object, filter2) {
-  const { path: path8, pattern } = filter2;
-  const key = path8.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) {
-    (evaluator.state ?? _internalGetGlobalState())?.spanCache?.start();
-  }
-  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(
-      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 dataResult = typeof evaluator.data === "function" ? evaluator.data() : evaluator.data;
+    parameters = await validateParameters(
+      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;
@@ -11415,6 +11614,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,
@@ -11654,869 +11856,1331 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       summary,
       collectResults ? collectedResults : []
     );
-  } finally {
-    if (enableCache) {
-      const spanCache = (evaluator.state ?? _internalGetGlobalState())?.spanCache;
-      spanCache?.dispose();
-      spanCache?.stop();
-    }
+  } finally {
+    if (enableCache) {
+      const spanCache = (evaluator.state ?? _internalGetGlobalState())?.spanCache;
+      spanCache?.dispose();
+      spanCache?.stop();
+    }
+  }
+}
+var error = (text) => `Error: ${text}`;
+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 = 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 = 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(summary.metrics ?? {}).length > 0;
+      const hasComparison = !!summary.comparisonExperimentName;
+      if (hasScores || hasMetrics) {
+        if (hasComparison) {
+          isomorph_default.writeln(
+            "Name                Value      Change     Improvements Regressions"
+          );
+          isomorph_default.writeln(
+            "----------------------------------------------------------------"
+          );
+        }
+        for (const score of Object.values(summary.scores)) {
+          const scorePercent = (score.score * 100).toFixed(2);
+          const scoreValue = `${scorePercent}%`;
+          if (hasComparison) {
+            let diffString = "-";
+            if (!isEmpty2(score.diff)) {
+              const diffPercent = (score.diff * 100).toFixed(2);
+              const diffSign = score.diff > 0 ? "+" : "";
+              diffString = `${diffSign}${diffPercent}%`;
+            }
+            const improvements = score.improvements > 0 ? score.improvements.toString() : "-";
+            const regressions = score.regressions > 0 ? score.regressions.toString() : "-";
+            isomorph_default.writeln(
+              `${score.name.padEnd(18)} ${scoreValue.padStart(10)} ${diffString.padStart(10)} ${improvements.padStart(12)} ${regressions.padStart(11)}`
+            );
+          } else {
+            isomorph_default.writeln(`${score.name.padEnd(20)} ${scoreValue.padStart(15)}`);
+          }
+        }
+        for (const metric of Object.values(summary.metrics ?? {})) {
+          const fractionDigits = Number.isInteger(metric.metric) ? 0 : 2;
+          const formattedValue = metric.metric.toFixed(fractionDigits);
+          const metricValue = metric.unit === "$" ? `${metric.unit}${formattedValue}` : `${formattedValue}${metric.unit}`;
+          if (hasComparison) {
+            let diffString = "-";
+            if (!isEmpty2(metric.diff)) {
+              const diffPercent = (metric.diff * 100).toFixed(2);
+              const diffSign = metric.diff > 0 ? "+" : "";
+              diffString = `${diffSign}${diffPercent}%`;
+            }
+            const improvements = metric.improvements > 0 ? metric.improvements.toString() : "-";
+            const regressions = metric.regressions > 0 ? metric.regressions.toString() : "-";
+            isomorph_default.writeln(
+              `${metric.name.padEnd(18)} ${metricValue.padStart(10)} ${diffString.padStart(10)} ${improvements.padStart(12)} ${regressions.padStart(11)}`
+            );
+          } else {
+            isomorph_default.writeln(
+              `${metric.name.padEnd(20)} ${metricValue.padStart(15)}`
+            );
+          }
+        }
+      }
+      if (summary.experimentUrl) {
+        isomorph_default.writeln("");
+        isomorph_default.writeln(`View results for ${summary.experimentName}`);
+        isomorph_default.writeln(`See results at ${summary.experimentUrl}`);
+      }
+    }
+    isomorph_default.writeln("");
+    return failingResults.length === 0;
+  },
+  async reportRun(evalReports) {
+    return evalReports.every((r) => r);
+  }
+};
+
+// src/cli/reporters/eval.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_termi_link = require("termi-link");
+var import_boxen = __toESM(require("boxen"));
+var import_cli_table3 = __toESM(require("cli-table3"));
+var import_pluralize = __toESM(require("pluralize"));
+function formatExperimentSummaryFancy(summary) {
+  let comparisonLine = "";
+  if (summary.comparisonExperimentName) {
+    comparisonLine = `${summary.comparisonExperimentName} ${import_chalk2.default.gray("(baseline)")} \u2190 ${summary.experimentName} ${import_chalk2.default.gray("(comparison)")}
+
+`;
+  }
+  const tableParts = [];
+  const hasScores = Object.keys(summary.scores).length > 0;
+  const hasMetrics = Object.keys(summary.metrics ?? {}).length > 0;
+  const hasComparison = !!summary.comparisonExperimentName;
+  if (hasScores || hasMetrics) {
+    const headers = [import_chalk2.default.gray("Name"), import_chalk2.default.gray("Value")];
+    if (hasComparison) {
+      headers.push(
+        import_chalk2.default.gray("Change"),
+        import_chalk2.default.gray("Improvements"),
+        import_chalk2.default.gray("Regressions")
+      );
+    }
+    const combinedTable = new import_cli_table3.default({
+      head: hasComparison ? headers : [],
+      style: { head: [], "padding-left": 0, "padding-right": 0, border: [] },
+      chars: {
+        top: "",
+        "top-mid": "",
+        "top-left": "",
+        "top-right": "",
+        bottom: "",
+        "bottom-mid": "",
+        "bottom-left": "",
+        "bottom-right": "",
+        left: "",
+        "left-mid": "",
+        mid: "",
+        "mid-mid": "",
+        right: "",
+        "right-mid": "",
+        middle: " "
+      },
+      colWidths: hasComparison ? [18, 10, 10, 13, 12] : [20, 15],
+      colAligns: hasComparison ? ["left", "right", "right", "right", "right"] : ["left", "right"],
+      wordWrap: false
+    });
+    const scoreValues = Object.values(summary.scores);
+    for (const score of scoreValues) {
+      const scorePercent = (score.score * 100).toFixed(2);
+      const scoreValue = import_chalk2.default.white(`${scorePercent}%`);
+      let diffString = "";
+      if (!isEmpty2(score.diff)) {
+        const diffPercent = (score.diff * 100).toFixed(2);
+        const diffSign = score.diff > 0 ? "+" : "";
+        const diffColor = score.diff > 0 ? import_chalk2.default.green : import_chalk2.default.red;
+        diffString = diffColor(`${diffSign}${diffPercent}%`);
+      } else {
+        diffString = import_chalk2.default.gray("-");
+      }
+      const improvements = score.improvements > 0 ? import_chalk2.default.dim.green(score.improvements) : import_chalk2.default.gray("-");
+      const regressions = score.regressions > 0 ? import_chalk2.default.dim.red(score.regressions) : import_chalk2.default.gray("-");
+      const row = [`${import_chalk2.default.blue("\u25EF")} ${score.name}`, scoreValue];
+      if (hasComparison) {
+        row.push(diffString, improvements, regressions);
+      }
+      combinedTable.push(row);
+    }
+    const metricValues = Object.values(summary.metrics ?? {});
+    for (const metric of metricValues) {
+      const fractionDigits = Number.isInteger(metric.metric) ? 0 : 2;
+      const formattedValue = metric.metric.toFixed(fractionDigits);
+      const metricValue = import_chalk2.default.white(
+        metric.unit === "$" ? `${metric.unit}${formattedValue}` : `${formattedValue}${metric.unit}`
+      );
+      let diffString = "";
+      if (!isEmpty2(metric.diff)) {
+        const diffPercent = (metric.diff * 100).toFixed(2);
+        const diffSign = metric.diff > 0 ? "+" : "";
+        const diffColor = metric.diff > 0 ? import_chalk2.default.green : import_chalk2.default.red;
+        diffString = diffColor(`${diffSign}${diffPercent}%`);
+      } else {
+        diffString = import_chalk2.default.gray("-");
+      }
+      const improvements = metric.improvements > 0 ? import_chalk2.default.dim.green(metric.improvements) : import_chalk2.default.gray("-");
+      const regressions = metric.regressions > 0 ? import_chalk2.default.dim.red(metric.regressions) : import_chalk2.default.gray("-");
+      const row = [`${import_chalk2.default.magenta("\u25EF")} ${metric.name}`, metricValue];
+      if (hasComparison) {
+        row.push(diffString, improvements, regressions);
+      }
+      combinedTable.push(row);
+    }
+    tableParts.push(combinedTable.toString());
+  }
+  const content = [comparisonLine, ...tableParts].filter(Boolean).join("\n");
+  const footer = summary.experimentUrl ? (0, import_termi_link.terminalLink)(
+    `View results for ${summary.experimentName}`,
+    summary.experimentUrl,
+    { fallback: () => `See results at ${summary.experimentUrl}` }
+  ) : "";
+  const boxContent = [content, footer].filter(Boolean).join("\n\n");
+  try {
+    return "\n" + (0, import_boxen.default)(boxContent, {
+      title: import_chalk2.default.gray("Experiment summary"),
+      titleAlignment: "left",
+      padding: 0.5,
+      borderColor: "gray",
+      borderStyle: "round"
+    });
+  } catch (error2) {
+    return "\n" + import_chalk2.default.gray("Experiment summary") + "\n" + boxContent + "\n";
+  }
+}
+var warning2 = import_chalk2.default.yellow;
+var fancyReporter = {
+  name: "Braintrust fancy reporter",
+  async reportEval(evaluator, result, { verbose, jsonl }) {
+    const { results, summary } = result;
+    const failingResults = results.filter(
+      (r) => r.error !== void 0
+    );
+    if (failingResults.length > 0) {
+      console.error(
+        warning2(
+          `Evaluator ${evaluator.evalName} failed with ${(0, import_pluralize.default)("error", failingResults.length, true)}. This evaluation ("${evaluator.evalName}") will not be fully logged.`
+        )
+      );
+      if (jsonl) {
+        for (const result2 of failingResults) {
+          process.stdout.write(JSON.stringify(result2));
+          process.stdout.write("\n");
+        }
+      } else if (verbose) {
+        for (const result2 of failingResults) {
+          console.error(result2);
+        }
+      }
+    }
+    process.stdout.write(
+      jsonl ? JSON.stringify(summary) : formatExperimentSummaryFancy(summary)
+    );
+    process.stdout.write("\n");
+    return failingResults.length === 0;
+  },
+  async reportRun(evalReports) {
+    return evalReports.every((r) => r);
+  }
+};
+
+// src/node.ts
+var import_node_async_hooks = require("async_hooks");
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs/promises"));
+var os = __toESM(require("os"));
+var fsSync = __toESM(require("fs"));
+var crypto = __toESM(require("crypto"));
+
+// src/gitutil.ts
+var import_simple_git = require("simple-git");
+var COMMON_BASE_BRANCHES = ["main", "master", "develop"];
+async function currentRepo() {
+  try {
+    const git = (0, import_simple_git.simpleGit)();
+    if (await git.checkIsRepo()) {
+      return git;
+    } else {
+      return null;
+    }
+  } catch (e) {
+    return null;
+  }
+}
+var _baseBranch = null;
+async function getBaseBranch(remote = void 0) {
+  if (_baseBranch === null) {
+    const git = await currentRepo();
+    if (git === null) {
+      throw new Error("Not in a git repo");
+    }
+    const remoteName = remote ?? (await git.getRemotes())[0]?.name;
+    if (!remoteName) {
+      throw new Error("No remote found");
+    }
+    let branch = null;
+    const repoBranches = new Set((await git.branchLocal()).all);
+    const matchingBaseBranches = COMMON_BASE_BRANCHES.filter(
+      (b) => repoBranches.has(b)
+    );
+    if (matchingBaseBranches.length === 1) {
+      branch = matchingBaseBranches[0];
+    } else {
+      try {
+        const remoteInfo = await git.remote(["show", remoteName]);
+        if (!remoteInfo) {
+          throw new Error(`Could not find remote ${remoteName}`);
+        }
+        const match = remoteInfo.match(/\s*HEAD branch:\s*(.*)$/m);
+        if (!match) {
+          throw new Error(`Could not find HEAD branch in remote ${remoteName}`);
+        }
+        branch = match[1];
+      } catch {
+        branch = "main";
+      }
+    }
+    _baseBranch = { remote: remoteName, branch };
+  }
+  return _baseBranch;
+}
+async function getBaseBranchAncestor(remote = void 0) {
+  const git = await currentRepo();
+  if (git === null) {
+    throw new Error("Not in a git repo");
+  }
+  const { remote: remoteName, branch: baseBranch } = await getBaseBranch(remote);
+  const isDirty = (await git.diffSummary()).files.length > 0;
+  const head = isDirty ? "HEAD" : "HEAD^";
+  try {
+    const ancestor = await git.raw([
+      "merge-base",
+      head,
+      `${remoteName}/${baseBranch}`
+    ]);
+    return ancestor.trim();
+  } catch (e) {
+    return void 0;
+  }
+}
+async function getPastNAncestors(n = 1e3, remote = void 0) {
+  const git = await currentRepo();
+  if (git === null) {
+    return [];
+  }
+  let ancestor = void 0;
+  try {
+    ancestor = await getBaseBranchAncestor(remote);
+  } catch (e) {
+    console.warn(
+      "Skipping git metadata. This is likely because the repository has not been published to a remote yet.",
+      `${e}`
+    );
+  }
+  if (!ancestor) {
+    return [];
+  }
+  const commits = await git.log({ from: ancestor, to: "HEAD", maxCount: n });
+  return commits.all.slice(0, n).map((c) => c.hash);
+}
+async function attempt(fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    return void 0;
+  }
+}
+function truncateToByteLimit(s, byteLimit = 65536) {
+  const encoded = new TextEncoder().encode(s);
+  if (encoded.length <= byteLimit) {
+    return s;
+  }
+  const truncated = encoded.subarray(0, byteLimit);
+  return new TextDecoder().decode(truncated);
+}
+async function getRepoInfo(settings) {
+  if (settings && settings.collect === "none") {
+    return void 0;
+  }
+  const repo = await repoInfo();
+  if (!repo || !settings || settings.collect === "all") {
+    return repo;
+  }
+  let sanitized = {};
+  settings.fields?.forEach((field) => {
+    sanitized = { ...sanitized, [field]: repo[field] };
+  });
+  return sanitized;
+}
+async function repoInfo() {
+  const git = await currentRepo();
+  if (git === null) {
+    return void 0;
+  }
+  let commit = void 0;
+  let commit_message = void 0;
+  let commit_time = void 0;
+  let author_name = void 0;
+  let author_email = void 0;
+  let tag = void 0;
+  let branch = void 0;
+  let git_diff = void 0;
+  const dirty = (await git.diffSummary()).files.length > 0;
+  commit = await attempt(async () => await git.revparse(["HEAD"]));
+  commit_message = await attempt(
+    async () => (await git.raw(["log", "-1", "--pretty=%B"])).trim()
+  );
+  commit_time = await attempt(
+    async () => (await git.raw(["log", "-1", "--pretty=%cI"])).trim()
+  );
+  author_name = await attempt(
+    async () => (await git.raw(["log", "-1", "--pretty=%aN"])).trim()
+  );
+  author_email = await attempt(
+    async () => (await git.raw(["log", "-1", "--pretty=%aE"])).trim()
+  );
+  tag = await attempt(
+    async () => (await git.raw(["describe", "--tags", "--exact-match", "--always"])).trim()
+  );
+  branch = await attempt(
+    async () => (await git.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim()
+  );
+  if (dirty) {
+    git_diff = await attempt(
+      async () => truncateToByteLimit(await git.raw(["--no-ext-diff", "diff", "HEAD"]))
+    );
   }
+  return {
+    commit,
+    branch,
+    tag,
+    dirty,
+    author_name,
+    author_email,
+    commit_message,
+    commit_time,
+    git_diff
+  };
 }
-var error = (text) => `Error: ${text}`;
-var warning = (text) => `Warning: ${text}`;
-function logError2(e, verbose) {
-  if (!verbose) {
-    console.error(`${e}`);
-  } else {
-    console.error(e);
+
+// src/stackutil.ts
+function getStackTrace() {
+  const trace = new Error().stack;
+  if (typeof trace !== "string") {
+    return [];
   }
-}
-function accumulateScores(accumulator, scores) {
-  for (const [name, score] of Object.entries(scores)) {
-    if (score === null || score === void 0) {
+  const traceLines = trace.split("\n");
+  const out = [];
+  const stackFrameRegex = /at(.*)\((.*):(\d+):(\d+)\)/;
+  for (const traceLine of traceLines.slice(1)) {
+    const matches = traceLine.match(stackFrameRegex);
+    if (matches === null || matches.length !== 5) {
       continue;
     }
-    const existing = accumulator[name] ?? { total: 0, count: 0 };
-    accumulator[name] = {
-      total: existing.total + score,
-      count: existing.count + 1
+    const entry = {
+      functionName: matches[1].trim(),
+      fileName: matches[2],
+      lineNo: parseInt(matches[3])
     };
+    if (!isNaN(entry.lineNo)) {
+      out.push(entry);
+    }
   }
+  return out;
 }
-function ensureScoreAccumulator(results) {
-  const accumulator = {};
-  for (const result of results) {
-    accumulateScores(accumulator, result.scores);
-  }
-  return accumulator;
-}
-function buildLocalSummary(evaluator, results, precomputedScores) {
-  const scoresByName = 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);
-      }
+function getCallerLocation() {
+  let thisDir = void 0;
+  const entries = getStackTrace();
+  for (const frame of entries) {
+    if (thisDir === void 0) {
+      thisDir = isomorph_default.pathDirname?.(frame.fileName);
     }
-    if (!verbose && !jsonl) {
-      console.error(warning("Add --verbose to see full stack traces."));
+    if (isomorph_default.pathDirname?.(frame.fileName) !== thisDir) {
+      return {
+        caller_functionname: frame.functionName,
+        caller_filename: frame.fileName,
+        caller_lineno: frame.lineNo
+      };
     }
   }
+  return void 0;
 }
-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(summary.metrics ?? {}).length > 0;
-      const hasComparison = !!summary.comparisonExperimentName;
-      if (hasScores || hasMetrics) {
-        if (hasComparison) {
-          isomorph_default.writeln(
-            "Name                Value      Change     Improvements Regressions"
-          );
-          isomorph_default.writeln(
-            "----------------------------------------------------------------"
-          );
-        }
-        for (const score of Object.values(summary.scores)) {
-          const scorePercent = (score.score * 100).toFixed(2);
-          const scoreValue = `${scorePercent}%`;
-          if (hasComparison) {
-            let diffString = "-";
-            if (!isEmpty2(score.diff)) {
-              const diffPercent = (score.diff * 100).toFixed(2);
-              const diffSign = score.diff > 0 ? "+" : "";
-              diffString = `${diffSign}${diffPercent}%`;
-            }
-            const improvements = score.improvements > 0 ? score.improvements.toString() : "-";
-            const regressions = score.regressions > 0 ? score.regressions.toString() : "-";
-            isomorph_default.writeln(
-              `${score.name.padEnd(18)} ${scoreValue.padStart(10)} ${diffString.padStart(10)} ${improvements.padStart(12)} ${regressions.padStart(11)}`
-            );
-          } else {
-            isomorph_default.writeln(`${score.name.padEnd(20)} ${scoreValue.padStart(15)}`);
-          }
-        }
-        for (const metric of Object.values(summary.metrics ?? {})) {
-          const fractionDigits = Number.isInteger(metric.metric) ? 0 : 2;
-          const formattedValue = metric.metric.toFixed(fractionDigits);
-          const metricValue = metric.unit === "$" ? `${metric.unit}${formattedValue}` : `${formattedValue}${metric.unit}`;
-          if (hasComparison) {
-            let diffString = "-";
-            if (!isEmpty2(metric.diff)) {
-              const diffPercent = (metric.diff * 100).toFixed(2);
-              const diffSign = metric.diff > 0 ? "+" : "";
-              diffString = `${diffSign}${diffPercent}%`;
-            }
-            const improvements = metric.improvements > 0 ? metric.improvements.toString() : "-";
-            const regressions = metric.regressions > 0 ? metric.regressions.toString() : "-";
-            isomorph_default.writeln(
-              `${metric.name.padEnd(18)} ${metricValue.padStart(10)} ${diffString.padStart(10)} ${improvements.padStart(12)} ${regressions.padStart(11)}`
-            );
-          } else {
-            isomorph_default.writeln(
-              `${metric.name.padEnd(20)} ${metricValue.padStart(15)}`
-            );
-          }
-        }
-      }
-      if (summary.experimentUrl) {
-        isomorph_default.writeln("");
-        isomorph_default.writeln(`View results for ${summary.experimentName}`);
-        isomorph_default.writeln(`See results at ${summary.experimentUrl}`);
-      }
+
+// src/node.ts
+var import_util9 = require("util");
+var zlib = __toESM(require("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 import_node_async_hooks.AsyncLocalStorage();
+  isomorph_default.processOn = (event, handler) => {
+    process.on(event, handler);
+  };
+  isomorph_default.basename = path.basename;
+  isomorph_default.writeln = (text) => process.stdout.write(text + "\n");
+  isomorph_default.pathJoin = path.join;
+  isomorph_default.pathDirname = path.dirname;
+  isomorph_default.mkdir = fs.mkdir;
+  isomorph_default.writeFile = fs.writeFile;
+  isomorph_default.readFile = fs.readFile;
+  isomorph_default.readdir = fs.readdir;
+  isomorph_default.stat = fs.stat;
+  isomorph_default.statSync = fsSync.statSync;
+  isomorph_default.utimes = fs.utimes;
+  isomorph_default.unlink = fs.unlink;
+  isomorph_default.homedir = os.homedir;
+  isomorph_default.tmpdir = os.tmpdir;
+  isomorph_default.writeFileSync = fsSync.writeFileSync;
+  isomorph_default.appendFileSync = fsSync.appendFileSync;
+  isomorph_default.readFileSync = (filename, encoding) => fsSync.readFileSync(filename, encoding);
+  isomorph_default.unlinkSync = fsSync.unlinkSync;
+  isomorph_default.openFile = fs.open;
+  isomorph_default.gzip = (0, import_util9.promisify)(zlib.gzip);
+  isomorph_default.gunzip = (0, import_util9.promisify)(zlib.gunzip);
+  isomorph_default.hash = (data) => crypto.createHash("sha256").update(data).digest("hex");
+  _internalSetInitialState();
+}
+
+// src/cli/index.ts
+var import_env2 = require("@next/env");
+
+// src/cli/functions/upload.ts
+var import_fs = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_zlib = require("zlib");
+var import_v312 = require("zod/v3");
+
+// src/cli/functions/infer-source.ts
+var import_source_map = require("source-map");
+var fs2 = __toESM(require("fs/promises"));
+
+// src/cli/jest/nodeModulesPaths.ts
+var path2 = __toESM(require("path"));
+
+// src/cli/jest/tryRealpath.ts
+var import_graceful_fs = require("graceful-fs");
+function tryRealpath(path8) {
+  try {
+    path8 = import_graceful_fs.realpathSync.native(path8);
+  } catch (error2) {
+    if (error2.code !== "ENOENT" && error2.code !== "EISDIR") {
+      throw error2;
     }
-    isomorph_default.writeln("");
-    return failingResults.length === 0;
-  },
-  async reportRun(evalReports) {
-    return evalReports.every((r) => r);
   }
-};
-
-// src/cli/reporters/eval.ts
-var import_chalk2 = __toESM(require("chalk"));
-var import_termi_link = require("termi-link");
-var import_boxen = __toESM(require("boxen"));
-var import_cli_table3 = __toESM(require("cli-table3"));
-var import_pluralize = __toESM(require("pluralize"));
-function formatExperimentSummaryFancy(summary) {
-  let comparisonLine = "";
-  if (summary.comparisonExperimentName) {
-    comparisonLine = `${summary.comparisonExperimentName} ${import_chalk2.default.gray("(baseline)")} \u2190 ${summary.experimentName} ${import_chalk2.default.gray("(comparison)")}
+  return path8;
+}
 
-`;
+// src/cli/jest/nodeModulesPaths.ts
+function nodeModulesPaths(basedir, options) {
+  const modules = options && options.moduleDirectory ? Array.from(options.moduleDirectory) : ["node_modules"];
+  const basedirAbs = path2.resolve(basedir);
+  let prefix = "/";
+  if (/^([A-Za-z]:)/.test(basedirAbs)) {
+    prefix = "";
+  } else if (/^\\\\/.test(basedirAbs)) {
+    prefix = "\\\\";
   }
-  const tableParts = [];
-  const hasScores = Object.keys(summary.scores).length > 0;
-  const hasMetrics = Object.keys(summary.metrics ?? {}).length > 0;
-  const hasComparison = !!summary.comparisonExperimentName;
-  if (hasScores || hasMetrics) {
-    const headers = [import_chalk2.default.gray("Name"), import_chalk2.default.gray("Value")];
-    if (hasComparison) {
-      headers.push(
-        import_chalk2.default.gray("Change"),
-        import_chalk2.default.gray("Improvements"),
-        import_chalk2.default.gray("Regressions")
-      );
-    }
-    const combinedTable = new import_cli_table3.default({
-      head: hasComparison ? headers : [],
-      style: { head: [], "padding-left": 0, "padding-right": 0, border: [] },
-      chars: {
-        top: "",
-        "top-mid": "",
-        "top-left": "",
-        "top-right": "",
-        bottom: "",
-        "bottom-mid": "",
-        "bottom-left": "",
-        "bottom-right": "",
-        left: "",
-        "left-mid": "",
-        mid: "",
-        "mid-mid": "",
-        right: "",
-        "right-mid": "",
-        middle: " "
-      },
-      colWidths: hasComparison ? [18, 10, 10, 13, 12] : [20, 15],
-      colAligns: hasComparison ? ["left", "right", "right", "right", "right"] : ["left", "right"],
-      wordWrap: false
-    });
-    const scoreValues = Object.values(summary.scores);
-    for (const score of scoreValues) {
-      const scorePercent = (score.score * 100).toFixed(2);
-      const scoreValue = import_chalk2.default.white(`${scorePercent}%`);
-      let diffString = "";
-      if (!isEmpty2(score.diff)) {
-        const diffPercent = (score.diff * 100).toFixed(2);
-        const diffSign = score.diff > 0 ? "+" : "";
-        const diffColor = score.diff > 0 ? import_chalk2.default.green : import_chalk2.default.red;
-        diffString = diffColor(`${diffSign}${diffPercent}%`);
-      } else {
-        diffString = import_chalk2.default.gray("-");
-      }
-      const improvements = score.improvements > 0 ? import_chalk2.default.dim.green(score.improvements) : import_chalk2.default.gray("-");
-      const regressions = score.regressions > 0 ? import_chalk2.default.dim.red(score.regressions) : import_chalk2.default.gray("-");
-      const row = [`${import_chalk2.default.blue("\u25EF")} ${score.name}`, scoreValue];
-      if (hasComparison) {
-        row.push(diffString, improvements, regressions);
-      }
-      combinedTable.push(row);
-    }
-    const metricValues = Object.values(summary.metrics ?? {});
-    for (const metric of metricValues) {
-      const fractionDigits = Number.isInteger(metric.metric) ? 0 : 2;
-      const formattedValue = metric.metric.toFixed(fractionDigits);
-      const metricValue = import_chalk2.default.white(
-        metric.unit === "$" ? `${metric.unit}${formattedValue}` : `${formattedValue}${metric.unit}`
-      );
-      let diffString = "";
-      if (!isEmpty2(metric.diff)) {
-        const diffPercent = (metric.diff * 100).toFixed(2);
-        const diffSign = metric.diff > 0 ? "+" : "";
-        const diffColor = metric.diff > 0 ? import_chalk2.default.green : import_chalk2.default.red;
-        diffString = diffColor(`${diffSign}${diffPercent}%`);
+  let physicalBasedir;
+  try {
+    physicalBasedir = tryRealpath(basedirAbs);
+  } catch {
+    physicalBasedir = basedirAbs;
+  }
+  const paths = [physicalBasedir];
+  let parsed = path2.parse(physicalBasedir);
+  while (parsed.dir !== paths[paths.length - 1]) {
+    paths.push(parsed.dir);
+    parsed = path2.parse(parsed.dir);
+  }
+  const dirs = paths.reduce((dirs2, aPath) => {
+    for (const moduleDir of modules) {
+      if (path2.isAbsolute(moduleDir)) {
+        if (aPath === basedirAbs && moduleDir) {
+          dirs2.push(moduleDir);
+        }
       } else {
-        diffString = import_chalk2.default.gray("-");
-      }
-      const improvements = metric.improvements > 0 ? import_chalk2.default.dim.green(metric.improvements) : import_chalk2.default.gray("-");
-      const regressions = metric.regressions > 0 ? import_chalk2.default.dim.red(metric.regressions) : import_chalk2.default.gray("-");
-      const row = [`${import_chalk2.default.magenta("\u25EF")} ${metric.name}`, metricValue];
-      if (hasComparison) {
-        row.push(diffString, improvements, regressions);
+        dirs2.push(path2.join(prefix, aPath, moduleDir));
       }
-      combinedTable.push(row);
     }
-    tableParts.push(combinedTable.toString());
+    return dirs2;
+  }, []);
+  if (options.paths) {
+    dirs.push(...options.paths);
   }
-  const content = [comparisonLine, ...tableParts].filter(Boolean).join("\n");
-  const footer = summary.experimentUrl ? (0, import_termi_link.terminalLink)(
-    `View results for ${summary.experimentName}`,
-    summary.experimentUrl,
-    { fallback: () => `See results at ${summary.experimentUrl}` }
-  ) : "";
-  const boxContent = [content, footer].filter(Boolean).join("\n\n");
+  return dirs;
+}
+function findGlobalPaths() {
+  const { root } = path2.parse(process.cwd());
+  const globalPath = path2.join(root, "node_modules");
+  const resolvePaths = require.resolve.paths("/");
+  if (resolvePaths) {
+    const rootIndex = resolvePaths.indexOf(globalPath);
+    return rootIndex > -1 ? resolvePaths.slice(rootIndex + 1) : [];
+  }
+  return [];
+}
+var GlobalPaths = findGlobalPaths();
+
+// src/cli/functions/load-module.ts
+var import_path = __toESM(require("path"));
+function evalWithModuleContext(inFile, evalFn) {
+  const modulePaths = [...module.paths];
   try {
-    return "\n" + (0, import_boxen.default)(boxContent, {
-      title: import_chalk2.default.gray("Experiment summary"),
-      titleAlignment: "left",
-      padding: 0.5,
-      borderColor: "gray",
-      borderStyle: "round"
-    });
-  } catch (error2) {
-    return "\n" + import_chalk2.default.gray("Experiment summary") + "\n" + boxContent + "\n";
+    module.paths = nodeModulesPaths(import_path.default.dirname(inFile), {});
+    return evalFn();
+  } finally {
+    module.paths = modulePaths;
   }
 }
-var warning2 = import_chalk2.default.yellow;
-var fancyReporter = {
-  name: "Braintrust fancy reporter",
-  async reportEval(evaluator, result, { verbose, jsonl }) {
-    const { results, summary } = result;
-    const failingResults = results.filter(
-      (r) => r.error !== void 0
+function loadModule({
+  inFile,
+  moduleText
+}) {
+  return evalWithModuleContext(inFile, () => {
+    globalThis._evals = {
+      functions: [],
+      prompts: [],
+      parameters: [],
+      evaluators: {},
+      reporters: {}
+    };
+    globalThis._lazy_load = true;
+    globalThis.__inherited_braintrust_state = _internalGetGlobalState();
+    const __filename2 = inFile;
+    const __dirname = (0, import_path.dirname)(__filename2);
+    new Function("require", "module", "__filename", "__dirname", moduleText)(
+      require,
+      module,
+      __filename2,
+      __dirname
     );
-    if (failingResults.length > 0) {
-      console.error(
-        warning2(
-          `Evaluator ${evaluator.evalName} failed with ${(0, import_pluralize.default)("error", failingResults.length, true)}. This evaluation ("${evaluator.evalName}") will not be fully logged.`
+    return { ...globalThis._evals };
+  });
+}
+
+// src/cli/functions/infer-source.ts
+var import_path2 = __toESM(require("path"));
+async function makeSourceMapContext({
+  inFile,
+  outFile,
+  sourceMapFile
+}) {
+  const [inFileContents, outFileContents, sourceMap] = await Promise.all([
+    fs2.readFile(inFile, "utf8"),
+    fs2.readFile(outFile, "utf8"),
+    (async () => {
+      const sourceMap2 = await fs2.readFile(sourceMapFile, "utf8");
+      const sourceMapJSON = JSON.parse(sourceMap2);
+      return new import_source_map.SourceMapConsumer(sourceMapJSON);
+    })()
+  ]);
+  return {
+    inFiles: { [inFile]: inFileContents.split("\n") },
+    outFileModule: loadModule({ inFile, moduleText: outFileContents }),
+    outFileLines: outFileContents.split("\n"),
+    sourceMapDir: import_path2.default.dirname(sourceMapFile),
+    sourceMap
+  };
+}
+function isNative(fn) {
+  return /\{\s*\[native code\]\s*\}/.test(Function.prototype.toString.call(fn));
+}
+function locationToString(location) {
+  if (location.type === "experiment") {
+    return `eval ${location.eval_name} -> ${location.position.type}`;
+  } else {
+    return `task ${location.index}`;
+  }
+}
+async function findCodeDefinition({
+  location,
+  ctx: { inFiles, outFileModule, outFileLines, sourceMapDir, sourceMap }
+}) {
+  let fn = void 0;
+  if (location.type === "experiment") {
+    const evaluator = outFileModule.evaluators[location.eval_name]?.evaluator;
+    if (!evaluator) {
+      console.warn(
+        warning(
+          `Warning: failed to find evaluator for ${location.eval_name}. Will not display preview.`
         )
       );
-      if (jsonl) {
-        for (const result2 of failingResults) {
-          process.stdout.write(JSON.stringify(result2));
-          process.stdout.write("\n");
-        }
-      } else if (verbose) {
-        for (const result2 of failingResults) {
-          console.error(result2);
-        }
-      }
-    }
-    process.stdout.write(
-      jsonl ? JSON.stringify(summary) : formatExperimentSummaryFancy(summary)
-    );
-    process.stdout.write("\n");
-    return failingResults.length === 0;
-  },
-  async reportRun(evalReports) {
-    return evalReports.every((r) => r);
-  }
-};
-
-// src/node.ts
-var import_node_async_hooks = require("async_hooks");
-var path = __toESM(require("path"));
-var fs = __toESM(require("fs/promises"));
-var os = __toESM(require("os"));
-var fsSync = __toESM(require("fs"));
-var crypto = __toESM(require("crypto"));
-
-// src/gitutil.ts
-var import_simple_git = require("simple-git");
-var COMMON_BASE_BRANCHES = ["main", "master", "develop"];
-async function currentRepo() {
-  try {
-    const git = (0, import_simple_git.simpleGit)();
-    if (await git.checkIsRepo()) {
-      return git;
-    } else {
-      return null;
+      return void 0;
     }
-  } catch (e) {
-    return null;
+    fn = location.position.type === "task" ? evaluator.task : evaluator.scores[location.position.index];
+  } else {
+    fn = outFileModule.functions[location.index].handler;
   }
-}
-var _baseBranch = null;
-async function getBaseBranch(remote = void 0) {
-  if (_baseBranch === null) {
-    const git = await currentRepo();
-    if (git === null) {
-      throw new Error("Not in a git repo");
-    }
-    const remoteName = remote ?? (await git.getRemotes())[0]?.name;
-    if (!remoteName) {
-      throw new Error("No remote found");
-    }
-    let branch = null;
-    const repoBranches = new Set((await git.branchLocal()).all);
-    const matchingBaseBranches = COMMON_BASE_BRANCHES.filter(
-      (b) => repoBranches.has(b)
+  if (!fn) {
+    console.warn(
+      warning(
+        `Warning: failed to find ${locationToString(location)}. Will not display preview.`
+      )
     );
-    if (matchingBaseBranches.length === 1) {
-      branch = matchingBaseBranches[0];
-    } else {
-      try {
-        const remoteInfo = await git.remote(["show", remoteName]);
-        if (!remoteInfo) {
-          throw new Error(`Could not find remote ${remoteName}`);
-        }
-        const match = remoteInfo.match(/\s*HEAD branch:\s*(.*)$/m);
-        if (!match) {
-          throw new Error(`Could not find HEAD branch in remote ${remoteName}`);
-        }
-        branch = match[1];
-      } catch {
-        branch = "main";
-      }
-    }
-    _baseBranch = { remote: remoteName, branch };
-  }
-  return _baseBranch;
-}
-async function getBaseBranchAncestor(remote = void 0) {
-  const git = await currentRepo();
-  if (git === null) {
-    throw new Error("Not in a git repo");
+    return void 0;
   }
-  const { remote: remoteName, branch: baseBranch } = await getBaseBranch(remote);
-  const isDirty = (await git.diffSummary()).files.length > 0;
-  const head = isDirty ? "HEAD" : "HEAD^";
-  try {
-    const ancestor = await git.raw([
-      "merge-base",
-      head,
-      `${remoteName}/${baseBranch}`
-    ]);
-    return ancestor.trim();
-  } catch (e) {
+  const sourceCode = fn.toString();
+  if (isNative(fn)) {
     return void 0;
   }
-}
-async function getPastNAncestors(n = 1e3, remote = void 0) {
-  const git = await currentRepo();
-  if (git === null) {
-    return [];
+  let lineNumber = 0;
+  let columnNumber = -1;
+  for (const line of outFileLines) {
+    const sourceDefinition = line.indexOf(sourceCode);
+    if (sourceDefinition !== -1) {
+      columnNumber = sourceDefinition;
+      break;
+    }
+    lineNumber++;
   }
-  let ancestor = void 0;
-  try {
-    ancestor = await getBaseBranchAncestor(remote);
-  } catch (e) {
+  if (columnNumber === -1) {
     console.warn(
-      "Skipping git metadata. This is likely because the repository has not been published to a remote yet.",
-      `${e}`
+      warning(
+        `Warning: failed to find code definition for ${fn.name}. Will not display preview.`
+      )
     );
-  }
-  if (!ancestor) {
-    return [];
-  }
-  const commits = await git.log({ from: ancestor, to: "HEAD", maxCount: n });
-  return commits.all.slice(0, n).map((c) => c.hash);
-}
-async function attempt(fn) {
-  try {
-    return await fn();
-  } catch (e) {
     return void 0;
   }
-}
-function truncateToByteLimit(s, byteLimit = 65536) {
-  const encoded = new TextEncoder().encode(s);
-  if (encoded.length <= byteLimit) {
-    return s;
-  }
-  const truncated = encoded.subarray(0, byteLimit);
-  return new TextDecoder().decode(truncated);
-}
-async function getRepoInfo(settings) {
-  if (settings && settings.collect === "none") {
+  const originalPosition = sourceMap.originalPositionFor({
+    line: lineNumber + 1,
+    column: columnNumber + 1
+  });
+  if (originalPosition.source === null || originalPosition.line === null) {
     return void 0;
   }
-  const repo = await repoInfo();
-  if (!repo || !settings || settings.collect === "all") {
-    return repo;
+  if (!inFiles[originalPosition.source]) {
+    const originalFile = import_path2.default.join(sourceMapDir, originalPosition.source);
+    inFiles[originalPosition.source] = (await fs2.readFile(originalFile, "utf-8")).split("\n");
   }
-  let sanitized = {};
-  settings.fields?.forEach((field) => {
-    sanitized = { ...sanitized, [field]: repo[field] };
-  });
-  return sanitized;
-}
-async function repoInfo() {
-  const git = await currentRepo();
-  if (git === null) {
+  const originalLines = inFiles[originalPosition.source];
+  const ts = await getTsModule();
+  if (!ts) {
     return void 0;
   }
-  let commit = void 0;
-  let commit_message = void 0;
-  let commit_time = void 0;
-  let author_name = void 0;
-  let author_email = void 0;
-  let tag = void 0;
-  let branch = void 0;
-  let git_diff = void 0;
-  const dirty = (await git.diffSummary()).files.length > 0;
-  commit = await attempt(async () => await git.revparse(["HEAD"]));
-  commit_message = await attempt(
-    async () => (await git.raw(["log", "-1", "--pretty=%B"])).trim()
-  );
-  commit_time = await attempt(
-    async () => (await git.raw(["log", "-1", "--pretty=%cI"])).trim()
-  );
-  author_name = await attempt(
-    async () => (await git.raw(["log", "-1", "--pretty=%aN"])).trim()
-  );
-  author_email = await attempt(
-    async () => (await git.raw(["log", "-1", "--pretty=%aE"])).trim()
-  );
-  tag = await attempt(
-    async () => (await git.raw(["describe", "--tags", "--exact-match", "--always"])).trim()
+  const sourceFile = ts.createSourceFile(
+    originalPosition.source,
+    originalLines.join("\n"),
+    ts.ScriptTarget.Latest,
+    true
   );
-  branch = await attempt(
-    async () => (await git.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim()
+  let functionNode = void 0;
+  const targetPosition = ts.getPositionOfLineAndCharacter(
+    sourceFile,
+    originalPosition.line - 1,
+    originalPosition.column || 0
   );
-  if (dirty) {
-    git_diff = await attempt(
-      async () => truncateToByteLimit(await git.raw(["--no-ext-diff", "diff", "HEAD"]))
-    );
-  }
-  return {
-    commit,
-    branch,
-    tag,
-    dirty,
-    author_name,
-    author_email,
-    commit_message,
-    commit_time,
-    git_diff
-  };
-}
-
-// src/stackutil.ts
-function getStackTrace() {
-  const trace = new Error().stack;
-  if (typeof trace !== "string") {
-    return [];
-  }
-  const traceLines = trace.split("\n");
-  const out = [];
-  const stackFrameRegex = /at(.*)\((.*):(\d+):(\d+)\)/;
-  for (const traceLine of traceLines.slice(1)) {
-    const matches = traceLine.match(stackFrameRegex);
-    if (matches === null || matches.length !== 5) {
-      continue;
-    }
-    const entry = {
-      functionName: matches[1].trim(),
-      fileName: matches[2],
-      lineNo: parseInt(matches[3])
-    };
-    if (!isNaN(entry.lineNo)) {
-      out.push(entry);
+  ts.forEachChild(sourceFile, function visit(node) {
+    if (node.pos <= targetPosition && targetPosition < node.end) {
+      if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {
+        functionNode = node;
+      } else {
+        ts.forEachChild(node, visit);
+      }
     }
+  });
+  if (!functionNode) {
+    return void 0;
   }
-  return out;
+  const printer = ts.createPrinter();
+  const functionDefinition = printer.printNode(
+    ts.EmitHint.Unspecified,
+    functionNode,
+    sourceFile
+  );
+  return functionDefinition;
 }
-function getCallerLocation() {
-  let thisDir = void 0;
-  const entries = getStackTrace();
-  for (const frame of entries) {
-    if (thisDir === void 0) {
-      thisDir = isomorph_default.pathDirname?.(frame.fileName);
-    }
-    if (isomorph_default.pathDirname?.(frame.fileName) !== thisDir) {
-      return {
-        caller_functionname: frame.functionName,
-        caller_filename: frame.fileName,
-        caller_lineno: frame.lineNo
-      };
+var tsModule = void 0;
+async function getTsModule() {
+  if (!tsModule) {
+    try {
+      tsModule = require("typescript");
+    } catch {
+      console.warn(
+        warning(
+          "Failed to load TypeScript module. Will not use TypeScript to derive preview."
+        )
+      );
     }
   }
-  return void 0;
+  return tsModule;
 }
 
-// src/node.ts
-var import_util10 = require("util");
-var zlib = __toESM(require("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 import_node_async_hooks.AsyncLocalStorage();
-  isomorph_default.processOn = (event, handler) => {
-    process.on(event, handler);
-  };
-  isomorph_default.basename = path.basename;
-  isomorph_default.writeln = (text) => process.stdout.write(text + "\n");
-  isomorph_default.pathJoin = path.join;
-  isomorph_default.pathDirname = path.dirname;
-  isomorph_default.mkdir = fs.mkdir;
-  isomorph_default.writeFile = fs.writeFile;
-  isomorph_default.readFile = fs.readFile;
-  isomorph_default.readdir = fs.readdir;
-  isomorph_default.stat = fs.stat;
-  isomorph_default.statSync = fsSync.statSync;
-  isomorph_default.utimes = fs.utimes;
-  isomorph_default.unlink = fs.unlink;
-  isomorph_default.homedir = os.homedir;
-  isomorph_default.tmpdir = os.tmpdir;
-  isomorph_default.writeFileSync = fsSync.writeFileSync;
-  isomorph_default.appendFileSync = fsSync.appendFileSync;
-  isomorph_default.readFileSync = (filename, encoding) => fsSync.readFileSync(filename, encoding);
-  isomorph_default.unlinkSync = fsSync.unlinkSync;
-  isomorph_default.openFile = fs.open;
-  isomorph_default.gzip = (0, import_util10.promisify)(zlib.gzip);
-  isomorph_default.gunzip = (0, import_util10.promisify)(zlib.gunzip);
-  isomorph_default.hash = (data) => crypto.createHash("sha256").update(data).digest("hex");
-  _internalSetInitialState();
+// src/zod/utils.ts
+var import_zod_to_json_schema = require("zod-to-json-schema");
+var z42 = __toESM(require("zod/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 (0, import_zod_to_json_schema.zodToJsonSchema)(schema);
 }
-
-// src/cli/index.ts
-var import_env2 = require("@next/env");
 
 // src/cli/functions/upload.ts
-var import_fs = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var import_zlib = require("zlib");
-var import_v311 = require("zod/v3");
-
-// src/cli/functions/infer-source.ts
-var import_source_map = require("source-map");
-var fs2 = __toESM(require("fs/promises"));
-
-// src/cli/jest/nodeModulesPaths.ts
-var path2 = __toESM(require("path"));
+var import_pluralize2 = __toESM(require("pluralize"));
 
-// src/cli/jest/tryRealpath.ts
-var import_graceful_fs = require("graceful-fs");
-function tryRealpath(path8) {
-  try {
-    path8 = import_graceful_fs.realpathSync.native(path8);
-  } catch (error2) {
-    if (error2.code !== "ENOENT" && error2.code !== "EISDIR") {
-      throw error2;
+// src/framework2.ts
+var import_v311 = require("zod/v3");
+var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
+var ProjectBuilder = class {
+  create(opts) {
+    return new Project2(opts);
+  }
+};
+var projects = new ProjectBuilder();
+var Project2 = class {
+  name;
+  id;
+  tools;
+  prompts;
+  parameters;
+  scorers;
+  _publishableCodeFunctions = [];
+  _publishablePrompts = [];
+  _publishableParameters = [];
+  constructor(args) {
+    _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);
+    }
+  }
+  addCodeFunction(fn) {
+    this._publishableCodeFunctions.push(fn);
+    if (globalThis._lazy_load) {
+      globalThis._evals.functions.push(fn);
+    }
+  }
+  async publish() {
+    if (globalThis._lazy_load) {
+      console.warn("publish() is a no-op when running `braintrust push`.");
+      return;
+    }
+    await login();
+    const projectMap = new ProjectNameIdMap();
+    const functionDefinitions = [];
+    if (this._publishableCodeFunctions.length > 0) {
+      console.warn(
+        "Code functions cannot be published directly. Use `braintrust push` instead."
+      );
+    }
+    if (this._publishablePrompts.length > 0) {
+      for (const prompt of this._publishablePrompts) {
+        const functionDefinition = await prompt.toFunctionDefinition(projectMap);
+        functionDefinitions.push(functionDefinition);
+      }
+    }
+    await _internalGetGlobalState().apiConn().post_json("insert-functions", {
+      functions: functionDefinitions
+    });
+  }
+};
+var ToolBuilder = class {
+  constructor(project) {
+    this.project = project;
+  }
+  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 = opts ?? {};
+    const { handler, name, slug, parameters, returns, ...rest } = opts;
+    let resolvedName = 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: 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;
+  }
+};
+var ScorerBuilder = class {
+  constructor(project) {
+    this.project = project;
+  }
+  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 = opts.slug ?? slugify(resolvedName, { lower: true, strict: true });
+    if ("handler" in opts) {
+      const scorer = new CodeFunction(this.project, {
+        ...opts,
+        name: resolvedName,
+        slug,
+        type: "scorer"
+      });
+      this.project.addCodeFunction(scorer);
+    } else {
+      const promptBlock = "messages" in opts ? {
+        type: "chat",
+        messages: opts.messages
+      } : {
+        type: "completion",
+        content: opts.prompt
+      };
+      const promptData = {
+        prompt: promptBlock,
+        options: {
+          model: opts.model,
+          params: opts.params
+        },
+        parser: {
+          type: "llm_classifier",
+          use_cot: opts.useCot,
+          choice_scores: opts.choiceScores
+        }
+      };
+      const codePrompt = new CodePrompt(
+        this.project,
+        promptData,
+        [],
+        {
+          ...opts,
+          name: resolvedName,
+          slug
+        },
+        "scorer"
+      );
+      this.project.addPrompt(codePrompt);
     }
   }
-  return path8;
-}
-
-// src/cli/jest/nodeModulesPaths.ts
-function nodeModulesPaths(basedir, options) {
-  const modules = options && options.moduleDirectory ? Array.from(options.moduleDirectory) : ["node_modules"];
-  const basedirAbs = path2.resolve(basedir);
-  let prefix = "/";
-  if (/^([A-Za-z]:)/.test(basedirAbs)) {
-    prefix = "";
-  } else if (/^\\\\/.test(basedirAbs)) {
-    prefix = "\\\\";
-  }
-  let physicalBasedir;
-  try {
-    physicalBasedir = tryRealpath(basedirAbs);
-  } catch {
-    physicalBasedir = basedirAbs;
-  }
-  const paths = [physicalBasedir];
-  let parsed = path2.parse(physicalBasedir);
-  while (parsed.dir !== paths[paths.length - 1]) {
-    paths.push(parsed.dir);
-    parsed = path2.parse(parsed.dir);
-  }
-  const dirs = paths.reduce((dirs2, aPath) => {
-    for (const moduleDir of modules) {
-      if (path2.isAbsolute(moduleDir)) {
-        if (aPath === basedirAbs && moduleDir) {
-          dirs2.push(moduleDir);
-        }
-      } else {
-        dirs2.push(path2.join(prefix, aPath, moduleDir));
-      }
+};
+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");
     }
-    return dirs2;
-  }, []);
-  if (options.paths) {
-    dirs.push(...options.paths);
   }
-  return dirs;
-}
-function findGlobalPaths() {
-  const { root } = path2.parse(process.cwd());
-  const globalPath = path2.join(root, "node_modules");
-  const resolvePaths = require.resolve.paths("/");
-  if (resolvePaths) {
-    const rootIndex = resolvePaths.indexOf(globalPath);
-    return rootIndex > -1 ? resolvePaths.slice(rootIndex + 1) : [];
+  handler;
+  name;
+  slug;
+  type;
+  description;
+  parameters;
+  returns;
+  ifExists;
+  metadata;
+  key() {
+    return JSON.stringify([
+      this.project.id ?? "",
+      this.project.name ?? "",
+      this.slug
+    ]);
   }
-  return [];
-}
-var GlobalPaths = findGlobalPaths();
-
-// src/cli/functions/load-module.ts
-var import_path = __toESM(require("path"));
-function evalWithModuleContext(inFile, evalFn) {
-  const modulePaths = [...module.paths];
-  try {
-    module.paths = nodeModulesPaths(import_path.default.dirname(inFile), {});
-    return evalFn();
-  } finally {
-    module.paths = modulePaths;
+};
+var CodePrompt = class {
+  project;
+  name;
+  slug;
+  prompt;
+  ifExists;
+  description;
+  id;
+  functionType;
+  toolFunctions;
+  metadata;
+  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;
   }
-}
-function loadModule({
-  inFile,
-  moduleText
-}) {
-  return evalWithModuleContext(inFile, () => {
-    globalThis._evals = {
-      functions: [],
-      prompts: [],
-      evaluators: {},
-      reporters: {}
+  async toFunctionDefinition(projectNameToId) {
+    const prompt_data = {
+      ...this.prompt
     };
-    globalThis._lazy_load = true;
-    globalThis.__inherited_braintrust_state = _internalGetGlobalState();
-    const __filename2 = inFile;
-    const __dirname = (0, import_path.dirname)(__filename2);
-    new Function("require", "module", "__filename", "__dirname", moduleText)(
-      require,
-      module,
-      __filename2,
-      __dirname
-    );
-    return { ...globalThis._evals };
-  });
-}
-
-// src/cli/functions/infer-source.ts
-var import_path2 = __toESM(require("path"));
-async function makeSourceMapContext({
-  inFile,
-  outFile,
-  sourceMapFile
-}) {
-  const [inFileContents, outFileContents, sourceMap] = await Promise.all([
-    fs2.readFile(inFile, "utf8"),
-    fs2.readFile(outFile, "utf8"),
-    (async () => {
-      const sourceMap2 = await fs2.readFile(sourceMapFile, "utf8");
-      const sourceMapJSON = JSON.parse(sourceMap2);
-      return new import_source_map.SourceMapConsumer(sourceMapJSON);
-    })()
-  ]);
-  return {
-    inFiles: { [inFile]: inFileContents.split("\n") },
-    outFileModule: loadModule({ inFile, moduleText: outFileContents }),
-    outFileLines: outFileContents.split("\n"),
-    sourceMapDir: import_path2.default.dirname(sourceMapFile),
-    sourceMap
-  };
-}
-function isNative(fn) {
-  return /\{\s*\[native code\]\s*\}/.test(Function.prototype.toString.call(fn));
-}
-function locationToString(location) {
-  if (location.type === "experiment") {
-    return `eval ${location.eval_name} -> ${location.position.type}`;
-  } else {
-    return `task ${location.index}`;
-  }
-}
-async function findCodeDefinition({
-  location,
-  ctx: { inFiles, outFileModule, outFileLines, sourceMapDir, sourceMap }
-}) {
-  let fn = void 0;
-  if (location.type === "experiment") {
-    const evaluator = outFileModule.evaluators[location.eval_name]?.evaluator;
-    if (!evaluator) {
-      console.warn(
-        warning(
-          `Warning: failed to find evaluator for ${location.eval_name}. Will not display preview.`
-        )
+    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;
+          }
+        })
       );
-      return void 0;
+      prompt_data.tool_functions = // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      resolvableToolFunctions;
     }
-    fn = location.position.type === "task" ? evaluator.task : evaluator.scores[location.position.index];
-  } else {
-    fn = outFileModule.functions[location.index].handler;
-  }
-  if (!fn) {
-    console.warn(
-      warning(
-        `Warning: failed to find ${locationToString(location)}. Will not display preview.`
-      )
-    );
-    return void 0;
+    return {
+      project_id: await projectNameToId.resolve(this.project),
+      name: this.name,
+      slug: this.slug,
+      description: this.description ?? "",
+      function_data: {
+        type: "prompt"
+      },
+      function_type: this.functionType,
+      prompt_data,
+      if_exists: this.ifExists,
+      metadata: this.metadata
+    };
   }
-  const sourceCode = fn.toString();
-  if (isNative(fn)) {
-    return void 0;
+};
+var PromptBuilder = class {
+  constructor(project) {
+    this.project = project;
   }
-  let lineNumber = 0;
-  let columnNumber = -1;
-  for (const line of outFileLines) {
-    const sourceDefinition = line.indexOf(sourceCode);
-    if (sourceDefinition !== -1) {
-      columnNumber = sourceDefinition;
-      break;
+  create(opts) {
+    const toolFunctions = [];
+    const rawTools = [];
+    for (const tool of opts.tools ?? []) {
+      if (tool instanceof CodeFunction) {
+        toolFunctions.push(tool);
+      } else if ("type" in tool && !("function" in tool)) {
+        toolFunctions.push(tool);
+      } else {
+        rawTools.push(tool);
+      }
     }
-    lineNumber++;
-  }
-  if (columnNumber === -1) {
-    console.warn(
-      warning(
-        `Warning: failed to find code definition for ${fn.name}. Will not display preview.`
-      )
+    const slug = 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.
+      opts.noTrace ?? false
     );
-    return void 0;
+    const codePrompt = new CodePrompt(this.project, promptData, toolFunctions, {
+      ...opts,
+      slug
+    });
+    this.project.addPrompt(codePrompt);
+    return prompt;
   }
-  const originalPosition = sourceMap.originalPositionFor({
-    line: lineNumber + 1,
-    column: columnNumber + 1
-  });
-  if (originalPosition.source === null || originalPosition.line === null) {
-    return void 0;
+};
+var CodeParameters = class {
+  project;
+  name;
+  slug;
+  description;
+  schema;
+  ifExists;
+  metadata;
+  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;
   }
-  if (!inFiles[originalPosition.source]) {
-    const originalFile = import_path2.default.join(sourceMapDir, originalPosition.source);
-    inFiles[originalPosition.source] = (await fs2.readFile(originalFile, "utf-8")).split("\n");
+  async toFunctionDefinition(projectNameToId) {
+    return {
+      project_id: await projectNameToId.resolve(this.project),
+      name: this.name,
+      slug: this.slug,
+      description: this.description ?? "",
+      function_type: "parameters",
+      function_data: {
+        type: "parameters",
+        data: {},
+        __schema: serializeEvalParameterstoParametersSchema(this.schema)
+      },
+      if_exists: this.ifExists,
+      metadata: this.metadata
+    };
   }
-  const originalLines = inFiles[originalPosition.source];
-  const ts = await getTsModule();
-  if (!ts) {
-    return void 0;
+};
+var ParametersBuilder = class {
+  constructor(project) {
+    this.project = project;
   }
-  const sourceFile = ts.createSourceFile(
-    originalPosition.source,
-    originalLines.join("\n"),
-    ts.ScriptTarget.Latest,
-    true
-  );
-  let functionNode = void 0;
-  const targetPosition = ts.getPositionOfLineAndCharacter(
-    sourceFile,
-    originalPosition.line - 1,
-    originalPosition.column || 0
-  );
-  ts.forEachChild(sourceFile, function visit(node) {
-    if (node.pos <= targetPosition && targetPosition < node.end) {
-      if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {
-        functionNode = node;
+  create(opts) {
+    const slug = 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 {
-        ts.forEachChild(node, visit);
+        const schemaObj = zodToJsonSchema(value);
+        return [
+          name,
+          {
+            type: "data",
+            schema: schemaObj,
+            default: schemaObj.default,
+            description: schemaObj.description
+          }
+        ];
       }
-    }
-  });
-  if (!functionNode) {
-    return void 0;
-  }
-  const printer = ts.createPrinter();
-  const functionDefinition = printer.printNode(
-    ts.EmitHint.Unspecified,
-    functionNode,
-    sourceFile
+    })
   );
-  return functionDefinition;
 }
-var tsModule = void 0;
-async function getTsModule() {
-  if (!tsModule) {
-    try {
-      tsModule = require("typescript");
-    } catch {
-      console.warn(
-        warning(
-          "Failed to load TypeScript module. Will not use TypeScript to derive preview."
-        )
-      );
+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);
+      }
+    } else {
+      const schemaObj = zodToJsonSchema(value);
+      properties[name] = schemaObj;
+      if (!("default" in schemaObj)) {
+        required.push(name);
+      }
     }
   }
-  return tsModule;
-}
-
-// src/zod/utils.ts
-var import_zod_to_json_schema = require("zod-to-json-schema");
-var z42 = __toESM(require("zod/v4"));
-function isZodV4(zodObject) {
-  return typeof zodObject === "object" && zodObject !== null && "_zod" in zodObject && zodObject._zod !== void 0;
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    additionalProperties: true
+  };
 }
-function zodToJsonSchema(schema) {
-  if (isZodV4(schema)) {
-    return z42.toJSONSchema(schema, {
-      target: "draft-7"
-    });
+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 (0, import_zod_to_json_schema.zodToJsonSchema)(schema);
+  return {
+    type: "braintrust.staticParameters",
+    schema: serializeEvalParametersToStaticParametersSchema(parameters),
+    source: null
+  };
 }
+var ProjectNameIdMap = class {
+  nameToId = {};
+  idToName = {};
+  async getId(projectName) {
+    if (!(projectName in this.nameToId)) {
+      const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
+        project_name: projectName
+      });
+      const result = import_v311.z.object({
+        project: Project
+      }).parse(response);
+      const projectId = result.project.id;
+      this.nameToId[projectName] = projectId;
+      this.idToName[projectId] = projectName;
+    }
+    return this.nameToId[projectName];
+  }
+  async getName(projectId) {
+    if (!(projectId in this.idToName)) {
+      const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
+        id: projectId
+      });
+      const result = import_v311.z.array(Project).nonempty().parse(response);
+      const projectName = result[0].name;
+      this.idToName[projectId] = projectName;
+      this.nameToId[projectName] = projectId;
+    }
+    return this.idToName[projectId];
+  }
+  async resolve(project) {
+    if (project.id) {
+      return project.id;
+    }
+    return this.getId(project.name);
+  }
+};
 
 // src/cli/functions/upload.ts
-var import_pluralize2 = __toESM(require("pluralize"));
-var pathInfoSchema = import_v311.z.strictObject({
-  url: import_v311.z.string(),
-  bundleId: import_v311.z.string()
+var pathInfoSchema = import_v312.z.strictObject({
+  url: import_v312.z.string(),
+  bundleId: import_v312.z.string()
 }).strip();
 async function uploadHandleBundles({
   buildResults,
@@ -12563,6 +13227,11 @@ async function uploadHandleBundles({
       for (const prompt of result.evaluator.prompts) {
         prompts.push(await prompt.toFunctionDefinition(projectNameToId));
       }
+      if (result.evaluator.parameters != null) {
+        for (const param of result.evaluator.parameters) {
+          prompts.push(await param.toFunctionDefinition(projectNameToId));
+        }
+      }
     }
     for (const evaluator of Object.values(result.evaluator.evaluators)) {
       const experiment = evalToExperiment?.[sourceFile]?.[evaluator.evaluator.evalName];
@@ -12858,7 +13527,7 @@ async function bundleCommand(args) {
 }
 
 // src/cli/util/pull.ts
-var import_v312 = require("zod/v3");
+var import_v313 = require("zod/v3");
 var import_promises = __toESM(require("fs/promises"));
 var import_util13 = __toESM(require("util"));
 var import_path4 = __toESM(require("path"));
@@ -12873,7 +13542,7 @@ async function pullCommand(args) {
     ...args.id ? { ids: [args.id] } : {},
     ...args.version ? { version: loadPrettyXact(args.version) } : {}
   });
-  const functionObjects = import_v312.z.object({ objects: import_v312.z.array(import_v312.z.unknown()) }).parse(functions);
+  const functionObjects = import_v313.z.object({ objects: import_v313.z.array(import_v313.z.unknown()) }).parse(functions);
   const projectNameToFunctions = {};
   const projectNameIdMap = new ProjectNameIdMap();
   for (const rawFunc of functionObjects.objects) {
@@ -13036,7 +13705,7 @@ function makeFunctionDefinition({
   const objectType = "prompt";
   const prompt = func.prompt_data.prompt;
   const promptContents = prompt.type === "completion" ? `prompt: ${doubleQuote(prompt.content)}` : `messages: ${safeStringify(prompt.messages).trimStart()}`;
-  const rawToolsParsed = prompt.type === "chat" && prompt.tools && prompt.tools.length > 0 ? import_v312.z.array(ToolFunctionDefinition).safeParse(JSON.parse(prompt.tools)) : void 0;
+  const rawToolsParsed = prompt.type === "chat" && prompt.tools && prompt.tools.length > 0 ? import_v313.z.array(ToolFunctionDefinition).safeParse(JSON.parse(prompt.tools)) : void 0;
   if (rawToolsParsed && !rawToolsParsed.success) {
     console.warn(
       warning(
@@ -13148,7 +13817,7 @@ var import_express = __toESM(require("express"));
 var import_cors = __toESM(require("cors"));
 
 // dev/errorHandler.ts
-var import_v313 = require("zod/v3");
+var import_v314 = require("zod/v3");
 var errorHandler = (err, req, res, next) => {
   if ("status" in err) {
     res.status(err.status).json({
@@ -13159,7 +13828,7 @@ var errorHandler = (err, req, res, next) => {
     });
     return;
   }
-  if (err instanceof import_v313.z.ZodError) {
+  if (err instanceof import_v314.z.ZodError) {
     res.status(400).json({
       error: {
         message: "Invalid request",
@@ -13331,49 +14000,79 @@ function serializeSSEEvent(event) {
 }
 
 // dev/types.ts
-var import_v314 = require("zod/v3");
-var evalBodySchema = import_v314.z.object({
-  name: import_v314.z.string(),
-  parameters: import_v314.z.record(import_v314.z.string(), import_v314.z.unknown()).nullish(),
+var import_v315 = require("zod/v3");
+var evalBodySchema = import_v315.z.object({
+  name: import_v315.z.string(),
+  parameters: import_v315.z.record(import_v315.z.string(), import_v315.z.unknown()).nullish(),
   data: RunEval.shape.data,
-  scores: import_v314.z.array(
-    import_v314.z.object({
+  scores: import_v315.z.array(
+    import_v315.z.object({
       function_id: FunctionId,
-      name: import_v314.z.string()
+      name: import_v315.z.string()
     })
   ).nullish(),
-  experiment_name: import_v314.z.string().nullish(),
-  project_id: import_v314.z.string().nullish(),
+  experiment_name: import_v315.z.string().nullish(),
+  project_id: import_v315.z.string().nullish(),
   parent: InvokeParent.optional(),
-  stream: import_v314.z.boolean().optional()
+  stream: import_v315.z.boolean().optional()
 });
-var evalParametersSerializedSchema = import_v314.z.record(
-  import_v314.z.string(),
-  import_v314.z.union([
-    import_v314.z.object({
-      type: import_v314.z.literal("prompt"),
+var staticParametersSchema = import_v315.z.record(
+  import_v315.z.string(),
+  import_v315.z.union([
+    import_v315.z.object({
+      type: import_v315.z.literal("prompt"),
       default: PromptData.optional(),
-      description: import_v314.z.string().optional()
+      description: import_v315.z.string().optional()
     }),
-    import_v314.z.object({
-      type: import_v314.z.literal("data"),
-      schema: import_v314.z.record(import_v314.z.unknown()),
-      // JSON Schema
-      default: import_v314.z.unknown().optional(),
-      description: import_v314.z.string().optional()
+    import_v315.z.object({
+      type: import_v315.z.literal("data"),
+      schema: import_v315.z.record(import_v315.z.unknown()),
+      default: import_v315.z.unknown().optional(),
+      description: import_v315.z.string().optional()
     })
   ])
 );
-var evaluatorDefinitionSchema = import_v314.z.object({
-  parameters: evalParametersSerializedSchema.optional()
+var parametersSchema = import_v315.z.object({
+  type: import_v315.z.literal("object"),
+  properties: import_v315.z.record(import_v315.z.string(), import_v315.z.record(import_v315.z.unknown())),
+  required: import_v315.z.array(import_v315.z.string()).optional(),
+  additionalProperties: import_v315.z.boolean().optional()
 });
-var evaluatorDefinitionsSchema = import_v314.z.record(
-  import_v314.z.string(),
+var parametersSourceSchema = import_v315.z.object({
+  parametersId: import_v315.z.string().optional(),
+  slug: import_v315.z.string(),
+  name: import_v315.z.string(),
+  projectId: import_v315.z.string().optional(),
+  version: import_v315.z.string().optional()
+});
+var parametersContainerSchema = import_v315.z.object({
+  type: import_v315.z.literal("braintrust.parameters"),
+  schema: parametersSchema,
+  source: parametersSourceSchema
+});
+var staticParametersContainerSchema = import_v315.z.object({
+  type: import_v315.z.literal("braintrust.staticParameters"),
+  schema: staticParametersSchema,
+  source: import_v315.z.null()
+});
+var serializedParametersContainerSchema = import_v315.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 = import_v315.z.object({
+  parameters: serializedParametersContainerSchema.optional(),
+  scores: import_v315.z.array(import_v315.z.object({ name: import_v315.z.string() })).optional()
+});
+var evaluatorDefinitionsSchema = import_v315.z.record(
+  import_v315.z.string(),
   evaluatorDefinitionSchema
 );
 
 // dev/server.ts
-var import_v315 = require("zod/v3");
+var import_v316 = require("zod/v3");
+var import_ajv2 = require("ajv");
 function runDevServer(evaluators, opts) {
   const allEvaluators = Object.fromEntries(
     evaluators.map((evaluator) => [evaluator.evalName, evaluator])
@@ -13408,20 +14107,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,
@@ -13446,18 +14152,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(parameters ?? {}, evaluator.parameters);
+          await validateParameters(parameters ?? {}, evaluator.parameters);
         } catch (e) {
           console.error("Error validating parameters", e);
-          if (e instanceof import_v315.z.ZodError || e instanceof Error) {
+          if (e instanceof import_v316.z.ZodError || e instanceof import_ajv2.ValidationError || e instanceof Error) {
             res.status(400).json({
               error: e.message
             });
@@ -13606,9 +14306,9 @@ async function getDataset(state, data) {
     return data.data;
   }
 }
-var datasetFetchSchema = import_v315.z.object({
-  project_id: import_v315.z.string(),
-  name: import_v315.z.string()
+var datasetFetchSchema = import_v316.z.object({
+  project_id: import_v316.z.string(),
+  name: import_v316.z.string()
 });
 async function getDatasetById({
   state,
@@ -13617,7 +14317,7 @@ async function getDatasetById({
   const dataset = await state.appConn().post_json("api/dataset/get", {
     id: datasetId
   });
-  const parsed = import_v315.z.array(datasetFetchSchema).parse(dataset);
+  const parsed = import_v316.z.array(datasetFetchSchema).parse(dataset);
   if (parsed.length === 0) {
     throw new Error(`Dataset '${datasetId}' not found`);
   }
@@ -13650,33 +14350,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
-          }
-        ];
-      }
-    })
-  );
-}
 
 // src/cli/util/external-packages-plugin.ts
 function createMarkKnownPackagesExternalPlugin(additionalPackages = []) {
@@ -13901,6 +14574,7 @@ async function initFile({
         const evaluator = evaluateBuildResults(inFile, result) || {
           functions: [],
           prompts: [],
+          parameters: [],
           evaluators: {},
           reporters: {}
         };