braintrust 0.3.7 → 0.4.0

package/dist/index.js

@@ -1528,7 +1528,7 @@ var init_BatchSpanProcessor = _chunkCDBUTZMHjs.__esm.call(void 0, {
 });
 
 // ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/RandomIdGenerator.js
-function getIdGenerator(bytes) {
+function getIdGenerator2(bytes) {
   return function generateId() {
     for (let i = 0; i < bytes / 4; i++) {
       SHARED_BUFFER.writeUInt32BE(Math.random() * 2 ** 32 >>> 0, i * 4);
@@ -1554,12 +1554,12 @@ var init_RandomIdGenerator = _chunkCDBUTZMHjs.__esm.call(void 0, {
        * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
        * characters corresponding to 128 bits.
        */
-      __init17() {this.generateTraceId = getIdGenerator(TRACE_ID_BYTES)}
+      __init17() {this.generateTraceId = getIdGenerator2(TRACE_ID_BYTES)}
       /**
        * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
        * characters corresponding to 64 bits.
        */
-      __init18() {this.generateSpanId = getIdGenerator(SPAN_ID_BYTES)}
+      __init18() {this.generateSpanId = getIdGenerator2(SPAN_ID_BYTES)}
     }, _class5);
     SHARED_BUFFER = Buffer.allocUnsafe(TRACE_ID_BYTES);
   }
@@ -3498,6 +3498,44 @@ var Queue = (_class11 = class {
   }
 }, _class11);
 
+// src/id-gen.ts
+
+function generateHexId(bytes) {
+  let result = "";
+  for (let i = 0; i < bytes; i++) {
+    result += Math.floor(Math.random() * 256).toString(16).padStart(2, "0");
+  }
+  return result;
+}
+var IDGenerator = class {
+};
+var UUIDGenerator = class extends IDGenerator {
+  getSpanId() {
+    return _uuid.v4.call(void 0, );
+  }
+  getTraceId() {
+    return _uuid.v4.call(void 0, );
+  }
+  shareRootSpanId() {
+    return true;
+  }
+};
+var OTELIDGenerator = class extends IDGenerator {
+  getSpanId() {
+    return generateHexId(8);
+  }
+  getTraceId() {
+    return generateHexId(16);
+  }
+  shareRootSpanId() {
+    return false;
+  }
+};
+function getIdGenerator() {
+  const useOtel = typeof process !== "undefined" && _optionalChain([process, 'access', _74 => _74.env, 'optionalAccess', _75 => _75.BRAINTRUST_OTEL_COMPAT, 'optionalAccess', _76 => _76.toLowerCase, 'call', _77 => _77()]) === "true";
+  return useOtel ? new OTELIDGenerator() : new UUIDGenerator();
+}
+
 // util/db_fields.ts
 var TRANSACTION_ID_FIELD = "_xact_id";
 var IS_MERGE_FIELD = "_is_merge";
@@ -3648,7 +3686,7 @@ var SpanComponentsV1 = class _SpanComponentsV1 {
     return {
       objectType: this.objectType,
       objectId: this.objectId,
-      rowIds: _optionalChain([this, 'access', _74 => _74.rowIds, 'optionalAccess', _75 => _75.toObject, 'call', _76 => _76()])
+      rowIds: _optionalChain([this, 'access', _78 => _78.rowIds, 'optionalAccess', _79 => _79.toObject, 'call', _80 => _80()])
     };
   }
 };
@@ -3862,7 +3900,7 @@ var SpanComponentsV2 = class _SpanComponentsV2 {
       objectType: this.objectType,
       objectId: this.objectId,
       computeObjectMetadataArgs: this.computeObjectMetadataArgs,
-      rowIds: _optionalChain([this, 'access', _77 => _77.rowIds, 'optionalAccess', _78 => _78.toObject, 'call', _79 => _79()])
+      rowIds: _optionalChain([this, 'access', _81 => _81.rowIds, 'optionalAccess', _82 => _82.toObject, 'call', _83 => _83()])
     };
   }
 };
