braintrust 2.2.0 → 2.2.1

package/dist/browser.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22;var __defProp = Object.defineProperty;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23;var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -110,11 +110,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
 
@@ -785,13 +793,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];
 }
@@ -806,72 +807,8 @@ function getObjValueByPath(row, path) {
   return curr;
 }
 
-// util/graph_util.ts
-function depthFirstSearch(args) {
-  const { graph, firstVisitF, lastVisitF } = args;
-  for (const vs of graph.values()) {
-    for (const v of vs.values()) {
-      if (!graph.has(v)) {
-        throw new Error(`Outgoing vertex ${v} must be a key in the graph`);
-      }
-    }
-  }
-  const firstVisitedVertices = /* @__PURE__ */ new Set();
-  const visitationOrder = _nullishCoalesce(args.visitationOrder, () => ( [...graph.keys()]));
-  const events = visitationOrder.map((vertex) => ({ eventType: "first", vertex, extras: {} })).reverse();
-  while (events.length) {
-    const { eventType, vertex, extras } = events.pop();
-    if (eventType === "last") {
-      _optionalChain([lastVisitF, 'optionalCall', _8 => _8(vertex)]);
-      continue;
-    }
-    if (firstVisitedVertices.has(vertex)) {
-      continue;
-    }
-    firstVisitedVertices.add(vertex);
-    _optionalChain([firstVisitF, 'optionalCall', _9 => _9(vertex, { parentVertex: extras.parentVertex })]);
-    events.push({ eventType: "last", vertex, extras: {} });
-    mapAt(graph, vertex).forEach((child) => {
-      events.push({
-        eventType: "first",
-        vertex: child,
-        extras: { parentVertex: vertex }
-      });
-    });
-  }
-}
-function undirectedConnectedComponents(graph) {
-  const directedGraph = new Map(
-    [...graph.vertices].map((v) => [v, /* @__PURE__ */ new Set()])
-  );
-  for (const [i, j] of graph.edges) {
-    mapAt(directedGraph, i).add(j);
-    mapAt(directedGraph, j).add(i);
-  }
-  let labelCounter = 0;
-  const vertexLabels = /* @__PURE__ */ new Map();
-  const firstVisitF = (vertex, args) => {
-    const label = _optionalChain([args, 'optionalAccess', _10 => _10.parentVertex]) !== void 0 ? mapAt(vertexLabels, _optionalChain([args, 'optionalAccess', _11 => _11.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",
@@ -880,7 +817,7 @@ function generateMergedRowKey(row, useParentIdForId) {
       "dataset_id",
       "prompt_session_id",
       "log_id",
-      _nullishCoalesce(useParentIdForId, () => ( false)) ? PARENT_ID_FIELD : "id"
+      "id"
     ].map((k) => row[k])
   );
 }
@@ -934,96 +871,34 @@ function mergeRowBatch(rows) {
       rowGroups.set(key, row);
     }
   }
-  const merged = [...rowGroups.values()];
-  const rowToLabel = new Map(
-    merged.map((r, i) => [generateMergedRowKey(r), i])
-  );
-  const graph = new Map(
-    Array.from({ length: merged.length }).map((_, i) => [i, /* @__PURE__ */ new Set()])
-  );
-  merged.forEach((r, i) => {
-    const parentId = r[PARENT_ID_FIELD];
-    if (!parentId) {
-      return;
-    }
-    const parentRowKey = generateMergedRowKey(
-      r,
-      true
-      /* useParentIdForId */
-    );
-    const parentLabel = rowToLabel.get(parentRowKey);
-    if (parentLabel !== void 0) {
-      mapAt(graph, parentLabel).add(i);
-    }
-  });
-  const connectedComponents = undirectedConnectedComponents({
-    vertices: new Set(graph.keys()),
-    edges: new Set(
-      [...graph.entries()].flatMap(
-        ([k, vs]) => [...vs].map((v) => {
-          const ret = [k, v];
-          return ret;
-        })
-      )
-    )
-  });
-  const buckets = connectedComponents.map(
-    (cc) => topologicalSort(
-      graph,
-      cc
-      /* visitationOrder */
-    )
-  );
-  return buckets.map((bucket) => bucket.map((i) => merged[i]));
+  return [...rowGroups.values()];
 }
 function batchItems(args) {
-  let { items } = args;
+  const { items } = args;
   const batchMaxNumItems = _nullishCoalesce(args.batchMaxNumItems, () => ( Number.POSITIVE_INFINITY));
   const batchMaxNumBytes = _nullishCoalesce(args.batchMaxNumBytes, () => ( Number.POSITIVE_INFINITY));
+  const getByteSize = args.getByteSize;
   const output = [];
-  let nextItems = [];
-  let batchSet = [];
   let batch = [];
   let batchLen = 0;
   function addToBatch(item) {
     batch.push(item);
-    batchLen += item.length;
+    batchLen += getByteSize(item);
   }
   function flushBatch() {
-    batchSet.push(batch);
+    output.push(batch);
     batch = [];
     batchLen = 0;
   }
-  while (items.length) {
-    for (const bucket of items) {
-      let i = 0;
-      for (const item of bucket) {
-        if (batch.length === 0 || item.length + batchLen < batchMaxNumBytes && batch.length < batchMaxNumItems) {
-          addToBatch(item);
-        } else if (i === 0) {
-          flushBatch();
-          addToBatch(item);
-        } else {
-          break;
-        }
-        ++i;
-      }
-      if (i < bucket.length) {
-        nextItems.push(bucket.slice(i));
-      }
-      if (batchLen >= batchMaxNumBytes || batch.length > batchMaxNumItems) {
-        flushBatch();
-      }
-    }
-    if (batch.length) {
+  for (const item of items) {
+    const itemSize = getByteSize(item);
+    if (batch.length > 0 && !(itemSize + batchLen < batchMaxNumBytes && batch.length < batchMaxNumItems)) {
       flushBatch();
     }
-    if (batchSet.length) {
-      output.push(batchSet);
-      batchSet = [];
-    }
-    items = nextItems;
-    nextItems = [];
+    addToBatch(item);
+  }
+  if (batch.length > 0) {
+    flushBatch();
   }
   return output;
 }
@@ -1141,20 +1016,20 @@ function slugify(text, options) {
     \u00FF: "y"
   };
   const replacement = "-";
-  const trim = _optionalChain([options, 'optionalAccess', _12 => _12.trim]) !== false;
+  const trim = _optionalChain([options, 'optionalAccess', _8 => _8.trim]) !== false;
   let slug = text.normalize().split("").reduce((result, ch) => {
     const mapped = charMap[ch] || ch;
     const appendChar = mapped === replacement ? " " : mapped;
     return result + appendChar.replace(/[^\w\s$*_+~.()'"!\-:@]+/g, "");
   }, "");
-  if (_optionalChain([options, 'optionalAccess', _13 => _13.strict])) {
+  if (_optionalChain([options, 'optionalAccess', _9 => _9.strict])) {
     slug = slug.replace(/[^A-Za-z0-9\s]/g, "");
   }
   if (trim) {
     slug = slug.trim();
   }
   slug = slug.replace(/\s+/g, replacement);
-  if (_optionalChain([options, 'optionalAccess', _14 => _14.lower])) {
+  if (_optionalChain([options, 'optionalAccess', _10 => _10.lower])) {
     slug = slug.toLowerCase();
   }
   return slug;
@@ -1610,10 +1485,15 @@ var FunctionTypeEnum = _v3.z.enum([
   "preprocessor",
   "facet",
   "classifier",
-  "tag"
+  "tag",
+  "parameters"
 ]);
 var NullableSavedFunctionId = _v3.z.union([
-  _v3.z.object({ type: _v3.z.literal("function"), id: _v3.z.string() }),
+  _v3.z.object({
+    type: _v3.z.literal("function"),
+    id: _v3.z.string(),
+    version: _v3.z.string().optional()
+  }),
   _v3.z.object({
     type: _v3.z.literal("global"),
     name: _v3.z.string(),
@@ -1621,6 +1501,67 @@ var NullableSavedFunctionId = _v3.z.union([
   }),
   _v3.z.null()
 ]);
+var TopicMapReport = _v3.z.object({
+  version: _v3.z.literal(1),
+  created_at: _v3.z.string().optional(),
+  settings: _v3.z.object({
+    algorithm: _v3.z.enum(["hdbscan", "kmeans", "hierarchical"]),
+    dimension_reduction: _v3.z.enum(["umap", "pca", "none"]),
+    vector_field: _v3.z.string(),
+    embedding_model: _v3.z.string(),
+    n_clusters: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+    umap_dimensions: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+    min_cluster_size: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+    min_samples: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional()
+  }),
+  query_settings: _v3.z.object({
+    hierarchy_threshold: _v3.z.union([_v3.z.number(), _v3.z.null()]),
+    auto_naming: _v3.z.boolean(),
+    skip_cache: _v3.z.boolean(),
+    viz_mode: _v3.z.enum(["bar", "scatter"]),
+    naming_model: _v3.z.string()
+  }).partial(),
+  clusters: _v3.z.array(
+    _v3.z.object({
+      cluster_id: _v3.z.number(),
+      parent_cluster_id: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+      topic_id: _v3.z.string(),
+      count: _v3.z.number(),
+      sample_texts: _v3.z.array(_v3.z.string()),
+      samples: _v3.z.array(
+        _v3.z.object({
+          id: _v3.z.string(),
+          text: _v3.z.string(),
+          root_span_id: _v3.z.string(),
+          span_id: _v3.z.string()
+        })
+      ),
+      name: _v3.z.string().optional(),
+      description: _v3.z.string().optional(),
+      keywords: _v3.z.array(_v3.z.string()).optional(),
+      centroid: _v3.z.array(_v3.z.number()).optional(),
+      parent_id: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+      is_leaf: _v3.z.boolean().optional(),
+      depth: _v3.z.number().optional()
+    })
+  ),
+  embedding_points: _v3.z.array(
+    _v3.z.object({
+      x: _v3.z.number(),
+      y: _v3.z.number(),
+      cluster: _v3.z.number(),
+      text: _v3.z.string().optional()
+    })
+  ).optional()
+});
+var TopicMapData = _v3.z.object({
+  type: _v3.z.literal("topic_map"),
+  source_facet: _v3.z.string(),
+  embedding_model: _v3.z.string(),
+  bundle_key: _v3.z.string(),
+  distance_threshold: _v3.z.number().optional(),
+  report: TopicMapReport.optional()
+});
 var BatchedFacetData = _v3.z.object({
   type: _v3.z.literal("batched_facet"),
   preprocessor: NullableSavedFunctionId.and(_v3.z.unknown()).optional(),
@@ -1629,9 +1570,17 @@ var BatchedFacetData = _v3.z.object({
       name: _v3.z.string(),
       prompt: _v3.z.string(),
       model: _v3.z.string().optional(),
+      embedding_model: _v3.z.string().optional(),
       no_match_pattern: _v3.z.string().optional()
     })
-  )
+  ),
+  topic_maps: _v3.z.record(
+    _v3.z.object({
+      function_name: _v3.z.string(),
+      topic_map_id: _v3.z.string().optional(),
+      topic_map_data: TopicMapData
+    })
+  ).optional()
 });
 var BraintrustModelParams = _v3.z.object({
   use_cache: _v3.z.boolean(),
@@ -1842,6 +1791,18 @@ var ObjectReferenceNullish = _v3.z.union([
   }),
   _v3.z.null()
 ]);
+var SavedFunctionId = _v3.z.union([
+  _v3.z.object({
+    type: _v3.z.literal("function"),
+    id: _v3.z.string(),
+    version: _v3.z.string().optional()
+  }),
+  _v3.z.object({
+    type: _v3.z.literal("global"),
+    name: _v3.z.string(),
+    function_type: FunctionTypeEnum.optional().default("scorer")
+  })
+]);
 var DatasetEvent = _v3.z.object({
   id: _v3.z.string(),
   _xact_id: _v3.z.string(),
@@ -1861,7 +1822,36 @@ var DatasetEvent = _v3.z.object({
   is_root: _v3.z.union([_v3.z.boolean(), _v3.z.null()]).optional(),
   origin: ObjectReferenceNullish.optional(),
   comments: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
-  audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional()
+  audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
+  facets: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+  classifications: _v3.z.union([
+    _v3.z.record(
+      _v3.z.array(
+        _v3.z.object({
+          id: _v3.z.string(),
+          label: _v3.z.string().optional(),
+          confidence: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+          metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            _v3.z.union([
+              _v3.z.object({
+                type: _v3.z.literal("function"),
+                id: _v3.z.string(),
+                version: _v3.z.string().optional()
+              }),
+              _v3.z.object({
+                type: _v3.z.literal("global"),
+                name: _v3.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              _v3.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    _v3.z.null()
+  ]).optional()
 });
 var EnvVar = _v3.z.object({
   id: _v3.z.string().uuid(),
@@ -1938,7 +1928,8 @@ var SpanType = _v3.z.union([
     "automation",
     "facet",
     "preprocessor",
-    "classifier"
+    "classifier",
+    "review"
   ]),
   _v3.z.null()
 ]);
@@ -1979,10 +1970,43 @@ var ExperimentEvent = _v3.z.object({
   is_root: _v3.z.union([_v3.z.boolean(), _v3.z.null()]).optional(),
   origin: ObjectReferenceNullish.optional(),
   comments: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
-  audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional()
+  audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
+  facets: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+  classifications: _v3.z.union([
+    _v3.z.record(
+      _v3.z.array(
+        _v3.z.object({
+          id: _v3.z.string(),
+          label: _v3.z.string().optional(),
+          confidence: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+          metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            _v3.z.union([
+              _v3.z.object({
+                type: _v3.z.literal("function"),
+                id: _v3.z.string(),
+                version: _v3.z.string().optional()
+              }),
+              _v3.z.object({
+                type: _v3.z.literal("global"),
+                name: _v3.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              _v3.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    _v3.z.null()
+  ]).optional()
 });
 var ExtendedSavedFunctionId = _v3.z.union([
-  _v3.z.object({ type: _v3.z.literal("function"), id: _v3.z.string() }),
+  _v3.z.object({
+    type: _v3.z.literal("function"),
+    id: _v3.z.string(),
+    version: _v3.z.string().optional()
+  }),
   _v3.z.object({
     type: _v3.z.literal("global"),
     name: _v3.z.string(),
@@ -1999,6 +2023,7 @@ var FacetData = _v3.z.object({
   preprocessor: NullableSavedFunctionId.and(_v3.z.unknown()).optional(),
   prompt: _v3.z.string(),
   model: _v3.z.string().optional(),
+  embedding_model: _v3.z.string().optional(),
   no_match_pattern: _v3.z.string().optional()
 });
 var PromptBlockDataNullish = _v3.z.union([
@@ -2088,14 +2113,6 @@ var PromptParserNullish = _v3.z.union([
   }),
   _v3.z.null()
 ]);
-var SavedFunctionId = _v3.z.union([
-  _v3.z.object({ type: _v3.z.literal("function"), id: _v3.z.string() }),
-  _v3.z.object({
-    type: _v3.z.literal("global"),
-    name: _v3.z.string(),
-    function_type: FunctionTypeEnum.optional().default("scorer")
-  })
-]);
 var PromptDataNullish = _v3.z.union([
   _v3.z.object({
     prompt: PromptBlockDataNullish,
@@ -2146,7 +2163,8 @@ var FunctionTypeEnumNullish = _v3.z.union([
     "preprocessor",
     "facet",
     "classifier",
-    "tag"
+    "tag",
+    "parameters"
   ]),
   _v3.z.null()
 ]);
@@ -2238,7 +2256,8 @@ var FunctionData = _v3.z.union([
     type: _v3.z.literal("remote_eval"),
     endpoint: _v3.z.string(),
     eval_name: _v3.z.string(),
-    parameters: _v3.z.object({}).partial().passthrough()
+    parameters: _v3.z.object({}).partial().passthrough(),
+    parameters_version: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional()
   }),
   _v3.z.object({
     type: _v3.z.literal("global"),
@@ -2247,7 +2266,18 @@ var FunctionData = _v3.z.union([
     config: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional()
   }),
   FacetData,
-  BatchedFacetData
+  BatchedFacetData,
+  _v3.z.object({
+    type: _v3.z.literal("parameters"),
+    data: _v3.z.object({}).partial().passthrough(),
+    __schema: _v3.z.object({
+      type: _v3.z.literal("object"),
+      properties: _v3.z.record(_v3.z.object({}).partial().passthrough()),
+      required: _v3.z.array(_v3.z.string()).optional(),
+      additionalProperties: _v3.z.boolean().optional()
+    })
+  }),
+  TopicMapData.and(_v3.z.unknown())
 ]);
 var Function = _v3.z.object({
   id: _v3.z.string().uuid(),
@@ -2277,7 +2307,13 @@ var Function = _v3.z.object({
     _v3.z.null()
   ]).optional()
 });
-var FunctionFormat = _v3.z.enum(["llm", "code", "global", "graph"]);
+var FunctionFormat = _v3.z.enum([
+  "llm",
+  "code",
+  "global",
+  "graph",
+  "topic_map"
+]);
 var PromptData = _v3.z.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
@@ -2360,13 +2396,14 @@ var FunctionObjectType = _v3.z.enum([
   "custom_view",
   "preprocessor",
   "facet",
-  "classifier"
+  "classifier",
+  "parameters"
 ]);
 var FunctionOutputType = _v3.z.enum([
   "completion",
   "score",
   "facet",
-  "tag",
+  "classification",
   "any"
 ]);
 var GitMetadataSettings = _v3.z.object({
@@ -2402,6 +2439,10 @@ var GroupScope = _v3.z.object({
   idle_seconds: _v3.z.number().optional()
 });
 var IfExists = _v3.z.enum(["error", "ignore", "replace"]);
+var ImageRenderingMode = _v3.z.union([
+  _v3.z.enum(["auto", "click_to_load", "blocked"]),
+  _v3.z.null()
+]);
 var InvokeParent = _v3.z.union([
   _v3.z.object({
     object_type: _v3.z.enum(["project_logs", "experiment", "playground_logs"]),
@@ -2494,7 +2535,8 @@ var Organization = _v3.z.object({
   is_universal_api: _v3.z.union([_v3.z.boolean(), _v3.z.null()]).optional(),
   proxy_url: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   realtime_url: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
-  created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional()
+  created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  image_rendering_mode: ImageRenderingMode.optional()
 });
 var ProjectSettings = _v3.z.union([
   _v3.z.object({
@@ -2635,7 +2677,36 @@ var ProjectLogsEvent = _v3.z.object({
   origin: ObjectReferenceNullish.optional(),
   comments: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
   audit_data: _v3.z.union([_v3.z.array(_v3.z.unknown()), _v3.z.null()]).optional(),
-  _async_scoring_state: _v3.z.unknown().optional()
+  _async_scoring_state: _v3.z.unknown().optional(),
+  facets: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+  classifications: _v3.z.union([
+    _v3.z.record(
+      _v3.z.array(
+        _v3.z.object({
+          id: _v3.z.string(),
+          label: _v3.z.string().optional(),
+          confidence: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+          metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
+          source: SavedFunctionId.and(
+            _v3.z.union([
+              _v3.z.object({
+                type: _v3.z.literal("function"),
+                id: _v3.z.string(),
+                version: _v3.z.string().optional()
+              }),
+              _v3.z.object({
+                type: _v3.z.literal("global"),
+                name: _v3.z.string(),
+                function_type: FunctionTypeEnum.optional().default("scorer")
+              }),
+              _v3.z.null()
+            ])
+          ).optional()
+        })
+      )
+    ),
+    _v3.z.null()
+  ]).optional()
 });
 var ProjectScoreType = _v3.z.enum([
   "slider",
@@ -2937,12 +3008,15 @@ var View = _v3.z.object({
     "datasets",
     "dataset",
     "prompts",
+    "parameters",
     "tools",
     "scorers",
     "classifiers",
     "logs",
     "monitor",
-    "for_review"
+    "for_review_project_log",
+    "for_review_experiments",
+    "for_review_datasets"
   ]),
   name: _v3.z.string(),
   created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
@@ -3687,6 +3761,52 @@ var PromptCache = class {
   }
 };
 
+// src/prompt-cache/parameters-cache.ts
+function createCacheKey2(key) {
+  if (key.id) {
+    return `parameters:id:${key.id}`;
+  }
+  const prefix = _nullishCoalesce(key.projectId, () => ( key.projectName));
+  if (!prefix) {
+    throw new Error("Either projectId or projectName must be provided");
+  }
+  if (!key.slug) {
+    throw new Error("Slug must be provided when not using ID");
+  }
+  return `parameters:${prefix}:${key.slug}:${_nullishCoalesce(key.version, () => ( "latest"))}`;
+}
+var ParametersCache = class {
+  
+  
+  constructor(options) {
+    this.memoryCache = options.memoryCache;
+    this.diskCache = options.diskCache;
+  }
+  async get(key) {
+    const cacheKey = createCacheKey2(key);
+    const memoryParams = this.memoryCache.get(cacheKey);
+    if (memoryParams !== void 0) {
+      return memoryParams;
+    }
+    if (this.diskCache) {
+      const diskParams = await this.diskCache.get(cacheKey);
+      if (!diskParams) {
+        return void 0;
+      }
+      this.memoryCache.set(cacheKey, diskParams);
+      return diskParams;
+    }
+    return void 0;
+  }
+  async set(key, value) {
+    const cacheKey = createCacheKey2(key);
+    this.memoryCache.set(cacheKey, value);
+    if (this.diskCache) {
+      await this.diskCache.set(cacheKey, value);
+    }
+  }
+};
+
 // src/span-cache.ts
 var activeCaches = /* @__PURE__ */ new Set();
 var exitHandlersRegistered = false;
@@ -3708,7 +3828,7 @@ var SpanCache = (_class4 = class {
   // Small in-memory index tracking which rootSpanIds have data
   __init12() {this.rootSpanIndex = /* @__PURE__ */ new Set()}
   constructor(options) {;_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);_class4.prototype.__init11.call(this);_class4.prototype.__init12.call(this);_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);
-    this._explicitlyDisabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.disabled]), () => ( false));
+    this._explicitlyDisabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.disabled]), () => ( false));
   }
   /**
    * Disable the cache at runtime. This is called automatically when
@@ -3977,7 +4097,24 @@ var SpanCache = (_class4 = class {
 // src/logger.ts
 var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
+var LOGS3_OVERFLOW_REFERENCE_TYPE = "logs3_overflow";
 var BRAINTRUST_PARAMS = Object.keys(BraintrustModelParams.shape);
+var DEFAULT_MAX_REQUEST_SIZE = 6 * 1024 * 1024;
+var parametersRowSchema = _v3.z.object({
+  id: _v3.z.string().uuid(),
+  _xact_id: _v3.z.string(),
+  project_id: _v3.z.string().uuid(),
+  name: _v3.z.string(),
+  slug: _v3.z.string(),
+  description: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  function_type: _v3.z.literal("parameters"),
+  function_data: _v3.z.object({
+    type: _v3.z.literal("parameters"),
+    data: _v3.z.record(_v3.z.unknown()).optional(),
+    __schema: _v3.z.record(_v3.z.unknown())
+  }),
+  metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional()
+});
 var LoginInvalidOrgError = class extends Error {
   constructor(message) {
     super(message);
@@ -4075,7 +4212,7 @@ var NoopSpan = (_class5 = class {
     return this;
   }
   end(args) {
-    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _16 => _16.endTime]), () => ( getCurrentUnixTimestamp()));
+    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _12 => _12.endTime]), () => ( getCurrentUnixTimestamp()));
   }
   async export() {
     return "";
@@ -4154,6 +4291,17 @@ var BraintrustState = (_class6 = class _BraintrustState {
       max: _nullishCoalesce(Number(isomorph_default.getEnv("BRAINTRUST_PROMPT_CACHE_DISK_MAX")), () => ( 1 << 20))
     }) : void 0;
     this.promptCache = new PromptCache({ memoryCache, diskCache });
+    const parametersMemoryCache = new LRUCache({
+      max: _nullishCoalesce(Number(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX")), () => ( 1 << 10))
+    });
+    const parametersDiskCache = canUseDiskCache() ? new DiskCache({
+      cacheDir: _nullishCoalesce(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_DIR"), () => ( `${_nullishCoalesce(isomorph_default.getEnv("HOME"), () => ( isomorph_default.homedir()))}/.braintrust/parameters_cache`)),
+      max: _nullishCoalesce(Number(isomorph_default.getEnv("BRAINTRUST_PARAMETERS_CACHE_DISK_MAX")), () => ( 1 << 20))
+    }) : void 0;
+    this.parametersCache = new ParametersCache({
+      memoryCache: parametersMemoryCache,
+      diskCache: parametersDiskCache
+    });
     this.spanCache = new SpanCache({ disabled: loginParams.disableSpanCache });
   }
   
@@ -4184,6 +4332,7 @@ var BraintrustState = (_class6 = class _BraintrustState {
   __init29() {this._proxyConn = null}
   
   
+  
   __init30() {this._idGenerator = null}
   __init31() {this._contextManager = null}
   __init32() {this._otelFlushCallback = null}
@@ -4299,8 +4448,8 @@ var BraintrustState = (_class6 = class _BraintrustState {
   setFetch(fetch2) {
     this.loginParams.fetch = fetch2;
     this.fetch = fetch2;
-    _optionalChain([this, 'access', _17 => _17._apiConn, 'optionalAccess', _18 => _18.setFetch, 'call', _19 => _19(fetch2)]);
-    _optionalChain([this, 'access', _20 => _20._appConn, 'optionalAccess', _21 => _21.setFetch, 'call', _22 => _22(fetch2)]);
+    _optionalChain([this, 'access', _13 => _13._apiConn, 'optionalAccess', _14 => _14.setFetch, 'call', _15 => _15(fetch2)]);
+    _optionalChain([this, 'access', _16 => _16._appConn, 'optionalAccess', _17 => _17.setFetch, 'call', _18 => _18(fetch2)]);
   }
   setMaskingFunction(maskingFunction) {
     this.bgLogger().setMaskingFunction(maskingFunction);
@@ -4412,7 +4561,7 @@ function useTestBackgroundLogger() {
   return logger;
 }
 function clearTestBackgroundLogger() {
-  _optionalChain([_internalGetGlobalState, 'call', _23 => _23(), 'optionalAccess', _24 => _24.setOverrideBgLogger, 'call', _25 => _25(null)]);
+  _optionalChain([_internalGetGlobalState, 'call', _19 => _19(), 'optionalAccess', _20 => _20.setOverrideBgLogger, 'call', _21 => _21(null)]);
 }
 function initTestExperiment(experimentName, projectName) {
   setInitialTestState();
@@ -4439,8 +4588,8 @@ function _internalSetInitialState() {
 }
 var _internalGetGlobalState = () => _globalState;
 function registerOtelFlush(callback) {
-  _optionalChain([_globalState, 'optionalAccess', _26 => _26.registerOtelFlush, 'call', _27 => _27(callback)]);
-  _optionalChain([_globalState, 'optionalAccess', _28 => _28.spanCache, 'optionalAccess', _29 => _29.disable, 'call', _30 => _30()]);
+  _optionalChain([_globalState, 'optionalAccess', _22 => _22.registerOtelFlush, 'call', _23 => _23(callback)]);
+  _optionalChain([_globalState, 'optionalAccess', _24 => _24.spanCache, 'optionalAccess', _25 => _25.disable, 'call', _26 => _26()]);
 }
 var FailedHTTPResponse = class extends Error {
   
@@ -5130,8 +5279,8 @@ function _getOrgName(orgName) {
   return orgName || isomorph_default.getEnv("BRAINTRUST_ORG_NAME") || void 0;
 }
 function _getLinkBaseUrl(state, linkArgs) {
-  const appUrl = _getAppUrl(state.appUrl || _optionalChain([linkArgs, 'optionalAccess', _31 => _31.app_url]));
-  const orgName = _getOrgName(state.orgName || _optionalChain([linkArgs, 'optionalAccess', _32 => _32.org_name]));
+  const appUrl = _getAppUrl(state.appUrl || _optionalChain([linkArgs, 'optionalAccess', _27 => _27.app_url]));
+  const orgName = _getOrgName(state.orgName || _optionalChain([linkArgs, 'optionalAccess', _28 => _28.org_name]));
   if (!orgName) {
     return null;
   }
@@ -5141,9 +5290,9 @@ async function permalink(slug, opts) {
   if (slug === "") {
     return NOOP_SPAN_PERMALINK;
   }
-  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _33 => _33.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _29 => _29.state]), () => ( _globalState));
   const getOrgName = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _34 => _34.orgName])) {
+    if (_optionalChain([opts, 'optionalAccess', _30 => _30.orgName])) {
       return opts.orgName;
     }
     await state.login({});
@@ -5153,7 +5302,7 @@ async function permalink(slug, opts) {
     return state.orgName;
   };
   const getAppUrl = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _35 => _35.appUrl])) {
+    if (_optionalChain([opts, 'optionalAccess', _31 => _31.appUrl])) {
       return opts.appUrl;
     }
     await state.login({});
@@ -5288,7 +5437,7 @@ var Logger = (_class7 = class {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _36 => _36.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _32 => _32.allowConcurrentWithSpans])) {
       throw new Error(
         "Cannot run toplevel `log` method while using spans. To log to the span, call `logger.traced` and then log with `span.log`"
       );
@@ -5356,12 +5505,12 @@ var Logger = (_class7 = class {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _37 => _37.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _33 => _33.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: this.computeMetadataArgs,
-        parentSpanIds: _optionalChain([args, 'optionalAccess', _38 => _38.parentSpanIds]),
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _39 => _39.propagatedEvent])
+        parentSpanIds: _optionalChain([args, 'optionalAccess', _34 => _34.parentSpanIds]),
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _35 => _35.propagatedEvent])
       }),
       defaultRootType: "task" /* TASK */
     });
@@ -5437,8 +5586,100 @@ function castLogger(logger, asyncFlush) {
   }
   return logger;
 }
+var logs3OverflowUploadSchema = _v3.z.object({
+  method: _v3.z.enum(["PUT", "POST"]),
+  signedUrl: _v3.z.string().url(),
+  headers: _v3.z.record(_v3.z.string()).optional(),
+  fields: _v3.z.record(_v3.z.string()).optional(),
+  key: _v3.z.string().min(1)
+});
 function constructLogs3Data(items) {
-  return `{"rows": ${constructJsonArray(items)}, "api_version": 2}`;
+  return `{"rows": ${constructJsonArray(items.map((i) => i.str))}, "api_version": 2}`;
+}
+function constructLogs3OverflowRequest(key) {
+  return {
+    rows: {
+      type: LOGS3_OVERFLOW_REFERENCE_TYPE,
+      key
+    },
+    api_version: 2
+  };
+}
+function pickLogs3OverflowObjectIds(row) {
+  const objectIds = {};
+  for (const key of OBJECT_ID_KEYS) {
+    if (key in row) {
+      objectIds[key] = row[key];
+    }
+  }
+  return objectIds;
+}
+async function uploadLogs3OverflowPayload(upload, payload, fetchFn = fetch) {
+  if (upload.method === "POST") {
+    if (!upload.fields) {
+      throw new Error("Missing logs3 overflow upload fields");
+    }
+    if (typeof FormData === "undefined" || typeof Blob === "undefined") {
+      throw new Error("FormData is not available for logs3 overflow upload");
+    }
+    const form = new FormData();
+    for (const [key, value] of Object.entries(upload.fields)) {
+      form.append(key, value);
+    }
+    const contentType = _nullishCoalesce(upload.fields["Content-Type"], () => ( "application/json"));
+    form.append("file", new Blob([payload], { type: contentType }));
+    const headers2 = {};
+    for (const [key, value] of Object.entries(_nullishCoalesce(upload.headers, () => ( {})))) {
+      if (key.toLowerCase() !== "content-type") {
+        headers2[key] = value;
+      }
+    }
+    const response2 = await fetchFn(upload.signedUrl, {
+      method: "POST",
+      headers: headers2,
+      body: form
+    });
+    if (!response2.ok) {
+      const responseText = await response2.text().catch(() => "");
+      throw new Error(
+        `Failed to upload logs3 overflow payload: ${response2.status} ${responseText}`
+      );
+    }
+    return;
+  }
+  const headers = { ..._nullishCoalesce(upload.headers, () => ( {})) };
+  addAzureBlobHeaders(headers, upload.signedUrl);
+  const response = await fetchFn(upload.signedUrl, {
+    method: "PUT",
+    headers,
+    body: payload
+  });
+  if (!response.ok) {
+    const responseText = await response.text().catch(() => "");
+    throw new Error(
+      `Failed to upload logs3 overflow payload: ${response.status} ${responseText}`
+    );
+  }
+}
+function stringifyWithOverflowMeta(item) {
+  const str = JSON.stringify(item);
+  const record = item;
+  return {
+    str,
+    overflowMeta: {
+      object_ids: pickLogs3OverflowObjectIds(record),
+      is_delete: record[OBJECT_DELETE_FIELD] === true,
+      input_row: {
+        byte_size: utf8ByteLength(str)
+      }
+    }
+  };
+}
+function utf8ByteLength(value) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(value).length;
+  }
+  return value.length;
 }
 function now() {
   return (/* @__PURE__ */ new Date()).getTime();
@@ -5464,10 +5705,9 @@ var TestBackgroundLogger = (_class8 = class {constructor() { _class8.prototype._
         events.push(await event.get());
       }
     }
-    const batch = mergeRowBatch(events);
-    let flatBatch = batch.flat();
+    let batch = mergeRowBatch(events);
     if (this.maskingFunction) {
-      flatBatch = flatBatch.map((item) => {
+      batch = batch.map((item) => {
         const maskedItem = { ...item };
         for (const field of REDACTION_FIELDS) {
           if (item[field] !== void 0) {
@@ -5492,7 +5732,7 @@ var TestBackgroundLogger = (_class8 = class {constructor() { _class8.prototype._
         return maskedItem;
       });
     }
-    return flatBatch;
+    return batch;
   }
 }, _class8);
 var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
@@ -5505,21 +5745,21 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
   
   __init39() {this.maskingFunction = null}
   __init40() {this.syncFlush = false}
-  // 6 MB for the AWS lambda gateway (from our own testing).
-  __init41() {this.maxRequestSize = 6 * 1024 * 1024}
-  __init42() {this.defaultBatchSize = 100}
-  __init43() {this.numTries = 3}
-  __init44() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
-  __init45() {this.queueDropLoggingPeriod = 60}
-  __init46() {this.failedPublishPayloadsDir = void 0}
-  __init47() {this.allPublishPayloadsDir = void 0}
-  __init48() {this.flushChunkSize = 25}
-  __init49() {this._disabled = false}
-  __init50() {this.queueDropLoggingState = {
+  __init41() {this.maxRequestSizeOverride = null}
+  __init42() {this._maxRequestSizePromise = null}
+  __init43() {this.defaultBatchSize = 100}
+  __init44() {this.numTries = 3}
+  __init45() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
+  __init46() {this.queueDropLoggingPeriod = 60}
+  __init47() {this.failedPublishPayloadsDir = void 0}
+  __init48() {this.allPublishPayloadsDir = void 0}
+  __init49() {this.flushChunkSize = 25}
+  __init50() {this._disabled = false}
+  __init51() {this.queueDropLoggingState = {
     numDropped: 0,
     lastLoggedTimestamp: 0
   }}
-  constructor(apiConn, opts) {;_class9.prototype.__init36.call(this);_class9.prototype.__init37.call(this);_class9.prototype.__init38.call(this);_class9.prototype.__init39.call(this);_class9.prototype.__init40.call(this);_class9.prototype.__init41.call(this);_class9.prototype.__init42.call(this);_class9.prototype.__init43.call(this);_class9.prototype.__init44.call(this);_class9.prototype.__init45.call(this);_class9.prototype.__init46.call(this);_class9.prototype.__init47.call(this);_class9.prototype.__init48.call(this);_class9.prototype.__init49.call(this);_class9.prototype.__init50.call(this);
+  constructor(apiConn, opts) {;_class9.prototype.__init36.call(this);_class9.prototype.__init37.call(this);_class9.prototype.__init38.call(this);_class9.prototype.__init39.call(this);_class9.prototype.__init40.call(this);_class9.prototype.__init41.call(this);_class9.prototype.__init42.call(this);_class9.prototype.__init43.call(this);_class9.prototype.__init44.call(this);_class9.prototype.__init45.call(this);_class9.prototype.__init46.call(this);_class9.prototype.__init47.call(this);_class9.prototype.__init48.call(this);_class9.prototype.__init49.call(this);_class9.prototype.__init50.call(this);_class9.prototype.__init51.call(this);
     opts = _nullishCoalesce(opts, () => ( {}));
     this.apiConn = apiConn;
     const syncFlushEnv = Number(isomorph_default.getEnv("BRAINTRUST_SYNC_FLUSH"));
@@ -5534,7 +5774,7 @@ var HTTPBackgroundLogger = (_class9 = 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)) {
@@ -5596,6 +5836,30 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
       }
     }
   }
+  getMaxRequestSize() {
+    if (!this._maxRequestSizePromise) {
+      this._maxRequestSizePromise = (async () => {
+        let serverLimit = null;
+        try {
+          const conn = await this.apiConn.get();
+          const versionInfo = await conn.get_json("version");
+          serverLimit = _nullishCoalesce(_v3.z.object({ logs3_payload_max_bytes: _v3.z.number().nullish() }).parse(versionInfo).logs3_payload_max_bytes, () => ( null));
+        } catch (e) {
+          console.warn("Failed to fetch version info for payload limit:", e);
+        }
+        const validServerLimit = serverLimit !== null && serverLimit > 0 ? serverLimit : null;
+        const canUseOverflow = validServerLimit !== null;
+        let maxRequestSize = DEFAULT_MAX_REQUEST_SIZE;
+        if (this.maxRequestSizeOverride !== null) {
+          maxRequestSize = validServerLimit !== null ? Math.min(this.maxRequestSizeOverride, validServerLimit) : this.maxRequestSizeOverride;
+        } else if (validServerLimit !== null) {
+          maxRequestSize = validServerLimit;
+        }
+        return { maxRequestSize, canUseOverflow };
+      })();
+    }
+    return this._maxRequestSizePromise;
+  }
   async flush() {
     if (this.syncFlush) {
       this.triggerActiveFlush();
@@ -5614,7 +5878,7 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
       this.queue.clear();
       return;
     }
-    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _40 => _40.batchSize]), () => ( this.defaultBatchSize));
+    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _36 => _36.batchSize]), () => ( this.defaultBatchSize));
     const wrappedItems = this.queue.drain();
     if (wrappedItems.length === 0) {
       return;
@@ -5639,33 +5903,33 @@ var HTTPBackgroundLogger = (_class9 = 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) {
@@ -5695,32 +5959,30 @@ var HTTPBackgroundLogger = (_class9 = 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) {
@@ -5747,20 +6009,73 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
     }
     throw new Error("Impossible");
   }
-  async submitLogsRequest(items) {
+  async requestLogs3OverflowUpload(conn, args) {
+    let response;
+    try {
+      response = await conn.post_json("logs3/overflow", {
+        content_type: "application/json",
+        size_bytes: args.sizeBytes,
+        rows: args.rows
+      });
+    } catch (error) {
+      const errorStr = JSON.stringify(error);
+      throw new Error(
+        `Failed to request logs3 overflow upload URL: ${errorStr}`
+      );
+    }
+    try {
+      return logs3OverflowUploadSchema.parse(response);
+    } catch (error) {
+      if (error instanceof _v3.ZodError) {
+        const errorStr = JSON.stringify(error.flatten());
+        throw new Error(`Invalid response from API server: ${errorStr}`);
+      }
+      throw error;
+    }
+  }
+  async _uploadLogs3OverflowPayload(conn, upload, payload) {
+    await uploadLogs3OverflowPayload(upload, payload, conn.fetch.bind(conn));
+  }
+  async submitLogsRequest(items, {
+    maxRequestSize,
+    canUseOverflow
+  }) {
     const conn = await this.apiConn.get();
     const dataStr = constructLogs3Data(items);
+    const payloadBytes = utf8ByteLength(dataStr);
+    const useOverflow = canUseOverflow && payloadBytes > maxRequestSize;
     if (this.allPublishPayloadsDir) {
       await _HTTPBackgroundLogger.writePayloadToDir({
         payloadDir: this.allPublishPayloadsDir,
         payload: dataStr
       });
     }
+    let overflowUpload = null;
+    const overflowRows = useOverflow ? items.map((item) => item.overflowMeta) : null;
     for (let i = 0; i < this.numTries; i++) {
       const startTime = now();
       let error = void 0;
       try {
-        await conn.post_json("logs3", dataStr);
+        if (overflowRows) {
+          if (!overflowUpload) {
+            const currentUpload = await this.requestLogs3OverflowUpload(conn, {
+              rows: overflowRows,
+              sizeBytes: payloadBytes
+            });
+            await this._uploadLogs3OverflowPayload(
+              conn,
+              currentUpload,
+              dataStr
+            );
+            overflowUpload = currentUpload;
+          }
+          await conn.post_json(
+            "logs3",
+            constructLogs3OverflowRequest(overflowUpload.key)
+          );
+        } else {
+          await conn.post_json("logs3", dataStr);
+        }
       } catch (e) {
         error = e;
       }
@@ -5776,7 +6091,7 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
           return `${error}`;
         }
       })();
-      const errMsg = `log request failed. Elapsed time: ${(now() - startTime) / 1e3} seconds. Payload size: ${dataStr.length}.${retryingText}
+      const errMsg = `log request failed. Elapsed time: ${(now() - startTime) / 1e3} seconds. Payload size: ${payloadBytes}.${retryingText}
 Error: ${errorText}`;
       if (!isRetrying && this.failedPublishPayloadsDir) {
         await _HTTPBackgroundLogger.writePayloadToDir({
@@ -5830,7 +6145,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())
@@ -5879,10 +6194,10 @@ Error: ${errorText}`;
         } catch (err) {
           if (err instanceof AggregateError) {
             for (const e of err.errors) {
-              _optionalChain([this, 'access', _41 => _41.onFlushError, 'optionalCall', _42 => _42(e)]);
+              _optionalChain([this, 'access', _37 => _37.onFlushError, 'optionalCall', _38 => _38(e)]);
             }
           } else {
-            _optionalChain([this, 'access', _43 => _43.onFlushError, 'optionalCall', _44 => _44(err)]);
+            _optionalChain([this, 'access', _39 => _39.onFlushError, 'optionalCall', _40 => _40(err)]);
           }
           this.activeFlushError = err;
         } finally {
@@ -6397,12 +6712,133 @@ async function loadPrompt({
   }
   return prompt;
 }
-function setMaskingFunction(maskingFunction) {
-  _globalState.setMaskingFunction(maskingFunction);
-}
-async function login(options = {}) {
-  const { forceLogin = false } = options || {};
-  if (_globalState.loggedIn && !forceLogin) {
+async function loadParameters({
+  projectName,
+  projectId,
+  slug,
+  version,
+  environment,
+  id,
+  appUrl,
+  apiKey,
+  orgName,
+  fetch: fetch2,
+  forceLogin,
+  state: stateArg
+}) {
+  if (version && environment) {
+    throw new Error(
+      "Cannot specify both 'version' and 'environment' parameters. Please use only one (remove the other)."
+    );
+  }
+  if (id) {
+  } else if (isEmpty2(projectName) && isEmpty2(projectId)) {
+    throw new Error("Must specify either projectName or projectId");
+  } else if (isEmpty2(slug)) {
+    throw new Error("Must specify slug");
+  }
+  const state = _nullishCoalesce(stateArg, () => ( _globalState));
+  let response;
+  try {
+    await state.login({
+      orgName,
+      apiKey,
+      appUrl,
+      fetch: fetch2,
+      forceLogin
+    });
+    if (id) {
+      response = await state.apiConn().get_json(`v1/function/${id}`, {
+        ...version && { version },
+        ...environment && { environment }
+      });
+      if (response) {
+        response = { objects: [response] };
+      }
+    } else {
+      response = await state.apiConn().get_json("v1/function", {
+        project_name: projectName,
+        project_id: projectId,
+        slug,
+        version,
+        function_type: "parameters",
+        ...environment && { environment }
+      });
+    }
+  } catch (e) {
+    if (environment || version) {
+      throw new Error(`Parameters not found with specified parameters: ${e}`);
+    }
+    console.warn(
+      "Failed to load parameters, attempting to fall back to cache:",
+      e
+    );
+    let parameters2;
+    if (id) {
+      parameters2 = await state.parametersCache.get({ id });
+      if (!parameters2) {
+        throw new Error(
+          `Parameters with id ${id} not found (not found on server or in local cache): ${e}`
+        );
+      }
+    } else {
+      parameters2 = await state.parametersCache.get({
+        slug,
+        projectId,
+        projectName,
+        version: _nullishCoalesce(version, () => ( "latest"))
+      });
+      if (!parameters2) {
+        throw new Error(
+          `Parameters ${slug} (version ${_nullishCoalesce(version, () => ( "latest"))}) not found in ${[
+            _nullishCoalesce(projectName, () => ( projectId))
+          ]} (not found on server or in local cache): ${e}`
+        );
+      }
+    }
+    return parameters2;
+  }
+  if (!("objects" in response) || response.objects.length === 0) {
+    if (id) {
+      throw new Error(`Parameters with id ${id} not found.`);
+    } else {
+      throw new Error(
+        `Parameters ${slug} not found in ${[_nullishCoalesce(projectName, () => ( projectId))]}`
+      );
+    }
+  } else if (response.objects.length > 1) {
+    if (id) {
+      throw new Error(
+        `Multiple parameters found with id ${id}. This should never happen.`
+      );
+    } else {
+      throw new Error(
+        `Multiple parameters found with slug ${slug} in project ${_nullishCoalesce(projectName, () => ( projectId))}. This should never happen.`
+      );
+    }
+  }
+  const metadata = parametersRowSchema.parse(response["objects"][0]);
+  const parameters = new RemoteEvalParameters(metadata);
+  try {
+    if (id) {
+      await state.parametersCache.set({ id }, parameters);
+    } else if (slug) {
+      await state.parametersCache.set(
+        { slug, projectId, projectName, version: _nullishCoalesce(version, () => ( "latest")) },
+        parameters
+      );
+    }
+  } catch (e) {
+    console.warn("Failed to set parameters in cache:", e);
+  }
+  return parameters;
+}
+function setMaskingFunction(maskingFunction) {
+  _globalState.setMaskingFunction(maskingFunction);
+}
+async function login(options = {}) {
+  const { forceLogin = false } = options || {};
+  if (_globalState.loggedIn && !forceLogin) {
     let checkUpdatedParam2 = function(varname, arg, orig) {
       if (!isEmpty2(arg) && !isEmpty2(orig) && arg !== orig) {
         throw new Error(
@@ -6513,24 +6949,24 @@ async function summarize(options = {}) {
   return await e.summarize(options);
 }
 function currentExperiment(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _41 => _41.state]), () => ( _globalState));
   return state.currentExperiment;
 }
 function currentLogger(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.state]), () => ( _globalState));
-  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _47 => _47.asyncFlush]));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _42 => _42.state]), () => ( _globalState));
+  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _43 => _43.asyncFlush]));
 }
 function currentSpan(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _48 => _48.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _44 => _44.state]), () => ( _globalState));
   return _nullishCoalesce(state.contextManager.getCurrentSpan(), () => ( NOOP_SPAN));
 }
 function getSpanParentObject(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _49 => _49.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.state]), () => ( _globalState));
   const parentSpan = currentSpan({ state });
   if (!Object.is(parentSpan, NOOP_SPAN)) {
     return parentSpan;
   }
-  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _50 => _50.parent]), () => ( state.currentParent.getStore()));
+  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.parent]), () => ( state.currentParent.getStore()));
   if (parentStr) return getSpanComponentsClass().fromStr(parentStr);
   const experiment = currentExperiment();
   if (experiment) {
@@ -6559,7 +6995,7 @@ function traced(callback, args) {
   const { span, isSyncFlushLogger } = startSpanAndIsLogger(args);
   const ret = runCatchFinally(
     () => {
-      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _51 => _51.setCurrent]), () => ( true))) {
+      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _47 => _47.setCurrent]), () => ( true))) {
         return withCurrent(span, callback);
       } else {
         return callback(span);
@@ -6571,7 +7007,7 @@ function traced(callback, args) {
     },
     () => span.end()
   );
-  if (_optionalChain([args, 'optionalAccess', _52 => _52.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _53 => _53.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _48 => _48.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _49 => _49.asyncFlush])) {
     return ret;
   } else {
     return (async () => {
@@ -6695,14 +7131,14 @@ function wrapTraced(fn, args) {
   };
   const hasExplicitInput = args && args.event && "input" in args.event && args.event.input !== void 0;
   const hasExplicitOutput = args && args.event && args.event.output !== void 0;
-  const noTraceIO = _optionalChain([args, 'optionalAccess', _54 => _54.noTraceIO]) || hasExplicitInput || hasExplicitOutput;
+  const noTraceIO = _optionalChain([args, 'optionalAccess', _50 => _50.noTraceIO]) || hasExplicitInput || hasExplicitOutput;
   if (isGeneratorFunction(fn)) {
     return wrapTracedSyncGenerator(fn, spanArgs, !!noTraceIO);
   }
   if (isAsyncGeneratorFunction(fn)) {
     return wrapTracedAsyncGenerator(fn, spanArgs, !!noTraceIO);
   }
-  if (_optionalChain([args, 'optionalAccess', _55 => _55.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _51 => _51.asyncFlush])) {
     return ((...fnArgs) => traced((span) => {
       if (!hasExplicitInput) {
         span.log({ input: fnArgs });
@@ -6740,17 +7176,17 @@ function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
 async function flush(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _56 => _56.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.state]), () => ( _globalState));
   return await state.bgLogger().flush();
 }
 function setFetch(fetch2) {
   _globalState.setFetch(fetch2);
 }
 function startSpanAndIsLogger(args) {
-  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _57 => _57.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _53 => _53.state]), () => ( _globalState));
   const parentObject = getSpanParentObject({
-    asyncFlush: _optionalChain([args, 'optionalAccess', _58 => _58.asyncFlush]),
-    parent: _optionalChain([args, 'optionalAccess', _59 => _59.parent]),
+    asyncFlush: _optionalChain([args, 'optionalAccess', _54 => _54.asyncFlush]),
+    parent: _optionalChain([args, 'optionalAccess', _55 => _55.parent]),
     state
   });
   if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
@@ -6767,14 +7203,14 @@ function startSpanAndIsLogger(args) {
       ),
       parentComputeObjectMetadataArgs: _nullishCoalesce(parentObject.data.compute_object_metadata_args, () => ( void 0)),
       parentSpanIds,
-      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _60 => _60.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _56 => _56.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       (_nullishCoalesce(parentObject.data.propagated_event, () => ( void 0)))))
     });
     return {
       span,
       isSyncFlushLogger: parentObject.data.object_type === 2 /* PROJECT_LOGS */ && // Since there's no parent logger here, we're free to choose the async flush
       // behavior, and therefore propagate along whatever we get from the arguments
-      _optionalChain([args, 'optionalAccess', _61 => _61.asyncFlush]) === false
+      _optionalChain([args, 'optionalAccess', _57 => _57.asyncFlush]) === false
     };
   } else {
     const span = parentObject.startSpan(args);
@@ -6966,10 +7402,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _62 => _62.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (_optionalChain([value, 'optionalAccess', _58 => _58.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _63 => _63.reference, 'optionalAccess', _64 => _64.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _65 => _65.uploader])) {
+    if (_optionalChain([value, 'optionalAccess', _59 => _59.reference, 'optionalAccess', _60 => _60.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _61 => _61.uploader])) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -7036,13 +7472,13 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
 var DEFAULT_FETCH_BATCH_SIZE = 1e3;
 var MAX_BTQL_ITERATIONS = 1e4;
 var ObjectFetcher = (_class10 = class {
-  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class10.prototype.__init51.call(this);
+  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class10.prototype.__init52.call(this);
     this.objectType = objectType;
     this.pinnedVersion = pinnedVersion;
     this.mutateRecord = mutateRecord;
     this._internal_btql = _internal_btql;
   }
-  __init51() {this._fetchedData = void 0}
+  __init52() {this._fetchedData = void 0}
   get id() {
     throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
   }
@@ -7120,7 +7556,7 @@ var ObjectFetcher = (_class10 = class {
       }
       return;
     }
-    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _66 => _66.batchSize]))) {
+    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _62 => _62.batchSize]))) {
       yield record;
     }
   }
@@ -7130,7 +7566,7 @@ var ObjectFetcher = (_class10 = class {
   async fetchedData(options) {
     if (this._fetchedData === void 0) {
       const data = [];
-      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _67 => _67.batchSize]))) {
+      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _63 => _63.batchSize]))) {
         data.push(record);
       }
       this._fetchedData = data;
@@ -7163,9 +7599,9 @@ var Experiment2 = (_class11 = class extends ObjectFetcher {
   
   
   // For type identification.
-  __init52() {this.kind = "experiment"}
+  __init53() {this.kind = "experiment"}
   constructor(state, lazyMetadata, dataset) {
-    super("experiment", void 0, (r) => enrichAttachments(r, state));_class11.prototype.__init52.call(this);;
+    super("experiment", void 0, (r) => enrichAttachments(r, state));_class11.prototype.__init53.call(this);;
     this.lazyMetadata = lazyMetadata;
     this.dataset = dataset;
     this.lastStartTime = getCurrentUnixTimestamp();
@@ -7225,7 +7661,7 @@ var Experiment2 = (_class11 = class extends ObjectFetcher {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _68 => _68.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _64 => _64.allowConcurrentWithSpans])) {
       throw new Error(
         "Cannot run toplevel `log` method while using spans. To log to the span, call `experiment.traced` and then log with `span.log`"
       );
@@ -7278,12 +7714,12 @@ var Experiment2 = (_class11 = class extends ObjectFetcher {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _69 => _69.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _65 => _65.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: void 0,
         parentSpanIds: void 0,
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _70 => _70.propagatedEvent])
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _66 => _66.propagatedEvent])
       }),
       defaultRootType: "eval" /* EVAL */
     });
