braintrust 3.5.0 → 3.6.0

package/dev/dist/index.js

@@ -2,6 +2,64 @@
 var _nodeasync_hooks = require('node:async_hooks');
 var _nodediagnostics_channel = require('node:diagnostics_channel'); var diagnostics_channel = _interopRequireWildcard(_nodediagnostics_channel);
 var _nodepath = require('node:path'); var path = _interopRequireWildcard(_nodepath);
+
+// src/auto-instrumentations/patch-tracing-channel.ts
+function patchTracingChannel(tracingChannelFn) {
+  const dummyChannel = tracingChannelFn("__braintrust_probe__");
+  const TracingChannel = _optionalChain([dummyChannel, 'optionalAccess', _2 => _2.constructor]);
+  if (!_optionalChain([TracingChannel, 'optionalAccess', _3 => _3.prototype])) {
+    return;
+  }
+  if (!Object.getOwnPropertyDescriptor(TracingChannel.prototype, "hasSubscribers")) {
+    Object.defineProperty(TracingChannel.prototype, "hasSubscribers", {
+      configurable: true,
+      enumerable: false,
+      get() {
+        return Boolean(
+          _optionalChain([this, 'access', _4 => _4.start, 'optionalAccess', _5 => _5.hasSubscribers]) || _optionalChain([this, 'access', _6 => _6.end, 'optionalAccess', _7 => _7.hasSubscribers]) || _optionalChain([this, 'access', _8 => _8.asyncStart, 'optionalAccess', _9 => _9.hasSubscribers]) || _optionalChain([this, 'access', _10 => _10.asyncEnd, 'optionalAccess', _11 => _11.hasSubscribers]) || _optionalChain([this, 'access', _12 => _12.error, 'optionalAccess', _13 => _13.hasSubscribers])
+        );
+      }
+    });
+  }
+  if (TracingChannel.prototype.tracePromise) {
+    TracingChannel.prototype.tracePromise = function(fn, context = {}, thisArg, ...args) {
+      const { start, end, asyncStart, asyncEnd, error } = this;
+      function reject2(err) {
+        context.error = err;
+        _optionalChain([error, 'optionalAccess', _14 => _14.publish, 'call', _15 => _15(context)]);
+        _optionalChain([asyncStart, 'optionalAccess', _16 => _16.publish, 'call', _17 => _17(context)]);
+        _optionalChain([asyncEnd, 'optionalAccess', _18 => _18.publish, 'call', _19 => _19(context)]);
+        return Promise.reject(err);
+      }
+      function resolve(result) {
+        context.result = result;
+        _optionalChain([asyncStart, 'optionalAccess', _20 => _20.publish, 'call', _21 => _21(context)]);
+        _optionalChain([asyncEnd, 'optionalAccess', _22 => _22.publish, 'call', _23 => _23(context)]);
+        return result;
+      }
+      return start.runStores(context, () => {
+        try {
+          const result = Reflect.apply(fn, thisArg, args);
+          _optionalChain([end, 'optionalAccess', _24 => _24.publish, 'call', _25 => _25(context)]);
+          if (result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function") {
+            return result.then(resolve, reject2);
+          }
+          context.result = result;
+          _optionalChain([asyncStart, 'optionalAccess', _26 => _26.publish, 'call', _27 => _27(context)]);
+          _optionalChain([asyncEnd, 'optionalAccess', _28 => _28.publish, 'call', _29 => _29(context)]);
+          return result;
+        } catch (err) {
+          context.error = err;
+          _optionalChain([error, 'optionalAccess', _30 => _30.publish, 'call', _31 => _31(context)]);
+          _optionalChain([end, 'optionalAccess', _32 => _32.publish, 'call', _33 => _33(context)]);
+          throw err;
+        }
+      });
+    };
+  }
+}
+
+// src/node/config.ts
 var _promises = require('node:fs/promises'); var fs = _interopRequireWildcard(_promises);
 var _nodeos = require('node:os'); var os = _interopRequireWildcard(_nodeos);
 var _nodefs = require('node:fs'); var fsSync = _interopRequireWildcard(_nodefs);
@@ -157,8 +215,8 @@ function setDebugLogStateResolver(resolver) {
   debugLogStateResolver = resolver;
 }
 function resolveDebugLogLevel(state) {
-  const stateLevel = _optionalChain([state, 'optionalAccess', _2 => _2.getDebugLogLevel, 'optionalCall', _3 => _3()]);
-  const hasStateOverride = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _4 => _4.hasDebugLogLevelOverride, 'optionalCall', _5 => _5()]), () => ( false));
+  const stateLevel = _optionalChain([state, 'optionalAccess', _34 => _34.getDebugLogLevel, 'optionalCall', _35 => _35()]);
+  const hasStateOverride = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _36 => _36.hasDebugLogLevelOverride, 'optionalCall', _37 => _37()]), () => ( false));
   if (hasStateOverride) {
     return stateLevel;
   }
