braintrust 3.3.0 → 3.4.0

package/dev/dist/index.js

@@ -1,5 +1,6 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28;// src/node/config.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25;// src/node/config.ts
 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);
 var _promises = require('node:fs/promises'); var fs = _interopRequireWildcard(_promises);
 var _nodeos = require('node:os'); var os = _interopRequireWildcard(_nodeos);
@@ -21,6 +22,26 @@ var DefaultAsyncLocalStorage = class {
     return void 0;
   }
 };
+var DefaultTracingChannel = (_class = class {constructor() { _class.prototype.__init.call(this); }
+  __init() {this.hasSubscribers = false}
+  subscribe(_handlers) {
+  }
+  unsubscribe(_handlers) {
+    return false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  traceSync(fn, _message, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  tracePromise(fn, _message, thisArg, ...args) {
+    return Promise.resolve(fn.apply(thisArg, args));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  traceCallback(fn, _position, _message, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+}, _class);
 var iso = {
   buildType: "unknown",
   // Will be set by configureBrowser() or configureNode()
@@ -29,6 +50,8 @@ var iso = {
   getEnv: (_name) => void 0,
   getCallerLocation: () => void 0,
   newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  newTracingChannel: (_nameOrChannels) => new DefaultTracingChannel(),
   processOn: (_0, _1) => {
   },
   basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
@@ -36,6 +59,111 @@ var iso = {
 };
 var isomorph_default = iso;
 
+// src/debug-logger.ts
+var PREFIX = "[braintrust]";
+var DEBUG_LOG_LEVEL_SYMBOL = Symbol.for("braintrust-debug-log-level");
+var LOG_LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+var hasWarnedAboutInvalidEnvValue = false;
+var debugLogStateResolver = void 0;
+function warnInvalidEnvValue(value) {
+  if (hasWarnedAboutInvalidEnvValue) {
+    return;
+  }
+  hasWarnedAboutInvalidEnvValue = true;
+  console.warn(
+    PREFIX,
+    `Invalid BRAINTRUST_DEBUG_LOG_LEVEL value "${value}". Expected "error", "warn", "info", or "debug".`
+  );
+}
+function normalizeDebugLogLevelOption(option) {
+  if (option === false) {
+    return void 0;
+  }
+  if (option === "error" || option === "warn" || option === "info" || option === "debug") {
+    return option;
+  }
+  throw new Error(
+    `Invalid debugLogLevel value "${option}". Expected false, "error", "warn", "info", or "debug".`
+  );
+}
+function parseDebugLogLevelEnv(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (value === "error" || value === "warn" || value === "info" || value === "debug") {
+    return value;
+  }
+  warnInvalidEnvValue(value);
+  return void 0;
+}
+function getEnvDebugLogLevel() {
+  return parseDebugLogLevelEnv(isomorph_default.getEnv("BRAINTRUST_DEBUG_LOG_LEVEL"));
+}
+function setGlobalDebugLogLevel(level) {
+  globalThis[DEBUG_LOG_LEVEL_SYMBOL] = level;
+}
+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));
+  if (hasStateOverride) {
+    return stateLevel;
+  }
+  const globalLevel = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    globalThis[DEBUG_LOG_LEVEL_SYMBOL]
+  );
+  if (globalLevel !== void 0) {
+    return globalLevel === false ? void 0 : globalLevel;
+  }
+  return getEnvDebugLogLevel();
+}
+function emit(method, state, args) {
+  const level = resolveDebugLogLevel(state);
+  if (!level || LOG_LEVEL_PRIORITY[method] > LOG_LEVEL_PRIORITY[level]) {
+    return;
+  }
+  if (method === "info") {
+    console.log(PREFIX, ...args);
+  } else if (method === "debug") {
+    console.debug(PREFIX, ...args);
+  } else if (method === "warn") {
+    console.warn(PREFIX, ...args);
+  } else {
+    console.error(PREFIX, ...args);
+  }
+}
+function createDebugLogger(state) {
+  const resolveState = () => _nullishCoalesce(state, () => ( _optionalChain([debugLogStateResolver, 'optionalCall', _6 => _6()])));
+  return {
+    info(...args) {
+      emit("info", resolveState(), args);
+    },
+    debug(...args) {
+      emit("debug", resolveState(), args);
+    },
+    warn(...args) {
+      emit("warn", resolveState(), args);
+    },
+    error(...args) {
+      emit("error", resolveState(), args);
+    }
+  };
+}
+var debugLogger = {
+  ...createDebugLogger(),
+  forState(state) {
+    return createDebugLogger(state);
+  }
+};
+
 // src/gitutil.ts
 var _simplegit = require('simple-git');
 var COMMON_BASE_BRANCHES = ["main", "master", "develop"];
@@ -58,7 +186,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 _2 => _2[0], 'optionalAccess', async _3 => _3.name])));
+    const remoteName = await _asyncNullishCoalesce(remote, async () => ( await _asyncOptionalChain([(await git.getRemotes()), 'access', async _7 => _7[0], 'optionalAccess', async _8 => _8.name])));
     if (!remoteName) {
       throw new Error("No remote found");
     }
