braintrust 3.3.0 → 3.4.0

package/dist/cli.js

@@ -1275,7 +1275,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "3.3.0",
+      version: "3.4.0",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
@@ -1382,6 +1382,7 @@ var require_package = __commonJS({
       ],
       scripts: {
         build: 'cross-env NODE_OPTIONS="--max-old-space-size=8192" tsup',
+        "check:typings": "tsc --noEmit",
         watch: "tsup --watch",
         clean: "rm -r dist/* && rm -r dev/dist/*",
         docs: "npx typedoc --options typedoc.json src/node/index.ts",
@@ -1402,7 +1403,8 @@ var require_package = __commonJS({
         "test:vitest": "pnpm --filter @braintrust/vitest-wrapper-tests test",
         "test:output": "tsx scripts/test-output.ts --with-comparison --with-metrics --with-progress",
         lint: "eslint .",
-        "fix:eslint": "eslint --fix ."
+        "fix:lint": "eslint --fix .",
+        playground: "tsx playground.ts"
       },
       author: "",
       license: "MIT",
@@ -1433,6 +1435,7 @@ var require_package = __commonJS({
         "cross-env": "^7.0.3",
         "eslint-plugin-node-import": "^1.0.5",
         jiti: "^2.6.1",
+        openai: "6.25.0",
         "openapi-zod-client": "^1.18.3",
         rollup: "^4.28.1",
         vite: "^5.4.14",
@@ -1461,7 +1464,7 @@ var require_package = __commonJS({
         "cli-progress": "^3.12.0",
         "cli-table3": "^0.6.5",
         cors: "^2.8.5",
-        "dc-browser": "^1.0.2",
+        "dc-browser": "^1.0.3",
         dotenv: "^16.4.5",
         esbuild: "^0.27.0",
         "eventsource-parser": "^1.1.2",
@@ -1509,6 +1512,161 @@ var import_pluralize4 = __toESM(require("pluralize"));
 // src/logger.ts
 var import_uuid2 = require("uuid");
 
+// src/isomorph.ts
+var DefaultAsyncLocalStorage = class {
+  constructor() {
+  }
+  enterWith(_) {
+  }
+  run(_, callback) {
+    return callback();
+  }
+  getStore() {
+    return void 0;
+  }
+};
+var DefaultTracingChannel = class {
+  hasSubscribers = false;
+  subscribe(_handlers) {
+  }
+  unsubscribe(_handlers) {
+    return false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  traceSync(fn, _message, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  tracePromise(fn, _message, thisArg, ...args) {
+    return Promise.resolve(fn.apply(thisArg, args));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  traceCallback(fn, _position, _message, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+};
+var iso = {
+  buildType: "unknown",
+  // Will be set by configureBrowser() or configureNode()
+  getRepoInfo: async (_settings) => void 0,
+  getPastNAncestors: async () => [],
+  getEnv: (_name) => void 0,
+  getCallerLocation: () => void 0,
+  newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  newTracingChannel: (_nameOrChannels) => new DefaultTracingChannel(),
+  processOn: (_0, _1) => {
+  },
+  basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
+  writeln: (text) => console.log(text)
+};
+var isomorph_default = iso;
+
+// src/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 {
@@ -1517,7 +1675,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;
@@ -5045,34 +5203,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);
@@ -5776,7 +5906,10 @@ var loginSchema = import_v38.z.strictObject({
   proxyUrl: import_v38.z.string(),
   loginToken: import_v38.z.string(),
   orgId: import_v38.z.string().nullish(),
-  gitMetadataSettings: GitMetadataSettings.nullish()
+  gitMetadataSettings: GitMetadataSettings.nullish(),
+  debugLogLevel: import_v38.z.enum(["error", "warn", "info", "debug"]).optional(),
+  // Distinguishes explicit false from unset so env fallback stays disabled after deserialization.
+  debugLogLevelDisabled: import_v38.z.boolean().optional()
 });
 var stateNonce = 0;
 var BraintrustState = class _BraintrustState {
@@ -5797,6 +5930,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
@@ -5841,6 +5984,8 @@ var BraintrustState = class _BraintrustState {
   proxyUrl = null;
   loggedIn = false;
   gitMetadataSettings;
+  debugLogLevel;
+  debugLogLevelConfigured = false;
   fetch = globalThis.fetch;
   _appConn = null;
   _apiConn = null;
@@ -5906,6 +6051,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());
@@ -5930,7 +6080,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) {
@@ -5957,6 +6109,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;
   }
@@ -5969,7 +6125,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;
     }
@@ -6080,6 +6251,7 @@ function _internalSetInitialState() {
   _globalState = existing;
 }
 var _internalGetGlobalState = () => _globalState;
+setDebugLogStateResolver(() => _internalGetGlobalState());
 var FailedHTTPResponse = class extends Error {
   status;
   text;
@@ -6194,7 +6366,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;
@@ -6406,7 +6578,7 @@ with a Blob/ArrayBuffer, or run the program on Node.js.`
     try {
       statSync2(data);
     } catch (e) {
-      console.warn(`Failed to read file: ${e}`);
+      debugLogger.warn(`Failed to read file: ${e}`);
     }
   }
 };
@@ -7118,7 +7290,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."
       );
     }
@@ -7180,7 +7352,10 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
           const versionInfo = await conn.get_json("version");
           serverLimit = import_v38.z.object({ logs3_payload_max_bytes: import_v38.z.number().nullish() }).parse(versionInfo).logs3_payload_max_bytes ?? null;
         } catch (e) {
-          console.warn("Failed to fetch version info for payload limit:", e);
+          debugLogger.warn(
+            "Failed to fetch version info for payload limit:",
+            e
+          );
         }
         const validServerLimit = serverLimit !== null && serverLimit > 0 ? serverLimit : null;
         const canUseOverflow = validServerLimit !== null;
@@ -7324,16 +7499,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(
             (resolve2) => setTimeout(resolve2, sleepTimeS * 1e3)
           );
@@ -7434,15 +7609,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(
             (resolve2) => setTimeout(resolve2, sleepTimeS * 1e3)
           );
@@ -7457,7 +7632,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) {
@@ -7489,7 +7664,7 @@ Error: ${errorText}`;
         await _HTTPBackgroundLogger.writePayloadToDir({ payloadDir, payload });
       }
     } catch (e) {
-      console.error(e);
+      debugLogger.error(e);
     }
   }
   static async writePayloadToDir({
@@ -7497,7 +7672,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;
@@ -7510,7 +7685,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
@@ -7541,7 +7716,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) {
@@ -7706,9 +7883,7 @@ function init(projectOrOptions, optionalOptions) {
           break;
         } catch (e) {
           if (args["base_experiment"] && `${"data" in e && e.data}`.includes("base experiment")) {
-            console.warn(
-              `Base experiment ${args["base_experiment"]} not found.`
-            );
+            debugLogger.forState(state).warn(`Base experiment ${args["base_experiment"]} not found.`);
             delete args["base_experiment"];
           } else {
             throw e;
@@ -7850,7 +8025,11 @@ async function computeLoggerMetadata(state, {
 }
 async function login(options = {}) {
   const { forceLogin = false } = options || {};
+  if (!_internalGetGlobalState()) {
+    _internalSetInitialState();
+  }
   const state = _internalGetGlobalState();
+  state.setDebugLogLevel(options.debugLogLevel);
   if (state.loggedIn && !forceLogin) {
     let checkUpdatedParam2 = function(varname, arg, orig) {
       if (!isEmpty2(arg) && !isEmpty2(orig) && arg !== orig) {
@@ -7869,9 +8048,6 @@ async function login(options = {}) {
     checkUpdatedParam2("orgName", options.orgName, state.orgName);
     return state;
   }
-  if (!state) {
-    _internalSetInitialState();
-  }
   await state.login(options);
   return state;
 }
@@ -8283,7 +8459,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) {
@@ -8291,7 +8474,6 @@ var ObjectFetcher = class {
         `btql`,
         {
           query: {
-            ...this._internal_btql,
             select: [
               {
                 op: "star"
@@ -8311,7 +8493,8 @@ var ObjectFetcher = class {
               ]
             },
             cursor,
-            limit
+            limit,
+            ...internalBtqlWithoutReservedQueryKeys
           },
           use_columnstore: false,
           brainstore_realtime: true,
@@ -8584,7 +8767,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.`
@@ -8661,7 +8844,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;
@@ -8858,8 +9041,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 = {
@@ -9094,7 +9277,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.`
       );
     }
@@ -9325,7 +9508,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;
@@ -11225,6 +11408,11 @@ var evalParametersSchema = import_v310.z.record(
       default: promptDefinitionWithToolsSchema.optional(),
       description: import_v310.z.string().optional()
     }),
+    import_v310.z.object({
+      type: import_v310.z.literal("model"),
+      default: import_v310.z.string().optional(),
+      description: import_v310.z.string().optional()
+    }),
     import_v310.z.instanceof(import_v310.z.ZodType)
     // For Zod schemas
   ])
@@ -11267,6 +11455,17 @@ function validateParametersWithZod(parameters, parameterSchema) {
             throw new Error(`Parameter '${name}' is required`);
           }
           return [name, Prompt2.fromPromptData(name, promptData)];
+        } else if ("type" in schema && schema.type === "model") {
+          const model = value ?? schema.default;
+          if (model === void 0) {
+            throw new Error(`Parameter '${name}' is required`);
+          }
+          if (typeof model !== "string") {
+            throw new Error(
+              `Parameter '${name}' must be a string model identifier`
+            );
+          }
+          return [name, model];
         } else {
           const schemaCasted = schema;
           return [name, schemaCasted.parse(value)];
@@ -11341,10 +11540,10 @@ function callEvaluatorData(data) {
   };
 }
 function isAsyncIterable2(value) {
-  return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
-  return typeof value === "object" && value !== null && typeof value[Symbol.iterator] === "function";
+  return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
 }
 globalThis._evals = {
   functions: [],
@@ -11806,7 +12005,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               const names = Object.keys(scorerErrors).join(", ");
               const errors = failingScorersAndResults.map((item) => item.error);
               unhandledScores = Object.keys(scorerErrors);
-              console.warn(
+              debugLogger.forState(evaluator.state).warn(
                 `Found exceptions for the following scorers: ${names}`,
                 errors
               );
@@ -11924,7 +12123,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       q.kill();
       if (e instanceof InternalAbortError) {
         if (isomorph_default.getEnv("BRAINTRUST_VERBOSE")) {
-          console.warn("Evaluator cancelled:", e.message);
+          debugLogger.forState(evaluator.state).warn("Evaluator cancelled:", e.message);
         }
       }
       throw e;
@@ -12020,7 +12219,11 @@ function reportFailures(evaluator, failingResults, { verbose, jsonl }) {
       }
     }
     if (!verbose && !jsonl) {
-      console.error(warning("Add --verbose to see full stack traces."));
+      console.error(
+        warning(
+          "Use --debug-logging debug to see full stack traces and troubleshooting details."
+        )
+      );
     }
   }
 }
@@ -12267,6 +12470,7 @@ var fancyReporter = {
 
 // src/node/config.ts
 var import_node_async_hooks = require("node:async_hooks");
+var diagnostics_channel = __toESM(require("node:diagnostics_channel"));
 var path = __toESM(require("node:path"));
 var fs = __toESM(require("node:fs/promises"));
 var os = __toESM(require("node:os"));
@@ -12355,7 +12559,7 @@ async function getPastNAncestors(n = 1e3, remote = void 0) {
   try {
     ancestor = await getBaseBranchAncestor(remote);
   } catch (e) {
-    console.warn(
+    debugLogger.warn(
       "Skipping git metadata. This is likely because the repository has not been published to a remote yet.",
       `${e}`
     );
@@ -12489,9 +12693,6 @@ function getCallerLocation() {
   return void 0;
 }
 
-// src/instrumentation/core/plugin.ts
-var import_dc_browser = require("dc-browser");
-
 // src/instrumentation/core/stream-patcher.ts
 function isAsyncIterable3(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
@@ -12507,7 +12708,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 {
@@ -12548,7 +12749,10 @@ function patchStreamIfNeeded(stream, options) {
             completed = true;
             if (options.onError) {
               try {
-                options.onError(error2, chunks);
+                options.onError(
+                  error2 instanceof Error ? error2 : new Error(String(error2)),
+                  chunks
+                );
               } catch (handlerError) {
                 console.error("Error in stream onError handler:", handlerError);
               }
@@ -12576,7 +12780,8 @@ function patchStreamIfNeeded(stream, options) {
         iterator.throw = async function(...args) {
           if (!completed) {
             completed = true;
-            const error2 = args[0];
+            const rawError = args[0];
+            const error2 = rawError instanceof Error ? rawError : new Error(String(rawError));
             if (options.onError) {
               try {
                 options.onError(error2, chunks);
@@ -12590,7 +12795,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 (error2) {
@@ -12599,6 +12806,49 @@ function patchStreamIfNeeded(stream, options) {
   }
 }
 
+// src/instrumentation/core/channel-tracing-utils.ts
+function hasChannelSpanInfo(value) {
+  return isObject(value) && isObject(value.span_info);
+}
+function getChannelSpanInfo(event) {
+  if (isObject(event.span_info)) {
+    return event.span_info;
+  }
+  const firstArg = event.arguments?.[0];
+  if (hasChannelSpanInfo(firstArg)) {
+    return firstArg.span_info;
+  }
+  return void 0;
+}
+function buildStartSpanArgs(config3, event) {
+  const spanInfo = getChannelSpanInfo(event);
+  const spanAttributes = {
+    type: config3.type
+  };
+  if (isObject(spanInfo?.spanAttributes)) {
+    mergeDicts(spanAttributes, spanInfo.spanAttributes);
+  }
+  return {
+    name: typeof spanInfo?.name === "string" && spanInfo.name ? spanInfo.name : config3.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;
@@ -12630,23 +12880,25 @@ var BasePlugin = class {
    * @param handlers - Event handlers
    */
   subscribe(channelName, handlers) {
-    const channel = (0, import_dc_browser.tracingChannel)(channelName);
-    channel.subscribe(handlers);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
+    channel2.subscribe(handlers);
   }
   /**
    * Subscribe to a channel for async methods (non-streaming).
    * Creates a span and logs input/output/metrics.
    */
   subscribeToChannel(channelName, config3) {
-    const channel = (0, import_dc_browser.tracingChannel)(channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config3,
+          event
+        );
         const span = startSpan({
-          name: config3.name,
-          spanAttributes: {
-            type: config3.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -12654,7 +12906,7 @@ var BasePlugin = class {
           const { input, metadata } = config3.extractInput(event.arguments);
           span.log({
             input,
-            metadata
+            metadata: mergeInputMetadata(metadata, spanInfoMetadata)
           });
         } catch (error2) {
           console.error(`Error extracting input for ${channelName}:`, error2);
@@ -12667,10 +12919,12 @@ var BasePlugin = class {
         }
         const { span, startTime } = spanData;
         try {
-          const output = config3.extractOutput(event.result);
-          const metrics = config3.extractMetrics(event.result, startTime);
+          const output = config3.extractOutput(event.result, event);
+          const metrics = config3.extractMetrics(event.result, startTime, event);
+          const metadata = config3.extractMetadata?.(event.result, event);
           span.log({
             output,
+            ...metadata !== void 0 ? { metadata } : {},
             metrics
           });
         } catch (error2) {
@@ -12693,9 +12947,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -12703,15 +12957,17 @@ var BasePlugin = class {
    * Handles both streaming and non-streaming responses.
    */
   subscribeToStreamingChannel(channelName, config3) {
-    const channel = (0, import_dc_browser.tracingChannel)(channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config3,
+          event
+        );
         const span = startSpan({
-          name: config3.name,
-          spanAttributes: {
-            type: config3.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -12719,7 +12975,7 @@ var BasePlugin = class {
           const { input, metadata } = config3.extractInput(event.arguments);
           span.log({
             input,
-            metadata
+            metadata: mergeInputMetadata(metadata, spanInfoMetadata)
           });
         } catch (error2) {
           console.error(`Error extracting input for ${channelName}:`, error2);
@@ -12732,24 +12988,39 @@ var BasePlugin = class {
         }
         const { span, startTime } = spanData;
         if (isAsyncIterable3(event.result)) {
+          let firstChunkTime;
           patchStreamIfNeeded(event.result, {
+            onChunk: () => {
+              if (firstChunkTime === void 0) {
+                firstChunkTime = getCurrentUnixTimestamp();
+              }
+            },
             onComplete: (chunks) => {
               try {
                 let output;
                 let metrics;
+                let metadata;
                 if (config3.aggregateChunks) {
-                  const aggregated = config3.aggregateChunks(chunks);
+                  const aggregated = config3.aggregateChunks(
+                    chunks,
+                    event.result,
+                    event
+                  );
                   output = aggregated.output;
                   metrics = aggregated.metrics;
+                  metadata = aggregated.metadata;
                 } else {
-                  output = config3.extractOutput(chunks);
-                  metrics = config3.extractMetrics(chunks, startTime);
+                  output = config3.extractOutput(chunks, event);
+                  metrics = config3.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 (error2) {
@@ -12770,10 +13041,16 @@ var BasePlugin = class {
           });
         } else {
           try {
-            const output = config3.extractOutput(event.result);
-            const metrics = config3.extractMetrics(event.result, startTime);
+            const output = config3.extractOutput(event.result, event);
+            const metadata = config3.extractMetadata ? config3.extractMetadata(event.result, event) : void 0;
+            const metrics = config3.extractMetrics(
+              event.result,
+              startTime,
+              event
+            );
             span.log({
               output,
+              ...metadata !== void 0 ? { metadata } : {},
               metrics
             });
           } catch (error2) {
@@ -12797,9 +13074,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
   /**
@@ -12807,15 +13084,17 @@ var BasePlugin = class {
    * Used for methods like beta.chat.completions.stream() and responses.stream().
    */
   subscribeToSyncStreamChannel(channelName, config3) {
-    const channel = (0, import_dc_browser.tracingChannel)(channelName);
+    const channel2 = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
+        const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+          config3,
+          event
+        );
         const span = startSpan({
-          name: config3.name,
-          spanAttributes: {
-            type: config3.type
-          }
+          name,
+          spanAttributes
         });
         const startTime = getCurrentUnixTimestamp();
         spans.set(event, { span, startTime });
@@ -12823,7 +13102,7 @@ var BasePlugin = class {
           const { input, metadata } = config3.extractInput(event.arguments);
           span.log({
             input,
-            metadata
+            metadata: mergeInputMetadata(metadata, spanInfoMetadata)
           });
         } catch (error2) {
           console.error(`Error extracting input for ${channelName}:`, error2);
@@ -12907,141 +13186,629 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
 };
 
-// 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(config3, event, channelName) {
+  const { name, spanAttributes, spanInfoMetadata } = buildStartSpanArgs(
+    config3,
+    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 } = config3.extractInput(event.arguments);
+    span.log({
+      input,
+      metadata: mergeInputMetadata(metadata, spanInfoMetadata)
+    });
+  } catch (error2) {
+    console.error(`Error extracting input for ${channelName}:`, error2);
   }
-  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, config3) {
+  const tracingChannel2 = channel2.tracingChannel();
+  const states = /* @__PURE__ */ new WeakMap();
+  const channelName = channel2.channelName;
+  const handlers = {
+    start: (event) => {
+      states.set(
+        event,
+        startSpanForEvent(
+          config3,
+          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
-        });
-        return {
-          ...part,
+      const asyncEndEvent = event;
+      const { span, startTime } = spanData;
+      try {
+        const output = config3.extractOutput(
+          asyncEndEvent.result,
+          asyncEndEvent
+        );
+        const metrics = config3.extractMetrics(
+          asyncEndEvent.result,
+          startTime,
+          asyncEndEvent
+        );
+        const metadata = config3.extractMetadata?.(
+          asyncEndEvent.result,
+          asyncEndEvent
+        );
+        span.log({
+          output,
+          ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
+          metrics
+        });
+      } catch (error2) {
+        console.error(`Error extracting output for ${channelName}:`, error2);
+      } finally {
+        span.end();
+        states.delete(event);
+      }
+    },
+    error: (event) => {
+      logErrorAndEnd(states, event);
+    }
+  };
+  tracingChannel2.subscribe(handlers);
+  return () => {
+    tracingChannel2.unsubscribe(handlers);
+  };
+}
+function traceStreamingChannel(channel2, config3) {
+  const tracingChannel2 = channel2.tracingChannel();
+  const states = /* @__PURE__ */ new WeakMap();
+  const channelName = channel2.channelName;
+  const handlers = {
+    start: (event) => {
+      states.set(
+        event,
+        startSpanForEvent(
+          config3,
+          event,
+          channelName
+        )
+      );
+    },
+    asyncEnd: (event) => {
+      const spanData = states.get(event);
+      if (!spanData) {
+        return;
+      }
+      const asyncEndEvent = event;
+      const { span, startTime } = spanData;
+      if (isAsyncIterable3(asyncEndEvent.result)) {
+        let firstChunkTime;
+        patchStreamIfNeeded(asyncEndEvent.result, {
+          onChunk: () => {
+            if (firstChunkTime === void 0) {
+              firstChunkTime = getCurrentUnixTimestamp();
+            }
+          },
+          onComplete: (chunks) => {
+            try {
+              let output;
+              let metrics;
+              let metadata;
+              if (config3.aggregateChunks) {
+                const aggregated = config3.aggregateChunks(
+                  chunks,
+                  asyncEndEvent.result,
+                  asyncEndEvent,
+                  startTime
+                );
+                output = aggregated.output;
+                metrics = aggregated.metrics;
+                metadata = aggregated.metadata;
+              } else {
+                output = config3.extractOutput(
+                  chunks,
+                  asyncEndEvent
+                );
+                metrics = config3.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 (error2) {
+              console.error(
+                `Error extracting output for ${channelName}:`,
+                error2
+              );
+            } finally {
+              span.end();
+              states.delete(event);
+            }
+          },
+          onError: (error2) => {
+            span.log({
+              error: error2.message
+            });
+            span.end();
+            states.delete(event);
+          }
+        });
+        return;
+      }
+      try {
+        const output = config3.extractOutput(
+          asyncEndEvent.result,
+          asyncEndEvent
+        );
+        const metrics = config3.extractMetrics(
+          asyncEndEvent.result,
+          startTime,
+          asyncEndEvent
+        );
+        const metadata = config3.extractMetadata?.(
+          asyncEndEvent.result,
+          asyncEndEvent
+        );
+        span.log({
+          output,
+          ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
+          metrics
+        });
+      } catch (error2) {
+        console.error(`Error extracting output for ${channelName}:`, error2);
+      } finally {
+        span.end();
+        states.delete(event);
+      }
+    },
+    error: (event) => {
+      logErrorAndEnd(states, event);
+    }
+  };
+  tracingChannel2.subscribe(handlers);
+  return () => {
+    tracingChannel2.unsubscribe(handlers);
+  };
+}
+function traceSyncStreamChannel(channel2, config3) {
+  const tracingChannel2 = channel2.tracingChannel();
+  const states = /* @__PURE__ */ new WeakMap();
+  const channelName = channel2.channelName;
+  const handlers = {
+    start: (event) => {
+      states.set(
+        event,
+        startSpanForEvent(
+          config3,
+          event,
+          channelName
+        )
+      );
+    },
+    end: (event) => {
+      const spanData = states.get(event);
+      if (!spanData) {
+        return;
+      }
+      const { span, startTime } = spanData;
+      const resultEvent = event;
+      const stream = resultEvent.result;
+      if (!isSyncStreamLike(stream)) {
+        span.end();
+        states.delete(event);
+        return;
+      }
+      let first = true;
+      stream.on("chunk", () => {
+        if (first) {
+          span.log({
+            metrics: {
+              time_to_first_token: getCurrentUnixTimestamp() - startTime
+            }
+          });
+          first = false;
+        }
+      });
+      stream.on("chatCompletion", (completion) => {
+        try {
+          if (hasChoices(completion)) {
+            span.log({
+              output: completion.choices
+            });
+          }
+        } catch (error2) {
+          console.error(
+            `Error extracting chatCompletion for ${channelName}:`,
+            error2
+          );
+        }
+      });
+      stream.on("event", (streamEvent) => {
+        if (!config3.extractFromEvent) {
+          return;
+        }
+        try {
+          if (first) {
+            span.log({
+              metrics: {
+                time_to_first_token: getCurrentUnixTimestamp() - startTime
+              }
+            });
+            first = false;
+          }
+          const extracted = config3.extractFromEvent(streamEvent);
+          if (extracted && Object.keys(extracted).length > 0) {
+            span.log(extracted);
+          }
+        } catch (error2) {
+          console.error(`Error extracting event for ${channelName}:`, error2);
+        }
+      });
+      stream.on("end", () => {
+        span.end();
+        states.delete(event);
+      });
+      stream.on("error", (error2) => {
+        span.log({
+          error: error2.message
+        });
+        span.end();
+        states.delete(event);
+      });
+    },
+    error: (event) => {
+      logErrorAndEnd(states, event);
+    }
+  };
+  tracingChannel2.subscribe(handlers);
+  return () => {
+    tracingChannel2.unsubscribe(handlers);
+  };
+}
+function unsubscribeAll(unsubscribers) {
+  for (const unsubscribe of unsubscribers) {
+    unsubscribe();
+  }
+  return [];
+}
+
+// src/wrappers/attachment-utils.ts
+function getExtensionFromMediaType(mediaType) {
+  const extensionMap = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/svg+xml": "svg",
+    "audio/mpeg": "mp3",
+    "audio/wav": "wav",
+    "audio/ogg": "ogg",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "application/pdf": "pdf",
+    "application/json": "json",
+    "text/plain": "txt",
+    "text/html": "html",
+    "text/csv": "csv"
+  };
+  return extensionMap[mediaType] || "bin";
+}
+function convertDataToBlob(data, mediaType) {
+  try {
+    if (typeof data === "string") {
+      if (data.startsWith("data:")) {
+        const base64Match = data.match(/^data:[^;]+;base64,(.+)$/);
+        if (base64Match) {
+          const base64 = base64Match[1];
+          const binaryString = atob(base64);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          return new Blob([bytes], { type: mediaType });
+        }
+      } else if (data.startsWith("http://") || data.startsWith("https://")) {
+        return null;
+      } else {
+        const binaryString = atob(data);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        return new Blob([bytes], { type: mediaType });
+      }
+    } else if (data instanceof Uint8Array) {
+      return new Blob([data], { type: mediaType });
+    } else if (data instanceof ArrayBuffer) {
+      return new Blob([data], { type: mediaType });
+    } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
+      return new Blob([data], { type: mediaType });
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function processInputAttachments(input) {
+  if (!input) {
+    return input;
+  }
+  let attachmentIndex = 0;
+  const inferMediaTypeFromDataUrl = (value, fallback2) => {
+    const mediaTypeMatch = value.match(/^data:([^;]+);/);
+    return mediaTypeMatch?.[1] || fallback2;
+  };
+  const toAttachment = (value, mediaType, filename) => {
+    const blob = convertDataToBlob(value, mediaType);
+    if (!blob) {
+      return null;
+    }
+    return new Attachment({
+      data: blob,
+      filename,
+      contentType: mediaType
+    });
+  };
+  const processNode = (node) => {
+    if (Array.isArray(node)) {
+      return node.map(processNode);
+    }
+    if (!node || typeof node !== "object") {
+      return node;
+    }
+    if (node.type === "image_url" && node.image_url && typeof node.image_url === "object" && typeof node.image_url.url === "string" && node.image_url.url.startsWith("data:")) {
+      const mediaType = inferMediaTypeFromDataUrl(
+        node.image_url.url,
+        "image/png"
+      );
+      const filename = `image.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.image_url.url, mediaType, filename);
+      if (attachment) {
+        return {
+          ...node,
+          image_url: {
+            ...node.image_url,
+            url: attachment
+          }
+        };
+      }
+    }
+    if (node.type === "file" && node.file && typeof node.file === "object" && typeof node.file.file_data === "string" && node.file.file_data.startsWith("data:")) {
+      const mediaType = inferMediaTypeFromDataUrl(
+        node.file.file_data,
+        "application/octet-stream"
+      );
+      const filename = typeof node.file.filename === "string" && node.file.filename ? node.file.filename : `document.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.file.file_data, mediaType, filename);
+      if (attachment) {
+        return {
+          ...node,
+          file: {
+            ...node.file,
+            file_data: attachment
+          }
+        };
+      }
+    }
+    if (node.type === "image" && node.image) {
+      let mediaType = "image/png";
+      if (typeof node.image === "string" && node.image.startsWith("data:")) {
+        mediaType = inferMediaTypeFromDataUrl(node.image, mediaType);
+      } else if (node.mediaType) {
+        mediaType = node.mediaType;
+      }
+      const filename = `input_image_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(node.image, mediaType, filename);
+      if (attachment) {
+        attachmentIndex++;
+        return {
+          ...node,
           image: attachment
         };
       }
     }
-    if (part.type === "file" && part.data) {
-      const mediaType = part.mediaType || "application/octet-stream";
-      const blob = convertDataToBlob(part.data, mediaType);
-      if (blob) {
-        const filename = part.filename || `input_file_${attachmentIndex}.${getExtensionFromMediaType(mediaType)}`;
+    if (node.type === "file" && node.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++;
-        const attachment = new Attachment({
-          data: blob,
-          filename,
-          contentType: mediaType
-        });
         return {
-          ...part,
+          ...node,
           data: attachment
         };
       }
     }
-    return part;
-  };
-  const processMessage = (message) => {
-    if (!message || typeof message !== "object") {
-      return message;
-    }
-    if (Array.isArray(message.content)) {
-      return {
-        ...message,
-        content: message.content.map(processContentPart)
-      };
+    const processed = {};
+    for (const [key, value] of Object.entries(node)) {
+      processed[key] = processNode(value);
     }
-    return message;
+    return processed;
   };
   if (Array.isArray(input)) {
-    return input.map(processMessage);
-  } else if (typeof input === "object" && input.content) {
-    return processMessage(input);
+    return input.map(processNode);
   }
-  return input;
+  return processNode(input);
+}
+
+// src/instrumentation/core/channel-definitions.ts
+function channel(spec) {
+  return spec;
+}
+function defineChannels(pkg, channels) {
+  return Object.fromEntries(
+    Object.entries(channels).map(([key, spec]) => {
+      const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
+      if (spec.kind === "async") {
+        const asyncSpec = spec;
+        const tracingChannel3 = () => isomorph_default.newTracingChannel(
+          fullChannelName
+        );
+        return [
+          key,
+          {
+            ...asyncSpec,
+            tracingChannel: tracingChannel3,
+            tracePromise: (fn, context2) => tracingChannel3().tracePromise(
+              fn,
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              context2
+            )
+          }
+        ];
+      }
+      const syncSpec = spec;
+      const tracingChannel2 = () => isomorph_default.newTracingChannel(
+        fullChannelName
+      );
+      return [
+        key,
+        {
+          ...syncSpec,
+          tracingChannel: tracingChannel2,
+          traceSync: (fn, context2) => tracingChannel2().traceSync(
+            fn,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            context2
+          )
+        }
+      ];
+    })
+  );
+}
+
+// src/instrumentation/plugins/openai-channels.ts
+var openAIChannels = defineChannels("openai", {
+  chatCompletionsCreate: channel({
+    channelName: "chat.completions.create",
+    kind: "async"
+  }),
+  embeddingsCreate: channel({
+    channelName: "embeddings.create",
+    kind: "async"
+  }),
+  betaChatCompletionsParse: channel({
+    channelName: "beta.chat.completions.parse",
+    kind: "async"
+  }),
+  betaChatCompletionsStream: channel({
+    channelName: "beta.chat.completions.stream",
+    kind: "sync-stream"
+  }),
+  moderationsCreate: channel({
+    channelName: "moderations.create",
+    kind: "async"
+  }),
+  responsesCreate: channel({
+    channelName: "responses.create",
+    kind: "async"
+  }),
+  responsesStream: channel({
+    channelName: "responses.stream",
+    kind: "sync-stream"
+  }),
+  responsesParse: channel({
+    channelName: "responses.parse",
+    kind: "async"
+  })
+});
+
+// src/openai-utils.ts
+var BRAINTRUST_CACHED_STREAM_METRIC = "__braintrust_cached_metric";
+var LEGACY_CACHED_HEADER = "x-cached";
+var X_CACHED_HEADER = "x-bt-cached";
+var TOKEN_NAME_MAP = {
+  input_tokens: "prompt_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_PREFIX_MAP = {
+  input: "prompt",
+  output: "completion"
+};
+function parseMetricsFromUsage(usage) {
+  if (!usage) {
+    return {};
+  }
+  const metrics = {};
+  for (const [oaiName, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      const metricName = TOKEN_NAME_MAP[oaiName] || oaiName;
+      metrics[metricName] = value;
+      continue;
+    }
+    if (!oaiName.endsWith("_tokens_details") || !isObject(value)) {
+      continue;
+    }
+    const rawPrefix = oaiName.slice(0, -"_tokens_details".length);
+    const prefix = TOKEN_PREFIX_MAP[rawPrefix] || rawPrefix;
+    for (const [key, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${key}`] = nestedValue;
+    }
+  }
+  return metrics;
+}
+function parseCachedHeader(value) {
+  if (!value) {
+    return void 0;
+  }
+  return ["true", "hit"].includes(value.toLowerCase()) ? 1 : 0;
+}
+function getCachedMetricFromHeaders(headers) {
+  if (!headers || typeof headers.get !== "function") {
+    return void 0;
+  }
+  const cachedHeader = headers.get(X_CACHED_HEADER);
+  if (cachedHeader) {
+    return parseCachedHeader(cachedHeader);
+  }
+  return parseCachedHeader(headers.get(LEGACY_CACHED_HEADER));
 }
 
 // src/instrumentation/plugins/openai-plugin.ts
@@ -13050,13 +13817,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),
@@ -13066,208 +13831,248 @@ 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: ([params]) => {
+          const { messages, ...metadata } = params;
+          return {
+            input: processInputAttachments(messages),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          return result?.choices;
+        },
+        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.unsubscribers.push(
+      traceSyncStreamChannel(openAIChannels.betaChatCompletionsStream, {
         name: "Chat Completion",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
-          const { messages, ...metadata } = params;
+        extractInput: ([params]) => {
+          const { messages, ...metadata } = params;
+          return {
+            input: processInputAttachments(messages),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(openAIChannels.moderationsCreate, {
+        name: "Moderation",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
+          return {
+            input,
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          return result?.results;
+        },
+        extractMetrics: (result, _startTime, endEvent) => {
+          return withCachedMetric(
+            parseMetricsFromUsage(result?.usage),
+            result,
+            endEvent
+          );
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openAIChannels.responsesCreate, {
+        name: "openai.responses.create",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
           return {
-            input: processInputAttachments(messages),
+            input: processInputAttachments(input),
             metadata: { ...metadata, provider: "openai" }
           };
         },
         extractOutput: (result) => {
-          return result?.choices;
+          return processImagesInOutput(result?.output);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = parseMetricsFromUsage(result?.usage);
+        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: aggregateChatCompletionChunks
-      }
+        aggregateChunks: aggregateResponseStreamEvents
+      })
     );
-    this.subscribeToSyncStreamChannel(
-      "orchestrion:openai:beta.chat.completions.stream",
-      {
-        name: "Chat Completion",
+    this.unsubscribers.push(
+      traceSyncStreamChannel(openAIChannels.responsesStream, {
+        name: "openai.responses.create",
         type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
-          const { messages, ...metadata } = params;
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
           return {
-            input: processInputAttachments(messages),
+            input: processInputAttachments(input),
             metadata: { ...metadata, provider: "openai" }
           };
-        }
-      }
-    );
-    this.subscribeToChannel("orchestrion:openai:moderations.create", {
-      name: "Moderation",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        const { input, ...metadata } = params;
-        return {
-          input,
-          metadata: { ...metadata, provider: "openai" }
-        };
-      },
-      extractOutput: (result) => {
-        return 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 {};
-        }
-        const response = event.response;
-        if (event.type === "response.completed") {
+        },
+        extractFromEvent: (event) => {
+          if (event.type !== "response.completed" || !event.response) {
+            return {};
+          }
+          const response = event.response;
           const data = {};
-          if (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)) {
@@ -13298,7 +14103,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;
@@ -13340,6 +14145,7 @@ function aggregateChatCompletionChunks(chunks) {
       }
     }
   }
+  metrics = withCachedMetric(metrics, streamResult, endEvent);
   return {
     metrics,
     output: [
@@ -13356,9 +14162,33 @@ function aggregateChatCompletionChunks(chunks) {
     ]
   };
 }
-
-// src/instrumentation/plugins/anthropic-plugin.ts
-var import_dc_browser2 = require("dc-browser");
+function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
+  let output = void 0;
+  let metrics = {};
+  let metadata = void 0;
+  for (const chunk of chunks) {
+    if (!chunk || !chunk.type || !chunk.response) {
+      continue;
+    }
+    if (chunk.type !== "response.completed") {
+      continue;
+    }
+    const response = chunk.response;
+    if (response?.output !== void 0) {
+      output = processImagesInOutput(response.output);
+    }
+    const { usage: _usage, output: _output, ...rest } = response || {};
+    if (Object.keys(rest).length > 0) {
+      metadata = rest;
+    }
+    metrics = parseMetricsFromUsage(response?.usage);
+  }
+  return {
+    output,
+    metrics: withCachedMetric(metrics, void 0, endEvent),
+    ...metadata !== void 0 ? { metadata } : {}
+  };
+}
 
 // src/wrappers/anthropic-tokens-util.ts
 function finalizeAnthropicTokens(metrics) {
@@ -13380,20 +14210,28 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
   return cacheTokens;
 }
 
+// src/instrumentation/plugins/anthropic-channels.ts
+var anthropicChannels = defineChannels("@anthropic-ai/sdk", {
+  messagesCreate: channel({
+    channelName: "messages.create",
+    kind: "async"
+  }),
+  betaMessagesCreate: channel({
+    channelName: "beta.messages.create",
+    kind: "async"
+  })
+});
+
 // src/instrumentation/plugins/anthropic-plugin.ts
 var AnthropicPlugin = class extends BasePlugin {
-  unsubscribers = [];
   onEnable() {
     this.subscribeToAnthropicChannels();
   }
   onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
   subscribeToAnthropicChannels() {
-    this.subscribeToStreamingChannel("orchestrion:anthropic:messages.create", {
+    const anthropicConfig = {
       name: "anthropic.messages.create",
       type: "llm" /* LLM */,
       extractInput: (args) => {
@@ -13405,190 +14243,42 @@ var AnthropicPlugin = class extends BasePlugin {
           metadata: { ...metadata, provider: "anthropic" }
         };
       },
-      extractOutput: (result) => {
-        return result ? { role: result.role, content: result.content } : null;
+      extractOutput: (message) => {
+        return message ? { role: message.role, content: message.content } : null;
       },
-      extractMetrics: (result, startTime) => {
-        const metrics = parseMetricsFromUsage2(result?.usage);
+      extractMetrics: (message, startTime) => {
+        const metrics = parseMetricsFromUsage2(message?.usage);
         if (startTime) {
           metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
         }
         const finalized = finalizeAnthropicTokens(metrics);
         return Object.fromEntries(
-          Object.entries(finalized).filter(([, v]) => v !== void 0)
+          Object.entries(finalized).filter(
+            (entry) => entry[1] !== void 0
+          )
         );
       },
-      extractMetadata: (result) => {
-        const metadata = {};
-        const metas = ["stop_reason", "stop_sequence"];
-        for (const m of metas) {
-          if (result?.[m] !== void 0) {
-            metadata[m] = result[m];
-          }
-        }
-        return metadata;
-      },
-      aggregateChunks: aggregateAnthropicStreamChunks,
-      isStreaming: (args) => {
-        return args[0]?.stream === true;
-      }
-    });
-    this.subscribeToStreamingChannel(
-      "orchestrion:anthropic:beta.messages.create",
-      {
-        name: "anthropic.beta.messages.create",
-        type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
-          const input = coalesceInput(params.messages || [], params.system);
-          const metadata = filterFrom(params, ["messages", "system"]);
-          return {
-            input: processAttachmentsInInput(input),
-            metadata: { ...metadata, provider: "anthropic" }
-          };
-        },
-        extractOutput: (result) => {
-          return result ? { role: result.role, content: result.content } : null;
-        },
-        extractMetrics: (result, startTime) => {
-          const metrics = parseMetricsFromUsage2(result?.usage);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          const finalized = finalizeAnthropicTokens(metrics);
-          return Object.fromEntries(
-            Object.entries(finalized).filter(([, v]) => v !== void 0)
-          );
-        },
-        extractMetadata: (result) => {
-          const metadata = {};
-          const metas = ["stop_reason", "stop_sequence"];
-          for (const m of metas) {
-            if (result?.[m] !== void 0) {
-              metadata[m] = result[m];
-            }
-          }
-          return metadata;
-        },
-        aggregateChunks: aggregateAnthropicStreamChunks,
-        isStreaming: (args) => {
-          return args[0]?.stream === true;
-        }
-      }
-    );
-  }
-  /**
-   * Subscribe to a channel for async methods that may return streams.
-   * Handles both streaming and non-streaming responses based on the stream parameter.
-   */
-  subscribeToStreamingChannel(channelName, config3) {
-    const channel = (0, import_dc_browser2.tracingChannel)(channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config3.name,
-          spanAttributes: {
-            type: config3.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config3.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error2) {
-          console.error(`Error extracting input for ${channelName}:`, error2);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        const isStreaming = config3.isStreaming ? config3.isStreaming(event.arguments) : isAsyncIterable3(event.result);
-        if (isStreaming && isAsyncIterable3(event.result)) {
-          patchStreamIfNeeded(event.result, {
-            onComplete: (chunks) => {
-              try {
-                let output;
-                let metrics;
-                let metadata = {};
-                if (config3.aggregateChunks) {
-                  const aggregated = config3.aggregateChunks(chunks);
-                  output = aggregated.output;
-                  metrics = aggregated.metrics;
-                  metadata = aggregated.metadata || {};
-                } else {
-                  output = config3.extractOutput(chunks);
-                  metrics = config3.extractMetrics(chunks, startTime);
-                  if (config3.extractMetadata) {
-                    metadata = config3.extractMetadata(chunks);
-                  }
-                }
-                if (!metrics.time_to_first_token && chunks.length > 0) {
-                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-                }
-                span.log({
-                  output,
-                  metrics,
-                  metadata
-                });
-              } catch (error2) {
-                console.error(
-                  `Error extracting output for ${channelName}:`,
-                  error2
-                );
-              } finally {
-                span.end();
-              }
-            },
-            onError: (error2) => {
-              span.log({
-                error: error2.message
-              });
-              span.end();
-            }
-          });
-        } else {
-          try {
-            const output = config3.extractOutput(event.result);
-            const metrics = config3.extractMetrics(event.result, startTime);
-            const metadata = config3.extractMetadata ? config3.extractMetadata(event.result) : {};
-            span.log({
-              output,
-              metrics,
-              metadata
-            });
-          } catch (error2) {
-            console.error(`Error extracting output for ${channelName}:`, error2);
-          } finally {
-            span.end();
-            spans.delete(event);
+      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) {
@@ -13612,29 +14302,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;
     }
@@ -13642,7 +14332,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,
@@ -13650,6 +14342,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;
@@ -13673,14 +14368,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)
@@ -13711,8 +14406,35 @@ function filterFrom(obj, fieldsToRemove) {
   return result;
 }
 
+// src/instrumentation/plugins/ai-sdk-channels.ts
+var aiSDKChannels = defineChannels("ai", {
+  generateText: channel({
+    channelName: "generateText",
+    kind: "async"
+  }),
+  streamText: channel({
+    channelName: "streamText",
+    kind: "async"
+  }),
+  generateObject: channel({
+    channelName: "generateObject",
+    kind: "async"
+  }),
+  streamObject: channel({
+    channelName: "streamObject",
+    kind: "async"
+  }),
+  agentGenerate: channel({
+    channelName: "Agent.generate",
+    kind: "async"
+  }),
+  agentStream: channel({
+    channelName: "Agent.stream",
+    kind: "async"
+  })
+});
+
 // src/instrumentation/plugins/ai-sdk-plugin.ts
-var import_dc_browser3 = require("dc-browser");
 var DEFAULT_DENY_OUTPUT_PATHS = [
   // v3
   "roundtrips[].request.body",
@@ -13728,7 +14450,6 @@ var DEFAULT_DENY_OUTPUT_PATHS = [
   "steps[].response.headers"
 ];
 var AISDKPlugin = class extends BasePlugin {
-  unsubscribers = [];
   config;
   constructor(config3 = {}) {
     super();
@@ -13738,249 +14459,148 @@ var AISDKPlugin = class extends BasePlugin {
     this.subscribeToAISDK();
   }
   onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
   subscribeToAISDK() {
     const denyOutputPaths = this.config.denyOutputPaths || DEFAULT_DENY_OUTPUT_PATHS;
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:generateText", {
-      name: "generateText",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:streamText", {
-      name: "streamText",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:generateObject", {
-      name: "generateObject",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:streamObject", {
-      name: "streamObject",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:Agent.generate", {
-      name: "Agent.generate",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-    this.subscribeToStreamingChannel("orchestrion:ai-sdk:Agent.stream", {
-      name: "Agent.stream",
-      type: "llm" /* LLM */,
-      extractInput: (args) => {
-        const params = args[0] || {};
-        return {
-          input: processAISDKInput(params),
-          metadata: extractMetadataFromParams(params)
-        };
-      },
-      extractOutput: (result) => {
-        return processAISDKOutput(result, denyOutputPaths);
-      },
-      extractMetrics: (result, startTime) => {
-        const metrics = extractTokenMetrics(result);
-        if (startTime) {
-          metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-        }
-        return metrics;
-      },
-      aggregateChunks: aggregateAISDKChunks
-    });
-  }
-  /**
-   * Subscribe to a channel for async methods that may return streams.
-   * Handles both streaming and non-streaming responses.
-   */
-  subscribeToStreamingChannel(channelName, config3) {
-    const channel = (0, import_dc_browser3.tracingChannel)(channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config3.name,
-          spanAttributes: {
-            type: config3.type
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.generateText, {
+        name: "generateText",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config3.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error2) {
-          console.error(`Error extracting input for ${channelName}:`, error2);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        if (isAsyncIterable3(event.result)) {
-          patchStreamIfNeeded(event.result, {
-            onComplete: (chunks) => {
-              try {
-                let output;
-                let metrics;
-                if (config3.aggregateChunks) {
-                  const aggregated = config3.aggregateChunks(chunks);
-                  output = aggregated.output;
-                  metrics = aggregated.metrics;
-                } else {
-                  output = config3.extractOutput(chunks);
-                  metrics = config3.extractMetrics(chunks, startTime);
-                }
-                if (!metrics.time_to_first_token && chunks.length > 0) {
-                  metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-                }
-                span.log({
-                  output,
-                  metrics
-                });
-              } catch (error2) {
-                console.error(
-                  `Error extracting output for ${channelName}:`,
-                  error2
-                );
-              } finally {
-                span.end();
-              }
-            },
-            onError: (error2) => {
-              span.log({
-                error: error2.message
-              });
-              span.end();
-            }
-          });
-        } else {
-          try {
-            const output = config3.extractOutput(event.result);
-            const metrics = config3.extractMetrics(event.result, startTime);
-            span.log({
-              output,
-              metrics
-            });
-          } catch (error2) {
-            console.error(`Error extracting output for ${channelName}:`, error2);
-          } finally {
-            span.end();
-            spans.delete(event);
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.streamText, {
+        name: "streamText",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.generateObject, {
+        name: "generateObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.streamObject, {
+        name: "streamObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.agentGenerate, {
+        name: "Agent.generate",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.agentStream, {
+        name: "Agent.stream",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          return {
+            input: processAISDKInput(params),
+            metadata: extractMetadataFromParams(params)
+          };
+        },
+        extractOutput: (result) => {
+          return processAISDKOutput(result, denyOutputPaths);
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = extractTokenMetrics(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
+          return metrics;
+        },
+        aggregateChunks: aggregateAISDKChunks
+      })
+    );
   }
 };
 function processAISDKInput(params) {
@@ -14222,7 +14842,10 @@ function omitAtPath(obj, keys) {
     if (Array.isArray(obj)) {
       obj.forEach((item) => {
         if (remainingKeys.length > 0) {
-          omitAtPath(item, remainingKeys);
+          omitAtPath(
+            item,
+            remainingKeys
+          );
         }
       });
     }
@@ -14232,7 +14855,10 @@ function omitAtPath(obj, keys) {
     }
   } else {
     if (obj && typeof obj === "object" && firstKey in obj) {
-      omitAtPath(obj[firstKey], remainingKeys);
+      omitAtPath(
+        obj[firstKey],
+        remainingKeys
+      );
     }
   }
 }
@@ -14245,8 +14871,18 @@ function omit(obj, paths) {
   return result;
 }
 
+// src/instrumentation/plugins/claude-agent-sdk-channels.ts
+var claudeAgentSDKChannels = defineChannels(
+  "@anthropic-ai/claude-agent-sdk",
+  {
+    query: channel({
+      channelName: "query",
+      kind: "async"
+    })
+  }
+);
+
 // src/instrumentation/plugins/claude-agent-sdk-plugin.ts
-var import_dc_browser4 = require("dc-browser");
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -14330,7 +14966,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: {
@@ -14349,7 +14987,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();
   }
@@ -14365,12 +15002,13 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
    * and individual LLM calls.
    */
   subscribeToQuery() {
-    const channel = (0, import_dc_browser4.tracingChannel)("orchestrion:claude-agent-sdk:query");
+    const channel2 = claudeAgentSDKChannels.query.tracingChannel();
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
-        const params = event.arguments[0] ?? {};
-        const { prompt, options = {} } = params;
+        const params = event.arguments[0];
+        const prompt = params?.prompt;
+        const options = params?.options ?? {};
         const span = startSpan({
           name: "Claude Agent",
           spanAttributes: {
@@ -14382,7 +15020,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           span.log({
             input: typeof prompt === "string" ? prompt : {
               type: "streaming",
-              description: "AsyncIterable<SDKMessage>"
+              description: "AsyncIterable<ClaudeAgentSDKMessage>"
             },
             metadata: filterSerializableOptions(options)
           });
@@ -14404,12 +15042,19 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         if (!spanData) {
           return;
         }
-        if (isAsyncIterable3(event.result)) {
-          patchStreamIfNeeded(event.result, {
+        const eventResult = event.result;
+        if (eventResult === void 0) {
+          spanData.span.end();
+          spans.delete(event);
+          return;
+        }
+        if (isAsyncIterable3(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) {
@@ -14433,289 +15078,96 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
                     spanData.accumulatedOutputTokens += outputTokens;
                   }
                   spanData.currentMessages = [];
-                }
-                spanData.currentMessageId = messageId;
-                spanData.currentMessageStartTime = currentTime;
-              }
-              if (message.type === "assistant" && message.message?.usage) {
-                spanData.currentMessages.push(message);
-              }
-              if (message.type === "result" && message.usage) {
-                const finalUsageMetrics = extractUsageFromMessage(message);
-                if (spanData.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
-                  const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (lastMessage?.message?.usage) {
-                    const adjustedTokens = finalUsageMetrics.completion_tokens - spanData.accumulatedOutputTokens;
-                    if (adjustedTokens >= 0) {
-                      lastMessage.message.usage.output_tokens = adjustedTokens;
-                    }
-                  }
-                }
-                const result_metadata = {};
-                if (message.num_turns !== void 0) {
-                  result_metadata.num_turns = message.num_turns;
-                }
-                if (message.session_id !== void 0) {
-                  result_metadata.session_id = message.session_id;
-                }
-                if (Object.keys(result_metadata).length > 0) {
-                  spanData.span.log({
-                    metadata: result_metadata
-                  });
-                }
-              }
-            },
-            onComplete: async () => {
-              try {
-                const params = event.arguments[0];
-                const { prompt, options = {} } = params;
-                if (spanData.currentMessages.length > 0) {
-                  const finalMessage = await createLLMSpanForMessages(
-                    spanData.currentMessages,
-                    prompt,
-                    spanData.conversationHistory,
-                    options,
-                    spanData.currentMessageStartTime,
-                    await spanData.span.export()
-                  );
-                  if (finalMessage) {
-                    spanData.conversationHistory.push(finalMessage);
-                  }
-                }
-                spanData.span.log({
-                  output: spanData.conversationHistory.length > 0 ? spanData.conversationHistory[spanData.conversationHistory.length - 1] : void 0
-                });
-              } catch (error2) {
-                console.error(
-                  "Error extracting output for Claude Agent SDK:",
-                  error2
-                );
-              } finally {
-                spanData.span.end();
-                spans.delete(event);
-              }
-            },
-            onError: (error2) => {
-              spanData.span.log({
-                error: error2.message
-              });
-              spanData.span.end();
-              spans.delete(event);
-            }
-          });
-        } else {
-          try {
-            spanData.span.log({
-              output: event.result
-            });
-          } catch (error2) {
-            console.error(
-              "Error extracting output for Claude Agent SDK:",
-              error2
-            );
-          } finally {
-            spanData.span.end();
-            spans.delete(event);
-          }
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
-  }
-};
-
-// src/instrumentation/plugins/google-genai-plugin.ts
-var import_dc_browser5 = require("dc-browser");
-var GoogleGenAIPlugin = class extends BasePlugin {
-  unsubscribers = [];
-  onEnable() {
-    this.subscribeToGoogleGenAIChannels();
-  }
-  onDisable() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
-    }
-    this.unsubscribers = [];
-  }
-  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",
-        type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const params = args[0] || {};
-          const input = serializeInput(params);
-          const metadata = extractMetadata(params);
-          return {
-            input,
-            metadata: { ...metadata, provider: "google-genai" }
-          };
-        },
-        aggregateChunks: aggregateGenerateContentChunks
-      }
-    );
-  }
-  subscribeToChannel(channelName, config3) {
-    const channel = (0, import_dc_browser5.tracingChannel)(channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config3.name,
-          spanAttributes: {
-            type: config3.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config3.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error2) {
-          console.error(`Error extracting input for ${channelName}:`, error2);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        try {
-          const output = config3.extractOutput(event.result);
-          const metrics = config3.extractMetrics(event.result, startTime);
-          span.log({
-            output,
-            metrics
-          });
-        } catch (error2) {
-          console.error(`Error extracting output for ${channelName}:`, error2);
-        } finally {
-          span.end();
-          spans.delete(event);
-        }
-      },
-      error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span } = spanData;
-        span.log({
-          error: event.error.message
-        });
-        span.end();
-        spans.delete(event);
-      }
-    };
-    channel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
-    });
-  }
-  subscribeToGoogleStreamingChannel(channelName, config3) {
-    const channel = (0, import_dc_browser5.tracingChannel)(channelName);
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const span = startSpan({
-          name: config3.name,
-          spanAttributes: {
-            type: config3.type
-          }
-        });
-        const startTime = getCurrentUnixTimestamp();
-        spans.set(event, { span, startTime });
-        try {
-          const { input, metadata } = config3.extractInput(event.arguments);
-          span.log({
-            input,
-            metadata
-          });
-        } catch (error2) {
-          console.error(`Error extracting input for ${channelName}:`, error2);
-        }
-      },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
-          return;
-        }
-        const { span, startTime } = spanData;
-        if (isAsyncIterable3(event.result)) {
-          patchStreamIfNeeded(event.result, {
-            onComplete: (chunks) => {
+                }
+                spanData.currentMessageId = messageId;
+                spanData.currentMessageStartTime = currentTime;
+              }
+              if (message.type === "assistant" && message.message?.usage) {
+                spanData.currentMessages.push(message);
+              }
+              if (message.type === "result" && message.usage) {
+                const finalUsageMetrics = extractUsageFromMessage(message);
+                if (spanData.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
+                  const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
+                  if (lastMessage?.message?.usage) {
+                    const adjustedTokens = finalUsageMetrics.completion_tokens - spanData.accumulatedOutputTokens;
+                    if (adjustedTokens >= 0) {
+                      lastMessage.message.usage.output_tokens = adjustedTokens;
+                    }
+                  }
+                }
+                const result_metadata = {};
+                if (message.num_turns !== void 0) {
+                  result_metadata.num_turns = message.num_turns;
+                }
+                if (message.session_id !== void 0) {
+                  result_metadata.session_id = message.session_id;
+                }
+                if (Object.keys(result_metadata).length > 0) {
+                  spanData.span.log({
+                    metadata: result_metadata
+                  });
+                }
+              }
+            },
+            onComplete: async () => {
               try {
-                const { output, metrics } = config3.aggregateChunks(
-                  chunks,
-                  startTime
-                );
-                span.log({
-                  output,
-                  metrics
+                const params = event.arguments[0];
+                const prompt = params?.prompt;
+                const options = params?.options ?? {};
+                if (spanData.currentMessages.length > 0) {
+                  const finalMessage = await createLLMSpanForMessages(
+                    spanData.currentMessages,
+                    prompt,
+                    spanData.conversationHistory,
+                    options,
+                    spanData.currentMessageStartTime,
+                    await spanData.span.export()
+                  );
+                  if (finalMessage) {
+                    spanData.conversationHistory.push(finalMessage);
+                  }
+                }
+                spanData.span.log({
+                  output: spanData.conversationHistory.length > 0 ? spanData.conversationHistory[spanData.conversationHistory.length - 1] : void 0
                 });
               } catch (error2) {
                 console.error(
-                  `Error extracting output for ${channelName}:`,
+                  "Error extracting output for Claude Agent SDK:",
                   error2
                 );
               } finally {
-                span.end();
+                spanData.span.end();
+                spans.delete(event);
               }
             },
             onError: (error2) => {
-              span.log({
+              spanData.span.log({
                 error: error2.message
               });
-              span.end();
+              spanData.span.end();
+              spans.delete(event);
             }
           });
         } else {
-          span.end();
-          spans.delete(event);
+          try {
+            spanData.span.log({
+              output: eventResult
+            });
+          } catch (error2) {
+            console.error(
+              "Error extracting output for Claude Agent SDK:",
+              error2
+            );
+          } finally {
+            spanData.span.end();
+            spans.delete(event);
+          }
         }
       },
       error: (event) => {
         const spanData = spans.get(event);
-        if (!spanData) {
+        if (!spanData || !event.error) {
           return;
         }
         const { span } = spanData;
@@ -14726,12 +15178,79 @@ var GoogleGenAIPlugin = class extends BasePlugin {
         spans.delete(event);
       }
     };
-    channel.subscribe(handlers);
+    channel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel.unsubscribe(handlers);
+      channel2.unsubscribe(handlers);
     });
   }
 };
+
+// src/instrumentation/plugins/google-genai-channels.ts
+var googleGenAIChannels = defineChannels("@google/genai", {
+  generateContent: channel({
+    channelName: "models.generateContent",
+    kind: "async"
+  }),
+  generateContentStream: channel({
+    channelName: "models.generateContentStream",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/google-genai-plugin.ts
+var GoogleGenAIPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToGoogleGenAIChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToGoogleGenAIChannels() {
+    this.unsubscribers.push(
+      traceAsyncChannel(googleGenAIChannels.generateContent, {
+        name: "google-genai.generateContent",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          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.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: { ...metadata, provider: "google-genai" }
+          };
+        },
+        extractOutput: (result) => {
+          return result;
+        },
+        extractMetrics: () => {
+          return {};
+        },
+        aggregateChunks: (chunks, _result, _endEvent, startTime) => {
+          return aggregateGenerateContentChunks(chunks, startTime);
+        }
+      })
+    );
+  }
+};
 function serializeInput(params) {
   const input = {
     model: params.model,
@@ -14785,8 +15304,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"
       });
@@ -14835,33 +15358,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;
   }
@@ -14932,21 +15458,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;
@@ -14958,7 +15470,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;
@@ -15122,6 +15635,7 @@ function configureNode() {
   isomorph_default.getEnv = (name) => process.env[name];
   isomorph_default.getCallerLocation = getCallerLocation;
   isomorph_default.newAsyncLocalStorage = () => new import_node_async_hooks.AsyncLocalStorage();
+  isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
   isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };
@@ -15219,17 +15733,6 @@ function nodeModulesPaths(basedir, options) {
   }
   return dirs;
 }
-function findGlobalPaths() {
-  const { root } = path2.parse(process.cwd());
-  const globalPath = path2.join(root, "node_modules");
-  const resolvePaths = require.resolve.paths("/");
-  if (resolvePaths) {
-    const rootIndex = resolvePaths.indexOf(globalPath);
-    return rootIndex > -1 ? resolvePaths.slice(rootIndex + 1) : [];
-  }
-  return [];
-}
-var GlobalPaths = findGlobalPaths();
 
 // src/cli/functions/load-module.ts
 var import_node_path = __toESM(require("node:path"));
@@ -15613,6 +16116,7 @@ var CodeFunction = class {
     this.description = opts.description;
     this.type = opts.type;
     this.ifExists = opts.ifExists;
+    this.tags = opts.tags;
     this.metadata = opts.metadata;
     this.parameters = opts.parameters;
     this.returns = opts.returns;
@@ -15628,6 +16132,7 @@ var CodeFunction = class {
   parameters;
   returns;
   ifExists;
+  tags;
   metadata;
   key() {
     return JSON.stringify([
@@ -15647,6 +16152,7 @@ var CodePrompt = class {
   id;
   functionType;
   toolFunctions;
+  tags;
   metadata;
   constructor(project, prompt, toolFunctions, opts, functionType) {
     this.project = project;
@@ -15658,6 +16164,7 @@ var CodePrompt = class {
     this.description = opts.description;
     this.id = opts.id;
     this.functionType = functionType;
+    this.tags = opts.tags;
     this.metadata = opts.metadata;
   }
   async toFunctionDefinition(projectNameToId) {
@@ -15692,6 +16199,7 @@ var CodePrompt = class {
       function_type: this.functionType,
       prompt_data,
       if_exists: this.ifExists,
+      tags: this.tags,
       metadata: this.metadata
     };
   }
@@ -15720,6 +16228,7 @@ var PromptBuilder = class {
       name: opts.name,
       slug,
       prompt_data: promptData,
+      tags: opts.tags,
       ...this.project.id !== void 0 ? { project_id: this.project.id } : {}
     };
     const prompt = new Prompt2(
@@ -15801,6 +16310,15 @@ function serializeEvalParametersToStaticParametersSchema(parameters) {
             description: value.description
           }
         ];
+      } else if ("type" in value && value.type === "model") {
+        return [
+          name,
+          {
+            type: "model",
+            default: value.default,
+            description: value.description
+          }
+        ];
       } else {
         const schemaObj = zodToJsonSchema(value);
         return [
@@ -15831,6 +16349,16 @@ function serializeEvalParameterstoParametersSchema(parameters) {
       if (!defaultPromptData) {
         required.push(name);
       }
+    } else if ("type" in value && value.type === "model") {
+      properties[name] = {
+        type: "string",
+        "x-bt-type": "model",
+        ...value.description ? { description: value.description } : {},
+        ..."default" in value ? { default: value.default } : {}
+      };
+      if (!("default" in value)) {
+        required.push(name);
+      }
     } else {
       const schemaObj = zodToJsonSchema(value);
       properties[name] = schemaObj;
@@ -15926,7 +16454,7 @@ async function uploadHandleBundles({
   bundlePromises,
   handles,
   setCurrent,
-  verbose,
+  showDetailedErrors,
   defaultIfExists
 }) {
   console.error(
@@ -15959,6 +16487,7 @@ async function uploadHandleBundles({
             returns: fn.returns ? zodToJsonSchema(fn.returns) : void 0
           } : void 0,
           if_exists: fn.ifExists,
+          tags: fn.tags,
           metadata: fn.metadata
         });
       }
@@ -15983,41 +16512,6 @@ async function uploadHandleBundles({
         object_id: experimentId,
         internal: !setCurrent
       } : void 0;
-      if (setCurrent) {
-        const sourceStem = import_node_path3.default.basename(sourceFile, import_node_path3.default.extname(sourceFile)).replace(/\.eval$/, "");
-        const evalName = evaluator.evaluator.evalName;
-        const sandboxGroupName = sourceStem;
-        const resolvedParameters = evaluator.evaluator.parameters ? await Promise.resolve(evaluator.evaluator.parameters) : void 0;
-        const evaluatorDefinition = {
-          ...resolvedParameters ? {
-            parameters: serializeRemoteEvalParametersContainer(resolvedParameters)
-          } : {},
-          scores: evaluator.evaluator.scores.map((score, i) => ({
-            name: scorerName(score, i)
-          }))
-        };
-        bundleSpecs.push({
-          ...baseInfo,
-          name: `Eval ${evalName} sandbox`,
-          slug: slugify(`${sourceStem}-${evalName}-sandbox`),
-          description: `Sandbox eval ${evalName}`,
-          location: {
-            type: "sandbox",
-            sandbox_spec: {
-              provider: "lambda"
-            },
-            entrypoints: [sourceFile],
-            eval_name: evalName,
-            evaluator_definition: evaluatorDefinition
-          },
-          function_type: "sandbox",
-          metadata: {
-            [SANDBOX_GROUP_NAME_METADATA_KEY]: sandboxGroupName
-          },
-          origin
-        });
-        continue;
-      }
       const fileSpecs = [
         {
           ...baseInfo,
@@ -16052,6 +16546,40 @@ async function uploadHandleBundles({
         })
       ];
       bundleSpecs.push(...fileSpecs);
+      if (setCurrent) {
+        const sourceStem = import_node_path3.default.basename(sourceFile, import_node_path3.default.extname(sourceFile)).replace(/\.eval$/, "");
+        const evalName = evaluator.evaluator.evalName;
+        const sandboxGroupName = sourceStem;
+        const resolvedParameters = evaluator.evaluator.parameters ? await Promise.resolve(evaluator.evaluator.parameters) : void 0;
+        const evaluatorDefinition = {
+          ...resolvedParameters ? {
+            parameters: serializeRemoteEvalParametersContainer(resolvedParameters)
+          } : {},
+          scores: evaluator.evaluator.scores.map((score, i) => ({
+            name: scorerName(score, i)
+          }))
+        };
+        bundleSpecs.push({
+          ...baseInfo,
+          name: `Eval ${evalName} sandbox`,
+          slug: slugify(`${sourceStem}-${evalName}-sandbox`),
+          description: `Sandbox eval ${evalName}`,
+          location: {
+            type: "sandbox",
+            sandbox_spec: {
+              provider: "lambda"
+            },
+            entrypoints: [sourceFile],
+            eval_name: evalName,
+            evaluator_definition: evaluatorDefinition
+          },
+          function_type: "sandbox",
+          metadata: {
+            [SANDBOX_GROUP_NAME_METADATA_KEY]: sandboxGroupName
+          },
+          origin
+        });
+      }
     }
     const slugs = /* @__PURE__ */ new Set();
     for (const spec of bundleSpecs) {
@@ -16073,7 +16601,7 @@ async function uploadHandleBundles({
       bundlePromises,
       handles,
       defaultIfExists,
-      verbose
+      showDetailedErrors
     });
   });
   const uploadResults = await Promise.all(uploadPromises);
@@ -16095,7 +16623,7 @@ async function uploadBundles({
   bundlePromises,
   handles,
   defaultIfExists,
-  verbose
+  showDetailedErrors
 }) {
   const orgId = _internalGetGlobalState().orgId;
   if (!orgId) {
@@ -16126,7 +16654,7 @@ async function uploadBundles({
         })
       );
     } catch (e) {
-      if (verbose) {
+      if (showDetailedErrors) {
         console.error(e);
       }
       const msg = e instanceof FailedHTTPResponse ? `Unable to upload your code. ${e.status} (${e.text}): ${e.data}` : `Unable to upload your code. You most likely need to update the API: ${e}`;
@@ -16174,30 +16702,14 @@ async function uploadBundles({
     ...prompts,
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     ...await Promise.all(
-      bundleSpecs.map(async (spec) => ({
-        project_id: spec.project_id,
-        name: spec.name,
-        slug: spec.slug,
-        description: spec.description,
-        function_data: {
-          type: "code",
-          data: {
-            type: "bundle",
-            runtime_context,
-            location: spec.location,
-            bundle_id: pathInfo.bundleId,
-            preview: sourceMapContext ? await findCodeDefinition({
-              location: spec.location,
-              ctx: sourceMapContext
-            }) : void 0
-          }
-        },
-        origin: spec.origin,
-        function_type: spec.function_type,
-        function_schema: spec.function_schema,
-        if_exists: spec.if_exists,
-        metadata: spec.metadata
-      }))
+      bundleSpecs.map(
+        (spec) => buildBundledFunctionEntry({
+          spec,
+          runtime_context,
+          bundleId: pathInfo.bundleId,
+          sourceMapContext
+        })
+      )
     )
   ].map((fn) => ({
     ...fn,
@@ -16209,7 +16721,7 @@ async function uploadBundles({
         functions: functionEntries
       });
     } catch (e) {
-      if (verbose) {
+      if (showDetailedErrors) {
         console.error(e);
       }
       const msg = e instanceof FailedHTTPResponse ? `Failed to save function definitions for '${sourceFile}'. ${e.status} (${e.text}): ${e.data}` : `Failed to save function definitions for '${sourceFile}'. You most likely need to update the API: ${e}`;
@@ -16231,11 +16743,66 @@ function formatNameAndSlug(pieces) {
     slug: slugify(nonEmptyPieces.join("-"))
   };
 }
+async function buildBundledFunctionEntry({
+  spec,
+  runtime_context,
+  bundleId,
+  sourceMapContext
+}) {
+  return {
+    project_id: spec.project_id,
+    name: spec.name,
+    slug: spec.slug,
+    description: spec.description,
+    function_data: {
+      type: "code",
+      data: {
+        type: "bundle",
+        runtime_context,
+        location: spec.location,
+        bundle_id: bundleId,
+        preview: sourceMapContext ? await findCodeDefinition({
+          location: spec.location,
+          ctx: sourceMapContext
+        }) : void 0
+      }
+    },
+    origin: spec.origin,
+    function_type: spec.function_type ?? void 0,
+    function_schema: spec.function_schema,
+    if_exists: spec.if_exists,
+    tags: spec.tags,
+    metadata: spec.metadata
+  };
+}
 
 // src/cli/util/bundle.ts
 var import_env = require("@next/env");
 var dotenv = __toESM(require("dotenv"));
+
+// src/cli/util/debug-logging.ts
+var VERBOSE_DEPRECATION_MESSAGE = "--verbose is deprecated and will be removed in a future version of braintrust. Use --debug-logging debug to see full stack traces and troubleshooting details.";
+var hasWarnedAboutVerboseFlag = false;
+function shouldShowDetailedErrors(debugLogLevel) {
+  return debugLogLevel === "debug";
+}
+function normalizeDebugLoggingArgs(args) {
+  if (!args.verbose) {
+    return args;
+  }
+  if (!hasWarnedAboutVerboseFlag) {
+    hasWarnedAboutVerboseFlag = true;
+    console.warn(warning(VERBOSE_DEPRECATION_MESSAGE));
+  }
+  if (!args.debug_logging) {
+    args.debug_logging = "debug";
+  }
+  return args;
+}
+
+// src/cli/util/bundle.ts
 async function loadCLIEnv(args) {
+  normalizeDebugLoggingArgs(args);
   (0, import_env.loadEnvConfig)(process.cwd(), true);
   if (args.env_file) {
     const loaded = dotenv.config({ path: args.env_file });
@@ -16247,11 +16814,13 @@ async function loadCLIEnv(args) {
   await login({
     apiKey: args.api_key,
     orgName: args.org_name,
-    appUrl: args.app_url
+    appUrl: args.app_url,
+    debugLogLevel: args.debug_logging
   });
 }
 async function bundleCommand(args) {
   await loadCLIEnv(args);
+  const showDetailedErrors = shouldShowDetailedErrors(args.debug_logging);
   const handles = await initializeHandles({
     mode: "bundle",
     files: args.files,
@@ -16275,7 +16844,7 @@ async function bundleCommand(args) {
         handleBuildFailure({
           result: buildResult,
           terminateOnFailure: args.terminate_on_failure,
-          verbose: args.verbose
+          showDetailedErrors
         });
       } else {
         buildResults.push(buildResult);
@@ -16286,7 +16855,7 @@ async function bundleCommand(args) {
       bundlePromises,
       handles,
       setCurrent: true,
-      verbose: args.verbose,
+      showDetailedErrors,
       defaultIfExists: args.if_exists
     });
     if (numFailed > 0) {
@@ -16797,6 +17366,11 @@ var staticParametersSchema = import_v315.z.record(
       default: PromptData.optional(),
       description: import_v315.z.string().optional()
     }),
+    import_v315.z.object({
+      type: import_v315.z.literal("model"),
+      default: import_v315.z.string().optional(),
+      description: import_v315.z.string().optional()
+    }),
     import_v315.z.object({
       type: import_v315.z.literal("data"),
       schema: import_v315.z.record(import_v315.z.unknown()),
@@ -17243,7 +17817,7 @@ function buildWatchPluginForEvaluator(inFile, opts) {
       build2.onEnd(async (result) => {
         console.error(`Done building ${inFile}`);
         if (!result.outputFiles) {
-          if (opts.verbose) {
+          if (opts.showDetailedErrors) {
             console.warn(`Failed to compile ${inFile}`);
             console.warn(result.errors);
           } else {
@@ -17296,7 +17870,7 @@ function buildWatchPluginForEvaluator(inFile, opts) {
             evaluator,
             evaluatorResult,
             {
-              verbose: opts.verbose,
+              verbose: opts.showDetailedErrors,
               jsonl: opts.jsonl
             }
           );
@@ -17385,11 +17959,11 @@ async function initFile({
 function handleBuildFailure({
   result,
   terminateOnFailure,
-  verbose
+  showDetailedErrors
 }) {
   if (terminateOnFailure) {
     throw result.error;
-  } else if (verbose) {
+  } else if (showDetailedErrors) {
     console.warn(`Failed to compile ${result.sourceFile}`);
     console.warn(result.error);
   } else {
@@ -17404,7 +17978,7 @@ function updateEvaluators(evaluators, buildResults, opts) {
       handleBuildFailure({
         result,
         terminateOnFailure: opts.terminateOnFailure,
-        verbose: opts.verbose
+        showDetailedErrors: opts.showDetailedErrors
       });
       continue;
     }
@@ -17523,7 +18097,7 @@ async function runOnce(handles, opts) {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       allEvalsResults[idx],
       {
-        verbose: opts.verbose,
+        verbose: opts.showDetailedErrors,
         jsonl: opts.jsonl
       }
     );
@@ -17540,7 +18114,7 @@ async function runOnce(handles, opts) {
       handles,
       setCurrent: opts.setCurrent,
       defaultIfExists: "replace",
-      verbose: opts.verbose
+      showDetailedErrors: opts.showDetailedErrors
     });
   }
   let allSuccess = true;
@@ -17751,6 +18325,7 @@ async function initializeHandles({
   return handles;
 }
 async function run(args) {
+  normalizeDebugLoggingArgs(args);
   (0, import_env2.loadEnvConfig)(process.cwd(), true);
   if (args.env_file) {
     const loaded = dotenv2.config({ path: args.env_file });
@@ -17760,7 +18335,7 @@ async function run(args) {
     }
   }
   const evaluatorOpts = {
-    verbose: args.verbose,
+    showDetailedErrors: shouldShowDetailedErrors(args.debug_logging),
     apiKey: args.api_key,
     orgName: args.org_name,
     appUrl: args.app_url,
@@ -17806,7 +18381,8 @@ async function run(args) {
       await login({
         apiKey: args.api_key,
         orgName: args.org_name,
-        appUrl: args.app_url
+        appUrl: args.app_url,
+        debugLogLevel: args.debug_logging
       });
     }
     if (args.watch) {
@@ -17842,6 +18418,12 @@ function addAuthArgs(parser) {
     help: "A path to a .env file containing environment variables to load (via dotenv)."
   });
 }
+function addDebugLoggingArg(parser) {
+  parser.add_argument("--debug-logging", {
+    choices: ["error", "warn", "info", "debug"],
+    help: "Enable internal Braintrust SDK troubleshooting output. Use 'error', 'warn', 'info', or 'debug' to control the log level."
+  });
+}
 function addCompileArgs(parser) {
   parser.add_argument("--terminate-on-failure", {
     action: "store_true",
@@ -17863,7 +18445,7 @@ async function main() {
   const parentParser = new import_argparse.ArgumentParser({ add_help: false });
   parentParser.add_argument("--verbose", {
     action: "store_true",
-    help: "Include additional details, including full stack traces on errors."
+    help: "Deprecated alias for --debug-logging debug. Use --debug-logging debug to include full stack traces and detailed troubleshooting output."
   });
   const subparser = parser.add_subparsers({
     required: true
@@ -17873,6 +18455,7 @@ async function main() {
     parents: [parentParser]
   });
   addAuthArgs(parser_run);
+  addDebugLoggingArg(parser_run);
   parser_run.add_argument("--filter", {
     help: "Only run evaluators that match these filters. Each filter is a regular expression (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp). For example, --filter metadata.priority='^P0$' input.name='foo.*bar' will only run evaluators that have metadata.priority equal to 'P0' and input.name matching the regular expression 'foo.*bar'.",
     nargs: "*"
@@ -17933,6 +18516,7 @@ async function main() {
     help: "Bundle prompts, tools, scorers, and other resources into Braintrust"
   });
   addAuthArgs(parser_push);
+  addDebugLoggingArg(parser_push);
   addCompileArgs(parser_push);
   parser_push.add_argument("files", {
     nargs: "*",
@@ -17947,6 +18531,7 @@ async function main() {
   const parser_pull = subparser.add_parser("pull", {
     help: "Pull prompts, tools, scorers, and other resources from Braintrust to save in your codebase."
   });
+  addDebugLoggingArg(parser_pull);
   parser_pull.add_argument("--output-dir", {
     help: "The directory to output the pulled resources to. If not specified, the current directory is used."
   });
@@ -17970,11 +18555,11 @@ async function main() {
     help: "Overwrite local files if they have uncommitted changes."
   });
   parser_pull.set_defaults({ func: pullCommand });
-  const parsed = parser.parse_args();
+  const parsed = normalizeDebugLoggingArgs(parser.parse_args());
   try {
     await parsed.func(parsed);
   } catch (e) {
-    logError2(e, parsed.verbose);
+    logError2(e, shouldShowDetailedErrors(parsed.debug_logging));
     process.exit(1);
   }
 }