@@ -7518,8 +7954,8 @@ var SpanImpl = (_class12 = class _SpanImpl {
   
   
   
-  __init53() {this.kind = "span"}
-  constructor(args) {;_class12.prototype.__init53.call(this);
+  __init54() {this.kind = "span"}
+  constructor(args) {;_class12.prototype.__init54.call(this);
     this._state = args.state;
     const spanAttributes = _nullishCoalesce(args.spanAttributes, () => ( {}));
     const rawEvent = _nullishCoalesce(args.event, () => ( {}));
@@ -7621,8 +8057,8 @@ var SpanImpl = (_class12 = class _SpanImpl {
       ...serializableInternalData,
       [IS_MERGE_FIELD]: this.isMerge
     });
-    if (_optionalChain([partialRecord, 'access', _71 => _71.metrics, 'optionalAccess', _72 => _72.end])) {
-      this.loggedEndTime = _optionalChain([partialRecord, 'access', _73 => _73.metrics, 'optionalAccess', _74 => _74.end]);
+    if (_optionalChain([partialRecord, 'access', _67 => _67.metrics, 'optionalAccess', _68 => _68.end])) {
+      this.loggedEndTime = _optionalChain([partialRecord, 'access', _69 => _69.metrics, 'optionalAccess', _70 => _70.end]);
     }
     if (this.parentObjectType === 1 /* EXPERIMENT */) {
       const cachedSpan = {
@@ -7681,18 +8117,18 @@ var SpanImpl = (_class12 = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _75 => _75.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _71 => _71.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this._state,
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _76 => _76.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _72 => _72.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _77 => _77.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _73 => _73.propagatedEvent]), () => ( this.propagatedEvent))
       })
     });
   }