@@ -187,7 +245,7 @@ function emit(method, state, args) {
   }
 }
 function createDebugLogger(state) {
-  const resolveState = () => _nullishCoalesce(state, () => ( _optionalChain([debugLogStateResolver, 'optionalCall', _6 => _6()])));
+  const resolveState = () => _nullishCoalesce(state, () => ( _optionalChain([debugLogStateResolver, 'optionalCall', _38 => _38()])));
   return {
     info(...args) {
       emit("info", resolveState(), args);
@@ -232,7 +290,7 @@ async function getBaseBranch(remote = void 0) {
     if (git === null) {
       throw new Error("Not in a git repo");
     }
-    const remoteName = await _asyncNullishCoalesce(remote, async () => ( await _asyncOptionalChain([(await git.getRemotes()), 'access', async _7 => _7[0], 'optionalAccess', async _8 => _8.name])));
+    const remoteName = await _asyncNullishCoalesce(remote, async () => ( await _asyncOptionalChain([(await git.getRemotes()), 'access', async _39 => _39[0], 'optionalAccess', async _40 => _40.name])));
     if (!remoteName) {
       throw new Error("No remote found");
     }
@@ -325,7 +383,7 @@ async function getRepoInfo(settings) {
     return repo;
   }
   let sanitized = {};
-  _optionalChain([settings, 'access', _9 => _9.fields, 'optionalAccess', _10 => _10.forEach, 'call', _11 => _11((field) => {
+  _optionalChain([settings, 'access', _41 => _41.fields, 'optionalAccess', _42 => _42.forEach, 'call', _43 => _43((field) => {
     sanitized = { ...sanitized, [field]: repo[field] };
   })]);
   return sanitized;
@@ -411,9 +469,9 @@ function getCallerLocation() {
   const entries = getStackTrace();
   for (const frame of entries) {
     if (thisDir === void 0) {
-      thisDir = _optionalChain([isomorph_default, 'access', _12 => _12.pathDirname, 'optionalCall', _13 => _13(frame.fileName)]);
+      thisDir = _optionalChain([isomorph_default, 'access', _44 => _44.pathDirname, 'optionalCall', _45 => _45(frame.fileName)]);
     }
-    if (_optionalChain([isomorph_default, 'access', _14 => _14.pathDirname, 'optionalCall', _15 => _15(frame.fileName)]) !== thisDir) {
+    if (_optionalChain([isomorph_default, 'access', _46 => _46.pathDirname, 'optionalCall', _47 => _47(frame.fileName)]) !== thisDir) {
       return {
         caller_functionname: frame.functionName,
         caller_filename: frame.fileName,
@@ -660,7 +718,7 @@ var SpanComponentsV1 = class _SpanComponentsV1 {
     return {
       objectType: this.objectType,
       objectId: this.objectId,
-      rowIds: _optionalChain([this, 'access', _16 => _16.rowIds, 'optionalAccess', _17 => _17.toObject, 'call', _18 => _18()])
+      rowIds: _optionalChain([this, 'access', _48 => _48.rowIds, 'optionalAccess', _49 => _49.toObject, 'call', _50 => _50()])
     };
   }
 };
@@ -874,7 +932,7 @@ var SpanComponentsV2 = class _SpanComponentsV2 {
       objectType: this.objectType,
       objectId: this.objectId,
       computeObjectMetadataArgs: this.computeObjectMetadataArgs,
-      rowIds: _optionalChain([this, 'access', _19 => _19.rowIds, 'optionalAccess', _20 => _20.toObject, 'call', _21 => _21()])
+      rowIds: _optionalChain([this, 'access', _51 => _51.rowIds, 'optionalAccess', _52 => _52.toObject, 'call', _53 => _53()])
     };
   }
 };
@@ -1414,20 +1472,20 @@ function slugify(text, options) {
     \u00FF: "y"
   };
   const replacement = "-";
-  const trim = _optionalChain([options, 'optionalAccess', _22 => _22.trim]) !== false;
+  const trim = _optionalChain([options, 'optionalAccess', _54 => _54.trim]) !== false;
   let slug = text.normalize().split("").reduce((result, ch) => {
     const mapped = charMap[ch] || ch;
     const appendChar = mapped === replacement ? " " : mapped;
     return result + appendChar.replace(/[^\w\s$*_+~.()'"!\-:@]+/g, "");
   }, "");
-  if (_optionalChain([options, 'optionalAccess', _23 => _23.strict])) {
+  if (_optionalChain([options, 'optionalAccess', _55 => _55.strict])) {
     slug = slug.replace(/[^A-Za-z0-9\s]/g, "");
   }
   if (trim) {
     slug = slug.trim();
   }
   slug = slug.replace(/\s+/g, replacement);
-  if (_optionalChain([options, 'optionalAccess', _24 => _24.lower])) {
+  if (_optionalChain([options, 'optionalAccess', _56 => _56.lower])) {
     slug = slug.toLowerCase();
   }
   return slug;
@@ -3566,8 +3624,8 @@ var mustachePlugin = {
   defaultOptions: { strict: true, escape: jsonEscape },
   createRenderer() {
     const opts = _nullishCoalesce(this.defaultOptions, () => ( {}));
-    const escapeFn = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _25 => _25.escape]), () => ( jsonEscape));
-    const strictDefault = typeof _optionalChain([opts, 'optionalAccess', _26 => _26.strict]) === "boolean" ? opts.strict : true;
+    const escapeFn = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _57 => _57.escape]), () => ( jsonEscape));
+    const strictDefault = typeof _optionalChain([opts, 'optionalAccess', _58 => _58.strict]) === "boolean" ? opts.strict : true;
     return {
       render(template, variables, escape, strict) {
         const esc = _nullishCoalesce(escape, () => ( escapeFn));
@@ -3601,7 +3659,7 @@ var TemplatePluginRegistry = (_class5 = class {constructor() { _class5.prototype
     return Array.from(this.plugins.keys());
   }
   get(name) {
-    return _optionalChain([this, 'access', _27 => _27.plugins, 'access', _28 => _28.get, 'call', _29 => _29(name), 'optionalAccess', _30 => _30.renderer]);
+    return _optionalChain([this, 'access', _59 => _59.plugins, 'access', _60 => _60.get, 'call', _61 => _61(name), 'optionalAccess', _62 => _62.renderer]);
   }
   isRegistered(name) {
     return this.plugins.has(name);
@@ -4235,7 +4293,7 @@ var SpanCache = (_class6 = class {
   // Small in-memory index tracking which rootSpanIds have data
   __init14() {this.rootSpanIndex = /* @__PURE__ */ new Set()}
   constructor(options) {;_class6.prototype.__init8.call(this);_class6.prototype.__init9.call(this);_class6.prototype.__init10.call(this);_class6.prototype.__init11.call(this);_class6.prototype.__init12.call(this);_class6.prototype.__init13.call(this);_class6.prototype.__init14.call(this);_class6.prototype.__init15.call(this);_class6.prototype.__init16.call(this);_class6.prototype.__init17.call(this);
-    this._explicitlyDisabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _31 => _31.disabled]), () => ( false));
+    this._explicitlyDisabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _63 => _63.disabled]), () => ( false));
   }
   /**
    * Disable the cache at runtime. This is called automatically when
@@ -4506,6 +4564,9 @@ var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
 var LOGS3_OVERFLOW_REFERENCE_TYPE = "logs3_overflow";
 var BRAINTRUST_PARAMS = Object.keys(BraintrustModelParams.shape);
+var RESET_CONTEXT_MANAGER_STATE = Symbol.for(
+  "braintrust.resetContextManagerState"
+);
 var DEFAULT_MAX_REQUEST_SIZE = 6 * 1024 * 1024;
 var parametersRowSchema = _v3.z.object({
   id: _v3.z.string().uuid(),
@@ -4568,13 +4629,18 @@ function applyMaskingToField(maskingFunction, data, fieldName) {
     return `ERROR: Failed to mask field '${fieldName}' - ${errorType}`;
   }
 }
+var BRAINTRUST_CURRENT_SPAN_STORE = Symbol.for(
+  "braintrust.currentSpanStore"
+);
 var ContextManager = class {
 };
 var BraintrustContextManager = class extends ContextManager {
   
+  
   constructor() {
     super();
     this._currentSpan = isomorph_default.newAsyncLocalStorage();
+    this[BRAINTRUST_CURRENT_SPAN_STORE] = this._currentSpan;
   }
   getParentSpanIds() {
     const currentSpan2 = this._currentSpan.getStore();
@@ -4625,7 +4691,7 @@ var NoopSpan = (_class7 = class {
     return this;
   }
   end(args) {
-    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _32 => _32.endTime]), () => ( getCurrentUnixTimestamp()));
+    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _64 => _64.endTime]), () => ( getCurrentUnixTimestamp()));
   }
   async export() {
     return "";
@@ -4781,6 +4847,9 @@ var BraintrustState = (_class8 = class _BraintrustState {
   resetIdGenState() {
     this._idGenerator = null;
   }
+  [RESET_CONTEXT_MANAGER_STATE]() {
+    this._contextManager = null;
+  }
   get idGenerator() {
     if (this._idGenerator === null) {
       this._idGenerator = getIdGenerator();
@@ -4887,8 +4956,8 @@ var BraintrustState = (_class8 = class _BraintrustState {
   setFetch(fetch2) {
     this.loginParams.fetch = fetch2;
     this.fetch = fetch2;
-    _optionalChain([this, 'access', _33 => _33._apiConn, 'optionalAccess', _34 => _34.setFetch, 'call', _35 => _35(fetch2)]);
-    _optionalChain([this, 'access', _36 => _36._appConn, 'optionalAccess', _37 => _37.setFetch, 'call', _38 => _38(fetch2)]);
+    _optionalChain([this, 'access', _65 => _65._apiConn, 'optionalAccess', _66 => _66.setFetch, 'call', _67 => _67(fetch2)]);
+    _optionalChain([this, 'access', _68 => _68._appConn, 'optionalAccess', _69 => _69.setFetch, 'call', _70 => _70(fetch2)]);
   }
   setMaskingFunction(maskingFunction) {
     this.bgLogger().setMaskingFunction(maskingFunction);
@@ -5590,8 +5659,8 @@ function _getOrgName(orgName) {
   return orgName || isomorph_default.getEnv("BRAINTRUST_ORG_NAME") || void 0;
 }
 function _getLinkBaseUrl(state, linkArgs) {
-  const appUrl = _getAppUrl(state.appUrl || _optionalChain([linkArgs, 'optionalAccess', _39 => _39.app_url]));
-  const orgName = _getOrgName(state.orgName || _optionalChain([linkArgs, 'optionalAccess', _40 => _40.org_name]));
+  const appUrl = _getAppUrl(state.appUrl || _optionalChain([linkArgs, 'optionalAccess', _71 => _71.app_url]));
+  const orgName = _getOrgName(state.orgName || _optionalChain([linkArgs, 'optionalAccess', _72 => _72.org_name]));
   if (!orgName) {
     return null;
   }
@@ -5601,9 +5670,9 @@ async function permalink(slug, opts) {
   if (slug === "") {
     return NOOP_SPAN_PERMALINK;
   }
-  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _41 => _41.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _73 => _73.state]), () => ( _globalState));
   const getOrgName = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _42 => _42.orgName])) {
+    if (_optionalChain([opts, 'optionalAccess', _74 => _74.orgName])) {
       return opts.orgName;
     }
     await state.login({});
@@ -5613,7 +5682,7 @@ async function permalink(slug, opts) {
     return state.orgName;
   };
   const getAppUrl = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _43 => _43.appUrl])) {
+    if (_optionalChain([opts, 'optionalAccess', _75 => _75.appUrl])) {
       return opts.appUrl;
     }
     await state.login({});
@@ -5748,7 +5817,7 @@ var Logger = (_class9 = class {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _44 => _44.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _76 => _76.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`"
       );
@@ -5816,12 +5885,12 @@ var Logger = (_class9 = class {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _45 => _45.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _77 => _77.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: this.computeMetadataArgs,
-        parentSpanIds: _optionalChain([args, 'optionalAccess', _46 => _46.parentSpanIds]),
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _47 => _47.propagatedEvent])
+        parentSpanIds: _optionalChain([args, 'optionalAccess', _78 => _78.parentSpanIds]),
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _79 => _79.propagatedEvent])
       }),
       defaultRootType: "task" /* TASK */
     });
@@ -6156,7 +6225,7 @@ var HTTPBackgroundLogger = (_class10 = class _HTTPBackgroundLogger {
       this.queue.clear();
       return;
     }
-    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _48 => _48.batchSize]), () => ( this.defaultBatchSize));
+    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _80 => _80.batchSize]), () => ( this.defaultBatchSize));
     const wrappedItems = this.queue.drain();
     if (wrappedItems.length === 0) {
       return;
@@ -6470,10 +6539,10 @@ Error: ${errorText}`;
         } catch (err) {
           if (err instanceof AggregateError) {
             for (const e of err.errors) {
-              _optionalChain([this, 'access', _49 => _49.onFlushError, 'optionalCall', _50 => _50(e)]);
+              _optionalChain([this, 'access', _81 => _81.onFlushError, 'optionalCall', _82 => _82(e)]);
             }
           } else {
-            _optionalChain([this, 'access', _51 => _51.onFlushError, 'optionalCall', _52 => _52(err)]);
+            _optionalChain([this, 'access', _83 => _83.onFlushError, 'optionalCall', _84 => _84(err)]);
           }
           this.activeFlushError = err;
         } finally {
@@ -6900,24 +6969,24 @@ async function loginToState(options = {}) {
   return state;
 }
 function currentExperiment(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _85 => _85.state]), () => ( _globalState));
   return state.currentExperiment;
 }
 function currentLogger(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.state]), () => ( _globalState));
-  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _55 => _55.asyncFlush]));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _86 => _86.state]), () => ( _globalState));
+  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _87 => _87.asyncFlush]));
 }
 function currentSpan(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _56 => _56.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _88 => _88.state]), () => ( _globalState));
   return _nullishCoalesce(state.contextManager.getCurrentSpan(), () => ( NOOP_SPAN));
 }
 function getSpanParentObject(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _57 => _57.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _89 => _89.state]), () => ( _globalState));
   const parentSpan = currentSpan({ state });
   if (!Object.is(parentSpan, NOOP_SPAN)) {
     return parentSpan;
   }
-  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _58 => _58.parent]), () => ( state.currentParent.getStore()));
+  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _90 => _90.parent]), () => ( state.currentParent.getStore()));
   if (parentStr) return getSpanComponentsClass().fromStr(parentStr);
   const experiment = currentExperiment();
   if (experiment) {
@@ -6946,7 +7015,7 @@ function traced(callback, args) {
   const { span, isSyncFlushLogger } = startSpanAndIsLogger(args);
   const ret = runCatchFinally(
     () => {
-      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _59 => _59.setCurrent]), () => ( true))) {
+      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _91 => _91.setCurrent]), () => ( true))) {
         return withCurrent(span, callback);
       } else {
         return callback(span);
@@ -6958,7 +7027,7 @@ function traced(callback, args) {
     },
     () => span.end()
   );
-  if (_optionalChain([args, 'optionalAccess', _60 => _60.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _61 => _61.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _92 => _92.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _93 => _93.asyncFlush])) {
     return ret;
   } else {
     return (async () => {
@@ -6974,14 +7043,14 @@ function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
 async function flush(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _94 => _94.state]), () => ( _globalState));
   return await state.bgLogger().flush();
 }
 function startSpanAndIsLogger(args) {
-  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _63 => _63.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _95 => _95.state]), () => ( _globalState));
   const parentObject = getSpanParentObject({
-    asyncFlush: _optionalChain([args, 'optionalAccess', _64 => _64.asyncFlush]),
-    parent: _optionalChain([args, 'optionalAccess', _65 => _65.parent]),
+    asyncFlush: _optionalChain([args, 'optionalAccess', _96 => _96.asyncFlush]),
+    parent: _optionalChain([args, 'optionalAccess', _97 => _97.parent]),
     state
   });
   if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
@@ -6998,14 +7067,14 @@ function startSpanAndIsLogger(args) {
       ),
       parentComputeObjectMetadataArgs: _nullishCoalesce(parentObject.data.compute_object_metadata_args, () => ( void 0)),
       parentSpanIds,
-      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _66 => _66.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _98 => _98.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', _67 => _67.asyncFlush]) === false
+      _optionalChain([args, 'optionalAccess', _99 => _99.asyncFlush]) === false
     };
   } else {
     const span = parentObject.startSpan(args);
@@ -7153,10 +7222,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _68 => _68.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (_optionalChain([value, 'optionalAccess', _100 => _100.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _69 => _69.reference, 'optionalAccess', _70 => _70.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _71 => _71.uploader])) {
+    if (_optionalChain([value, 'optionalAccess', _101 => _101.reference, 'optionalAccess', _102 => _102.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _103 => _103.uploader])) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -7240,7 +7309,7 @@ var ObjectFetcher = (_class11 = class {
     const state = await this.getState();
     const objectId = await this.id;
     const batchLimit = _nullishCoalesce(batchSize, () => ( DEFAULT_FETCH_BATCH_SIZE));
-    const internalLimit = _optionalChain([this, 'access', _72 => _72._internal_btql, 'optionalAccess', _73 => _73.limit]);
+    const internalLimit = _optionalChain([this, 'access', _104 => _104._internal_btql, 'optionalAccess', _105 => _105.limit]);
     const limit = batchSize !== void 0 ? batchSize : _nullishCoalesce(internalLimit, () => ( batchLimit));
     const internalBtqlWithoutReservedQueryKeys = Object.fromEntries(
       Object.entries(_nullishCoalesce(this._internal_btql, () => ( {}))).filter(
@@ -7314,7 +7383,7 @@ var ObjectFetcher = (_class11 = class {
       }
       return;
     }
-    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _74 => _74.batchSize]))) {
+    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _106 => _106.batchSize]))) {
       yield record;
     }
   }
@@ -7324,7 +7393,7 @@ var ObjectFetcher = (_class11 = class {
   async fetchedData(options) {
     if (this._fetchedData === void 0) {
       const data = [];
-      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _75 => _75.batchSize]))) {
+      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _107 => _107.batchSize]))) {
         data.push(record);
       }
       this._fetchedData = data;
@@ -7419,7 +7488,7 @@ var Experiment2 = (_class12 = class extends ObjectFetcher {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _76 => _76.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _108 => _108.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`"
       );
@@ -7472,12 +7541,12 @@ var Experiment2 = (_class12 = class extends ObjectFetcher {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _77 => _77.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _109 => _109.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: void 0,
         parentSpanIds: void 0,
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _78 => _78.propagatedEvent])
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _110 => _110.propagatedEvent])
       }),
       defaultRootType: "eval" /* EVAL */
     });
@@ -7821,7 +7890,7 @@ var SpanImpl = (_class13 = class _SpanImpl {
       ...serializableInternalData,
       [IS_MERGE_FIELD]: this.isMerge
     });
-    if (typeof _optionalChain([partialRecord, 'access', _79 => _79.metrics, 'optionalAccess', _80 => _80.end]) === "number") {
+    if (typeof _optionalChain([partialRecord, 'access', _111 => _111.metrics, 'optionalAccess', _112 => _112.end]) === "number") {
       this.loggedEndTime = partialRecord.metrics.end;
     }
     if (this.parentObjectType === 1 /* EXPERIMENT */) {
@@ -7881,18 +7950,18 @@ var SpanImpl = (_class13 = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _81 => _81.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _113 => _113.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this._state,
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _82 => _82.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _114 => _114.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _83 => _83.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _115 => _115.propagatedEvent]), () => ( this.propagatedEvent))
       })
     });
   }
@@ -7906,12 +7975,12 @@ var SpanImpl = (_class13 = class _SpanImpl {
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _84 => _84.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _116 => _116.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _85 => _85.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _117 => _117.propagatedEvent]), () => ( this.propagatedEvent))
       }),
       spanId
     });
