braintrust 3.3.0 → 3.4.0

package/dev/dist/index.mjs

@@ -1,5 +1,6 @@
 // src/node/config.ts
 import { AsyncLocalStorage } from "node:async_hooks";
+import * as diagnostics_channel from "node:diagnostics_channel";
 import * as path from "node:path";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
@@ -21,6 +22,26 @@ var DefaultAsyncLocalStorage = class {
     return void 0;
   }
 };
+var DefaultTracingChannel = class {
+  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);
+  }
+};
 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 = state?.getDebugLogLevel?.();
+  const hasStateOverride = state?.hasDebugLogLevelOverride?.() ?? 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 = () => state ?? debugLogStateResolver?.();
+  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
 import { simpleGit } from "simple-git";
 var COMMON_BASE_BRANCHES = ["main", "master", "develop"];
@@ -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}`
     );
@@ -261,7 +389,7 @@ var Queue = class {
   enforceSizeLimit = false;
   constructor(maxSize) {
     if (maxSize < 1) {
-      console.warn(
+      debugLogger.warn(
         `maxSize ${maxSize} is <1, using default ${DEFAULT_QUEUE_SIZE}`
       );
       maxSize = DEFAULT_QUEUE_SIZE;
@@ -4482,7 +4610,10 @@ var loginSchema = z8.strictObject({
   proxyUrl: z8.string(),
   loginToken: z8.string(),
   orgId: z8.string().nullish(),
-  gitMetadataSettings: GitMetadataSettings.nullish()
+  gitMetadataSettings: GitMetadataSettings.nullish(),
+  debugLogLevel: z8.enum(["error", "warn", "info", "debug"]).optional(),
+  // Distinguishes explicit false from unset so env fallback stays disabled after deserialization.
+  debugLogLevelDisabled: z8.boolean().optional()
 });
 var stateNonce = 0;
 var BraintrustState = class _BraintrustState {
@@ -4503,6 +4634,16 @@ var BraintrustState = 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(this.debugLogLevel ?? false);
+    } else {
+      this.debugLogLevel = getEnvDebugLogLevel();
+      setGlobalDebugLogLevel(void 0);
+    }
     this.resetLoginInfo();
     const memoryCache = new LRUCache({
       max: Number(isomorph_default.getEnv("BRAINTRUST_PROMPT_CACHE_MEMORY_MAX")) ?? 1 << 10
@@ -4547,6 +4688,8 @@ var BraintrustState = class _BraintrustState {
   proxyUrl = null;
   loggedIn = false;
   gitMetadataSettings;
+  debugLogLevel;
+  debugLogLevelConfigured = false;
   fetch = globalThis.fetch;
   _appConn = null;
   _apiConn = null;
@@ -4612,6 +4755,11 @@ var BraintrustState = 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 ? this.debugLogLevel ?? false : void 0
+    );
     this._appConn = other._appConn;
     this._apiConn = other._apiConn;
     this.loginReplaceApiConn(this.apiConn());
@@ -4636,7 +4784,9 @@ var BraintrustState = 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,6 +4813,10 @@ var BraintrustState = class _BraintrustState {
       state.proxyConn().set_token(state.loginToken);
     }
     state.loggedIn = true;
+    state.debugLogLevelConfigured = "debugLogLevel" in serializedParsed.data || !!serializedParsed.data.debugLogLevelDisabled;
+    setGlobalDebugLogLevel(
+      state.debugLogLevelConfigured ? state.debugLogLevel ?? false : void 0
+    );
     state.loginReplaceApiConn(state.apiConn());
     return state;
   }
@@ -4675,7 +4829,22 @@ var BraintrustState = class _BraintrustState {
   setMaskingFunction(maskingFunction) {
     this.bgLogger().setMaskingFunction(maskingFunction);
   }
+  setDebugLogLevel(option) {
+    if (option === void 0) {
+      return;
+    }
+    this.debugLogLevelConfigured = true;
+    this.debugLogLevel = normalizeDebugLogLevelOption(option);
+    setGlobalDebugLogLevel(this.debugLogLevel ?? false);
+  }
+  getDebugLogLevel() {
+    return this.debugLogLevel;
+  }
+  hasDebugLogLevelOverride() {
+    return this.debugLogLevelConfigured;
+  }
   async login(loginParams) {
+    this.setDebugLogLevel(loginParams.debugLogLevel);
     if (this.apiUrl && !loginParams.forceLogin) {
       return;
     }
@@ -4786,6 +4955,7 @@ function _internalSetInitialState() {
   _globalState = existing;
 }
 var _internalGetGlobalState = () => _globalState;
+setDebugLogStateResolver(() => _internalGetGlobalState());
 var FailedHTTPResponse = class extends Error {
   status;
   text;
@@ -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}`);
     }
   }
 };