@@ -7706,12 +8142,12 @@ var SpanImpl = (_class12 = class _SpanImpl {
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _78 => _78.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _74 => _74.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _79 => _79.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _75 => _75.propagatedEvent]), () => ( this.propagatedEvent))
       }),
       spanId
     });
@@ -7720,7 +8156,7 @@ var SpanImpl = (_class12 = class _SpanImpl {
     let endTime;
     let internalData = {};
     if (!this.loggedEndTime) {
-      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _80 => _80.endTime]), () => ( getCurrentUnixTimestamp()));
+      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _76 => _76.endTime]), () => ( getCurrentUnixTimestamp()));
       internalData = { metrics: { end: endTime } };
     } else {
       endTime = this.loggedEndTime;
@@ -7771,8 +8207,8 @@ var SpanImpl = (_class12 = class _SpanImpl {
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
       case 2 /* PROJECT_LOGS */: {
-        const projectID = _optionalChain([args, 'optionalAccess', _81 => _81.project_id]) || this.parentObjectId.getSync().value;
-        const projectName = _optionalChain([args, 'optionalAccess', _82 => _82.project_name]);
+        const projectID = _optionalChain([args, 'optionalAccess', _77 => _77.project_id]) || this.parentObjectId.getSync().value;
+        const projectName = _optionalChain([args, 'optionalAccess', _78 => _78.project_name]);
         if (projectID) {
           return `${baseUrl}/object?object_type=project_logs&object_id=${projectID}&id=${this._id}`;
         } else if (projectName) {
@@ -7782,7 +8218,7 @@ var SpanImpl = (_class12 = class _SpanImpl {
         }
       }
       case 1 /* EXPERIMENT */: {
-        const expID = _optionalChain([args, 'optionalAccess', _83 => _83.experiment_id]) || _optionalChain([this, 'access', _84 => _84.parentObjectId, 'optionalAccess', _85 => _85.getSync, 'call', _86 => _86(), 'optionalAccess', _87 => _87.value]);
+        const expID = _optionalChain([args, 'optionalAccess', _79 => _79.experiment_id]) || _optionalChain([this, 'access', _80 => _80.parentObjectId, 'optionalAccess', _81 => _81.getSync, 'call', _82 => _82(), 'optionalAccess', _83 => _83.value]);
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
         } else {
@@ -7872,13 +8308,13 @@ var Dataset2 = (_class13 = class extends ObjectFetcher {
         )
       ),
       _internal_btql
-    );_class13.prototype.__init54.call(this);_class13.prototype.__init55.call(this);;
+    );_class13.prototype.__init55.call(this);_class13.prototype.__init56.call(this);;
     this.state = state;
     this.lazyMetadata = lazyMetadata;
   }
   
-  __init54() {this.__braintrust_dataset_marker = true}
-  __init55() {this.newRecords = 0}
+  __init55() {this.__braintrust_dataset_marker = true}
+  __init56() {this.newRecords = 0}
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).dataset.id;
@@ -8232,14 +8668,14 @@ function renderPromptParams(params, args, options = {}) {
   return params;
 }
 var Prompt2 = (_class14 = class _Prompt {
-  constructor(metadata, defaults, noTrace) {;_class14.prototype.__init56.call(this);_class14.prototype.__init57.call(this);
+  constructor(metadata, defaults, noTrace) {;_class14.prototype.__init57.call(this);_class14.prototype.__init58.call(this);
     this.metadata = metadata;
     this.defaults = defaults;
     this.noTrace = noTrace;
   }
   
-  __init56() {this.hasParsedPromptData = false}
-  __init57() {this.__braintrust_prompt_marker = true}
+  __init57() {this.hasParsedPromptData = false}
+  __init58() {this.__braintrust_prompt_marker = true}
   get id() {
     return this.metadata.id;
   }
@@ -8253,16 +8689,16 @@ var Prompt2 = (_class14 = class _Prompt {
     return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
   }
   get prompt() {
-    return _optionalChain([this, 'access', _88 => _88.getParsedPromptData, 'call', _89 => _89(), 'optionalAccess', _90 => _90.prompt]);
+    return _optionalChain([this, 'access', _84 => _84.getParsedPromptData, 'call', _85 => _85(), 'optionalAccess', _86 => _86.prompt]);
   }
   get version() {
     return this.metadata[TRANSACTION_ID_FIELD];
   }
   get options() {
-    return _optionalChain([this, 'access', _91 => _91.getParsedPromptData, 'call', _92 => _92(), 'optionalAccess', _93 => _93.options]) || {};
+    return _optionalChain([this, 'access', _87 => _87.getParsedPromptData, 'call', _88 => _88(), 'optionalAccess', _89 => _89.options]) || {};
   }
   get templateFormat() {
-    return _optionalChain([this, 'access', _94 => _94.getParsedPromptData, 'call', _95 => _95(), 'optionalAccess', _96 => _96.template_format]);
+    return _optionalChain([this, 'access', _90 => _90.getParsedPromptData, 'call', _91 => _91(), 'optionalAccess', _92 => _92.template_format]);
   }
   get promptData() {
     return this.getParsedPromptData();
@@ -8422,7 +8858,7 @@ var Prompt2 = (_class14 = class _Prompt {
       return {
         type: "chat",
         messages,
-        ..._optionalChain([prompt, 'access', _97 => _97.tools, 'optionalAccess', _98 => _98.trim, 'call', _99 => _99()]) ? {
+        ..._optionalChain([prompt, 'access', _93 => _93.tools, 'optionalAccess', _94 => _94.trim, 'call', _95 => _95()]) ? {
           tools: render(prompt.tools)
         } : void 0
       };
@@ -8467,6 +8903,55 @@ var Prompt2 = (_class14 = class _Prompt {
     );
   }
 }, _class14);
+var RemoteEvalParameters = (_class15 = class {
+  constructor(metadata) {;_class15.prototype.__init59.call(this);
+    this.metadata = metadata;
+  }
+  __init59() {this.__braintrust_parameters_marker = true}
+  get id() {
+    return this.metadata.id;
+  }
+  get projectId() {
+    return this.metadata.project_id;
+  }
+  get name() {
+    return this.metadata.name;
+  }
+  get slug() {
+    return this.metadata.slug;
+  }
+  get version() {
+    return this.metadata[TRANSACTION_ID_FIELD];
+  }
+  get schema() {
+    return this.metadata.function_data.__schema;
+  }
+  get data() {
+    return _nullishCoalesce(this.metadata.function_data.data, () => ( {}));
+  }
+  validate(data) {
+    if (typeof data !== "object" || data === null) {
+      return false;
+    }
+    const schemaProps = this.schema.properties;
+    if (typeof schemaProps !== "object" || schemaProps === null) {
+      return true;
+    }
+    for (const key of Object.keys(schemaProps)) {
+      if (!(key in data)) {
+        const required = Array.isArray(this.schema.required) ? this.schema.required : [];
+        if (required.includes(key)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  static isParameters(x) {
+    return typeof x === "object" && x !== null && "__braintrust_parameters_marker" in x && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    x.__braintrust_parameters_marker === true;
+  }
+}, _class15);
 var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
 function setInitialTestState() {
   if (!_internalGetGlobalState()) {
@@ -8531,9 +9016,9 @@ async function getPromptVersions(projectId, promptId) {
     );
   }
   const result = await response.json();
-  return _optionalChain([result, 'access', _100 => _100.data, 'optionalAccess', _101 => _101.filter, 'call', _102 => _102(
-    (entry) => ["upsert", "merge"].includes(_optionalChain([entry, 'access', _103 => _103.audit_data, 'optionalAccess', _104 => _104.action]))
-  ), 'access', _105 => _105.map, 'call', _106 => _106((entry) => prettifyXact(entry._xact_id))]) || [];
+  return _optionalChain([result, 'access', _96 => _96.data, 'optionalAccess', _97 => _97.filter, 'call', _98 => _98(
+    (entry) => ["upsert", "merge"].includes(_optionalChain([entry, 'access', _99 => _99.audit_data, 'optionalAccess', _100 => _100.action]))
+  ), 'access', _101 => _101.map, 'call', _102 => _102((entry) => prettifyXact(entry._xact_id))]) || [];
 }
 function resetIdGenStateForTests() {
   const state = _internalGetGlobalState();
@@ -8602,6 +9087,7 @@ __export(exports_exports, {
   CodePrompt: () => CodePrompt,
   ContextManager: () => ContextManager,
   DEFAULT_FETCH_BATCH_SIZE: () => DEFAULT_FETCH_BATCH_SIZE,
+  DEFAULT_MAX_REQUEST_SIZE: () => DEFAULT_MAX_REQUEST_SIZE,
   Dataset: () => Dataset2,
   ERR_PERMALINK: () => ERR_PERMALINK,
   Eval: () => Eval,
@@ -8612,6 +9098,7 @@ __export(exports_exports, {
   IDGenerator: () => IDGenerator,
   JSONAttachment: () => JSONAttachment,
   LEGACY_CACHED_HEADER: () => LEGACY_CACHED_HEADER,
+  LOGS3_OVERFLOW_REFERENCE_TYPE: () => LOGS3_OVERFLOW_REFERENCE_TYPE,
   LazyValue: () => LazyValue,
   Logger: () => Logger,
   LoginInvalidOrgError: () => LoginInvalidOrgError,
@@ -8636,8 +9123,10 @@ __export(exports_exports, {
   _exportsForTestingOnly: () => _exportsForTestingOnly,
   _internalGetGlobalState: () => _internalGetGlobalState,
   _internalSetInitialState: () => _internalSetInitialState,
+  addAzureBlobHeaders: () => addAzureBlobHeaders,
   braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   buildLocalSummary: () => buildLocalSummary,
+  constructLogs3OverflowRequest: () => constructLogs3OverflowRequest,
   createFinalValuePassThroughStream: () => createFinalValuePassThroughStream,
   currentExperiment: () => currentExperiment,
   currentLogger: () => currentLogger,
@@ -8661,15 +9150,18 @@ __export(exports_exports, {
   initLogger: () => initLogger,
   invoke: () => invoke,
   isTemplateFormat: () => isTemplateFormat,
+  loadParameters: () => loadParameters,
   loadPrompt: () => loadPrompt,
   log: () => log,
   logError: () => logError,
   login: () => login,
   loginToState: () => loginToState,
+  logs3OverflowUploadSchema: () => logs3OverflowUploadSchema,
   newId: () => newId,
   parseCachedHeader: () => parseCachedHeader,
   parseTemplateFormat: () => parseTemplateFormat,
   permalink: () => permalink,
+  pickLogs3OverflowObjectIds: () => pickLogs3OverflowObjectIds,
   projects: () => projects,
   promptContentsSchema: () => promptContentsSchema,
   promptDefinitionSchema: () => promptDefinitionSchema,
@@ -8690,6 +9182,8 @@ __export(exports_exports, {
   traceable: () => traceable,
   traced: () => traced,
   updateSpan: () => updateSpan,
+  uploadLogs3OverflowPayload: () => uploadLogs3OverflowPayload,
+  utf8ByteLength: () => utf8ByteLength,
   withCurrent: () => withCurrent,
   withDataset: () => withDataset,
   withExperiment: () => withExperiment,
@@ -8792,7 +9286,7 @@ function initFunction({
   state
 }) {
   const s = _nullishCoalesce(state, () => ( _internalGetGlobalState()));
-  _optionalChain([s, 'optionalAccess', _107 => _107.spanCache, 'optionalAccess', _108 => _108.disable, 'call', _109 => _109()]);
+  _optionalChain([s, 'optionalAccess', _103 => _103.spanCache, 'optionalAccess', _104 => _104.disable, 'call', _105 => _105()]);
   const f = async (input) => {
     return await invoke({
       projectName,
@@ -8856,7 +9350,7 @@ function parseSpanFromResponseCreateParams(params) {
 }
 function parseEventFromResponseCreateResult(result) {
   const data = {};
-  if (_optionalChain([result, 'optionalAccess', _110 => _110.output]) !== void 0) {
+  if (_optionalChain([result, 'optionalAccess', _106 => _106.output]) !== void 0) {
     data.output = processImagesInOutput(result.output);
   }
   if (result) {
@@ -8865,7 +9359,7 @@ function parseEventFromResponseCreateResult(result) {
       data.metadata = metadata;
     }
   }
-  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _111 => _111.usage]));
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _107 => _107.usage]));
   return data;
 }
 function processImagesInOutput(output) {
@@ -8919,7 +9413,7 @@ function parseSpanFromResponseParseParams(params) {
 }
 function parseEventFromResponseParseResult(result) {
   const data = {};
-  if (_optionalChain([result, 'optionalAccess', _112 => _112.output]) !== void 0) {
+  if (_optionalChain([result, 'optionalAccess', _108 => _108.output]) !== void 0) {
     data.output = processImagesInOutput(result.output);
   }
   if (result) {
@@ -8928,7 +9422,7 @@ function parseEventFromResponseParseResult(result) {
       data.metadata = metadata;
     }
   }
-  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _113 => _113.usage]));
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _109 => _109.usage]));
   return data;
 }
 function traceResponseCreateStream(stream, timedSpan) {
@@ -8945,7 +9439,7 @@ function traceResponseCreateStream(stream, timedSpan) {
       return result;
     }
     const item = result.value;
-    if (!item || !_optionalChain([item, 'optionalAccess', _114 => _114.type]) || !_optionalChain([item, 'optionalAccess', _115 => _115.response])) {
+    if (!item || !_optionalChain([item, 'optionalAccess', _110 => _110.type]) || !_optionalChain([item, 'optionalAccess', _111 => _111.response])) {
       return result;
     }
     const event = parseLogFromItem(item);
@@ -8956,14 +9450,14 @@ function traceResponseCreateStream(stream, timedSpan) {
   };
 }
 function parseLogFromItem(item) {
-  if (!item || !_optionalChain([item, 'optionalAccess', _116 => _116.type]) || !_optionalChain([item, 'optionalAccess', _117 => _117.response])) {
+  if (!item || !_optionalChain([item, 'optionalAccess', _112 => _112.type]) || !_optionalChain([item, 'optionalAccess', _113 => _113.response])) {
     return {};
   }
   const response = item.response;
   switch (item.type) {
     case "response.completed":
       const data = {};
-      if (_optionalChain([response, 'optionalAccess', _118 => _118.output]) !== void 0) {
+      if (_optionalChain([response, 'optionalAccess', _114 => _114.output]) !== void 0) {
         data.output = processImagesInOutput(response.output);
       }
       if (response) {
@@ -8972,7 +9466,7 @@ function parseLogFromItem(item) {
           data.metadata = metadata;
         }
       }
-      data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _119 => _119.usage]));
+      data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _115 => _115.usage]));
       return data;
     default:
       return {};
@@ -9169,8 +9663,8 @@ function wrapOpenAIv4(openai) {
   const embeddingProxy = createEndpointProxy(openai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(openai.moderations, wrapModerations);
   let betaProxy2;
-  if (_optionalChain([openai, 'access', _120 => _120.beta, 'optionalAccess', _121 => _121.chat, 'optionalAccess', _122 => _122.completions, 'optionalAccess', _123 => _123.stream])) {
-    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _124 => _124.beta, 'optionalAccess', _125 => _125.chat, 'access', _126 => _126.completions]), {
+  if (_optionalChain([openai, 'access', _116 => _116.beta, 'optionalAccess', _117 => _117.chat, 'optionalAccess', _118 => _118.completions, 'optionalAccess', _119 => _119.stream])) {
+    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _120 => _120.beta, 'optionalAccess', _121 => _121.chat, 'access', _122 => _122.completions]), {
       get(target, name, receiver) {
         const baseVal = Reflect.get(target, name, receiver);
         if (name === "parse") {
@@ -9218,7 +9712,7 @@ function wrapOpenAIv4(openai) {
   });
 }
 function logCompletionResponse(startTime, response, span) {
-  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _127 => _127.usage]));
+  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _123 => _123.usage]));
   metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
   span.log({
     output: response.choices,
@@ -9516,7 +10010,7 @@ function parseChatCompletionParams(params) {
 function processEmbeddingResponse(result, span) {
   span.log({
     output: { embedding_length: result.data[0].embedding.length },
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _128 => _128.usage]))
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _124 => _124.usage]))
   });
 }
 function processModerationResponse(result, span) {
@@ -9546,10 +10040,10 @@ function postprocessStreamingResults(allResults) {
     if (result.usage) {
       metrics = {
         ...metrics,
-        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _129 => _129.usage]))
+        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _125 => _125.usage]))
       };
     }
-    const delta = _optionalChain([result, 'access', _130 => _130.choices, 'optionalAccess', _131 => _131[0], 'optionalAccess', _132 => _132.delta]);
+    const delta = _optionalChain([result, 'access', _126 => _126.choices, 'optionalAccess', _127 => _127[0], 'optionalAccess', _128 => _128.delta]);
     if (!delta) {
       continue;
     }
@@ -9793,7 +10287,7 @@ function isModuleNamespace(obj) {
   if (!obj || typeof obj !== "object") {
     return false;
   }
-  if (_optionalChain([obj, 'access', _133 => _133.constructor, 'optionalAccess', _134 => _134.name]) === "Module") {
+  if (_optionalChain([obj, 'access', _129 => _129.constructor, 'optionalAccess', _130 => _130.name]) === "Module") {
     return true;
   }
   try {
@@ -9892,10 +10386,10 @@ var makeGenerateTextWrapper = (name, options, generateText, aiSDK) => {
         });
         const gatewayInfo = extractGatewayRoutingInfo(result);
         const resolvedMetadata = {};
-        if (_optionalChain([gatewayInfo, 'optionalAccess', _135 => _135.provider])) {
+        if (_optionalChain([gatewayInfo, 'optionalAccess', _131 => _131.provider])) {
           resolvedMetadata.provider = gatewayInfo.provider;
         }
-        if (_optionalChain([gatewayInfo, 'optionalAccess', _136 => _136.model])) {
+        if (_optionalChain([gatewayInfo, 'optionalAccess', _132 => _132.model])) {
           resolvedMetadata.model = gatewayInfo.model;
         }
         span.log({
@@ -9933,7 +10427,7 @@ var resolveModel = (model, ai) => {
   if (typeof model !== "string") {
     return model;
   }
-  const provider = _nullishCoalesce(_nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( _optionalChain([ai, 'optionalAccess', _137 => _137.gateway]))), () => ( null));
+  const provider = _nullishCoalesce(_nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( _optionalChain([ai, 'optionalAccess', _133 => _133.gateway]))), () => ( null));
   if (provider && typeof provider.languageModel === "function") {
     return provider.languageModel(model);
   }
@@ -9948,7 +10442,7 @@ var wrapModel = (model, ai) => {
     return resolvedModel;
   }
   const originalDoGenerate = resolvedModel.doGenerate.bind(resolvedModel);
-  const originalDoStream = _optionalChain([resolvedModel, 'access', _138 => _138.doStream, 'optionalAccess', _139 => _139.bind, 'call', _140 => _140(resolvedModel)]);
+  const originalDoStream = _optionalChain([resolvedModel, 'access', _134 => _134.doStream, 'optionalAccess', _135 => _135.bind, 'call', _136 => _136(resolvedModel)]);
   const { model: modelId, provider } = serializeModelWithProvider(resolvedModel);
   const wrappedDoGenerate = async (options) => {
     const processedInput = await processInputAttachments2(options);
@@ -9957,10 +10451,10 @@ var wrapModel = (model, ai) => {
         const result = await originalDoGenerate(options);
         const gatewayInfo = extractGatewayRoutingInfo(result);
         const resolvedMetadata = {};
-        if (_optionalChain([gatewayInfo, 'optionalAccess', _141 => _141.provider])) {
+        if (_optionalChain([gatewayInfo, 'optionalAccess', _137 => _137.provider])) {
           resolvedMetadata.provider = gatewayInfo.provider;
         }
-        if (_optionalChain([gatewayInfo, 'optionalAccess', _142 => _142.model])) {
+        if (_optionalChain([gatewayInfo, 'optionalAccess', _138 => _138.model])) {
           resolvedMetadata.model = gatewayInfo.model;
         }
         if (result.finishReason !== void 0) {
@@ -10056,9 +10550,9 @@ var wrapModel = (model, ai) => {
           case "raw":
             if (chunk.rawValue) {
               const rawVal = chunk.rawValue;
-              if (_optionalChain([rawVal, 'access', _143 => _143.delta, 'optionalAccess', _144 => _144.content])) {
+              if (_optionalChain([rawVal, 'access', _139 => _139.delta, 'optionalAccess', _140 => _140.content])) {
                 text += rawVal.delta.content;
-              } else if (_optionalChain([rawVal, 'access', _145 => _145.choices, 'optionalAccess', _146 => _146[0], 'optionalAccess', _147 => _147.delta, 'optionalAccess', _148 => _148.content])) {
+              } else if (_optionalChain([rawVal, 'access', _141 => _141.choices, 'optionalAccess', _142 => _142[0], 'optionalAccess', _143 => _143.delta, 'optionalAccess', _144 => _144.content])) {
                 text += rawVal.choices[0].delta.content;
               } else if (typeof rawVal.text === "string") {
                 text += rawVal.text;
@@ -10078,10 +10572,10 @@ var wrapModel = (model, ai) => {
             }
             const gatewayInfo = extractGatewayRoutingInfo(output);
             const resolvedMetadata = {};
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _149 => _149.provider])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _145 => _145.provider])) {
               resolvedMetadata.provider = gatewayInfo.provider;
             }
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _150 => _150.model])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _146 => _146.model])) {
               resolvedMetadata.model = gatewayInfo.model;
             }
             if (chunk.finishReason !== void 0) {
@@ -10141,10 +10635,10 @@ var wrapGenerateObject = (generateObject, options = {}, aiSDK) => {
         const output = await processOutput(result, options.denyOutputPaths);
         const gatewayInfo = extractGatewayRoutingInfo(result);
         const resolvedMetadata = {};
-        if (_optionalChain([gatewayInfo, 'optionalAccess', _151 => _151.provider])) {
+        if (_optionalChain([gatewayInfo, 'optionalAccess', _147 => _147.provider])) {
           resolvedMetadata.provider = gatewayInfo.provider;
         }
-        if (_optionalChain([gatewayInfo, 'optionalAccess', _152 => _152.model])) {
+        if (_optionalChain([gatewayInfo, 'optionalAccess', _148 => _148.model])) {
           resolvedMetadata.model = gatewayInfo.model;
         }
         span.log({
@@ -10229,16 +10723,16 @@ var makeStreamTextWrapper = (name, options, streamText, aiSDK) => {
                 }
               });
             }
-            _optionalChain([params, 'access', _153 => _153.onChunk, 'optionalCall', _154 => _154(chunk)]);
+            _optionalChain([params, 'access', _149 => _149.onChunk, 'optionalCall', _150 => _150(chunk)]);
           },
           onFinish: async (event) => {
-            _optionalChain([params, 'access', _155 => _155.onFinish, 'optionalCall', _156 => _156(event)]);
+            _optionalChain([params, 'access', _151 => _151.onFinish, 'optionalCall', _152 => _152(event)]);
             const gatewayInfo = extractGatewayRoutingInfo(event);
             const resolvedMetadata = {};
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _157 => _157.provider])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _153 => _153.provider])) {
               resolvedMetadata.provider = gatewayInfo.provider;
             }
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _158 => _158.model])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _154 => _154.model])) {
               resolvedMetadata.model = gatewayInfo.model;
             }
             span.log({
@@ -10249,7 +10743,7 @@ var makeStreamTextWrapper = (name, options, streamText, aiSDK) => {
             span.end();
           },
           onError: async (err) => {
-            _optionalChain([params, 'access', _159 => _159.onError, 'optionalCall', _160 => _160(err)]);
+            _optionalChain([params, 'access', _155 => _155.onError, 'optionalCall', _156 => _156(err)]);
             span.log({
               error: serializeError(err)
             });
@@ -10353,16 +10847,16 @@ var wrapStreamObject = (streamObject, options = {}, aiSDK) => {
                 }
               });
             }
-            _optionalChain([params, 'access', _161 => _161.onChunk, 'optionalCall', _162 => _162(chunk)]);
+            _optionalChain([params, 'access', _157 => _157.onChunk, 'optionalCall', _158 => _158(chunk)]);
           },
           onFinish: async (event) => {
-            _optionalChain([params, 'access', _163 => _163.onFinish, 'optionalCall', _164 => _164(event)]);
+            _optionalChain([params, 'access', _159 => _159.onFinish, 'optionalCall', _160 => _160(event)]);
             const gatewayInfo = extractGatewayRoutingInfo(event);
             const resolvedMetadata = {};
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _165 => _165.provider])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _161 => _161.provider])) {
               resolvedMetadata.provider = gatewayInfo.provider;
             }
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _166 => _166.model])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _162 => _162.model])) {
               resolvedMetadata.model = gatewayInfo.model;
             }
             span.log({
@@ -10373,7 +10867,7 @@ var wrapStreamObject = (streamObject, options = {}, aiSDK) => {
             span.end();
           },
           onError: async (err) => {
-            _optionalChain([params, 'access', _167 => _167.onError, 'optionalCall', _168 => _168(err)]);
+            _optionalChain([params, 'access', _163 => _163.onError, 'optionalCall', _164 => _164(err)]);
             span.log({
               error: serializeError(err)
             });
@@ -10554,8 +11048,8 @@ function parseGatewayModelString(modelString) {
   return { model: modelString };
 }
 function serializeModelWithProvider(model) {
-  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _169 => _169.modelId]);
-  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _170 => _170.provider]) : void 0;
+  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _165 => _165.modelId]);
+  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _166 => _166.provider]) : void 0;
   if (!modelId) {
     return { model: modelId, provider: explicitProvider };
   }
