braintrust 3.3.0 → 3.5.0

package/dist/instrumentation/index.mjs

@@ -1,5 +1,98 @@
-// src/instrumentation/core/plugin.ts
-import { tracingChannel } from "dc-browser";
+// src/isomorph.ts
+var DefaultAsyncLocalStorage = class {
+  constructor() {
+  }
+  enterWith(_) {
+  }
+  run(_, callback) {
+    return callback();
+  }
+  getStore() {
+    return void 0;
+  }
+};
+var DefaultChannel = class {
+  constructor(name) {
+    this.name = name;
+  }
+  hasSubscribers = false;
+  subscribe(_subscription) {
+  }
+  unsubscribe(_subscription) {
+    return false;
+  }
+  bindStore(_store, _transform) {
+  }
+  unbindStore(_store) {
+    return false;
+  }
+  publish(_message) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runStores(_message, fn, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+};
+var DefaultTracingChannel = class {
+  start;
+  end;
+  asyncStart;
+  asyncEnd;
+  error;
+  constructor(nameOrChannels) {
+    if (typeof nameOrChannels === "string") {
+      this.start = new DefaultChannel(`tracing:${nameOrChannels}:start`);
+      this.end = new DefaultChannel(`tracing:${nameOrChannels}:end`);
+      this.asyncStart = new DefaultChannel(
+        `tracing:${nameOrChannels}:asyncStart`
+      );
+      this.asyncEnd = new DefaultChannel(`tracing:${nameOrChannels}:asyncEnd`);
+      this.error = new DefaultChannel(`tracing:${nameOrChannels}:error`);
+      return;
+    }
+    this.start = nameOrChannels.start ?? new DefaultChannel("tracing:start");
+    this.end = nameOrChannels.end ?? new DefaultChannel("tracing:end");
+    this.asyncStart = nameOrChannels.asyncStart ?? new DefaultChannel("tracing:asyncStart");
+    this.asyncEnd = nameOrChannels.asyncEnd ?? new DefaultChannel("tracing:asyncEnd");
+    this.error = nameOrChannels.error ?? new DefaultChannel("tracing:error");
+  }
+  get hasSubscribers() {
+    return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
+  }
+  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(nameOrChannels),
+  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) {
@@ -16,7 +109,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 {
@@ -57,7 +150,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);
               }
@@ -85,7 +181,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);
@@ -99,7 +196,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) {
@@ -111,6 +210,111 @@ function patchStreamIfNeeded(stream, options) {
 // src/logger.ts
 import { v4 as uuidv42 } from "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 {
@@ -119,7 +323,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;
@@ -1916,6 +2120,8 @@ var Experiment = z6.object({
   deleted_at: z6.union([z6.string(), z6.null()]).optional(),
   dataset_id: z6.union([z6.string(), z6.null()]).optional(),
   dataset_version: z6.union([z6.string(), z6.null()]).optional(),
+  parameters_id: z6.union([z6.string(), z6.null()]).optional(),
+  parameters_version: z6.union([z6.string(), z6.null()]).optional(),
   public: z6.boolean(),
   user_id: z6.union([z6.string(), z6.null()]).optional(),
   metadata: z6.union([z6.object({}).partial().passthrough(), z6.null()]).optional(),
@@ -1938,7 +2144,11 @@ var SpanType = z6.union([
   z6.null()
 ]);
 var SpanAttributes = z6.union([
-  z6.object({ name: z6.union([z6.string(), z6.null()]), type: SpanType }).partial().passthrough(),
+  z6.object({
+    name: z6.union([z6.string(), z6.null()]),
+    type: SpanType,
+    purpose: z6.union([z6.literal("scorer"), z6.null()])
+  }).partial().passthrough(),
   z6.null()
 ]);
 var ExperimentEvent = z6.object({
@@ -2378,6 +2588,7 @@ var FunctionId = z6.union([
       version: z6.string()
     }),
     code: z6.string(),
+    function_type: FunctionTypeEnum.and(z6.unknown()).optional(),
     name: z6.union([z6.string(), z6.null()]).optional()
   }),
   z6.object({
@@ -2607,7 +2818,12 @@ var TopicAutomationConfig = z6.object({
   topic_map_functions: z6.array(TopicMapFunctionAutomation),
   scope: z6.union([SpanScope, TraceScope, GroupScope, z6.null()]).optional(),
   data_scope: TopicAutomationDataScope.optional(),
-  btql_filter: z6.union([z6.string(), z6.null()]).optional()
+  btql_filter: z6.union([z6.string(), z6.null()]).optional(),
+  backfill_time_range: z6.union([
+    z6.string(),
+    z6.object({ from: z6.string(), to: z6.string() }),
+    z6.null()
+  ]).optional()
 });
 var ProjectAutomation = z6.object({
   id: z6.string().uuid(),
@@ -3461,34 +3677,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);
@@ -4046,6 +4234,12 @@ var parametersRowSchema = z8.object({
   }),
   metadata: z8.union([z8.object({}).partial().passthrough(), z8.null()]).optional()
 });
+var InlineAttachmentReferenceSchema = z8.object({
+  type: z8.literal("inline_attachment"),
+  src: z8.string().min(1),
+  content_type: z8.string().optional(),
+  filename: z8.string().optional()
+});
 var LoginInvalidOrgError = class extends Error {
   constructor(message) {
     super(message);
@@ -4192,7 +4386,10 @@ var loginSchema = z8.strictObject({
   proxyUrl: z8.string(),
   loginToken: z8.string(),
   orgId: z8.string().nullish(),
-  gitMetadataSettings: GitMetadataSettings.nullish()
+  gitMetadataSettings: GitMetadataSettings.nullish(),
+  debugLogLevel: z8.enum(["error", "warn", "info", "debug"]).optional(),
+  // Distinguishes explicit false from unset so env fallback stays disabled after deserialization.
+  debugLogLevelDisabled: z8.boolean().optional()
 });
 var stateNonce = 0;
 var BraintrustState = class _BraintrustState {
@@ -4213,6 +4410,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
@@ -4257,6 +4464,8 @@ var BraintrustState = class _BraintrustState {
   proxyUrl = null;
   loggedIn = false;
   gitMetadataSettings;
+  debugLogLevel;
+  debugLogLevelConfigured = false;
   fetch = globalThis.fetch;
   _appConn = null;
   _apiConn = null;
@@ -4322,6 +4531,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());
@@ -4346,7 +4560,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) {
@@ -4373,6 +4589,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;
   }
@@ -4385,7 +4605,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;
     }
@@ -4483,6 +4718,7 @@ var BraintrustState = class _BraintrustState {
 };
 var _globalState;
 var _internalGetGlobalState = () => _globalState;
+setDebugLogStateResolver(() => _internalGetGlobalState());
 var FailedHTTPResponse = class extends Error {
   status;
   text;
@@ -4597,7 +4833,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;
@@ -4809,7 +5045,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}`);
     }
   }
 };
@@ -5521,7 +5757,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."
       );
     }
@@ -5583,7 +5819,10 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
           const versionInfo = await conn.get_json("version");
           serverLimit = z8.object({ logs3_payload_max_bytes: z8.number().nullish() }).parse(versionInfo).logs3_payload_max_bytes ?? null;
         } catch (e) {
-          console.warn("Failed to fetch version info for payload limit:", e);
+          debugLogger.warn(
+            "Failed to fetch version info for payload limit:",
+            e
+          );
         }
         const validServerLimit = serverLimit !== null && serverLimit > 0 ? serverLimit : null;
         const canUseOverflow = validServerLimit !== null;
@@ -5727,16 +5966,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)
           );
@@ -5837,15 +6076,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)
           );
@@ -5860,7 +6099,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) {
@@ -5892,7 +6131,7 @@ Error: ${errorText}`;
         await _HTTPBackgroundLogger.writePayloadToDir({ payloadDir, payload });
       }
     } catch (e) {
-      console.error(e);
+      debugLogger.error(e);
     }
   }
   static async writePayloadToDir({
@@ -5900,7 +6139,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;
@@ -5913,7 +6152,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
@@ -5944,7 +6183,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) {
@@ -6355,7 +6596,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) {
@@ -6363,7 +6611,6 @@ var ObjectFetcher = class {
         `btql`,
         {
           query: {
-            ...this._internal_btql,
             select: [
               {
                 op: "star"
@@ -6383,7 +6630,8 @@ var ObjectFetcher = class {
               ]
             },
             cursor,
-            limit
+            limit,
+            ...internalBtqlWithoutReservedQueryKeys
           },
           use_columnstore: false,
           brainstore_realtime: true,
@@ -6656,7 +6904,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.`
@@ -6733,7 +6981,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;
@@ -6890,8 +7138,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 = {
@@ -7126,7 +7374,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.`
       );
     }
@@ -7357,7 +7605,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;
@@ -7368,6 +7616,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;
@@ -7399,23 +7690,25 @@ var BasePlugin = class {
    * @param handlers - Event handlers
    */
   subscribe(channelName, handlers) {
-    const channel = tracingChannel(channelName);
-    channel.subscribe(handlers);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
+    channel2.subscribe(handlers);
   }
   /**
    * Subscribe to a channel for async methods (non-streaming).
    * Creates a span and logs input/output/metrics.
    */
   subscribeToChannel(channelName, config) {
-    const channel = tracingChannel(channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config,
+          event
+        );
         const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -7423,7 +7716,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);
@@ -7436,10 +7729,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) {
@@ -7462,9 +7757,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -7472,15 +7767,17 @@ var BasePlugin = class {
    * Handles both streaming and non-streaming responses.
    */
   subscribeToStreamingChannel(channelName, config) {
-    const channel = tracingChannel(channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config,
+          event
+        );
         const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -7488,7 +7785,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);
@@ -7501,24 +7798,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) {
@@ -7539,10 +7851,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) {
@@ -7566,9 +7884,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -7576,15 +7894,17 @@ var BasePlugin = class {
    * Used for methods like beta.chat.completions.stream() and responses.stream().
    */
   subscribeToSyncStreamChannel(channelName, config) {
-    const channel = tracingChannel(channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config,
+          event
+        );
         const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -7592,7 +7912,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);
@@ -7676,9 +7996,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
 };
@@ -7701,134 +8021,645 @@ 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,
+      event,
+      span
+    );
+    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;
+  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;
       }
-      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
+      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,
-          image: attachment
-        };
-      }
+      } catch (error) {
+        console.error(`Error extracting output for ${channelName}:`, error);
+      } finally {
+        span.end();
+        states.delete(event);
+      }
+    },
+    error: (event) => {
+      logErrorAndEnd(states, event);
     }
-    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
+  };
+  tracingChannel.subscribe(handlers);
+  return () => {
+    tracingChannel.unsubscribe(handlers);
+  };
+}
+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;
+      }
+      if (config.patchResult?.({
+        channelName,
+        endEvent: asyncEndEvent,
+        result: asyncEndEvent.result,
+        span,
+        startTime
+      })) {
+        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 endEvent = event;
+      if (config.patchResult?.({
+        channelName,
+        endEvent,
+        result: endEvent.result,
+        span,
+        startTime
+      })) {
+        return;
+      }
+      const stream = endEvent.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 {
-          ...part,
-          data: attachment
+          ...node,
+          image_url: {
+            ...node.image_url,
+            url: attachment
+          }
         };
       }
     }