@@ -5824,7 +5994,7 @@ var HTTPBackgroundLogger = 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 = class _HTTPBackgroundLogger {
           const versionInfo = await conn.get_json("version");
           serverLimit = z8.object({ logs3_payload_max_bytes: z8.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;
@@ -6030,16 +6203,16 @@ var HTTPBackgroundLogger = 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
@@ -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) {
@@ -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;
 }
@@ -6989,7 +7163,14 @@ var ObjectFetcher = class {
   async *fetchRecordsFromApi(batchSize) {
     const state = await this.getState();
     const objectId = await this.id;
-    const limit = batchSize ?? DEFAULT_FETCH_BATCH_SIZE;
+    const batchLimit = batchSize ?? DEFAULT_FETCH_BATCH_SIZE;
+    const internalLimit = this._internal_btql?.limit;
+    const limit = batchSize !== void 0 ? batchSize : internalLimit ?? batchLimit;
+    const internalBtqlWithoutReservedQueryKeys = Object.fromEntries(
+      Object.entries(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 = class {
         `btql`,
         {
           query: {
-            ...this._internal_btql,
             select: [
               {
                 op: "star"
@@ -7017,7 +7197,8 @@ var ObjectFetcher = class {
               ]
             },
             cursor,
-            limit
+            limit,
+            ...internalBtqlWithoutReservedQueryKeys
           },
           use_columnstore: false,
           brainstore_realtime: true,
@@ -7290,7 +7471,7 @@ var Experiment2 = 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,7 +7548,7 @@ 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;
@@ -7564,8 +7745,8 @@ var SpanImpl = class _SpanImpl {
       ...serializableInternalData,
       [IS_MERGE_FIELD]: this.isMerge
     });
-    if (partialRecord.metrics?.end) {
-      this.loggedEndTime = partialRecord.metrics?.end;
+    if (typeof partialRecord.metrics?.end === "number") {
+      this.loggedEndTime = partialRecord.metrics.end;
     }
     if (this.parentObjectType === 1 /* EXPERIMENT */) {
       const cachedSpan = {
@@ -7800,7 +7981,7 @@ var Dataset2 = class extends ObjectFetcher {
   constructor(state, lazyMetadata, pinnedVersion, legacy, _internal_btql) {
     const isLegacyDataset = 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.`
       );
     }
@@ -8031,7 +8212,7 @@ var Dataset2 = 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;
@@ -8447,9 +8628,6 @@ var RemoteEvalParameters = class {
 };
 var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
 
-// src/instrumentation/core/plugin.ts
-import { tracingChannel } from "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,6 +8741,49 @@ 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 = event.arguments?.[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(spanInfo?.spanAttributes)) {
+    mergeDicts(spanAttributes, spanInfo.spanAttributes);
+  }
+  return {
+    name: typeof spanInfo?.name === "string" && spanInfo.name ? spanInfo.name : config.name,
+    spanAttributes,
+    spanInfoMetadata: isObject(spanInfo?.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 = class {
   enabled = false;
@@ -8588,23 +8815,25 @@ var BasePlugin = class {
    * @param handlers - Event handlers
    */
   subscribe(channelName, handlers) {
-    const channel = tracingChannel(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 = tracingChannel(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 = class {
           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 = class {
         }
         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 = config.extractMetadata?.(event.result, event);
           span.log({
             output,
+            ...metadata !== void 0 ? { metadata } : {},
             metrics
           });
         } catch (error) {
@@ -8651,9 +8882,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -8661,15 +8892,17 @@ var BasePlugin = class {
    * Handles both streaming and non-streaming responses.
    */
   subscribeToStreamingChannel(channelName, config) {
-    const channel = tracingChannel(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 = class {
           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 = class {
         }
         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 = class {
           });
         } 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 = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -8765,15 +9019,17 @@ var BasePlugin = class {
    * Used for methods like beta.chat.completions.stream() and responses.stream().
    */
   subscribeToSyncStreamChannel(channelName, config) {
-    const channel = tracingChannel(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 = class {
           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,13 +9121,335 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
 };
 
+// src/instrumentation/core/channel-tracing.ts
+function isSyncStreamLike(value) {
+  return !!value && typeof value === "object" && typeof value.on === "function";
+}
+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 {
+    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 { span, startTime };
+}
+function logErrorAndEnd(states, event) {
+  const spanData = states.get(event);
+  if (!spanData) {
+    return;
+  }
+  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;
+      }
+      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 = config.extractMetadata?.(
+          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 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 = config.extractMetadata?.(
+          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 = {
@@ -8934,72 +9512,238 @@ function processInputAttachments(input) {
     return input;
   }
   let attachmentIndex = 0;
-  const processContentPart = (part) => {
-    if (!part || typeof part !== "object") {
-      return part;
+  const inferMediaTypeFromDataUrl = (value, fallback2) => {
+    const mediaTypeMatch = value.match(/^data:([^;]+);/);
+    return mediaTypeMatch?.[1] || fallback2;
+  };
+  const toAttachment = (value, mediaType, filename) => {
+    const blob = convertDataToBlob(value, mediaType);
+    if (!blob) {
+      return null;
     }
-    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
-        };
+    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 (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)}`;
+    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++;
-        const attachment = new Attachment({
-          data: blob,
-          filename,
-          contentType: mediaType
-        });
         return {
-          ...part,
-          data: attachment
+          ...node,
+          image: attachment
         };
       }
     }
-    return part;
-  };
-  const processMessage = (message) => {
-    if (!message || typeof message !== "object") {
-      return message;
+    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
+        };
+      }
     }
-    if (Array.isArray(message.content)) {
-      return {
-        ...message,
-        content: message.content.map(processContentPart)
-      };
+    const processed = {};
+    for (const [key, value] of Object.entries(node)) {
+      processed[key] = processNode(value);
     }
-    return message;
+    return processed;
   };
   if (Array.isArray(input)) {
-    return input.map(processMessage);
-  } else if (typeof input === "object" && input.content) {
-    return processMessage(input);
+    return input.map(processNode);
   }
-  return input;
+  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
@@ -9008,13 +9752,11 @@ var OpenAIPlugin = class extends BasePlugin {
     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),
@@ -9024,41 +9766,49 @@ var OpenAIPlugin = class extends BasePlugin {
         extractOutput: (result) => {
           return result?.choices;
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = parseMetricsFromUsage(result?.usage);
+        extractMetrics: (result, startTime, endEvent) => {
+          const metrics = withCachedMetric(
+            parseMetricsFromUsage(result?.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 result?.data?.map((d) => d.embedding);
-      },
-      extractMetrics: (result) => {
-        return parseMetricsFromUsage(result?.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 = result?.data?.[0]?.embedding;
+          return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
+        },
+        extractMetrics: (result, _startTime, endEvent) => {
+          return withCachedMetric(
+            parseMetricsFromUsage(result?.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),
@@ -9068,164 +9818,196 @@ var OpenAIPlugin = class extends BasePlugin {
         extractOutput: (result) => {
           return result?.choices;
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = parseMetricsFromUsage(result?.usage);
+        extractMetrics: (result, startTime, endEvent) => {
+          const metrics = withCachedMetric(
+            parseMetricsFromUsage(result?.usage),
+            result,
+            endEvent
+          );
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
           return metrics;
         },
         aggregateChunks: aggregateChatCompletionChunks
-      }
+      })
     );
-    this.subscribeToSyncStreamChannel(
-      "orchestrion:openai:beta.chat.completions.stream",
-      {
+    this.unsubscribers.push(
+      traceSyncStreamChannel(openAIChannels.betaChatCompletionsStream, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
+        extractInput: ([params]) => {
           const { messages, ...metadata } = params;
           return {
             input: processInputAttachments(messages),
             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 result?.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(result?.output);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = parseMetricsFromUsage(result?.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 {};
+    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 result?.results;
+        },
+        extractMetrics: (result, _startTime, endEvent) => {
+          return withCachedMetric(
+            parseMetricsFromUsage(result?.usage),
+            result,
+            endEvent
+          );
         }
-        const response = event.response;
-        if (event.type === "response.completed") {
+      })
+    );
+    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(result?.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(result?.usage),
+            result,
+            endEvent
+          );
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateResponseStreamEvents
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(openAIChannels.responsesStream, {
+        name: "openai.responses.create",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
+          return {
+            input: processInputAttachments(input),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractFromEvent: (event) => {
+          if (event.type !== "response.completed" || !event.response) {
+            return {};
+          }
+          const response = event.response;
           const data = {};
-          if (response?.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(response?.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(result?.output);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = parseMetricsFromUsage(result?.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(result?.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(result?.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;
@@ -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
-import { tracingChannel as tracingChannel2 } from "dc-browser";
+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 (response?.output !== void 0) {
+      output = processImagesInOutput(response.output);
+    }
+    const { usage: _usage, output: _output, ...rest } = response || {};
+    if (Object.keys(rest).length > 0) {
+      metadata = rest;
+    }
+    metrics = parseMetricsFromUsage(response?.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 = class extends BasePlugin {
-  unsubscribers = [];
   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,190 +10178,42 @@ var AnthropicPlugin = class extends BasePlugin {
           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(result?.usage);
+      extractMetrics: (message, startTime) => {
+        const metrics = parseMetricsFromUsage2(message?.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 (result?.[m] !== void 0) {
-            metadata[m] = result[m];
-          }
-        }
-        return metadata;
-      },
-      aggregateChunks: aggregateAnthropicStreamChunks,
-      isStreaming: (args) => {
-        return args[0]?.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(result?.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 (result?.[m] !== void 0) {
-              metadata[m] = result[m];
-            }
-          }
-          return metadata;
-        },
-        aggregateChunks: aggregateAnthropicStreamChunks,
-        isStreaming: (args) => {
-          return args[0]?.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 = tracingChannel2(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);
-          }
-        }
+        const finalized = finalizeAnthropicTokens(metrics);
+        return Object.fromEntries(
+          Object.entries(finalized).filter(
+            (entry) => entry[1] !== void 0
+          )
+        );
       },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
+      extractMetadata: (message) => {
+        const metadata = {};
+        const metas = ["stop_reason", "stop_sequence"];
+        for (const m of metas) {
+          if (message?.[m] !== void 0) {
+            metadata[m] = message[m];
+          }
         }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
+        return metadata;
+      },
+      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"
+      })
+    );
   }
 };
 function parseMetricsFromUsage2(usage) {
@@ -9570,29 +10237,29 @@ function aggregateAnthropicStreamChunks(chunks) {
   const deltas = [];
   let metrics = {};
   let metadata = {};
-  for (const chunk of chunks) {
-    switch (chunk?.type) {
+  for (const event of chunks) {
+    switch (event?.type) {
       case "message_start":
-        if (chunk.message?.usage) {
-          const initialMetrics = parseMetricsFromUsage2(chunk.message.usage);
+        if (event.message?.usage) {
+          const initialMetrics = parseMetricsFromUsage2(event.message.usage);
           metrics = { ...metrics, ...initialMetrics };
         }
         break;
       case "content_block_delta":
-        if (chunk.delta?.type === "text_delta") {
-          const text = chunk.delta?.text;
+        if (event.delta?.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-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
-import { tracingChannel as tracingChannel3 } from "dc-browser";
 var DEFAULT_DENY_OUTPUT_PATHS = [
   // v3
   "roundtrips[].request.body",
@@ -9686,7 +10385,6 @@ var DEFAULT_DENY_OUTPUT_PATHS = [
   "steps[].response.headers"
 ];
 var AISDKPlugin = class extends BasePlugin {
-  unsubscribers = [];
   config;
   constructor(config = {}) {
     super();
@@ -9696,249 +10394,148 @@ var AISDKPlugin = class extends BasePlugin {
     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 = tracingChannel3(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;
+          }
+          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;
           }
-        }
-      },
-      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
+      })
+    );
   }
 };
 function processAISDKInput(params) {
@@ -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-channels.ts
+var claudeAgentSDKChannels = defineChannels(
+  "@anthropic-ai/claude-agent-sdk",
+  {
+    query: channel({
+      channelName: "query",
+      kind: "async"
+    })
+  }
+);
+
 // src/instrumentation/plugins/claude-agent-sdk-plugin.ts
-import { tracingChannel as tracingChannel4 } from "dc-browser";
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -10288,7 +10901,9 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
   const input = buildLLMInput(prompt, conversationHistory);
   const outputs = messages.map(
     (m) => m.message?.content && m.message?.role ? { content: m.message.content, role: m.message.role } : void 0
-  ).filter((c) => c !== void 0);
+  ).filter(
+    (c) => c !== void 0
+  );
   const span = startSpan({
     name: "anthropic.messages.create",
     spanAttributes: {
@@ -10307,7 +10922,6 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
   return lastMessage.message?.content && lastMessage.message?.role ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 var ClaudeAgentSDKPlugin = class extends BasePlugin {
-  unsubscribers = [];
   onEnable() {
     this.subscribeToQuery();
   }
@@ -10323,12 +10937,13 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
    * and individual LLM calls.
    */
   subscribeToQuery() {
-    const channel = tracingChannel4("orchestrion:claude-agent-sdk:query");
+    const channel2 = claudeAgentSDKChannels.query.tracingChannel();
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
-        const params = event.arguments[0] ?? {};
-        const { prompt, options = {} } = params;
+        const params = event.arguments[0];
+        const prompt = params?.prompt;
+        const options = params?.options ?? {};
         const span = startSpan({
           name: "Claude Agent",
           spanAttributes: {
@@ -10340,7 +10955,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           span.log({
             input: typeof prompt === "string" ? prompt : {
               type: "streaming",
-              description: "AsyncIterable<SDKMessage>"
+              description: "AsyncIterable<ClaudeAgentSDKMessage>"
             },
             metadata: filterSerializableOptions(options)
           });
@@ -10362,12 +10977,19 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         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 prompt = params?.prompt;
+              const options = params?.options ?? {};
               const messageId = message.message?.id;
               if (messageId && messageId !== spanData.currentMessageId) {
                 if (spanData.currentMessages.length > 0) {
@@ -10426,7 +11048,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
             onComplete: async () => {
               try {
                 const params = event.arguments[0];
-                const { prompt, options = {} } = params;
+                const prompt = params?.prompt;
+                const options = params?.options ?? {};
                 if (spanData.currentMessages.length > 0) {
                   const finalMessage = await createLLMSpanForMessages(
                     spanData.currentMessages,
@@ -10464,7 +11087,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         } else {
           try {
             spanData.span.log({
-              output: event.result
+              output: eventResult
             });
           } catch (error) {
             console.error(
@@ -10479,7 +11102,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
       },
       error: (event) => {
         const spanData = spans.get(event);
-        if (!spanData) {
+        if (!spanData || !event.error) {
           return;
         }
         const { span } = spanData;
@@ -10490,53 +11113,39 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
 };
 
+// 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"
+  })
+});
+
 // src/instrumentation/plugins/google-genai-plugin.ts
-import { tracingChannel as tracingChannel5 } from "dc-browser";
 var GoogleGenAIPlugin = class extends BasePlugin {
-  unsubscribers = [];
   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,150 +11153,37 @@ var GoogleGenAIPlugin = class extends BasePlugin {
             metadata: { ...metadata, provider: "google-genai" }
           };
         },
-        aggregateChunks: aggregateGenerateContentChunks
-      }
-    );
-  }
-  subscribeToChannel(channelName, config) {
-    const channel = tracingChannel5(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 = tracingChannel5(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);
-    });
+      })
+    );
   }
 };
 function serializeInput(params) {
@@ -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"
       });
@@ -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 (response?.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;
   }
@@ -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;
@@ -11080,6 +11570,7 @@ function configureNode() {
   isomorph_default.getEnv = (name) => process.env[name];
   isomorph_default.getCallerLocation = getCallerLocation;
   isomorph_default.newAsyncLocalStorage = () => new AsyncLocalStorage();
+  isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
   isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };
@@ -12550,6 +13041,11 @@ var evalParametersSchema = z10.record(
       default: promptDefinitionWithToolsSchema.optional(),
       description: z10.string().optional()
     }),
+    z10.object({
+      type: z10.literal("model"),
+      default: z10.string().optional(),
+      description: z10.string().optional()
+    }),
     z10.instanceof(z10.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 = 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)];
@@ -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: [],
@@ -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
               );
@@ -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;
@@ -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."
+        )
+      );
     }
   }
 }
@@ -13619,6 +14130,11 @@ var staticParametersSchema = z12.record(
       default: PromptData.optional(),
       description: z12.string().optional()
     }),
+    z12.object({
+      type: z12.literal("model"),
+      default: z12.string().optional(),
+      description: z12.string().optional()
+    }),
     z12.object({
       type: z12.literal("data"),
       schema: z12.record(z12.unknown()),
@@ -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;
@@ -13870,6 +14387,7 @@ var CodeFunction = class {
   parameters;
   returns;
   ifExists;
+  tags;
   metadata;
   key() {
     return JSON.stringify([
@@ -13889,6 +14407,7 @@ var CodePrompt = class {
   id;
   functionType;
   toolFunctions;
+  tags;
   metadata;
   constructor(project, prompt, toolFunctions, opts, functionType) {
     this.project = project;
@@ -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;