@@ -10566,8 +11060,8 @@ function serializeModelWithProvider(model) {
   };
 }
 function extractGatewayRoutingInfo(result) {
-  if (_optionalChain([result, 'optionalAccess', _171 => _171.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
-    const routing2 = _optionalChain([result, 'access', _172 => _172.steps, 'access', _173 => _173[0], 'optionalAccess', _174 => _174.providerMetadata, 'optionalAccess', _175 => _175.gateway, 'optionalAccess', _176 => _176.routing]);
+  if (_optionalChain([result, 'optionalAccess', _167 => _167.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+    const routing2 = _optionalChain([result, 'access', _168 => _168.steps, 'access', _169 => _169[0], 'optionalAccess', _170 => _170.providerMetadata, 'optionalAccess', _171 => _171.gateway, 'optionalAccess', _172 => _172.routing]);
     if (routing2) {
       return {
         provider: routing2.resolvedProvider || routing2.finalProvider,
@@ -10575,7 +11069,7 @@ function extractGatewayRoutingInfo(result) {
       };
     }
   }
-  const routing = _optionalChain([result, 'optionalAccess', _177 => _177.providerMetadata, 'optionalAccess', _178 => _178.gateway, 'optionalAccess', _179 => _179.routing]);
+  const routing = _optionalChain([result, 'optionalAccess', _173 => _173.providerMetadata, 'optionalAccess', _174 => _174.gateway, 'optionalAccess', _175 => _175.routing]);
   if (routing) {
     return {
       provider: routing.resolvedProvider || routing.finalProvider,
@@ -10847,7 +11341,7 @@ var convertImageToAttachment = (image, explicitMimeType) => {
   try {
     if (typeof image === "string" && image.startsWith("data:")) {
       const [mimeTypeSection, base64Data] = image.split(",");
-      const mimeType = _optionalChain([mimeTypeSection, 'access', _180 => _180.match, 'call', _181 => _181(/data:(.*?);/), 'optionalAccess', _182 => _182[1]]);
+      const mimeType = _optionalChain([mimeTypeSection, 'access', _176 => _176.match, 'call', _177 => _177(/data:(.*?);/), 'optionalAccess', _178 => _178[1]]);
       if (mimeType && base64Data) {
         const blob = convertDataToBlob(base64Data, mimeType);
         if (blob) {
@@ -11014,7 +11508,7 @@ function firstNumber(...values) {
 }
 function extractTokenMetrics(result) {
   const metrics = {};
-  let usage = _optionalChain([result, 'optionalAccess', _183 => _183.totalUsage]) || _optionalChain([result, 'optionalAccess', _184 => _184.usage]);
+  let usage = _optionalChain([result, 'optionalAccess', _179 => _179.totalUsage]) || _optionalChain([result, 'optionalAccess', _180 => _180.usage]);
   if (!usage && result) {
     try {
       if ("totalUsage" in result && typeof result.totalUsage !== "function") {
@@ -11029,7 +11523,7 @@ function extractTokenMetrics(result) {
     return metrics;
   }
   const promptTokens = firstNumber(
-    _optionalChain([usage, 'access', _185 => _185.inputTokens, 'optionalAccess', _186 => _186.total]),
+    _optionalChain([usage, 'access', _181 => _181.inputTokens, 'optionalAccess', _182 => _182.total]),
     usage.inputTokens,
     usage.promptTokens,
     usage.prompt_tokens
@@ -11038,7 +11532,7 @@ function extractTokenMetrics(result) {
     metrics.prompt_tokens = promptTokens;
   }
   const completionTokens = firstNumber(
-    _optionalChain([usage, 'access', _187 => _187.outputTokens, 'optionalAccess', _188 => _188.total]),
+    _optionalChain([usage, 'access', _183 => _183.outputTokens, 'optionalAccess', _184 => _184.total]),
     usage.outputTokens,
     usage.completionTokens,
     usage.completion_tokens
@@ -11055,7 +11549,7 @@ function extractTokenMetrics(result) {
     metrics.tokens = totalTokens;
   }
   const promptCachedTokens = firstNumber(
-    _optionalChain([usage, 'access', _189 => _189.inputTokens, 'optionalAccess', _190 => _190.cacheRead]),
+    _optionalChain([usage, 'access', _185 => _185.inputTokens, 'optionalAccess', _186 => _186.cacheRead]),
     usage.cachedInputTokens,
     usage.promptCachedTokens,
     usage.prompt_cached_tokens
@@ -11085,7 +11579,7 @@ function extractTokenMetrics(result) {
     metrics.completion_cached_tokens = completionCachedTokens;
   }
   const reasoningTokenCount = firstNumber(
-    _optionalChain([usage, 'access', _191 => _191.outputTokens, 'optionalAccess', _192 => _192.reasoning]),
+    _optionalChain([usage, 'access', _187 => _187.outputTokens, 'optionalAccess', _188 => _188.reasoning]),
     usage.reasoningTokens,
     usage.completionReasoningTokens,
     usage.completion_reasoning_tokens,
@@ -11111,12 +11605,12 @@ function extractTokenMetrics(result) {
   return metrics;
 }
 function extractCostFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _193 => _193.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+  if (_optionalChain([result, 'optionalAccess', _189 => _189.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
     let totalCost = 0;
     let foundCost = false;
     for (const step of result.steps) {
-      const gateway2 = _optionalChain([step, 'optionalAccess', _194 => _194.providerMetadata, 'optionalAccess', _195 => _195.gateway]);
-      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _196 => _196.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _197 => _197.marketCost]));
+      const gateway2 = _optionalChain([step, 'optionalAccess', _190 => _190.providerMetadata, 'optionalAccess', _191 => _191.gateway]);
+      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _192 => _192.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _193 => _193.marketCost]));
       if (stepCost !== void 0 && stepCost > 0) {
         totalCost += stepCost;
         foundCost = true;
@@ -11126,8 +11620,8 @@ function extractCostFromResult(result) {
       return totalCost;
     }
   }
-  const gateway = _optionalChain([result, 'optionalAccess', _198 => _198.providerMetadata, 'optionalAccess', _199 => _199.gateway]);
-  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _200 => _200.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _201 => _201.marketCost]));
+  const gateway = _optionalChain([result, 'optionalAccess', _194 => _194.providerMetadata, 'optionalAccess', _195 => _195.gateway]);
+  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _196 => _196.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _197 => _197.marketCost]));
   if (directCost !== void 0 && directCost > 0) {
     return directCost;
   }
@@ -11221,7 +11715,7 @@ var omit = (obj, paths) => {
 // src/wrappers/ai-sdk/deprecated/wrapAISDKModel.ts
 function wrapAISDKModel(model) {
   const m = model;
-  if (_optionalChain([m, 'optionalAccess', _202 => _202.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _203 => _203.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _204 => _204.modelId]) === "string") {
+  if (_optionalChain([m, 'optionalAccess', _198 => _198.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _199 => _199.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _200 => _200.modelId]) === "string") {
     return new BraintrustLanguageModelWrapper(m);
   } else {
     console.warn("Unsupported AI SDK model. Not wrapping.");
@@ -11278,10 +11772,10 @@ var BraintrustLanguageModelWrapper = class {
         metrics: {
           time_to_first_token: getCurrentUnixTimestamp() - startTime,
           tokens: !isEmpty2(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
-          prompt_tokens: _optionalChain([ret, 'access', _205 => _205.usage, 'optionalAccess', _206 => _206.promptTokens]),
-          completion_tokens: _optionalChain([ret, 'access', _207 => _207.usage, 'optionalAccess', _208 => _208.completionTokens]),
+          prompt_tokens: _optionalChain([ret, 'access', _201 => _201.usage, 'optionalAccess', _202 => _202.promptTokens]),
+          completion_tokens: _optionalChain([ret, 'access', _203 => _203.usage, 'optionalAccess', _204 => _204.completionTokens]),
           cached: parseCachedHeader(
-            _nullishCoalesce(_optionalChain([ret, 'access', _209 => _209.rawResponse, 'optionalAccess', _210 => _210.headers, 'optionalAccess', _211 => _211[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _212 => _212.rawResponse, 'optionalAccess', _213 => _213.headers, 'optionalAccess', _214 => _214[LEGACY_CACHED_HEADER]])))
+            _nullishCoalesce(_optionalChain([ret, 'access', _205 => _205.rawResponse, 'optionalAccess', _206 => _206.headers, 'optionalAccess', _207 => _207[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _208 => _208.rawResponse, 'optionalAccess', _209 => _209.headers, 'optionalAccess', _210 => _210[LEGACY_CACHED_HEADER]])))
           )
         }
       });
@@ -11373,10 +11867,10 @@ var BraintrustLanguageModelWrapper = class {
                 metrics: {
                   time_to_first_token,
                   tokens: !isEmpty2(usage) ? usage.promptTokens + usage.completionTokens : void 0,
-                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _215 => _215.promptTokens]),
-                  completion_tokens: _optionalChain([usage, 'optionalAccess', _216 => _216.completionTokens]),
+                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _211 => _211.promptTokens]),
+                  completion_tokens: _optionalChain([usage, 'optionalAccess', _212 => _212.completionTokens]),
                   cached: parseCachedHeader(
-                    _nullishCoalesce(_optionalChain([ret, 'access', _217 => _217.rawResponse, 'optionalAccess', _218 => _218.headers, 'optionalAccess', _219 => _219[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _220 => _220.rawResponse, 'optionalAccess', _221 => _221.headers, 'optionalAccess', _222 => _222[LEGACY_CACHED_HEADER]])))
+                    _nullishCoalesce(_optionalChain([ret, 'access', _213 => _213.rawResponse, 'optionalAccess', _214 => _214.headers, 'optionalAccess', _215 => _215[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _216 => _216.rawResponse, 'optionalAccess', _217 => _217.headers, 'optionalAccess', _218 => _218[LEGACY_CACHED_HEADER]])))
                   )
                 }
               });
@@ -11420,7 +11914,7 @@ function postProcessPrompt(prompt) {
         return [
           {
             role: "assistant",
-            content: _optionalChain([textPart, 'optionalAccess', _223 => _223.text]),
+            content: _optionalChain([textPart, 'optionalAccess', _219 => _219.text]),
             ...toolCallParts.length > 0 ? {
               tool_calls: toolCallParts.map((part) => ({
                 id: part.toolCallId,
@@ -11513,23 +12007,23 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
 
 // src/wrappers/ai-sdk/deprecated/BraintrustMiddleware.ts
 function detectProviderFromResult(result) {
-  if (!_optionalChain([result, 'optionalAccess', _224 => _224.providerMetadata])) {
+  if (!_optionalChain([result, 'optionalAccess', _220 => _220.providerMetadata])) {
     return void 0;
   }
   const keys = Object.keys(result.providerMetadata);
-  return _optionalChain([keys, 'optionalAccess', _225 => _225.at, 'call', _226 => _226(0)]);
+  return _optionalChain([keys, 'optionalAccess', _221 => _221.at, 'call', _222 => _222(0)]);
 }
 function extractModelFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _227 => _227.response, 'optionalAccess', _228 => _228.modelId])) {
+  if (_optionalChain([result, 'optionalAccess', _223 => _223.response, 'optionalAccess', _224 => _224.modelId])) {
     return result.response.modelId;
   }
-  if (_optionalChain([result, 'optionalAccess', _229 => _229.request, 'optionalAccess', _230 => _230.body, 'optionalAccess', _231 => _231.model])) {
+  if (_optionalChain([result, 'optionalAccess', _225 => _225.request, 'optionalAccess', _226 => _226.body, 'optionalAccess', _227 => _227.model])) {
     return result.request.body.model;
   }
   return void 0;
 }
 function extractModelFromWrapGenerateCallback(model) {
-  return _optionalChain([model, 'optionalAccess', _232 => _232.modelId]);
+  return _optionalChain([model, 'optionalAccess', _228 => _228.modelId]);
 }
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
@@ -11574,7 +12068,7 @@ function normalizeUsageMetrics(usage, provider, providerMetadata) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
   if (provider === "anthropic") {
-    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _233 => _233.anthropic]);
+    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _229 => _229.anthropic]);
     if (anthropicMetadata) {
       const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
       const cacheCreationTokens = getNumberProperty(
@@ -11600,7 +12094,7 @@ function buildAssistantOutputWithToolCalls(result, toolCalls) {
     {
       index: 0,
       logprobs: null,
-      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _234 => _234.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
+      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _230 => _230.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
       message: {
         role: "assistant",
         tool_calls: toolCalls.length > 0 ? toolCalls : void 0
@@ -11613,7 +12107,7 @@ function extractToolCallsFromSteps(steps) {
   if (!Array.isArray(steps)) return toolCalls;
   let idx = 0;
   for (const step of steps) {
-    const blocks = _optionalChain([step, 'optionalAccess', _235 => _235.content]);
+    const blocks = _optionalChain([step, 'optionalAccess', _231 => _231.content]);
     if (!Array.isArray(blocks)) continue;
     for (const block of blocks) {
       if (block && typeof block === "object" && block.type === "tool-call") {
@@ -11636,7 +12130,7 @@ function extractToolCallsFromBlocks(blocks) {
   return extractToolCallsFromSteps([{ content: blocks }]);
 }
 function extractInput(params) {
-  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _236 => _236.prompt]), () => ( _optionalChain([params, 'optionalAccess', _237 => _237.messages]))), () => ( _optionalChain([params, 'optionalAccess', _238 => _238.system])));
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _232 => _232.prompt]), () => ( _optionalChain([params, 'optionalAccess', _233 => _233.messages]))), () => ( _optionalChain([params, 'optionalAccess', _234 => _234.system])));
 }
 var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
   "prompt",
@@ -11660,16 +12154,16 @@ function BraintrustMiddleware(config = {}) {
       const rawInput = extractInput(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
-        name: _optionalChain([config, 'access', _239 => _239.spanInfo, 'optionalAccess', _240 => _240.name]) || "ai-sdk.doGenerate",
+        name: _optionalChain([config, 'access', _235 => _235.spanInfo, 'optionalAccess', _236 => _236.name]) || "ai-sdk.doGenerate",
         spanAttributes: {
           type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _241 => _241.spanInfo, 'optionalAccess', _242 => _242.spanAttributes]) || {}
+          ..._optionalChain([config, 'access', _237 => _237.spanInfo, 'optionalAccess', _238 => _238.spanAttributes]) || {}
         },
         event: {
           input: processedInput,
           metadata: {
             ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _243 => _243.spanInfo, 'optionalAccess', _244 => _244.metadata]) || {}
+            ..._optionalChain([config, 'access', _239 => _239.spanInfo, 'optionalAccess', _240 => _240.metadata]) || {}
           }
         }
       };
@@ -11695,12 +12189,12 @@ function BraintrustMiddleware(config = {}) {
             metadata.model = modelId;
           }
         }
-        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _245 => _245.steps]));
+        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _241 => _241.steps]));
         if (!toolCalls || toolCalls.length === 0) {
-          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _246 => _246.content]));
+          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _242 => _242.content]));
         }
         span.log({
-          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _247 => _247.content]),
+          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _243 => _243.content]),
           metadata,
           metrics: normalizeUsageMetrics(
             result.usage,
@@ -11722,16 +12216,16 @@ function BraintrustMiddleware(config = {}) {
       const rawInput = extractInput(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
-        name: _optionalChain([config, 'access', _248 => _248.spanInfo, 'optionalAccess', _249 => _249.name]) || "ai-sdk.doStream",
+        name: _optionalChain([config, 'access', _244 => _244.spanInfo, 'optionalAccess', _245 => _245.name]) || "ai-sdk.doStream",
         spanAttributes: {
           type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _250 => _250.spanInfo, 'optionalAccess', _251 => _251.spanAttributes]) || {}
+          ..._optionalChain([config, 'access', _246 => _246.spanInfo, 'optionalAccess', _247 => _247.spanAttributes]) || {}
         },
         event: {
           input: processedInput,
           metadata: {
             ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _252 => _252.spanInfo, 'optionalAccess', _253 => _253.metadata]) || {}
+            ..._optionalChain([config, 'access', _248 => _248.spanInfo, 'optionalAccess', _249 => _249.metadata]) || {}
           }
         }
       };
