braintrust 3.3.0 → 3.4.0

package/dist/instrumentation/index.js

@@ -39,8 +39,55 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/instrumentation/core/plugin.ts
-var import_dc_browser = require("dc-browser");
+// src/isomorph.ts
+var DefaultAsyncLocalStorage = class {
+  constructor() {
+  }
+  enterWith(_) {
+  }
+  run(_, callback) {
+    return callback();
+  }
+  getStore() {
+    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()
+  getRepoInfo: async (_settings) => void 0,
+  getPastNAncestors: async () => [],
+  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,
+  writeln: (text) => console.log(text)
+};
+var isomorph_default = iso;
 
 // src/instrumentation/core/stream-patcher.ts
 function isAsyncIterable(value) {
@@ -57,7 +104,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 {
@@ -98,7 +145,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);
               }
@@ -126,7 +176,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);
@@ -140,7 +191,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) {
@@ -152,6 +205,111 @@ function patchStreamIfNeeded(stream, options) {
 // src/logger.ts
 var import_uuid2 = require("uuid");
 
+// 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/queue.ts
 var DEFAULT_QUEUE_SIZE = 15e3;
 var Queue = class {
@@ -160,7 +318,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;
@@ -3500,34 +3658,6 @@ function devNullWritableStream() {
   });
 }
 
-// src/isomorph.ts
-var DefaultAsyncLocalStorage = class {
-  constructor() {
-  }
-  enterWith(_) {
-  }
-  run(_, callback) {
-    return callback();
-  }
-  getStore() {
-    return void 0;
-  }
-};
-var iso = {
-  buildType: "unknown",
-  // Will be set by configureBrowser() or configureNode()
-  getRepoInfo: async (_settings) => void 0,
-  getPastNAncestors: async () => [],
-  getEnv: (_name) => void 0,
-  getCallerLocation: () => void 0,
-  newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
-  processOn: (_0, _1) => {
-  },
-  basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
-  writeln: (text) => console.log(text)
-};
-var isomorph_default = iso;
-
 // src/prompt-cache/disk-cache.ts
 function canUseDiskCache() {
   return !!(isomorph_default.hash && isomorph_default.gunzip && isomorph_default.gzip && isomorph_default.stat && isomorph_default.readFile && isomorph_default.writeFile && isomorph_default.utimes && isomorph_default.readdir && isomorph_default.mkdir && isomorph_default.unlink && isomorph_default.homedir);
@@ -4231,7 +4361,10 @@ var loginSchema = import_v38.z.strictObject({
   proxyUrl: import_v38.z.string(),
   loginToken: import_v38.z.string(),
   orgId: import_v38.z.string().nullish(),
-  gitMetadataSettings: GitMetadataSettings.nullish()
+  gitMetadataSettings: GitMetadataSettings.nullish(),
+  debugLogLevel: import_v38.z.enum(["error", "warn", "info", "debug"]).optional(),
+  // Distinguishes explicit false from unset so env fallback stays disabled after deserialization.
+  debugLogLevelDisabled: import_v38.z.boolean().optional()
 });
 var stateNonce = 0;
 var BraintrustState = class _BraintrustState {
@@ -4252,6 +4385,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
@@ -4296,6 +4439,8 @@ var BraintrustState = class _BraintrustState {
   proxyUrl = null;
   loggedIn = false;
   gitMetadataSettings;
+  debugLogLevel;
+  debugLogLevelConfigured = false;
   fetch = globalThis.fetch;
   _appConn = null;
   _apiConn = null;
@@ -4361,6 +4506,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());
@@ -4385,7 +4535,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) {
@@ -4412,6 +4564,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;
   }
@@ -4424,7 +4580,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;
     }
@@ -4522,6 +4693,7 @@ var BraintrustState = class _BraintrustState {
 };
 var _globalState;
 var _internalGetGlobalState = () => _globalState;
+setDebugLogStateResolver(() => _internalGetGlobalState());
 var FailedHTTPResponse = class extends Error {
   status;
   text;
@@ -4636,7 +4808,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;
@@ -4848,7 +5020,7 @@ with a Blob/ArrayBuffer, or run the program on Node.js.`
     try {
       statSync(data);
     } catch (e) {
-      console.warn(`Failed to read file: ${e}`);
+      debugLogger.warn(`Failed to read file: ${e}`);
     }
   }
 };
@@ -5560,7 +5732,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."
       );
     }
@@ -5622,7 +5794,10 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
           const versionInfo = await conn.get_json("version");
           serverLimit = import_v38.z.object({ logs3_payload_max_bytes: import_v38.z.number().nullish() }).parse(versionInfo).logs3_payload_max_bytes ?? null;
         } catch (e) {
-          console.warn("Failed to fetch version info for payload limit:", e);
+          debugLogger.warn(
+            "Failed to fetch version info for payload limit:",
+            e
+          );
         }
         const validServerLimit = serverLimit !== null && serverLimit > 0 ? serverLimit : null;
         const canUseOverflow = validServerLimit !== null;
@@ -5766,16 +5941,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)
           );
@@ -5876,15 +6051,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)
           );
@@ -5899,7 +6074,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) {
@@ -5931,7 +6106,7 @@ Error: ${errorText}`;
         await _HTTPBackgroundLogger.writePayloadToDir({ payloadDir, payload });
       }
     } catch (e) {
-      console.error(e);
+      debugLogger.error(e);
     }
   }
   static async writePayloadToDir({
@@ -5939,7 +6114,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;
@@ -5952,7 +6127,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
@@ -5983,7 +6158,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) {
@@ -6394,7 +6571,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) {
@@ -6402,7 +6586,6 @@ var ObjectFetcher = class {
         `btql`,
         {
           query: {
-            ...this._internal_btql,
             select: [
               {
                 op: "star"
@@ -6422,7 +6605,8 @@ var ObjectFetcher = class {
               ]
             },
             cursor,
-            limit
+            limit,
+            ...internalBtqlWithoutReservedQueryKeys
           },
           use_columnstore: false,
           brainstore_realtime: true,
@@ -6695,7 +6879,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.`
@@ -6772,7 +6956,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;
@@ -6929,8 +7113,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 = {
@@ -7165,7 +7349,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.`
       );
     }
@@ -7396,7 +7580,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;
@@ -7407,6 +7591,49 @@ var Dataset2 = class extends ObjectFetcher {
 };
 var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
 
+// 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;
@@ -7438,23 +7665,25 @@ var BasePlugin = class {
    * @param handlers - Event handlers
    */
   subscribe(channelName, handlers) {
-    const channel = (0, import_dc_browser.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 = (0, import_dc_browser.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 });
@@ -7462,7 +7691,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);
@@ -7475,10 +7704,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) {
@@ -7501,9 +7732,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -7511,15 +7742,17 @@ var BasePlugin = class {
    * Handles both streaming and non-streaming responses.
    */
   subscribeToStreamingChannel(channelName, config) {
-    const channel = (0, import_dc_browser.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 });
@@ -7527,7 +7760,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);
@@ -7540,24 +7773,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) {
@@ -7578,10 +7826,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) {
@@ -7605,9 +7859,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -7615,15 +7869,17 @@ var BasePlugin = class {
    * Used for methods like beta.chat.completions.stream() and responses.stream().
    */
   subscribeToSyncStreamChannel(channelName, config) {
-    const channel = (0, import_dc_browser.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 });
@@ -7631,7 +7887,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);
@@ -7715,9 +7971,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
 };
@@ -7740,149 +7996,635 @@ function isValidChannelName(channelName) {
   return /^braintrust:[^:]+:.+$/.test(channelName);
 }
 
-// src/wrappers/attachment-utils.ts
-function getExtensionFromMediaType(mediaType) {
-  const extensionMap = {
-    "image/png": "png",
-    "image/jpeg": "jpg",
-    "image/gif": "gif",
-    "image/webp": "webp",
-    "image/svg+xml": "svg",
-    "audio/mpeg": "mp3",
-    "audio/wav": "wav",
-    "audio/ogg": "ogg",
-    "video/mp4": "mp4",
-    "video/webm": "webm",
-    "application/pdf": "pdf",
-    "application/json": "json",
-    "text/plain": "txt",
-    "text/html": "html",
-    "text/csv": "csv"
-  };
-  return extensionMap[mediaType] || "bin";
+// src/instrumentation/core/channel-tracing.ts
+function isSyncStreamLike(value) {
+  return !!value && typeof value === "object" && typeof value.on === "function";
 }
-function convertDataToBlob(data, mediaType) {
+function hasChoices(value) {
+  return !!value && typeof value === "object" && "choices" in value;
+}
+function normalizeMetadata(metadata) {
+  return isObject(metadata) ? metadata : void 0;
+}
+function startSpanForEvent(config, event, channelName) {
+  const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+    config,
+    event
+  );
+  const span = startSpan({
+    name,
+    spanAttributes
+  });
+  const startTime = getCurrentUnixTimestamp();
   try {
-    if (typeof data === "string") {
-      if (data.startsWith("data:")) {
-        const base64Match = data.match(/^data:[^;]+;base64,(.+)$/);
-        if (base64Match) {
-          const base64 = base64Match[1];
-          const binaryString = atob(base64);
-          const bytes = new Uint8Array(binaryString.length);
-          for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-          }
-          return new Blob([bytes], { type: mediaType });
-        }
-      } else if (data.startsWith("http://") || data.startsWith("https://")) {
-        return null;
-      } else {
-        const binaryString = atob(data);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-          bytes[i] = binaryString.charCodeAt(i);
-        }
-        return new Blob([bytes], { type: mediaType });
-      }
-    } else if (data instanceof Uint8Array) {
-      return new Blob([data], { type: mediaType });
-    } else if (data instanceof ArrayBuffer) {
-      return new Blob([data], { type: mediaType });
-    } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
-      return new Blob([data], { type: mediaType });
-    }
-  } catch {
-    return null;
+    const { input, metadata } = config.extractInput(event.arguments);
+    span.log({
+      input,
+      metadata: mergeInputMetadata(metadata, spanInfoMetadata)
+    });
+  } catch (error) {
+    console.error(`Error extracting input for ${channelName}:`, error);
   }
-  return null;
+  return { span, startTime };
 }
-function processInputAttachments(input) {
-  if (!input) {
-    return input;
+function logErrorAndEnd(states, event) {
+  const spanData = states.get(event);
+  if (!spanData) {
+    return;
   }
-  let attachmentIndex = 0;
-  const processContentPart = (part) => {
-    if (!part || typeof part !== "object") {
-      return part;
-    }
-    if (part.type === "image" && part.image) {
-      let mediaType = "image/png";
-      if (typeof part.image === "string" && part.image.startsWith("data:")) {
-        const mediaTypeMatch = part.image.match(/^data:([^;]+);/);
-        if (mediaTypeMatch) {
-          mediaType = mediaTypeMatch[1];
-        }
-      } else if (part.mediaType) {
-        mediaType = part.mediaType;
-      }
-      const blob = convertDataToBlob(part.image, mediaType);
-      if (blob) {
-        const filename = `input_image_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
-        attachmentIndex++;
-        const attachment = new Attachment({
-          data: blob,
-          filename,
-          contentType: mediaType
-        });
-        return {
-          ...part,
-          image: attachment
-        };
+  spanData.span.log({
+    error: event.error.message
+  });
+  spanData.span.end();
+  states.delete(event);
+}
+function traceAsyncChannel(channel2, config) {
+  const tracingChannel = channel2.tracingChannel();
+  const states = /* @__PURE__ */ new WeakMap();
+  const channelName = channel2.channelName;
+  const handlers = {
+    start: (event) => {
+      states.set(
+        event,
+        startSpanForEvent(
+          config,
+          event,
+          channelName
+        )
+      );
+    },
+    asyncEnd: (event) => {
+      const spanData = states.get(event);
+      if (!spanData) {
+        return;
       }
-    }
-    if (part.type === "file" && part.data) {
-      const mediaType = part.mediaType || "application/octet-stream";
-      const blob = convertDataToBlob(part.data, mediaType);
-      if (blob) {
-        const filename = part.filename || `input_file_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
-        attachmentIndex++;
-        const attachment = new Attachment({
-          data: blob,
-          filename,
-          contentType: mediaType
+      const asyncEndEvent = event;
+      const { span, startTime } = spanData;
+      try {
+        const output = config.extractOutput(
+          asyncEndEvent.result,
+          asyncEndEvent
+        );
+        const metrics = config.extractMetrics(
+          asyncEndEvent.result,
+          startTime,
+          asyncEndEvent
+        );
+        const metadata = config.extractMetadata?.(
+          asyncEndEvent.result,
+          asyncEndEvent
+        );
+        span.log({
+          output,
+          ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
+          metrics
         });
-        return {
-          ...part,
-          data: attachment
-        };
+      } catch (error) {
+        console.error(`Error extracting output for ${channelName}:`, error);
+      } finally {
+        span.end();
+        states.delete(event);
       }
+    },
+    error: (event) => {
+      logErrorAndEnd(states, event);
     }
-    return part;
   };
-  const processMessage = (message) => {
-    if (!message || typeof message !== "object") {
-      return message;
-    }
-    if (Array.isArray(message.content)) {
-      return {
-        ...message,
-        content: message.content.map(processContentPart)
-      };
-    }
-    return message;
+  tracingChannel.subscribe(handlers);
+  return () => {
+    tracingChannel.unsubscribe(handlers);
   };
-  if (Array.isArray(input)) {
-    return input.map(processMessage);
-  } else if (typeof input === "object" && input.content) {
-    return processMessage(input);
-  }
-  return input;
 }
-
-// src/instrumentation/plugins/openai-plugin.ts
-var OpenAIPlugin = class extends BasePlugin {
-  constructor() {
+function traceStreamingChannel(channel2, config) {
+  const tracingChannel = 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);
+    }
+  };
+  tracingChannel.subscribe(handlers);
+  return () => {
+    tracingChannel.unsubscribe(handlers);
+  };
+}
+function traceSyncStreamChannel(channel2, config) {
+  const tracingChannel = 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);
+    }
+  };
+  tracingChannel.subscribe(handlers);
+  return () => {
+    tracingChannel.unsubscribe(handlers);
+  };
+}
+function unsubscribeAll(unsubscribers) {
+  for (const unsubscribe of unsubscribers) {
+    unsubscribe();
+  }
+  return [];
+}
+
+// src/wrappers/attachment-utils.ts
+function getExtensionFromMediaType(mediaType) {
+  const extensionMap = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/svg+xml": "svg",
+    "audio/mpeg": "mp3",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "application/pdf": "pdf",
+    "application/json": "json",
+    "text/plain": "txt",
+    "text/html": "html",
+    "text/csv": "csv"
+  };
+  return extensionMap[mediaType] || "bin";
+}
+function convertDataToBlob(data, mediaType) {
+  try {
+    if (typeof data === "string") {
+      if (data.startsWith("data:")) {
+        const base64Match = data.match(/^data:[^;]+;base64,(.+)$/);
+        if (base64Match) {
+          const base64 = base64Match[1];
+          const binaryString = atob(base64);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          return new Blob([bytes], { type: mediaType });
+        }
+      } else if (data.startsWith("http://") || data.startsWith("https://")) {
+        return null;
+      } else {
+        const binaryString = atob(data);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        return new Blob([bytes], { type: mediaType });
+      }
+    } else if (data instanceof Uint8Array) {
+      return new Blob([data], { type: mediaType });
+    } else if (data instanceof ArrayBuffer) {
+      return new Blob([data], { type: mediaType });
+    } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
+      return new Blob([data], { type: mediaType });
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function processInputAttachments(input) {
+  if (!input) {
+    return input;
+  }
+  let attachmentIndex = 0;
+  const inferMediaTypeFromDataUrl = (value, fallback) => {
+    const mediaTypeMatch = value.match(/^data:([^;]+);/);
+    return mediaTypeMatch?.[1] || fallback;
+  };
+  const toAttachment = (value, mediaType, filename) => {
+    const blob = convertDataToBlob(value, mediaType);
+    if (!blob) {
+      return null;
+    }
+    return new Attachment({
+      data: blob,
+      filename,
+      contentType: mediaType
+    });
+  };
+  const processNode = (node) => {
+    if (Array.isArray(node)) {
+      return node.map(processNode);
+    }
+    if (!node || typeof node !== "object") {
+      return node;
+    }
+    if (node.type === "image_url" && node.image_url && typeof node.image_url === "object" && typeof node.image_url.url === "string" && node.image_url.url.startsWith("data:")) {
+      const mediaType = inferMediaTypeFromDataUrl(
+        node.image_url.url,
+        "image/png"
+      );
+      const filename = `image.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.image_url.url, mediaType, filename);
+      if (attachment) {
+        return {
+          ...node,
+          image_url: {
+            ...node.image_url,
+            url: attachment
+          }
+        };
+      }
+    }
+    if (node.type === "file" && node.file && typeof node.file === "object" && typeof node.file.file_data === "string" && node.file.file_data.startsWith("data:")) {
+      const mediaType = inferMediaTypeFromDataUrl(
+        node.file.file_data,
+        "application/octet-stream"
+      );
+      const filename = typeof node.file.filename === "string" && node.file.filename ? node.file.filename : `document.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.file.file_data, mediaType, filename);
+      if (attachment) {
+        return {
+          ...node,
+          file: {
+            ...node.file,
+            file_data: attachment
+          }
+        };
+      }
+    }
+    if (node.type === "image" && node.image) {
+      let mediaType = "image/png";
+      if (typeof node.image === "string" && node.image.startsWith("data:")) {
+        mediaType = inferMediaTypeFromDataUrl(node.image, mediaType);
+      } else if (node.mediaType) {
+        mediaType = node.mediaType;
+      }
+      const filename = `input_image_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.image, mediaType, filename);
+      if (attachment) {
+        attachmentIndex++;
+        return {
+          ...node,
+          image: attachment
+        };
+      }
+    }
+    if (node.type === "file" && node.data) {
+      const mediaType = node.mediaType || "application/octet-stream";
+      const filename = node.filename || `input_file_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.data, mediaType, filename);
+      if (attachment) {
+        attachmentIndex++;
+        return {
+          ...node,
+          data: attachment
+        };
+      }
+    }
+    const processed = {};
+    for (const [key, value] of Object.entries(node)) {
+      processed[key] = processNode(value);
+    }
+    return processed;
+  };
+  if (Array.isArray(input)) {
+    return input.map(processNode);
+  }
+  return processNode(input);
+}
+
+// src/instrumentation/core/channel-definitions.ts
+function channel(spec) {
+  return spec;
+}
+function defineChannels(pkg, channels) {
+  return Object.fromEntries(
+    Object.entries(channels).map(([key, spec]) => {
+      const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
+      if (spec.kind === "async") {
+        const asyncSpec = spec;
+        const tracingChannel2 = () => isomorph_default.newTracingChannel(
+          fullChannelName
+        );
+        return [
+          key,
+          {
+            ...asyncSpec,
+            tracingChannel: tracingChannel2,
+            tracePromise: (fn, context) => tracingChannel2().tracePromise(
+              fn,
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              context
+            )
+          }
+        ];
+      }
+      const syncSpec = spec;
+      const tracingChannel = () => isomorph_default.newTracingChannel(
+        fullChannelName
+      );
+      return [
+        key,
+        {
+          ...syncSpec,
+          tracingChannel,
+          traceSync: (fn, context) => tracingChannel().traceSync(
+            fn,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            context
+          )
+        }
+      ];
+    })
+  );
+}
+
+// src/instrumentation/plugins/openai-channels.ts
+var openAIChannels = defineChannels("openai", {
+  chatCompletionsCreate: channel({
+    channelName: "chat.completions.create",
+    kind: "async"
+  }),
+  embeddingsCreate: channel({
+    channelName: "embeddings.create",
+    kind: "async"
+  }),
+  betaChatCompletionsParse: channel({
+    channelName: "beta.chat.completions.parse",
+    kind: "async"
+  }),
+  betaChatCompletionsStream: channel({
+    channelName: "beta.chat.completions.stream",
+    kind: "sync-stream"
+  }),
+  moderationsCreate: channel({
+    channelName: "moderations.create",
+    kind: "async"
+  }),
+  responsesCreate: channel({
+    channelName: "responses.create",
+    kind: "async"
+  }),
+  responsesStream: channel({
+    channelName: "responses.stream",
+    kind: "sync-stream"
+  }),
+  responsesParse: channel({
+    channelName: "responses.parse",
+    kind: "async"
+  })
+});
+
+// src/openai-utils.ts
+var BRAINTRUST_CACHED_STREAM_METRIC = "__braintrust_cached_metric";
+var LEGACY_CACHED_HEADER = "x-cached";
+var X_CACHED_HEADER = "x-bt-cached";
+var TOKEN_NAME_MAP = {
+  input_tokens: "prompt_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_PREFIX_MAP = {
+  input: "prompt",
+  output: "completion"
+};
+function parseMetricsFromUsage(usage) {
+  if (!usage) {
+    return {};
+  }
+  const metrics = {};
+  for (const [oaiName, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      const metricName = TOKEN_NAME_MAP[oaiName] || oaiName;
+      metrics[metricName] = value;
+      continue;
+    }
+    if (!oaiName.endsWith("_tokens_details") || !isObject(value)) {
+      continue;
+    }
+    const rawPrefix = oaiName.slice(0, -"_tokens_details".length);
+    const prefix = TOKEN_PREFIX_MAP[rawPrefix] || rawPrefix;
+    for (const [key, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${key}`] = nestedValue;
+    }
+  }
+  return metrics;
+}
+function parseCachedHeader(value) {
+  if (!value) {
+    return void 0;
+  }
+  return ["true", "hit"].includes(value.toLowerCase()) ? 1 : 0;
+}
+function getCachedMetricFromHeaders(headers) {
+  if (!headers || typeof headers.get !== "function") {
+    return void 0;
+  }
+  const cachedHeader = headers.get(X_CACHED_HEADER);
+  if (cachedHeader) {
+    return parseCachedHeader(cachedHeader);
+  }
+  return parseCachedHeader(headers.get(LEGACY_CACHED_HEADER));
+}
+
+// src/instrumentation/plugins/openai-plugin.ts
+var OpenAIPlugin = class extends BasePlugin {
+  constructor() {
     super();
   }
   onEnable() {
-    this.subscribeToStreamingChannel(
-      "orchestrion:openai:chat.completions.create",
-      {
+    this.unsubscribers.push(
+      traceStreamingChannel(openAIChannels.chatCompletionsCreate, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
+        extractInput: ([params]) => {
           const { messages, ...metadata } = params;
           return {
             input: processInputAttachments(messages),
@@ -7892,41 +8634,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),
@@ -7936,164 +8686,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)) {
@@ -8124,7 +8906,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;
@@ -8166,6 +8948,7 @@ function aggregateChatCompletionChunks(chunks) {
       }
     }
   }
+  metrics = withCachedMetric(metrics, streamResult, endEvent);
   return {
     metrics,
     output: [
@@ -8182,9 +8965,33 @@ function aggregateChatCompletionChunks(chunks) {
     ]
   };
 }
-
-// src/instrumentation/plugins/anthropic-plugin.ts
-var import_dc_browser2 = require("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) {
@@ -8205,216 +9012,76 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
   }
   return cacheTokens;
 }
-
-// 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 = [];
-  }
-  subscribeToAnthropicChannels() {
-    this.subscribeToStreamingChannel("orchestrion:anthropic:messages.create", {
-      name: "anthropic.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;
-      }
-    });
-    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 = (0, import_dc_browser2.tracingChannel)(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);
-          }
+
+// 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 {
+  onEnable() {
+    this.subscribeToAnthropicChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToAnthropicChannels() {
+    const anthropicConfig = {
+      name: "anthropic.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: (message) => {
+        return message ? { role: message.role, content: message.content } : null;
+      },
+      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(
+            (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) {
@@ -8438,29 +9105,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;
     }
@@ -8468,7 +9135,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,
@@ -8476,6 +9145,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;
@@ -8499,14 +9171,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)
@@ -8537,8 +9209,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
-var import_dc_browser3 = require("dc-browser");
 var DEFAULT_DENY_OUTPUT_PATHS = [
   // v3
   "roundtrips[].request.body",
@@ -8554,7 +9253,6 @@ var DEFAULT_DENY_OUTPUT_PATHS = [
   "steps[].response.headers"
 ];
 var AISDKPlugin = class extends BasePlugin {
-  unsubscribers = [];
   config;
   constructor(config = {}) {
     super();
@@ -8564,249 +9262,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 = (0, import_dc_browser3.tracingChannel)(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;
           }
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.agentGenerate, {
+        name: "Agent.generate",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.agentStream, {
+        name: "Agent.stream",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
   }
 };
 function processAISDKInput(params) {
@@ -9048,7 +9645,10 @@ function omitAtPath(obj, keys) {
     if (Array.isArray(obj)) {
       obj.forEach((item) => {
         if (remainingKeys.length > 0) {
-          omitAtPath(item, remainingKeys);
+          omitAtPath(
+            item,
+            remainingKeys
+          );
         }
       });
     }
@@ -9058,7 +9658,10 @@ function omitAtPath(obj, keys) {
     }
   } else {
     if (obj && typeof obj === "object" && firstKey in obj) {
-      omitAtPath(obj[firstKey], remainingKeys);
+      omitAtPath(
+        obj[firstKey],
+        remainingKeys
+      );
     }
   }
 }
@@ -9071,8 +9674,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
-var import_dc_browser4 = require("dc-browser");
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -9156,7 +9769,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: {
@@ -9175,7 +9790,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();
   }
@@ -9191,12 +9805,13 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
    * and individual LLM calls.
    */
   subscribeToQuery() {
-    const channel = (0, import_dc_browser4.tracingChannel)("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: {
@@ -9208,7 +9823,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           span.log({
             input: typeof prompt === "string" ? prompt : {
               type: "streaming",
-              description: "AsyncIterable<SDKMessage>"
+              description: "AsyncIterable<ClaudeAgentSDKMessage>"
             },
             metadata: filterSerializableOptions(options)
           });
@@ -9230,12 +9845,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) {
@@ -9294,7 +9916,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,
@@ -9332,7 +9955,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         } else {
           try {
             spanData.span.log({
-              output: event.result
+              output: eventResult
             });
           } catch (error) {
             console.error(
@@ -9347,7 +9970,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
       },
       error: (event) => {
         const spanData = spans.get(event);
-        if (!spanData) {
+        if (!spanData || !event.error) {
           return;
         }
         const { span } = spanData;
@@ -9358,53 +9981,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
-var import_dc_browser5 = require("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 {
@@ -9412,150 +10021,37 @@ var GoogleGenAIPlugin = class extends BasePlugin {
             metadata: { ...metadata, provider: "google-genai" }
           };
         },
-        aggregateChunks: aggregateGenerateContentChunks
-      }
-    );
-  }
-  subscribeToChannel(channelName, config) {
-    const channel = (0, import_dc_browser5.tracingChannel)(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 = (0, import_dc_browser5.tracingChannel)(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) {
@@ -9611,8 +10107,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"
       });
@@ -9661,33 +10161,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;
   }
@@ -9758,21 +10261,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;
@@ -9784,7 +10273,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;