-    return part;
-  };
-  const processMessage = (message) => {
-    if (!message || typeof message !== "object") {
-      return message;
+    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 (Array.isArray(message.content)) {
-      return {
-        ...message,
-        content: message.content.map(processContentPart)
-      };
+    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 message;
+    return processed;
   };
   if (Array.isArray(input)) {
-    return input.map(processMessage);
-  } else if (typeof input === "object" && input.content) {
-    return processMessage(input);
+    return input.map(processNode);
+  }
+  return 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 input;
+  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
@@ -7837,13 +8668,11 @@ var OpenAIPlugin = class extends BasePlugin {
     super();
   }
   onEnable() {
-    this.subscribeToStreamingChannel(
-      "orchestrion:openai:chat.completions.create",
-      {
+    this.unsubscribers.push(
+      traceStreamingChannel(openAIChannels.chatCompletionsCreate, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
+        extractInput: ([params]) => {
           const { messages, ...metadata } = params;
           return {
             input: processInputAttachments(messages),
@@ -7853,41 +8682,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),
@@ -7897,164 +8734,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)) {
@@ -8085,7 +8954,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;
@@ -8127,6 +8996,7 @@ function aggregateChatCompletionChunks(chunks) {
       }
     }
   }
+  metrics = withCachedMetric(metrics, streamResult, endEvent);
   return {
     metrics,
     output: [
@@ -8143,9 +9013,33 @@ function aggregateChatCompletionChunks(chunks) {
     ]
   };
 }
-
-// src/instrumentation/plugins/anthropic-plugin.ts
-import { tracingChannel as tracingChannel2 } from "dc-browser";
+function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
+  let output = void 0;
+  let metrics = {};
+  let metadata = void 0;
+  for (const chunk of chunks) {
+    if (!chunk || !chunk.type || !chunk.response) {
+      continue;
+    }
+    if (chunk.type !== "response.completed") {
+      continue;
+    }
+    const response = chunk.response;
+    if (response?.output !== void 0) {
+      output = processImagesInOutput(response.output);
+    }
+    const { usage: _usage, output: _output, ...rest } = response || {};
+    if (Object.keys(rest).length > 0) {
+      metadata = rest;
+    }
+    metrics = parseMetricsFromUsage(response?.usage);
+  }
+  return {
+    output,
+    metrics: withCachedMetric(metrics, void 0, endEvent),
+    ...metadata !== void 0 ? { metadata } : {}
+  };
+}
 
 // src/wrappers/anthropic-tokens-util.ts
 function finalizeAnthropicTokens(metrics) {
@@ -8167,215 +9061,75 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
   return cacheTokens;
 }
 
+// src/instrumentation/plugins/anthropic-channels.ts
+var anthropicChannels = defineChannels("@anthropic-ai/sdk", {
+  messagesCreate: channel({
+    channelName: "messages.create",
+    kind: "async"
+  }),
+  betaMessagesCreate: channel({
+    channelName: "beta.messages.create",
+    kind: "async"
+  })
+});
+
 // src/instrumentation/plugins/anthropic-plugin.ts
 var AnthropicPlugin = class extends BasePlugin {
-  unsubscribers = [];
-  onEnable() {
-    this.subscribeToAnthropicChannels();
-  }
-  onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
-  }
-  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;
-        }
-      }
-    );
+  onEnable() {
+    this.subscribeToAnthropicChannels();
   }
-  /**
-   * Subscribe to a channel for async methods that may return streams.
-   * Handles both streaming and non-streaming responses based on the stream parameter.
-   */
-  subscribeToStreamingChannel(channelName, config) {
-    const channel = tracingChannel2(channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error) {
-          console.error(`Error extracting input for ${channelName}:`, error);
-        }
+  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" }
+        };
       },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