@@ -116,7 +244,7 @@ async function getPastNAncestors(n = 1e3, remote = void 0) {
   try {
     ancestor = await getBaseBranchAncestor(remote);
   } catch (e) {
-    console.warn(
+    debugLogger.warn(
       "Skipping git metadata. This is likely because the repository has not been published to a remote yet.",
       `${e}`
     );
@@ -151,7 +279,7 @@ async function getRepoInfo(settings) {
     return repo;
   }
   let sanitized = {};
-  _optionalChain([settings, 'access', _4 => _4.fields, 'optionalAccess', _5 => _5.forEach, 'call', _6 => _6((field) => {
+  _optionalChain([settings, 'access', _9 => _9.fields, 'optionalAccess', _10 => _10.forEach, 'call', _11 => _11((field) => {
     sanitized = { ...sanitized, [field]: repo[field] };
   })]);
   return sanitized;
@@ -237,9 +365,9 @@ function getCallerLocation() {
   const entries = getStackTrace();
   for (const frame of entries) {
     if (thisDir === void 0) {
-      thisDir = _optionalChain([isomorph_default, 'access', _7 => _7.pathDirname, 'optionalCall', _8 => _8(frame.fileName)]);
+      thisDir = _optionalChain([isomorph_default, 'access', _12 => _12.pathDirname, 'optionalCall', _13 => _13(frame.fileName)]);
     }
-    if (_optionalChain([isomorph_default, 'access', _9 => _9.pathDirname, 'optionalCall', _10 => _10(frame.fileName)]) !== thisDir) {
+    if (_optionalChain([isomorph_default, 'access', _14 => _14.pathDirname, 'optionalCall', _15 => _15(frame.fileName)]) !== thisDir) {
       return {
         caller_functionname: frame.functionName,
         caller_filename: frame.fileName,
@@ -255,13 +383,13 @@ var _uuid = require('uuid'); var uuid3 = _interopRequireWildcard(_uuid); var uui
 
 // src/queue.ts
 var DEFAULT_QUEUE_SIZE = 15e3;
-var Queue = (_class = class {
-  __init() {this.items = []}
+var Queue = (_class2 = class {
+  __init2() {this.items = []}
   
-  __init2() {this.enforceSizeLimit = false}
-  constructor(maxSize) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+  __init3() {this.enforceSizeLimit = false}
+  constructor(maxSize) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
     if (maxSize < 1) {
-      console.warn(
+      debugLogger.warn(
         `maxSize ${maxSize} is <1, using default ${DEFAULT_QUEUE_SIZE}`
       );
       maxSize = DEFAULT_QUEUE_SIZE;
@@ -307,7 +435,7 @@ var Queue = (_class = class {
   get capacity() {
     return this.maxSize;
   }
-}, _class);
+}, _class2);
 
 // src/id-gen.ts
 
@@ -486,7 +614,7 @@ var SpanComponentsV1 = class _SpanComponentsV1 {
     return {
       objectType: this.objectType,
       objectId: this.objectId,
-      rowIds: _optionalChain([this, 'access', _11 => _11.rowIds, 'optionalAccess', _12 => _12.toObject, 'call', _13 => _13()])
+      rowIds: _optionalChain([this, 'access', _16 => _16.rowIds, 'optionalAccess', _17 => _17.toObject, 'call', _18 => _18()])
     };
   }
 };
@@ -700,7 +828,7 @@ var SpanComponentsV2 = class _SpanComponentsV2 {
       objectType: this.objectType,
       objectId: this.objectId,
       computeObjectMetadataArgs: this.computeObjectMetadataArgs,
-      rowIds: _optionalChain([this, 'access', _14 => _14.rowIds, 'optionalAccess', _15 => _15.toObject, 'call', _16 => _16()])
+      rowIds: _optionalChain([this, 'access', _19 => _19.rowIds, 'optionalAccess', _20 => _20.toObject, 'call', _21 => _21()])
     };
   }
 };
@@ -1240,20 +1368,20 @@ function slugify(text, options) {
     \u00FF: "y"
   };
   const replacement = "-";
-  const trim = _optionalChain([options, 'optionalAccess', _17 => _17.trim]) !== false;
+  const trim = _optionalChain([options, 'optionalAccess', _22 => _22.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', _18 => _18.strict])) {
+  if (_optionalChain([options, 'optionalAccess', _23 => _23.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', _19 => _19.lower])) {
+  if (_optionalChain([options, 'optionalAccess', _24 => _24.lower])) {
     slug = slug.toLowerCase();
   }
   return slug;
@@ -1555,13 +1683,13 @@ function getCurrentUnixTimestamp() {
 function isEmpty2(a) {
   return a === void 0 || a === null;
 }
-var LazyValue = (_class2 = class {
+var LazyValue = (_class3 = class {
   
-  __init3() {this.resolvedValue = void 0}
-  __init4() {this.value = {
+  __init4() {this.resolvedValue = void 0}
+  __init5() {this.value = {
     computedState: "uninitialized"
   }}
-  constructor(callable) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+  constructor(callable) {;_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);
     this.callable = callable;
   }
   get() {
@@ -1589,13 +1717,13 @@ var LazyValue = (_class2 = class {
   get hasSucceeded() {
     return this.value.computedState === "succeeded";
   }
-}, _class2);
-var SyncLazyValue = (_class3 = class {
+}, _class3);
+var SyncLazyValue = (_class4 = class {
   
-  __init5() {this.value = {
+  __init6() {this.value = {
     computedState: "uninitialized"
   }}
-  constructor(callable) {;_class3.prototype.__init5.call(this);
+  constructor(callable) {;_class4.prototype.__init6.call(this);
     this.callable = callable;
   }
   get() {
@@ -1611,7 +1739,7 @@ var SyncLazyValue = (_class3 = class {
   get hasSucceeded() {
     return this.value.computedState === "succeeded";
   }
-}, _class3);
+}, _class4);
 function addAzureBlobHeaders(headers, url) {
   if (url.includes("blob.core.windows.net")) {
     headers["x-ms-blob-type"] = "BlockBlob";
@@ -3380,8 +3508,8 @@ var mustachePlugin = {
   defaultOptions: { strict: true, escape: jsonEscape },
   createRenderer() {
     const opts = _nullishCoalesce(this.defaultOptions, () => ( {}));
-    const escapeFn = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _20 => _20.escape]), () => ( jsonEscape));
-    const strictDefault = typeof _optionalChain([opts, 'optionalAccess', _21 => _21.strict]) === "boolean" ? opts.strict : true;
+    const escapeFn = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _25 => _25.escape]), () => ( jsonEscape));
+    const strictDefault = typeof _optionalChain([opts, 'optionalAccess', _26 => _26.strict]) === "boolean" ? opts.strict : true;
     return {
       render(template, variables, escape, strict) {
         const esc = _nullishCoalesce(escape, () => ( escapeFn));
@@ -3397,8 +3525,8 @@ var mustachePlugin = {
 };
 
 // src/template/registry.ts
-var TemplatePluginRegistry = (_class4 = class {constructor() { _class4.prototype.__init6.call(this); }
-  __init6() {this.plugins = /* @__PURE__ */ new Map()}
+var TemplatePluginRegistry = (_class5 = class {constructor() { _class5.prototype.__init7.call(this); }
+  __init7() {this.plugins = /* @__PURE__ */ new Map()}
   register(plugin) {
     if (this.plugins.has(plugin.name)) {
       console.warn(
@@ -3415,12 +3543,12 @@ var TemplatePluginRegistry = (_class4 = class {constructor() { _class4.prototype
     return Array.from(this.plugins.keys());
   }
   get(name) {
-    return _optionalChain([this, 'access', _22 => _22.plugins, 'access', _23 => _23.get, 'call', _24 => _24(name), 'optionalAccess', _25 => _25.renderer]);
+    return _optionalChain([this, 'access', _27 => _27.plugins, 'access', _28 => _28.get, 'call', _29 => _29(name), 'optionalAccess', _30 => _30.renderer]);
   }
   isRegistered(name) {
     return this.plugins.has(name);
   }
-}, _class4);
+}, _class5);
 var templateRegistry = new TemplatePluginRegistry();
 var registerTemplatePlugin = templateRegistry.register.bind(templateRegistry);
 var getTemplateRenderer = templateRegistry.get.bind(templateRegistry);
@@ -4034,22 +4162,22 @@ var exitHandlersRegistered = false;
 function canUseSpanCache() {
   return !!(isomorph_default.pathJoin && isomorph_default.tmpdir && isomorph_default.writeFileSync && isomorph_default.appendFileSync && isomorph_default.readFileSync && isomorph_default.unlinkSync && isomorph_default.openFile);
 }
-var SpanCache = (_class5 = class {
-  __init7() {this.cacheFilePath = null}
-  __init8() {this.fileHandle = null}
+var SpanCache = (_class6 = class {
+  __init8() {this.cacheFilePath = null}
+  __init9() {this.fileHandle = null}
   // type-erased fs.promises.FileHandle
-  __init9() {this.initialized = false}
-  __init10() {this.initPromise = null}
+  __init10() {this.initialized = false}
+  __init11() {this.initPromise = null}
   // Tracks whether the cache was explicitly disabled (via constructor or disable())
   
   // Tracks whether the cache has been enabled (for evals only)
-  __init11() {this._enabled = false}
+  __init12() {this._enabled = false}
   // Reference count of active evals using this cache
-  __init12() {this._activeEvalCount = 0}
+  __init13() {this._activeEvalCount = 0}
   // Small in-memory index tracking which rootSpanIds have data
-  __init13() {this.rootSpanIndex = /* @__PURE__ */ new Set()}
-  constructor(options) {;_class5.prototype.__init7.call(this);_class5.prototype.__init8.call(this);_class5.prototype.__init9.call(this);_class5.prototype.__init10.call(this);_class5.prototype.__init11.call(this);_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);
-    this._explicitlyDisabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _26 => _26.disabled]), () => ( false));
+  __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));
   }
   /**
    * Disable the cache at runtime. This is called automatically when
@@ -4145,9 +4273,9 @@ var SpanCache = (_class5 = class {
     }
   }
   // Buffer for pending writes - flushed asynchronously
-  __init14() {this.writeBuffer = []}
-  __init15() {this.flushScheduled = false}
-  __init16() {this.flushPromise = null}
+  __init15() {this.writeBuffer = []}
+  __init16() {this.flushScheduled = false}
+  __init17() {this.flushPromise = null}
   /**
    * Queue a span write for async flushing.
    * This is non-blocking - writes are buffered in memory and flushed
@@ -4313,7 +4441,7 @@ var SpanCache = (_class5 = class {
     this.initPromise = null;
     this.rootSpanIndex.clear();
   }
-}, _class5);
+}, _class6);
 
 // src/logger.ts
 var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
@@ -4407,13 +4535,13 @@ function getSpanComponentsClass() {
 function getContextManager() {
   return globalThis.BRAINTRUST_CONTEXT_MANAGER ? new globalThis.BRAINTRUST_CONTEXT_MANAGER() : new BraintrustContextManager();
 }
-var NoopSpan = (_class6 = class {
+var NoopSpan = (_class7 = class {
   
   
   
   
-  __init17() {this.kind = "span"}
-  constructor() {;_class6.prototype.__init17.call(this);
+  __init18() {this.kind = "span"}
+  constructor() {;_class7.prototype.__init18.call(this);
     this.id = "";
     this.spanId = "";
     this.rootSpanId = "";
@@ -4433,7 +4561,7 @@ var NoopSpan = (_class6 = class {
     return this;
   }
   end(args) {
-    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _27 => _27.endTime]), () => ( getCurrentUnixTimestamp()));
+    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _32 => _32.endTime]), () => ( getCurrentUnixTimestamp()));
   }
   async export() {
     return "";
@@ -4471,7 +4599,7 @@ var NoopSpan = (_class6 = class {
   toString() {
     return `NoopSpan(id=${this.id}, spanId=${this.spanId})`;
   }
-}, _class6);
+}, _class7);
 var NOOP_SPAN = new NoopSpan();
 var NOOP_SPAN_PERMALINK = "https://braintrust.dev/noop-span";
 var loginSchema = _v3.z.strictObject({
@@ -4482,11 +4610,14 @@ var loginSchema = _v3.z.strictObject({
   proxyUrl: _v3.z.string(),
   loginToken: _v3.z.string(),
   orgId: _v3.z.string().nullish(),
-  gitMetadataSettings: GitMetadataSettings.nullish()
+  gitMetadataSettings: GitMetadataSettings.nullish(),
+  debugLogLevel: _v3.z.enum(["error", "warn", "info", "debug"]).optional(),
+  // Distinguishes explicit false from unset so env fallback stays disabled after deserialization.
+  debugLogLevelDisabled: _v3.z.boolean().optional()
 });
 var stateNonce = 0;
-var BraintrustState = (_class7 = class _BraintrustState {
-  constructor(loginParams) {;_class7.prototype.__init18.call(this);_class7.prototype.__init19.call(this);_class7.prototype.__init20.call(this);_class7.prototype.__init21.call(this);_class7.prototype.__init22.call(this);_class7.prototype.__init23.call(this);_class7.prototype.__init24.call(this);_class7.prototype.__init25.call(this);_class7.prototype.__init26.call(this);_class7.prototype.__init27.call(this);_class7.prototype.__init28.call(this);_class7.prototype.__init29.call(this);_class7.prototype.__init30.call(this);_class7.prototype.__init31.call(this);_class7.prototype.__init32.call(this);_class7.prototype.__init33.call(this);
+var BraintrustState = (_class8 = class _BraintrustState {
+  constructor(loginParams) {;_class8.prototype.__init19.call(this);_class8.prototype.__init20.call(this);_class8.prototype.__init21.call(this);_class8.prototype.__init22.call(this);_class8.prototype.__init23.call(this);_class8.prototype.__init24.call(this);_class8.prototype.__init25.call(this);_class8.prototype.__init26.call(this);_class8.prototype.__init27.call(this);_class8.prototype.__init28.call(this);_class8.prototype.__init29.call(this);_class8.prototype.__init30.call(this);_class8.prototype.__init31.call(this);_class8.prototype.__init32.call(this);_class8.prototype.__init33.call(this);_class8.prototype.__init34.call(this);_class8.prototype.__init35.call(this);
     this.loginParams = loginParams;
     this.id = `${(/* @__PURE__ */ new Date()).toLocaleString()}-${stateNonce++}`;
     this.currentExperiment = void 0;
@@ -4503,6 +4634,16 @@ var BraintrustState = (_class7 = class _BraintrustState {
     this._bgLogger = new SyncLazyValue(
       () => new HTTPBackgroundLogger(new LazyValue(defaultGetLogConn), loginParams)
     );
+    if (loginParams.debugLogLevel !== void 0) {
+      this.debugLogLevelConfigured = true;
+      this.debugLogLevel = normalizeDebugLogLevelOption(
+        loginParams.debugLogLevel
+      );
+      setGlobalDebugLogLevel(_nullishCoalesce(this.debugLogLevel, () => ( false)));
+    } else {
+      this.debugLogLevel = getEnvDebugLogLevel();
+      setGlobalDebugLogLevel(void 0);
+    }
     this.resetLoginInfo();
     const memoryCache = new LRUCache({
       max: _nullishCoalesce(Number(isomorph_default.getEnv("BRAINTRUST_PROMPT_CACHE_MEMORY_MAX")), () => ( 1 << 10))
@@ -4537,26 +4678,28 @@ var BraintrustState = (_class7 = class _BraintrustState {
   // possibility of multiple loggers floating around, which may not log in a
   // deterministic order.
   
-  __init18() {this._overrideBgLogger = null}
-  __init19() {this.appUrl = null}
-  __init20() {this.appPublicUrl = null}
-  __init21() {this.loginToken = null}
-  __init22() {this.orgId = null}
-  __init23() {this.orgName = null}
-  __init24() {this.apiUrl = null}
-  __init25() {this.proxyUrl = null}
-  __init26() {this.loggedIn = false}
+  __init19() {this._overrideBgLogger = null}
+  __init20() {this.appUrl = null}
+  __init21() {this.appPublicUrl = null}
+  __init22() {this.loginToken = null}
+  __init23() {this.orgId = null}
+  __init24() {this.orgName = null}
+  __init25() {this.apiUrl = null}
+  __init26() {this.proxyUrl = null}
+  __init27() {this.loggedIn = false}
+  
   
-  __init27() {this.fetch = globalThis.fetch}
-  __init28() {this._appConn = null}
-  __init29() {this._apiConn = null}
-  __init30() {this._proxyConn = null}
+  __init28() {this.debugLogLevelConfigured = false}
+  __init29() {this.fetch = globalThis.fetch}
+  __init30() {this._appConn = null}
+  __init31() {this._apiConn = null}
+  __init32() {this._proxyConn = null}
   
   
   
-  __init31() {this._idGenerator = null}
-  __init32() {this._contextManager = null}
-  __init33() {this._otelFlushCallback = null}
+  __init33() {this._idGenerator = null}
+  __init34() {this._contextManager = null}
+  __init35() {this._otelFlushCallback = null}
   resetLoginInfo() {
     this.appUrl = null;
     this.appPublicUrl = null;
@@ -4612,6 +4755,11 @@ var BraintrustState = (_class7 = class _BraintrustState {
     this.proxyUrl = other.proxyUrl;
     this.loggedIn = other.loggedIn;
     this.gitMetadataSettings = other.gitMetadataSettings;
+    this.debugLogLevel = other.debugLogLevel;
+    this.debugLogLevelConfigured = other.debugLogLevelConfigured;
+    setGlobalDebugLogLevel(
+      this.debugLogLevelConfigured ? _nullishCoalesce(this.debugLogLevel, () => ( false)) : void 0
+    );
     this._appConn = other._appConn;
     this._apiConn = other._apiConn;
     this.loginReplaceApiConn(this.apiConn());
@@ -4636,7 +4784,9 @@ var BraintrustState = (_class7 = class _BraintrustState {
       orgName: this.orgName,
       apiUrl: this.apiUrl,
       proxyUrl: this.proxyUrl,
-      gitMetadataSettings: this.gitMetadataSettings
+      gitMetadataSettings: this.gitMetadataSettings,
+      ...this.debugLogLevel ? { debugLogLevel: this.debugLogLevel } : {},
+      ...this.debugLogLevelConfigured && !this.debugLogLevel ? { debugLogLevelDisabled: true } : {}
     };
   }
   static deserialize(serialized, opts) {
@@ -4663,19 +4813,38 @@ var BraintrustState = (_class7 = class _BraintrustState {
       state.proxyConn().set_token(state.loginToken);
     }
     state.loggedIn = true;
+    state.debugLogLevelConfigured = "debugLogLevel" in serializedParsed.data || !!serializedParsed.data.debugLogLevelDisabled;
+    setGlobalDebugLogLevel(
+      state.debugLogLevelConfigured ? _nullishCoalesce(state.debugLogLevel, () => ( false)) : void 0
+    );
     state.loginReplaceApiConn(state.apiConn());
     return state;
   }
   setFetch(fetch2) {
     this.loginParams.fetch = fetch2;
     this.fetch = fetch2;
-    _optionalChain([this, 'access', _28 => _28._apiConn, 'optionalAccess', _29 => _29.setFetch, 'call', _30 => _30(fetch2)]);
-    _optionalChain([this, 'access', _31 => _31._appConn, 'optionalAccess', _32 => _32.setFetch, 'call', _33 => _33(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)]);
   }
   setMaskingFunction(maskingFunction) {
     this.bgLogger().setMaskingFunction(maskingFunction);
   }
+  setDebugLogLevel(option) {
+    if (option === void 0) {
+      return;
+    }
+    this.debugLogLevelConfigured = true;
+    this.debugLogLevel = normalizeDebugLogLevelOption(option);
+    setGlobalDebugLogLevel(_nullishCoalesce(this.debugLogLevel, () => ( false)));
+  }
+  getDebugLogLevel() {
+    return this.debugLogLevel;
+  }
+  hasDebugLogLevelOverride() {
+    return this.debugLogLevelConfigured;
+  }
   async login(loginParams) {
+    this.setDebugLogLevel(loginParams.debugLogLevel);
     if (this.apiUrl && !loginParams.forceLogin) {
       return;
     }
@@ -4770,7 +4939,7 @@ var BraintrustState = (_class7 = class _BraintrustState {
   toString() {
     return `BraintrustState(id=${this.id}, org=${this.orgName || "none"}, loggedIn=${this.loggedIn})`;
   }
-}, _class7);
+}, _class8);
 var _globalState;
 function _internalSetInitialState() {
   if (_globalState) {
@@ -4786,6 +4955,7 @@ function _internalSetInitialState() {
   _globalState = existing;
 }
 var _internalGetGlobalState = () => _globalState;
+setDebugLogStateResolver(() => _internalGetGlobalState());
 var FailedHTTPResponse = class extends Error {
   
   
@@ -4900,7 +5070,7 @@ var HTTPConnection = class _HTTPConnection {
         return await resp.json();
       } catch (e) {
         if (i < tries - 1) {
-          console.log(
+          debugLogger.debug(
             `Retrying API request ${object_type} ${JSON.stringify(args)} ${e.status} ${e.text}`
           );
           continue;
@@ -5112,7 +5282,7 @@ with a Blob/ArrayBuffer, or run the program on Node.js.`
     try {
       statSync2(data);
     } catch (e) {
-      console.warn(`Failed to read file: ${e}`);
+      debugLogger.warn(`Failed to read file: ${e}`);
     }
   }
 };
@@ -5356,8 +5526,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', _34 => _34.app_url]));
-  const orgName = _getOrgName(state.orgName || _optionalChain([linkArgs, 'optionalAccess', _35 => _35.org_name]));
+  const appUrl = _getAppUrl(state.appUrl || _optionalChain([linkArgs, 'optionalAccess', _39 => _39.app_url]));
+  const orgName = _getOrgName(state.orgName || _optionalChain([linkArgs, 'optionalAccess', _40 => _40.org_name]));
   if (!orgName) {
     return null;
   }
@@ -5367,9 +5537,9 @@ async function permalink(slug, opts) {
   if (slug === "") {
     return NOOP_SPAN_PERMALINK;
   }
-  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _36 => _36.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _41 => _41.state]), () => ( _globalState));
   const getOrgName = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _37 => _37.orgName])) {
+    if (_optionalChain([opts, 'optionalAccess', _42 => _42.orgName])) {
       return opts.orgName;
     }
     await state.login({});
@@ -5379,7 +5549,7 @@ async function permalink(slug, opts) {
     return state.orgName;
   };
   const getAppUrl = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _38 => _38.appUrl])) {
+    if (_optionalChain([opts, 'optionalAccess', _43 => _43.appUrl])) {
       return opts.appUrl;
     }
     await state.login({});
@@ -5457,7 +5627,7 @@ function startSpanParentArgs(args) {
     propagatedEvent: argPropagatedEvent
   };
 }
-var Logger = (_class8 = class {
+var Logger = (_class9 = class {
   
   
   
@@ -5467,8 +5637,8 @@ var Logger = (_class8 = class {
   
   
   // For type identification.
-  __init34() {this.kind = "logger"}
-  constructor(state, lazyMetadata, logOptions = {}) {;_class8.prototype.__init34.call(this);
+  __init36() {this.kind = "logger"}
+  constructor(state, lazyMetadata, logOptions = {}) {;_class9.prototype.__init36.call(this);
     this.lazyMetadata = lazyMetadata;
     this._asyncFlush = logOptions.asyncFlush;
     this.computeMetadataArgs = logOptions.computeMetadataArgs;
@@ -5514,7 +5684,7 @@ var Logger = (_class8 = class {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _39 => _39.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _44 => _44.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`"
       );
@@ -5582,12 +5752,12 @@ var Logger = (_class8 = class {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _40 => _40.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _45 => _45.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: this.computeMetadataArgs,
-        parentSpanIds: _optionalChain([args, 'optionalAccess', _41 => _41.parentSpanIds]),
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _42 => _42.propagatedEvent])
+        parentSpanIds: _optionalChain([args, 'optionalAccess', _46 => _46.parentSpanIds]),
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _47 => _47.propagatedEvent])
       }),
       defaultRootType: "task" /* TASK */
     });
@@ -5655,7 +5825,7 @@ var Logger = (_class8 = class {
   _getLinkBaseUrl() {
     return _getLinkBaseUrl(this.state, this._linkArgs);
   }
-}, _class8);
+}, _class9);
 function castLogger(logger, asyncFlush) {
   if (logger === void 0) return void 0;
   if (asyncFlush !== void 0 && !!asyncFlush !== !!logger.asyncFlush) {
@@ -5765,31 +5935,31 @@ function now() {
 }
 var DEFAULT_FLUSH_BACKPRESSURE_BYTES = 10 * 1024 * 1024;
 var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
-var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
-  
-  
-  __init35() {this.activeFlush = Promise.resolve()}
-  __init36() {this.activeFlushResolved = true}
-  __init37() {this.activeFlushError = void 0}
-  
-  __init38() {this.maskingFunction = null}
-  __init39() {this.syncFlush = false}
-  __init40() {this.maxRequestSizeOverride = null}
-  __init41() {this._maxRequestSizePromise = null}
-  __init42() {this.defaultBatchSize = 100}
-  __init43() {this.numTries = 3}
-  __init44() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
-  __init45() {this.queueDropLoggingPeriod = 60}
-  __init46() {this.failedPublishPayloadsDir = void 0}
-  __init47() {this.allPublishPayloadsDir = void 0}
-  __init48() {this._flushBackpressureBytes = DEFAULT_FLUSH_BACKPRESSURE_BYTES}
-  __init49() {this._pendingBytes = 0}
-  __init50() {this._disabled = false}
-  __init51() {this.queueDropLoggingState = {
+var HTTPBackgroundLogger = (_class10 = class _HTTPBackgroundLogger {
+  
+  
+  __init37() {this.activeFlush = Promise.resolve()}
+  __init38() {this.activeFlushResolved = true}
+  __init39() {this.activeFlushError = void 0}
+  
+  __init40() {this.maskingFunction = null}
+  __init41() {this.syncFlush = false}
+  __init42() {this.maxRequestSizeOverride = null}
+  __init43() {this._maxRequestSizePromise = null}
+  __init44() {this.defaultBatchSize = 100}
+  __init45() {this.numTries = 3}
+  __init46() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
+  __init47() {this.queueDropLoggingPeriod = 60}
+  __init48() {this.failedPublishPayloadsDir = void 0}
+  __init49() {this.allPublishPayloadsDir = void 0}
+  __init50() {this._flushBackpressureBytes = DEFAULT_FLUSH_BACKPRESSURE_BYTES}
+  __init51() {this._pendingBytes = 0}
+  __init52() {this._disabled = false}
+  __init53() {this.queueDropLoggingState = {
     numDropped: 0,
     lastLoggedTimestamp: 0
   }}
-  constructor(apiConn, opts) {;_class9.prototype.__init35.call(this);_class9.prototype.__init36.call(this);_class9.prototype.__init37.call(this);_class9.prototype.__init38.call(this);_class9.prototype.__init39.call(this);_class9.prototype.__init40.call(this);_class9.prototype.__init41.call(this);_class9.prototype.__init42.call(this);_class9.prototype.__init43.call(this);_class9.prototype.__init44.call(this);_class9.prototype.__init45.call(this);_class9.prototype.__init46.call(this);_class9.prototype.__init47.call(this);_class9.prototype.__init48.call(this);_class9.prototype.__init49.call(this);_class9.prototype.__init50.call(this);_class9.prototype.__init51.call(this);
+  constructor(apiConn, opts) {;_class10.prototype.__init37.call(this);_class10.prototype.__init38.call(this);_class10.prototype.__init39.call(this);_class10.prototype.__init40.call(this);_class10.prototype.__init41.call(this);_class10.prototype.__init42.call(this);_class10.prototype.__init43.call(this);_class10.prototype.__init44.call(this);_class10.prototype.__init45.call(this);_class10.prototype.__init46.call(this);_class10.prototype.__init47.call(this);_class10.prototype.__init48.call(this);_class10.prototype.__init49.call(this);_class10.prototype.__init50.call(this);_class10.prototype.__init51.call(this);_class10.prototype.__init52.call(this);_class10.prototype.__init53.call(this);
     opts = _nullishCoalesce(opts, () => ( {}));
     this.apiConn = apiConn;
     const syncFlushEnv = Number(isomorph_default.getEnv("BRAINTRUST_SYNC_FLUSH"));
@@ -5824,7 +5994,7 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
       this.queueDropLoggingPeriod = queueDropLoggingPeriodEnv;
     }
     if (isomorph_default.getEnv("BRAINTRUST_LOG_FLUSH_CHUNK_SIZE")) {
-      console.warn(
+      debugLogger.warn(
         "BRAINTRUST_LOG_FLUSH_CHUNK_SIZE is deprecated and no longer has any effect. Log flushing now sends all items at once and batches them automatically. This environment variable will be removed in a future major release."
       );
     }
@@ -5886,7 +6056,10 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
           const versionInfo = await conn.get_json("version");
           serverLimit = _nullishCoalesce(_v3.z.object({ logs3_payload_max_bytes: _v3.z.number().nullish() }).parse(versionInfo).logs3_payload_max_bytes, () => ( null));
         } catch (e) {
-          console.warn("Failed to fetch version info for payload limit:", e);
+          debugLogger.warn(
+            "Failed to fetch version info for payload limit:",
+            e
+          );
         }
         const validServerLimit = serverLimit !== null && serverLimit > 0 ? serverLimit : null;
         const canUseOverflow = validServerLimit !== null;
@@ -5919,7 +6092,7 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
       this.queue.clear();
       return;
     }
-    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _43 => _43.batchSize]), () => ( this.defaultBatchSize));
+    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _48 => _48.batchSize]), () => ( this.defaultBatchSize));
     const wrappedItems = this.queue.drain();
     if (wrappedItems.length === 0) {
       return;
@@ -6030,16 +6203,16 @@ var HTTPBackgroundLogger = (_class9 = class _HTTPBackgroundLogger {
         if (isRetrying) {
           errmsg += ". Retrying";
         }
-        console.warn(errmsg);
+        debugLogger.warn(errmsg);
         if (!isRetrying) {
-          console.warn(
+          debugLogger.warn(
             `Failed to construct log records to flush after ${this.numTries} attempts. Dropping batch`
           );
           throw e;
         } else {
-          console.warn(e);
+          debugLogger.warn(e);
           const sleepTimeS = BACKGROUND_LOGGER_BASE_SLEEP_TIME_S * 2 ** i;
-          console.info(`Sleeping for ${sleepTimeS}s`);
+          debugLogger.info(`Sleeping for ${sleepTimeS}s`);
           await new Promise(
             (resolve) => setTimeout(resolve, sleepTimeS * 1e3)
           );
@@ -6140,15 +6313,15 @@ Error: ${errorText}`;
         this.logFailedPayloadsDir();
       }
       if (!isRetrying) {
-        console.warn(
+        debugLogger.warn(
           `log request failed after ${this.numTries} retries. Dropping batch`
         );
         throw new Error(errMsg);
       } else {
-        console.warn(errMsg);
+        debugLogger.warn(errMsg);
         if (isRetrying) {
           const sleepTimeS = BACKGROUND_LOGGER_BASE_SLEEP_TIME_S * 2 ** i;
-          console.info(`Sleeping for ${sleepTimeS}s`);
+          debugLogger.info(`Sleeping for ${sleepTimeS}s`);
           await new Promise(
             (resolve) => setTimeout(resolve, sleepTimeS * 1e3)
           );
@@ -6163,7 +6336,7 @@ Error: ${errorText}`;
     this.queueDropLoggingState.numDropped += numItems;
     const timeNow = getCurrentUnixTimestamp();
     if (timeNow - this.queueDropLoggingState.lastLoggedTimestamp > this.queueDropLoggingPeriod) {
-      console.warn(
+      debugLogger.warn(
         `Dropped ${this.queueDropLoggingState.numDropped} elements due to full queue`
       );
       if (this.failedPublishPayloadsDir) {
@@ -6195,7 +6368,7 @@ Error: ${errorText}`;
         await _HTTPBackgroundLogger.writePayloadToDir({ payloadDir, payload });
       }
     } catch (e) {
-      console.error(e);
+      debugLogger.error(e);
     }
   }
   static async writePayloadToDir({
@@ -6203,7 +6376,7 @@ Error: ${errorText}`;
     payload
   }) {
     if (!(isomorph_default.pathJoin && isomorph_default.mkdir && isomorph_default.writeFile)) {
-      console.warn(
+      debugLogger.warn(
         "Cannot dump payloads: filesystem-operations not supported on this platform"
       );
       return;
@@ -6216,7 +6389,7 @@ Error: ${errorText}`;
       await isomorph_default.mkdir(payloadDir, { recursive: true });
       await isomorph_default.writeFile(payloadFile, payload);
     } catch (e) {
-      console.error(
+      debugLogger.error(
         `Failed to write failed payload to output file ${payloadFile}:
 `,
         e
@@ -6233,10 +6406,10 @@ Error: ${errorText}`;
         } catch (err) {
           if (err instanceof AggregateError) {
             for (const e of err.errors) {
-              _optionalChain([this, 'access', _44 => _44.onFlushError, 'optionalCall', _45 => _45(e)]);
+              _optionalChain([this, 'access', _49 => _49.onFlushError, 'optionalCall', _50 => _50(e)]);
             }
           } else {
-            _optionalChain([this, 'access', _46 => _46.onFlushError, 'optionalCall', _47 => _47(err)]);
+            _optionalChain([this, 'access', _51 => _51.onFlushError, 'optionalCall', _52 => _52(err)]);
           }
           this.activeFlushError = err;
         } finally {
@@ -6247,7 +6420,9 @@ Error: ${errorText}`;
     }
   }
   logFailedPayloadsDir() {
-    console.warn(`Logging failed payloads to ${this.failedPublishPayloadsDir}`);
+    debugLogger.warn(
+      `Logging failed payloads to ${this.failedPublishPayloadsDir}`
+    );
   }
   // Should only be called by BraintrustState.
   internalReplaceApiConn(apiConn) {
@@ -6259,7 +6434,7 @@ Error: ${errorText}`;
   enforceQueueSizeLimit(enforce) {
     this.queue.enforceQueueSizeLimit(enforce);
   }
-}, _class9);
+}, _class10);
 function init(projectOrOptions, optionalOptions) {
   const options = (() => {
     if (typeof projectOrOptions === "string") {
@@ -6412,9 +6587,7 @@ function init(projectOrOptions, optionalOptions) {
           break;
         } catch (e) {
           if (args["base_experiment"] && `${"data" in e && e.data}`.includes("base experiment")) {
-            console.warn(
-              `Base experiment ${args["base_experiment"]} not found.`
-            );
+            debugLogger.forState(state).warn(`Base experiment ${args["base_experiment"]} not found.`);
             delete args["base_experiment"];
           } else {
             throw e;
@@ -6556,7 +6729,11 @@ async function computeLoggerMetadata(state, {
 }
 async function login(options = {}) {
   const { forceLogin = false } = options || {};
+  if (!_internalGetGlobalState()) {
+    _internalSetInitialState();
+  }
   const state = _internalGetGlobalState();
+  state.setDebugLogLevel(options.debugLogLevel);
   if (state.loggedIn && !forceLogin) {
     let checkUpdatedParam2 = function(varname, arg, orig) {
       if (!isEmpty2(arg) && !isEmpty2(orig) && arg !== orig) {
@@ -6575,9 +6752,6 @@ async function login(options = {}) {
     checkUpdatedParam2("orgName", options.orgName, state.orgName);
     return state;
   }
-  if (!state) {
-    _internalSetInitialState();
-  }
   await state.login(options);
   return state;
 }
@@ -6650,24 +6824,24 @@ async function loginToState(options = {}) {
   return state;
 }
 function currentExperiment(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _48 => _48.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.state]), () => ( _globalState));
   return state.currentExperiment;
 }
 function currentLogger(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _49 => _49.state]), () => ( _globalState));
-  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _50 => _50.asyncFlush]));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.state]), () => ( _globalState));
+  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _55 => _55.asyncFlush]));
 }
 function currentSpan(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _56 => _56.state]), () => ( _globalState));
   return _nullishCoalesce(state.contextManager.getCurrentSpan(), () => ( NOOP_SPAN));
 }
 function getSpanParentObject(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _57 => _57.state]), () => ( _globalState));
   const parentSpan = currentSpan({ state });
   if (!Object.is(parentSpan, NOOP_SPAN)) {
     return parentSpan;
   }
-  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.parent]), () => ( state.currentParent.getStore()));
+  const parentStr = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _58 => _58.parent]), () => ( state.currentParent.getStore()));
   if (parentStr) return getSpanComponentsClass().fromStr(parentStr);
   const experiment = currentExperiment();
   if (experiment) {
@@ -6696,7 +6870,7 @@ function traced(callback, args) {
   const { span, isSyncFlushLogger } = startSpanAndIsLogger(args);
   const ret = runCatchFinally(
     () => {
-      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _54 => _54.setCurrent]), () => ( true))) {
+      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _59 => _59.setCurrent]), () => ( true))) {
         return withCurrent(span, callback);
       } else {
         return callback(span);
@@ -6708,7 +6882,7 @@ function traced(callback, args) {
     },
     () => span.end()
   );
-  if (_optionalChain([args, 'optionalAccess', _55 => _55.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _56 => _56.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _60 => _60.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _61 => _61.asyncFlush])) {
     return ret;
   } else {
     return (async () => {
@@ -6724,14 +6898,14 @@ function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
 async function flush(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _57 => _57.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.state]), () => ( _globalState));
   return await state.bgLogger().flush();
 }
 function startSpanAndIsLogger(args) {
-  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _58 => _58.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _63 => _63.state]), () => ( _globalState));
   const parentObject = getSpanParentObject({
-    asyncFlush: _optionalChain([args, 'optionalAccess', _59 => _59.asyncFlush]),
-    parent: _optionalChain([args, 'optionalAccess', _60 => _60.parent]),
+    asyncFlush: _optionalChain([args, 'optionalAccess', _64 => _64.asyncFlush]),
+    parent: _optionalChain([args, 'optionalAccess', _65 => _65.parent]),
     state
   });
   if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
@@ -6748,14 +6922,14 @@ function startSpanAndIsLogger(args) {
       ),
       parentComputeObjectMetadataArgs: _nullishCoalesce(parentObject.data.compute_object_metadata_args, () => ( void 0)),
       parentSpanIds,
-      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _61 => _61.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _66 => _66.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', _62 => _62.asyncFlush]) === false
+      _optionalChain([args, 'optionalAccess', _67 => _67.asyncFlush]) === false
     };
   } else {
     const span = parentObject.startSpan(args);
@@ -6903,10 +7077,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _63 => _63.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (_optionalChain([value, 'optionalAccess', _68 => _68.type]) === BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _64 => _64.reference, 'optionalAccess', _65 => _65.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _66 => _66.uploader])) {
+    if (_optionalChain([value, 'optionalAccess', _69 => _69.reference, 'optionalAccess', _70 => _70.type]) === BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _71 => _71.uploader])) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -6972,14 +7146,14 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
 }
 var DEFAULT_FETCH_BATCH_SIZE = 1e3;
 var MAX_BTQL_ITERATIONS = 1e4;
-var ObjectFetcher = (_class10 = class {
-  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class10.prototype.__init52.call(this);
+var ObjectFetcher = (_class11 = class {
+  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class11.prototype.__init54.call(this);
     this.objectType = objectType;
     this.pinnedVersion = pinnedVersion;
     this.mutateRecord = mutateRecord;
     this._internal_btql = _internal_btql;
   }
-  __init52() {this._fetchedData = void 0}
+  __init54() {this._fetchedData = void 0}
   get id() {
     throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
   }
@@ -6989,7 +7163,14 @@ var ObjectFetcher = (_class10 = class {
   async *fetchRecordsFromApi(batchSize) {
     const state = await this.getState();
     const objectId = await this.id;
-    const limit = _nullishCoalesce(batchSize, () => ( DEFAULT_FETCH_BATCH_SIZE));
+    const batchLimit = _nullishCoalesce(batchSize, () => ( DEFAULT_FETCH_BATCH_SIZE));
+    const internalLimit = _optionalChain([this, 'access', _72 => _72._internal_btql, 'optionalAccess', _73 => _73.limit]);
+    const limit = batchSize !== void 0 ? batchSize : _nullishCoalesce(internalLimit, () => ( batchLimit));
+    const internalBtqlWithoutReservedQueryKeys = Object.fromEntries(
+      Object.entries(_nullishCoalesce(this._internal_btql, () => ( {}))).filter(
+        ([key]) => key !== "cursor" && key !== "limit" && key !== "select" && key !== "from"
+      )
+    );
     let cursor = void 0;
     let iterations = 0;
     while (true) {
@@ -6997,7 +7178,6 @@ var ObjectFetcher = (_class10 = class {
         `btql`,
         {
           query: {
-            ...this._internal_btql,
             select: [
               {
                 op: "star"
@@ -7017,7 +7197,8 @@ var ObjectFetcher = (_class10 = class {
               ]
             },
             cursor,
-            limit
+            limit,
+            ...internalBtqlWithoutReservedQueryKeys
           },
           use_columnstore: false,
           brainstore_realtime: true,
@@ -7057,7 +7238,7 @@ var ObjectFetcher = (_class10 = class {
       }
       return;
     }
-    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _67 => _67.batchSize]))) {
+    for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _74 => _74.batchSize]))) {
       yield record;
     }
   }
@@ -7067,7 +7248,7 @@ var ObjectFetcher = (_class10 = class {
   async fetchedData(options) {
     if (this._fetchedData === void 0) {
       const data = [];
-      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _68 => _68.batchSize]))) {
+      for await (const record of this.fetchRecordsFromApi(_optionalChain([options, 'optionalAccess', _75 => _75.batchSize]))) {
         data.push(record);
       }
       this._fetchedData = data;
@@ -7091,8 +7272,8 @@ var ObjectFetcher = (_class10 = class {
       return maxVersion;
     }
   }
-}, _class10);
-var Experiment2 = (_class11 = class extends ObjectFetcher {
+}, _class11);
+var Experiment2 = (_class12 = class extends ObjectFetcher {
   
   
   
@@ -7100,9 +7281,9 @@ var Experiment2 = (_class11 = class extends ObjectFetcher {
   
   
   // For type identification.
-  __init53() {this.kind = "experiment"}
+  __init55() {this.kind = "experiment"}
   constructor(state, lazyMetadata, dataset) {
-    super("experiment", void 0, (r) => enrichAttachments(r, state));_class11.prototype.__init53.call(this);;
+    super("experiment", void 0, (r) => enrichAttachments(r, state));_class12.prototype.__init55.call(this);;
     this.lazyMetadata = lazyMetadata;
     this.dataset = dataset;
     this.lastStartTime = getCurrentUnixTimestamp();
@@ -7162,7 +7343,7 @@ var Experiment2 = (_class11 = class extends ObjectFetcher {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _69 => _69.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 `experiment.traced` and then log with `span.log`"
       );
@@ -7215,12 +7396,12 @@ var Experiment2 = (_class11 = class extends ObjectFetcher {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _70 => _70.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _77 => _77.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: void 0,
         parentSpanIds: void 0,
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _71 => _71.propagatedEvent])
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _78 => _78.propagatedEvent])
       }),
       defaultRootType: "eval" /* EVAL */
     });
@@ -7290,7 +7471,7 @@ var Experiment2 = (_class11 = class extends ObjectFetcher {
         scores = results["scores"];
         metrics = results["metrics"];
       } catch (e) {
-        console.warn(
+        debugLogger.forState(state).warn(
           `Failed to fetch experiment scores and metrics: ${e}
 
 View complete results in Braintrust or run experiment.summarize() again.`
@@ -7367,12 +7548,12 @@ View complete results in Braintrust or run experiment.summarize() again.`
    * @deprecated This function is deprecated. You can simply remove it from your code.
    */
   async close() {
-    console.warn(
+    debugLogger.forState(this.state).warn(
       "close is deprecated and will be removed in a future version of braintrust. It is now a no-op and can be removed"
     );
     return this.id;
   }
-}, _class11);
+}, _class12);
 var ReadonlyExperiment = class extends ObjectFetcher {
   constructor(state, lazyMetadata) {
     super("experiment", void 0, (r) => enrichAttachments(r, state));
@@ -7448,7 +7629,7 @@ function _resolveSpanIds(spanId, parentSpanIds, lookupSpanParent, idGenerator, c
     spanParents: void 0
   };
 }
-var SpanImpl = (_class12 = class _SpanImpl {
+var SpanImpl = (_class13 = class _SpanImpl {
   
   
   
@@ -7461,8 +7642,8 @@ var SpanImpl = (_class12 = class _SpanImpl {
   
   
   
-  __init54() {this.kind = "span"}
-  constructor(args) {;_class12.prototype.__init54.call(this);
+  __init56() {this.kind = "span"}
+  constructor(args) {;_class13.prototype.__init56.call(this);
     this._state = args.state;
     const spanAttributes = _nullishCoalesce(args.spanAttributes, () => ( {}));
     const rawEvent = _nullishCoalesce(args.event, () => ( {}));
@@ -7564,8 +7745,8 @@ var SpanImpl = (_class12 = class _SpanImpl {
       ...serializableInternalData,
       [IS_MERGE_FIELD]: this.isMerge
     });
-    if (_optionalChain([partialRecord, 'access', _72 => _72.metrics, 'optionalAccess', _73 => _73.end])) {
-      this.loggedEndTime = _optionalChain([partialRecord, 'access', _74 => _74.metrics, 'optionalAccess', _75 => _75.end]);
+    if (typeof _optionalChain([partialRecord, 'access', _79 => _79.metrics, 'optionalAccess', _80 => _80.end]) === "number") {
+      this.loggedEndTime = partialRecord.metrics.end;
     }
     if (this.parentObjectType === 1 /* EXPERIMENT */) {
       const cachedSpan = {
@@ -7624,18 +7805,18 @@ var SpanImpl = (_class12 = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _76 => _76.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _81 => _81.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this._state,
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _77 => _77.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _82 => _82.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _78 => _78.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _83 => _83.propagatedEvent]), () => ( this.propagatedEvent))
       })
     });
   }
@@ -7649,12 +7830,12 @@ var SpanImpl = (_class12 = class _SpanImpl {
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _79 => _79.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _84 => _84.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _80 => _80.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _85 => _85.propagatedEvent]), () => ( this.propagatedEvent))
       }),
       spanId
     });
@@ -7663,7 +7844,7 @@ var SpanImpl = (_class12 = class _SpanImpl {
     let endTime;
     let internalData = {};
     if (!this.loggedEndTime) {
-      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _81 => _81.endTime]), () => ( getCurrentUnixTimestamp()));
+      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _86 => _86.endTime]), () => ( getCurrentUnixTimestamp()));
       internalData = { metrics: { end: endTime } };
     } else {
       endTime = this.loggedEndTime;
@@ -7714,8 +7895,8 @@ var SpanImpl = (_class12 = class _SpanImpl {
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
       case 2 /* PROJECT_LOGS */: {
-        const projectID = _optionalChain([args, 'optionalAccess', _82 => _82.project_id]) || this.parentObjectId.getSync().value;
-        const projectName = _optionalChain([args, 'optionalAccess', _83 => _83.project_name]);
+        const projectID = _optionalChain([args, 'optionalAccess', _87 => _87.project_id]) || this.parentObjectId.getSync().value;
+        const projectName = _optionalChain([args, 'optionalAccess', _88 => _88.project_name]);
         if (projectID) {
           return `${baseUrl}/object?object_type=project_logs&object_id=${projectID}&id=${this._id}`;
         } else if (projectName) {
@@ -7725,7 +7906,7 @@ var SpanImpl = (_class12 = class _SpanImpl {
         }
       }
       case 1 /* EXPERIMENT */: {
-        const expID = _optionalChain([args, 'optionalAccess', _84 => _84.experiment_id]) || _optionalChain([this, 'access', _85 => _85.parentObjectId, 'optionalAccess', _86 => _86.getSync, 'call', _87 => _87(), 'optionalAccess', _88 => _88.value]);
+        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]);
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
         } else {
@@ -7765,7 +7946,7 @@ var SpanImpl = (_class12 = class _SpanImpl {
   toString() {
     return `SpanImpl(id=${this.id}, spanId=${this.spanId})`;
   }
-}, _class12);
+}, _class13);
 function splitLoggingData({
   event,
   internalData
@@ -7796,11 +7977,11 @@ function splitLoggingData({
   }
   return [serializableInternalData, lazyInternalData];
 }
-var Dataset2 = (_class13 = class extends ObjectFetcher {
+var Dataset2 = (_class14 = class extends ObjectFetcher {
   constructor(state, lazyMetadata, pinnedVersion, legacy, _internal_btql) {
     const isLegacyDataset = _nullishCoalesce(legacy, () => ( DEFAULT_IS_LEGACY_DATASET));
     if (isLegacyDataset) {
-      console.warn(
+      debugLogger.forState(state).warn(
         `Records will be fetched from this dataset in the legacy format, with the "expected" field renamed to "output". Please update your code to use "expected", and use \`braintrust.initDataset()\` with \`{ useOutput: false }\`, which will become the default in a future version of Braintrust.`
       );
     }
@@ -7815,13 +7996,13 @@ var Dataset2 = (_class13 = class extends ObjectFetcher {
         )
       ),
       _internal_btql
-    );_class13.prototype.__init55.call(this);_class13.prototype.__init56.call(this);;
+    );_class14.prototype.__init57.call(this);_class14.prototype.__init58.call(this);;
     this.state = state;
     this.lazyMetadata = lazyMetadata;
   }
   
-  __init55() {this.__braintrust_dataset_marker = true}
-  __init56() {this.newRecords = 0}
+  __init57() {this.__braintrust_dataset_marker = true}
+  __init58() {this.newRecords = 0}
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).dataset.id;
@@ -8031,7 +8212,7 @@ var Dataset2 = (_class13 = class extends ObjectFetcher {
    * @deprecated This function is deprecated. You can simply remove it from your code.
    */
   async close() {
-    console.warn(
+    debugLogger.forState(this.state).warn(
       "close is deprecated and will be removed in a future version of braintrust. It is now a no-op and can be removed"
     );
     return this.id;
@@ -8039,7 +8220,7 @@ var Dataset2 = (_class13 = class extends ObjectFetcher {
   static isDataset(data) {
     return typeof data === "object" && data !== null && "__braintrust_dataset_marker" in data;
   }
-}, _class13);
+}, _class14);
 function renderMessage(render, message) {
   return {
     ...message,
@@ -8161,15 +8342,15 @@ function renderPromptParams(params, args, options = {}) {
   }
   return params;
 }
-var Prompt2 = (_class14 = class _Prompt {
-  constructor(metadata, defaults, noTrace) {;_class14.prototype.__init57.call(this);_class14.prototype.__init58.call(this);
+var Prompt2 = (_class15 = class _Prompt {
+  constructor(metadata, defaults, noTrace) {;_class15.prototype.__init59.call(this);_class15.prototype.__init60.call(this);
     this.metadata = metadata;
     this.defaults = defaults;
     this.noTrace = noTrace;
   }
   
-  __init57() {this.hasParsedPromptData = false}
-  __init58() {this.__braintrust_prompt_marker = true}
+  __init59() {this.hasParsedPromptData = false}
+  __init60() {this.__braintrust_prompt_marker = true}
   get id() {
     return this.metadata.id;
   }
@@ -8183,16 +8364,16 @@ var Prompt2 = (_class14 = class _Prompt {
     return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
   }
   get prompt() {
-    return _optionalChain([this, 'access', _89 => _89.getParsedPromptData, 'call', _90 => _90(), 'optionalAccess', _91 => _91.prompt]);
+    return _optionalChain([this, 'access', _94 => _94.getParsedPromptData, 'call', _95 => _95(), 'optionalAccess', _96 => _96.prompt]);
   }
   get version() {
     return this.metadata[TRANSACTION_ID_FIELD];
   }
   get options() {
-    return _optionalChain([this, 'access', _92 => _92.getParsedPromptData, 'call', _93 => _93(), 'optionalAccess', _94 => _94.options]) || {};
+    return _optionalChain([this, 'access', _97 => _97.getParsedPromptData, 'call', _98 => _98(), 'optionalAccess', _99 => _99.options]) || {};
   }
   get templateFormat() {
-    return _optionalChain([this, 'access', _95 => _95.getParsedPromptData, 'call', _96 => _96(), 'optionalAccess', _97 => _97.template_format]);
+    return _optionalChain([this, 'access', _100 => _100.getParsedPromptData, 'call', _101 => _101(), 'optionalAccess', _102 => _102.template_format]);
   }
   get promptData() {
     return this.getParsedPromptData();
@@ -8352,7 +8533,7 @@ var Prompt2 = (_class14 = class _Prompt {
       return {
         type: "chat",
         messages,
-        ..._optionalChain([prompt, 'access', _98 => _98.tools, 'optionalAccess', _99 => _99.trim, 'call', _100 => _100()]) ? {
+        ..._optionalChain([prompt, 'access', _103 => _103.tools, 'optionalAccess', _104 => _104.trim, 'call', _105 => _105()]) ? {
           tools: render(prompt.tools)
         } : void 0
       };
@@ -8396,12 +8577,12 @@ var Prompt2 = (_class14 = class _Prompt {
       false
     );
   }
-}, _class14);
-var RemoteEvalParameters = (_class15 = class {
-  constructor(metadata) {;_class15.prototype.__init59.call(this);
+}, _class15);
+var RemoteEvalParameters = (_class16 = class {
+  constructor(metadata) {;_class16.prototype.__init61.call(this);
     this.metadata = metadata;
   }
-  __init59() {this.__braintrust_parameters_marker = true}
+  __init61() {this.__braintrust_parameters_marker = true}
   get id() {
     return this.metadata.id;
   }
@@ -8444,12 +8625,9 @@ var RemoteEvalParameters = (_class15 = class {
   static isParameters(x) {
     return typeof x === "object" && x !== null && "__braintrust_parameters_marker" in x && x.__braintrust_parameters_marker === true;
   }
-}, _class15);
+}, _class16);
 var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
 
-// src/instrumentation/core/plugin.ts
-var _dcbrowser = require('dc-browser');
-
 // src/instrumentation/core/stream-patcher.ts
 function isAsyncIterable(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
@@ -8465,7 +8643,7 @@ function patchStreamIfNeeded(stream, options) {
     return stream;
   }
   const originalIteratorFn = stream[Symbol.asyncIterator];
-  if (originalIteratorFn.__braintrust_patched) {
+  if ("__braintrust_patched" in originalIteratorFn && originalIteratorFn["__braintrust_patched"]) {
     return stream;
   }
   try {
@@ -8506,7 +8684,10 @@ function patchStreamIfNeeded(stream, options) {
             completed = true;
             if (options.onError) {
               try {
-                options.onError(error, chunks);
+                options.onError(
+                  error instanceof Error ? error : new Error(String(error)),
+                  chunks
+                );
               } catch (handlerError) {
                 console.error("Error in stream onError handler:", handlerError);
               }
@@ -8534,7 +8715,8 @@ function patchStreamIfNeeded(stream, options) {
         iterator.throw = async function(...args) {
           if (!completed) {
             completed = true;
-            const error = args[0];
+            const rawError = args[0];
+            const error = rawError instanceof Error ? rawError : new Error(String(rawError));
             if (options.onError) {
               try {
                 options.onError(error, chunks);
@@ -8548,7 +8730,9 @@ function patchStreamIfNeeded(stream, options) {
       }
       return iterator;
     };
-    patchedIteratorFn.__braintrust_patched = true;
+    Object.defineProperty(patchedIteratorFn, "__braintrust_patched", {
+      value: true
+    });
     stream[Symbol.asyncIterator] = patchedIteratorFn;
     return stream;
   } catch (error) {
@@ -8557,10 +8741,53 @@ function patchStreamIfNeeded(stream, options) {
   }
 }
 
+// src/instrumentation/core/channel-tracing-utils.ts
+function hasChannelSpanInfo(value) {
+  return isObject(value) && isObject(value.span_info);
+}
+function getChannelSpanInfo(event) {
+  if (isObject(event.span_info)) {
+    return event.span_info;
+  }
+  const firstArg = _optionalChain([event, 'access', _106 => _106.arguments, 'optionalAccess', _107 => _107[0]]);
+  if (hasChannelSpanInfo(firstArg)) {
+    return firstArg.span_info;
+  }
+  return void 0;
+}
+function buildStartSpanArgs(config, event) {
+  const spanInfo = getChannelSpanInfo(event);
+  const spanAttributes = {
+    type: config.type
+  };
+  if (isObject(_optionalChain([spanInfo, 'optionalAccess', _108 => _108.spanAttributes]))) {
+    mergeDicts(spanAttributes, spanInfo.spanAttributes);
+  }
+  return {
+    name: typeof _optionalChain([spanInfo, 'optionalAccess', _109 => _109.name]) === "string" && spanInfo.name ? spanInfo.name : config.name,
+    spanAttributes,
+    spanInfoMetadata: isObject(_optionalChain([spanInfo, 'optionalAccess', _110 => _110.metadata])) ? spanInfo.metadata : void 0
+  };
+}
+function mergeInputMetadata(metadata, spanInfoMetadata) {
+  if (!spanInfoMetadata) {
+    return isObject(metadata) ? (
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      metadata
+    ) : void 0;
+  }
+  const mergedMetadata = {};
+  mergeDicts(mergedMetadata, spanInfoMetadata);
+  if (isObject(metadata)) {
+    mergeDicts(mergedMetadata, metadata);
+  }
+  return mergedMetadata;
+}
+
 // src/instrumentation/core/plugin.ts
-var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.call(this);_class16.prototype.__init61.call(this); }
-  __init60() {this.enabled = false}
-  __init61() {this.unsubscribers = []}
+var BasePlugin = (_class17 = class {constructor() { _class17.prototype.__init62.call(this);_class17.prototype.__init63.call(this); }
+  __init62() {this.enabled = false}
+  __init63() {this.unsubscribers = []}
   /**
    * Enables the plugin. Must be called before the plugin will receive events.
    */
@@ -8588,23 +8815,25 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
    * @param handlers - Event handlers
    */
   subscribe(channelName, handlers) {
-    const channel = _dcbrowser.tracingChannel.call(void 0, channelName);
-    channel.subscribe(handlers);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
+    channel2.subscribe(handlers);
   }
   /**
    * Subscribe to a channel for async methods (non-streaming).
    * Creates a span and logs input/output/metrics.
    */
   subscribeToChannel(channelName, config) {
-    const channel = _dcbrowser.tracingChannel.call(void 0, channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config,
+          event
+        );
         const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -8612,7 +8841,7 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
           const { input, metadata } = config.extractInput(event.arguments);
           span.log({
             input,
-            metadata
+            metadata: mergeInputMetadata(metadata, spanInfoMetadata)
           });
         } catch (error) {
           console.error(`Error extracting input for ${channelName}:`, error);
@@ -8625,10 +8854,12 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
         }
         const { span, startTime } = spanData;
         try {
-          const output = config.extractOutput(event.result);
-          const metrics = config.extractMetrics(event.result, startTime);
+          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)]);
           span.log({
             output,
+            ...metadata !== void 0 ? { metadata } : {},
             metrics
           });
         } catch (error) {
@@ -8651,9 +8882,9 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -8661,15 +8892,17 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
    * Handles both streaming and non-streaming responses.
    */
   subscribeToStreamingChannel(channelName, config) {
-    const channel = _dcbrowser.tracingChannel.call(void 0, channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config,
+          event
+        );
         const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -8677,7 +8910,7 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
           const { input, metadata } = config.extractInput(event.arguments);
           span.log({
             input,
-            metadata
+            metadata: mergeInputMetadata(metadata, spanInfoMetadata)
           });
         } catch (error) {
           console.error(`Error extracting input for ${channelName}:`, error);
@@ -8690,24 +8923,39 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
         }
         const { span, startTime } = spanData;
         if (isAsyncIterable(event.result)) {
+          let firstChunkTime;
           patchStreamIfNeeded(event.result, {
+            onChunk: () => {
+              if (firstChunkTime === void 0) {
+                firstChunkTime = getCurrentUnixTimestamp();
+              }
+            },
             onComplete: (chunks) => {
               try {
                 let output;
                 let metrics;
+                let metadata;
                 if (config.aggregateChunks) {
-                  const aggregated = config.aggregateChunks(chunks);
+                  const aggregated = config.aggregateChunks(
+                    chunks,
+                    event.result,
+                    event
+                  );
                   output = aggregated.output;
                   metrics = aggregated.metrics;
+                  metadata = aggregated.metadata;
                 } else {
-                  output = config.extractOutput(chunks);
-                  metrics = config.extractMetrics(chunks, startTime);
+                  output = config.extractOutput(chunks, event);
+                  metrics = config.extractMetrics(chunks, startTime, event);
                 }
-                if (!metrics.time_to_first_token && chunks.length > 0) {
+                if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
+                  metrics.time_to_first_token = firstChunkTime - startTime;
+                } else if (metrics.time_to_first_token === void 0 && chunks.length > 0) {
                   metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
                 }
                 span.log({
                   output,
+                  ...metadata !== void 0 ? { metadata } : {},
                   metrics
                 });
               } catch (error) {
@@ -8728,10 +8976,16 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
           });
         } else {
           try {
-            const output = config.extractOutput(event.result);
-            const metrics = config.extractMetrics(event.result, startTime);
+            const output = config.extractOutput(event.result, event);
+            const metadata = config.extractMetadata ? config.extractMetadata(event.result, event) : void 0;
+            const metrics = config.extractMetrics(
+              event.result,
+              startTime,
+              event
+            );
             span.log({
               output,
+              ...metadata !== void 0 ? { metadata } : {},
               metrics
             });
           } catch (error) {
@@ -8755,9 +9009,9 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -8765,15 +9019,17 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
    * Used for methods like beta.chat.completions.stream() and responses.stream().
    */
   subscribeToSyncStreamChannel(channelName, config) {
-    const channel = _dcbrowser.tracingChannel.call(void 0, channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config,
+          event
+        );
         const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -8781,7 +9037,7 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
           const { input, metadata } = config.extractInput(event.arguments);
           span.log({
             input,
-            metadata
+            metadata: mergeInputMetadata(metadata, spanInfoMetadata)
           });
         } catch (error) {
           console.error(`Error extracting input for ${channelName}:`, error);
@@ -8865,156 +9121,642 @@ var BasePlugin = (_class16 = class {constructor() { _class16.prototype.__init60.
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
-}, _class16);
+}, _class17);
 
-// src/wrappers/attachment-utils.ts
-function getExtensionFromMediaType(mediaType) {
-  const extensionMap = {
-    "image/png": "png",
-    "image/jpeg": "jpg",
-    "image/gif": "gif",
-    "image/webp": "webp",
-    "image/svg+xml": "svg",
-    "audio/mpeg": "mp3",
-    "audio/wav": "wav",
-    "audio/ogg": "ogg",
-    "video/mp4": "mp4",
-    "video/webm": "webm",
-    "application/pdf": "pdf",
-    "application/json": "json",
-    "text/plain": "txt",
-    "text/html": "html",
-    "text/csv": "csv"
-  };
-  return extensionMap[mediaType] || "bin";
+// src/instrumentation/core/channel-tracing.ts
+function isSyncStreamLike(value) {
+  return !!value && typeof value === "object" && typeof value.on === "function";
 }
-function convertDataToBlob(data, mediaType) {
+function hasChoices(value) {
+  return !!value && typeof value === "object" && "choices" in value;
+}
+function normalizeMetadata(metadata) {
+  return isObject(metadata) ? metadata : void 0;
+}
+function startSpanForEvent(config, event, channelName) {
+  const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+    config,
+    event
+  );
+  const span = startSpan({
+    name,
+    spanAttributes
+  });
+  const startTime = getCurrentUnixTimestamp();
   try {
-    if (typeof data === "string") {
-      if (data.startsWith("data:")) {
-        const base64Match = data.match(/^data:[^;]+;base64,(.+)$/);
-        if (base64Match) {
-          const base64 = base64Match[1];
-          const binaryString = atob(base64);
-          const bytes = new Uint8Array(binaryString.length);
-          for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-          }
-          return new Blob([bytes], { type: mediaType });
-        }
-      } else if (data.startsWith("http://") || data.startsWith("https://")) {
-        return null;
-      } else {
-        const binaryString = atob(data);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-          bytes[i] = binaryString.charCodeAt(i);
-        }
-        return new Blob([bytes], { type: mediaType });
-      }
-    } else if (data instanceof Uint8Array) {
-      return new Blob([data], { type: mediaType });
-    } else if (data instanceof ArrayBuffer) {
-      return new Blob([data], { type: mediaType });
-    } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
-      return new Blob([data], { type: mediaType });
-    }
-  } catch (e18) {
-    return null;
+    const { input, metadata } = config.extractInput(event.arguments);
+    span.log({
+      input,
+      metadata: mergeInputMetadata(metadata, spanInfoMetadata)
+    });
+  } catch (error) {
+    console.error(`Error extracting input for ${channelName}:`, error);
   }
-  return null;
+  return { span, startTime };
 }
-function processInputAttachments(input) {
-  if (!input) {
-    return input;
+function logErrorAndEnd(states, event) {
+  const spanData = states.get(event);
+  if (!spanData) {
+    return;
   }
-  let attachmentIndex = 0;
-  const processContentPart = (part) => {
-    if (!part || typeof part !== "object") {
-      return part;
-    }
-    if (part.type === "image" && part.image) {
-      let mediaType = "image/png";
-      if (typeof part.image === "string" && part.image.startsWith("data:")) {
-        const mediaTypeMatch = part.image.match(/^data:([^;]+);/);
-        if (mediaTypeMatch) {
-          mediaType = mediaTypeMatch[1];
-        }
-      } else if (part.mediaType) {
-        mediaType = part.mediaType;
-      }
-      const blob = convertDataToBlob(part.image, mediaType);
-      if (blob) {
-        const filename = `input_image_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
-        attachmentIndex++;
-        const attachment = new Attachment({
-          data: blob,
-          filename,
-          contentType: mediaType
-        });
-        return {
-          ...part,
-          image: attachment
-        };
+  spanData.span.log({
+    error: event.error.message
+  });
+  spanData.span.end();
+  states.delete(event);
+}
+function traceAsyncChannel(channel2, config) {
+  const tracingChannel2 = channel2.tracingChannel();
+  const states = /* @__PURE__ */ new WeakMap();
+  const channelName = channel2.channelName;
+  const handlers = {
+    start: (event) => {
+      states.set(
+        event,
+        startSpanForEvent(
+          config,
+          event,
+          channelName
+        )
+      );
+    },
+    asyncEnd: (event) => {
+      const spanData = states.get(event);
+      if (!spanData) {
+        return;
       }
-    }
-    if (part.type === "file" && part.data) {
-      const mediaType = part.mediaType || "application/octet-stream";
-      const blob = convertDataToBlob(part.data, mediaType);
-      if (blob) {
-        const filename = part.filename || `input_file_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
-        attachmentIndex++;
-        const attachment = new Attachment({
-          data: blob,
-          filename,
-          contentType: mediaType
+      const asyncEndEvent = event;
+      const { span, startTime } = spanData;
+      try {
+        const output = config.extractOutput(
+          asyncEndEvent.result,
+          asyncEndEvent
+        );
+        const metrics = config.extractMetrics(
+          asyncEndEvent.result,
+          startTime,
+          asyncEndEvent
+        );
+        const metadata = _optionalChain([config, 'access', _113 => _113.extractMetadata, 'optionalCall', _114 => _114(
+          asyncEndEvent.result,
+          asyncEndEvent
+        )]);
+        span.log({
+          output,
+          ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
+          metrics
         });
-        return {
-          ...part,
-          data: attachment
-        };
+      } catch (error) {
+        console.error(`Error extracting output for ${channelName}:`, error);
+      } finally {
+        span.end();
+        states.delete(event);
       }
+    },
+    error: (event) => {
+      logErrorAndEnd(states, event);
     }
-    return part;
   };
-  const processMessage = (message) => {
-    if (!message || typeof message !== "object") {
-      return message;
-    }
-    if (Array.isArray(message.content)) {
-      return {
-        ...message,
-        content: message.content.map(processContentPart)
-      };
-    }
-    return message;
+  tracingChannel2.subscribe(handlers);
+  return () => {
+    tracingChannel2.unsubscribe(handlers);
   };
-  if (Array.isArray(input)) {
-    return input.map(processMessage);
-  } else if (typeof input === "object" && input.content) {
-    return processMessage(input);
-  }
-  return input;
 }
-
-// src/instrumentation/plugins/openai-plugin.ts
-var OpenAIPlugin = class extends BasePlugin {
-  constructor() {
+function traceStreamingChannel(channel2, config) {
+  const tracingChannel2 = channel2.tracingChannel();
+  const states = /* @__PURE__ */ new WeakMap();
+  const channelName = channel2.channelName;
+  const handlers = {
+    start: (event) => {
+      states.set(
+        event,
+        startSpanForEvent(
+          config,
+          event,
+          channelName
+        )
+      );
+    },
+    asyncEnd: (event) => {
+      const spanData = states.get(event);
+      if (!spanData) {
+        return;
+      }
+      const asyncEndEvent = event;
+      const { span, startTime } = spanData;
+      if (isAsyncIterable(asyncEndEvent.result)) {
+        let firstChunkTime;
+        patchStreamIfNeeded(asyncEndEvent.result, {
+          onChunk: () => {
+            if (firstChunkTime === void 0) {
+              firstChunkTime = getCurrentUnixTimestamp();
+            }
+          },
+          onComplete: (chunks) => {
+            try {
+              let output;
+              let metrics;
+              let metadata;
+              if (config.aggregateChunks) {
+                const aggregated = config.aggregateChunks(
+                  chunks,
+                  asyncEndEvent.result,
+                  asyncEndEvent,
+                  startTime
+                );
+                output = aggregated.output;
+                metrics = aggregated.metrics;
+                metadata = aggregated.metadata;
+              } else {
+                output = config.extractOutput(
+                  chunks,
+                  asyncEndEvent
+                );
+                metrics = config.extractMetrics(
+                  chunks,
+                  startTime,
+                  asyncEndEvent
+                );
+              }
+              if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
+                metrics.time_to_first_token = firstChunkTime - startTime;
+              } else if (metrics.time_to_first_token === void 0 && chunks.length > 0) {
+                metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+              }
+              span.log({
+                output,
+                ...metadata !== void 0 ? { metadata } : {},
+                metrics
+              });
+            } catch (error) {
+              console.error(
+                `Error extracting output for ${channelName}:`,
+                error
+              );
+            } finally {
+              span.end();
+              states.delete(event);
+            }
+          },
+          onError: (error) => {
+            span.log({
+              error: error.message
+            });
+            span.end();
+            states.delete(event);
+          }
+        });
+        return;
+      }
+      try {
+        const output = config.extractOutput(
+          asyncEndEvent.result,
+          asyncEndEvent
+        );
+        const metrics = config.extractMetrics(
+          asyncEndEvent.result,
+          startTime,
+          asyncEndEvent
+        );
+        const metadata = _optionalChain([config, 'access', _115 => _115.extractMetadata, 'optionalCall', _116 => _116(
+          asyncEndEvent.result,
+          asyncEndEvent
+        )]);
+        span.log({
+          output,
+          ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
+          metrics
+        });
+      } catch (error) {
+        console.error(`Error extracting output for ${channelName}:`, error);
+      } finally {
+        span.end();
+        states.delete(event);
+      }
+    },
+    error: (event) => {
+      logErrorAndEnd(states, event);
+    }
+  };
+  tracingChannel2.subscribe(handlers);
+  return () => {
+    tracingChannel2.unsubscribe(handlers);
+  };
+}
+function traceSyncStreamChannel(channel2, config) {
+  const tracingChannel2 = channel2.tracingChannel();
+  const states = /* @__PURE__ */ new WeakMap();
+  const channelName = channel2.channelName;
+  const handlers = {
+    start: (event) => {
+      states.set(
+        event,
+        startSpanForEvent(
+          config,
+          event,
+          channelName
+        )
+      );
+    },
+    end: (event) => {
+      const spanData = states.get(event);
+      if (!spanData) {
+        return;
+      }
+      const { span, startTime } = spanData;
+      const resultEvent = event;
+      const stream = resultEvent.result;
+      if (!isSyncStreamLike(stream)) {
+        span.end();
+        states.delete(event);
+        return;
+      }
+      let first = true;
+      stream.on("chunk", () => {
+        if (first) {
+          span.log({
+            metrics: {
+              time_to_first_token: getCurrentUnixTimestamp() - startTime
+            }
+          });
+          first = false;
+        }
+      });
+      stream.on("chatCompletion", (completion) => {
+        try {
+          if (hasChoices(completion)) {
+            span.log({
+              output: completion.choices
+            });
+          }
+        } catch (error) {
+          console.error(
+            `Error extracting chatCompletion for ${channelName}:`,
+            error
+          );
+        }
+      });
+      stream.on("event", (streamEvent) => {
+        if (!config.extractFromEvent) {
+          return;
+        }
+        try {
+          if (first) {
+            span.log({
+              metrics: {
+                time_to_first_token: getCurrentUnixTimestamp() - startTime
+              }
+            });
+            first = false;
+          }
+          const extracted = config.extractFromEvent(streamEvent);
+          if (extracted && Object.keys(extracted).length > 0) {
+            span.log(extracted);
+          }
+        } catch (error) {
+          console.error(`Error extracting event for ${channelName}:`, error);
+        }
+      });
+      stream.on("end", () => {
+        span.end();
+        states.delete(event);
+      });
+      stream.on("error", (error) => {
+        span.log({
+          error: error.message
+        });
+        span.end();
+        states.delete(event);
+      });
+    },
+    error: (event) => {
+      logErrorAndEnd(states, event);
+    }
+  };
+  tracingChannel2.subscribe(handlers);
+  return () => {
+    tracingChannel2.unsubscribe(handlers);
+  };
+}
+function unsubscribeAll(unsubscribers) {
+  for (const unsubscribe of unsubscribers) {
+    unsubscribe();
+  }
+  return [];
+}
+
+// src/wrappers/attachment-utils.ts
+function getExtensionFromMediaType(mediaType) {
+  const extensionMap = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/svg+xml": "svg",
+    "audio/mpeg": "mp3",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "application/pdf": "pdf",
+    "application/json": "json",
+    "text/plain": "txt",
+    "text/html": "html",
+    "text/csv": "csv"
+  };
+  return extensionMap[mediaType] || "bin";
+}
+function convertDataToBlob(data, mediaType) {
+  try {
+    if (typeof data === "string") {
+      if (data.startsWith("data:")) {
+        const base64Match = data.match(/^data:[^;]+;base64,(.+)$/);
+        if (base64Match) {
+          const base64 = base64Match[1];
+          const binaryString = atob(base64);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          return new Blob([bytes], { type: mediaType });
+        }
+      } else if (data.startsWith("http://") || data.startsWith("https://")) {
+        return null;
+      } else {
+        const binaryString = atob(data);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        return new Blob([bytes], { type: mediaType });
+      }
+    } else if (data instanceof Uint8Array) {
+      return new Blob([data], { type: mediaType });
+    } else if (data instanceof ArrayBuffer) {
+      return new Blob([data], { type: mediaType });
+    } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
+      return new Blob([data], { type: mediaType });
+    }
+  } catch (e18) {
+    return null;
+  }
+  return null;
+}
+function processInputAttachments(input) {
+  if (!input) {
+    return input;
+  }
+  let attachmentIndex = 0;
+  const inferMediaTypeFromDataUrl = (value, fallback2) => {
+    const mediaTypeMatch = value.match(/^data:([^;]+);/);
+    return _optionalChain([mediaTypeMatch, 'optionalAccess', _117 => _117[1]]) || fallback2;
+  };
+  const toAttachment = (value, mediaType, filename) => {
+    const blob = convertDataToBlob(value, mediaType);
+    if (!blob) {
+      return null;
+    }
+    return new Attachment({
+      data: blob,
+      filename,
+      contentType: mediaType
+    });
+  };
+  const processNode = (node) => {
+    if (Array.isArray(node)) {
+      return node.map(processNode);
+    }
+    if (!node || typeof node !== "object") {
+      return node;
+    }
+    if (node.type === "image_url" && node.image_url && typeof node.image_url === "object" && typeof node.image_url.url === "string" && node.image_url.url.startsWith("data:")) {
+      const mediaType = inferMediaTypeFromDataUrl(
+        node.image_url.url,
+        "image/png"
+      );
+      const filename = `image.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.image_url.url, mediaType, filename);
+      if (attachment) {
+        return {
+          ...node,
+          image_url: {
+            ...node.image_url,
+            url: attachment
+          }
+        };
+      }
+    }
+    if (node.type === "file" && node.file && typeof node.file === "object" && typeof node.file.file_data === "string" && node.file.file_data.startsWith("data:")) {
+      const mediaType = inferMediaTypeFromDataUrl(
+        node.file.file_data,
+        "application/octet-stream"
+      );
+      const filename = typeof node.file.filename === "string" && node.file.filename ? node.file.filename : `document.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.file.file_data, mediaType, filename);
+      if (attachment) {
+        return {
+          ...node,
+          file: {
+            ...node.file,
+            file_data: attachment
+          }
+        };
+      }
+    }
+    if (node.type === "image" && node.image) {
+      let mediaType = "image/png";
+      if (typeof node.image === "string" && node.image.startsWith("data:")) {
+        mediaType = inferMediaTypeFromDataUrl(node.image, mediaType);
+      } else if (node.mediaType) {
+        mediaType = node.mediaType;
+      }
+      const filename = `input_image_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.image, mediaType, filename);
+      if (attachment) {
+        attachmentIndex++;
+        return {
+          ...node,
+          image: attachment
+        };
+      }
+    }
+    if (node.type === "file" && node.data) {
+      const mediaType = node.mediaType || "application/octet-stream";
+      const filename = node.filename || `input_file_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.data, mediaType, filename);
+      if (attachment) {
+        attachmentIndex++;
+        return {
+          ...node,
+          data: attachment
+        };
+      }
+    }
+    const processed = {};
+    for (const [key, value] of Object.entries(node)) {
+      processed[key] = processNode(value);
+    }
+    return processed;
+  };
+  if (Array.isArray(input)) {
+    return input.map(processNode);
+  }
+  return processNode(input);
+}
+
+// src/instrumentation/core/channel-definitions.ts
+function channel(spec) {
+  return spec;
+}
+function defineChannels(pkg, channels) {
+  return Object.fromEntries(
+    Object.entries(channels).map(([key, spec]) => {
+      const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
+      if (spec.kind === "async") {
+        const asyncSpec = spec;
+        const tracingChannel3 = () => isomorph_default.newTracingChannel(
+          fullChannelName
+        );
+        return [
+          key,
+          {
+            ...asyncSpec,
+            tracingChannel: tracingChannel3,
+            tracePromise: (fn, context) => tracingChannel3().tracePromise(
+              fn,
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              context
+            )
+          }
+        ];
+      }
+      const syncSpec = spec;
+      const tracingChannel2 = () => isomorph_default.newTracingChannel(
+        fullChannelName
+      );
+      return [
+        key,
+        {
+          ...syncSpec,
+          tracingChannel: tracingChannel2,
+          traceSync: (fn, context) => tracingChannel2().traceSync(
+            fn,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            context
+          )
+        }
+      ];
+    })
+  );
+}
+
+// src/instrumentation/plugins/openai-channels.ts
+var openAIChannels = defineChannels("openai", {
+  chatCompletionsCreate: channel({
+    channelName: "chat.completions.create",
+    kind: "async"
+  }),
+  embeddingsCreate: channel({
+    channelName: "embeddings.create",
+    kind: "async"
+  }),
+  betaChatCompletionsParse: channel({
+    channelName: "beta.chat.completions.parse",
+    kind: "async"
+  }),
+  betaChatCompletionsStream: channel({
+    channelName: "beta.chat.completions.stream",
+    kind: "sync-stream"
+  }),
+  moderationsCreate: channel({
+    channelName: "moderations.create",
+    kind: "async"
+  }),
+  responsesCreate: channel({
+    channelName: "responses.create",
+    kind: "async"
+  }),
+  responsesStream: channel({
+    channelName: "responses.stream",
+    kind: "sync-stream"
+  }),
+  responsesParse: channel({
+    channelName: "responses.parse",
+    kind: "async"
+  })
+});
+
+// src/openai-utils.ts
+var BRAINTRUST_CACHED_STREAM_METRIC = "__braintrust_cached_metric";
+var LEGACY_CACHED_HEADER = "x-cached";
+var X_CACHED_HEADER = "x-bt-cached";
+var TOKEN_NAME_MAP = {
+  input_tokens: "prompt_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_PREFIX_MAP = {
+  input: "prompt",
+  output: "completion"
+};
+function parseMetricsFromUsage(usage) {
+  if (!usage) {
+    return {};
+  }
+  const metrics = {};
+  for (const [oaiName, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      const metricName = TOKEN_NAME_MAP[oaiName] || oaiName;
+      metrics[metricName] = value;
+      continue;
+    }
+    if (!oaiName.endsWith("_tokens_details") || !isObject(value)) {
+      continue;
+    }
+    const rawPrefix = oaiName.slice(0, -"_tokens_details".length);
+    const prefix = TOKEN_PREFIX_MAP[rawPrefix] || rawPrefix;
+    for (const [key, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${key}`] = nestedValue;
+    }
+  }
+  return metrics;
+}
+function parseCachedHeader(value) {
+  if (!value) {
+    return void 0;
+  }
+  return ["true", "hit"].includes(value.toLowerCase()) ? 1 : 0;
+}
+function getCachedMetricFromHeaders(headers) {
+  if (!headers || typeof headers.get !== "function") {
+    return void 0;
+  }
+  const cachedHeader = headers.get(X_CACHED_HEADER);
+  if (cachedHeader) {
+    return parseCachedHeader(cachedHeader);
+  }
+  return parseCachedHeader(headers.get(LEGACY_CACHED_HEADER));
+}
+
+// src/instrumentation/plugins/openai-plugin.ts
+var OpenAIPlugin = class extends BasePlugin {
+  constructor() {
     super();
   }
   onEnable() {
-    this.subscribeToStreamingChannel(
-      "orchestrion:openai:chat.completions.create",
-      {
+    this.unsubscribers.push(
+      traceStreamingChannel(openAIChannels.chatCompletionsCreate, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
+        extractInput: ([params]) => {
           const { messages, ...metadata } = params;
           return {
             input: processInputAttachments(messages),
@@ -9022,43 +9764,51 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _101 => _101.choices]);
+          return _optionalChain([result, 'optionalAccess', _118 => _118.choices]);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _102 => _102.usage]));
+        extractMetrics: (result, startTime, endEvent) => {
+          const metrics = withCachedMetric(
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _119 => _119.usage])),
+            result,
+            endEvent
+          );
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
           return metrics;
         },
         aggregateChunks: aggregateChatCompletionChunks
-      }
+      })
     );
-    this.subscribeToChannel("orchestrion:openai:embeddings.create", {
-      name: "Embedding",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        const { input, ...metadata } = params;
-        return {
-          input,
-          metadata: { ...metadata, provider: "openai" }
-        };
-      },
-      extractOutput: (result) => {
-        return _optionalChain([result, 'optionalAccess', _103 => _103.data, 'optionalAccess', _104 => _104.map, 'call', _105 => _105((d) => d.embedding)]);
-      },
-      extractMetrics: (result) => {
-        return parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _106 => _106.usage]));
-      }
-    });
-    this.subscribeToStreamingChannel(
-      "orchestrion:openai:beta.chat.completions.parse",
-      {
+    this.unsubscribers.push(
+      traceAsyncChannel(openAIChannels.embeddingsCreate, {
+        name: "Embedding",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
+          return {
+            input,
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          const embedding = _optionalChain([result, 'optionalAccess', _120 => _120.data, 'optionalAccess', _121 => _121[0], 'optionalAccess', _122 => _122.embedding]);
+          return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
+        },
+        extractMetrics: (result, _startTime, endEvent) => {
+          return withCachedMetric(
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _123 => _123.usage])),
+            result,
+            endEvent
+          );
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openAIChannels.betaChatCompletionsParse, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
+        extractInput: ([params]) => {
           const { messages, ...metadata } = params;
           return {
             input: processInputAttachments(messages),
@@ -9066,166 +9816,198 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _107 => _107.choices]);
+          return _optionalChain([result, 'optionalAccess', _124 => _124.choices]);
+        },
+        extractMetrics: (result, startTime, endEvent) => {
+          const metrics = withCachedMetric(
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _125 => _125.usage])),
+            result,
+            endEvent
+          );
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateChatCompletionChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(openAIChannels.betaChatCompletionsStream, {
+        name: "Chat Completion",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { messages, ...metadata } = params;
+          return {
+            input: processInputAttachments(messages),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(openAIChannels.moderationsCreate, {
+        name: "Moderation",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
+          return {
+            input,
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          return _optionalChain([result, 'optionalAccess', _126 => _126.results]);
+        },
+        extractMetrics: (result, _startTime, endEvent) => {
+          return withCachedMetric(
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _127 => _127.usage])),
+            result,
+            endEvent
+          );
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openAIChannels.responsesCreate, {
+        name: "openai.responses.create",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
+          return {
+            input: processInputAttachments(input),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _128 => _128.output]));
+        },
+        extractMetadata: (result) => {
+          if (!result) {
+            return void 0;
+          }
+          const { output: _output, usage: _usage, ...metadata } = result;
+          return Object.keys(metadata).length > 0 ? metadata : void 0;
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _108 => _108.usage]));
+        extractMetrics: (result, startTime, endEvent) => {
+          const metrics = withCachedMetric(
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _129 => _129.usage])),
+            result,
+            endEvent
+          );
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
           return metrics;
         },
-        aggregateChunks: aggregateChatCompletionChunks
-      }
+        aggregateChunks: aggregateResponseStreamEvents
+      })
     );
-    this.subscribeToSyncStreamChannel(
-      "orchestrion:openai:beta.chat.completions.stream",
-      {
-        name: "Chat Completion",
+    this.unsubscribers.push(
+      traceSyncStreamChannel(openAIChannels.responsesStream, {
+        name: "openai.responses.create",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
-          const { messages, ...metadata } = params;
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
           return {
-            input: processInputAttachments(messages),
+            input: processInputAttachments(input),
             metadata: { ...metadata, provider: "openai" }
           };
-        }
-      }
-    );
-    this.subscribeToChannel("orchestrion:openai:moderations.create", {
-      name: "Moderation",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        const { input, ...metadata } = params;
-        return {
-          input,
-          metadata: { ...metadata, provider: "openai" }
-        };
-      },
-      extractOutput: (result) => {
-        return _optionalChain([result, 'optionalAccess', _109 => _109.results]);
-      },
-      extractMetrics: () => {
-        return {};
-      }
-    });
-    this.subscribeToStreamingChannel("orchestrion:openai:responses.create", {
-      name: "openai.responses.create",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        const { input, ...metadata } = params;
-        return {
-          input: processInputAttachments(input),
-          metadata: { ...metadata, provider: "openai" }
-        };
-      },
-      extractOutput: (result) => {
-        return processImagesInOutput(_optionalChain([result, 'optionalAccess', _110 => _110.output]));
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _111 => _111.usage]));
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      }
-    });
-    this.subscribeToSyncStreamChannel("orchestrion:openai:responses.stream", {
-      name: "openai.responses.stream",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        const { input, ...metadata } = params;
-        return {
-          input: processInputAttachments(input),
-          metadata: { ...metadata, provider: "openai" }
-        };
-      },
-      extractFromEvent: (event) => {
-        if (!event || !event.type || !event.response) {
-          return {};
-        }
-        const response = event.response;
-        if (event.type === "response.completed") {
+        },
+        extractFromEvent: (event) => {
+          if (event.type !== "response.completed" || !event.response) {
+            return {};
+          }
+          const response = event.response;
           const data = {};
-          if (_optionalChain([response, 'optionalAccess', _112 => _112.output]) !== void 0) {
+          if (response.output !== void 0) {
             data.output = processImagesInOutput(response.output);
           }
-          if (response) {
-            const { usage: _usage, output: _output, ...metadata } = response;
-            if (Object.keys(metadata).length > 0) {
-              data.metadata = metadata;
-            }
+          const { usage: _usage, output: _output, ...metadata } = response;
+          if (Object.keys(metadata).length > 0) {
+            data.metadata = metadata;
           }
-          data.metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _113 => _113.usage]));
+          data.metrics = parseMetricsFromUsage(response.usage);
           return data;
         }
-        return {};
-      }
-    });
-    this.subscribeToStreamingChannel("orchestrion:openai:responses.parse", {
-      name: "openai.responses.parse",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        const { input, ...metadata } = params;
-        return {
-          input: processInputAttachments(input),
-          metadata: { ...metadata, provider: "openai" }
-        };
-      },
-      extractOutput: (result) => {
-        return processImagesInOutput(_optionalChain([result, 'optionalAccess', _114 => _114.output]));
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _115 => _115.usage]));
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      }
-    });
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openAIChannels.responsesParse, {
+        name: "openai.responses.parse",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
+          return {
+            input: processInputAttachments(input),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _130 => _130.output]));
+        },
+        extractMetadata: (result) => {
+          if (!result) {
+            return void 0;
+          }
+          const { output: _output, usage: _usage, ...metadata } = result;
+          return Object.keys(metadata).length > 0 ? metadata : void 0;
+        },
+        extractMetrics: (result, startTime, endEvent) => {
+          const metrics = withCachedMetric(
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _131 => _131.usage])),
+            result,
+            endEvent
+          );
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateResponseStreamEvents
+      })
+    );
   }
   onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
 };
-var TOKEN_NAME_MAP = {
-  input_tokens: "prompt_tokens",
-  output_tokens: "completion_tokens",
-  total_tokens: "tokens"
-};
-var TOKEN_PREFIX_MAP = {
-  input: "prompt",
-  output: "completion"
-};
-function parseMetricsFromUsage(usage) {
-  if (!usage) {
-    return {};
+function getCachedMetricFromEndEvent(endEvent) {
+  if (!isObject(endEvent)) {
+    return void 0;
   }
-  const metrics = {};
-  for (const [oai_name, value] of Object.entries(usage)) {
-    if (typeof value === "number") {
-      const metricName = TOKEN_NAME_MAP[oai_name] || oai_name;
-      metrics[metricName] = value;
-    } else if (oai_name.endsWith("_tokens_details")) {
-      if (!isObject(value)) {
-        continue;
-      }
-      const rawPrefix = oai_name.slice(0, -"_tokens_details".length);
-      const prefix = TOKEN_PREFIX_MAP[rawPrefix] || rawPrefix;
-      for (const [key, n] of Object.entries(value)) {
-        if (typeof n !== "number") {
-          continue;
-        }
-        const metricName = `${prefix}_${key}`;
-        metrics[metricName] = n;
-      }
-    }
+  const response = endEvent.response;
+  if (!isObject(response)) {
+    return void 0;
   }
-  return metrics;
+  const headers = response.headers;
+  if (!headers || typeof headers.get !== "function") {
+    return void 0;
+  }
+  return getCachedMetricFromHeaders(headers);
+}
+function withCachedMetric(metrics, result, endEvent) {
+  if (metrics.cached !== void 0) {
+    return metrics;
+  }
+  const cachedFromEvent = getCachedMetricFromEndEvent(endEvent);
+  if (cachedFromEvent !== void 0) {
+    return {
+      ...metrics,
+      cached: cachedFromEvent
+    };
+  }
+  if (!isObject(result)) {
+    return metrics;
+  }
+  const cached = result[BRAINTRUST_CACHED_STREAM_METRIC];
+  if (typeof cached !== "number") {
+    return metrics;
+  }
+  return {
+    ...metrics,
+    cached
+  };
 }
 function processImagesInOutput(output) {
   if (Array.isArray(output)) {
@@ -9256,7 +10038,7 @@ function processImagesInOutput(output) {
   }
   return output;
 }
-function aggregateChatCompletionChunks(chunks) {
+function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
   let role = void 0;
   let content = void 0;
   let tool_calls = void 0;
@@ -9269,7 +10051,7 @@ function aggregateChatCompletionChunks(chunks) {
         ...parseMetricsFromUsage(chunk.usage)
       };
     }
-    const delta = _optionalChain([chunk, 'access', _116 => _116.choices, 'optionalAccess', _117 => _117[0], 'optionalAccess', _118 => _118.delta]);
+    const delta = _optionalChain([chunk, 'access', _132 => _132.choices, 'optionalAccess', _133 => _133[0], 'optionalAccess', _134 => _134.delta]);
     if (!delta) {
       continue;
     }
@@ -9298,6 +10080,7 @@ function aggregateChatCompletionChunks(chunks) {
       }
     }
   }
+  metrics = withCachedMetric(metrics, streamResult, endEvent);
   return {
     metrics,
     output: [
@@ -9314,9 +10097,33 @@ function aggregateChatCompletionChunks(chunks) {
     ]
   };
 }
-
-// src/instrumentation/plugins/anthropic-plugin.ts
-
+function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
+  let output = void 0;
+  let metrics = {};
+  let metadata = void 0;
+  for (const chunk of chunks) {
+    if (!chunk || !chunk.type || !chunk.response) {
+      continue;
+    }
+    if (chunk.type !== "response.completed") {
+      continue;
+    }
+    const response = chunk.response;
+    if (_optionalChain([response, 'optionalAccess', _135 => _135.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', _136 => _136.usage]));
+  }
+  return {
+    output,
+    metrics: withCachedMetric(metrics, void 0, endEvent),
+    ...metadata !== void 0 ? { metadata } : {}
+  };
+}
 
 // src/wrappers/anthropic-tokens-util.ts
 function finalizeAnthropicTokens(metrics) {
@@ -9338,20 +10145,28 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
   return cacheTokens;
 }
 
+// src/instrumentation/plugins/anthropic-channels.ts
+var anthropicChannels = defineChannels("@anthropic-ai/sdk", {
+  messagesCreate: channel({
+    channelName: "messages.create",
+    kind: "async"
+  }),
+  betaMessagesCreate: channel({
+    channelName: "beta.messages.create",
+    kind: "async"
+  })
+});
+
 // src/instrumentation/plugins/anthropic-plugin.ts
-var AnthropicPlugin = (_class17 = class extends BasePlugin {constructor(...args2) { super(...args2); _class17.prototype.__init62.call(this); }
-  __init62() {this.unsubscribers = []}
+var AnthropicPlugin = class extends BasePlugin {
   onEnable() {
     this.subscribeToAnthropicChannels();
   }
   onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
   subscribeToAnthropicChannels() {
-    this.subscribeToStreamingChannel("orchestrion:anthropic:messages.create", {
+    const anthropicConfig = {
       name: "anthropic.messages.create",
       type: "llm" /* LLM */,
       extractInput: (args) => {
@@ -9363,192 +10178,44 @@ var AnthropicPlugin = (_class17 = class extends BasePlugin {constructor(...args2
           metadata: { ...metadata, provider: "anthropic" }
         };
       },
-      extractOutput: (result) => {
-        return result ? { role: result.role, content: result.content } : null;
+      extractOutput: (message) => {
+        return message ? { role: message.role, content: message.content } : null;
       },
-      extractMetrics: (result, startTime) => {
-        const metrics = parseMetricsFromUsage2(_optionalChain([result, 'optionalAccess', _119 => _119.usage]));
+      extractMetrics: (message, startTime) => {
+        const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _137 => _137.usage]));
         if (startTime) {
           metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
         }
         const finalized = finalizeAnthropicTokens(metrics);
         return Object.fromEntries(
-          Object.entries(finalized).filter(([, v]) => v !== void 0)
+          Object.entries(finalized).filter(
+            (entry) => entry[1] !== void 0
+          )
         );
       },
-      extractMetadata: (result) => {
+      extractMetadata: (message) => {
         const metadata = {};
         const metas = ["stop_reason", "stop_sequence"];
         for (const m of metas) {
-          if (_optionalChain([result, 'optionalAccess', _120 => _120[m]]) !== void 0) {
-            metadata[m] = result[m];
+          if (_optionalChain([message, 'optionalAccess', _138 => _138[m]]) !== void 0) {
+            metadata[m] = message[m];
           }
         }
         return metadata;
       },
-      aggregateChunks: aggregateAnthropicStreamChunks,
-      isStreaming: (args) => {
-        return _optionalChain([args, 'access', _121 => _121[0], 'optionalAccess', _122 => _122.stream]) === true;
-      }
-    });
-    this.subscribeToStreamingChannel(
-      "orchestrion:anthropic:beta.messages.create",
-      {
-        name: "anthropic.beta.messages.create",
-        type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
-          const input = coalesceInput(params.messages || [], params.system);
-          const metadata = filterFrom(params, ["messages", "system"]);
-          return {
-            input: processAttachmentsInInput(input),
-            metadata: { ...metadata, provider: "anthropic" }
-          };
-        },
-        extractOutput: (result) => {
-          return result ? { role: result.role, content: result.content } : null;
-        },
-        extractMetrics: (result, startTime) => {
-          const metrics = parseMetricsFromUsage2(_optionalChain([result, 'optionalAccess', _123 => _123.usage]));
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          const finalized = finalizeAnthropicTokens(metrics);
-          return Object.fromEntries(
-            Object.entries(finalized).filter(([, v]) => v !== void 0)
-          );
-        },
-        extractMetadata: (result) => {
-          const metadata = {};
-          const metas = ["stop_reason", "stop_sequence"];
-          for (const m of metas) {
-            if (_optionalChain([result, 'optionalAccess', _124 => _124[m]]) !== void 0) {
-              metadata[m] = result[m];
-            }
-          }
-          return metadata;
-        },
-        aggregateChunks: aggregateAnthropicStreamChunks,
-        isStreaming: (args) => {
-          return _optionalChain([args, 'access', _125 => _125[0], 'optionalAccess', _126 => _126.stream]) === true;
-        }
-      }
-    );
-  }
-  /**
-   * Subscribe to a channel for async methods that may return streams.
-   * Handles both streaming and non-streaming responses based on the stream parameter.
-   */
-  subscribeToStreamingChannel(channelName, config) {
-    const channel = _dcbrowser.tracingChannel.call(void 0, channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error) {
-          console.error(`Error extracting input for ${channelName}:`, error);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        const isStreaming = config.isStreaming ? config.isStreaming(event.arguments) : isAsyncIterable(event.result);
-        if (isStreaming && isAsyncIterable(event.result)) {
-          patchStreamIfNeeded(event.result, {
-            onComplete: (chunks) => {
-              try {
-                let output;
-                let metrics;
-                let metadata = {};
-                if (config.aggregateChunks) {
-                  const aggregated = config.aggregateChunks(chunks);
-                  output = aggregated.output;
-                  metrics = aggregated.metrics;
-                  metadata = aggregated.metadata || {};
-                } else {
-                  output = config.extractOutput(chunks);
-                  metrics = config.extractMetrics(chunks, startTime);
-                  if (config.extractMetadata) {
-                    metadata = config.extractMetadata(chunks);
-                  }
-                }
-                if (!metrics.time_to_first_token && chunks.length > 0) {
-                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-                }
-                span.log({
-                  output,
-                  metrics,
-                  metadata
-                });
-              } catch (error) {
-                console.error(
-                  `Error extracting output for ${channelName}:`,
-                  error
-                );
-              } finally {
-                span.end();
-              }
-            },
-            onError: (error) => {
-              span.log({
-                error: error.message
-              });
-              span.end();
-            }
-          });
-        } else {
-          try {
-            const output = config.extractOutput(event.result);
-            const metrics = config.extractMetrics(event.result, startTime);
-            const metadata = config.extractMetadata ? config.extractMetadata(event.result) : {};
-            span.log({
-              output,
-              metrics,
-              metadata
-            });
-          } catch (error) {
-            console.error(`Error extracting output for ${channelName}:`, error);
-          } finally {
-            span.end();
-            spans.delete(event);
-          }
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
+      aggregateChunks: (chunks) => aggregateAnthropicStreamChunks(chunks)
     };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
+    this.unsubscribers.push(
+      traceStreamingChannel(anthropicChannels.messagesCreate, anthropicConfig)
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(anthropicChannels.betaMessagesCreate, {
+        ...anthropicConfig,
+        name: "anthropic.beta.messages.create"
+      })
+    );
   }
-}, _class17);
+};
 function parseMetricsFromUsage2(usage) {
   if (!usage) {
     return {};
@@ -9570,29 +10237,29 @@ function aggregateAnthropicStreamChunks(chunks) {
   const deltas = [];
   let metrics = {};
   let metadata = {};
-  for (const chunk of chunks) {
-    switch (_optionalChain([chunk, 'optionalAccess', _127 => _127.type])) {
+  for (const event of chunks) {
+    switch (_optionalChain([event, 'optionalAccess', _139 => _139.type])) {
       case "message_start":
-        if (_optionalChain([chunk, 'access', _128 => _128.message, 'optionalAccess', _129 => _129.usage])) {
-          const initialMetrics = parseMetricsFromUsage2(chunk.message.usage);
+        if (_optionalChain([event, 'access', _140 => _140.message, 'optionalAccess', _141 => _141.usage])) {
+          const initialMetrics = parseMetricsFromUsage2(event.message.usage);
           metrics = { ...metrics, ...initialMetrics };
         }
         break;
       case "content_block_delta":
-        if (_optionalChain([chunk, 'access', _130 => _130.delta, 'optionalAccess', _131 => _131.type]) === "text_delta") {
-          const text = _optionalChain([chunk, 'access', _132 => _132.delta, 'optionalAccess', _133 => _133.text]);
+        if (_optionalChain([event, 'access', _142 => _142.delta, 'optionalAccess', _143 => _143.type]) === "text_delta") {
+          const text = event.delta.text;
           if (text) {
             deltas.push(text);
           }
         }
         break;
       case "message_delta":
-        if (chunk.usage) {
-          const finalMetrics = parseMetricsFromUsage2(chunk.usage);
+        if (event.usage) {
+          const finalMetrics = parseMetricsFromUsage2(event.usage);
           metrics = { ...metrics, ...finalMetrics };
         }
-        if (chunk.delta) {
-          metadata = { ...metadata, ...chunk.delta };
+        if (event.delta) {
+          metadata = { ...metadata, ...event.delta };
         }
         break;
     }
@@ -9600,7 +10267,9 @@ function aggregateAnthropicStreamChunks(chunks) {
   const output = deltas.join("");
   const finalized = finalizeAnthropicTokens(metrics);
   const filteredMetrics = Object.fromEntries(
-    Object.entries(finalized).filter(([, v]) => v !== void 0)
+    Object.entries(finalized).filter(
+      (entry) => entry[1] !== void 0
+    )
   );
   return {
     output,
@@ -9608,6 +10277,9 @@ function aggregateAnthropicStreamChunks(chunks) {
     metadata
   };
 }
+function isAnthropicBase64ContentBlock(input) {
+  return (input.type === "image" || input.type === "document") && isObject(input.source) && input.source.type === "base64";
+}
 function convertBase64ToAttachment(source, contentType) {
   const mediaType = typeof source.media_type === "string" ? source.media_type : "image/png";
   const base64Data = source.data;
@@ -9631,14 +10303,14 @@ function convertBase64ToAttachment(source, contentType) {
       data: attachment
     };
   }
-  return source;
+  return { ...source };
 }
 function processAttachmentsInInput(input) {
   if (Array.isArray(input)) {
     return input.map(processAttachmentsInInput);
   }
   if (isObject(input)) {
-    if ((input.type === "image" || input.type === "document") && isObject(input.source) && input.source.type === "base64") {
+    if (isAnthropicBase64ContentBlock(input)) {
       return {
         ...input,
         source: convertBase64ToAttachment(input.source, input.type)
@@ -9669,8 +10341,35 @@ function filterFrom(obj, fieldsToRemove) {
   return result;
 }
 
-// src/instrumentation/plugins/ai-sdk-plugin.ts
+// src/instrumentation/plugins/ai-sdk-channels.ts
+var aiSDKChannels = defineChannels("ai", {
+  generateText: channel({
+    channelName: "generateText",
+    kind: "async"
+  }),
+  streamText: channel({
+    channelName: "streamText",
+    kind: "async"
+  }),
+  generateObject: channel({
+    channelName: "generateObject",
+    kind: "async"
+  }),
+  streamObject: channel({
+    channelName: "streamObject",
+    kind: "async"
+  }),
+  agentGenerate: channel({
+    channelName: "Agent.generate",
+    kind: "async"
+  }),
+  agentStream: channel({
+    channelName: "Agent.stream",
+    kind: "async"
+  })
+});
 
+// src/instrumentation/plugins/ai-sdk-plugin.ts
 var DEFAULT_DENY_OUTPUT_PATHS = [
   // v3
   "roundtrips[].request.body",
@@ -9685,262 +10384,160 @@ var DEFAULT_DENY_OUTPUT_PATHS = [
   "steps[].response.body",
   "steps[].response.headers"
 ];
-var AISDKPlugin = (_class18 = class extends BasePlugin {
-  __init63() {this.unsubscribers = []}
+var AISDKPlugin = class extends BasePlugin {
   
   constructor(config = {}) {
-    super();_class18.prototype.__init63.call(this);;
+    super();
     this.config = config;
   }
   onEnable() {
     this.subscribeToAISDK();
   }
   onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
   subscribeToAISDK() {
     const denyOutputPaths = this.config.denyOutputPaths || DEFAULT_DENY_OUTPUT_PATHS;
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:generateText", {
-      name: "generateText",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:streamText", {
-      name: "streamText",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:generateObject", {
-      name: "generateObject",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:streamObject", {
-      name: "streamObject",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:Agent.generate", {
-      name: "Agent.generate",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:Agent.stream", {
-      name: "Agent.stream",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-  }
-  /**
-   * Subscribe to a channel for async methods that may return streams.
-   * Handles both streaming and non-streaming responses.
-   */
-  subscribeToStreamingChannel(channelName, config) {
-    const channel = _dcbrowser.tracingChannel.call(void 0, channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.generateText, {
+        name: "generateText",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error) {
-          console.error(`Error extracting input for ${channelName}:`, error);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        if (isAsyncIterable(event.result)) {
-          patchStreamIfNeeded(event.result, {
-            onComplete: (chunks) => {
-              try {
-                let output;
-                let metrics;
-                if (config.aggregateChunks) {
-                  const aggregated = config.aggregateChunks(chunks);
-                  output = aggregated.output;
-                  metrics = aggregated.metrics;
-                } else {
-                  output = config.extractOutput(chunks);
-                  metrics = config.extractMetrics(chunks, startTime);
-                }
-                if (!metrics.time_to_first_token && chunks.length > 0) {
-                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-                }
-                span.log({
-                  output,
-                  metrics
-                });
-              } catch (error) {
-                console.error(
-                  `Error extracting output for ${channelName}:`,
-                  error
-                );
-              } finally {
-                span.end();
-              }
-            },
-            onError: (error) => {
-              span.log({
-                error: error.message
-              });
-              span.end();
-            }
-          });
-        } else {
-          try {
-            const output = config.extractOutput(event.result);
-            const metrics = config.extractMetrics(event.result, startTime);
-            span.log({
-              output,
-              metrics
-            });
-          } catch (error) {
-            console.error(`Error extracting output for ${channelName}:`, error);
-          } finally {
-            span.end();
-            spans.delete(event);
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.streamText, {
+        name: "streamText",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.generateObject, {
+        name: "generateObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.streamObject, {
+        name: "streamObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.agentGenerate, {
+        name: "Agent.generate",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.agentStream, {
+        name: "Agent.stream",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
   }
-}, _class18);
+};
 function processAISDKInput(params) {
   if (!params) return params;
   return processInputAttachments(params);
@@ -9969,7 +10566,7 @@ function processAISDKOutput(output, denyOutputPaths) {
 }
 function extractTokenMetrics(result) {
   const metrics = {};
-  let usage = _optionalChain([result, 'optionalAccess', _134 => _134.totalUsage]) || _optionalChain([result, 'optionalAccess', _135 => _135.usage]);
+  let usage = _optionalChain([result, 'optionalAccess', _144 => _144.totalUsage]) || _optionalChain([result, 'optionalAccess', _145 => _145.usage]);
   if (!usage && result) {
     try {
       if ("totalUsage" in result && typeof result.totalUsage !== "function") {
@@ -9984,7 +10581,7 @@ function extractTokenMetrics(result) {
     return metrics;
   }
   const promptTokens = firstNumber(
-    _optionalChain([usage, 'access', _136 => _136.inputTokens, 'optionalAccess', _137 => _137.total]),
+    _optionalChain([usage, 'access', _146 => _146.inputTokens, 'optionalAccess', _147 => _147.total]),
     usage.inputTokens,
     usage.promptTokens,
     usage.prompt_tokens
@@ -9993,7 +10590,7 @@ function extractTokenMetrics(result) {
     metrics.prompt_tokens = promptTokens;
   }
   const completionTokens = firstNumber(
-    _optionalChain([usage, 'access', _138 => _138.outputTokens, 'optionalAccess', _139 => _139.total]),
+    _optionalChain([usage, 'access', _148 => _148.outputTokens, 'optionalAccess', _149 => _149.total]),
     usage.outputTokens,
     usage.completionTokens,
     usage.completion_tokens
@@ -10063,8 +10660,8 @@ function extractGetterValues(obj) {
   return getterValues;
 }
 function serializeModelWithProvider(model) {
-  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _140 => _140.modelId]);
-  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _141 => _141.provider]) : void 0;
+  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _150 => _150.modelId]);
+  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _151 => _151.provider]) : void 0;
   if (!modelId) {
     return { model: modelId, provider: explicitProvider };
   }
@@ -10088,12 +10685,12 @@ function parseGatewayModelString(modelString) {
   return { model: modelString };
 }
 function extractCostFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _142 => _142.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+  if (_optionalChain([result, 'optionalAccess', _152 => _152.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', _143 => _143.providerMetadata, 'optionalAccess', _144 => _144.gateway]);
-      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _145 => _145.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _146 => _146.marketCost]));
+      const gateway2 = _optionalChain([step, 'optionalAccess', _153 => _153.providerMetadata, 'optionalAccess', _154 => _154.gateway]);
+      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _155 => _155.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _156 => _156.marketCost]));
       if (stepCost !== void 0 && stepCost > 0) {
         totalCost += stepCost;
         foundCost = true;
@@ -10103,8 +10700,8 @@ function extractCostFromResult(result) {
       return totalCost;
     }
   }
-  const gateway = _optionalChain([result, 'optionalAccess', _147 => _147.providerMetadata, 'optionalAccess', _148 => _148.gateway]);
-  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _149 => _149.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _150 => _150.marketCost]));
+  const gateway = _optionalChain([result, 'optionalAccess', _157 => _157.providerMetadata, 'optionalAccess', _158 => _158.gateway]);
+  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _159 => _159.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _160 => _160.marketCost]));
   if (directCost !== void 0 && directCost > 0) {
     return directCost;
   }
@@ -10180,7 +10777,10 @@ function omitAtPath(obj, keys) {
     if (Array.isArray(obj)) {
       obj.forEach((item) => {
         if (remainingKeys.length > 0) {
-          omitAtPath(item, remainingKeys);
+          omitAtPath(
+            item,
+            remainingKeys
+          );
         }
       });
     }
@@ -10190,7 +10790,10 @@ function omitAtPath(obj, keys) {
     }
   } else {
     if (obj && typeof obj === "object" && firstKey in obj) {
-      omitAtPath(obj[firstKey], remainingKeys);
+      omitAtPath(
+        obj[firstKey],
+        remainingKeys
+      );
     }
   }
 }
@@ -10203,8 +10806,18 @@ function omit(obj, paths) {
   return result;
 }
 
-// src/instrumentation/plugins/claude-agent-sdk-plugin.ts
+// src/instrumentation/plugins/claude-agent-sdk-channels.ts
+var claudeAgentSDKChannels = defineChannels(
+  "@anthropic-ai/claude-agent-sdk",
+  {
+    query: channel({
+      channelName: "query",
+      kind: "async"
+    })
+  }
+);
 
+// src/instrumentation/plugins/claude-agent-sdk-plugin.ts
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -10240,7 +10853,7 @@ function extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _151 => _151.message, 'optionalAccess', _152 => _152.usage]);
+    usage = _optionalChain([message, 'access', _161 => _161.message, 'optionalAccess', _162 => _162.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -10280,15 +10893,17 @@ 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', _153 => _153.message, 'optionalAccess', _154 => _154.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _163 => _163.message, 'optionalAccess', _164 => _164.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', _155 => _155.message, 'optionalAccess', _156 => _156.content]) && _optionalChain([m, 'access', _157 => _157.message, 'optionalAccess', _158 => _158.role]) ? { content: m.message.content, role: m.message.role } : void 0
-  ).filter((c) => c !== void 0);
+    (m) => _optionalChain([m, 'access', _165 => _165.message, 'optionalAccess', _166 => _166.content]) && _optionalChain([m, 'access', _167 => _167.message, 'optionalAccess', _168 => _168.role]) ? { content: m.message.content, role: m.message.role } : void 0
+  ).filter(
+    (c) => c !== void 0
+  );
   const span = startSpan({
     name: "anthropic.messages.create",
     spanAttributes: {
@@ -10304,10 +10919,9 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
     metrics: usage
   });
   await span.end();
-  return _optionalChain([lastMessage, 'access', _159 => _159.message, 'optionalAccess', _160 => _160.content]) && _optionalChain([lastMessage, 'access', _161 => _161.message, 'optionalAccess', _162 => _162.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _169 => _169.message, 'optionalAccess', _170 => _170.content]) && _optionalChain([lastMessage, 'access', _171 => _171.message, 'optionalAccess', _172 => _172.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
-var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...args3) { super(...args3); _class19.prototype.__init64.call(this); }
-  __init64() {this.unsubscribers = []}
+var ClaudeAgentSDKPlugin = class extends BasePlugin {
   onEnable() {
     this.subscribeToQuery();
   }
@@ -10323,12 +10937,13 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
    * and individual LLM calls.
    */
   subscribeToQuery() {
-    const channel = _dcbrowser.tracingChannel.call(void 0, "orchestrion:claude-agent-sdk:query");
+    const channel2 = claudeAgentSDKChannels.query.tracingChannel();
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
-        const params = _nullishCoalesce(event.arguments[0], () => ( {}));
-        const { prompt, options = {} } = params;
+        const params = event.arguments[0];
+        const prompt = _optionalChain([params, 'optionalAccess', _173 => _173.prompt]);
+        const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _174 => _174.options]), () => ( {}));
         const span = startSpan({
           name: "Claude Agent",
           spanAttributes: {
@@ -10340,7 +10955,7 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
           span.log({
             input: typeof prompt === "string" ? prompt : {
               type: "streaming",
-              description: "AsyncIterable<SDKMessage>"
+              description: "AsyncIterable<ClaudeAgentSDKMessage>"
             },
             metadata: filterSerializableOptions(options)
           });
@@ -10362,13 +10977,20 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
         if (!spanData) {
           return;
         }
-        if (isAsyncIterable(event.result)) {
-          patchStreamIfNeeded(event.result, {
+        const eventResult = event.result;
+        if (eventResult === void 0) {
+          spanData.span.end();
+          spans.delete(event);
+          return;
+        }
+        if (isAsyncIterable(eventResult)) {
+          patchStreamIfNeeded(eventResult, {
             onChunk: async (message) => {
               const currentTime = getCurrentUnixTimestamp();
               const params = event.arguments[0];
-              const { prompt, options = {} } = params;
-              const messageId = _optionalChain([message, 'access', _163 => _163.message, 'optionalAccess', _164 => _164.id]);
+              const prompt = _optionalChain([params, 'optionalAccess', _175 => _175.prompt]);
+              const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _176 => _176.options]), () => ( {}));
+              const messageId = _optionalChain([message, 'access', _177 => _177.message, 'optionalAccess', _178 => _178.id]);
               if (messageId && messageId !== spanData.currentMessageId) {
                 if (spanData.currentMessages.length > 0) {
                   const finalMessage = await createLLMSpanForMessages(
@@ -10383,7 +11005,7 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
                     spanData.conversationHistory.push(finalMessage);
                   }
                   const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (_optionalChain([lastMessage, 'optionalAccess', _165 => _165.message, 'optionalAccess', _166 => _166.usage])) {
+                  if (_optionalChain([lastMessage, 'optionalAccess', _179 => _179.message, 'optionalAccess', _180 => _180.usage])) {
                     const outputTokens = getNumberProperty(
                       lastMessage.message.usage,
                       "output_tokens"
@@ -10395,14 +11017,14 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
                 spanData.currentMessageId = messageId;
                 spanData.currentMessageStartTime = currentTime;
               }
-              if (message.type === "assistant" && _optionalChain([message, 'access', _167 => _167.message, 'optionalAccess', _168 => _168.usage])) {
+              if (message.type === "assistant" && _optionalChain([message, 'access', _181 => _181.message, 'optionalAccess', _182 => _182.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', _169 => _169.message, 'optionalAccess', _170 => _170.usage])) {
+                  if (_optionalChain([lastMessage, 'optionalAccess', _183 => _183.message, 'optionalAccess', _184 => _184.usage])) {
                     const adjustedTokens = finalUsageMetrics.completion_tokens - spanData.accumulatedOutputTokens;
                     if (adjustedTokens >= 0) {
                       lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -10426,7 +11048,8 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
             onComplete: async () => {
               try {
                 const params = event.arguments[0];
-                const { prompt, options = {} } = params;
+                const prompt = _optionalChain([params, 'optionalAccess', _185 => _185.prompt]);
+                const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _186 => _186.options]), () => ( {}));
                 if (spanData.currentMessages.length > 0) {
                   const finalMessage = await createLLMSpanForMessages(
                     spanData.currentMessages,
@@ -10464,7 +11087,7 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
         } else {
           try {
             spanData.span.log({
-              output: event.result
+              output: eventResult
             });
           } catch (error) {
             console.error(
@@ -10479,7 +11102,7 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
       },
       error: (event) => {
         const spanData = spans.get(event);
-        if (!spanData) {
+        if (!spanData || !event.error) {
           return;
         }
         const { span } = spanData;
@@ -10490,53 +11113,39 @@ var ClaudeAgentSDKPlugin = (_class19 = class extends BasePlugin {constructor(...
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
-}, _class19);
+};
 
-// src/instrumentation/plugins/google-genai-plugin.ts
+// src/instrumentation/plugins/google-genai-channels.ts
+var googleGenAIChannels = defineChannels("@google/genai", {
+  generateContent: channel({
+    channelName: "models.generateContent",
+    kind: "async"
+  }),
+  generateContentStream: channel({
+    channelName: "models.generateContentStream",
+    kind: "async"
+  })
+});
 
-var GoogleGenAIPlugin = (_class20 = class extends BasePlugin {constructor(...args4) { super(...args4); _class20.prototype.__init65.call(this); }
-  __init65() {this.unsubscribers = []}
+// src/instrumentation/plugins/google-genai-plugin.ts
+var GoogleGenAIPlugin = class extends BasePlugin {
   onEnable() {
     this.subscribeToGoogleGenAIChannels();
   }
   onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
   subscribeToGoogleGenAIChannels() {
-    this.subscribeToChannel("orchestrion:google-genai:models.generateContent", {
-      name: "google-genai.generateContent",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        const input = serializeInput(params);
-        const metadata = extractMetadata(params);
-        return {
-          input,
-          metadata: { ...metadata, provider: "google-genai" }
-        };
-      },
-      extractOutput: (result) => {
-        return result;
-      },
-      extractMetrics: (result, startTime) => {
-        return extractGenerateContentMetrics(result, startTime);
-      }
-    });
-    this.subscribeToGoogleStreamingChannel(
-      "orchestrion:google-genai:models.generateContentStream",
-      {
-        name: "google-genai.generateContentStream",
+    this.unsubscribers.push(
+      traceAsyncChannel(googleGenAIChannels.generateContent, {
+        name: "google-genai.generateContent",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
+        extractInput: ([params]) => {
           const input = serializeInput(params);
           const metadata = extractMetadata(params);
           return {
@@ -10544,152 +11153,39 @@ var GoogleGenAIPlugin = (_class20 = class extends BasePlugin {constructor(...arg
             metadata: { ...metadata, provider: "google-genai" }
           };
         },
-        aggregateChunks: aggregateGenerateContentChunks
-      }
-    );
-  }
-  subscribeToChannel(channelName, config) {
-    const channel = _dcbrowser.tracingChannel.call(void 0, channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error) {
-          console.error(`Error extracting input for ${channelName}:`, error);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        try {
-          const output = config.extractOutput(event.result);
-          const metrics = config.extractMetrics(event.result, startTime);
-          span.log({
-            output,
-            metrics
-          });
-        } catch (error) {
-          console.error(`Error extracting output for ${channelName}:`, error);
-        } finally {
-          span.end();
-          spans.delete(event);
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
+        extractOutput: (result) => {
+          return result;
+        },
+        extractMetrics: (result, startTime) => {
+          return extractGenerateContentMetrics(result, startTime);
         }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
-  }
-  subscribeToGoogleStreamingChannel(channelName, config) {
-    const channel = _dcbrowser.tracingChannel.call(void 0, channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config.extractInput(event.arguments);
-          span.log({
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(googleGenAIChannels.generateContentStream, {
+        name: "google-genai.generateContentStream",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const input = serializeInput(params);
+          const metadata = extractMetadata(params);
+          return {
             input,
-            metadata
-          });
-        } catch (error) {
-          console.error(`Error extracting input for ${channelName}:`, error);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        if (isAsyncIterable(event.result)) {
-          patchStreamIfNeeded(event.result, {
-            onComplete: (chunks) => {
-              try {
-                const { output, metrics } = config.aggregateChunks(
-                  chunks,
-                  startTime
-                );
-                span.log({
-                  output,
-                  metrics
-                });
-              } catch (error) {
-                console.error(
-                  `Error extracting output for ${channelName}:`,
-                  error
-                );
-              } finally {
-                span.end();
-              }
-            },
-            onError: (error) => {
-              span.log({
-                error: error.message
-              });
-              span.end();
-            }
-          });
-        } else {
-          span.end();
-          spans.delete(event);
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
+            metadata: { ...metadata, provider: "google-genai" }
+          };
+        },
+        extractOutput: (result) => {
+          return result;
+        },
+        extractMetrics: () => {
+          return {};
+        },
+        aggregateChunks: (chunks, _result, _endEvent, startTime) => {
+          return aggregateGenerateContentChunks(chunks, startTime);
         }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
+      })
+    );
   }
-}, _class20);
+};
 function serializeInput(params) {
   const input = {
     model: params.model,
@@ -10743,8 +11239,12 @@ function serializePart(part) {
       const buffer = typeof data === "string" ? typeof Buffer !== "undefined" ? Buffer.from(data, "base64") : new Uint8Array(
         atob(data).split("").map((c) => c.charCodeAt(0))
       ) : typeof Buffer !== "undefined" ? Buffer.from(data) : new Uint8Array(data);
+      const arrayBuffer = buffer instanceof Uint8Array ? buffer.buffer.slice(
+        buffer.byteOffset,
+        buffer.byteOffset + buffer.byteLength
+      ) : buffer;
       const attachment = new Attachment({
-        data: buffer,
+        data: arrayBuffer,
         filename,
         contentType: mimeType || "application/octet-stream"
       });
@@ -10756,7 +11256,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _171 => _171.config, 'optionalAccess', _172 => _172.tools])) {
+  if (!_optionalChain([params, 'access', _187 => _187.config, 'optionalAccess', _188 => _188.tools])) {
     return null;
   }
   try {
@@ -10793,33 +11293,36 @@ function extractGenerateContentMetrics(response, startTime) {
     const end = getCurrentUnixTimestamp();
     metrics.duration = end - startTime;
   }
-  if (response.usageMetadata) {
-    const usage = response.usageMetadata;
-    if (usage.promptTokenCount !== void 0) {
-      metrics.prompt_tokens = usage.promptTokenCount;
-    }
-    if (usage.candidatesTokenCount !== void 0) {
-      metrics.completion_tokens = usage.candidatesTokenCount;
-    }
-    if (usage.totalTokenCount !== void 0) {
-      metrics.tokens = usage.totalTokenCount;
-    }
-    if (usage.cachedContentTokenCount !== void 0) {
-      metrics.prompt_cached_tokens = usage.cachedContentTokenCount;
-    }
-    if (usage.thoughtsTokenCount !== void 0) {
-      metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
-    }
+  if (_optionalChain([response, 'optionalAccess', _189 => _189.usageMetadata])) {
+    populateUsageMetrics(metrics, response.usageMetadata);
   }
   return metrics;
 }
+function populateUsageMetrics(metrics, usage) {
+  if (usage.promptTokenCount !== void 0) {
+    metrics.prompt_tokens = usage.promptTokenCount;
+  }
+  if (usage.candidatesTokenCount !== void 0) {
+    metrics.completion_tokens = usage.candidatesTokenCount;
+  }
+  if (usage.totalTokenCount !== void 0) {
+    metrics.tokens = usage.totalTokenCount;
+  }
+  if (usage.cachedContentTokenCount !== void 0) {
+    metrics.prompt_cached_tokens = usage.cachedContentTokenCount;
+  }
+  if (usage.thoughtsTokenCount !== void 0) {
+    metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
+  }
+}
 function aggregateGenerateContentChunks(chunks, startTime) {
-  const end = getCurrentUnixTimestamp();
-  const metrics = {
-    duration: end - startTime
-  };
+  const metrics = {};
+  if (startTime !== void 0) {
+    const end = getCurrentUnixTimestamp();
+    metrics.duration = end - startTime;
+  }
   let firstTokenTime = null;
-  if (chunks.length > 0 && firstTokenTime === null) {
+  if (chunks.length > 0 && firstTokenTime === null && startTime !== void 0) {
     firstTokenTime = getCurrentUnixTimestamp();
     metrics.time_to_first_token = firstTokenTime - startTime;
   }
@@ -10838,7 +11341,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _173 => _173.content, 'optionalAccess', _174 => _174.parts])) {
+        if (_optionalChain([candidate, 'access', _190 => _190.content, 'optionalAccess', _191 => _191.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -10869,7 +11372,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _175 => _175.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _192 => _192.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -10890,21 +11393,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
   }
   if (usageMetadata) {
     output.usageMetadata = usageMetadata;
-    if (usageMetadata.promptTokenCount !== void 0) {
-      metrics.prompt_tokens = usageMetadata.promptTokenCount;
-    }
-    if (usageMetadata.candidatesTokenCount !== void 0) {
-      metrics.completion_tokens = usageMetadata.candidatesTokenCount;
-    }
-    if (usageMetadata.totalTokenCount !== void 0) {
-      metrics.tokens = usageMetadata.totalTokenCount;
-    }
-    if (usageMetadata.cachedContentTokenCount !== void 0) {
-      metrics.prompt_cached_tokens = usageMetadata.cachedContentTokenCount;
-    }
-    if (usageMetadata.thoughtsTokenCount !== void 0) {
-      metrics.completion_reasoning_tokens = usageMetadata.thoughtsTokenCount;
-    }
+    populateUsageMetrics(metrics, usageMetadata);
   }
   if (text) {
     output.text = text;
@@ -10916,7 +11405,8 @@ function tryToDict(obj) {
     return null;
   }
   if (typeof obj === "object") {
-    if (typeof obj.toJSON === "function") {
+    if ("toJSON" in obj && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    typeof obj.toJSON === "function") {
       return obj.toJSON();
     }
     return obj;
@@ -10925,15 +11415,15 @@ function tryToDict(obj) {
 }
 
 // src/instrumentation/braintrust-plugin.ts
-var BraintrustPlugin = (_class21 = class extends BasePlugin {
+var BraintrustPlugin = (_class18 = class extends BasePlugin {
   
-  __init66() {this.openaiPlugin = null}
-  __init67() {this.anthropicPlugin = null}
-  __init68() {this.aiSDKPlugin = null}
-  __init69() {this.claudeAgentSDKPlugin = null}
-  __init70() {this.googleGenAIPlugin = null}
+  __init64() {this.openaiPlugin = null}
+  __init65() {this.anthropicPlugin = null}
+  __init66() {this.aiSDKPlugin = null}
+  __init67() {this.claudeAgentSDKPlugin = null}
+  __init68() {this.googleGenAIPlugin = null}
   constructor(config = {}) {
-    super();_class21.prototype.__init66.call(this);_class21.prototype.__init67.call(this);_class21.prototype.__init68.call(this);_class21.prototype.__init69.call(this);_class21.prototype.__init70.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);;
     this.config = config;
   }
   onEnable() {
@@ -10981,13 +11471,13 @@ var BraintrustPlugin = (_class21 = class extends BasePlugin {
       this.googleGenAIPlugin = null;
     }
   }
-}, _class21);
+}, _class18);
 
 // src/instrumentation/registry.ts
-var PluginRegistry = (_class22 = class {constructor() { _class22.prototype.__init71.call(this);_class22.prototype.__init72.call(this);_class22.prototype.__init73.call(this); }
-  __init71() {this.braintrustPlugin = null}
-  __init72() {this.config = {}}
-  __init73() {this.enabled = false}
+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}
   /**
    * Configure which integrations should be enabled.
    * This must be called before any SDK imports to take effect.
@@ -11069,7 +11559,7 @@ var PluginRegistry = (_class22 = class {constructor() { _class22.prototype.__ini
     }
     return { integrations };
   }
-}, _class22);
+}, _class19);
 var registry = new PluginRegistry();
 
 // src/node/config.ts
@@ -11080,6 +11570,7 @@ function configureNode() {
   isomorph_default.getEnv = (name) => process.env[name];
   isomorph_default.getCallerLocation = getCallerLocation;
   isomorph_default.newAsyncLocalStorage = () => new (0, _nodeasync_hooks.AsyncLocalStorage)();
+  isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
   isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };
@@ -12283,11 +12774,11 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
     return this._state;
   }
 };
-var CachedSpanFetcher = (_class23 = class {
-  __init74() {this.spanCache = /* @__PURE__ */ new Map()}
-  __init75() {this.allFetched = false}
+var CachedSpanFetcher = (_class20 = class {
+  __init72() {this.spanCache = /* @__PURE__ */ new Map()}
+  __init73() {this.allFetched = false}
   
-  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class23.prototype.__init74.call(this);_class23.prototype.__init75.call(this);
+  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class20.prototype.__init72.call(this);_class20.prototype.__init73.call(this);
     if (typeof objectTypeOrFetchFn === "function") {
       this.fetchFn = objectTypeOrFetchFn;
     } else {
@@ -12302,7 +12793,7 @@ var CachedSpanFetcher = (_class23 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _176 => _176.span_attributes, 'optionalAccess', _177 => _177.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _193 => _193.span_attributes, 'optionalAccess', _194 => _194.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -12336,7 +12827,7 @@ var CachedSpanFetcher = (_class23 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _178 => _178.span_attributes, 'optionalAccess', _179 => _179.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _195 => _195.span_attributes, 'optionalAccess', _196 => _196.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -12353,24 +12844,24 @@ var CachedSpanFetcher = (_class23 = class {
     }
     return result;
   }
-}, _class23);
-var LocalTrace = (_class24 = class {
+}, _class20);
+var LocalTrace = (_class21 = class {
   
   
   
   
   
-  __init76() {this.spansFlushed = false}
-  __init77() {this.spansFlushPromise = null}
+  __init74() {this.spansFlushed = false}
+  __init75() {this.spansFlushPromise = null}
   
-  __init78() {this.threadCache = /* @__PURE__ */ new Map()}
+  __init76() {this.threadCache = /* @__PURE__ */ new Map()}
   constructor({
     objectType,
     objectId,
     rootSpanId,
     ensureSpansFlushed,
     state
-  }) {;_class24.prototype.__init76.call(this);_class24.prototype.__init77.call(this);_class24.prototype.__init78.call(this);
+  }) {;_class21.prototype.__init74.call(this);_class21.prototype.__init75.call(this);_class21.prototype.__init76.call(this);
     this.objectType = objectType;
     this.objectId = objectId;
     this.rootSpanId = rootSpanId;
@@ -12416,11 +12907,11 @@ var LocalTrace = (_class24 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _180 => _180.span_attributes, 'optionalAccess', _181 => _181.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _197 => _197.span_attributes, 'optionalAccess', _198 => _198.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _182 => _182.span_attributes, 'optionalAccess', _183 => _183.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _199 => _199.span_attributes, 'optionalAccess', _200 => _200.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -12439,7 +12930,7 @@ var LocalTrace = (_class24 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _184 => _184.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _201 => _201.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -12450,7 +12941,7 @@ var LocalTrace = (_class24 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _185 => _185.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _202 => _202.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -12481,7 +12972,7 @@ var LocalTrace = (_class24 = class {
     }
     await this.spansFlushPromise;
   }
-}, _class24);
+}, _class21);
 
 // src/reporters/progress.ts
 var SimpleProgressReporter = class {
@@ -12550,6 +13041,11 @@ var evalParametersSchema = _v3.z.record(
       default: promptDefinitionWithToolsSchema.optional(),
       description: _v3.z.string().optional()
     }),
+    _v3.z.object({
+      type: _v3.z.literal("model"),
+      default: _v3.z.string().optional(),
+      description: _v3.z.string().optional()
+    }),
     _v3.z.instanceof(_v3.z.ZodType)
     // For Zod schemas
   ])
@@ -12592,6 +13088,17 @@ function validateParametersWithZod(parameters, parameterSchema) {
             throw new Error(`Parameter '${name}' is required`);
           }
           return [name, Prompt2.fromPromptData(name, promptData)];
+        } else if ("type" in schema && schema.type === "model") {
+          const model = _nullishCoalesce(value, () => ( schema.default));
+          if (model === void 0) {
+            throw new Error(`Parameter '${name}' is required`);
+          }
+          if (typeof model !== "string") {
+            throw new Error(
+              `Parameter '${name}' must be a string model identifier`
+            );
+          }
+          return [name, model];
         } else {
           const schemaCasted = schema;
           return [name, schemaCasted.parse(value)];
@@ -12609,10 +13116,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', _186 => _186.errors, 'optionalAccess', _187 => _187.map, 'call', _188 => _188((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _203 => _203.errors, 'optionalAccess', _204 => _204.map, 'call', _205 => _205((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _189 => _189.join, 'call', _190 => _190(", ")]);
+    }), 'access', _206 => _206.join, 'call', _207 => _207(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return parameters;
@@ -12666,10 +13173,10 @@ function callEvaluatorData(data) {
   };
 }
 function isAsyncIterable3(value) {
-  return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
-  return typeof value === "object" && value !== null && typeof value[Symbol.iterator] === "function";
+  return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
 }
 globalThis._evals = {
   functions: [],
@@ -12832,7 +13339,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', _191 => _191.spanCache, 'optionalAccess', _192 => _192.start, 'call', _193 => _193()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _208 => _208.spanCache, 'optionalAccess', _209 => _209.start, 'call', _210 => _210()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -12943,7 +13450,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _194 => _194.data, 'access', async _195 => _195.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _211 => _211.data, 'access', async _212 => _212.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -12969,10 +13476,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _196 => _196({
+                    _optionalChain([stream, 'optionalCall', _213 => _213({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _197 => _197.event, 'optionalAccess', _198 => _198.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _214 => _214.event, 'optionalAccess', _215 => _215.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -13105,7 +13612,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               const names = Object.keys(scorerErrors).join(", ");
               const errors = failingScorersAndResults.map((item) => item.error);
               unhandledScores = Object.keys(scorerErrors);
-              console.warn(
+              debugLogger.forState(evaluator.state).warn(
                 `Found exceptions for the following scorers: ${names}`,
                 errors
               );
@@ -13136,7 +13643,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _199 => _199.event, 'optionalAccess', _200 => _200.origin])
+              origin: _optionalChain([baseEvent, 'access', _216 => _216.event, 'optionalAccess', _217 => _217.origin])
             });
           }
         };
@@ -13170,7 +13677,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _201 => _201.setTotal, 'optionalCall', _202 => _202(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _218 => _218.setTotal, 'optionalCall', _219 => _219(evaluator.evalName, scheduledTrials)]);
           q.push({ datum, trialIndex });
         }
       }
@@ -13223,7 +13730,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       q.kill();
       if (e instanceof InternalAbortError) {
         if (isomorph_default.getEnv("BRAINTRUST_VERBOSE")) {
-          console.warn("Evaluator cancelled:", e.message);
+          debugLogger.forState(evaluator.state).warn("Evaluator cancelled:", e.message);
         }
       }
       throw e;
@@ -13245,9 +13752,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _203 => _203.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _204 => _204.dispose, 'call', _205 => _205()]);
-      _optionalChain([spanCache, 'optionalAccess', _206 => _206.stop, 'call', _207 => _207()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _220 => _220.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _221 => _221.dispose, 'call', _222 => _222()]);
+      _optionalChain([spanCache, 'optionalAccess', _223 => _223.stop, 'call', _224 => _224()]);
     }
   }
 }
@@ -13318,7 +13825,11 @@ function reportFailures(evaluator, failingResults, { verbose, jsonl }) {
       }
     }
     if (!verbose && !jsonl) {
-      console.error(warning("Add --verbose to see full stack traces."));
+      console.error(
+        warning(
+          "Use --debug-logging debug to see full stack traces and troubleshooting details."
+        )
+      );
     }
   }
 }
@@ -13480,7 +13991,7 @@ async function cachedLogin(options) {
 }
 function makeCheckAuthorized(allowedOrgName) {
   return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _208 => _208.ctx, 'optionalAccess', _209 => _209.token])) {
+    if (!_optionalChain([req, 'access', _225 => _225.ctx, 'optionalAccess', _226 => _226.token])) {
       return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
     try {
@@ -13493,7 +14004,7 @@ function makeCheckAuthorized(allowedOrgName) {
         return next(_httperrors2.default.call(void 0, 403, errorMessage));
       }
       const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _210 => _210.ctx, 'optionalAccess', _211 => _211.token]),
+        apiKey: _optionalChain([req, 'access', _227 => _227.ctx, 'optionalAccess', _228 => _228.token]),
         orgName
       });
       req.ctx.state = state;
@@ -13619,6 +14130,11 @@ var staticParametersSchema = _v3.z.record(
       default: PromptData.optional(),
       description: _v3.z.string().optional()
     }),
+    _v3.z.object({
+      type: _v3.z.literal("model"),
+      default: _v3.z.string().optional(),
+      description: _v3.z.string().optional()
+    }),
     _v3.z.object({
       type: _v3.z.literal("data"),
       schema: _v3.z.record(_v3.z.unknown()),
@@ -13695,17 +14211,17 @@ var ProjectBuilder = class {
   }
 };
 var projects = new ProjectBuilder();
-var Project2 = (_class25 = class {
+var Project2 = (_class22 = class {
   
   
   
   
   
   
-  __init79() {this._publishableCodeFunctions = []}
-  __init80() {this._publishablePrompts = []}
-  __init81() {this._publishableParameters = []}
-  constructor(args) {;_class25.prototype.__init79.call(this);_class25.prototype.__init80.call(this);_class25.prototype.__init81.call(this);
+  __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);
     _initializeSpanContext();
     this.name = "name" in args ? args.name : void 0;
     this.id = "id" in args ? args.id : void 0;
@@ -13757,12 +14273,12 @@ var Project2 = (_class25 = class {
       functions: functionDefinitions
     });
   }
-}, _class25);
-var ToolBuilder = (_class26 = class {
-  constructor(project) {;_class26.prototype.__init82.call(this);
+}, _class22);
+var ToolBuilder = (_class23 = class {
+  constructor(project) {;_class23.prototype.__init80.call(this);
     this.project = project;
   }
-  __init82() {this.taskCounter = 0}
+  __init80() {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) {
@@ -13787,12 +14303,12 @@ var ToolBuilder = (_class26 = class {
     this.project.addCodeFunction(tool);
     return tool;
   }
-}, _class26);
-var ScorerBuilder = (_class27 = class {
-  constructor(project) {;_class27.prototype.__init83.call(this);
+}, _class23);
+var ScorerBuilder = (_class24 = class {
+  constructor(project) {;_class24.prototype.__init81.call(this);
     this.project = project;
   }
-  __init83() {this.taskCounter = 0}
+  __init81() {this.taskCounter = 0}
   create(opts) {
     this.taskCounter++;
     let resolvedName = opts.name;
@@ -13845,7 +14361,7 @@ var ScorerBuilder = (_class27 = class {
       this.project.addPrompt(codePrompt);
     }
   }
-}, _class27);
+}, _class24);
 var CodeFunction = class {
   constructor(project, opts) {
     this.project = project;
@@ -13855,6 +14371,7 @@ var CodeFunction = class {
     this.description = opts.description;
     this.type = opts.type;
     this.ifExists = opts.ifExists;
+    this.tags = opts.tags;
     this.metadata = opts.metadata;
     this.parameters = opts.parameters;
     this.returns = opts.returns;
@@ -13871,6 +14388,7 @@ var CodeFunction = class {
   
   
   
+  
   key() {
     return JSON.stringify([
       _nullishCoalesce(this.project.id, () => ( "")),
@@ -13890,6 +14408,7 @@ var CodePrompt = class {
   
   
   
+  
   constructor(project, prompt, toolFunctions, opts, functionType) {
     this.project = project;
     this.name = opts.name;
@@ -13900,6 +14419,7 @@ var CodePrompt = class {
     this.description = opts.description;
     this.id = opts.id;
     this.functionType = functionType;
+    this.tags = opts.tags;
     this.metadata = opts.metadata;
   }
   async toFunctionDefinition(projectNameToId) {
@@ -13934,6 +14454,7 @@ var CodePrompt = class {
       function_type: this.functionType,
       prompt_data,
       if_exists: this.ifExists,
+      tags: this.tags,
       metadata: this.metadata
     };
   }
@@ -13962,6 +14483,7 @@ var PromptBuilder = class {
       name: opts.name,
       slug,
       prompt_data: promptData,
+      tags: opts.tags,
       ...this.project.id !== void 0 ? { project_id: this.project.id } : {}
     };
     const prompt = new Prompt2(
@@ -14043,6 +14565,15 @@ function serializeEvalParametersToStaticParametersSchema(parameters) {
             description: value.description
           }
         ];
+      } else if ("type" in value && value.type === "model") {
+        return [
+          name,
+          {
+            type: "model",
+            default: value.default,
+            description: value.description
+          }
+        ];
       } else {
         const schemaObj = zodToJsonSchema(value);
         return [
@@ -14073,6 +14604,16 @@ function serializeEvalParameterstoParametersSchema(parameters) {
       if (!defaultPromptData) {
         required.push(name);
       }
+    } else if ("type" in value && value.type === "model") {
+      properties[name] = {
+        type: "string",
+        "x-bt-type": "model",
+        ...value.description ? { description: value.description } : {},
+        ..."default" in value ? { default: value.default } : {}
+      };
+      if (!("default" in value)) {
+        required.push(name);
+      }
     } else {
       const schemaObj = zodToJsonSchema(value);
       properties[name] = schemaObj;
@@ -14119,9 +14660,9 @@ function serializeRemoteEvalParametersContainer(parameters) {
     source: null
   };
 }
-var ProjectNameIdMap = (_class28 = class {constructor() { _class28.prototype.__init84.call(this);_class28.prototype.__init85.call(this); }
-  __init84() {this.nameToId = {}}
-  __init85() {this.idToName = {}}
+var ProjectNameIdMap = (_class25 = class {constructor() { _class25.prototype.__init82.call(this);_class25.prototype.__init83.call(this); }
+  __init82() {this.nameToId = {}}
+  __init83() {this.idToName = {}}
   async getId(projectName) {
     if (!(projectName in this.nameToId)) {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
@@ -14154,7 +14695,7 @@ var ProjectNameIdMap = (_class28 = class {constructor() { _class28.prototype.__i
     }
     return this.getId(project.name);
   }
-}, _class28);
+}, _class25);
 
 // dev/server.ts
 function runDevServer(evaluators, opts) {
@@ -14226,7 +14767,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _212 => _212.ctx, 'optionalAccess', _213 => _213.state])) {
+      if (!_optionalChain([req, 'access', _229 => _229.ctx, 'optionalAccess', _230 => _230.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -14277,12 +14818,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: evaluator.scores.concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _214 => _214.map, 'call', _215 => _215(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _231 => _231.map, 'call', _232 => _232(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _216 => _216.ctx, 'optionalAccess', _217 => _217.projectId])
+                  _optionalChain([req, 'access', _233 => _233.ctx, 'optionalAccess', _234 => _234.projectId])
                 )
               )]), () => ( []))
             ),