@@ -7920,7 +7989,7 @@ var SpanImpl = (_class13 = class _SpanImpl {
     let endTime;
     let internalData = {};
     if (!this.loggedEndTime) {
-      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _86 => _86.endTime]), () => ( getCurrentUnixTimestamp()));
+      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _118 => _118.endTime]), () => ( getCurrentUnixTimestamp()));
       internalData = { metrics: { end: endTime } };
     } else {
       endTime = this.loggedEndTime;
@@ -7971,8 +8040,8 @@ var SpanImpl = (_class13 = class _SpanImpl {
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
       case 2 /* PROJECT_LOGS */: {
-        const projectID = _optionalChain([args, 'optionalAccess', _87 => _87.project_id]) || this.parentObjectId.getSync().value;
-        const projectName = _optionalChain([args, 'optionalAccess', _88 => _88.project_name]);
+        const projectID = _optionalChain([args, 'optionalAccess', _119 => _119.project_id]) || this.parentObjectId.getSync().value;
+        const projectName = _optionalChain([args, 'optionalAccess', _120 => _120.project_name]);
         if (projectID) {
           return `${baseUrl}/object?object_type=project_logs&object_id=${projectID}&id=${this._id}`;
         } else if (projectName) {
@@ -7982,7 +8051,7 @@ var SpanImpl = (_class13 = class _SpanImpl {
         }
       }
       case 1 /* EXPERIMENT */: {
-        const expID = _optionalChain([args, 'optionalAccess', _89 => _89.experiment_id]) || _optionalChain([this, 'access', _90 => _90.parentObjectId, 'optionalAccess', _91 => _91.getSync, 'call', _92 => _92(), 'optionalAccess', _93 => _93.value]);
+        const expID = _optionalChain([args, 'optionalAccess', _121 => _121.experiment_id]) || _optionalChain([this, 'access', _122 => _122.parentObjectId, 'optionalAccess', _123 => _123.getSync, 'call', _124 => _124(), 'optionalAccess', _125 => _125.value]);
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
         } else {
@@ -8482,16 +8551,16 @@ var Prompt2 = (_class15 = class _Prompt {
     return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
   }
   get prompt() {
-    return _optionalChain([this, 'access', _94 => _94.getParsedPromptData, 'call', _95 => _95(), 'optionalAccess', _96 => _96.prompt]);
+    return _optionalChain([this, 'access', _126 => _126.getParsedPromptData, 'call', _127 => _127(), 'optionalAccess', _128 => _128.prompt]);
   }
   get version() {
     return this.metadata[TRANSACTION_ID_FIELD];
   }
   get options() {
-    return _optionalChain([this, 'access', _97 => _97.getParsedPromptData, 'call', _98 => _98(), 'optionalAccess', _99 => _99.options]) || {};
+    return _optionalChain([this, 'access', _129 => _129.getParsedPromptData, 'call', _130 => _130(), 'optionalAccess', _131 => _131.options]) || {};
   }
   get templateFormat() {
-    return _optionalChain([this, 'access', _100 => _100.getParsedPromptData, 'call', _101 => _101(), 'optionalAccess', _102 => _102.template_format]);
+    return _optionalChain([this, 'access', _132 => _132.getParsedPromptData, 'call', _133 => _133(), 'optionalAccess', _134 => _134.template_format]);
   }
   get promptData() {
     return this.getParsedPromptData();
@@ -8653,7 +8722,7 @@ var Prompt2 = (_class15 = class _Prompt {
       return {
         type: "chat",
         messages,
-        ..._optionalChain([prompt, 'access', _103 => _103.tools, 'optionalAccess', _104 => _104.trim, 'call', _105 => _105()]) ? {
+        ..._optionalChain([prompt, 'access', _135 => _135.tools, 'optionalAccess', _136 => _136.trim, 'call', _137 => _137()]) ? {
           tools: render(prompt.tools)
         } : void 0
       };
@@ -8869,7 +8938,7 @@ function getChannelSpanInfo(event) {
   if (isObject(event.span_info)) {
     return event.span_info;
   }
-  const firstArg = _optionalChain([event, 'access', _106 => _106.arguments, 'optionalAccess', _107 => _107[0]]);
+  const firstArg = _optionalChain([event, 'access', _138 => _138.arguments, 'optionalAccess', _139 => _139[0]]);
   if (hasChannelSpanInfo(firstArg)) {
     return firstArg.span_info;
   }
@@ -8880,13 +8949,13 @@ function buildStartSpanArgs(config, event) {
   const spanAttributes = {
     type: config.type
   };
-  if (isObject(_optionalChain([spanInfo, 'optionalAccess', _108 => _108.spanAttributes]))) {
+  if (isObject(_optionalChain([spanInfo, 'optionalAccess', _140 => _140.spanAttributes]))) {
     mergeDicts(spanAttributes, spanInfo.spanAttributes);
   }
   return {
-    name: typeof _optionalChain([spanInfo, 'optionalAccess', _109 => _109.name]) === "string" && spanInfo.name ? spanInfo.name : config.name,
+    name: typeof _optionalChain([spanInfo, 'optionalAccess', _141 => _141.name]) === "string" && spanInfo.name ? spanInfo.name : config.name,
     spanAttributes,
-    spanInfoMetadata: isObject(_optionalChain([spanInfo, 'optionalAccess', _110 => _110.metadata])) ? spanInfo.metadata : void 0
+    spanInfoMetadata: isObject(_optionalChain([spanInfo, 'optionalAccess', _142 => _142.metadata])) ? spanInfo.metadata : void 0
   };
 }
 function mergeInputMetadata(metadata, spanInfoMetadata) {
@@ -8976,7 +9045,7 @@ var BasePlugin = (_class17 = class {constructor() { _class17.prototype.__init62.
         try {
           const output = config.extractOutput(event.result, event);
           const metrics = config.extractMetrics(event.result, startTime, event);
-          const metadata = _optionalChain([config, 'access', _111 => _111.extractMetadata, 'optionalCall', _112 => _112(event.result, event)]);
+          const metadata = _optionalChain([config, 'access', _143 => _143.extractMetadata, 'optionalCall', _144 => _144(event.result, event)]);
           span.log({
             output,
             ...metadata !== void 0 ? { metadata } : {},
@@ -9283,6 +9352,36 @@ function startSpanForEvent(config, event, channelName) {
   }
   return { span, startTime };
 }
+function ensureSpanStateForEvent(states, config, event, channelName) {
+  const key = event;
+  const existing = states.get(key);
+  if (existing) {
+    return existing;
+  }
+  const created = startSpanForEvent(config, event, channelName);
+  states.set(key, created);
+  return created;
+}
+function bindCurrentSpanStoreToStart(tracingChannel2, states, config, channelName) {
+  const state = _internalGetGlobalState();
+  const startChannel = tracingChannel2.start;
+  const currentSpanStore = _optionalChain([state, 'optionalAccess', _145 => _145.contextManager]) ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (!currentSpanStore || !startChannel) {
+    return void 0;
+  }
+  startChannel.bindStore(
+    currentSpanStore,
+    (event) => ensureSpanStateForEvent(
+      states,
+      config,
+      event,
+      channelName
+    ).span
+  );
+  return () => {
+    startChannel.unbindStore(currentSpanStore);
+  };
+}
 function logErrorAndEnd(states, event) {
   const spanData = states.get(event);
   if (!spanData) {
@@ -9298,15 +9397,19 @@ function traceAsyncChannel(channel2, config) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     asyncEnd: (event) => {
@@ -9326,7 +9429,7 @@ function traceAsyncChannel(channel2, config) {
           startTime,
           asyncEndEvent
         );
-        const metadata = _optionalChain([config, 'access', _113 => _113.extractMetadata, 'optionalCall', _114 => _114(
+        const metadata = _optionalChain([config, 'access', _146 => _146.extractMetadata, 'optionalCall', _147 => _147(
           asyncEndEvent.result,
           asyncEndEvent
         )]);
@@ -9348,6 +9451,7 @@ function traceAsyncChannel(channel2, config) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    _optionalChain([unbindCurrentSpanStore, 'optionalCall', _148 => _148()]);
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -9355,15 +9459,19 @@ function traceStreamingChannel(channel2, config) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     asyncEnd: (event) => {
@@ -9437,7 +9545,7 @@ function traceStreamingChannel(channel2, config) {
         });
         return;
       }
-      if (_optionalChain([config, 'access', _115 => _115.patchResult, 'optionalCall', _116 => _116({
+      if (_optionalChain([config, 'access', _149 => _149.patchResult, 'optionalCall', _150 => _150({
         channelName,
         endEvent: asyncEndEvent,
         result: asyncEndEvent.result,
@@ -9457,7 +9565,7 @@ function traceStreamingChannel(channel2, config) {
           startTime,
           asyncEndEvent
         );
-        const metadata = _optionalChain([config, 'access', _117 => _117.extractMetadata, 'optionalCall', _118 => _118(
+        const metadata = _optionalChain([config, 'access', _151 => _151.extractMetadata, 'optionalCall', _152 => _152(
           asyncEndEvent.result,
           asyncEndEvent
         )]);
@@ -9479,6 +9587,7 @@ function traceStreamingChannel(channel2, config) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    _optionalChain([unbindCurrentSpanStore, 'optionalCall', _153 => _153()]);
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -9486,15 +9595,19 @@ function traceSyncStreamChannel(channel2, config) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     end: (event) => {
@@ -9504,7 +9617,7 @@ function traceSyncStreamChannel(channel2, config) {
       }
       const { span, startTime } = spanData;
       const endEvent = event;
-      if (_optionalChain([config, 'access', _119 => _119.patchResult, 'optionalCall', _120 => _120({
+      if (_optionalChain([config, 'access', _154 => _154.patchResult, 'optionalCall', _155 => _155({
         channelName,
         endEvent,
         result: endEvent.result,
@@ -9583,6 +9696,7 @@ function traceSyncStreamChannel(channel2, config) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    _optionalChain([unbindCurrentSpanStore, 'optionalCall', _156 => _156()]);
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -9657,7 +9771,7 @@ function processInputAttachments(input) {
   let attachmentIndex = 0;
   const inferMediaTypeFromDataUrl = (value, fallback2) => {
     const mediaTypeMatch = value.match(/^data:([^;]+);/);
-    return _optionalChain([mediaTypeMatch, 'optionalAccess', _121 => _121[1]]) || fallback2;
+    return _optionalChain([mediaTypeMatch, 'optionalAccess', _157 => _157[1]]) || fallback2;
   };
   const toAttachment = (value, mediaType, filename) => {
     const blob = convertDataToBlob(value, mediaType);
@@ -9907,11 +10021,11 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _122 => _122.choices]);
+          return _optionalChain([result, 'optionalAccess', _158 => _158.choices]);
         },
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _123 => _123.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _159 => _159.usage])),
             result,
             endEvent
           );
@@ -9935,12 +10049,12 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          const embedding = _optionalChain([result, 'optionalAccess', _124 => _124.data, 'optionalAccess', _125 => _125[0], 'optionalAccess', _126 => _126.embedding]);
+          const embedding = _optionalChain([result, 'optionalAccess', _160 => _160.data, 'optionalAccess', _161 => _161[0], 'optionalAccess', _162 => _162.embedding]);
           return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
         },
         extractMetrics: (result, _startTime, endEvent) => {
           return withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _127 => _127.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _163 => _163.usage])),
             result,
             endEvent
           );
@@ -9959,11 +10073,11 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _128 => _128.choices]);
+          return _optionalChain([result, 'optionalAccess', _164 => _164.choices]);
         },
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _129 => _129.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _165 => _165.usage])),
             result,
             endEvent
           );
@@ -10000,11 +10114,11 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _130 => _130.results]);
+          return _optionalChain([result, 'optionalAccess', _166 => _166.results]);
         },
         extractMetrics: (result, _startTime, endEvent) => {
           return withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _131 => _131.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _167 => _167.usage])),
             result,
             endEvent
           );
@@ -10023,7 +10137,7 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _132 => _132.output]));
+          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _168 => _168.output]));
         },
         extractMetadata: (result) => {
           if (!result) {
@@ -10034,7 +10148,7 @@ var OpenAIPlugin = class extends BasePlugin {
         },
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _133 => _133.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _169 => _169.usage])),
             result,
             endEvent
           );
@@ -10087,7 +10201,7 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _134 => _134.output]));
+          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _170 => _170.output]));
         },
         extractMetadata: (result) => {
           if (!result) {
@@ -10098,7 +10212,7 @@ var OpenAIPlugin = class extends BasePlugin {
         },
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _135 => _135.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _171 => _171.usage])),
             result,
             endEvent
           );
@@ -10194,7 +10308,7 @@ function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
         ...parseMetricsFromUsage(chunk.usage)
       };
     }
-    const delta = _optionalChain([chunk, 'access', _136 => _136.choices, 'optionalAccess', _137 => _137[0], 'optionalAccess', _138 => _138.delta]);
+    const delta = _optionalChain([chunk, 'access', _172 => _172.choices, 'optionalAccess', _173 => _173[0], 'optionalAccess', _174 => _174.delta]);
     if (!delta) {
       continue;
     }
@@ -10252,14 +10366,14 @@ function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
       continue;
     }
     const response = chunk.response;
-    if (_optionalChain([response, 'optionalAccess', _139 => _139.output]) !== void 0) {
+    if (_optionalChain([response, 'optionalAccess', _175 => _175.output]) !== void 0) {
       output = processImagesInOutput(response.output);
     }
     const { usage: _usage, output: _output, ...rest } = response || {};
     if (Object.keys(rest).length > 0) {
       metadata = rest;
     }
-    metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _140 => _140.usage]));
+    metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _176 => _176.usage]));
   }
   return {
     output,
@@ -10325,7 +10439,7 @@ var AnthropicPlugin = class extends BasePlugin {
         return message ? { role: message.role, content: message.content } : null;
       },
       extractMetrics: (message, startTime) => {
-        const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _141 => _141.usage]));
+        const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _177 => _177.usage]));
         if (startTime) {
           metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
         }