+      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 { span, startTime } = spanData;
-        const isStreaming = config.isStreaming ? config.isStreaming(event.arguments) : isAsyncIterable(event.result);
-        if (isStreaming && isAsyncIterable(event.result)) {
-          patchStreamIfNeeded(event.result, {
-            onComplete: (chunks) => {
-              try {
-                let output;
-                let metrics;
-                let metadata = {};
-                if (config.aggregateChunks) {
-                  const aggregated = config.aggregateChunks(chunks);
-                  output = aggregated.output;
-                  metrics = aggregated.metrics;
-                  metadata = aggregated.metadata || {};
-                } else {
-                  output = config.extractOutput(chunks);
-                  metrics = config.extractMetrics(chunks, startTime);
-                  if (config.extractMetadata) {
-                    metadata = config.extractMetadata(chunks);
-                  }
-                }
-                if (!metrics.time_to_first_token && chunks.length > 0) {
-                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-                }
-                span.log({
-                  output,
-                  metrics,
-                  metadata
-                });
-              } catch (error) {
-                console.error(
-                  `Error extracting output for ${channelName}:`,
-                  error
-                );
-              } finally {
-                span.end();
-              }
-            },
-            onError: (error) => {
-              span.log({
-                error: error.message
-              });
-              span.end();
-            }
-          });
-        } else {
-          try {
-            const output = config.extractOutput(event.result);
-            const metrics = config.extractMetrics(event.result, startTime);
-            const metadata = config.extractMetadata ? config.extractMetadata(event.result) : {};
-            span.log({
-              output,
-              metrics,
-              metadata
-            });
-          } catch (error) {
-            console.error(`Error extracting output for ${channelName}:`, error);
-          } finally {
-            span.end();
-            spans.delete(event);
+        const finalized = finalizeAnthropicTokens(metrics);
+        return Object.fromEntries(
+          Object.entries(finalized).filter(
+            (entry) => entry[1] !== void 0
+          )
+        );
+      },
+      extractMetadata: (message) => {
+        const metadata = {};
+        const metas = ["stop_reason", "stop_sequence"];
+        for (const m of metas) {
+          if (message?.[m] !== void 0) {
+            metadata[m] = message[m];
           }
         }
+        return metadata;
       },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
+      aggregateChunks: (chunks) => aggregateAnthropicStreamChunks(chunks)
     };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
+    this.unsubscribers.push(
+      traceStreamingChannel(anthropicChannels.messagesCreate, anthropicConfig)
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(anthropicChannels.betaMessagesCreate, {
+        ...anthropicConfig,
+        name: "anthropic.beta.messages.create"
+      })
+    );
   }
 };
 function parseMetricsFromUsage2(usage) {
@@ -8399,29 +9153,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;
     }
@@ -8429,7 +9183,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,
@@ -8437,6 +9193,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;
@@ -8460,14 +9219,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)
@@ -8495,306 +9254,755 @@ function filterFrom(obj, fieldsToRemove) {
       result[key] = value;
     }
   }