@@ -4194,14 +4232,14 @@ function depthFirstSearch(args) {
   while (events.length) {
     const { eventType, vertex, extras } = events.pop();
     if (eventType === "last") {
-      _optionalChain([lastVisitF, 'optionalCall', _80 => _80(vertex)]);
+      _optionalChain([lastVisitF, 'optionalCall', _84 => _84(vertex)]);
       continue;
     }
     if (firstVisitedVertices.has(vertex)) {
       continue;
     }
     firstVisitedVertices.add(vertex);
-    _optionalChain([firstVisitF, 'optionalCall', _81 => _81(vertex, { parentVertex: extras.parentVertex })]);
+    _optionalChain([firstVisitF, 'optionalCall', _85 => _85(vertex, { parentVertex: extras.parentVertex })]);
     events.push({ eventType: "last", vertex, extras: {} });
     mapAt(graph, vertex).forEach((child) => {
       events.push({
@@ -4223,7 +4261,7 @@ function undirectedConnectedComponents(graph) {
   let labelCounter = 0;
   const vertexLabels = /* @__PURE__ */ new Map();
   const firstVisitF = (vertex, args) => {
-    const label = _optionalChain([args, 'optionalAccess', _82 => _82.parentVertex]) !== void 0 ? mapAt(vertexLabels, _optionalChain([args, 'optionalAccess', _83 => _83.parentVertex])) : labelCounter++;
+    const label = _optionalChain([args, 'optionalAccess', _86 => _86.parentVertex]) !== void 0 ? mapAt(vertexLabels, _optionalChain([args, 'optionalAccess', _87 => _87.parentVertex])) : labelCounter++;
     vertexLabels.set(vertex, label);
   };
   depthFirstSearch({ graph: directedGraph, firstVisitF });
@@ -4445,6 +4483,41 @@ function _urljoin(...parts) {
   ).filter((x) => x.trim() !== "").join("/");
 }
 
+// util/span_identifier_v4.ts
+
+var ENCODING_VERSION_NUMBER_V4 = 4;
+var INVALID_ENCODING_ERRMSG_V4 = `SpanComponents string is not properly encoded. This library only supports encoding versions up to ${ENCODING_VERSION_NUMBER_V4}. Please make sure the SDK library used to decode the SpanComponents is at least as new as any library used to encode it.`;
+var spanComponentsV4Schema = _v3.z.object({
+  object_type: spanObjectTypeV3EnumSchema,
+  propagated_event: _v3.z.record(_v3.z.unknown()).nullish()
+}).and(
+  _v3.z.union([
+    // Must provide one or the other.
+    _v3.z.object({
+      object_id: _v3.z.string().nullish(),
+      compute_object_metadata_args: _v3.z.optional(_v3.z.null())
+    }),
+    _v3.z.object({
+      object_id: _v3.z.optional(_v3.z.null()),
+      compute_object_metadata_args: _v3.z.record(_v3.z.unknown())
+    })
+  ])
+).and(
+  _v3.z.union([
+    // Either all of these must be provided or none.
+    _v3.z.object({
+      row_id: _v3.z.string(),
+      span_id: _v3.z.string(),
+      root_span_id: _v3.z.string()
+    }),
+    _v3.z.object({
+      row_id: _v3.z.optional(_v3.z.null()),
+      span_id: _v3.z.optional(_v3.z.null()),
+      root_span_id: _v3.z.optional(_v3.z.null())
+    })
+  ])
+);
+
 // util/git_fields.ts
 function mergeGitMetadataSettings(s1, s2) {
   if (s1.collect === "all") {
@@ -6460,7 +6533,7 @@ var NoopSpan = (_class14 = class {
     return this;
   }
   end(args) {
-    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _84 => _84.endTime]), () => ( getCurrentUnixTimestamp()));
+    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _88 => _88.endTime]), () => ( getCurrentUnixTimestamp()));
   }
   async export() {
     return "";
@@ -6484,6 +6557,20 @@ var NoopSpan = (_class14 = class {
   state() {
     return _internalGetGlobalState();
   }
+  // Custom inspect for Node.js console.log
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `NoopSpan {
+  kind: '${this.kind}',
+  id: '${this.id}',
+  spanId: '${this.spanId}',
+  rootSpanId: '${this.rootSpanId}',
+  spanParents: ${JSON.stringify(this.spanParents)}
+}`;
+  }
+  // Custom toString
+  toString() {
+    return `NoopSpan(id=${this.id}, spanId=${this.spanId})`;
+  }
 }, _class14);
 var NOOP_SPAN = new NoopSpan();
 var NOOP_SPAN_PERMALINK = "https://braintrust.dev/noop-span";
@@ -6499,7 +6586,7 @@ var loginSchema = _zod.z.strictObject({
 });
 var stateNonce = 0;
 var BraintrustState = (_class15 = class _BraintrustState {
-  constructor(loginParams) {;_class15.prototype.__init31.call(this);_class15.prototype.__init32.call(this);_class15.prototype.__init33.call(this);_class15.prototype.__init34.call(this);_class15.prototype.__init35.call(this);_class15.prototype.__init36.call(this);_class15.prototype.__init37.call(this);_class15.prototype.__init38.call(this);_class15.prototype.__init39.call(this);_class15.prototype.__init40.call(this);_class15.prototype.__init41.call(this);_class15.prototype.__init42.call(this);_class15.prototype.__init43.call(this);
+  constructor(loginParams) {;_class15.prototype.__init31.call(this);_class15.prototype.__init32.call(this);_class15.prototype.__init33.call(this);_class15.prototype.__init34.call(this);_class15.prototype.__init35.call(this);_class15.prototype.__init36.call(this);_class15.prototype.__init37.call(this);_class15.prototype.__init38.call(this);_class15.prototype.__init39.call(this);_class15.prototype.__init40.call(this);_class15.prototype.__init41.call(this);_class15.prototype.__init42.call(this);_class15.prototype.__init43.call(this);_class15.prototype.__init44.call(this);
     this.loginParams = loginParams;
     this.id = `${(/* @__PURE__ */ new Date()).toLocaleString()}-${stateNonce++}`;
     this.currentExperiment = void 0;
@@ -6553,6 +6640,7 @@ var BraintrustState = (_class15 = class _BraintrustState {
   __init42() {this._apiConn = null}
   __init43() {this._proxyConn = null}
   
+  __init44() {this._idGenerator = null}
   resetLoginInfo() {
     this.appUrl = null;
     this.appPublicUrl = null;
@@ -6567,6 +6655,15 @@ var BraintrustState = (_class15 = class _BraintrustState {
     this._apiConn = null;
     this._proxyConn = null;
   }
+  resetIdGenState() {
+    this._idGenerator = null;
+  }
+  get idGenerator() {
+    if (this._idGenerator === null) {
+      this._idGenerator = getIdGenerator();
+    }
+    return this._idGenerator;
+  }
   copyLoginInfo(other) {
     this.appUrl = other.appUrl;
     this.appPublicUrl = other.appPublicUrl;
@@ -6634,8 +6731,8 @@ var BraintrustState = (_class15 = class _BraintrustState {
   setFetch(fetch2) {
     this.loginParams.fetch = fetch2;
     this.fetch = fetch2;
-    _optionalChain([this, 'access', _85 => _85._apiConn, 'optionalAccess', _86 => _86.setFetch, 'call', _87 => _87(fetch2)]);
-    _optionalChain([this, 'access', _88 => _88._appConn, 'optionalAccess', _89 => _89.setFetch, 'call', _90 => _90(fetch2)]);
+    _optionalChain([this, 'access', _89 => _89._apiConn, 'optionalAccess', _90 => _90.setFetch, 'call', _91 => _91(fetch2)]);
+    _optionalChain([this, 'access', _92 => _92._appConn, 'optionalAccess', _93 => _93.setFetch, 'call', _94 => _94(fetch2)]);
   }
   setMaskingFunction(maskingFunction) {
     this.bgLogger().setMaskingFunction(maskingFunction);
@@ -6704,6 +6801,37 @@ var BraintrustState = (_class15 = class _BraintrustState {
   enforceQueueSizeLimit(enforce) {
     this._bgLogger.get().enforceQueueSizeLimit(enforce);
   }
+  // Custom serialization to avoid logging sensitive data
+  toJSON() {
+    return {
+      id: this.id,
+      orgId: this.orgId,
+      orgName: this.orgName,
+      appUrl: this.appUrl,
+      appPublicUrl: this.appPublicUrl,
+      apiUrl: this.apiUrl,
+      proxyUrl: this.proxyUrl,
+      loggedIn: this.loggedIn
+      // Explicitly exclude loginToken, _apiConn, _appConn, _proxyConn and other sensitive fields
+    };
+  }
+  // Custom inspect for Node.js console.log
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `BraintrustState {
+  id: '${this.id}',
+  orgId: ${this.orgId ? `'${this.orgId}'` : "null"},
+  orgName: ${this.orgName ? `'${this.orgName}'` : "null"},
+  appUrl: ${this.appUrl ? `'${this.appUrl}'` : "null"},
+  apiUrl: ${this.apiUrl ? `'${this.apiUrl}'` : "null"},
+  proxyUrl: ${this.proxyUrl ? `'${this.proxyUrl}'` : "null"},
+  loggedIn: ${this.loggedIn},
+  loginToken: '[REDACTED]'
+}`;
+  }
+  // Custom toString
+  toString() {
+    return `BraintrustState(id=${this.id}, org=${this.orgName || "none"}, loggedIn=${this.loggedIn})`;
+  }
 }, _class15);
 var _globalState;
 function useTestBackgroundLogger() {
@@ -6716,7 +6844,7 @@ function useTestBackgroundLogger() {
   return logger;
 }
 function clearTestBackgroundLogger() {
-  _optionalChain([_internalGetGlobalState, 'call', _91 => _91(), 'optionalAccess', _92 => _92.setOverrideBgLogger, 'call', _93 => _93(null)]);
+  _optionalChain([_internalGetGlobalState, 'call', _95 => _95(), 'optionalAccess', _96 => _96.setOverrideBgLogger, 'call', _97 => _97(null)]);
 }
 function initTestExperiment(experimentName, projectName) {
   setInitialTestState();
@@ -6871,6 +6999,17 @@ var HTTPConnection = class _HTTPConnection {
     });
     return await resp.json();
   }
+  // Custom inspect for Node.js console.log
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `HTTPConnection {
+  base_url: '${this.base_url}',
+  token: '[REDACTED]'
+}`;
+  }
+  // Custom toString
+  toString() {
+    return `HTTPConnection(${this.base_url})`;
+  }
 };
 var BaseAttachment = class {
   
@@ -7378,9 +7517,9 @@ async function permalink(slug, opts) {
   if (slug === "") {
     return NOOP_SPAN_PERMALINK;
   }
-  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _94 => _94.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _98 => _98.state]), () => ( _globalState));
   const getOrgName = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _95 => _95.orgName])) {
+    if (_optionalChain([opts, 'optionalAccess', _99 => _99.orgName])) {
       return opts.orgName;
     }
     await state.login({});
@@ -7390,7 +7529,7 @@ async function permalink(slug, opts) {
     return state.orgName;
   };
   const getAppUrl = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _96 => _96.appUrl])) {
+    if (_optionalChain([opts, 'optionalAccess', _100 => _100.appUrl])) {
       return opts.appUrl;
     }
     await state.login({});
@@ -7477,8 +7616,8 @@ var Logger = (_class16 = class {
   
   
   // For type identification.
-  __init44() {this.kind = "logger"}
-  constructor(state, lazyMetadata, logOptions = {}) {;_class16.prototype.__init44.call(this);
+  __init45() {this.kind = "logger"}
+  constructor(state, lazyMetadata, logOptions = {}) {;_class16.prototype.__init45.call(this);
     this.lazyMetadata = lazyMetadata;
     this._asyncFlush = logOptions.asyncFlush;
     this.computeMetadataArgs = logOptions.computeMetadataArgs;
@@ -7520,7 +7659,7 @@ var Logger = (_class16 = class {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _97 => _97.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _101 => _101.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`"
       );
@@ -7588,12 +7727,12 @@ var Logger = (_class16 = class {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _98 => _98.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _102 => _102.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: this.computeMetadataArgs,
-        parentSpanIds: _optionalChain([args, 'optionalAccess', _99 => _99.parentSpanIds]),
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _100 => _100.propagatedEvent])
+        parentSpanIds: _optionalChain([args, 'optionalAccess', _103 => _103.parentSpanIds]),
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _104 => _104.propagatedEvent])
       }),
       defaultRootType: "task" /* TASK */
     });
@@ -7667,9 +7806,9 @@ function constructLogs3Data(items) {
 function now() {
   return (/* @__PURE__ */ new Date()).getTime();
 }
-var TestBackgroundLogger = (_class17 = class {constructor() { _class17.prototype.__init45.call(this);_class17.prototype.__init46.call(this); }
-  __init45() {this.items = []}
-  __init46() {this.maskingFunction = null}
+var TestBackgroundLogger = (_class17 = class {constructor() { _class17.prototype.__init46.call(this);_class17.prototype.__init47.call(this); }
+  __init46() {this.items = []}
+  __init47() {this.maskingFunction = null}
   log(items) {
     this.items.push(items);
   }
@@ -7723,26 +7862,26 @@ var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
 var HTTPBackgroundLogger = (_class18 = class _HTTPBackgroundLogger {
   
   
-  __init47() {this.activeFlush = Promise.resolve()}
-  __init48() {this.activeFlushResolved = true}
-  __init49() {this.activeFlushError = void 0}
+  __init48() {this.activeFlush = Promise.resolve()}
+  __init49() {this.activeFlushResolved = true}
+  __init50() {this.activeFlushError = void 0}
   
-  __init50() {this.maskingFunction = null}
-  __init51() {this.syncFlush = false}
+  __init51() {this.maskingFunction = null}
+  __init52() {this.syncFlush = false}
   // 6 MB for the AWS lambda gateway (from our own testing).
-  __init52() {this.maxRequestSize = 6 * 1024 * 1024}
-  __init53() {this.defaultBatchSize = 100}
-  __init54() {this.numTries = 3}
-  __init55() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
-  __init56() {this.queueDropLoggingPeriod = 60}
-  __init57() {this.failedPublishPayloadsDir = void 0}
-  __init58() {this.allPublishPayloadsDir = void 0}
-  __init59() {this._disabled = false}
-  __init60() {this.queueDropLoggingState = {
+  __init53() {this.maxRequestSize = 6 * 1024 * 1024}
+  __init54() {this.defaultBatchSize = 100}
+  __init55() {this.numTries = 3}
+  __init56() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
+  __init57() {this.queueDropLoggingPeriod = 60}
+  __init58() {this.failedPublishPayloadsDir = void 0}
+  __init59() {this.allPublishPayloadsDir = void 0}
+  __init60() {this._disabled = false}
+  __init61() {this.queueDropLoggingState = {
     numDropped: 0,
     lastLoggedTimestamp: 0
   }}
-  constructor(apiConn, opts) {;_class18.prototype.__init47.call(this);_class18.prototype.__init48.call(this);_class18.prototype.__init49.call(this);_class18.prototype.__init50.call(this);_class18.prototype.__init51.call(this);_class18.prototype.__init52.call(this);_class18.prototype.__init53.call(this);_class18.prototype.__init54.call(this);_class18.prototype.__init55.call(this);_class18.prototype.__init56.call(this);_class18.prototype.__init57.call(this);_class18.prototype.__init58.call(this);_class18.prototype.__init59.call(this);_class18.prototype.__init60.call(this);
+  constructor(apiConn, opts) {;_class18.prototype.__init48.call(this);_class18.prototype.__init49.call(this);_class18.prototype.__init50.call(this);_class18.prototype.__init51.call(this);_class18.prototype.__init52.call(this);_class18.prototype.__init53.call(this);_class18.prototype.__init54.call(this);_class18.prototype.__init55.call(this);_class18.prototype.__init56.call(this);_class18.prototype.__init57.call(this);_class18.prototype.__init58.call(this);_class18.prototype.__init59.call(this);_class18.prototype.__init60.call(this);_class18.prototype.__init61.call(this);
     opts = _nullishCoalesce(opts, () => ( {}));
     this.apiConn = apiConn;
     const syncFlushEnv = Number(isomorph_default.getEnv("BRAINTRUST_SYNC_FLUSH"));
@@ -7831,7 +7970,7 @@ var HTTPBackgroundLogger = (_class18 = class _HTTPBackgroundLogger {
       this.queue.clear();
       return;
     }
-    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _101 => _101.batchSize]), () => ( this.defaultBatchSize));
+    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _105 => _105.batchSize]), () => ( this.defaultBatchSize));
     const wrappedItems = this.queue.drain();
     const [allItems, attachments] = await this.unwrapLazyValues(wrappedItems);
     if (allItems.length === 0) {
@@ -8080,10 +8219,10 @@ Error: ${errorText}`;
         } catch (err) {
           if (err instanceof AggregateError) {
             for (const e of err.errors) {
-              _optionalChain([this, 'access', _102 => _102.onFlushError, 'optionalCall', _103 => _103(e)]);
+              _optionalChain([this, 'access', _106 => _106.onFlushError, 'optionalCall', _107 => _107(e)]);
             }
           } else {
-            _optionalChain([this, 'access', _104 => _104.onFlushError, 'optionalCall', _105 => _105(err)]);
+            _optionalChain([this, 'access', _108 => _108.onFlushError, 'optionalCall', _109 => _109(err)]);
           }
           this.activeFlushError = err;
         } finally {
@@ -8696,24 +8835,24 @@ async function summarize(options = {}) {
   return await e.summarize(options);
 }
 function currentExperiment(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _106 => _106.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _110 => _110.state]), () => ( _globalState));
   return state.currentExperiment;
 }
 function currentLogger(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _107 => _107.state]), () => ( _globalState));
-  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _108 => _108.asyncFlush]));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _111 => _111.state]), () => ( _globalState));
+  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _112 => _112.asyncFlush]));
 }
 function currentSpan(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _109 => _109.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _113 => _113.state]), () => ( _globalState));
   return _nullishCoalesce(state.currentSpan.getStore(), () => ( NOOP_SPAN));
 }
 function getSpanParentObject(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _110 => _110.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _114 => _114.state]), () => ( _globalState));
   const parentSpan = currentSpan({ state });
   if (!Object.is(parentSpan, NOOP_SPAN)) {
     return parentSpan;
   }