@@ -10340,7 +10454,7 @@ var AnthropicPlugin = class extends BasePlugin {
         const metadata = {};
         const metas = ["stop_reason", "stop_sequence"];
         for (const m of metas) {
-          if (_optionalChain([message, 'optionalAccess', _142 => _142[m]]) !== void 0) {
+          if (_optionalChain([message, 'optionalAccess', _178 => _178[m]]) !== void 0) {
             metadata[m] = message[m];
           }
         }
@@ -10381,15 +10495,15 @@ function aggregateAnthropicStreamChunks(chunks) {
   let metrics = {};
   let metadata = {};
   for (const event of chunks) {
-    switch (_optionalChain([event, 'optionalAccess', _143 => _143.type])) {
+    switch (_optionalChain([event, 'optionalAccess', _179 => _179.type])) {
       case "message_start":
-        if (_optionalChain([event, 'access', _144 => _144.message, 'optionalAccess', _145 => _145.usage])) {
+        if (_optionalChain([event, 'access', _180 => _180.message, 'optionalAccess', _181 => _181.usage])) {
           const initialMetrics = parseMetricsFromUsage2(event.message.usage);
           metrics = { ...metrics, ...initialMetrics };
         }
         break;
       case "content_block_delta":
-        if (_optionalChain([event, 'access', _146 => _146.delta, 'optionalAccess', _147 => _147.type]) === "text_delta") {
+        if (_optionalChain([event, 'access', _182 => _182.delta, 'optionalAccess', _183 => _183.type]) === "text_delta") {
           const text = event.delta.text;
           if (text) {
             deltas.push(text);
@@ -10846,7 +10960,7 @@ function extractTopLevelAISDKMetrics(result, event, startTime) {
   return metrics;
 }
 function hasModelChildTracing(event) {
-  return _optionalChain([event, 'optionalAccess', _148 => _148.__braintrust_ai_sdk_model_wrapped]) === true;
+  return _optionalChain([event, 'optionalAccess', _184 => _184.__braintrust_ai_sdk_model_wrapped]) === true;
 }
 function extractMetadataFromParams(params, self) {
   const metadata = {
@@ -10855,7 +10969,7 @@ function extractMetadataFromParams(params, self) {
       sdk_language: "typescript"
     }
   };
-  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _149 => _149.settings, 'optionalAccess', _150 => _150.model]) ? _optionalChain([self, 'access', _151 => _151.settings, 'optionalAccess', _152 => _152.model]) : void 0;
+  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _185 => _185.settings, 'optionalAccess', _186 => _186.model]) ? _optionalChain([self, 'access', _187 => _187.settings, 'optionalAccess', _188 => _188.model]) : void 0;
   const { model, provider } = serializeModelWithProvider(
     _nullishCoalesce(params.model, () => ( agentModel))
   );
@@ -10957,9 +11071,9 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
               case "raw":
                 if (chunk.rawValue) {
                   const rawVal = chunk.rawValue;
-                  if (_optionalChain([rawVal, 'access', _153 => _153.delta, 'optionalAccess', _154 => _154.content])) {
+                  if (_optionalChain([rawVal, 'access', _189 => _189.delta, 'optionalAccess', _190 => _190.content])) {
                     text += rawVal.delta.content;
-                  } else if (_optionalChain([rawVal, 'access', _155 => _155.choices, 'optionalAccess', _156 => _156[0], 'optionalAccess', _157 => _157.delta, 'optionalAccess', _158 => _158.content])) {
+                  } else if (_optionalChain([rawVal, 'access', _191 => _191.choices, 'optionalAccess', _192 => _192[0], 'optionalAccess', _193 => _193.delta, 'optionalAccess', _194 => _194.content])) {
                     text += rawVal.choices[0].delta.content;
                   } else if (typeof rawVal.text === "string") {
                     text += rawVal.text;
@@ -11096,14 +11210,14 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
   return {
     cleanup: cleanup.length > 0 ? () => {
       while (cleanup.length > 0) {
-        _optionalChain([cleanup, 'access', _159 => _159.pop, 'call', _160 => _160(), 'optionalCall', _161 => _161()]);
+        _optionalChain([cleanup, 'access', _195 => _195.pop, 'call', _196 => _196(), 'optionalCall', _197 => _197()]);
       }
     } : void 0,
     modelWrapped
   };
 }
 function finalizeAISDKChildTracing(event) {
-  const cleanup = _optionalChain([event, 'optionalAccess', _162 => _162.__braintrust_ai_sdk_cleanup]);
+  const cleanup = _optionalChain([event, 'optionalAccess', _198 => _198.__braintrust_ai_sdk_cleanup]);
   if (event && typeof cleanup === "function") {
     cleanup();
     delete event.__braintrust_ai_sdk_cleanup;
@@ -11195,10 +11309,10 @@ function buildAISDKChildMetadata(model) {
 function buildResolvedMetadataPayload(result) {
   const gatewayInfo = extractGatewayRoutingInfo(result);
   const metadata = {};
-  if (_optionalChain([gatewayInfo, 'optionalAccess', _163 => _163.provider])) {
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _199 => _199.provider])) {
     metadata.provider = gatewayInfo.provider;
   }
-  if (_optionalChain([gatewayInfo, 'optionalAccess', _164 => _164.model])) {
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _200 => _200.model])) {
     metadata.model = gatewayInfo.model;
   }
   if (result.finishReason !== void 0) {
@@ -11233,7 +11347,7 @@ function processAISDKOutput(output, denyOutputPaths) {
 }
 function extractTokenMetrics(result) {
   const metrics = {};
-  let usage = _optionalChain([result, 'optionalAccess', _165 => _165.totalUsage]) || _optionalChain([result, 'optionalAccess', _166 => _166.usage]);
+  let usage = _optionalChain([result, 'optionalAccess', _201 => _201.totalUsage]) || _optionalChain([result, 'optionalAccess', _202 => _202.usage]);
   if (!usage && result) {
     try {
       if ("totalUsage" in result && typeof result.totalUsage !== "function") {
@@ -11248,7 +11362,7 @@ function extractTokenMetrics(result) {
     return metrics;
   }
   const promptTokens = firstNumber(
-    _optionalChain([usage, 'access', _167 => _167.inputTokens, 'optionalAccess', _168 => _168.total]),
+    _optionalChain([usage, 'access', _203 => _203.inputTokens, 'optionalAccess', _204 => _204.total]),
     usage.inputTokens,
     usage.promptTokens,
     usage.prompt_tokens
@@ -11257,7 +11371,7 @@ function extractTokenMetrics(result) {
     metrics.prompt_tokens = promptTokens;
   }
   const completionTokens = firstNumber(
-    _optionalChain([usage, 'access', _169 => _169.outputTokens, 'optionalAccess', _170 => _170.total]),
+    _optionalChain([usage, 'access', _205 => _205.outputTokens, 'optionalAccess', _206 => _206.total]),
     usage.outputTokens,
     usage.completionTokens,
     usage.completion_tokens
@@ -11343,7 +11457,7 @@ function extractSerializableOutputFields(output) {
   ];
   for (const name of directFieldNames) {
     try {
-      const value = _optionalChain([output, 'optionalAccess', _171 => _171[name]]);
+      const value = _optionalChain([output, 'optionalAccess', _207 => _207[name]]);
       if (isSerializableOutputValue(value)) {
         serialized[name] = value;
       }
@@ -11371,8 +11485,8 @@ function isSerializableOutputValue(value) {
   return true;
 }
 function serializeModelWithProvider(model) {
-  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _172 => _172.modelId]);
-  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _173 => _173.provider]) : void 0;
+  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _208 => _208.modelId]);
+  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _209 => _209.provider]) : void 0;
   if (!modelId) {
     return { model: modelId, provider: explicitProvider };
   }
@@ -11396,8 +11510,8 @@ function parseGatewayModelString(modelString) {
   return { model: modelString };
 }
 function extractGatewayRoutingInfo(result) {
-  if (_optionalChain([result, 'optionalAccess', _174 => _174.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
-    const routing2 = _optionalChain([result, 'access', _175 => _175.steps, 'access', _176 => _176[0], 'optionalAccess', _177 => _177.providerMetadata, 'optionalAccess', _178 => _178.gateway, 'optionalAccess', _179 => _179.routing]);
+  if (_optionalChain([result, 'optionalAccess', _210 => _210.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+    const routing2 = _optionalChain([result, 'access', _211 => _211.steps, 'access', _212 => _212[0], 'optionalAccess', _213 => _213.providerMetadata, 'optionalAccess', _214 => _214.gateway, 'optionalAccess', _215 => _215.routing]);
     if (routing2) {
       return {
         provider: routing2.resolvedProvider || routing2.finalProvider,
@@ -11405,7 +11519,7 @@ function extractGatewayRoutingInfo(result) {
       };
     }
   }
-  const routing = _optionalChain([result, 'optionalAccess', _180 => _180.providerMetadata, 'optionalAccess', _181 => _181.gateway, 'optionalAccess', _182 => _182.routing]);
+  const routing = _optionalChain([result, 'optionalAccess', _216 => _216.providerMetadata, 'optionalAccess', _217 => _217.gateway, 'optionalAccess', _218 => _218.routing]);
   if (routing) {
     return {
       provider: routing.resolvedProvider || routing.finalProvider,
@@ -11415,12 +11529,12 @@ function extractGatewayRoutingInfo(result) {
   return null;
 }
 function extractCostFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _183 => _183.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+  if (_optionalChain([result, 'optionalAccess', _219 => _219.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
     let totalCost = 0;
     let foundCost = false;
     for (const step of result.steps) {
-      const gateway2 = _optionalChain([step, 'optionalAccess', _184 => _184.providerMetadata, 'optionalAccess', _185 => _185.gateway]);
-      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _186 => _186.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _187 => _187.marketCost]));
+      const gateway2 = _optionalChain([step, 'optionalAccess', _220 => _220.providerMetadata, 'optionalAccess', _221 => _221.gateway]);
+      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _222 => _222.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _223 => _223.marketCost]));
       if (stepCost !== void 0 && stepCost > 0) {
         totalCost += stepCost;
         foundCost = true;
@@ -11430,8 +11544,8 @@ function extractCostFromResult(result) {
       return totalCost;
     }
   }
-  const gateway = _optionalChain([result, 'optionalAccess', _188 => _188.providerMetadata, 'optionalAccess', _189 => _189.gateway]);
-  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _190 => _190.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _191 => _191.marketCost]));
+  const gateway = _optionalChain([result, 'optionalAccess', _224 => _224.providerMetadata, 'optionalAccess', _225 => _225.gateway]);
+  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _226 => _226.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _227 => _227.marketCost]));
   if (directCost !== void 0 && directCost > 0) {
     return directCost;
   }
@@ -11583,7 +11697,7 @@ function extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _192 => _192.message, 'optionalAccess', _193 => _193.usage]);
+    usage = _optionalChain([message, 'access', _228 => _228.message, 'optionalAccess', _229 => _229.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -11623,14 +11737,14 @@ function buildLLMInput(prompt, conversationHistory) {
 async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
   if (messages.length === 0) return void 0;
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _194 => _194.message, 'optionalAccess', _195 => _195.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _230 => _230.message, 'optionalAccess', _231 => _231.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
   const usage = extractUsageFromMessage(lastMessage);
   const input = buildLLMInput(prompt, conversationHistory);
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _196 => _196.message, 'optionalAccess', _197 => _197.content]) && _optionalChain([m, 'access', _198 => _198.message, 'optionalAccess', _199 => _199.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _232 => _232.message, 'optionalAccess', _233 => _233.content]) && _optionalChain([m, 'access', _234 => _234.message, 'optionalAccess', _235 => _235.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter(
     (c) => c !== void 0
   );
@@ -11649,7 +11763,7 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
     metrics: usage
   });
   await span.end();
-  return _optionalChain([lastMessage, 'access', _200 => _200.message, 'optionalAccess', _201 => _201.content]) && _optionalChain([lastMessage, 'access', _202 => _202.message, 'optionalAccess', _203 => _203.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _236 => _236.message, 'optionalAccess', _237 => _237.content]) && _optionalChain([lastMessage, 'access', _238 => _238.message, 'optionalAccess', _239 => _239.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 var ClaudeAgentSDKPlugin = class extends BasePlugin {
   onEnable() {
@@ -11672,8 +11786,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
     const handlers = {
       start: (event) => {
         const params = event.arguments[0];
-        const prompt = _optionalChain([params, 'optionalAccess', _204 => _204.prompt]);
-        const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _205 => _205.options]), () => ( {}));
+        const prompt = _optionalChain([params, 'optionalAccess', _240 => _240.prompt]);
+        const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _241 => _241.options]), () => ( {}));
         const span = startSpan({
           name: "Claude Agent",
           spanAttributes: {
@@ -11718,9 +11832,9 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
             onChunk: async (message) => {
               const currentTime = getCurrentUnixTimestamp();
               const params = event.arguments[0];
-              const prompt = _optionalChain([params, 'optionalAccess', _206 => _206.prompt]);
-              const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _207 => _207.options]), () => ( {}));
-              const messageId = _optionalChain([message, 'access', _208 => _208.message, 'optionalAccess', _209 => _209.id]);
+              const prompt = _optionalChain([params, 'optionalAccess', _242 => _242.prompt]);
+              const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _243 => _243.options]), () => ( {}));
+              const messageId = _optionalChain([message, 'access', _244 => _244.message, 'optionalAccess', _245 => _245.id]);
               if (messageId && messageId !== spanData.currentMessageId) {
                 if (spanData.currentMessages.length > 0) {
                   const finalMessage = await createLLMSpanForMessages(
@@ -11735,7 +11849,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
                     spanData.conversationHistory.push(finalMessage);
                   }
                   const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (_optionalChain([lastMessage, 'optionalAccess', _210 => _210.message, 'optionalAccess', _211 => _211.usage])) {
+                  if (_optionalChain([lastMessage, 'optionalAccess', _246 => _246.message, 'optionalAccess', _247 => _247.usage])) {
                     const outputTokens = getNumberProperty(
                       lastMessage.message.usage,
                       "output_tokens"
@@ -11747,14 +11861,14 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
                 spanData.currentMessageId = messageId;
                 spanData.currentMessageStartTime = currentTime;
               }
-              if (message.type === "assistant" && _optionalChain([message, 'access', _212 => _212.message, 'optionalAccess', _213 => _213.usage])) {
+              if (message.type === "assistant" && _optionalChain([message, 'access', _248 => _248.message, 'optionalAccess', _249 => _249.usage])) {
                 spanData.currentMessages.push(message);
               }
               if (message.type === "result" && message.usage) {
                 const finalUsageMetrics = extractUsageFromMessage(message);
                 if (spanData.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
                   const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (_optionalChain([lastMessage, 'optionalAccess', _214 => _214.message, 'optionalAccess', _215 => _215.usage])) {
+                  if (_optionalChain([lastMessage, 'optionalAccess', _250 => _250.message, 'optionalAccess', _251 => _251.usage])) {
                     const adjustedTokens = finalUsageMetrics.completion_tokens - spanData.accumulatedOutputTokens;
                     if (adjustedTokens >= 0) {
                       lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -11778,8 +11892,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
             onComplete: async () => {
               try {
                 const params = event.arguments[0];
-                const prompt = _optionalChain([params, 'optionalAccess', _216 => _216.prompt]);
-                const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _217 => _217.options]), () => ( {}));
+                const prompt = _optionalChain([params, 'optionalAccess', _252 => _252.prompt]);
+                const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _253 => _253.options]), () => ( {}));
                 if (spanData.currentMessages.length > 0) {
                   const finalMessage = await createLLMSpanForMessages(
                     spanData.currentMessages,
@@ -11986,7 +12100,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _218 => _218.config, 'optionalAccess', _219 => _219.tools])) {
+  if (!_optionalChain([params, 'access', _254 => _254.config, 'optionalAccess', _255 => _255.tools])) {
     return null;
   }
   try {
@@ -12023,7 +12137,7 @@ function extractGenerateContentMetrics(response, startTime) {
     const end = getCurrentUnixTimestamp();
     metrics.duration = end - startTime;
   }
-  if (_optionalChain([response, 'optionalAccess', _220 => _220.usageMetadata])) {
+  if (_optionalChain([response, 'optionalAccess', _256 => _256.usageMetadata])) {
     populateUsageMetrics(metrics, response.usageMetadata);
   }
   return metrics;
@@ -12071,7 +12185,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _221 => _221.content, 'optionalAccess', _222 => _222.parts])) {
+        if (_optionalChain([candidate, 'access', _257 => _257.content, 'optionalAccess', _258 => _258.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -12102,7 +12216,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _223 => _223.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _259 => _259.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -12144,6 +12258,1023 @@ function tryToDict(obj) {
   return null;
 }
 
+// src/instrumentation/plugins/openrouter-channels.ts
+var openRouterChannels = defineChannels("@openrouter/sdk", {
+  chatSend: channel({
+    channelName: "chat.send",
+    kind: "async"
+  }),
+  embeddingsGenerate: channel({
+    channelName: "embeddings.generate",
+    kind: "async"
+  }),
+  betaResponsesSend: channel({
+    channelName: "beta.responses.send",
+    kind: "async"
+  }),
+  callModel: channel({
+    channelName: "callModel",
+    kind: "sync-stream"
+  }),
+  toolExecute: channel({
+    channelName: "tool.execute",
+    kind: "async"
+  })
+});
+
+// src/openrouter-utils.ts
+var TOKEN_NAME_MAP2 = {
+  promptTokens: "prompt_tokens",
+  inputTokens: "prompt_tokens",
+  completionTokens: "completion_tokens",
+  outputTokens: "completion_tokens",
+  totalTokens: "tokens",
+  prompt_tokens: "prompt_tokens",
+  input_tokens: "prompt_tokens",
+  completion_tokens: "completion_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_DETAIL_PREFIX_MAP = {
+  promptTokensDetails: "prompt",
+  inputTokensDetails: "prompt",
+  completionTokensDetails: "completion",
+  outputTokensDetails: "completion",
+  costDetails: "cost",
+  prompt_tokens_details: "prompt",
+  input_tokens_details: "prompt",
+  completion_tokens_details: "completion",
+  output_tokens_details: "completion",
+  cost_details: "cost"
+};
+function camelToSnake(value) {
+  return value.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+}
+function parseOpenRouterMetricsFromUsage(usage) {
+  if (!isObject(usage)) {
+    return {};
+  }
+  const metrics = {};
+  for (const [name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      metrics[TOKEN_NAME_MAP2[name] || camelToSnake(name)] = value;
+      continue;
+    }
+    if (!isObject(value)) {
+      continue;
+    }
+    const prefix = TOKEN_DETAIL_PREFIX_MAP[name];
+    if (!prefix) {
+      continue;
+    }
+    for (const [nestedName, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${camelToSnake(nestedName)}`] = nestedValue;
+    }
+  }
+  return metrics;
+}
+function extractOpenRouterUsageMetadata(usage) {
+  if (!isObject(usage)) {
+    return void 0;
+  }
+  const metadata = {};
+  if (typeof usage.isByok === "boolean") {
+    metadata.is_byok = usage.isByok;
+  } else if (typeof usage.is_byok === "boolean") {
+    metadata.is_byok = usage.is_byok;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+
+// src/openrouter-logging.ts
+var OMITTED_OPENROUTER_KEYS = /* @__PURE__ */ new Set([
+  "execute",
+  "render",
+  "nextTurnParams",
+  "requireApproval"
+]);
+function parseOpenRouterModelString(model) {
+  if (typeof model !== "string") {
+    return { model };
+  }
+  const slashIndex = model.indexOf("/");
+  if (slashIndex > 0 && slashIndex < model.length - 1) {
+    return {
+      provider: model.substring(0, slashIndex),
+      model: model.substring(slashIndex + 1)
+    };
+  }
+  return { model };
+}
+function isZodSchema2(value) {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function serializeZodSchema2(schema) {
+  try {
+    return zodToJsonSchema(schema);
+  } catch (e27) {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
+  }
+}
+function serializeOpenRouterTool(tool) {
+  if (!isObject(tool)) {
+    return tool;
+  }
+  const serialized = {};
+  for (const [key, value] of Object.entries(tool)) {
+    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+      continue;
+    }
+    if (key === "function" && isObject(value)) {
+      serialized.function = sanitizeOpenRouterLoggedValue(value);
+      continue;
+    }
+    serialized[key] = sanitizeOpenRouterLoggedValue(value);
+  }
+  return serialized;
+}
+function serializeOpenRouterToolsForLogging(tools) {
+  if (!Array.isArray(tools)) {
+    return void 0;
+  }
+  return tools.map((tool) => serializeOpenRouterTool(tool));
+}
+function sanitizeOpenRouterLoggedValue(value) {
+  if (isZodSchema2(value)) {
+    return serializeZodSchema2(value);
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeOpenRouterLoggedValue(entry));
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+      continue;
+    }
+    if (key === "tools" && Array.isArray(entry)) {
+      sanitized.tools = serializeOpenRouterToolsForLogging(entry);
+      continue;
+    }
+    sanitized[key] = sanitizeOpenRouterLoggedValue(entry);
+  }
+  return sanitized;
+}
+function buildOpenRouterMetadata(metadata, httpReferer, xTitle) {
+  const sanitized = sanitizeOpenRouterLoggedValue(metadata);
+  const metadataRecord = isObject(sanitized) ? sanitized : {};
+  const { model, provider: providerRouting, ...rest } = metadataRecord;
+  const normalizedModel = parseOpenRouterModelString(model);
+  return {
+    ...rest,
+    ...normalizedModel.model !== void 0 ? { model: normalizedModel.model } : {},
+    ...providerRouting !== void 0 ? { providerRouting } : {},
+    ...httpReferer !== void 0 ? { httpReferer } : {},
+    ...xTitle !== void 0 ? { xTitle } : {},
+    provider: normalizedModel.provider || "openrouter"
+  };
+}
+function buildOpenRouterEmbeddingMetadata(metadata, httpReferer, xTitle) {
+  const normalized = buildOpenRouterMetadata(metadata, httpReferer, xTitle);
+  return typeof normalized.model === "string" ? {
+    ...normalized,
+    embedding_model: normalized.model
+  } : normalized;
+}
+function extractOpenRouterCallModelInput(request) {
+  return isObject(request) && "input" in request ? sanitizeOpenRouterLoggedValue(request.input) : void 0;
+}
+function extractOpenRouterCallModelMetadata(request) {
+  if (!isObject(request)) {
+    return { provider: "openrouter" };
+  }
+  const { input: _input, ...metadata } = request;
+  return buildOpenRouterMetadata(metadata, void 0, void 0);
+}
+function extractOpenRouterResponseMetadata(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const { output: _output, data: _data, usage, ...metadata } = result;
+  const sanitized = sanitizeOpenRouterLoggedValue(metadata);
+  const metadataRecord = isObject(sanitized) ? sanitized : {};
+  const { model, provider, ...rest } = metadataRecord;
+  const normalizedModel = parseOpenRouterModelString(model);
+  const normalizedProvider = (typeof provider === "string" ? provider : void 0) || normalizedModel.provider;
+  const usageMetadata = extractOpenRouterUsageMetadata(usage);
+  const combined = {
+    ...rest,
+    ...normalizedModel.model !== void 0 ? { model: normalizedModel.model } : {},
+    ...usageMetadata || {},
+    ...normalizedProvider !== void 0 ? { provider: normalizedProvider } : {}
+  };
+  return Object.keys(combined).length > 0 ? combined : void 0;
+}
+function extractOpenRouterResponseOutput(response, fallbackOutput) {
+  if (isObject(response) && "output" in response && response.output !== void 0) {
+    return sanitizeOpenRouterLoggedValue(response.output);
+  }
+  if (fallbackOutput !== void 0) {
+    return sanitizeOpenRouterLoggedValue(fallbackOutput);
+  }
+  return void 0;
+}
+
+// src/openrouter-tool-wrapping.ts
+var OPENROUTER_WRAPPED_TOOL = Symbol("braintrust.openrouter.wrappedTool");
+var OPENROUTER_WRAPPED_CALL_MODEL_RESULT = Symbol(
+  "braintrust.openrouter.wrappedCallModelResult"
+);
+var OPENROUTER_CALL_MODEL_STREAM_METHODS = [
+  "getFullResponsesStream",
+  "getItemsStream",
+  "getNewMessagesStream",
+  "getReasoningStream",
+  "getTextStream",
+  "getToolCallsStream",
+  "getToolStream"
+];
+var OPENROUTER_CALL_MODEL_CONTEXT_METHODS = [
+  "cancel",
+  "getPendingToolCalls",
+  "getState",
+  "getToolCalls",
+  "requiresApproval"
+];
+function patchOpenRouterCallModelRequestTools(request) {
+  if (!Array.isArray(request.tools) || request.tools.length === 0) {
+    return void 0;
+  }
+  const originalTools = request.tools;
+  const wrappedTools = originalTools.map((tool) => wrapOpenRouterTool(tool));
+  const didPatch = wrappedTools.some(
+    (tool, index) => tool !== originalTools[index]
+  );
+  if (!didPatch) {
+    return void 0;
+  }
+  request.tools = wrappedTools;
+  return () => {
+    request.tools = originalTools;
+  };
+}
+function patchOpenRouterCallModelResult(span, result, request) {
+  if (!isObject(result) || isWrappedCallModelResult(result)) {
+    return false;
+  }
+  const resultLike = result;
+  const hasInstrumentableMethod = typeof resultLike.getResponse === "function" || typeof resultLike.getText === "function" || OPENROUTER_CALL_MODEL_STREAM_METHODS.some(
+    (methodName) => typeof resultLike[methodName] === "function"
+  );
+  if (!hasInstrumentableMethod) {
+    return false;
+  }
+  Object.defineProperty(resultLike, OPENROUTER_WRAPPED_CALL_MODEL_RESULT, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  const originalGetResponse = typeof resultLike.getResponse === "function" ? resultLike.getResponse.bind(resultLike) : void 0;
+  const originalGetInitialResponse = typeof resultLike.getInitialResponse === "function" ? resultLike.getInitialResponse.bind(resultLike) : void 0;
+  const originalMakeFollowupRequest = typeof resultLike.makeFollowupRequest === "function" ? resultLike.makeFollowupRequest.bind(resultLike) : void 0;
+  let ended = false;
+  let tracedTurnCount = 0;
+  const endSpanWithResult = async (response, fallbackOutput) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    const finalResponse = getFinalOpenRouterCallModelResponse(
+      resultLike,
+      response
+    );
+    if (finalResponse) {
+      const rounds = getOpenRouterCallModelRounds(resultLike);
+      const metadata = extractOpenRouterCallModelResultMetadata(
+        finalResponse,
+        rounds.length + 1
+      );
+      span.log({
+        output: extractOpenRouterResponseOutput(finalResponse, fallbackOutput),
+        ...metadata ? { metadata } : {},
+        metrics: aggregateOpenRouterCallModelMetrics(rounds, finalResponse)
+      });
+      span.end();
+      return;
+    }
+    if (fallbackOutput !== void 0) {
+      span.log({
+        output: fallbackOutput
+      });
+    }
+    span.end();
+  };
+  const endSpanWithError = (error) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    span.log({
+      error: normalizeError(error).message
+    });
+    span.end();
+  };
+  const finalizeFromResponse = async (fallbackOutput) => {
+    if (!originalGetResponse) {
+      await endSpanWithResult(void 0, fallbackOutput);
+      return;
+    }
+    try {
+      await endSpanWithResult(await originalGetResponse(), fallbackOutput);
+    } catch (e28) {
+      await endSpanWithResult(void 0, fallbackOutput);
+    }
+  };
+  if (originalGetResponse) {
+    resultLike.getResponse = async (...args) => {
+      return await withCurrent(span, async () => {
+        try {
+          const response = await originalGetResponse(...args);
+          await endSpanWithResult(response);
+          return response;
+        } catch (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
+    };
+  }
+  if (typeof resultLike.getText === "function") {
+    const originalGetText = resultLike.getText.bind(resultLike);
+    resultLike.getText = async (...args) => {
+      return await withCurrent(span, async () => {
+        try {
+          const text = await originalGetText(...args);
+          await finalizeFromResponse(text);
+          return text;
+        } catch (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_CONTEXT_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
+      continue;
+    }
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = async (...args) => {
+      return await withCurrent(span, async () => {
+        return await originalMethod.apply(resultLike, args);
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_STREAM_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
+      continue;
+    }
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = (...args) => {
+      const stream = withCurrent(
+        span,
+        () => originalMethod.apply(resultLike, args)
+      );
+      if (!isAsyncIterable2(stream)) {
+        return stream;
+      }
+      return wrapAsyncIterableWithSpan({
+        finalize: finalizeFromResponse,
+        iteratorFactory: () => stream[Symbol.asyncIterator](),
+        onError: endSpanWithError,
+        span
+      });
+    };
+  }
+  if (originalGetInitialResponse) {
+    let initialTurnTraced = false;
+    resultLike.getInitialResponse = async (...args) => {
+      if (initialTurnTraced) {
+        return await withCurrent(span, async () => {
+          return await originalGetInitialResponse(...args);
+        });
+      }
+      initialTurnTraced = true;
+      const resolvedRequest = getOpenRouterResolvedRequest(resultLike, request);
+      const childSpan = startOpenRouterCallModelTurnSpan({
+        request: resolvedRequest,
+        step: tracedTurnCount + 1,
+        stepType: tracedTurnCount === 0 ? "initial" : "continue"
+      });
+      return await withCurrent(childSpan, async () => {
+        try {
+          const response = await originalGetInitialResponse(...args);
+          tracedTurnCount++;
+          finishOpenRouterCallModelTurnSpan({
+            response,
+            step: tracedTurnCount,
+            stepType: tracedTurnCount === 1 ? "initial" : "continue",
+            span: childSpan
+          });
+          return response;
+        } catch (error) {
+          childSpan.log({
+            error: normalizeError(error).message
+          });
+          childSpan.end();
+          throw error;
+        }
+      });
+    };
+  }
+  if (originalMakeFollowupRequest) {
+    resultLike.makeFollowupRequest = async (...args) => {
+      const currentResponse = args[0];
+      const toolResults = Array.isArray(args[1]) ? args[1] : [];
+      const resolvedRequest = getOpenRouterResolvedRequest(resultLike, request);
+      const followupRequest = buildOpenRouterFollowupRequest(
+        resolvedRequest,
+        currentResponse,
+        toolResults
+      );
+      const childSpan = startOpenRouterCallModelTurnSpan({
+        request: followupRequest,
+        step: tracedTurnCount + 1,
+        stepType: "continue"
+      });
+      return await withCurrent(childSpan, async () => {
+        try {
+          const response = await originalMakeFollowupRequest(...args);
+          tracedTurnCount++;
+          finishOpenRouterCallModelTurnSpan({
+            response,
+            step: tracedTurnCount,
+            stepType: "continue",
+            span: childSpan
+          });
+          return response;
+        } catch (error) {
+          childSpan.log({
+            error: normalizeError(error).message
+          });
+          childSpan.end();
+          throw error;
+        }
+      });
+    };
+  }
+  return true;
+}
+function wrapOpenRouterTool(tool) {
+  if (isWrappedTool(tool) || !tool.function || typeof tool.function !== "object" || typeof tool.function.execute !== "function") {
+    return tool;
+  }
+  const toolName = tool.function.name || "tool";
+  const originalExecute = tool.function.execute;
+  const wrappedTool = {
+    ...tool,
+    function: {
+      ...tool.function,
+      execute(...args) {
+        return traceToolExecution({
+          args,
+          execute: () => Reflect.apply(originalExecute, this, args),
+          toolCallId: getToolCallId(args[1]),
+          toolName
+        });
+      }
+    }
+  };
+  Object.defineProperty(wrappedTool, OPENROUTER_WRAPPED_TOOL, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  return wrappedTool;
+}
+function isWrappedTool(tool) {
+  return Boolean(tool[OPENROUTER_WRAPPED_TOOL]);
+}
+function isWrappedCallModelResult(value) {
+  return Boolean(
+    isObject(value) && value[OPENROUTER_WRAPPED_CALL_MODEL_RESULT]
+  );
+}
+function traceToolExecution(args) {
+  const tracingChannel2 = openRouterChannels.toolExecute.tracingChannel();
+  const input = args.args.length > 0 ? args.args[0] : void 0;
+  const event = {
+    arguments: [input],
+    span_info: {
+      name: args.toolName
+    },
+    toolCallId: args.toolCallId,
+    toolName: args.toolName
+  };
+  tracingChannel2.start.publish(event);
+  try {
+    const result = args.execute();
+    return publishToolResult(tracingChannel2, event, result);
+  } catch (error) {
+    event.error = normalizeError(error);
+    tracingChannel2.error.publish(event);
+    throw error;
+  }
+}
+function publishToolResult(tracingChannel2, event, result) {
+  if (isPromiseLike(result)) {
+    return result.then(
+      (resolved) => {
+        event.result = resolved;
+        tracingChannel2.asyncEnd.publish(event);
+        return resolved;
+      },
+      (error) => {
+        event.error = normalizeError(error);
+        tracingChannel2.error.publish(event);
+        throw error;
+      }
+    );
+  }
+  event.result = result;
+  tracingChannel2.asyncEnd.publish(event);
+  return result;
+}
+function getToolCallId(context) {
+  const toolContext = context;
+  return typeof _optionalChain([toolContext, 'optionalAccess', _260 => _260.toolCall, 'optionalAccess', _261 => _261.id]) === "string" ? toolContext.toolCall.id : void 0;
+}
+function extractOpenRouterCallModelResultMetadata(response, turnCount) {
+  const combined = {
+    ...extractOpenRouterResponseMetadata(response) || {},
+    ...turnCount !== void 0 ? { turn_count: turnCount } : {}
+  };
+  return Object.keys(combined).length > 0 ? combined : void 0;
+}
+function getFinalOpenRouterCallModelResponse(result, response) {
+  if (isObject(response)) {
+    return response;
+  }
+  return isObject(result.finalResponse) ? result.finalResponse : void 0;
+}
+function getOpenRouterCallModelRounds(result) {
+  if (!Array.isArray(result.allToolExecutionRounds)) {
+    return [];
+  }
+  return result.allToolExecutionRounds.filter((round) => isObject(round)).map((round) => ({
+    response: isObject(round.response) ? round.response : void 0,
+    round: typeof round.round === "number" ? round.round : void 0,
+    toolResults: Array.isArray(round.toolResults) ? round.toolResults : []
+  })).filter((round) => round.response !== void 0);
+}
+function aggregateOpenRouterCallModelMetrics(rounds, finalResponse) {
+  const metrics = {};
+  const responses = [
+    ...rounds.map((round) => round.response).filter(isObject),
+    finalResponse
+  ];
+  for (const response of responses) {
+    const responseMetrics = parseOpenRouterMetricsFromUsage(response.usage);
+    for (const [name, value] of Object.entries(responseMetrics)) {
+      metrics[name] = (metrics[name] || 0) + value;
+    }
+  }
+  return metrics;
+}
+function buildNextOpenRouterCallModelInput(currentInput, response, toolResults) {
+  const normalizedInput = Array.isArray(currentInput) ? [...currentInput] : currentInput === void 0 ? [] : [currentInput];
+  const responseOutput = Array.isArray(response.output) ? response.output : response.output === void 0 ? [] : [response.output];
+  return [...normalizedInput, ...responseOutput, ...toolResults].map(
+    (entry) => sanitizeOpenRouterLoggedValue(entry)
+  );
+}
+function startOpenRouterCallModelTurnSpan(args) {
+  const requestRecord = isObject(args.request) ? args.request : void 0;
+  const metadata = requestRecord ? extractOpenRouterCallModelMetadata(requestRecord) : { provider: "openrouter" };
+  if (isObject(metadata) && "tools" in metadata) {
+    delete metadata.tools;
+  }
+  return startSpan({
+    name: "openrouter.beta.responses.send",
+    spanAttributes: {
+      type: "llm" /* LLM */
+    },
+    event: {
+      input: requestRecord ? extractOpenRouterCallModelInput(requestRecord) : void 0,
+      metadata: {
+        ...metadata,
+        step: args.step,
+        step_type: args.stepType
+      }
+    }
+  });
+}
+function finishOpenRouterCallModelTurnSpan(args) {
+  if (!isObject(args.response)) {
+    args.span.end();
+    return;
+  }
+  args.span.log({
+    output: extractOpenRouterResponseOutput(args.response),
+    ...extractOpenRouterResponseMetadata(args.response) ? {
+      metadata: {
+        ...extractOpenRouterResponseMetadata(args.response),
+        ...args.step !== void 0 ? { step: args.step } : {},
+        ...args.stepType ? { step_type: args.stepType } : {}
+      }
+    } : {},
+    metrics: parseOpenRouterMetricsFromUsage(args.response.usage)
+  });
+  args.span.end();
+}
+function getOpenRouterResolvedRequest(result, request) {
+  if (isObject(result.resolvedRequest)) {
+    return result.resolvedRequest;
+  }
+  return request;
+}
+function buildOpenRouterFollowupRequest(request, currentResponse, toolResults) {
+  if (!request) {
+    return void 0;
+  }
+  return {
+    ...request,
+    input: buildNextOpenRouterCallModelInput(
+      extractOpenRouterCallModelInput(request),
+      isObject(currentResponse) ? currentResponse : {},
+      toolResults
+    ),
+    stream: false
+  };
+}
+function wrapAsyncIterableWithSpan(args) {
+  return {
+    [Symbol.asyncIterator]() {
+      const iterator = args.iteratorFactory();
+      return {
+        next(value) {
+          return withCurrent(
+            args.span,
+            () => value === void 0 ? iterator.next() : iterator.next(value)
+          ).then(
+            async (result) => {
+              if (result.done) {
+                await args.finalize();
+              }
+              return result;
+            },
+            (error) => {
+              args.onError(error);
+              throw error;
+            }
+          );
+        },
+        return(value) {
+          if (typeof iterator.return !== "function") {
+            return args.finalize().then(() => ({
+              done: true,
+              value
+            }));
+          }
+          return withCurrent(args.span, () => iterator.return(value)).then(
+            async (result) => {
+              await args.finalize();
+              return result;
+            },
+            (error) => {
+              args.onError(error);
+              throw error;
+            }
+          );
+        },
+        throw(error) {
+          args.onError(error);
+          if (typeof iterator.throw !== "function") {
+            return Promise.reject(error);
+          }
+          return withCurrent(args.span, () => iterator.throw(error));
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    }
+  };
+}
+function isAsyncIterable2(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function isPromiseLike(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/instrumentation/plugins/openrouter-plugin.ts
+var OpenRouterPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToOpenRouterChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToOpenRouterChannels() {
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.chatSend, {
+        name: "openrouter.chat.send",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _262 => _262.chatGenerationParams])) ? request.chatGenerationParams : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _263 => _263.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _264 => _264.xTitle]);
+          const { messages, ...metadata } = chatGenerationParams;
+          return {
+            input: messages,
+            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+          };
+        },
+        extractOutput: (result) => {
+          return isObject(result) ? result.choices : void 0;
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _265 => _265.usage]));
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateOpenRouterChatChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(openRouterChannels.embeddingsGenerate, {
+        name: "openrouter.embeddings.generate",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _266 => _266.requestBody])) ? request.requestBody : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _267 => _267.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _268 => _268.xTitle]);
+          const { input, ...metadata } = requestBody;
+          return {
+            input,
+            metadata: buildOpenRouterEmbeddingMetadata(
+              metadata,
+              httpReferer,
+              xTitle
+            )
+          };
+        },
+        extractOutput: (result) => {
+          if (!isObject(result)) {
+            return void 0;
+          }
+          const embedding = _optionalChain([result, 'access', _269 => _269.data, 'optionalAccess', _270 => _270[0], 'optionalAccess', _271 => _271.embedding]);
+          return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
+        },
+        extractMetadata: (result) => {
+          if (!isObject(result)) {
+            return void 0;
+          }
+          return extractOpenRouterResponseMetadata(result);
+        },
+        extractMetrics: (result) => {
+          return isObject(result) ? parseOpenRouterMetricsFromUsage(result.usage) : {};
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.betaResponsesSend, {
+        name: "openrouter.beta.responses.send",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const openResponsesRequest = isObject(_optionalChain([request, 'optionalAccess', _272 => _272.openResponsesRequest])) ? request.openResponsesRequest : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _273 => _273.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _274 => _274.xTitle]);
+          const { input, ...metadata } = openResponsesRequest;
+          return {
+            input,
+            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+          };
+        },
+        extractOutput: (result) => extractOpenRouterResponseOutput(result),
+        extractMetadata: (result) => extractOpenRouterResponseMetadata(result),
+        extractMetrics: (result, startTime) => {
+          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _275 => _275.usage]));
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateOpenRouterResponseStreamEvents
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(openRouterChannels.callModel, {
+        name: "openrouter.callModel",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterCallModelRequestArg(args);
+          return {
+            input: request ? extractOpenRouterCallModelInput(request) : void 0,
+            metadata: request ? extractOpenRouterCallModelMetadata(request) : { provider: "openrouter" }
+          };
+        },
+        patchResult: ({ endEvent, result, span }) => {
+          return patchOpenRouterCallModelResult(
+            span,
+            result,
+            getOpenRouterCallModelRequestArg(endEvent.arguments)
+          );
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.toolExecute, {
+        name: "openrouter.tool",
+        type: "tool" /* TOOL */,
+        extractInput: (args, event) => ({
+          input: args[0],
+          metadata: {
+            provider: "openrouter",
+            tool_name: event.toolName,
+            ...event.toolCallId ? { tool_call_id: event.toolCallId } : {}
+          }
+        }),
+        extractOutput: (result) => result,
+        extractMetrics: () => ({}),
+        aggregateChunks: (chunks) => ({
+          output: chunks.length > 0 ? chunks[chunks.length - 1] : void 0,
+          metrics: {}
+        })
+      })
+    );
+    const callModelChannel = openRouterChannels.callModel.tracingChannel();
+    const callModelHandlers = {
+      start: (event) => {
+        const request = getOpenRouterCallModelRequestArg(event.arguments);
+        if (!request) {
+          return;
+        }
+        patchOpenRouterCallModelRequestTools(request);
+      }
+    };
+    callModelChannel.subscribe(callModelHandlers);
+    this.unsubscribers.push(() => {
+      callModelChannel.unsubscribe(callModelHandlers);
+    });
+  }
+};
+function normalizeArgs(args) {
+  if (Array.isArray(args)) {
+    return args;
+  }
+  if (isArrayLike(args)) {
+    return Array.from(args);
+  }
+  return [args];
+}
+function isArrayLike(value) {
+  return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
+}
+function getOpenRouterRequestArg(args) {
+  const normalizedArgs = normalizeArgs(args);
+  const keyedCandidate = normalizedArgs.find(
+    (arg) => isObject(arg) && ("chatGenerationParams" in arg || "requestBody" in arg || "openResponsesRequest" in arg)
+  );
+  if (isObject(keyedCandidate)) {
+    return keyedCandidate;
+  }
+  const firstObjectArg = normalizedArgs.find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function getOpenRouterCallModelRequestArg(args) {
+  const firstObjectArg = normalizeArgs(args).find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function aggregateOpenRouterChatChunks(chunks) {
+  let role;
+  let content = "";
+  let toolCalls;
+  let finishReason;
+  let metrics = {};
+  for (const chunk of chunks) {
+    metrics = {
+      ...metrics,
+      ...parseOpenRouterMetricsFromUsage(_optionalChain([chunk, 'optionalAccess', _276 => _276.usage]))
+    };
+    const choice = _optionalChain([chunk, 'optionalAccess', _277 => _277.choices, 'optionalAccess', _278 => _278[0]]);
+    const delta = _optionalChain([choice, 'optionalAccess', _279 => _279.delta]);
+    if (!delta) {
+      if (_optionalChain([choice, 'optionalAccess', _280 => _280.finish_reason]) !== void 0) {
+        finishReason = choice.finish_reason;
+      }
+      continue;
+    }
+    if (!role && delta.role) {
+      role = delta.role;
+    }
+    if (typeof delta.content === "string") {
+      content += delta.content;
+    }
+    const choiceFinishReason = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _281 => _281.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _282 => _282.finish_reason]))), () => ( void 0));
+    const deltaFinishReason = _nullishCoalesce(_nullishCoalesce(delta.finishReason, () => ( delta.finish_reason)), () => ( void 0));
+    if (choiceFinishReason !== void 0) {
+      finishReason = choiceFinishReason;
+    } else if (deltaFinishReason !== void 0) {
+      finishReason = deltaFinishReason;
+    }
+    const toolCallDeltas = Array.isArray(delta.toolCalls) ? delta.toolCalls : Array.isArray(delta.tool_calls) ? delta.tool_calls : void 0;
+    if (!toolCallDeltas) {
+      continue;
+    }
+    for (const toolDelta of toolCallDeltas) {
+      if (!_optionalChain([toolDelta, 'optionalAccess', _283 => _283.function])) {
+        continue;
+      }
+      const toolIndex = _nullishCoalesce(toolDelta.index, () => ( 0));
+      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _284 => _284[toolIndex]]);
+      if (!existingToolCall || toolDelta.id && existingToolCall.id !== void 0 && existingToolCall.id !== toolDelta.id) {
+        const nextToolCalls = [...toolCalls || []];
+        nextToolCalls[toolIndex] = {
+          index: toolIndex,
+          id: toolDelta.id,
+          type: toolDelta.type,
+          function: {
+            name: toolDelta.function.name,
+            arguments: toolDelta.function.arguments || ""
+          }
+        };
+        toolCalls = nextToolCalls;
+        continue;
+      }
+      const current = existingToolCall;
+      if (toolDelta.id && !current.id) {
+        current.id = toolDelta.id;
+      }
+      if (toolDelta.type && !current.type) {
+        current.type = toolDelta.type;
+      }
+      if (toolDelta.function.name && !current.function.name) {
+        current.function.name = toolDelta.function.name;
+      }
+      current.function.arguments += toolDelta.function.arguments || "";
+    }
+  }
+  return {
+    output: [
+      {
+        index: 0,
+        message: {
+          role,
+          content: content || void 0,
+          ...toolCalls ? { tool_calls: toolCalls } : {}
+        },
+        logprobs: null,
+        finish_reason: finishReason
+      }
+    ],
+    metrics
+  };
+}
+function aggregateOpenRouterResponseStreamEvents(chunks) {
+  let finalResponse;
+  for (const chunk of chunks) {
+    const response = _optionalChain([chunk, 'optionalAccess', _285 => _285.response]);
+    if (!response) {
+      continue;
+    }
+    if (chunk.type === "response.completed" || chunk.type === "response.incomplete" || chunk.type === "response.failed") {
+      finalResponse = response;
+    }
+  }
+  if (!finalResponse) {
+    return {
+      output: void 0,
+      metrics: {}
+    };
+  }
+  return {
+    output: extractOpenRouterResponseOutput(finalResponse),
+    metrics: parseOpenRouterMetricsFromUsage(finalResponse.usage),
+    ...extractOpenRouterResponseMetadata(finalResponse) ? { metadata: extractOpenRouterResponseMetadata(finalResponse) } : {}
+  };
+}
+
 // src/instrumentation/braintrust-plugin.ts
 var BraintrustPlugin = (_class18 = class extends BasePlugin {
   
@@ -12152,8 +13283,9 @@ var BraintrustPlugin = (_class18 = class extends BasePlugin {
   __init66() {this.aiSDKPlugin = null}
   __init67() {this.claudeAgentSDKPlugin = null}
   __init68() {this.googleGenAIPlugin = null}
+  __init69() {this.openRouterPlugin = null}
   constructor(config = {}) {
-    super();_class18.prototype.__init64.call(this);_class18.prototype.__init65.call(this);_class18.prototype.__init66.call(this);_class18.prototype.__init67.call(this);_class18.prototype.__init68.call(this);;
+    super();_class18.prototype.__init64.call(this);_class18.prototype.__init65.call(this);_class18.prototype.__init66.call(this);_class18.prototype.__init67.call(this);_class18.prototype.__init68.call(this);_class18.prototype.__init69.call(this);;
     this.config = config;
   }
   onEnable() {
@@ -12178,6 +13310,10 @@ var BraintrustPlugin = (_class18 = class extends BasePlugin {
       this.googleGenAIPlugin = new GoogleGenAIPlugin();
       this.googleGenAIPlugin.enable();
     }
+    if (integrations.openrouter !== false) {
+      this.openRouterPlugin = new OpenRouterPlugin();
+      this.openRouterPlugin.enable();
+    }
   }
   onDisable() {
     if (this.openaiPlugin) {
@@ -12200,14 +13336,18 @@ var BraintrustPlugin = (_class18 = class extends BasePlugin {
       this.googleGenAIPlugin.disable();
       this.googleGenAIPlugin = null;
     }
+    if (this.openRouterPlugin) {
+      this.openRouterPlugin.disable();
+      this.openRouterPlugin = null;
+    }
   }
 }, _class18);
 
 // src/instrumentation/registry.ts
-var PluginRegistry = (_class19 = class {constructor() { _class19.prototype.__init69.call(this);_class19.prototype.__init70.call(this);_class19.prototype.__init71.call(this); }
-  __init69() {this.braintrustPlugin = null}
-  __init70() {this.config = {}}
-  __init71() {this.enabled = false}
+var PluginRegistry = (_class19 = class {constructor() { _class19.prototype.__init70.call(this);_class19.prototype.__init71.call(this);_class19.prototype.__init72.call(this); }
+  __init70() {this.braintrustPlugin = null}
+  __init71() {this.config = {}}
+  __init72() {this.enabled = false}
   /**
    * Configure which integrations should be enabled.
    * This must be called before any SDK imports to take effect.
@@ -12271,7 +13411,8 @@ var PluginRegistry = (_class19 = class {constructor() { _class19.prototype.__ini
       vercel: true,
       aisdk: true,
       google: true,
-      claudeAgentSDK: true
+      claudeAgentSDK: true,
+      openrouter: true
     };
   }
   /**
@@ -12301,6 +13442,7 @@ function configureNode() {
   isomorph_default.getCallerLocation = getCallerLocation;
   isomorph_default.newAsyncLocalStorage = () => new (0, _nodeasync_hooks.AsyncLocalStorage)();
   isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
+  patchTracingChannel(diagnostics_channel.tracingChannel);
   isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };
@@ -12405,7 +13547,7 @@ function isAsync(fn) {
 function isAsyncGenerator2(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable2(obj) {
+function isAsyncIterable3(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -12455,7 +13597,7 @@ function _asyncMap(eachfn, arr, iteratee, callback) {
     callback(err, results);
   });
 }
-function isArrayLike(value) {
+function isArrayLike2(value) {
   return value && typeof value.length === "number" && value.length >= 0 && value.length % 1 === 0;
 }
 var breakLoop = {};
@@ -12503,7 +13645,7 @@ function createObjectIterator(obj) {
   };
 }
 function createIterator(coll) {
-  if (isArrayLike(coll)) {
+  if (isArrayLike2(coll)) {
     return createArrayIterator(coll);
   }
   var iterator = getIterator(coll);
@@ -12577,7 +13719,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator2(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable2(obj)) {
+    if (isAsyncIterable3(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -12649,7 +13791,7 @@ function eachOfGeneric(coll, iteratee, callback) {
   return eachOfLimit$1(coll, Infinity, iteratee, callback);
 }
 function eachOf(coll, iteratee, callback) {
-  var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;
+  var eachOfImplementation = isArrayLike2(coll) ? eachOfArrayLike : eachOfGeneric;
   return eachOfImplementation(coll, wrapAsync(iteratee), callback);
 }
 var eachOf$1 = awaitify(eachOf, 3);
@@ -13164,7 +14306,7 @@ function filterGeneric(eachfn, coll, iteratee, callback) {
   });
 }
 function _filter(eachfn, coll, iteratee, callback) {
-  var filter2 = isArrayLike(coll) ? filterArray : filterGeneric;
+  var filter2 = isArrayLike2(coll) ? filterArray : filterGeneric;
   return filter2(eachfn, coll, wrapAsync(iteratee), callback);
 }
 function filter(coll, iteratee, callback) {
@@ -13239,7 +14381,7 @@ if (hasNextTick) {
 }
 var nextTick = wrap(_defer);
 var _parallel = awaitify((eachfn, tasks, callback) => {
-  var results = isArrayLike(tasks) ? [] : {};
+  var results = isArrayLike2(tasks) ? [] : {};
   eachfn(tasks, (task, key, taskCb) => {
     wrapAsync(task)((err, ...result) => {
       if (result.length < 2) {
@@ -13506,10 +14648,10 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
   }
 };
 var CachedSpanFetcher = (_class20 = class {
-  __init72() {this.spanCache = /* @__PURE__ */ new Map()}
-  __init73() {this.allFetched = false}
+  __init73() {this.spanCache = /* @__PURE__ */ new Map()}
+  __init74() {this.allFetched = false}
   
-  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class20.prototype.__init72.call(this);_class20.prototype.__init73.call(this);
+  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class20.prototype.__init73.call(this);_class20.prototype.__init74.call(this);
     if (typeof objectTypeOrFetchFn === "function") {
       this.fetchFn = objectTypeOrFetchFn;
     } else {
@@ -13524,7 +14666,7 @@ var CachedSpanFetcher = (_class20 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _224 => _224.span_attributes, 'optionalAccess', _225 => _225.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _286 => _286.span_attributes, 'optionalAccess', _287 => _287.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -13558,7 +14700,7 @@ var CachedSpanFetcher = (_class20 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _226 => _226.span_attributes, 'optionalAccess', _227 => _227.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _288 => _288.span_attributes, 'optionalAccess', _289 => _289.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -13582,17 +14724,17 @@ var LocalTrace = (_class21 = class {
   
   
   
-  __init74() {this.spansFlushed = false}
-  __init75() {this.spansFlushPromise = null}
+  __init75() {this.spansFlushed = false}
+  __init76() {this.spansFlushPromise = null}
   
-  __init76() {this.threadCache = /* @__PURE__ */ new Map()}
+  __init77() {this.threadCache = /* @__PURE__ */ new Map()}
   constructor({
     objectType,
     objectId,
     rootSpanId,
     ensureSpansFlushed,
     state
-  }) {;_class21.prototype.__init74.call(this);_class21.prototype.__init75.call(this);_class21.prototype.__init76.call(this);
+  }) {;_class21.prototype.__init75.call(this);_class21.prototype.__init76.call(this);_class21.prototype.__init77.call(this);
     this.objectType = objectType;
     this.objectId = objectId;
     this.rootSpanId = rootSpanId;
@@ -13638,11 +14780,11 @@ var LocalTrace = (_class21 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _228 => _228.span_attributes, 'optionalAccess', _229 => _229.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _290 => _290.span_attributes, 'optionalAccess', _291 => _291.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _230 => _230.span_attributes, 'optionalAccess', _231 => _231.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _292 => _292.span_attributes, 'optionalAccess', _293 => _293.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -13661,7 +14803,7 @@ var LocalTrace = (_class21 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _232 => _232.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _294 => _294.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -13672,7 +14814,7 @@ var LocalTrace = (_class21 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _233 => _233.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _295 => _295.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -13848,10 +14990,10 @@ function validateParametersWithJsonSchema(parameters, schema) {
   const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
   const validate = ajv.compile(schema);
   if (!validate(parameters)) {
-    const errorMessages = _optionalChain([validate, 'access', _234 => _234.errors, 'optionalAccess', _235 => _235.map, 'call', _236 => _236((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _296 => _296.errors, 'optionalAccess', _297 => _297.map, 'call', _298 => _298((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _237 => _237.join, 'call', _238 => _238(", ")]);
+    }), 'access', _299 => _299.join, 'call', _300 => _300(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return parameters;
@@ -13920,7 +15062,7 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable3(value) {
+function isAsyncIterable4(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
@@ -14089,7 +15231,7 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters, st
 }
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _239 => _239.spanCache, 'optionalAccess', _240 => _240.start, 'call', _241 => _241()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _301 => _301.spanCache, 'optionalAccess', _302 => _302.start, 'call', _303 => _303()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -14125,7 +15267,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     }
     const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
     const dataIterable = (() => {
-      if (isAsyncIterable3(resolvedDataResult)) {
+      if (isAsyncIterable4(resolvedDataResult)) {
         return resolvedDataResult;
       }
       if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
@@ -14144,7 +15286,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const experimentIdPromise = experiment ? (async () => {
       try {
         return await experiment.id;
-      } catch (e27) {
+      } catch (e29) {
         return void 0;
       }
     })() : void 0;
@@ -14200,7 +15342,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _242 => _242.data, 'access', async _243 => _243.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _304 => _304.data, 'access', async _305 => _305.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -14226,10 +15368,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _244 => _244({
+                    _optionalChain([stream, 'optionalCall', _306 => _306({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _245 => _245.event, 'optionalAccess', _246 => _246.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _307 => _307.event, 'optionalAccess', _308 => _308.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -14393,7 +15535,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _247 => _247.event, 'optionalAccess', _248 => _248.origin])
+              origin: _optionalChain([baseEvent, 'access', _309 => _309.event, 'optionalAccess', _310 => _310.origin])
             });
           }
         };
@@ -14428,7 +15570,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _249 => _249.setTotal, 'optionalCall', _250 => _250(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _311 => _311.setTotal, 'optionalCall', _312 => _312(evaluator.evalName, scheduledTrials)]);
           q.pushAsync({ datum, trialIndex }).catch((e) => {
             if (queueErrors.length < 5) {
               queueErrors.push(e);
@@ -14513,9 +15655,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _251 => _251.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _252 => _252.dispose, 'call', _253 => _253()]);
-      _optionalChain([spanCache, 'optionalAccess', _254 => _254.stop, 'call', _255 => _255()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _313 => _313.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _314 => _314.dispose, 'call', _315 => _315()]);
+      _optionalChain([spanCache, 'optionalAccess', _316 => _316.stop, 'call', _317 => _317()]);
     }
   }
 }
@@ -14752,7 +15894,7 @@ async function cachedLogin(options) {
 }
 function makeCheckAuthorized(allowedOrgName) {
   return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _256 => _256.ctx, 'optionalAccess', _257 => _257.token])) {
+    if (!_optionalChain([req, 'access', _318 => _318.ctx, 'optionalAccess', _319 => _319.token])) {
       return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
     try {
@@ -14765,7 +15907,7 @@ function makeCheckAuthorized(allowedOrgName) {
         return next(_httperrors2.default.call(void 0, 403, errorMessage));
       }
       const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _258 => _258.ctx, 'optionalAccess', _259 => _259.token]),
+        apiKey: _optionalChain([req, 'access', _320 => _320.ctx, 'optionalAccess', _321 => _321.token]),
         orgName
       });
       req.ctx.state = state;
@@ -14962,10 +16104,10 @@ var Project2 = (_class22 = class {
   
   
   
-  __init77() {this._publishableCodeFunctions = []}
-  __init78() {this._publishablePrompts = []}
-  __init79() {this._publishableParameters = []}
-  constructor(args) {;_class22.prototype.__init77.call(this);_class22.prototype.__init78.call(this);_class22.prototype.__init79.call(this);
+  __init78() {this._publishableCodeFunctions = []}
+  __init79() {this._publishablePrompts = []}
+  __init80() {this._publishableParameters = []}
+  constructor(args) {;_class22.prototype.__init78.call(this);_class22.prototype.__init79.call(this);_class22.prototype.__init80.call(this);
     _initializeSpanContext();
     this.name = "name" in args ? args.name : void 0;
     this.id = "id" in args ? args.id : void 0;
@@ -15019,10 +16161,10 @@ var Project2 = (_class22 = class {
   }
 }, _class22);
 var ToolBuilder = (_class23 = class {
-  constructor(project) {;_class23.prototype.__init80.call(this);
+  constructor(project) {;_class23.prototype.__init81.call(this);
     this.project = project;
   }
-  __init80() {this.taskCounter = 0}
+  __init81() {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) {
@@ -15049,10 +16191,10 @@ var ToolBuilder = (_class23 = class {
   }
 }, _class23);
 var ScorerBuilder = (_class24 = class {
-  constructor(project) {;_class24.prototype.__init81.call(this);
+  constructor(project) {;_class24.prototype.__init82.call(this);
     this.project = project;
   }
-  __init81() {this.taskCounter = 0}
+  __init82() {this.taskCounter = 0}
   create(opts) {
     this.taskCounter++;
     let resolvedName = opts.name;
@@ -15407,9 +16549,9 @@ function serializeRemoteEvalParametersContainer(parameters) {
     source: null
   };
 }
-var ProjectNameIdMap = (_class25 = class {constructor() { _class25.prototype.__init82.call(this);_class25.prototype.__init83.call(this); }
-  __init82() {this.nameToId = {}}
-  __init83() {this.idToName = {}}
+var ProjectNameIdMap = (_class25 = class {constructor() { _class25.prototype.__init83.call(this);_class25.prototype.__init84.call(this); }
+  __init83() {this.nameToId = {}}
+  __init84() {this.idToName = {}}
   async getId(projectName) {
     if (!(projectName in this.nameToId)) {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
@@ -15514,7 +16656,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _260 => _260.ctx, 'optionalAccess', _261 => _261.state])) {
+      if (!_optionalChain([req, 'access', _322 => _322.ctx, 'optionalAccess', _323 => _323.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -15565,12 +16707,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: evaluator.scores.concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _262 => _262.map, 'call', _263 => _263(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _324 => _324.map, 'call', _325 => _325(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _264 => _264.ctx, 'optionalAccess', _265 => _265.projectId])
+                  _optionalChain([req, 'access', _326 => _326.ctx, 'optionalAccess', _327 => _327.projectId])
                 )
               )]), () => ( []))
             ),