-  return result;
+  return result;
+}
+
+// src/wrappers/ai-sdk/normalize-logged-output.ts
+var REMOVE_NORMALIZED_VALUE = Symbol("braintrust.ai-sdk.remove-normalized");
+function normalizeAISDKLoggedOutput(value) {
+  const normalized = normalizeAISDKLoggedValue(value);
+  return normalized === REMOVE_NORMALIZED_VALUE ? {} : normalized;
+}
+function normalizeAISDKLoggedValue(value, context = {}) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeAISDKLoggedValue(entry, context)).filter((entry) => entry !== REMOVE_NORMALIZED_VALUE);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const nextInProviderMetadata = context.inProviderMetadata || context.parentKey === "providerMetadata" || context.parentKey === "experimental_providerMetadata";
+  const normalizedEntries = [];
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "cachedPromptTokens" && entry === 0) {
+      continue;
+    }
+    if (context.parentKey === "request" && key === "body" && entry === "<omitted>") {
+      continue;
+    }
+    const normalizedEntry = normalizeAISDKLoggedValue(entry, {
+      inProviderMetadata: nextInProviderMetadata,
+      parentKey: key
+    });
+    if (normalizedEntry === REMOVE_NORMALIZED_VALUE) {
+      continue;
+    }
+    normalizedEntries.push([key, normalizedEntry]);
+  }
+  if (normalizedEntries.length === 0) {
+    if (context.parentKey === "request" || nextInProviderMetadata) {
+      return REMOVE_NORMALIZED_VALUE;
+    }
+    return {};
+  }
+  return Object.fromEntries(normalizedEntries);
+}
+
+// src/zod/utils.ts
+import { zodToJsonSchema as zodToJsonSchemaV3 } from "zod-to-json-schema";
+import * as z42 from "zod/v4";
+function isZodV4(zodObject) {
+  return typeof zodObject === "object" && zodObject !== null && "_zod" in zodObject && zodObject._zod !== void 0;
+}
+function zodToJsonSchema(schema) {
+  if (isZodV4(schema)) {
+    return z42.toJSONSchema(schema, {
+      target: "draft-7"
+    });
+  }
+  return zodToJsonSchemaV3(schema);
+}
+
+// src/wrappers/ai-sdk/tool-serialization.ts
+function isZodSchema(value) {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function serializeZodSchema(schema) {
+  try {
+    return zodToJsonSchema(schema);
+  } catch {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
+  }
+}
+function serializeTool(tool) {
+  if (!tool || typeof tool !== "object") {
+    return tool;
+  }
+  const serialized = { ...tool };
+  if (isZodSchema(serialized.inputSchema)) {
+    serialized.inputSchema = serializeZodSchema(serialized.inputSchema);
+  }
+  if (isZodSchema(serialized.parameters)) {
+    serialized.parameters = serializeZodSchema(serialized.parameters);
+  }
+  if ("execute" in serialized) {
+    delete serialized.execute;
+  }
+  if ("render" in serialized) {
+    delete serialized.render;
+  }
+  return serialized;
+}
+function serializeAISDKToolsForLogging(tools) {
+  if (!tools || typeof tools !== "object") {
+    return tools;
+  }
+  if (Array.isArray(tools)) {
+    return tools.map(serializeTool);
+  }
+  const serialized = {};
+  for (const [key, tool] of Object.entries(tools)) {
+    serialized[key] = serializeTool(tool);
+  }
+  return serialized;
+}
+
+// src/instrumentation/plugins/ai-sdk-channels.ts
+var aiSDKChannels = defineChannels("ai", {
+  generateText: channel({
+    channelName: "generateText",
+    kind: "async"
+  }),
+  streamText: channel({
+    channelName: "streamText",
+    kind: "async"
+  }),
+  streamTextSync: channel({
+    channelName: "streamText.sync",
+    kind: "sync-stream"
+  }),
+  generateObject: channel({
+    channelName: "generateObject",
+    kind: "async"
+  }),
+  streamObject: channel({
+    channelName: "streamObject",
+    kind: "async"
+  }),
+  streamObjectSync: channel({
+    channelName: "streamObject.sync",
+    kind: "sync-stream"
+  }),
+  agentGenerate: channel({
+    channelName: "Agent.generate",
+    kind: "async"
+  }),
+  agentStream: channel({
+    channelName: "Agent.stream",
+    kind: "async"
+  }),
+  toolLoopAgentGenerate: channel({
+    channelName: "ToolLoopAgent.generate",
+    kind: "async"
+  }),
+  toolLoopAgentStream: channel({
+    channelName: "ToolLoopAgent.stream",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/ai-sdk-plugin.ts
+var DEFAULT_DENY_OUTPUT_PATHS = [
+  // v3
+  "roundtrips[].request.body",
+  "roundtrips[].response.headers",
+  "rawResponse.headers",
+  "responseMessages",
+  // v5
+  "request.body",
+  "response.body",
+  "response.headers",
+  "steps[].request.body",
+  "steps[].response.body",
+  "steps[].response.headers"
+];
+var AUTO_PATCHED_MODEL = Symbol.for("braintrust.ai-sdk.auto-patched-model");
+var AUTO_PATCHED_TOOL = Symbol.for("braintrust.ai-sdk.auto-patched-tool");
+var AISDKPlugin = class extends BasePlugin {
+  config;
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  onEnable() {
+    this.subscribeToAISDK();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToAISDK() {
+    const denyOutputPaths = this.config.denyOutputPaths || DEFAULT_DENY_OUTPUT_PATHS;
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.generateText, {
+        name: "generateText",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.streamText, {
+        name: "streamText",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.streamTextSync, {
+        name: "streamText",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.generateObject, {
+        name: "generateObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.streamObject, {
+        name: "streamObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.streamObjectSync, {
+        name: "streamObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.agentGenerate, {
+        name: "Agent.generate",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.agentStream, {
+        name: "Agent.stream",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.toolLoopAgentGenerate, {
+        name: "ToolLoopAgent.generate",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.toolLoopAgentStream, {
+        name: "ToolLoopAgent.stream",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+  }
+};
+function processAISDKInput(params) {
+  if (!params) return params;
+  const input = processInputAttachments(params);
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return input;
+  }
+  const { tools: _tools, ...rest } = input;
+  return rest;
+}
+function prepareAISDKInput(params, event, span, denyOutputPaths) {
+  const input = processAISDKInput(params);
+  const metadata = extractMetadataFromParams(params, event.self);
+  const childTracing = prepareAISDKChildTracing(
+    params,
+    event.self,
+    span,
+    denyOutputPaths
+  );
+  event.__braintrust_ai_sdk_model_wrapped = childTracing.modelWrapped;
+  if (childTracing.cleanup) {
+    event.__braintrust_ai_sdk_cleanup = childTracing.cleanup;
+  }
+  return {
+    input,
+    metadata
+  };
+}
+function extractTopLevelAISDKMetrics(result, event, startTime) {
+  const metrics = hasModelChildTracing(event) ? {} : extractTokenMetrics(result);
+  if (startTime) {
+    metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+  }
+  return metrics;
 }
-
-// src/instrumentation/plugins/ai-sdk-plugin.ts
-import { tracingChannel as tracingChannel3 } from "dc-browser";
-var DEFAULT_DENY_OUTPUT_PATHS = [
-  // v3
-  "roundtrips[].request.body",
-  "roundtrips[].response.headers",
-  "rawResponse.headers",
-  "responseMessages",
-  // v5
-  "request.body",
-  "response.body",
-  "response.headers",
-  "steps[].request.body",
-  "steps[].response.body",
-  "steps[].response.headers"
-];
-var AISDKPlugin = class extends BasePlugin {
-  unsubscribers = [];
-  config;
-  constructor(config = {}) {
-    super();
-    this.config = config;
+function hasModelChildTracing(event) {
+  return event?.__braintrust_ai_sdk_model_wrapped === true;
+}
+function extractMetadataFromParams(params, self) {
+  const metadata = {
+    braintrust: {
+      integration_name: "ai-sdk",
+      sdk_language: "typescript"
+    }
+  };
+  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && self.settings?.model ? self.settings?.model : void 0;
+  const { model, provider } = serializeModelWithProvider(
+    params.model ?? agentModel
+  );
+  if (model) {
+    metadata.model = model;
   }
-  onEnable() {
-    this.subscribeToAISDK();
+  if (provider) {
+    metadata.provider = provider;
   }
-  onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
+  const tools = serializeAISDKToolsForLogging(params.tools);
+  if (tools) {
+    metadata.tools = tools;
   }
-  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 metadata;
+}
+function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
+  const cleanup = [];
+  const patchedModels = /* @__PURE__ */ new WeakSet();
+  const patchedTools = /* @__PURE__ */ new WeakSet();
+  let modelWrapped = false;
+  const patchModel = (model) => {
+    const resolvedModel = resolveAISDKModel(model);
+    if (!resolvedModel || typeof resolvedModel !== "object" || typeof resolvedModel.doGenerate !== "function" || patchedModels.has(resolvedModel) || resolvedModel[AUTO_PATCHED_MODEL]) {
+      return;
+    }
+    patchedModels.add(resolvedModel);
+    resolvedModel[AUTO_PATCHED_MODEL] = true;
+    modelWrapped = true;
+    const originalDoGenerate = resolvedModel.doGenerate;
+    const originalDoStream = resolvedModel.doStream;
+    const baseMetadata = buildAISDKChildMetadata(resolvedModel);
+    resolvedModel.doGenerate = async function doGeneratePatched(options) {
+      return parentSpan.traced(
+        async (span) => {
+          const result = await Reflect.apply(
+            originalDoGenerate,
+            resolvedModel,
+            [options]
+          );
+          span.log({
+            output: processAISDKOutput(result, denyOutputPaths),
+            metrics: extractTokenMetrics(result),
+            ...buildResolvedMetadataPayload(result)
+          });
+          return result;
+        },
+        {
+          name: "doGenerate",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: {
+            input: processAISDKInput(options),
+            metadata: baseMetadata
+          }
         }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-  }
-  /**
-   * Subscribe to a channel for async methods that may return streams.
-   * Handles both streaming and non-streaming responses.
-   */
-  subscribeToStreamingChannel(channelName, config) {
-    const channel = tracingChannel3(channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config.name,
+      );
+    };
+    if (originalDoStream) {
+      resolvedModel.doStream = async function doStreamPatched(options) {
+        const span = parentSpan.startSpan({
+          name: "doStream",
           spanAttributes: {
-            type: config.type
+            type: "llm" /* LLM */
+          },
+          event: {
+            input: processAISDKInput(options),
+            metadata: baseMetadata
           }
         });
-        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);
+        const result = await withCurrent(
+          span,
+          () => Reflect.apply(originalDoStream, resolvedModel, [options])
+        );
+        const output = {};
+        let text = "";
+        let reasoning = "";
+        const toolCalls = [];
+        let object = void 0;
+        const transformStream = new TransformStream({
+          transform(chunk, controller) {
+            switch (chunk.type) {
+              case "text-delta":
+                text += extractTextDelta(chunk);
+                break;
+              case "reasoning-delta":
+                if (chunk.delta) {
+                  reasoning += chunk.delta;
+                } else if (chunk.text) {
+                  reasoning += chunk.text;
                 }
-                if (!metrics.time_to_first_token && chunks.length > 0) {
-                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+                break;
+              case "tool-call":
+                toolCalls.push(chunk);
+                break;
+              case "object":
+                object = chunk.object;
+                break;
+              case "raw":
+                if (chunk.rawValue) {
+                  const rawVal = chunk.rawValue;
+                  if (rawVal.delta?.content) {
+                    text += rawVal.delta.content;
+                  } else if (rawVal.choices?.[0]?.delta?.content) {
+                    text += rawVal.choices[0].delta.content;
+                  } else if (typeof rawVal.text === "string") {
+                    text += rawVal.text;
+                  } else if (typeof rawVal.content === "string") {
+                    text += rawVal.content;
+                  }
+                }
+                break;
+              case "finish":
+                output.text = text;
+                output.reasoning = reasoning;
+                output.toolCalls = toolCalls;
+                output.finishReason = chunk.finishReason;
+                output.usage = chunk.usage;
+                if (object !== void 0) {
+                  output.object = object;
                 }
                 span.log({
-                  output,
-                  metrics
+                  output: processAISDKOutput(
+                    output,
+                    denyOutputPaths
+                  ),
+                  metrics: extractTokenMetrics(output),
+                  ...buildResolvedMetadataPayload(output)
                 });
-              } catch (error) {
-                console.error(
-                  `Error extracting output for ${channelName}:`,
-                  error
-                );
-              } finally {
                 span.end();
-              }
-            },
-            onError: (error) => {
-              span.log({
-                error: error.message
-              });
-              span.end();
+                break;
+            }
+            controller.enqueue(chunk);
+          }
+        });
+        return {
+          ...result,
+          stream: result.stream.pipeThrough(transformStream)
+        };
+      };
+    }
+    cleanup.push(() => {
+      resolvedModel.doGenerate = originalDoGenerate;
+      if (originalDoStream) {
+        resolvedModel.doStream = originalDoStream;
+      }
+      delete resolvedModel[AUTO_PATCHED_MODEL];
+    });
+  };
+  const patchTool = (tool, name) => {
+    if (tool == null || typeof tool !== "object" || !("execute" in tool) || typeof tool.execute !== "function" || patchedTools.has(tool) || tool[AUTO_PATCHED_TOOL]) {
+      return;
+    }
+    patchedTools.add(tool);
+    tool[AUTO_PATCHED_TOOL] = true;
+    const originalExecute = tool.execute;
+    tool.execute = function executePatched(...args) {
+      const result = Reflect.apply(originalExecute, this, args);
+      if (isAsyncGenerator(result)) {
+        return (async function* () {
+          const span = parentSpan.startSpan({
+            name,
+            spanAttributes: {
+              type: "tool" /* TOOL */
             }
           });
-        } else {
+          span.log({ input: args.length === 1 ? args[0] : args });
           try {
-            const output = config.extractOutput(event.result);
-            const metrics = config.extractMetrics(event.result, startTime);
+            let lastValue;
+            for await (const value of result) {
+              lastValue = value;
+              yield value;
+            }
+            span.log({ output: lastValue });
+          } catch (error) {
             span.log({
-              output,
-              metrics
+              error: error instanceof Error ? error.message : String(error)
             });
-          } catch (error) {
-            console.error(`Error extracting output for ${channelName}:`, error);
+            throw error;
           } finally {
             span.end();
-            spans.delete(event);
           }
+        })();
+      }
+      return parentSpan.traced(
+        async (span) => {
+          span.log({ input: args.length === 1 ? args[0] : args });
+          const awaitedResult = await result;
+          span.log({ output: awaitedResult });
+          return awaitedResult;
+        },
+        {
+          name,
+          spanAttributes: {
+            type: "tool" /* TOOL */
+          }
+        }
+      );
+    };
+    cleanup.push(() => {
+      tool.execute = originalExecute;
+      delete tool[AUTO_PATCHED_TOOL];
+    });
+  };
+  const patchTools = (tools) => {
+    if (!tools) {
+      return;
+    }
+    const inferName = (tool, fallback) => tool && (tool.name || tool.toolName || tool.id) || fallback;
+    if (Array.isArray(tools)) {
+      tools.forEach(
+        (tool, index) => patchTool(tool, inferName(tool, `tool[${index}]`))
+      );
+      return;
+    }
+    for (const [key, tool] of Object.entries(tools)) {
+      patchTool(tool, key);
+    }
+  };
+  if (params && typeof params === "object") {
+    patchModel(params.model);
+    patchTools(params.tools);
+  }
+  if (self && typeof self === "object") {
+    const selfRecord = self;
+    if (selfRecord.model !== void 0) {
+      patchModel(selfRecord.model);
+    }
+    if (selfRecord.settings && typeof selfRecord.settings === "object") {
+      if (selfRecord.settings.model !== void 0) {
+        patchModel(selfRecord.settings.model);
+      }
+      if (selfRecord.settings.tools !== void 0) {
+        patchTools(selfRecord.settings.tools);
+      }
+    }
+  }
+  return {
+    cleanup: cleanup.length > 0 ? () => {
+      while (cleanup.length > 0) {
+        cleanup.pop()?.();
+      }
+    } : void 0,
+    modelWrapped
+  };
+}
+function finalizeAISDKChildTracing(event) {
+  const cleanup = event?.__braintrust_ai_sdk_cleanup;
+  if (event && typeof cleanup === "function") {
+    cleanup();
+    delete event.__braintrust_ai_sdk_cleanup;
+  }
+}
+function patchAISDKStreamingResult(args) {
+  const { denyOutputPaths, endEvent, result, span, startTime } = args;
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  const resultRecord = result;
+  if (!isReadableStreamLike(resultRecord.baseStream)) {
+    return false;
+  }
+  let firstChunkTime;
+  const wrappedBaseStream = resultRecord.baseStream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        if (firstChunkTime === void 0) {
+          firstChunkTime = getCurrentUnixTimestamp();
         }
+        controller.enqueue(chunk);
       },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
+      async flush() {
+        const metrics = extractTopLevelAISDKMetrics(result, endEvent);
+        if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
+          metrics.time_to_first_token = firstChunkTime - startTime;
         }
-        const { span } = spanData;
+        const output = await processAISDKStreamingOutput(
+          result,
+          denyOutputPaths
+        );
+        const metadata = buildResolvedMetadataPayload(result).metadata;
         span.log({
-          error: event.error.message
+          output,
+          ...metadata ? { metadata } : {},
+          metrics
         });
+        finalizeAISDKChildTracing(endEvent);
         span.end();
-        spans.delete(event);
       }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
+    })
+  );
+  Object.defineProperty(resultRecord, "baseStream", {
+    configurable: true,
+    enumerable: true,
+    value: wrappedBaseStream,
+    writable: true
+  });
+  return true;
+}
+function isReadableStreamLike(value) {
+  return value != null && typeof value === "object" && typeof value.pipeThrough === "function";
+}
+async function processAISDKStreamingOutput(result, denyOutputPaths) {
+  const output = processAISDKOutput(result, denyOutputPaths);
+  if (!output || typeof output !== "object") {
+    return output;
+  }
+  const outputRecord = output;
+  try {
+    if ("text" in result && typeof result.text === "string") {
+      outputRecord.text = result.text;
+    }
+  } catch {
+  }
+  try {
+    if ("object" in result) {
+      const resolvedObject = await Promise.resolve(result.object);
+      if (resolvedObject !== void 0) {
+        outputRecord.object = resolvedObject;
+      }
+    }
+  } catch {
   }
-};
-function processAISDKInput(params) {
-  if (!params) return params;
-  return processInputAttachments(params);
+  return outputRecord;
 }
-function extractMetadataFromParams(params) {
-  const metadata = {
+function buildAISDKChildMetadata(model) {
+  const { model: modelId, provider } = serializeModelWithProvider(model);
+  return {
+    ...modelId ? { model: modelId } : {},
+    ...provider ? { provider } : {},
     braintrust: {
       integration_name: "ai-sdk",
       sdk_language: "typescript"
     }
   };
-  const { model, provider } = serializeModelWithProvider(params.model);
-  if (model) {
-    metadata.model = model;
+}
+function buildResolvedMetadataPayload(result) {
+  const gatewayInfo = extractGatewayRoutingInfo(result);
+  const metadata = {};
+  if (gatewayInfo?.provider) {
+    metadata.provider = gatewayInfo.provider;
   }
-  if (provider) {
-    metadata.provider = provider;
+  if (gatewayInfo?.model) {
+    metadata.model = gatewayInfo.model;
   }
-  return metadata;
+  if (result.finishReason !== void 0) {
+    metadata.finish_reason = result.finishReason;
+  }
+  return Object.keys(metadata).length > 0 ? { metadata } : {};
+}
+function resolveAISDKModel(model) {
+  if (typeof model !== "string") {
+    return model;
+  }
+  const provider = globalThis.AI_SDK_DEFAULT_PROVIDER ?? null;
+  if (provider && typeof provider.languageModel === "function") {
+    return provider.languageModel(model);
+  }
+  return model;
+}
+function extractTextDelta(chunk) {
+  if (typeof chunk.textDelta === "string") return chunk.textDelta;
+  if (typeof chunk.delta === "string") return chunk.delta;
+  if (typeof chunk.text === "string") return chunk.text;
+  if (typeof chunk.content === "string") return chunk.content;
+  return "";
+}
+function isAsyncGenerator(value) {
+  return value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function" && typeof value.next === "function" && typeof value.return === "function" && typeof value.throw === "function";
 }
 function processAISDKOutput(output, denyOutputPaths) {
   if (!output) return output;
-  const getterValues = extractGetterValues(output);
-  const merged = { ...output, ...getterValues };
-  return omit(merged, denyOutputPaths);
+  const merged = extractSerializableOutputFields(output);
+  return normalizeAISDKLoggedOutput(omit(merged, denyOutputPaths));
 }
 function extractTokenMetrics(result) {
   const metrics = {};
@@ -8844,12 +10052,14 @@ function extractTokenMetrics(result) {
   }
   return metrics;
 }
-function aggregateAISDKChunks(chunks) {
+function aggregateAISDKChunks(chunks, _result, endEvent) {
   const lastChunk = chunks[chunks.length - 1];
   const output = {};
   let metrics = {};
+  let metadata;
   if (lastChunk) {
-    metrics = extractTokenMetrics(lastChunk);
+    metrics = hasModelChildTracing(endEvent) ? {} : extractTokenMetrics(lastChunk);
+    metadata = buildResolvedMetadataPayload(lastChunk).metadata;
     if (lastChunk.text !== void 0) {
       output.text = lastChunk.text;
     }
@@ -8863,7 +10073,8 @@ function aggregateAISDKChunks(chunks) {
       output.toolCalls = lastChunk.toolCalls;
     }
   }
-  return { output, metrics };
+  finalizeAISDKChildTracing(endEvent);
+  return { output, metrics, metadata };
 }
 function extractGetterValues(obj) {
   const getterValues = {};
@@ -8883,7 +10094,7 @@ function extractGetterValues(obj) {
   ];
   for (const name of getterNames) {
     try {
-      if (obj && name in obj && typeof obj[name] !== "function") {
+      if (obj && name in obj && isSerializableOutputValue(obj[name])) {
         getterValues[name] = obj[name];
       }
     } catch {
@@ -8891,6 +10102,47 @@ function extractGetterValues(obj) {
   }
   return getterValues;
 }
+function extractSerializableOutputFields(output) {
+  const serialized = {};
+  const directFieldNames = [
+    "steps",
+    "request",
+    "responseMessages",
+    "warnings",
+    "rawResponse",
+    "response",
+    "providerMetadata",
+    "experimental_providerMetadata"
+  ];
+  for (const name of directFieldNames) {
+    try {
+      const value = output?.[name];
+      if (isSerializableOutputValue(value)) {
+        serialized[name] = value;
+      }
+    } catch {
+    }
+  }
+  return {
+    ...serialized,
+    ...extractGetterValues(output)
+  };
+}
+function isSerializableOutputValue(value) {
+  if (typeof value === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value.then === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value.getReader === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function") {
+    return false;
+  }
+  return true;
+}
 function serializeModelWithProvider(model) {
   const modelId = typeof model === "string" ? model : model?.modelId;
   const explicitProvider = typeof model === "object" ? model?.provider : void 0;
@@ -8916,6 +10168,25 @@ function parseGatewayModelString(modelString) {
   }
   return { model: modelString };
 }
+function extractGatewayRoutingInfo(result) {
+  if (result?.steps && Array.isArray(result.steps) && result.steps.length > 0) {
+    const routing2 = result.steps[0]?.providerMetadata?.gateway?.routing;
+    if (routing2) {
+      return {
+        provider: routing2.resolvedProvider || routing2.finalProvider,
+        model: routing2.resolvedProviderApiModelId
+      };
+    }
+  }
+  const routing = result?.providerMetadata?.gateway?.routing;
+  if (routing) {
+    return {
+      provider: routing.resolvedProvider || routing.finalProvider,
+      model: routing.resolvedProviderApiModelId
+    };
+  }
+  return null;
+}
 function extractCostFromResult(result) {
   if (result?.steps && Array.isArray(result.steps) && result.steps.length > 0) {
     let totalCost = 0;
@@ -9009,7 +10280,10 @@ function omitAtPath(obj, keys) {
     if (Array.isArray(obj)) {
       obj.forEach((item) => {
         if (remainingKeys.length > 0) {
-          omitAtPath(item, remainingKeys);
+          omitAtPath(
+            item,
+            remainingKeys
+          );
         }
       });
     }
@@ -9019,7 +10293,10 @@ function omitAtPath(obj, keys) {
     }
   } else {
     if (obj && typeof obj === "object" && firstKey in obj) {
-      omitAtPath(obj[firstKey], remainingKeys);
+      omitAtPath(
+        obj[firstKey],
+        remainingKeys
+      );
     }
   }
 }
@@ -9032,8 +10309,18 @@ function omit(obj, paths) {
   return result;
 }
 
+// src/instrumentation/plugins/claude-agent-sdk-channels.ts
+var claudeAgentSDKChannels = defineChannels(
+  "@anthropic-ai/claude-agent-sdk",
+  {
+    query: channel({
+      channelName: "query",
+      kind: "async"
+    })
+  }
+);
+
 // src/instrumentation/plugins/claude-agent-sdk-plugin.ts
-import { tracingChannel as tracingChannel4 } from "dc-browser";
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -9117,7 +10404,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: {
@@ -9136,7 +10425,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();
   }
@@ -9152,12 +10440,13 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
    * and individual LLM calls.
    */
   subscribeToQuery() {
-    const channel = tracingChannel4("orchestrion:claude-agent-sdk:query");
+    const channel2 = claudeAgentSDKChannels.query.tracingChannel();
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
-        const params = event.arguments[0] ?? {};
-        const { prompt, options = {} } = params;
+        const params = event.arguments[0];
+        const prompt = params?.prompt;
+        const options = params?.options ?? {};
         const span = startSpan({
           name: "Claude Agent",
           spanAttributes: {
@@ -9169,7 +10458,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           span.log({
             input: typeof prompt === "string" ? prompt : {
               type: "streaming",
-              description: "AsyncIterable<SDKMessage>"
+              description: "AsyncIterable<ClaudeAgentSDKMessage>"
             },
             metadata: filterSerializableOptions(options)
           });
@@ -9191,12 +10480,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) {
@@ -9255,7 +10551,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,
@@ -9293,7 +10590,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         } else {
           try {
             spanData.span.log({
-              output: event.result
+              output: eventResult
             });
           } catch (error) {
             console.error(
@@ -9308,7 +10605,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
       },
       error: (event) => {
         const spanData = spans.get(event);
-        if (!spanData) {
+        if (!spanData || !event.error) {
           return;
         }
         const { span } = spanData;
@@ -9319,53 +10616,39 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
 };
 
+// src/instrumentation/plugins/google-genai-channels.ts
+var googleGenAIChannels = defineChannels("@google/genai", {
+  generateContent: channel({
+    channelName: "models.generateContent",
+    kind: "async"
+  }),
+  generateContentStream: channel({
+    channelName: "models.generateContentStream",
+    kind: "async"
+  })
+});
+
 // src/instrumentation/plugins/google-genai-plugin.ts
-import { tracingChannel as tracingChannel5 } from "dc-browser";
 var GoogleGenAIPlugin = class extends BasePlugin {
-  unsubscribers = [];
   onEnable() {
     this.subscribeToGoogleGenAIChannels();
   }
   onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
   subscribeToGoogleGenAIChannels() {
-    this.subscribeToChannel("orchestrion:google-genai:models.generateContent", {
-      name: "google-genai.generateContent",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        const input = serializeInput(params);
-        const metadata = extractMetadata(params);
-        return {
-          input,
-          metadata: { ...metadata, provider: "google-genai" }
-        };
-      },
-      extractOutput: (result) => {
-        return result;
-      },
-      extractMetrics: (result, startTime) => {
-        return extractGenerateContentMetrics(result, startTime);
-      }
-    });
-    this.subscribeToGoogleStreamingChannel(
-      "orchestrion:google-genai:models.generateContentStream",
-      {
-        name: "google-genai.generateContentStream",
+    this.unsubscribers.push(
+      traceAsyncChannel(googleGenAIChannels.generateContent, {
+        name: "google-genai.generateContent",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
+        extractInput: ([params]) => {
           const input = serializeInput(params);
           const metadata = extractMetadata(params);
           return {
@@ -9373,150 +10656,37 @@ var GoogleGenAIPlugin = class extends BasePlugin {
             metadata: { ...metadata, provider: "google-genai" }
           };
         },
-        aggregateChunks: aggregateGenerateContentChunks
-      }
-    );
-  }
-  subscribeToChannel(channelName, config) {
-    const channel = tracingChannel5(channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error) {
-          console.error(`Error extracting input for ${channelName}:`, error);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        try {
-          const output = config.extractOutput(event.result);
-          const metrics = config.extractMetrics(event.result, startTime);
-          span.log({
-            output,
-            metrics
-          });
-        } catch (error) {
-          console.error(`Error extracting output for ${channelName}:`, error);
-        } finally {
-          span.end();
-          spans.delete(event);
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
+        extractOutput: (result) => {
+          return result;
+        },
+        extractMetrics: (result, startTime) => {
+          return extractGenerateContentMetrics(result, startTime);
         }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
-  }
-  subscribeToGoogleStreamingChannel(channelName, config) {
-    const channel = tracingChannel5(channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config.name,
-          spanAttributes: {
-            type: config.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config.extractInput(event.arguments);
-          span.log({
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(googleGenAIChannels.generateContentStream, {
+        name: "google-genai.generateContentStream",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const input = serializeInput(params);
+          const metadata = extractMetadata(params);
+          return {
             input,
-            metadata
-          });
-        } catch (error) {
-          console.error(`Error extracting input for ${channelName}:`, error);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        if (isAsyncIterable(event.result)) {
-          patchStreamIfNeeded(event.result, {
-            onComplete: (chunks) => {
-              try {
-                const { output, metrics } = config.aggregateChunks(
-                  chunks,
-                  startTime
-                );
-                span.log({
-                  output,
-                  metrics
-                });
-              } catch (error) {
-                console.error(
-                  `Error extracting output for ${channelName}:`,
-                  error
-                );
-              } finally {
-                span.end();
-              }
-            },
-            onError: (error) => {
-              span.log({
-                error: error.message
-              });
-              span.end();
-            }
-          });
-        } else {
-          span.end();
-          spans.delete(event);
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
+            metadata: { ...metadata, provider: "google-genai" }
+          };
+        },
+        extractOutput: (result) => {
+          return result;
+        },
+        extractMetrics: () => {
+          return {};
+        },
+        aggregateChunks: (chunks, _result, _endEvent, startTime) => {
+          return aggregateGenerateContentChunks(chunks, startTime);
         }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
+      })
+    );
   }
 };
 function serializeInput(params) {
@@ -9572,8 +10742,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"
       });
@@ -9622,33 +10796,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;
   }
@@ -9719,21 +10896,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;
@@ -9745,7 +10908,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;