@@ -12002,9 +12496,9 @@ function streamNextProxy(stream, sspan) {
     }
     const item = result.value;
     const blockIndex = item.index;
-    switch (_optionalChain([item, 'optionalAccess', _254 => _254.type])) {
+    switch (_optionalChain([item, 'optionalAccess', _250 => _250.type])) {
       case "message_start":
-        const msg = _optionalChain([item, 'optionalAccess', _255 => _255.message]);
+        const msg = _optionalChain([item, 'optionalAccess', _251 => _251.message]);
         if (msg) {
           const event = parseEventFromMessage(msg);
           totals = { ...totals, ...event.metrics };
@@ -12021,23 +12515,23 @@ function streamNextProxy(stream, sspan) {
         if (!contentBlockDeltas[blockIndex]) {
           contentBlockDeltas[blockIndex] = [];
         }
-        if (_optionalChain([item, 'optionalAccess', _256 => _256.delta, 'optionalAccess', _257 => _257.type]) === "text_delta") {
-          const text2 = _optionalChain([item, 'optionalAccess', _258 => _258.delta, 'optionalAccess', _259 => _259.text]);
+        if (_optionalChain([item, 'optionalAccess', _252 => _252.delta, 'optionalAccess', _253 => _253.type]) === "text_delta") {
+          const text2 = _optionalChain([item, 'optionalAccess', _254 => _254.delta, 'optionalAccess', _255 => _255.text]);
           if (text2) {
             contentBlockDeltas[blockIndex].push(text2);
           }
-        } else if (_optionalChain([item, 'optionalAccess', _260 => _260.delta, 'optionalAccess', _261 => _261.type]) === "input_json_delta") {
-          const partialJson = _optionalChain([item, 'optionalAccess', _262 => _262.delta, 'optionalAccess', _263 => _263.partial_json]);
+        } else if (_optionalChain([item, 'optionalAccess', _256 => _256.delta, 'optionalAccess', _257 => _257.type]) === "input_json_delta") {
+          const partialJson = _optionalChain([item, 'optionalAccess', _258 => _258.delta, 'optionalAccess', _259 => _259.partial_json]);
           if (partialJson) {
             contentBlockDeltas[blockIndex].push(partialJson);
           }
         }
         break;
       case "content_block_stop":
-        const text = _optionalChain([contentBlockDeltas, 'access', _264 => _264[blockIndex], 'optionalAccess', _265 => _265.join, 'call', _266 => _266("")]);
+        const text = _optionalChain([contentBlockDeltas, 'access', _260 => _260[blockIndex], 'optionalAccess', _261 => _261.join, 'call', _262 => _262("")]);
         if (!text) break;
         const block = contentBlocks[blockIndex];
-        if (_optionalChain([block, 'optionalAccess', _267 => _267.type]) === "tool_use") {
+        if (_optionalChain([block, 'optionalAccess', _263 => _263.type]) === "tool_use") {
           try {
             span.log({
               output: {
@@ -12053,12 +12547,12 @@ function streamNextProxy(stream, sspan) {
         }
         break;
       case "message_delta":
-        const usage = _optionalChain([item, 'optionalAccess', _268 => _268.usage]);
+        const usage = _optionalChain([item, 'optionalAccess', _264 => _264.usage]);
         if (usage) {
           const metrics = parseMetricsFromUsage2(usage);
           totals = { ...totals, ...metrics };
         }
-        const delta = _optionalChain([item, 'optionalAccess', _269 => _269.delta]);
+        const delta = _optionalChain([item, 'optionalAccess', _265 => _265.delta]);
         if (delta) {
           metadata = { ...metadata, ...delta };
         }
@@ -12071,7 +12565,7 @@ function streamNextProxy(stream, sspan) {
 }
 function parseEventFromMessage(message) {
   const output = message ? { role: message.role, content: message.content } : null;
-  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _270 => _270.usage]));
+  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _266 => _266.usage]));
   const metas = ["stop_reason", "stop_sequence"];
   const metadata = {};
   for (const m of metas) {
@@ -12160,6 +12654,189 @@ function wrapMastraAgent(agent, _options) {
 }
 
 // src/wrappers/claude-agent-sdk/claude-agent-sdk.ts
+function getMcpServerMetadata(serverName, mcpServers) {
+  if (!serverName || !mcpServers) {
+    return {};
+  }
+  const serverConfig = mcpServers[serverName];
+  if (!serverConfig) {
+    return {};
+  }
+  const metadata = {};
+  if (serverConfig.type) {
+    metadata["mcp.type"] = serverConfig.type;
+  } else if (typeof serverConfig === "object" && "transport" in serverConfig) {
+    metadata["mcp.type"] = "sdk";
+  }
+  if (serverConfig.url) {
+    metadata["mcp.url"] = serverConfig.url;
+  }
+  if (serverConfig.command) {
+    metadata["mcp.command"] = serverConfig.command;
+    if (serverConfig.args) {
+      metadata["mcp.args"] = serverConfig.args.join(" ");
+    }
+  }
+  return metadata;
+}
+function parseToolName(rawToolName) {
+  const mcpMatch = rawToolName.match(/^mcp__([^_]+)__(.+)$/);
+  if (mcpMatch) {
+    const [, mcpServer, toolName] = mcpMatch;
+    return {
+      displayName: `tool: ${mcpServer}/${toolName}`,
+      toolName,
+      mcpServer,
+      rawToolName
+    };
+  }
+  return {
+    displayName: `tool: ${rawToolName}`,
+    toolName: rawToolName,
+    rawToolName
+  };
+}
+function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, subAgentSpans, endedSubAgentSpans) {
+  const preToolUse = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PreToolUse" || !toolUseID) {
+      return {};
+    }
+    if (input.tool_name === "Task") {
+      return {};
+    }
+    const parsed = parseToolName(input.tool_name);
+    const mcpMetadata = getMcpServerMetadata(parsed.mcpServer, mcpServers);
+    const parentExport = await resolveParentSpan(toolUseID);
+    const toolSpan = startSpan({
+      name: parsed.displayName,
+      spanAttributes: { type: "tool" /* TOOL */ },
+      event: {
+        input: input.tool_input,
+        metadata: {
+          // GenAI semantic conventions
+          "gen_ai.tool.name": parsed.toolName,
+          "gen_ai.tool.call.id": toolUseID,
+          // MCP-specific metadata
+          ...parsed.mcpServer && { "mcp.server": parsed.mcpServer },
+          ...mcpMetadata,
+          // Claude SDK metadata
+          "claude_agent_sdk.raw_tool_name": parsed.rawToolName,
+          "claude_agent_sdk.session_id": input.session_id,
+          "claude_agent_sdk.cwd": input.cwd
+        }
+      },
+      parent: parentExport
+    });
+    activeToolSpans.set(toolUseID, toolSpan);
+    return {};
+  };
+  const postToolUse = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PostToolUse" || !toolUseID) {
+      return {};
+    }
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan) {
+      try {
+        const response = input.tool_response;
+        const metadata = {};
+        if (_optionalChain([response, 'optionalAccess', _267 => _267.status])) {
+          metadata["claude_agent_sdk.status"] = response.status;
+        }
+        if (_optionalChain([response, 'optionalAccess', _268 => _268.totalDurationMs])) {
+          metadata["claude_agent_sdk.duration_ms"] = response.totalDurationMs;
+        }
+        if (_optionalChain([response, 'optionalAccess', _269 => _269.totalToolUseCount]) !== void 0) {
+          metadata["claude_agent_sdk.tool_use_count"] = response.totalToolUseCount;
+        }
+        subAgentSpan.log({
+          output: _optionalChain([response, 'optionalAccess', _270 => _270.content]),
+          metadata
+        });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
+    const toolSpan = activeToolSpans.get(toolUseID);
+    if (!toolSpan) {
+      return {};
+    }
+    try {
+      toolSpan.log({ output: input.tool_response });
+    } finally {
+      toolSpan.end();
+      activeToolSpans.delete(toolUseID);
+    }
+    return {};
+  };
+  const postToolUseFailure = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PostToolUseFailure" || !toolUseID) {
+      return {};
+    }
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan) {
+      try {
+        subAgentSpan.log({ error: input.error });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
+    const toolSpan = activeToolSpans.get(toolUseID);
+    if (!toolSpan) {
+      return {};
+    }
+    const parsed = parseToolName(input.tool_name);
+    try {
+      toolSpan.log({
+        error: input.error,
+        metadata: {
+          "gen_ai.tool.name": parsed.toolName,
+          "gen_ai.tool.call.id": toolUseID,
+          ...parsed.mcpServer && { "mcp.server": parsed.mcpServer },
+          "claude_agent_sdk.is_interrupt": input.is_interrupt,
+          "claude_agent_sdk.session_id": input.session_id
+        }
+      });
+    } finally {
+      toolSpan.end();
+      activeToolSpans.delete(toolUseID);
+    }
+    return {};
+  };
+  return { preToolUse, postToolUse, postToolUseFailure };
+}
+function injectTracingHooks(options, resolveParentSpan, activeToolSpans, subAgentSpans, endedSubAgentSpans) {
+  const mcpServers = options.mcpServers;
+  const { preToolUse, postToolUse, postToolUseFailure } = createToolTracingHooks(
+    resolveParentSpan,
+    activeToolSpans,
+    mcpServers,
+    subAgentSpans,
+    endedSubAgentSpans
+  );
+  const existingHooks = _nullishCoalesce(options.hooks, () => ( {}));
+  return {
+    ...options,
+    hooks: {
+      ...existingHooks,
+      PreToolUse: [
+        ..._nullishCoalesce(existingHooks.PreToolUse, () => ( [])),
+        { hooks: [preToolUse] }
+      ],
+      PostToolUse: [
+        ..._nullishCoalesce(existingHooks.PostToolUse, () => ( [])),
+        { hooks: [postToolUse] }
+      ],
+      PostToolUseFailure: [
+        ..._nullishCoalesce(existingHooks.PostToolUseFailure, () => ( [])),
+        { hooks: [postToolUseFailure] }
+      ]
+    }
+  };
+}
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -12184,18 +12861,45 @@ function filterSerializableOptions(options) {
   }
   return filtered;
 }
+function isAsyncIterable(value) {
+  return value !== null && value !== void 0 && typeof value[Symbol.asyncIterator] === "function";
+}
 function wrapClaudeAgentQuery(queryFn, defaultThis) {
   const proxy = new Proxy(queryFn, {
     apply(target, thisArg, argArray) {
       const params = _nullishCoalesce(argArray[0], () => ( {}));
       const { prompt, options = {} } = params;
+      const promptIsAsyncIterable = isAsyncIterable(prompt);
+      let capturedPromptMessages;
+      let promptForQuery = prompt;
+      let promptStarted = false;
+      let resolvePromptDone;
+      const promptDone = new Promise((resolve) => {
+        resolvePromptDone = resolve;
+      });
+      if (promptIsAsyncIterable) {
+        capturedPromptMessages = [];
+        const originalPrompt = prompt;
+        const capturingPrompt = (async function* () {
+          promptStarted = true;
+          try {
+            for await (const msg of originalPrompt) {
+              capturedPromptMessages.push(msg);
+              yield msg;
+            }
+          } finally {
+            _optionalChain([resolvePromptDone, 'optionalCall', _271 => _271()]);
+          }
+        })();
+        promptForQuery = capturingPrompt;
+      }
       const span = startSpan({
         name: "Claude Agent",
         spanAttributes: {
           type: "task" /* TASK */
         },
         event: {
-          input: typeof prompt === "string" ? prompt : { type: "streaming", description: "AsyncIterable<SDKMessage>" },
+          input: typeof prompt === "string" ? prompt : promptIsAsyncIterable ? void 0 : prompt !== void 0 ? String(prompt) : void 0,
           metadata: filterSerializableOptions(options)
         }
       });
@@ -12206,47 +12910,120 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
       let currentMessageStartTime = getCurrentUnixTimestamp();
       const currentMessages = [];
       const createLLMSpan = async () => {
+        const parentToolUseId = _nullishCoalesce(_optionalChain([currentMessages, 'access', _272 => _272[0], 'optionalAccess', _273 => _273.parent_tool_use_id]), () => ( null));
+        let parentSpanExport;
+        if (parentToolUseId) {
+          const subAgentSpan = subAgentSpans.get(parentToolUseId);
+          parentSpanExport = subAgentSpan ? await subAgentSpan.export() : await span.export();
+        } else {
+          parentSpanExport = await span.export();
+        }
         const finalMessageContent = await _createLLMSpanForMessages(
           currentMessages,
           prompt,
           finalResults,
           options,
           currentMessageStartTime,
-          await span.export()
+          capturedPromptMessages,
+          parentSpanExport
         );
         if (finalMessageContent) {
           finalResults.push(finalMessageContent);
         }
         const lastMessage = currentMessages[currentMessages.length - 1];
-        if (_optionalChain([lastMessage, 'optionalAccess', _271 => _271.message, 'optionalAccess', _272 => _272.usage])) {
+        if (_optionalChain([lastMessage, 'optionalAccess', _274 => _274.message, 'optionalAccess', _275 => _275.usage])) {
           const outputTokens = getNumberProperty2(lastMessage.message.usage, "output_tokens") || 0;
           accumulatedOutputTokens += outputTokens;
         }
         currentMessages.length = 0;
       };
       const invocationTarget = thisArg === proxy || thisArg === void 0 ? _nullishCoalesce(defaultThis, () => ( thisArg)) : thisArg;
+      const activeToolSpans = /* @__PURE__ */ new Map();
+      const subAgentSpans = /* @__PURE__ */ new Map();
+      const endedSubAgentSpans = /* @__PURE__ */ new Set();
+      const toolUseToParent = /* @__PURE__ */ new Map();
+      const pendingSubAgentNames = /* @__PURE__ */ new Map();
+      const resolveParentSpan = async (toolUseID) => {
+        const parentToolUseId = toolUseToParent.get(toolUseID);
+        if (parentToolUseId) {
+          const subAgentSpan = subAgentSpans.get(parentToolUseId);
+          if (subAgentSpan) {
+            return subAgentSpan.export();
+          }
+        }
+        return span.export();
+      };
+      const optionsWithHooks = injectTracingHooks(
+        options,
+        resolveParentSpan,
+        activeToolSpans,
+        subAgentSpans,
+        endedSubAgentSpans
+      );
+      const modifiedArgArray = [
+        {
+          ...params,
+          ...promptForQuery !== void 0 ? { prompt: promptForQuery } : {},
+          options: optionsWithHooks
+        }
+      ];
       const originalGenerator = withCurrent(
         span,
-        () => Reflect.apply(target, invocationTarget, argArray)
+        () => Reflect.apply(target, invocationTarget, modifiedArgArray)
       );
       const wrappedGenerator = (async function* () {
         try {
           for await (const message of originalGenerator) {
             const currentTime = getCurrentUnixTimestamp();
-            const messageId = _optionalChain([message, 'access', _273 => _273.message, 'optionalAccess', _274 => _274.id]);
+            if (message.type === "assistant" && Array.isArray(_optionalChain([message, 'access', _276 => _276.message, 'optionalAccess', _277 => _277.content]))) {
+              const parentToolUseId = _nullishCoalesce(message.parent_tool_use_id, () => ( null));
+              for (const block of message.message.content) {
+                if (block.type === "tool_use" && block.id) {
+                  toolUseToParent.set(block.id, parentToolUseId);
+                  if (block.name === "Task" && _optionalChain([block, 'access', _278 => _278.input, 'optionalAccess', _279 => _279.subagent_type])) {
+                    pendingSubAgentNames.set(
+                      block.id,
+                      block.input.subagent_type
+                    );
+                  }
+                }
+              }
+            }
+            if ("parent_tool_use_id" in message) {
+              const parentToolUseId = message.parent_tool_use_id;
+              if (parentToolUseId && !subAgentSpans.has(parentToolUseId)) {
+                const agentName = pendingSubAgentNames.get(parentToolUseId);
+                const spanName = agentName ? `Agent: ${agentName}` : "Agent: sub-agent";
+                const parentExport = await span.export();
+                const subAgentSpan = startSpan({
+                  name: spanName,
+                  spanAttributes: { type: "task" /* TASK */ },
+                  event: {
+                    metadata: {
+                      ...agentName && {
+                        "claude_agent_sdk.agent_type": agentName
+                      }
+                    }
+                  },
+                  parent: parentExport
+                });
+                subAgentSpans.set(parentToolUseId, subAgentSpan);
+              }
+            }
+            const messageId = _optionalChain([message, 'access', _280 => _280.message, 'optionalAccess', _281 => _281.id]);
             if (messageId && messageId !== currentMessageId) {
               await createLLMSpan();
               currentMessageId = messageId;
               currentMessageStartTime = currentTime;
             }
-            if (message.type === "assistant" && _optionalChain([message, 'access', _275 => _275.message, 'optionalAccess', _276 => _276.usage])) {
+            if (message.type === "assistant" && _optionalChain([message, 'access', _282 => _282.message, 'optionalAccess', _283 => _283.usage])) {
               currentMessages.push(message);
             }
             if (message.type === "result" && message.usage) {
               finalUsageMetrics = _extractUsageFromMessage(message);
               if (currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
                 const lastMessage = currentMessages[currentMessages.length - 1];
-                if (_optionalChain([lastMessage, 'optionalAccess', _277 => _277.message, 'optionalAccess', _278 => _278.usage])) {
+                if (_optionalChain([lastMessage, 'optionalAccess', _284 => _284.message, 'optionalAccess', _285 => _285.usage])) {
                   const adjustedTokens = finalUsageMetrics.completion_tokens - accumulatedOutputTokens;
                   if (adjustedTokens >= 0) {
                     lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -12278,6 +13055,22 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
           });
           throw error;
         } finally {
+          for (const [id, subSpan] of subAgentSpans) {
+            if (!endedSubAgentSpans.has(id)) {
+              subSpan.end();
+            }
+          }
+          subAgentSpans.clear();
+          if (capturedPromptMessages) {
+            if (promptStarted) {
+              await promptDone;
+            }
+            if (capturedPromptMessages.length > 0) {
+              span.log({
+                input: _formatCapturedMessages(capturedPromptMessages)
+              });
+            }
+          }
           span.end();
         }
       })();
@@ -12305,48 +13098,30 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
   });
   return proxy;
 }
-function wrapClaudeAgentTool(toolDef) {
-  const originalHandler = toolDef.handler;
-  const wrappedHandler = (args, extra) => traced(
-    async (span) => {
-      span.log({
-        input: args,
-        metadata: {
-          tool_name: toolDef.name,
-          tool_description: toolDef.description
-        }
-      });
-      const result = await originalHandler(args, extra);
-      span.log({
-        output: result
-      });
-      return result;
-    },
-    {
-      name: `${toolDef.name}`,
-      spanAttributes: {
-        type: "tool" /* TOOL */
+function _buildLLMInput(prompt, conversationHistory, capturedPromptMessages) {
+  const promptMessages = [];
+  if (typeof prompt === "string") {
+    promptMessages.push({ content: prompt, role: "user" });
+  } else if (capturedPromptMessages && capturedPromptMessages.length > 0) {
+    for (const msg of capturedPromptMessages) {
+      const role = _optionalChain([msg, 'access', _286 => _286.message, 'optionalAccess', _287 => _287.role]);
+      const content = _optionalChain([msg, 'access', _288 => _288.message, 'optionalAccess', _289 => _289.content]);
+      if (role && content !== void 0) {
+        promptMessages.push({ content, role });
       }
     }
-  );
-  return {
-    ...toolDef,
-    handler: wrappedHandler
-  };
-}
-function _buildLLMInput(prompt, conversationHistory) {
-  const promptMessage = typeof prompt === "string" ? { content: prompt, role: "user" } : void 0;
-  const inputParts = [
-    ...promptMessage ? [promptMessage] : [],
-    ...conversationHistory
-  ];
+  }
+  const inputParts = [...promptMessages, ...conversationHistory];
   return inputParts.length > 0 ? inputParts : void 0;
 }
+function _formatCapturedMessages(messages) {
+  return messages.length > 0 ? messages : [];
+}
 function _extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _279 => _279.message, 'optionalAccess', _280 => _280.usage]);
+    usage = _optionalChain([message, 'access', _290 => _290.message, 'optionalAccess', _291 => _291.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -12375,17 +13150,21 @@ function _extractUsageFromMessage(message) {
   }
   return metrics;
 }
-async function _createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
+async function _createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, capturedPromptMessages, parentSpan) {
   if (messages.length === 0) return void 0;
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _281 => _281.message, 'optionalAccess', _282 => _282.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _292 => _292.message, 'optionalAccess', _293 => _293.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
   const usage = _extractUsageFromMessage(lastMessage);
-  const input = _buildLLMInput(prompt, conversationHistory);
+  const input = _buildLLMInput(
+    prompt,
+    conversationHistory,
+    capturedPromptMessages
+  );
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _283 => _283.message, 'optionalAccess', _284 => _284.content]) && _optionalChain([m, 'access', _285 => _285.message, 'optionalAccess', _286 => _286.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _294 => _294.message, 'optionalAccess', _295 => _295.content]) && _optionalChain([m, 'access', _296 => _296.message, 'optionalAccess', _297 => _297.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter((c) => c !== void 0);
   await traced(
     (llmSpan) => {
@@ -12405,7 +13184,7 @@ async function _createLLMSpanForMessages(messages, prompt, conversationHistory,
       parent: parentSpan
     }
   );
-  return _optionalChain([lastMessage, 'access', _287 => _287.message, 'optionalAccess', _288 => _288.content]) && _optionalChain([lastMessage, 'access', _289 => _289.message, 'optionalAccess', _290 => _290.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _298 => _298.message, 'optionalAccess', _299 => _299.content]) && _optionalChain([lastMessage, 'access', _300 => _300.message, 'optionalAccess', _301 => _301.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 function wrapClaudeAgentSDK(sdk) {
   const cache = /* @__PURE__ */ new Map();
@@ -12424,25 +13203,9 @@ function wrapClaudeAgentSDK(sdk) {
         return wrappedQuery;
       }
       if (prop === "tool" && typeof value === "function") {
-        const toolFn = value;
-        const wrappedToolFactory = new Proxy(toolFn, {
-          apply(toolTarget, thisArg, argArray) {
-            const invocationTarget = thisArg === receiver || thisArg === void 0 ? target : thisArg;
-            const toolDef = Reflect.apply(
-              toolTarget,
-              invocationTarget,
-              argArray
-            );
-            if (toolDef && typeof toolDef === "object" && "handler" in toolDef) {
-              return wrapClaudeAgentTool(
-                toolDef
-              );
-            }
-            return toolDef;
-          }
-        });
-        cache.set(prop, wrappedToolFactory);
-        return wrappedToolFactory;
+        const bound = value.bind(target);
+        cache.set(prop, bound);
+        return bound;
       }
       if (typeof value === "function") {
         const bound = value.bind(target);
@@ -12695,7 +13458,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _291 => _291.config, 'optionalAccess', _292 => _292.tools])) {
+  if (!_optionalChain([params, 'access', _302 => _302.config, 'optionalAccess', _303 => _303.tools])) {
     return null;
   }
   try {
@@ -12778,7 +13541,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _293 => _293.content, 'optionalAccess', _294 => _294.parts])) {
+        if (_optionalChain([candidate, 'access', _304 => _304.content, 'optionalAccess', _305 => _305.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -12809,7 +13572,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _295 => _295.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _306 => _306.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -12889,15 +13652,15 @@ __export(graph_framework_exports, {
   escapePath: () => escapePath,
   unescapePath: () => unescapePath
 });
-var GraphBuilder = (_class15 = class {
-  __init58() {this.nodes = /* @__PURE__ */ new Map()}
-  __init59() {this.edges = {}}
-  __init60() {this.nodeLikeNodes = /* @__PURE__ */ new Map()}
+var GraphBuilder = (_class16 = class {
+  __init60() {this.nodes = /* @__PURE__ */ new Map()}
+  __init61() {this.edges = {}}
+  __init62() {this.nodeLikeNodes = /* @__PURE__ */ new Map()}
   // Maps node-like objects, like prompts, to their nodes
   // Special nodes
   
   
-  constructor() {;_class15.prototype.__init58.call(this);_class15.prototype.__init59.call(this);_class15.prototype.__init60.call(this);
+  constructor() {;_class16.prototype.__init60.call(this);_class16.prototype.__init61.call(this);_class16.prototype.__init62.call(this);
     this.IN = this.createInputNode();
     this.OUT = this.createOutputNode();
   }
@@ -13027,7 +13790,7 @@ var GraphBuilder = (_class15 = class {
     this.nodes.set(id, promptNode);
     return promptNode;
   }
-}, _class15);
+}, _class16);
 function isProxyVariable(node) {
   return typeof node === "object" && node !== null && "__type" in node && // @ts-ignore
   node.__type === "proxy-variable";
@@ -13035,17 +13798,17 @@ function isProxyVariable(node) {
 function proxyVariableToNode(proxy) {
   return [proxy.__node, proxy.__path];
 }
-var BaseNode = (_class16 = class {
-  constructor(graph, id) {;_class16.prototype.__init61.call(this);_class16.prototype.__init62.call(this);
+var BaseNode = (_class17 = class {
+  constructor(graph, id) {;_class17.prototype.__init63.call(this);_class17.prototype.__init64.call(this);
     this.graph = graph;
     this.id = id;
   }
-  __init61() {this.__type = "node"}
-  __init62() {this.dependencies = []}
+  __init63() {this.__type = "node"}
+  __init64() {this.dependencies = []}
   addDependency(dependency) {
     this.dependencies.push(dependency);
   }
-}, _class16);
+}, _class17);
 var InputNode = class extends BaseNode {
   constructor(graph, id) {
     super(graph, id);
@@ -13227,7 +13990,7 @@ function isAsync(fn) {
 function isAsyncGenerator2(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable(obj) {
+function isAsyncIterable2(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -13398,7 +14161,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator2(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable(obj)) {
+    if (isAsyncIterable2(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -14247,11 +15010,11 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
     return this._state;
   }
 };
-var CachedSpanFetcher = (_class17 = class {
-  __init63() {this.spanCache = /* @__PURE__ */ new Map()}
-  __init64() {this.allFetched = false}
+var CachedSpanFetcher = (_class18 = class {
+  __init65() {this.spanCache = /* @__PURE__ */ new Map()}
+  __init66() {this.allFetched = false}
   
-  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class17.prototype.__init63.call(this);_class17.prototype.__init64.call(this);
+  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class18.prototype.__init65.call(this);_class18.prototype.__init66.call(this);
     if (typeof objectTypeOrFetchFn === "function") {
       this.fetchFn = objectTypeOrFetchFn;
     } else {
@@ -14266,7 +15029,7 @@ var CachedSpanFetcher = (_class17 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _296 => _296.span_attributes, 'optionalAccess', _297 => _297.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _307 => _307.span_attributes, 'optionalAccess', _308 => _308.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -14300,7 +15063,7 @@ var CachedSpanFetcher = (_class17 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _298 => _298.span_attributes, 'optionalAccess', _299 => _299.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _309 => _309.span_attributes, 'optionalAccess', _310 => _310.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -14317,23 +15080,24 @@ var CachedSpanFetcher = (_class17 = class {
     }
     return result;
   }
-}, _class17);
-var LocalTrace = (_class18 = class {
+}, _class18);
+var LocalTrace = (_class19 = class {
   
   
   
   
   
-  __init65() {this.spansFlushed = false}
-  __init66() {this.spansFlushPromise = null}
+  __init67() {this.spansFlushed = false}
+  __init68() {this.spansFlushPromise = null}
   
+  __init69() {this.threadCache = /* @__PURE__ */ new Map()}
   constructor({
     objectType,
     objectId,
     rootSpanId,
     ensureSpansFlushed,
     state
-  }) {;_class18.prototype.__init65.call(this);_class18.prototype.__init66.call(this);
+  }) {;_class19.prototype.__init67.call(this);_class19.prototype.__init68.call(this);_class19.prototype.__init69.call(this);
     this.objectType = objectType;
     this.objectId = objectId;
     this.rootSpanId = rootSpanId;
@@ -14379,11 +15143,11 @@ var LocalTrace = (_class18 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _300 => _300.span_attributes, 'optionalAccess', _301 => _301.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _311 => _311.span_attributes, 'optionalAccess', _312 => _312.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _302 => _302.span_attributes, 'optionalAccess', _303 => _303.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _313 => _313.span_attributes, 'optionalAccess', _314 => _314.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -14397,6 +15161,36 @@ var LocalTrace = (_class18 = class {
     }
     return this.cachedFetcher.getSpans({ spanType });
   }
+  /**
+   * Get the thread (preprocessed messages) for this trace.
+   * Calls the API with the project_default preprocessor (which falls back to "thread").
+   */
+  async getThread(options) {
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _315 => _315.preprocessor]), () => ( "project_default"));
+    if (!this.threadCache.has(cacheKey)) {
+      const promise = this.fetchThread(options);
+      this.threadCache.set(cacheKey, promise);
+    }
+    return this.threadCache.get(cacheKey);
+  }
+  async fetchThread(options) {
+    await this.ensureSpansReady();
+    await this.state.login({});
+    const result = await invoke({
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _316 => _316.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;
@@ -14414,7 +15208,7 @@ var LocalTrace = (_class18 = class {
     }
     await this.spansFlushPromise;
   }
-}, _class18);
+}, _class19);
 
 // src/reporters/progress.ts
 var SimpleProgressReporter = class {
@@ -14431,248 +15225,10 @@ var SimpleProgressReporter = class {
 
 // src/eval-parameters.ts
 
+var _ajv = require('ajv'); var _ajv2 = _interopRequireDefault(_ajv);
 
-// src/framework2.ts
+// src/prompt-schemas.ts
 
-var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
-var ProjectBuilder = class {
-  create(opts) {
-    return new Project2(opts);
-  }
-};
-var projects = new ProjectBuilder();
-var Project2 = (_class19 = class {
-  
-  
-  
-  
-  
-  __init67() {this._publishableCodeFunctions = []}
-  __init68() {this._publishablePrompts = []}
-  constructor(args) {;_class19.prototype.__init67.call(this);_class19.prototype.__init68.call(this);
-    _initializeSpanContext();
-    this.name = "name" in args ? args.name : void 0;
-    this.id = "id" in args ? args.id : void 0;
-    this.tools = new ToolBuilder(this);
-    this.prompts = new PromptBuilder(this);
-    this.scorers = new ScorerBuilder(this);
-  }
-  addPrompt(prompt) {
-    this._publishablePrompts.push(prompt);
-    if (globalThis._lazy_load) {
-      globalThis._evals.prompts.push(prompt);
-    }
-  }
-  addCodeFunction(fn) {
-    this._publishableCodeFunctions.push(fn);
-    if (globalThis._lazy_load) {
-      globalThis._evals.functions.push(fn);
-    }
-  }
-  async publish() {
-    if (globalThis._lazy_load) {
-      console.warn("publish() is a no-op when running `braintrust push`.");
-      return;
-    }
-    await login();
-    const projectMap = new ProjectNameIdMap();
-    const functionDefinitions = [];
-    if (this._publishableCodeFunctions.length > 0) {
-      console.warn(
-        "Code functions cannot be published directly. Use `braintrust push` instead."
-      );
-    }
-    if (this._publishablePrompts.length > 0) {
-      for (const prompt of this._publishablePrompts) {
-        const functionDefinition = await prompt.toFunctionDefinition(projectMap);
-        functionDefinitions.push(functionDefinition);
-      }
-    }
-    await _internalGetGlobalState().apiConn().post_json("insert-functions", {
-      functions: functionDefinitions
-    });
-  }
-}, _class19);
-var ToolBuilder = (_class20 = class {
-  constructor(project) {;_class20.prototype.__init69.call(this);
-    this.project = project;
-  }
-  __init69() {this.taskCounter = 0}
-  // This type definition is just a catch all so that the implementation can be
-  // less specific than the two more specific declarations above.
-  create(opts) {
-    this.taskCounter++;
-    opts = _nullishCoalesce(opts, () => ( {}));
-    const { handler, name, slug, parameters, returns, ...rest } = opts;
-    let resolvedName = _nullishCoalesce(name, () => ( handler.name));
-    if (resolvedName.trim().length === 0) {
-      resolvedName = `Tool ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
-    }
-    const tool = new CodeFunction(this.project, {
-      handler,
-      name: resolvedName,
-      slug: _nullishCoalesce(slug, () => ( slugify(resolvedName, { lower: true, strict: true }))),
-      type: "tool",
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
-      parameters,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
-      returns,
-      ...rest
-    });
-    this.project.addCodeFunction(tool);
-    return tool;
-  }
-}, _class20);
-var ScorerBuilder = (_class21 = class {
-  constructor(project) {;_class21.prototype.__init70.call(this);
-    this.project = project;
-  }
-  __init70() {this.taskCounter = 0}
-  create(opts) {
-    this.taskCounter++;
-    let resolvedName = opts.name;
-    if (!resolvedName && "handler" in opts) {
-      resolvedName = opts.handler.name;
-    }
-    if (!resolvedName || resolvedName.trim().length === 0) {
-      resolvedName = `Scorer ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
-    }
-    const slug = _nullishCoalesce(opts.slug, () => ( slugify(resolvedName, { lower: true, strict: true })));
-    if ("handler" in opts) {
-      const scorer = new CodeFunction(this.project, {
-        ...opts,
-        name: resolvedName,
-        slug,
-        type: "scorer"
-      });
-      this.project.addCodeFunction(scorer);
-    } else {
-      const promptBlock = "messages" in opts ? {
-        type: "chat",
-        messages: opts.messages
-      } : {
-        type: "completion",
-        content: opts.prompt
-      };
-      const promptData = {
-        prompt: promptBlock,
-        options: {
-          model: opts.model,
-          params: opts.params
-        },
-        parser: {
-          type: "llm_classifier",
-          use_cot: opts.useCot,
-          choice_scores: opts.choiceScores
-        }
-      };
-      const codePrompt = new CodePrompt(
-        this.project,
-        promptData,
-        [],
-        {
-          ...opts,
-          name: resolvedName,
-          slug
-        },
-        "scorer"
-      );
-      this.project.addPrompt(codePrompt);
-    }
-  }
-}, _class21);
-var CodeFunction = class {
-  constructor(project, opts) {
-    this.project = project;
-    this.handler = opts.handler;
-    this.name = opts.name;
-    this.slug = opts.slug;
-    this.description = opts.description;
-    this.type = opts.type;
-    this.ifExists = opts.ifExists;
-    this.metadata = opts.metadata;
-    this.parameters = opts.parameters;
-    this.returns = opts.returns;
-    if (this.returns && !this.parameters) {
-      throw new Error("parameters are required if return type is defined");
-    }
-  }
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  key() {
-    return JSON.stringify([
-      _nullishCoalesce(this.project.id, () => ( "")),
-      _nullishCoalesce(this.project.name, () => ( "")),
-      this.slug
-    ]);
-  }
-};
-var CodePrompt = class {
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  constructor(project, prompt, toolFunctions, opts, functionType) {
-    this.project = project;
-    this.name = opts.name;
-    this.slug = opts.slug;
-    this.prompt = prompt;
-    this.toolFunctions = toolFunctions;
-    this.ifExists = opts.ifExists;
-    this.description = opts.description;
-    this.id = opts.id;
-    this.functionType = functionType;
-    this.metadata = opts.metadata;
-  }
-  async toFunctionDefinition(projectNameToId) {
-    const prompt_data = {
-      ...this.prompt
-    };
-    if (this.toolFunctions.length > 0) {
-      const resolvableToolFunctions = await Promise.all(
-        this.toolFunctions.map(async (fn) => {
-          if ("slug" in fn) {
-            return {
-              type: "slug",
-              project_id: await projectNameToId.resolve(fn.project),
-              slug: fn.slug
-            };
-          } else {
-            return fn;
-          }
-        })
-      );
-      prompt_data.tool_functions = // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      resolvableToolFunctions;
-    }
-    return {
-      project_id: await projectNameToId.resolve(this.project),
-      name: this.name,
-      slug: this.slug,
-      description: _nullishCoalesce(this.description, () => ( "")),
-      function_data: {
-        type: "prompt"
-      },
-      function_type: this.functionType,
-      prompt_data,
-      if_exists: this.ifExists,
-      metadata: this.metadata
-    };
-  }
-};
 var promptContentsSchema = _v3.z.union([
   _v3.z.object({
     prompt: _v3.z.string()
@@ -14693,46 +15249,6 @@ var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
     tools: _v3.z.array(ToolFunctionDefinition).optional()
   })
 );
-var PromptBuilder = class {
-  constructor(project) {
-    this.project = project;
-  }
-  create(opts) {
-    const toolFunctions = [];
-    const rawTools = [];
-    for (const tool of _nullishCoalesce(opts.tools, () => ( []))) {
-      if (tool instanceof CodeFunction) {
-        toolFunctions.push(tool);
-      } else if ("type" in tool && !("function" in tool)) {
-        toolFunctions.push(tool);
-      } else {
-        rawTools.push(tool);
-      }
-    }
-    const slug = _nullishCoalesce(opts.slug, () => ( slugify(opts.name, { lower: true, strict: true })));
-    const promptData = promptDefinitionToPromptData(opts, rawTools);
-    const promptRow = {
-      id: opts.id,
-      _xact_id: opts.version ? loadPrettyXact(opts.version) : void 0,
-      name: opts.name,
-      slug,
-      prompt_data: promptData,
-      ...this.project.id !== void 0 ? { project_id: this.project.id } : {}
-    };
-    const prompt = new Prompt2(
-      promptRow,
-      {},
-      // It doesn't make sense to specify defaults here.
-      _nullishCoalesce(opts.noTrace, () => ( false))
-    );
-    const codePrompt = new CodePrompt(this.project, promptData, toolFunctions, {
-      ...opts,
-      slug
-    });
-    this.project.addPrompt(codePrompt);
-    return prompt;
-  }
-};
 function promptDefinitionToPromptData(promptDefinition, rawTools) {
   const promptBlock = "messages" in promptDefinition ? {
     type: "chat",
@@ -14751,42 +15267,6 @@ function promptDefinitionToPromptData(promptDefinition, rawTools) {
     ...promptDefinition.templateFormat ? { template_format: promptDefinition.templateFormat } : {}
   };
 }
-var ProjectNameIdMap = (_class22 = class {constructor() { _class22.prototype.__init71.call(this);_class22.prototype.__init72.call(this); }
-  __init71() {this.nameToId = {}}
-  __init72() {this.idToName = {}}
-  async getId(projectName) {
-    if (!(projectName in this.nameToId)) {
-      const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
-        project_name: projectName
-      });
-      const result = _v3.z.object({
-        project: Project
-      }).parse(response);
-      const projectId = result.project.id;
-      this.nameToId[projectName] = projectId;
-      this.idToName[projectId] = projectName;
-    }
-    return this.nameToId[projectName];
-  }
-  async getName(projectId) {
-    if (!(projectId in this.idToName)) {
-      const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
-        id: projectId
-      });
-      const result = _v3.z.array(Project).nonempty().parse(response);
-      const projectName = result[0].name;
-      this.idToName[projectId] = projectName;
-      this.nameToId[projectName] = projectId;
-    }
-    return this.idToName[projectId];
-  }
-  async resolve(project) {
-    if (project.id) {
-      return project.id;
-    }
-    return this.getId(project.name);
-  }
-}, _class22);
 
 // src/eval-parameters.ts
 var evalParametersSchema = _v3.z.record(
@@ -14801,7 +15281,31 @@ var evalParametersSchema = _v3.z.record(
     // For Zod schemas
   ])
 );
-function validateParameters(parameters, parameterSchema) {
+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
+    );
+  }
+  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];
@@ -14828,6 +15332,18 @@ function validateParameters(parameters, parameterSchema) {
     })
   );
 }
+function validateParametersWithJsonSchema(parameters, schema) {
+  const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
+  const validate = ajv.compile(schema);
+  if (!validate(parameters)) {
+    const errorMessages = _optionalChain([validate, 'access', _317 => _317.errors, 'optionalAccess', _318 => _318.map, 'call', _319 => _319((err) => {
+      const path = err.instancePath || "root";
+      return `${path}: ${err.message}`;
+    }), 'access', _320 => _320.join, 'call', _321 => _321(", ")]);
+    throw Error(`Invalid parameters: ${errorMessages}`);
+  }
+  return parameters;
+}
 
 // src/framework.ts
 function BaseExperiment(options = {}) {
@@ -14879,7 +15395,7 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable2(value) {
+function isAsyncIterable3(value) {
   return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
@@ -14888,6 +15404,7 @@ function isIterable(value) {
 globalThis._evals = {
   functions: [],
   prompts: [],
+  parameters: [],
   evaluators: {},
   reporters: {}
 };
@@ -15063,16 +15580,16 @@ var defaultErrorScoreHandler = ({
 };
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _304 => _304.spanCache, 'optionalAccess', _305 => _305.start, 'call', _306 => _306()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _322 => _322.spanCache, 'optionalAccess', _323 => _323.start, 'call', _324 => _324()]);
   }
   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 = await validateParameters(
       _nullishCoalesce(parameters, () => ( {})),
-      _nullishCoalesce(evaluator.parameters, () => ( {}))
+      evaluator.parameters
     );
     if ("_type" in dataResult) {
       if (dataResult._type !== "BaseExperiment") {
@@ -15099,7 +15616,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     }
     const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
     const dataIterable = (() => {
-      if (isAsyncIterable2(resolvedDataResult)) {
+      if (isAsyncIterable3(resolvedDataResult)) {
         return resolvedDataResult;
       }
       if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
@@ -15174,7 +15691,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _307 => _307.data, 'access', async _308 => _308.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _325 => _325.data, 'access', async _326 => _326.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -15200,10 +15717,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _309 => _309({
+                    _optionalChain([stream, 'optionalCall', _327 => _327({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _310 => _310.event, 'optionalAccess', _311 => _311.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _328 => _328.event, 'optionalAccess', _329 => _329.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -15231,6 +15748,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,
@@ -15364,7 +15884,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _312 => _312.event, 'optionalAccess', _313 => _313.origin])
+              origin: _optionalChain([baseEvent, 'access', _330 => _330.event, 'optionalAccess', _331 => _331.origin])
             });
           }
         };
@@ -15397,7 +15917,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _314 => _314.setTotal, 'optionalCall', _315 => _315(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _332 => _332.setTotal, 'optionalCall', _333 => _333(evaluator.evalName, scheduledTrials)]);
           q.push({ datum, trialIndex });
         }
       }
@@ -15472,9 +15992,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _316 => _316.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _317 => _317.dispose, 'call', _318 => _318()]);
-      _optionalChain([spanCache, 'optionalAccess', _319 => _319.stop, 'call', _320 => _320()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _334 => _334.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _335 => _335.dispose, 'call', _336 => _336()]);
+      _optionalChain([spanCache, 'optionalAccess', _337 => _337.stop, 'call', _338 => _338()]);
     }
   }
 }
@@ -15638,6 +16158,417 @@ var defaultReporter = {
   }
 };
 
+// src/framework2.ts
+
+var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
+var ProjectBuilder = class {
+  create(opts) {
+    return new Project2(opts);
+  }
+};
+var projects = new ProjectBuilder();
+var Project2 = (_class20 = class {
+  
+  
+  
+  
+  
+  
+  __init70() {this._publishableCodeFunctions = []}
+  __init71() {this._publishablePrompts = []}
+  __init72() {this._publishableParameters = []}
+  constructor(args) {;_class20.prototype.__init70.call(this);_class20.prototype.__init71.call(this);_class20.prototype.__init72.call(this);
+    _initializeSpanContext();
+    this.name = "name" in args ? args.name : void 0;
+    this.id = "id" in args ? args.id : void 0;
+    this.tools = new ToolBuilder(this);
+    this.prompts = new PromptBuilder(this);
+    this.parameters = new ParametersBuilder(this);
+    this.scorers = new ScorerBuilder(this);
+  }
+  addPrompt(prompt) {
+    this._publishablePrompts.push(prompt);
+    if (globalThis._lazy_load) {
+      globalThis._evals.prompts.push(prompt);
+    }
+  }
+  addParameters(parameters) {
+    this._publishableParameters.push(parameters);
+    if (globalThis._lazy_load) {
+      if (globalThis._evals.parameters == null)
+        globalThis._evals.parameters = [];
+      globalThis._evals.parameters.push(parameters);
+    }
+  }
+  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
+    });
+  }
+}, _class20);
+var ToolBuilder = (_class21 = class {
+  constructor(project) {;_class21.prototype.__init73.call(this);
+    this.project = project;
+  }
+  __init73() {this.taskCounter = 0}
+  // This type definition is just a catch all so that the implementation can be
+  // less specific than the two more specific declarations above.
+  create(opts) {
+    this.taskCounter++;
+    opts = _nullishCoalesce(opts, () => ( {}));
+    const { handler, name, slug, parameters, returns, ...rest } = opts;
+    let resolvedName = _nullishCoalesce(name, () => ( handler.name));
+    if (resolvedName.trim().length === 0) {
+      resolvedName = `Tool ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+    }
+    const tool = new CodeFunction(this.project, {
+      handler,
+      name: resolvedName,
+      slug: _nullishCoalesce(slug, () => ( slugify(resolvedName, { lower: true, strict: true }))),
+      type: "tool",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
+      parameters,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
+      returns,
+      ...rest
+    });
+    this.project.addCodeFunction(tool);
+    return tool;
+  }
+}, _class21);
+var ScorerBuilder = (_class22 = class {
+  constructor(project) {;_class22.prototype.__init74.call(this);
+    this.project = project;
+  }
+  __init74() {this.taskCounter = 0}
+  create(opts) {
+    this.taskCounter++;
+    let resolvedName = opts.name;
+    if (!resolvedName && "handler" in opts) {
+      resolvedName = opts.handler.name;
+    }
+    if (!resolvedName || resolvedName.trim().length === 0) {
+      resolvedName = `Scorer ${isomorph_default.basename(currentFilename)} ${this.taskCounter}`;
+    }
+    const slug = _nullishCoalesce(opts.slug, () => ( slugify(resolvedName, { lower: true, strict: true })));
+    if ("handler" in opts) {
+      const scorer = new CodeFunction(this.project, {
+        ...opts,
+        name: resolvedName,
+        slug,
+        type: "scorer"
+      });
+      this.project.addCodeFunction(scorer);
+    } else {
+      const promptBlock = "messages" in opts ? {
+        type: "chat",
+        messages: opts.messages
+      } : {
+        type: "completion",
+        content: opts.prompt
+      };
+      const promptData = {
+        prompt: promptBlock,
+        options: {
+          model: opts.model,
+          params: opts.params
+        },
+        parser: {
+          type: "llm_classifier",
+          use_cot: opts.useCot,
+          choice_scores: opts.choiceScores
+        }
+      };
+      const codePrompt = new CodePrompt(
+        this.project,
+        promptData,
+        [],
+        {
+          ...opts,
+          name: resolvedName,
+          slug
+        },
+        "scorer"
+      );
+      this.project.addPrompt(codePrompt);
+    }
+  }
+}, _class22);
+var CodeFunction = class {
+  constructor(project, opts) {
+    this.project = project;
+    this.handler = opts.handler;
+    this.name = opts.name;
+    this.slug = opts.slug;
+    this.description = opts.description;
+    this.type = opts.type;
+    this.ifExists = opts.ifExists;
+    this.metadata = opts.metadata;
+    this.parameters = opts.parameters;
+    this.returns = opts.returns;
+    if (this.returns && !this.parameters) {
+      throw new Error("parameters are required if return type is defined");
+    }
+  }
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  key() {
+    return JSON.stringify([
+      _nullishCoalesce(this.project.id, () => ( "")),
+      _nullishCoalesce(this.project.name, () => ( "")),
+      this.slug
+    ]);
+  }
+};
+var CodePrompt = class {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  constructor(project, prompt, toolFunctions, opts, functionType) {
+    this.project = project;
+    this.name = opts.name;
+    this.slug = opts.slug;
+    this.prompt = prompt;
+    this.toolFunctions = toolFunctions;
+    this.ifExists = opts.ifExists;
+    this.description = opts.description;
+    this.id = opts.id;
+    this.functionType = functionType;
+    this.metadata = opts.metadata;
+  }
+  async toFunctionDefinition(projectNameToId) {
+    const prompt_data = {
+      ...this.prompt
+    };
+    if (this.toolFunctions.length > 0) {
+      const resolvableToolFunctions = await Promise.all(
+        this.toolFunctions.map(async (fn) => {
+          if ("slug" in fn) {
+            return {
+              type: "slug",
+              project_id: await projectNameToId.resolve(fn.project),
+              slug: fn.slug
+            };
+          } else {
+            return fn;
+          }
+        })
+      );
+      prompt_data.tool_functions = // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      resolvableToolFunctions;
+    }
+    return {
+      project_id: await projectNameToId.resolve(this.project),
+      name: this.name,
+      slug: this.slug,
+      description: _nullishCoalesce(this.description, () => ( "")),
+      function_data: {
+        type: "prompt"
+      },
+      function_type: this.functionType,
+      prompt_data,
+      if_exists: this.ifExists,
+      metadata: this.metadata
+    };
+  }
+};
+var PromptBuilder = class {
+  constructor(project) {
+    this.project = project;
+  }
+  create(opts) {
+    const toolFunctions = [];
+    const rawTools = [];
+    for (const tool of _nullishCoalesce(opts.tools, () => ( []))) {
+      if (tool instanceof CodeFunction) {
+        toolFunctions.push(tool);
+      } else if ("type" in tool && !("function" in tool)) {
+        toolFunctions.push(tool);
+      } else {
+        rawTools.push(tool);
+      }
+    }
+    const slug = _nullishCoalesce(opts.slug, () => ( slugify(opts.name, { lower: true, strict: true })));
+    const promptData = promptDefinitionToPromptData(opts, rawTools);
+    const promptRow = {
+      id: opts.id,
+      _xact_id: opts.version ? loadPrettyXact(opts.version) : void 0,
+      name: opts.name,
+      slug,
+      prompt_data: promptData,
+      ...this.project.id !== void 0 ? { project_id: this.project.id } : {}
+    };
+    const prompt = new Prompt2(
+      promptRow,
+      {},
+      // It doesn't make sense to specify defaults here.
+      _nullishCoalesce(opts.noTrace, () => ( false))
+    );
+    const codePrompt = new CodePrompt(this.project, promptData, toolFunctions, {
+      ...opts,
+      slug
+    });
+    this.project.addPrompt(codePrompt);
+    return prompt;
+  }
+};
+var CodeParameters = class {
+  
+  
+  
+  
+  
+  
+  
+  constructor(project, opts) {
+    this.project = project;
+    this.name = opts.name;
+    this.slug = opts.slug;
+    this.description = opts.description;
+    this.schema = opts.schema;
+    this.ifExists = opts.ifExists;
+    this.metadata = opts.metadata;
+  }
+  async toFunctionDefinition(projectNameToId) {
+    return {
+      project_id: await projectNameToId.resolve(this.project),
+      name: this.name,
+      slug: this.slug,
+      description: _nullishCoalesce(this.description, () => ( "")),
+      function_type: "parameters",
+      function_data: {
+        type: "parameters",
+        data: {},
+        __schema: serializeEvalParameterstoParametersSchema(this.schema)
+      },
+      if_exists: this.ifExists,
+      metadata: this.metadata
+    };
+  }
+};
+var ParametersBuilder = class {
+  constructor(project) {
+    this.project = project;
+  }
+  create(opts) {
+    const slug = _nullishCoalesce(opts.slug, () => ( slugify(opts.name, { lower: true, strict: true })));
+    const codeParameters = new CodeParameters(this.project, {
+      name: opts.name,
+      slug,
+      description: opts.description,
+      schema: opts.schema,
+      ifExists: opts.ifExists,
+      metadata: opts.metadata
+    });
+    this.project.addParameters(codeParameters);
+    return opts.schema;
+  }
+};
+function 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 {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    additionalProperties: true
+  };
+}
+var ProjectNameIdMap = (_class23 = class {constructor() { _class23.prototype.__init75.call(this);_class23.prototype.__init76.call(this); }
+  __init75() {this.nameToId = {}}
+  __init76() {this.idToName = {}}
+  async getId(projectName) {
+    if (!(projectName in this.nameToId)) {
+      const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
+        project_name: projectName
+      });
+      const result = _v3.z.object({
+        project: Project
+      }).parse(response);
+      const projectId = result.project.id;
+      this.nameToId[projectName] = projectId;
+      this.idToName[projectId] = projectName;
+    }
+    return this.nameToId[projectName];
+  }
+  async getName(projectId) {
+    if (!(projectId in this.idToName)) {
+      const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
+        id: projectId
+      });
+      const result = _v3.z.array(Project).nonempty().parse(response);
+      const projectName = result[0].name;
+      this.idToName[projectId] = projectName;
+      this.nameToId[projectName] = projectId;
+    }
+    return this.idToName[projectId];
+  }
+  async resolve(project) {
+    if (project.id) {
+      return project.id;
+    }
+    return this.getId(project.name);
+  }
+}, _class23);
+
 // dev/types.ts
 
 var evalBodySchema = _v3.z.object({
@@ -15655,7 +16586,7 @@ var evalBodySchema = _v3.z.object({
   parent: InvokeParent.optional(),
   stream: _v3.z.boolean().optional()
 });
-var evalParametersSerializedSchema = _v3.z.record(
+var staticParametersSchema = _v3.z.record(
   _v3.z.string(),
   _v3.z.union([
     _v3.z.object({
@@ -15666,14 +16597,43 @@ var evalParametersSerializedSchema = _v3.z.record(
     _v3.z.object({
       type: _v3.z.literal("data"),
       schema: _v3.z.record(_v3.z.unknown()),
-      // JSON Schema
       default: _v3.z.unknown().optional(),
       description: _v3.z.string().optional()
     })
   ])
 );
+var parametersSchema = _v3.z.object({
+  type: _v3.z.literal("object"),
+  properties: _v3.z.record(_v3.z.string(), _v3.z.record(_v3.z.unknown())),
+  required: _v3.z.array(_v3.z.string()).optional(),
+  additionalProperties: _v3.z.boolean().optional()
+});
+var parametersSourceSchema = _v3.z.object({
+  parametersId: _v3.z.string().optional(),
+  slug: _v3.z.string(),
+  name: _v3.z.string(),
+  projectId: _v3.z.string().optional(),
+  version: _v3.z.string().optional()
+});
+var parametersContainerSchema = _v3.z.object({
+  type: _v3.z.literal("braintrust.parameters"),
+  schema: parametersSchema,
+  source: parametersSourceSchema
+});
+var staticParametersContainerSchema = _v3.z.object({
+  type: _v3.z.literal("braintrust.staticParameters"),
+  schema: staticParametersSchema,
+  source: _v3.z.null()
+});
+var serializedParametersContainerSchema = _v3.z.union([
+  parametersContainerSchema,
+  staticParametersContainerSchema,
+  // keeping this type here since old versions of the SDK will still pass the unwrapped schema and we need to handle this in the app
+  staticParametersSchema
+]);
 var evaluatorDefinitionSchema = _v3.z.object({
-  parameters: evalParametersSerializedSchema.optional()
+  parameters: serializedParametersContainerSchema.optional(),
+  scores: _v3.z.array(_v3.z.object({ name: _v3.z.string() })).optional()
 });
 var evaluatorDefinitionsSchema = _v3.z.record(
   _v3.z.string(),
@@ -15799,4 +16759,13 @@ configureBrowser();
 
 
 
-exports.Attachment = Attachment; exports.AttachmentReference = AttachmentReference; exports.BaseAttachment = BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BraintrustMiddleware = BraintrustMiddleware; exports.BraintrustState = BraintrustState; exports.BraintrustStream = BraintrustStream; exports.CachedSpanFetcher = CachedSpanFetcher; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; exports.ContextManager = ContextManager; exports.DEFAULT_FETCH_BATCH_SIZE = DEFAULT_FETCH_BATCH_SIZE; exports.Dataset = Dataset2; exports.ERR_PERMALINK = ERR_PERMALINK; exports.Eval = Eval; exports.EvalResultWithSummary = EvalResultWithSummary; exports.Experiment = Experiment2; exports.ExternalAttachment = ExternalAttachment; exports.FailedHTTPResponse = FailedHTTPResponse; exports.IDGenerator = IDGenerator; exports.JSONAttachment = JSONAttachment; exports.LEGACY_CACHED_HEADER = LEGACY_CACHED_HEADER; exports.LazyValue = LazyValue; exports.Logger = Logger; exports.LoginInvalidOrgError = LoginInvalidOrgError; exports.NOOP_SPAN = NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = NOOP_SPAN_PERMALINK; exports.NoopSpan = NoopSpan; exports.ObjectFetcher = ObjectFetcher; exports.Project = Project2; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = Prompt2; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = ReadonlyAttachment; exports.ReadonlyExperiment = ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanFetcher = SpanFetcher; exports.SpanImpl = SpanImpl; exports.TestBackgroundLogger = TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.UUIDGenerator = UUIDGenerator; exports.X_CACHED_HEADER = X_CACHED_HEADER; exports._exportsForTestingOnly = _exportsForTestingOnly; exports._internalGetGlobalState = _internalGetGlobalState; exports._internalSetInitialState = _internalSetInitialState; exports.braintrustStreamChunkSchema = braintrustStreamChunkSchema; exports.buildLocalSummary = buildLocalSummary; exports.createFinalValuePassThroughStream = createFinalValuePassThroughStream; exports.currentExperiment = currentExperiment; exports.currentLogger = currentLogger; exports.currentSpan = currentSpan; exports.deepCopyEvent = deepCopyEvent; exports.default = exports_exports; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.deserializePlainStringAsJSON = deserializePlainStringAsJSON; exports.devNullWritableStream = devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.flush = flush; exports.getContextManager = getContextManager; exports.getIdGenerator = getIdGenerator; exports.getPromptVersions = getPromptVersions; exports.getSpanParentObject = getSpanParentObject; exports.graph = graph_framework_exports; exports.init = init; exports.initDataset = initDataset; exports.initExperiment = initExperiment; exports.initFunction = initFunction; exports.initLogger = initLogger; exports.invoke = invoke; exports.isTemplateFormat = isTemplateFormat; exports.loadPrompt = loadPrompt; exports.log = log; exports.logError = logError; exports.login = login; exports.loginToState = loginToState; exports.newId = newId; exports.parseCachedHeader = parseCachedHeader; exports.parseTemplateFormat = parseTemplateFormat; exports.permalink = permalink; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.registerOtelFlush = registerOtelFlush; exports.renderMessage = renderMessage; exports.renderPromptParams = renderPromptParams; exports.renderTemplateContent = renderTemplateContent; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = setFetch; exports.setMaskingFunction = setMaskingFunction; exports.spanComponentsToObjectId = spanComponentsToObjectId; exports.startSpan = startSpan; exports.summarize = summarize; exports.toolFunctionDefinitionSchema = ToolFunctionDefinition; exports.traceable = traceable; exports.traced = traced; exports.updateSpan = updateSpan; exports.withCurrent = withCurrent; exports.withDataset = withDataset; exports.withExperiment = withExperiment; exports.withLogger = withLogger; exports.withParent = withParent; exports.wrapAISDK = wrapAISDK; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAgentClass = wrapAgentClass; exports.wrapAnthropic = wrapAnthropic; exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK; exports.wrapGoogleGenAI = wrapGoogleGenAI; exports.wrapMastraAgent = wrapMastraAgent; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapTraced = wrapTraced;
+
+
+
+
+
+
+
+
+
+exports.Attachment = Attachment; exports.AttachmentReference = AttachmentReference; exports.BaseAttachment = BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BraintrustMiddleware = BraintrustMiddleware; exports.BraintrustState = BraintrustState; exports.BraintrustStream = BraintrustStream; exports.CachedSpanFetcher = CachedSpanFetcher; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; exports.ContextManager = ContextManager; exports.DEFAULT_FETCH_BATCH_SIZE = DEFAULT_FETCH_BATCH_SIZE; exports.DEFAULT_MAX_REQUEST_SIZE = DEFAULT_MAX_REQUEST_SIZE; exports.Dataset = Dataset2; exports.ERR_PERMALINK = ERR_PERMALINK; exports.Eval = Eval; exports.EvalResultWithSummary = EvalResultWithSummary; exports.Experiment = Experiment2; exports.ExternalAttachment = ExternalAttachment; exports.FailedHTTPResponse = FailedHTTPResponse; exports.IDGenerator = IDGenerator; exports.JSONAttachment = JSONAttachment; exports.LEGACY_CACHED_HEADER = LEGACY_CACHED_HEADER; exports.LOGS3_OVERFLOW_REFERENCE_TYPE = LOGS3_OVERFLOW_REFERENCE_TYPE; exports.LazyValue = LazyValue; exports.Logger = Logger; exports.LoginInvalidOrgError = LoginInvalidOrgError; exports.NOOP_SPAN = NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = NOOP_SPAN_PERMALINK; exports.NoopSpan = NoopSpan; exports.ObjectFetcher = ObjectFetcher; exports.Project = Project2; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = Prompt2; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = ReadonlyAttachment; exports.ReadonlyExperiment = ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanFetcher = SpanFetcher; exports.SpanImpl = SpanImpl; exports.TestBackgroundLogger = TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.UUIDGenerator = UUIDGenerator; exports.X_CACHED_HEADER = X_CACHED_HEADER; exports._exportsForTestingOnly = _exportsForTestingOnly; exports._internalGetGlobalState = _internalGetGlobalState; exports._internalSetInitialState = _internalSetInitialState; exports.addAzureBlobHeaders = addAzureBlobHeaders; exports.braintrustStreamChunkSchema = braintrustStreamChunkSchema; exports.buildLocalSummary = buildLocalSummary; exports.constructLogs3OverflowRequest = constructLogs3OverflowRequest; exports.createFinalValuePassThroughStream = createFinalValuePassThroughStream; exports.currentExperiment = currentExperiment; exports.currentLogger = currentLogger; exports.currentSpan = currentSpan; exports.deepCopyEvent = deepCopyEvent; exports.default = exports_exports; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.deserializePlainStringAsJSON = deserializePlainStringAsJSON; exports.devNullWritableStream = devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.flush = flush; exports.getContextManager = getContextManager; exports.getIdGenerator = getIdGenerator; exports.getPromptVersions = getPromptVersions; exports.getSpanParentObject = getSpanParentObject; exports.graph = graph_framework_exports; exports.init = init; exports.initDataset = initDataset; exports.initExperiment = initExperiment; exports.initFunction = initFunction; exports.initLogger = initLogger; exports.invoke = invoke; exports.isTemplateFormat = isTemplateFormat; exports.loadParameters = loadParameters; exports.loadPrompt = loadPrompt; exports.log = log; exports.logError = logError; exports.login = login; exports.loginToState = loginToState; exports.logs3OverflowUploadSchema = logs3OverflowUploadSchema; exports.newId = newId; exports.parseCachedHeader = parseCachedHeader; exports.parseTemplateFormat = parseTemplateFormat; exports.permalink = permalink; exports.pickLogs3OverflowObjectIds = pickLogs3OverflowObjectIds; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.registerOtelFlush = registerOtelFlush; exports.renderMessage = renderMessage; exports.renderPromptParams = renderPromptParams; exports.renderTemplateContent = renderTemplateContent; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = setFetch; exports.setMaskingFunction = setMaskingFunction; exports.spanComponentsToObjectId = spanComponentsToObjectId; exports.startSpan = startSpan; exports.summarize = summarize; exports.toolFunctionDefinitionSchema = ToolFunctionDefinition; exports.traceable = traceable; exports.traced = traced; exports.updateSpan = updateSpan; exports.uploadLogs3OverflowPayload = uploadLogs3OverflowPayload; exports.utf8ByteLength = utf8ByteLength; exports.withCurrent = withCurrent; exports.withDataset = withDataset; exports.withExperiment = withExperiment; exports.withLogger = withLogger; exports.withParent = withParent; exports.wrapAISDK = wrapAISDK; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAgentClass = wrapAgentClass; exports.wrapAnthropic = wrapAnthropic; exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK; exports.wrapGoogleGenAI = wrapGoogleGenAI; exports.wrapMastraAgent = wrapMastraAgent; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapTraced = wrapTraced;