-  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _111 => _111.parent]), () => ( state.currentParent.getStore()));
+  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _115 => _115.parent]), () => ( state.currentParent.getStore()));
   if (parentStr) return SpanComponentsV3.fromStr(parentStr);
   const experiment = currentExperiment();
   if (experiment) {
@@ -8742,7 +8881,7 @@ function traced(callback, args) {
   const { span, isSyncFlushLogger } = startSpanAndIsLogger(args);
   const ret = runCatchFinally(
     () => {
-      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _112 => _112.setCurrent]), () => ( true))) {
+      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _116 => _116.setCurrent]), () => ( true))) {
         return withCurrent(span, callback);
       } else {
         return callback(span);
@@ -8754,7 +8893,7 @@ function traced(callback, args) {
     },
     () => span.end()
   );
-  if (_optionalChain([args, 'optionalAccess', _113 => _113.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _114 => _114.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _117 => _117.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _118 => _118.asyncFlush])) {
     return ret;
   } else {
     return (async () => {
@@ -8878,14 +9017,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', _115 => _115.noTraceIO]) || hasExplicitInput || hasExplicitOutput;
+  const noTraceIO = _optionalChain([args, 'optionalAccess', _119 => _119.noTraceIO]) || hasExplicitInput || hasExplicitOutput;
   if (isGeneratorFunction(fn)) {
     return wrapTracedSyncGenerator(fn, spanArgs, !!noTraceIO);
   }
   if (isAsyncGeneratorFunction(fn)) {
     return wrapTracedAsyncGenerator(fn, spanArgs, !!noTraceIO);
   }
-  if (_optionalChain([args, 'optionalAccess', _116 => _116.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _120 => _120.asyncFlush])) {
     return (...fnArgs) => traced((span) => {
       if (!hasExplicitInput) {
         span.log({ input: fnArgs });
@@ -8923,17 +9062,17 @@ function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
 async function flush(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _117 => _117.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _121 => _121.state]), () => ( _globalState));
   return await state.bgLogger().flush();
 }
 function setFetch(fetch2) {
   _globalState.setFetch(fetch2);
 }
 function startSpanAndIsLogger(args) {
-  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _118 => _118.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _122 => _122.state]), () => ( _globalState));
   const parentObject = getSpanParentObject({
-    asyncFlush: _optionalChain([args, 'optionalAccess', _119 => _119.asyncFlush]),
-    parent: _optionalChain([args, 'optionalAccess', _120 => _120.parent]),
+    asyncFlush: _optionalChain([args, 'optionalAccess', _123 => _123.asyncFlush]),
+    parent: _optionalChain([args, 'optionalAccess', _124 => _124.parent]),
     state
   });
   if (parentObject instanceof SpanComponentsV3) {
@@ -8950,14 +9089,14 @@ function startSpanAndIsLogger(args) {
       ),
       parentComputeObjectMetadataArgs: _nullishCoalesce(parentObject.data.compute_object_metadata_args, () => ( void 0)),
       parentSpanIds,
-      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _121 => _121.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _125 => _125.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', _122 => _122.asyncFlush]) === false
+      _optionalChain([args, 'optionalAccess', _126 => _126.asyncFlush]) === false
     };
   } else {
     const span = parentObject.startSpan(args);
@@ -9146,10 +9285,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _123 => _123.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (_optionalChain([value, 'optionalAccess', _127 => _127.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _124 => _124.reference, 'optionalAccess', _125 => _125.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _126 => _126.uploader])) {
+    if (_optionalChain([value, 'optionalAccess', _128 => _128.reference, 'optionalAccess', _129 => _129.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _130 => _130.uploader])) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -9216,13 +9355,13 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
 var INTERNAL_BTQL_LIMIT = 1e3;
 var MAX_BTQL_ITERATIONS = 1e4;
 var ObjectFetcher = (_class19 = class {
-  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class19.prototype.__init61.call(this);
+  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class19.prototype.__init62.call(this);
     this.objectType = objectType;
     this.pinnedVersion = pinnedVersion;
     this.mutateRecord = mutateRecord;
     this._internal_btql = _internal_btql;
   }
-  __init61() {this._fetchedData = void 0}
+  __init62() {this._fetchedData = void 0}
   get id() {
     throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
   }
@@ -9287,7 +9426,7 @@ var ObjectFetcher = (_class19 = class {
           throw new Error("Too many BTQL iterations");
         }
       }
-      this._fetchedData = this.mutateRecord ? _optionalChain([data, 'optionalAccess', _127 => _127.map, 'call', _128 => _128(this.mutateRecord)]) : data;
+      this._fetchedData = this.mutateRecord ? _optionalChain([data, 'optionalAccess', _131 => _131.map, 'call', _132 => _132(this.mutateRecord)]) : data;
     }
     return this._fetchedData || [];
   }
@@ -9318,9 +9457,9 @@ var Experiment2 = (_class20 = class extends ObjectFetcher {
   
   
   // For type identification.
-  __init62() {this.kind = "experiment"}
+  __init63() {this.kind = "experiment"}
   constructor(state, lazyMetadata, dataset) {
-    super("experiment", void 0, (r) => enrichAttachments(r, state));_class20.prototype.__init62.call(this);;
+    super("experiment", void 0, (r) => enrichAttachments(r, state));_class20.prototype.__init63.call(this);;
     this.lazyMetadata = lazyMetadata;
     this.dataset = dataset;
     this.lastStartTime = getCurrentUnixTimestamp();
@@ -9368,7 +9507,7 @@ var Experiment2 = (_class20 = class extends ObjectFetcher {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _129 => _129.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _133 => _133.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`"
       );
@@ -9421,12 +9560,12 @@ var Experiment2 = (_class20 = class extends ObjectFetcher {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _130 => _130.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _134 => _134.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: void 0,
         parentSpanIds: void 0,
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _131 => _131.propagatedEvent])
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _135 => _135.propagatedEvent])
       }),
       defaultRootType: "eval" /* EVAL */
     });
@@ -9627,8 +9766,8 @@ var SpanImpl = (_class21 = class _SpanImpl {
   
   
   
-  __init63() {this.kind = "span"}
-  constructor(args) {;_class21.prototype.__init63.call(this);
+  __init64() {this.kind = "span"}
+  constructor(args) {;_class21.prototype.__init64.call(this);
     this._state = args.state;
     const spanAttributes = _nullishCoalesce(args.spanAttributes, () => ( {}));
     const rawEvent = _nullishCoalesce(args.event, () => ( {}));
@@ -9668,13 +9807,17 @@ var SpanImpl = (_class21 = class _SpanImpl {
       },
       created: (/* @__PURE__ */ new Date()).toISOString()
     };
-    this._id = _nullishCoalesce(eventId, () => ( _uuid.v4.call(void 0, )));
-    this._spanId = _nullishCoalesce(args.spanId, () => ( _uuid.v4.call(void 0, )));
+    this._id = _nullishCoalesce(eventId, () => ( this._state.idGenerator.getSpanId()));
+    this._spanId = _nullishCoalesce(args.spanId, () => ( this._state.idGenerator.getSpanId()));
     if (args.parentSpanIds) {
       this._rootSpanId = args.parentSpanIds.rootSpanId;
       this._spanParents = "parentSpanIds" in args.parentSpanIds ? args.parentSpanIds.parentSpanIds : [args.parentSpanIds.spanId];
     } else {
-      this._rootSpanId = this._spanId;
+      if (this._state.idGenerator.shareRootSpanId()) {
+        this._rootSpanId = this._spanId;
+      } else {
+        this._rootSpanId = this._state.idGenerator.getTraceId();
+      }
       this._spanParents = void 0;
     }
     this.isMerge = false;
@@ -9718,10 +9861,10 @@ var SpanImpl = (_class21 = class _SpanImpl {
       ...serializableInternalData,
       [IS_MERGE_FIELD]: this.isMerge
     });
-    if (_optionalChain([partialRecord, 'access', _132 => _132.metrics, 'optionalAccess', _133 => _133.end])) {
-      this.loggedEndTime = _optionalChain([partialRecord, 'access', _134 => _134.metrics, 'optionalAccess', _135 => _135.end]);
+    if (_optionalChain([partialRecord, 'access', _136 => _136.metrics, 'optionalAccess', _137 => _137.end])) {
+      this.loggedEndTime = _optionalChain([partialRecord, 'access', _138 => _138.metrics, 'optionalAccess', _139 => _139.end]);
     }
-    if ((_nullishCoalesce(partialRecord.tags, () => ( []))).length > 0 && _optionalChain([this, 'access', _136 => _136._spanParents, 'optionalAccess', _137 => _137.length])) {
+    if ((_nullishCoalesce(partialRecord.tags, () => ( []))).length > 0 && _optionalChain([this, 'access', _140 => _140._spanParents, 'optionalAccess', _141 => _141.length])) {
       throw new Error("Tags can only be logged to the root span");
     }
     const computeRecord = async () => ({
@@ -9766,18 +9909,18 @@ var SpanImpl = (_class21 = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _138 => _138.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _142 => _142.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this._state,
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _139 => _139.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _143 => _143.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _140 => _140.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _144 => _144.propagatedEvent]), () => ( this.propagatedEvent))
       })
     });
   }
@@ -9791,12 +9934,12 @@ var SpanImpl = (_class21 = class _SpanImpl {
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _141 => _141.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _145 => _145.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _142 => _142.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _146 => _146.propagatedEvent]), () => ( this.propagatedEvent))
       }),
       spanId
     });
@@ -9805,7 +9948,7 @@ var SpanImpl = (_class21 = class _SpanImpl {
     let endTime;
     let internalData = {};
     if (!this.loggedEndTime) {
-      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _143 => _143.endTime]), () => ( getCurrentUnixTimestamp()));
+      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _147 => _147.endTime]), () => ( getCurrentUnixTimestamp()));
       internalData = { metrics: { end: endTime } };
     } else {
       endTime = this.loggedEndTime;
@@ -9848,8 +9991,8 @@ var SpanImpl = (_class21 = class _SpanImpl {
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
       case 2 /* PROJECT_LOGS */: {
-        const projectID = _optionalChain([args, 'optionalAccess', _144 => _144.project_id]) || this.parentObjectId.getSync().value;
-        const projectName = _optionalChain([args, 'optionalAccess', _145 => _145.project_name]);
+        const projectID = _optionalChain([args, 'optionalAccess', _148 => _148.project_id]) || this.parentObjectId.getSync().value;
+        const projectName = _optionalChain([args, 'optionalAccess', _149 => _149.project_name]);
         if (projectID) {
           return `${baseUrl}/object?object_type=project_logs&object_id=${projectID}&id=${this._id}`;
         } else if (projectName) {
@@ -9859,7 +10002,7 @@ var SpanImpl = (_class21 = class _SpanImpl {
         }
       }
       case 1 /* EXPERIMENT */: {
-        const expID = _optionalChain([args, 'optionalAccess', _146 => _146.experiment_id]) || _optionalChain([this, 'access', _147 => _147.parentObjectId, 'optionalAccess', _148 => _148.getSync, 'call', _149 => _149(), 'optionalAccess', _150 => _150.value]);
+        const expID = _optionalChain([args, 'optionalAccess', _150 => _150.experiment_id]) || _optionalChain([this, 'access', _151 => _151.parentObjectId, 'optionalAccess', _152 => _152.getSync, 'call', _153 => _153(), 'optionalAccess', _154 => _154.value]);
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
         } else {
@@ -9885,6 +10028,20 @@ var SpanImpl = (_class21 = class _SpanImpl {
   state() {
     return this._state;
   }
+  // Custom inspect for Node.js console.log
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `SpanImpl {
+  kind: '${this.kind}',
+  id: '${this.id}',
+  spanId: '${this.spanId}',
+  rootSpanId: '${this.rootSpanId}',
+  spanParents: ${JSON.stringify(this.spanParents)}
+}`;
+  }
+  // Custom toString
+  toString() {
+    return `SpanImpl(id=${this.id}, spanId=${this.spanId})`;
+  }
 }, _class21);
 function splitLoggingData({
   event,
@@ -9935,13 +10092,13 @@ var Dataset2 = (_class22 = class extends ObjectFetcher {
         )
       ),
       _internal_btql
-    );_class22.prototype.__init64.call(this);_class22.prototype.__init65.call(this);;
+    );_class22.prototype.__init65.call(this);_class22.prototype.__init66.call(this);;
     this.state = state;
     this.lazyMetadata = lazyMetadata;
   }
   
-  __init64() {this.__braintrust_dataset_marker = true}
-  __init65() {this.newRecords = 0}
+  __init65() {this.__braintrust_dataset_marker = true}
+  __init66() {this.newRecords = 0}
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).dataset.id;
@@ -10264,14 +10421,14 @@ function renderPromptParams(params, args, options) {
   return params;
 }
 var Prompt2 = (_class23 = class _Prompt {
-  constructor(metadata, defaults, noTrace) {;_class23.prototype.__init66.call(this);_class23.prototype.__init67.call(this);
+  constructor(metadata, defaults, noTrace) {;_class23.prototype.__init67.call(this);_class23.prototype.__init68.call(this);
     this.metadata = metadata;
     this.defaults = defaults;
     this.noTrace = noTrace;
   }
   
-  __init66() {this.hasParsedPromptData = false}
-  __init67() {this.__braintrust_prompt_marker = true}
+  __init67() {this.hasParsedPromptData = false}
+  __init68() {this.__braintrust_prompt_marker = true}
   get id() {
     return this.metadata.id;
   }
@@ -10285,13 +10442,13 @@ var Prompt2 = (_class23 = class _Prompt {
     return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
   }
   get prompt() {
-    return _optionalChain([this, 'access', _151 => _151.getParsedPromptData, 'call', _152 => _152(), 'optionalAccess', _153 => _153.prompt]);
+    return _optionalChain([this, 'access', _155 => _155.getParsedPromptData, 'call', _156 => _156(), 'optionalAccess', _157 => _157.prompt]);
   }
   get version() {
     return this.metadata[TRANSACTION_ID_FIELD];
   }
   get options() {
-    return _optionalChain([this, 'access', _154 => _154.getParsedPromptData, 'call', _155 => _155(), 'optionalAccess', _156 => _156.options]) || {};
+    return _optionalChain([this, 'access', _158 => _158.getParsedPromptData, 'call', _159 => _159(), 'optionalAccess', _160 => _160.options]) || {};
   }
   get promptData() {
     return this.getParsedPromptData();
@@ -10442,7 +10599,7 @@ var Prompt2 = (_class23 = class _Prompt {
       return {
         type: "chat",
         messages,
-        ..._optionalChain([prompt, 'access', _157 => _157.tools, 'optionalAccess', _158 => _158.trim, 'call', _159 => _159()]) ? {
+        ..._optionalChain([prompt, 'access', _161 => _161.tools, 'optionalAccess', _162 => _162.trim, 'call', _163 => _163()]) ? {
           tools: render(prompt.tools)
         } : void 0
       };
@@ -10552,9 +10709,15 @@ async function getPromptVersions(projectId, promptId) {
     );
   }
   const result = await response.json();
-  return _optionalChain([result, 'access', _160 => _160.data, 'optionalAccess', _161 => _161.filter, 'call', _162 => _162(
-    (entry) => ["upsert", "merge"].includes(_optionalChain([entry, 'access', _163 => _163.audit_data, 'optionalAccess', _164 => _164.action]))
-  ), 'access', _165 => _165.map, 'call', _166 => _166((entry) => prettifyXact(entry._xact_id))]) || [];
+  return _optionalChain([result, 'access', _164 => _164.data, 'optionalAccess', _165 => _165.filter, 'call', _166 => _166(
+    (entry) => ["upsert", "merge"].includes(_optionalChain([entry, 'access', _167 => _167.audit_data, 'optionalAccess', _168 => _168.action]))
+  ), 'access', _169 => _169.map, 'call', _170 => _170((entry) => prettifyXact(entry._xact_id))]) || [];
+}
+function resetIdGenStateForTests() {
+  const state = _internalGetGlobalState();
+  if (state) {
+    state.resetIdGenState();
+  }
 }
 var _exportsForTestingOnly = {
   extractAttachments,
@@ -10566,7 +10729,8 @@ var _exportsForTestingOnly = {
   setInitialTestState,
   initTestExperiment,
   isGeneratorFunction,
-  isAsyncGeneratorFunction
+  isAsyncGeneratorFunction,
+  resetIdGenStateForTests
 };
 
 // src/node.ts
@@ -10619,6 +10783,7 @@ _chunkCDBUTZMHjs.__export.call(void 0, exports_node_exports, {
   Experiment: () => Experiment2,
   ExternalAttachment: () => ExternalAttachment,
   FailedHTTPResponse: () => FailedHTTPResponse,
+  IDGenerator: () => IDGenerator,
   INTERNAL_BTQL_LIMIT: () => INTERNAL_BTQL_LIMIT,
   LEGACY_CACHED_HEADER: () => LEGACY_CACHED_HEADER,
   LazyValue: () => LazyValue,
@@ -10626,6 +10791,7 @@ _chunkCDBUTZMHjs.__export.call(void 0, exports_node_exports, {
   NOOP_SPAN: () => NOOP_SPAN,
   NOOP_SPAN_PERMALINK: () => NOOP_SPAN_PERMALINK,
   NoopSpan: () => NoopSpan,
+  OTELIDGenerator: () => OTELIDGenerator,
   Project: () => Project2,
   ProjectNameIdMap: () => ProjectNameIdMap,
   Prompt: () => Prompt2,
@@ -10637,6 +10803,7 @@ _chunkCDBUTZMHjs.__export.call(void 0, exports_node_exports, {
   SpanImpl: () => SpanImpl,
   TestBackgroundLogger: () => TestBackgroundLogger,
   ToolBuilder: () => ToolBuilder,
+  UUIDGenerator: () => UUIDGenerator,
   X_CACHED_HEADER: () => X_CACHED_HEADER,
   _exportsForTestingOnly: () => _exportsForTestingOnly,
   _internalGetGlobalState: () => _internalGetGlobalState,
@@ -10647,10 +10814,12 @@ _chunkCDBUTZMHjs.__export.call(void 0, exports_node_exports, {
   currentExperiment: () => currentExperiment,
   currentLogger: () => currentLogger,
   currentSpan: () => currentSpan,
+  deepCopyEvent: () => deepCopyEvent,
   defaultErrorScoreHandler: () => defaultErrorScoreHandler,
   deserializePlainStringAsJSON: () => deserializePlainStringAsJSON,
   devNullWritableStream: () => devNullWritableStream,
   flush: () => flush,
+  getIdGenerator: () => getIdGenerator,
   getPromptVersions: () => getPromptVersions,
   getSpanParentObject: () => getSpanParentObject,
   graph: () => graph_framework_exports,
@@ -10694,6 +10863,8 @@ _chunkCDBUTZMHjs.__export.call(void 0, exports_node_exports, {
   wrapAISDK: () => wrapAISDK,
   wrapAISDKModel: () => wrapAISDKModel,
   wrapAnthropic: () => wrapAnthropic,
+  wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
+  wrapMastraAgent: () => wrapMastraAgent,
   wrapOpenAI: () => wrapOpenAI,
   wrapOpenAIv4: () => wrapOpenAIv4,
   wrapTraced: () => wrapTraced
@@ -11840,8 +12011,8 @@ function fitNameToSpaces(name, length) {
 }
 var BarProgressReporter = (_class24 = class {
   
-  __init68() {this.bars = {}}
-  constructor() {;_class24.prototype.__init68.call(this);
+  __init69() {this.bars = {}}
+  constructor() {;_class24.prototype.__init69.call(this);
     this.multiBar = new cliProgress.MultiBar(
       {
         clearOnComplete: false,
@@ -11884,9 +12055,9 @@ var Project2 = (_class25 = class {
   
   
   
-  __init69() {this._publishableCodeFunctions = []}
-  __init70() {this._publishablePrompts = []}
-  constructor(args) {;_class25.prototype.__init69.call(this);_class25.prototype.__init70.call(this);
+  __init70() {this._publishableCodeFunctions = []}
+  __init71() {this._publishablePrompts = []}
+  constructor(args) {;_class25.prototype.__init70.call(this);_class25.prototype.__init71.call(this);
     _initializeSpanContext();
     this.name = "name" in args ? args.name : void 0;
     this.id = "id" in args ? args.id : void 0;
@@ -11931,10 +12102,10 @@ var Project2 = (_class25 = class {
   }
 }, _class25);
 var ToolBuilder = (_class26 = class {
-  constructor(project) {;_class26.prototype.__init71.call(this);
+  constructor(project) {;_class26.prototype.__init72.call(this);
     this.project = project;
   }
-  __init71() {this.taskCounter = 0}
+  __init72() {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) {
@@ -11961,10 +12132,10 @@ var ToolBuilder = (_class26 = class {
   }
 }, _class26);
 var ScorerBuilder = (_class27 = class {
-  constructor(project) {;_class27.prototype.__init72.call(this);
+  constructor(project) {;_class27.prototype.__init73.call(this);
     this.project = project;
   }
-  __init72() {this.taskCounter = 0}
+  __init73() {this.taskCounter = 0}
   create(opts) {
     this.taskCounter++;
     let resolvedName = opts.name;
@@ -12181,9 +12352,9 @@ function promptDefinitionToPromptData(promptDefinition, rawTools) {
     }
   };
 }
-var ProjectNameIdMap = (_class28 = class {constructor() { _class28.prototype.__init73.call(this);_class28.prototype.__init74.call(this); }
-  __init73() {this.nameToId = {}}
-  __init74() {this.idToName = {}}
+var ProjectNameIdMap = (_class28 = class {constructor() { _class28.prototype.__init74.call(this);_class28.prototype.__init75.call(this); }
+  __init74() {this.nameToId = {}}
+  __init75() {this.idToName = {}}
   async getId(projectName) {
     if (!(projectName in this.nameToId)) {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
@@ -12567,10 +12738,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                 span,
                 parameters: _nullishCoalesce(parameters, () => ( {})),
                 reportProgress: (event) => {
-                  _optionalChain([stream, 'optionalCall', _167 => _167({
+                  _optionalChain([stream, 'optionalCall', _171 => _171({
                     ...event,
                     id: rootSpan.id,
-                    origin: _optionalChain([baseEvent, 'access', _168 => _168.event, 'optionalAccess', _169 => _169.origin]),
+                    origin: _optionalChain([baseEvent, 'access', _172 => _172.event, 'optionalAccess', _173 => _173.origin]),
                     name: evaluator.evalName,
                     object_type: "task"
                   })]);
@@ -12720,7 +12891,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             ...scores
           },
           error: error2,
-          origin: _optionalChain([baseEvent, 'access', _170 => _170.event, 'optionalAccess', _171 => _171.origin])
+          origin: _optionalChain([baseEvent, 'access', _174 => _174.event, 'optionalAccess', _175 => _175.origin])
         });
       };
       if (!experiment) {
@@ -12892,14 +13063,14 @@ _chunkCDBUTZMHjs.__export.call(void 0, graph_framework_exports, {
   unescapePath: () => unescapePath
 });
 var GraphBuilder = (_class29 = class {
-  __init75() {this.nodes = /* @__PURE__ */ new Map()}
-  __init76() {this.edges = {}}
-  __init77() {this.nodeLikeNodes = /* @__PURE__ */ new Map()}
+  __init76() {this.nodes = /* @__PURE__ */ new Map()}
+  __init77() {this.edges = {}}
+  __init78() {this.nodeLikeNodes = /* @__PURE__ */ new Map()}
   // Maps node-like objects, like prompts, to their nodes
   // Special nodes
   
   
-  constructor() {;_class29.prototype.__init75.call(this);_class29.prototype.__init76.call(this);_class29.prototype.__init77.call(this);
+  constructor() {;_class29.prototype.__init76.call(this);_class29.prototype.__init77.call(this);_class29.prototype.__init78.call(this);
     this.IN = this.createInputNode();
     this.OUT = this.createOutputNode();
   }
@@ -13038,12 +13209,12 @@ function proxyVariableToNode(proxy) {
   return [proxy.__node, proxy.__path];
 }
 var BaseNode = (_class30 = class {
-  constructor(graph, id) {;_class30.prototype.__init78.call(this);_class30.prototype.__init79.call(this);
+  constructor(graph, id) {;_class30.prototype.__init79.call(this);_class30.prototype.__init80.call(this);
     this.graph = graph;
     this.id = id;
   }
-  __init78() {this.__type = "node"}
-  __init79() {this.dependencies = []}
+  __init79() {this.__type = "node"}
+  __init80() {this.dependencies = []}
   addDependency(dependency) {
     this.dependencies.push(dependency);
   }
@@ -13207,8 +13378,8 @@ function parseSpanFromResponseCreateParams(params) {
 }
 function parseEventFromResponseCreateResult(result) {
   const data = {};
-  if (_optionalChain([result, 'optionalAccess', _172 => _172.output]) !== void 0) {
-    data.output = result.output;
+  if (_optionalChain([result, 'optionalAccess', _176 => _176.output]) !== void 0) {
+    data.output = processImagesInOutput(result.output);
   }
   if (result) {
     const { output, usage, ...metadata } = result;
@@ -13216,9 +13387,38 @@ function parseEventFromResponseCreateResult(result) {
       data.metadata = metadata;
     }
   }
-  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _173 => _173.usage]));
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _177 => _177.usage]));
   return data;
 }
+function processImagesInOutput(output) {
+  if (Array.isArray(output)) {
+    return output.map(processImagesInOutput);
+  }
+  if (isObject(output)) {
+    if (output.type === "image_generation_call" && output.result && typeof output.result === "string") {
+      const fileExtension = output.output_format || "png";
+      const contentType = `image/${fileExtension}`;
+      const baseFilename = output.revised_prompt && typeof output.revised_prompt === "string" ? output.revised_prompt.slice(0, 50).replace(/[^a-zA-Z0-9]/g, "_") : "generated_image";
+      const filename = `${baseFilename}.${fileExtension}`;
+      const binaryString = atob(output.result);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      const blob = new Blob([bytes], { type: contentType });
+      const attachment = new Attachment({
+        data: blob,
+        filename,
+        contentType
+      });
+      return {
+        ...output,
+        result: attachment
+      };
+    }
+  }
+  return output;
+}
 function parseSpanFromResponseParseParams(params) {
   const spanArgs = {
     name: "openai.responses.parse",
@@ -13241,8 +13441,8 @@ function parseSpanFromResponseParseParams(params) {
 }
 function parseEventFromResponseParseResult(result) {
   const data = {};
-  if (_optionalChain([result, 'optionalAccess', _174 => _174.output]) !== void 0) {
-    data.output = result.output;
+  if (_optionalChain([result, 'optionalAccess', _178 => _178.output]) !== void 0) {
+    data.output = processImagesInOutput(result.output);
   }
   if (result) {
     const { output, usage, ...metadata } = result;
@@ -13250,7 +13450,7 @@ function parseEventFromResponseParseResult(result) {
       data.metadata = metadata;
     }
   }
-  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _175 => _175.usage]));
+  data.metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _179 => _179.usage]));
   return data;
 }
 function traceResponseCreateStream(stream, timedSpan) {
@@ -13267,7 +13467,7 @@ function traceResponseCreateStream(stream, timedSpan) {
       return result;
     }
     const item = result.value;
-    if (!item || !_optionalChain([item, 'optionalAccess', _176 => _176.type]) || !_optionalChain([item, 'optionalAccess', _177 => _177.response])) {
+    if (!item || !_optionalChain([item, 'optionalAccess', _180 => _180.type]) || !_optionalChain([item, 'optionalAccess', _181 => _181.response])) {
       return result;
     }
     const event = parseLogFromItem(item);
@@ -13278,15 +13478,15 @@ function traceResponseCreateStream(stream, timedSpan) {
   };
 }
 function parseLogFromItem(item) {
-  if (!item || !_optionalChain([item, 'optionalAccess', _178 => _178.type]) || !_optionalChain([item, 'optionalAccess', _179 => _179.response])) {
+  if (!item || !_optionalChain([item, 'optionalAccess', _182 => _182.type]) || !_optionalChain([item, 'optionalAccess', _183 => _183.response])) {
     return {};
   }
   const response = item.response;
   switch (item.type) {
     case "response.completed":
       const data = {};
-      if (_optionalChain([response, 'optionalAccess', _180 => _180.output]) !== void 0) {
-        data.output = response.output;
+      if (_optionalChain([response, 'optionalAccess', _184 => _184.output]) !== void 0) {
+        data.output = processImagesInOutput(response.output);
       }
       if (response) {
         const { usage, output, ...metadata } = response;
@@ -13294,7 +13494,7 @@ function parseLogFromItem(item) {
           data.metadata = metadata;
         }
       }
-      data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _181 => _181.usage]));
+      data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _185 => _185.usage]));
       return data;
     default:
       return {};
@@ -13478,8 +13678,8 @@ function wrapOpenAIv4(openai) {
   const embeddingProxy = createEndpointProxy(openai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(openai.moderations, wrapModerations);
   let betaProxy2;
-  if (_optionalChain([openai, 'access', _182 => _182.beta, 'optionalAccess', _183 => _183.chat, 'optionalAccess', _184 => _184.completions, 'optionalAccess', _185 => _185.stream])) {
-    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _186 => _186.beta, 'optionalAccess', _187 => _187.chat, 'access', _188 => _188.completions]), {
+  if (_optionalChain([openai, 'access', _186 => _186.beta, 'optionalAccess', _187 => _187.chat, 'optionalAccess', _188 => _188.completions, 'optionalAccess', _189 => _189.stream])) {
+    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _190 => _190.beta, 'optionalAccess', _191 => _191.chat, 'access', _192 => _192.completions]), {
       get(target, name, receiver) {
         const baseVal = Reflect.get(target, name, receiver);
         if (name === "parse") {
@@ -13527,7 +13727,7 @@ function wrapOpenAIv4(openai) {
   });
 }
 function logCompletionResponse(startTime, response, span) {
-  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _189 => _189.usage]));
+  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _193 => _193.usage]));
   metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
   span.log({
     output: response.choices,
@@ -13757,7 +13957,7 @@ function parseChatCompletionParams(params) {
 function processEmbeddingResponse(result, span) {
   span.log({
     output: { embedding_length: result.data[0].embedding.length },
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _190 => _190.usage]))
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _194 => _194.usage]))
   });
 }
 function processModerationResponse(result, span) {
@@ -13787,10 +13987,10 @@ function postprocessStreamingResults(allResults) {
     if (result.usage) {
       metrics = {
         ...metrics,
-        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _191 => _191.usage]))
+        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _195 => _195.usage]))
       };
     }
-    const delta = _optionalChain([result, 'access', _192 => _192.choices, 'optionalAccess', _193 => _193[0], 'optionalAccess', _194 => _194.delta]);
+    const delta = _optionalChain([result, 'access', _196 => _196.choices, 'optionalAccess', _197 => _197[0], 'optionalAccess', _198 => _198.delta]);
     if (!delta) {
       continue;
     }
@@ -13892,21 +14092,24 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
 
 // src/wrappers/ai-sdk-shared.ts
 function detectProviderFromResult(result) {
-  if (!_optionalChain([result, 'optionalAccess', _195 => _195.providerMetadata])) {
+  if (!_optionalChain([result, 'optionalAccess', _199 => _199.providerMetadata])) {
     return void 0;
   }
   const keys = Object.keys(result.providerMetadata);
-  return _optionalChain([keys, 'optionalAccess', _196 => _196.at, 'call', _197 => _197(0)]);
+  return _optionalChain([keys, 'optionalAccess', _200 => _200.at, 'call', _201 => _201(0)]);
 }
 function extractModelFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _198 => _198.response, 'optionalAccess', _199 => _199.modelId])) {
+  if (_optionalChain([result, 'optionalAccess', _202 => _202.response, 'optionalAccess', _203 => _203.modelId])) {
     return result.response.modelId;
   }
-  if (_optionalChain([result, 'optionalAccess', _200 => _200.request, 'optionalAccess', _201 => _201.body, 'optionalAccess', _202 => _202.model])) {
+  if (_optionalChain([result, 'optionalAccess', _204 => _204.request, 'optionalAccess', _205 => _205.body, 'optionalAccess', _206 => _206.model])) {
     return result.request.body.model;
   }
   return void 0;
 }
+function extractModelFromWrapGenerateCallback(model) {
+  return _optionalChain([model, 'optionalAccess', _207 => _207.modelId]);
+}
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
@@ -13950,7 +14153,7 @@ function normalizeUsageMetrics(usage, provider, providerMetadata) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
   if (provider === "anthropic") {
-    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _203 => _203.anthropic]);
+    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _208 => _208.anthropic]);
     if (anthropicMetadata) {
       const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
       const cacheCreationTokens = getNumberProperty(
@@ -13976,7 +14179,7 @@ function extractToolCallsFromSteps(steps) {
   if (!Array.isArray(steps)) return toolCalls;
   let idx = 0;
   for (const step of steps) {
-    const blocks = _optionalChain([step, 'optionalAccess', _204 => _204.content]);
+    const blocks = _optionalChain([step, 'optionalAccess', _209 => _209.content]);
     if (!Array.isArray(blocks)) continue;
     for (const block of blocks) {
       if (block && typeof block === "object" && block.type === "tool-call") {
@@ -13999,7 +14202,7 @@ function buildAssistantOutputWithToolCalls(result, toolCalls) {
     {
       index: 0,
       logprobs: null,
-      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _205 => _205.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
+      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _210 => _210.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
       message: {
         role: "assistant",
         tool_calls: toolCalls.length > 0 ? toolCalls : void 0
@@ -14048,7 +14251,7 @@ function wrapTools(tools) {
   return wrappedTools;
 }
 function extractInput(params) {
-  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _206 => _206.prompt]), () => ( _optionalChain([params, 'optionalAccess', _207 => _207.messages]))), () => ( _optionalChain([params, 'optionalAccess', _208 => _208.system])));
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _211 => _211.prompt]), () => ( _optionalChain([params, 'optionalAccess', _212 => _212.messages]))), () => ( _optionalChain([params, 'optionalAccess', _213 => _213.system])));
 }
 function wrapStreamObject(iterable, onFirst) {
   let sawFirst = false;
@@ -14079,7 +14282,11 @@ var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
 ]);
 function BraintrustMiddleware(config = {}) {
   return {
-    wrapGenerate: async ({ doGenerate, params }) => {
+    wrapGenerate: async ({
+      doGenerate,
+      params,
+      model: modelFromWrapGenerate
+    }) => {
       const spanArgs = {
         name: "ai-sdk.generateText",
         spanAttributes: {
@@ -14106,13 +14313,20 @@ function BraintrustMiddleware(config = {}) {
         const model = extractModelFromResult(result);
         if (model !== void 0) {
           metadata.model = model;
+        } else if (modelFromWrapGenerate) {
+          const modelId = extractModelFromWrapGenerateCallback(
+            modelFromWrapGenerate
+          );
+          if (modelId) {
+            metadata.model = modelId;
+          }
         }
-        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _209 => _209.steps]));
+        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _214 => _214.steps]));
         if (!toolCalls || toolCalls.length === 0) {
-          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _210 => _210.content]));
+          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _215 => _215.content]));
         }
         span.log({
-          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _211 => _211.content]),
+          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _216 => _216.content]),
           metadata,
           metrics: normalizeUsageMetrics(
             result.usage,
@@ -14245,7 +14459,7 @@ function BraintrustMiddleware(config = {}) {
 // src/wrappers/ai-sdk-v1.ts
 function wrapAISDKModel(model) {
   const m = model;
-  if (_optionalChain([m, 'optionalAccess', _212 => _212.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _213 => _213.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _214 => _214.modelId]) === "string") {
+  if (_optionalChain([m, 'optionalAccess', _217 => _217.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _218 => _218.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _219 => _219.modelId]) === "string") {
     return new BraintrustLanguageModelWrapper(m);
   } else {
     console.warn("Unsupported AI SDK model. Not wrapping.");
@@ -14301,10 +14515,10 @@ var BraintrustLanguageModelWrapper = class {
         metrics: {
           time_to_first_token: getCurrentUnixTimestamp() - startTime,
           tokens: !isEmpty(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
-          prompt_tokens: _optionalChain([ret, 'access', _215 => _215.usage, 'optionalAccess', _216 => _216.promptTokens]),
-          completion_tokens: _optionalChain([ret, 'access', _217 => _217.usage, 'optionalAccess', _218 => _218.completionTokens]),
+          prompt_tokens: _optionalChain([ret, 'access', _220 => _220.usage, 'optionalAccess', _221 => _221.promptTokens]),
+          completion_tokens: _optionalChain([ret, 'access', _222 => _222.usage, 'optionalAccess', _223 => _223.completionTokens]),
           cached: parseCachedHeader(
-            _nullishCoalesce(_optionalChain([ret, 'access', _219 => _219.rawResponse, 'optionalAccess', _220 => _220.headers, 'optionalAccess', _221 => _221[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _222 => _222.rawResponse, 'optionalAccess', _223 => _223.headers, 'optionalAccess', _224 => _224[LEGACY_CACHED_HEADER]])))
+            _nullishCoalesce(_optionalChain([ret, 'access', _224 => _224.rawResponse, 'optionalAccess', _225 => _225.headers, 'optionalAccess', _226 => _226[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _227 => _227.rawResponse, 'optionalAccess', _228 => _228.headers, 'optionalAccess', _229 => _229[LEGACY_CACHED_HEADER]])))
           )
         }
       });
@@ -14396,10 +14610,10 @@ var BraintrustLanguageModelWrapper = class {
                 metrics: {
                   time_to_first_token,
                   tokens: !isEmpty(usage) ? usage.promptTokens + usage.completionTokens : void 0,
-                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _225 => _225.promptTokens]),
-                  completion_tokens: _optionalChain([usage, 'optionalAccess', _226 => _226.completionTokens]),
+                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _230 => _230.promptTokens]),
+                  completion_tokens: _optionalChain([usage, 'optionalAccess', _231 => _231.completionTokens]),
                   cached: parseCachedHeader(
-                    _nullishCoalesce(_optionalChain([ret, 'access', _227 => _227.rawResponse, 'optionalAccess', _228 => _228.headers, 'optionalAccess', _229 => _229[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _230 => _230.rawResponse, 'optionalAccess', _231 => _231.headers, 'optionalAccess', _232 => _232[LEGACY_CACHED_HEADER]])))
+                    _nullishCoalesce(_optionalChain([ret, 'access', _232 => _232.rawResponse, 'optionalAccess', _233 => _233.headers, 'optionalAccess', _234 => _234[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _235 => _235.rawResponse, 'optionalAccess', _236 => _236.headers, 'optionalAccess', _237 => _237[LEGACY_CACHED_HEADER]])))
                   )
                 }
               });
@@ -14446,7 +14660,7 @@ function postProcessPrompt(prompt) {
         return [
           {
             role: "assistant",
-            content: _optionalChain([textPart, 'optionalAccess', _233 => _233.text]),
+            content: _optionalChain([textPart, 'optionalAccess', _238 => _238.text]),
             ...toolCallParts.length > 0 ? {
               tool_calls: toolCallParts.map((part) => ({
                 id: part.toolCallId,
@@ -14554,7 +14768,7 @@ function wrapAISDK(ai) {
         });
         const provider = detectProviderFromResult(result);
         const model = extractModelFromResult(result);
-        const finishReason = normalizeFinishReason(_optionalChain([result, 'optionalAccess', _234 => _234.finishReason]));
+        const finishReason = normalizeFinishReason(_optionalChain([result, 'optionalAccess', _239 => _239.finishReason]));
         span.log({
           input: extractInput(params),
           output: result.text,
@@ -14647,9 +14861,9 @@ function wrapAISDK(ai) {
             }
             const provider = detectProviderFromResult(event);
             const model = extractModelFromResult(event);
-            const finishReason = normalizeFinishReason(_optionalChain([event, 'optionalAccess', _235 => _235.finishReason]));
+            const finishReason = normalizeFinishReason(_optionalChain([event, 'optionalAccess', _240 => _240.finishReason]));
             span.log({
-              output: _optionalChain([event, 'optionalAccess', _236 => _236.text]),
+              output: _optionalChain([event, 'optionalAccess', _241 => _241.text]),
               metadata: {
                 ...extractModelParameters(params, V3_EXCLUDE_KEYS),
                 ...provider ? { provider } : {},
@@ -14707,9 +14921,9 @@ function wrapAISDK(ai) {
             }
             const provider = detectProviderFromResult(event);
             const model = extractModelFromResult(event);
-            const finishReason = normalizeFinishReason(_optionalChain([event, 'optionalAccess', _237 => _237.finishReason]));
+            const finishReason = normalizeFinishReason(_optionalChain([event, 'optionalAccess', _242 => _242.finishReason]));
             span.log({
-              output: _optionalChain([event, 'optionalAccess', _238 => _238.object]),
+              output: _optionalChain([event, 'optionalAccess', _243 => _243.object]),
               metadata: {
                 ...extractModelParameters(params, V3_EXCLUDE_KEYS),
                 ...provider ? { provider } : {},
@@ -14755,6 +14969,146 @@ function wrapAISDK(ai) {
   };
 }
 
+// src/wrappers/mastra.ts
+var aiSDKFormatWarning = false;
+function wrapMastraAgent(agent, options) {
+  const prefix = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _244 => _244.name]), () => ( _optionalChain([options, 'optionalAccess', _245 => _245.span_name]))), () => ( agent.name)), () => ( "Agent"));
+  if (!hasAllMethods(agent)) {
+    return agent;
+  }
+  if (agent.tools) {
+    agent.__setTools(wrapTools(agent.tools));
+  }
+  return new Proxy(agent, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "generateVNext" && typeof value === "function") {
+        return wrapGenerateVNext(value, target, prefix);
+      }
+      if (prop === "streamVNext" && typeof value === "function") {
+        return wrapStreamVNext(value, target, prefix);
+      }
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+}
+function hasAllMethods(a) {
+  return typeof a.generateVNext === "function" && typeof a.streamVNext === "function";
+}
+function wrapGenerateVNext(original, target, prefix) {
+  return function(...args) {
+    const input = args[0];
+    return traced(
+      async (span) => {
+        const result = await original.apply(target, args);
+        const provider = detectProviderFromResult(result);
+        const model = extractModelFromResult(result);
+        const finishReason = normalizeFinishReason(_optionalChain([result, 'optionalAccess', _246 => _246.finishReason]));
+        const metrics = _optionalChain([result, 'optionalAccess', _247 => _247.usage]) ? normalizeUsageMetrics(
+          result.usage,
+          provider,
+          result.providerMetadata
+        ) : {};
+        span.log({
+          input,
+          output: result,
+          metadata: {
+            agent_name: _nullishCoalesce(target.name, () => ( prefix)),
+            ...provider ? { provider } : {},
+            ...model ? { model } : {},
+            ...finishReason ? { finish_reason: finishReason } : {}
+          },
+          metrics
+        });
+        return result;
+      },
+      {
+        name: `${prefix}.generateVNext`
+      }
+    );
+  };
+}
+function wrapStreamVNext(original, target, prefix) {
+  return function(...args) {
+    const input = args[0];
+    const span = startSpan({
+      name: `${prefix}.streamVNext`,
+      event: {
+        input,
+        metadata: {
+          agent_name: _nullishCoalesce(target.name, () => ( prefix))
+        }
+      }
+    });
+    const baseOpts = typeof args[1] === "object" && args[1] !== null ? args[1] : {};
+    if (baseOpts.format && baseOpts.format !== "aisdk" && !aiSDKFormatWarning) {
+      aiSDKFormatWarning = true;
+      console.warn(
+        `Braintrust Mastra wrapper: For best compatibility, use { format: 'aisdk' } (AI SDK v5) instead of format: '${baseOpts.format}'. See https://mastra.ai/en/docs/frameworks/agentic-uis/ai-sdk for more details.`
+      );
+    }
+    const wrappedOpts = {
+      ...baseOpts,
+      format: baseOpts.format || "aisdk"
+      // Default to AI SDK v5 format if not specified
+    };
+    const userOnChunk = _optionalChain([baseOpts, 'optionalAccess', _248 => _248.onChunk]);
+    const userOnFinish = _optionalChain([baseOpts, 'optionalAccess', _249 => _249.onFinish]);
+    const userOnError = _optionalChain([baseOpts, 'optionalAccess', _250 => _250.onError]);
+    const startTime = Date.now();
+    let receivedFirst = false;
+    wrappedOpts.onChunk = (chunk) => {
+      try {
+        _optionalChain([userOnChunk, 'optionalCall', _251 => _251(chunk)]);
+      } finally {
+        if (!receivedFirst) {
+          receivedFirst = true;
+          span.log({
+            metrics: { time_to_first_token: (Date.now() - startTime) / 1e3 }
+          });
+        }
+      }
+    };
+    wrappedOpts.onFinish = async (event) => {
+      try {
+        await _optionalChain([userOnFinish, 'optionalCall', _252 => _252(event)]);
+      } finally {
+        const e = event;
+        const provider = detectProviderFromResult(e);
+        const model = extractModelFromResult(e);
+        const finishReason = normalizeFinishReason(_optionalChain([e, 'optionalAccess', _253 => _253.finishReason]));
+        const metrics = _optionalChain([e, 'optionalAccess', _254 => _254.usage]) ? normalizeUsageMetrics(e.usage, provider, e.providerMetadata) : {};
+        span.log({
+          output: _nullishCoalesce(_nullishCoalesce(e.text, () => ( e.content)), () => ( e)),
+          metadata: {
+            agent_name: _nullishCoalesce(target.name, () => ( prefix)),
+            ...provider ? { provider } : {},
+            ...model ? { model } : {},
+            ...finishReason ? { finish_reason: finishReason } : {}
+          },
+          metrics
+        });
+        span.end();
+      }
+    };
+    wrappedOpts.onError = async (err) => {
+      try {
+        await _optionalChain([userOnError, 'optionalCall', _255 => _255(err)]);
+      } finally {
+        logError(span, err);
+        span.end();
+      }
+    };
+    return withCurrent(
+      span,
+      () => original.apply(target, [args[0], wrappedOpts, ...args.slice(2)])
+    );
+  };
+}
+
 // src/wrappers/anthropic.ts
 function wrapAnthropic(anthropic) {
   const au = anthropic;
@@ -14920,9 +15274,9 @@ function streamNextProxy(stream, sspan) {
       return result;
     }
     const item = result.value;
-    switch (_optionalChain([item, 'optionalAccess', _239 => _239.type])) {
+    switch (_optionalChain([item, 'optionalAccess', _256 => _256.type])) {
       case "message_start":
-        const msg = _optionalChain([item, 'optionalAccess', _240 => _240.message]);
+        const msg = _optionalChain([item, 'optionalAccess', _257 => _257.message]);
         if (msg) {
           const event = parseEventFromMessage(msg);
           totals = { ...totals, ...event.metrics };
@@ -14930,20 +15284,20 @@ function streamNextProxy(stream, sspan) {
         }
         break;
       case "content_block_delta":
-        if (_optionalChain([item, 'access', _241 => _241.delta, 'optionalAccess', _242 => _242.type]) === "text_delta") {
-          const text = _optionalChain([item, 'optionalAccess', _243 => _243.delta, 'optionalAccess', _244 => _244.text]);
+        if (_optionalChain([item, 'access', _258 => _258.delta, 'optionalAccess', _259 => _259.type]) === "text_delta") {
+          const text = _optionalChain([item, 'optionalAccess', _260 => _260.delta, 'optionalAccess', _261 => _261.text]);
           if (text) {
             deltas.push(text);
           }
         }
         break;
       case "message_delta":
-        const usage = _optionalChain([item, 'optionalAccess', _245 => _245.usage]);
+        const usage = _optionalChain([item, 'optionalAccess', _262 => _262.usage]);
         if (usage) {
           const metrics = parseMetricsFromUsage2(usage);
           totals = { ...totals, ...metrics };
         }
-        const delta = _optionalChain([item, 'optionalAccess', _246 => _246.delta]);
+        const delta = _optionalChain([item, 'optionalAccess', _263 => _263.delta]);
         if (delta) {
           metadata = { ...metadata, ...delta };
         }
@@ -14955,8 +15309,8 @@ function streamNextProxy(stream, sspan) {
   };
 }
 function parseEventFromMessage(message) {
-  const output = _optionalChain([message, 'optionalAccess', _247 => _247.content]) || null;
-  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _248 => _248.usage]));
+  const output = message ? { role: message.role, content: message.content } : null;
+  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _264 => _264.usage]));
   const metas = ["stop_reason", "stop_sequence"];
   const metadata = {};
   for (const m of metas) {
@@ -14995,6 +15349,282 @@ function coalesceInput(messages, system) {
   return input;
 }
 
+// src/wrappers/claude-agent-sdk.ts
+function filterSerializableOptions(options) {
+  const allowedKeys = [
+    "model",
+    "maxTurns",
+    "cwd",
+    "continue",
+    "allowedTools",
+    "disallowedTools",
+    "additionalDirectories",
+    "permissionMode",
+    "debug",
+    "apiKey",
+    "apiKeySource",
+    "agentName",
+    "instructions"
+  ];
+  const filtered = {};
+  for (const key of allowedKeys) {
+    if (options[key] !== void 0) {
+      filtered[key] = options[key];
+    }
+  }
+  return filtered;
+}
+function wrapClaudeAgentQuery(queryFn, defaultThis) {
+  const proxy = new Proxy(queryFn, {
+    apply(target, thisArg, argArray) {
+      const params = _nullishCoalesce(argArray[0], () => ( {}));
+      const { prompt, options = {} } = params;
+      const span = startSpan({
+        name: "Claude Agent",
+        spanAttributes: {
+          type: "task" /* TASK */
+        },
+        event: {
+          input: typeof prompt === "string" ? prompt : { type: "streaming", description: "AsyncIterable<SDKMessage>" },
+          metadata: filterSerializableOptions(options)
+        }
+      });
+      const finalResults = [];
+      let finalUsageMetrics;
+      let accumulatedOutputTokens = 0;
+      let currentMessageId;
+      let currentMessageStartTime = getCurrentUnixTimestamp();
+      const currentMessages = [];
+      const createLLMSpan = async () => {
+        const finalMessageContent = await _createLLMSpanForMessages(
+          currentMessages,
+          prompt,
+          finalResults,
+          options,
+          currentMessageStartTime,
+          await span.export()
+        );
+        if (finalMessageContent) {
+          finalResults.push(finalMessageContent);
+        }
+        const lastMessage = currentMessages[currentMessages.length - 1];
+        if (_optionalChain([lastMessage, 'optionalAccess', _265 => _265.message, 'optionalAccess', _266 => _266.usage])) {
+          const outputTokens = getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
+          accumulatedOutputTokens += outputTokens;
+        }
+        currentMessages.length = 0;
+      };
+      const wrappedGenerator = async function* () {
+        try {
+          const invocationTarget = thisArg === proxy || thisArg === void 0 ? _nullishCoalesce(defaultThis, () => ( thisArg)) : thisArg;
+          const generator = withCurrent(
+            span,
+            () => Reflect.apply(target, invocationTarget, argArray)
+          );
+          for await (const message of generator) {
+            const currentTime = getCurrentUnixTimestamp();
+            const messageId = _optionalChain([message, 'access', _267 => _267.message, 'optionalAccess', _268 => _268.id]);
+            if (messageId && messageId !== currentMessageId) {
+              await createLLMSpan();
+              currentMessageId = messageId;
+              currentMessageStartTime = currentTime;
+            }
+            if (message.type === "assistant" && _optionalChain([message, 'access', _269 => _269.message, 'optionalAccess', _270 => _270.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', _271 => _271.message, 'optionalAccess', _272 => _272.usage])) {
+                  const adjustedTokens = finalUsageMetrics.completion_tokens - accumulatedOutputTokens;
+                  if (adjustedTokens >= 0) {
+                    lastMessage.message.usage.output_tokens = adjustedTokens;
+                  }
+                }
+              }
+              const result_metadata = {};
+              if (message.num_turns !== void 0) {
+                result_metadata.num_turns = message.num_turns;
+              }
+              if (message.session_id !== void 0) {
+                result_metadata.session_id = message.session_id;
+              }
+              if (Object.keys(result_metadata).length > 0) {
+                span.log({
+                  metadata: result_metadata
+                });
+              }
+            }
+            yield message;
+          }
+          await createLLMSpan();
+          span.log({
+            output: finalResults.length > 0 ? finalResults[finalResults.length - 1] : void 0
+          });
+        } catch (error2) {
+          span.log({
+            error: error2 instanceof Error ? error2.message : String(error2)
+          });
+          throw error2;
+        } finally {
+          span.end();
+        }
+      }();
+      return wrappedGenerator;
+    }
+  });
+  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 */
+      }
+    }
+  );
+  return {
+    ...toolDef,
+    handler: wrappedHandler
+  };
+}
+function _buildLLMInput(prompt, conversationHistory) {
+  const promptMessage = typeof prompt === "string" ? { content: prompt, role: "user" } : void 0;
+  const inputParts = [
+    ...promptMessage ? [promptMessage] : [],
+    ...conversationHistory
+  ];
+  return inputParts.length > 0 ? inputParts : void 0;
+}
+function _extractUsageFromMessage(message) {
+  const metrics = {};
+  let usage;
+  if (message.type === "assistant") {
+    usage = _optionalChain([message, 'access', _273 => _273.message, 'optionalAccess', _274 => _274.usage]);
+  } else if (message.type === "result") {
+    usage = message.usage;
+  }
+  if (!usage || typeof usage !== "object") {
+    return metrics;
+  }
+  const inputTokens = getNumberProperty(usage, "input_tokens");
+  if (inputTokens !== void 0) {
+    metrics.prompt_tokens = inputTokens;
+  }
+  const outputTokens = getNumberProperty(usage, "output_tokens");
+  if (outputTokens !== void 0) {
+    metrics.completion_tokens = outputTokens;
+  }
+  const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
+  const cacheCreationTokens = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
+  if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
+    const cacheTokens = extractAnthropicCacheTokens(
+      cacheReadTokens,
+      cacheCreationTokens
+    );
+    Object.assign(metrics, cacheTokens);
+  }
+  if (Object.keys(metrics).length > 0) {
+    Object.assign(metrics, finalizeAnthropicTokens(metrics));
+  }
+  return metrics;
+}
+async function _createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
+  if (messages.length === 0) return void 0;
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _275 => _275.message, 'optionalAccess', _276 => _276.usage])) {
+    return void 0;
+  }
+  const model = lastMessage.message.model || options.model;
+  const usage = _extractUsageFromMessage(lastMessage);
+  const input = _buildLLMInput(prompt, conversationHistory);
+  const outputs = messages.map(
+    (m) => _optionalChain([m, 'access', _277 => _277.message, 'optionalAccess', _278 => _278.content]) && _optionalChain([m, 'access', _279 => _279.message, 'optionalAccess', _280 => _280.role]) ? { content: m.message.content, role: m.message.role } : void 0
+  ).filter((c) => c !== void 0);
+  await traced(
+    (llmSpan) => {
+      llmSpan.log({
+        input,
+        output: outputs,
+        metadata: model ? { model } : void 0,
+        metrics: usage
+      });
+    },
+    {
+      name: "anthropic.messages.create",
+      spanAttributes: {
+        type: "llm" /* LLM */
+      },
+      startTime,
+      parent: parentSpan
+    }
+  );
+  return _optionalChain([lastMessage, 'access', _281 => _281.message, 'optionalAccess', _282 => _282.content]) && _optionalChain([lastMessage, 'access', _283 => _283.message, 'optionalAccess', _284 => _284.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+}
+function wrapClaudeAgentSDK(sdk) {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(sdk, {
+    get(target, prop, receiver) {
+      if (cache.has(prop)) {
+        return cache.get(prop);
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "query" && typeof value === "function") {
+        const wrappedQuery = wrapClaudeAgentQuery(
+          value,
+          target
+        );
+        cache.set(prop, wrappedQuery);
+        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;
+      }
+      if (typeof value === "function") {
+        const bound = value.bind(target);
+        cache.set(prop, bound);
+        return bound;
+      }
+      return value;
+    }
+  });
+}
+
 // src/otel.ts
 var otelApi = null;
 var otelSdk = null;
@@ -15158,8 +15788,8 @@ var BraintrustSpanProcessor = class _BraintrustSpanProcessor {
                   span.instrumentationScope = span.instrumentationLibrary;
                 }
                 if (!span.parentSpanContext && span.parentSpanId) {
-                  const spanContext = _optionalChain([span, 'access', _249 => _249.spanContext, 'optionalCall', _250 => _250()]);
-                  if (_optionalChain([spanContext, 'optionalAccess', _251 => _251.traceId])) {
+                  const spanContext = _optionalChain([span, 'access', _285 => _285.spanContext, 'optionalCall', _286 => _286()]);
+                  if (_optionalChain([spanContext, 'optionalAccess', _287 => _287.traceId])) {
                     span.parentSpanContext = {
                       spanId: span.parentSpanId,
                       traceId: spanContext.traceId
@@ -15218,9 +15848,9 @@ var BraintrustExporter = (_class31 = class _BraintrustExporter {
     }
   }
   
-  __init80() {this.spans = []}
-  __init81() {this.callbacks = []}
-  constructor(options = {}) {;_class31.prototype.__init80.call(this);_class31.prototype.__init81.call(this);
+  __init81() {this.spans = []}
+  __init82() {this.callbacks = []}
+  constructor(options = {}) {;_class31.prototype.__init81.call(this);_class31.prototype.__init82.call(this);
     _BraintrustExporter.checkOtelAvailable();
     this.processor = new BraintrustSpanProcessor(options);
   }
@@ -15400,4 +16030,11 @@ var index_default = exports_node_exports;
 
 
 
-exports.AISpanProcessor = AISpanProcessor; exports.Attachment = Attachment; exports.BaseAttachment = BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BraintrustExporter = BraintrustExporter; exports.BraintrustMiddleware = BraintrustMiddleware; exports.BraintrustSpanProcessor = BraintrustSpanProcessor; exports.BraintrustState = BraintrustState; exports.BraintrustStream = BraintrustStream; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; exports.Dataset = Dataset2; exports.ERR_PERMALINK = ERR_PERMALINK; exports.Eval = Eval; exports.EvalResultWithSummary = EvalResultWithSummary; exports.Experiment = Experiment2; exports.ExternalAttachment = ExternalAttachment; exports.FailedHTTPResponse = FailedHTTPResponse; exports.INTERNAL_BTQL_LIMIT = INTERNAL_BTQL_LIMIT; exports.LEGACY_CACHED_HEADER = LEGACY_CACHED_HEADER; exports.LazyValue = LazyValue; exports.Logger = Logger; exports.NOOP_SPAN = NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = NOOP_SPAN_PERMALINK; exports.NoopSpan = NoopSpan; exports.Project = Project2; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = Prompt2; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = ReadonlyAttachment; exports.ReadonlyExperiment = ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanImpl = SpanImpl; exports.TestBackgroundLogger = TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.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.default = index_default; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.deserializePlainStringAsJSON = deserializePlainStringAsJSON; exports.devNullWritableStream = devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.flush = flush; exports.getPromptVersions = getPromptVersions; exports.getSpanParentObject = getSpanParentObject; exports.graph = graph_framework_exports; exports.init = init; exports.initDataset = initDataset; exports.initExperiment = initExperiment; exports.initFunction = initFunction; exports.initLogger = initLogger; exports.invoke = invoke; exports.loadPrompt = loadPrompt; exports.log = log; exports.logError = logError; exports.login = login; exports.loginToState = loginToState; exports.newId = newId; exports.parseCachedHeader = parseCachedHeader; exports.permalink = permalink; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.renderMessage = renderMessage; exports.renderPromptParams = renderPromptParams; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = setFetch; exports.setMaskingFunction = setMaskingFunction; exports.spanComponentsToObjectId = spanComponentsToObjectId; exports.startSpan = startSpan; exports.summarize = summarize; exports.toolFunctionDefinitionSchema = ToolFunctionDefinition; exports.traceable = traceable; exports.traced = traced; exports.updateSpan = updateSpan; exports.withCurrent = withCurrent; exports.withDataset = withDataset; exports.withExperiment = withExperiment; exports.withLogger = withLogger; exports.withParent = withParent; exports.wrapAISDK = wrapAISDK; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAnthropic = wrapAnthropic; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapTraced = wrapTraced;
+
+
+
+
+
+
+
+exports.AISpanProcessor = AISpanProcessor; exports.Attachment = Attachment; exports.BaseAttachment = BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BraintrustExporter = BraintrustExporter; exports.BraintrustMiddleware = BraintrustMiddleware; exports.BraintrustSpanProcessor = BraintrustSpanProcessor; exports.BraintrustState = BraintrustState; exports.BraintrustStream = BraintrustStream; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; 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.INTERNAL_BTQL_LIMIT = INTERNAL_BTQL_LIMIT; exports.LEGACY_CACHED_HEADER = LEGACY_CACHED_HEADER; exports.LazyValue = LazyValue; exports.Logger = Logger; exports.NOOP_SPAN = NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = NOOP_SPAN_PERMALINK; exports.NoopSpan = NoopSpan; exports.OTELIDGenerator = OTELIDGenerator; exports.Project = Project2; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = Prompt2; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = ReadonlyAttachment; exports.ReadonlyExperiment = ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanImpl = SpanImpl; exports.TestBackgroundLogger = TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.UUIDGenerator = UUIDGenerator; exports.X_CACHED_HEADER = X_CACHED_HEADER; exports._exportsForTestingOnly = _exportsForTestingOnly; exports._internalGetGlobalState = _internalGetGlobalState; exports._internalSetInitialState = _internalSetInitialState; exports.braintrustStreamChunkSchema = braintrustStreamChunkSchema; exports.buildLocalSummary = buildLocalSummary; exports.createFinalValuePassThroughStream = createFinalValuePassThroughStream; exports.currentExperiment = currentExperiment; exports.currentLogger = currentLogger; exports.currentSpan = currentSpan; exports.deepCopyEvent = deepCopyEvent; exports.default = index_default; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.deserializePlainStringAsJSON = deserializePlainStringAsJSON; exports.devNullWritableStream = devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.flush = flush; exports.getIdGenerator = getIdGenerator; exports.getPromptVersions = getPromptVersions; exports.getSpanParentObject = getSpanParentObject; exports.graph = graph_framework_exports; exports.init = init; exports.initDataset = initDataset; exports.initExperiment = initExperiment; exports.initFunction = initFunction; exports.initLogger = initLogger; exports.invoke = invoke; exports.loadPrompt = loadPrompt; exports.log = log; exports.logError = logError; exports.login = login; exports.loginToState = loginToState; exports.newId = newId; exports.parseCachedHeader = parseCachedHeader; exports.permalink = permalink; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.renderMessage = renderMessage; exports.renderPromptParams = renderPromptParams; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = setFetch; exports.setMaskingFunction = setMaskingFunction; exports.spanComponentsToObjectId = spanComponentsToObjectId; exports.startSpan = startSpan; exports.summarize = summarize; exports.toolFunctionDefinitionSchema = ToolFunctionDefinition; exports.traceable = traceable; exports.traced = traced; exports.updateSpan = updateSpan; exports.withCurrent = withCurrent; exports.withDataset = withDataset; exports.withExperiment = withExperiment; exports.withLogger = withLogger; exports.withParent = withParent; exports.wrapAISDK = wrapAISDK; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAnthropic = wrapAnthropic; exports.wrapClaudeAgentSDK = wrapClaudeAgentSDK; exports.wrapMastraAgent = wrapMastraAgent; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapTraced = wrapTraced;