braintrust 3.25.0 → 3.27.0

package/dist/apply-auto-instrumentation.mjs

@@ -1,8 +1,15 @@
 import {
+  GLOBAL_INSTRUMENTATION_HOOKS_KEY,
+  GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+  GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND,
+  GLOBAL_INSTRUMENTATION_HOOK_BRAND,
   aiSDKChannels,
   anthropicChannels,
   classifyMastraTarget,
   claudeAgentSDKChannels,
+  cloudflareAIChatChannels,
+  cloudflareAgentsChannels,
+  cloudflareThinkChannels,
   cohereChannels,
   cursorSDKChannels,
   flueChannels,
@@ -14,26 +21,26 @@ import {
   groqChannels,
   harnessAgentChannels,
   huggingFaceChannels,
+  huggingFaceTransformersChannels,
   isInstrumentationIntegrationDisabled,
   langChainChannels,
   langSmithChannels,
   mistralChannels,
+  ollamaChannels,
   openAIAgentsCoreChannels,
   openAIChannels,
   openAICodexChannels,
   openRouterAgentChannels,
   openRouterChannels,
   patchMastraSource,
-  patchTracingChannel,
   piCodingAgentChannels,
   readDisabledInstrumentationEnvConfig,
   smithyClientChannels,
   smithyCoreChannels,
   strandsAgentSDKChannels
-} from "./chunk-ABR2QWDP.mjs";
+} from "./chunk-CZM5JIQL.mjs";
 
 // src/node/apply-auto-instrumentation-entry.ts
-import * as diagnostics_channel from "node:diagnostics_channel";
 import { register } from "node:module";
 import { pathToFileURL } from "node:url";
 
@@ -544,7 +551,40 @@ var anthropicConfigs = [
       methodName: "toolRunner",
       kind: "Sync"
     }
-  }
+  },
+  // Managed Agents Sessions event streams are discovered automatically, but
+  // remain passive until the user calls collectAnthropicSession() on the
+  // returned stream.
+  ...["mjs", "js"].map(
+    (extension) => ({
+      channelName: anthropicChannels.betaSessionsEventsStream.channelName,
+      module: {
+        name: "@anthropic-ai/sdk",
+        versionRange: ">=0.86.0",
+        filePath: `resources/beta/sessions/events.${extension}`
+      },
+      functionQuery: {
+        className: "Events",
+        methodName: "stream",
+        kind: "Async"
+      }
+    })
+  ),
+  ...["mjs", "js"].map(
+    (extension) => ({
+      channelName: anthropicChannels.betaSessionsThreadsEventsStream.channelName,
+      module: {
+        name: "@anthropic-ai/sdk",
+        versionRange: ">=0.86.0",
+        filePath: `resources/beta/sessions/threads/events.${extension}`
+      },
+      functionQuery: {
+        className: "Events",
+        methodName: "stream",
+        kind: "Async"
+      }
+    })
+  )
 ];
 
 // src/auto-instrumentations/configs/bedrock-runtime.ts
@@ -634,6 +674,64 @@ var claudeAgentSDKConfigs = [
   }
 ];
 
+// src/auto-instrumentations/configs/cloudflare-ai-chat.ts
+var cloudflareAIChatVersionRange = ">=0.9.0 <0.10.0";
+var cloudflareAIChatConfigs = [
+  {
+    // AIChatAgent subclasses replace onChatMessage, so there is no stable
+    // public implementation for the transformer to target. This runner is
+    // the narrowest shared boundary around every chat turn; keep the version
+    // range tight because it is an internal method.
+    channelName: cloudflareAIChatChannels.runExclusiveChatTurn.channelName,
+    module: {
+      name: "@cloudflare/ai-chat",
+      versionRange: cloudflareAIChatVersionRange,
+      filePath: "dist/index.js"
+    },
+    functionQuery: {
+      className: "AIChatAgent",
+      methodName: "_runExclusiveChatTurn",
+      kind: "Async"
+    }
+  }
+];
+
+// src/auto-instrumentations/configs/cloudflare-agents.ts
+var cloudflareAgentsVersionRange = ">=0.17.0 <0.18.0";
+var cloudflareAgentsConfigs = [
+  {
+    channelName: cloudflareAgentsChannels.runAgentTool.channelName,
+    module: {
+      name: "agents",
+      versionRange: cloudflareAgentsVersionRange,
+      filePath: "dist/index.js"
+    },
+    functionQuery: {
+      className: "Agent",
+      methodName: "runAgentTool",
+      kind: "Async"
+    }
+  }
+];
+
+// src/auto-instrumentations/configs/cloudflare-think.ts
+var cloudflareThinkVersionRange = ">=0.13.0 <0.14.0";
+var cloudflareThinkConfigs = [
+  {
+    channelName: cloudflareThinkChannels.runInferenceLoop.channelName,
+    module: {
+      name: "@cloudflare/think",
+      versionRange: cloudflareThinkVersionRange,
+      filePath: "dist/think.js"
+    },
+    functionQuery: {
+      className: "Think",
+      methodName: "_runInferenceLoop",
+      kind: "Async"
+    }
+  }
+];
+
 // src/auto-instrumentations/configs/cohere.ts
 var cohereConfigs = [
   {
@@ -1786,6 +1884,67 @@ var huggingFaceConfigs = [
   }
 ];
 
+// src/auto-instrumentations/configs/huggingface-transformers.ts
+var moduleFiles = [
+  {
+    filePath: "dist/transformers.mjs",
+    versionRange: ">=3.0.0 <3.4.0"
+  },
+  {
+    filePath: "dist/transformers.cjs",
+    versionRange: ">=3.0.0 <3.4.0"
+  },
+  {
+    filePath: "dist/transformers.js",
+    versionRange: ">=3.0.0 <3.4.0"
+  },
+  {
+    filePath: "dist/transformers.node.mjs",
+    versionRange: ">=3.4.0 <5.0.0"
+  },
+  {
+    filePath: "dist/transformers.node.cjs",
+    versionRange: ">=3.4.0 <5.0.0"
+  },
+  {
+    filePath: "dist/transformers.web.js",
+    versionRange: ">=3.4.0 <5.0.0"
+  }
+];
+var pipelineClasses = [
+  "TextGenerationPipeline",
+  "Text2TextGenerationPipeline",
+  "FeatureExtractionPipeline",
+  "QuestionAnsweringPipeline"
+];
+var huggingFaceTransformersConfigs = moduleFiles.flatMap(({ filePath, versionRange: versionRange2 }) => [
+  {
+    channelName: huggingFaceTransformersChannels.pipeline.channelName,
+    module: {
+      name: "@huggingface/transformers",
+      versionRange: versionRange2,
+      filePath
+    },
+    functionQuery: {
+      functionName: "pipeline",
+      kind: "Async"
+    }
+  },
+  ...pipelineClasses.map((className) => ({
+    channelName: huggingFaceTransformersChannels.pipelineCall.channelName,
+    module: {
+      name: "@huggingface/transformers",
+      versionRange: versionRange2,
+      filePath
+    },
+    functionQuery: {
+      className,
+      methodName: "_call",
+      kind: "Async"
+    }
+  }))
+]);
+
 // src/auto-instrumentations/configs/langchain.ts
 var langChainCoreVersionRange = ">=0.3.42";
 var langChainCallbackManagerFilePath = "dist/callbacks/manager.js";
@@ -2142,6 +2301,31 @@ var mistralConfigs = [
   }
 ];
 
+// src/auto-instrumentations/configs/ollama.ts
+var methods = [
+  ["chat", ollamaChannels.chat.channelName],
+  ["generate", ollamaChannels.generate.channelName],
+  ["embed", ollamaChannels.embed.channelName]
+];
+var implementationFiles = ["dist/browser.mjs", "dist/browser.cjs"];
+var ollamaConfigs = [
+  ...implementationFiles.flatMap(
+    (filePath) => methods.map(([methodName, channelName]) => ({
+      channelName,
+      module: {
+        name: "ollama",
+        versionRange: ">=0.6.0 <0.7.0",
+        filePath
+      },
+      functionQuery: {
+        className: "Ollama",
+        methodName,
+        kind: "Async"
+      }
+    }))
+  )
+];
+
 // src/auto-instrumentations/configs/openai-agents.ts
 var lifecycleMethods = [
   ["onTraceStart", openAIAgentsCoreChannels.onTraceStart.channelName],
@@ -2431,6 +2615,19 @@ var openRouterConfigs = [
       kind: "Async"
     }
   },
+  {
+    channelName: openRouterChannels.betaResponsesSend.channelName,
+    module: {
+      name: "@openrouter/sdk",
+      versionRange: ">=1.1.2 <2.0.0",
+      filePath: "esm/sdk/betaresponses.js"
+    },
+    functionQuery: {
+      className: "BetaResponses",
+      methodName: "send",
+      kind: "Async"
+    }
+  },
   {
     channelName: openRouterChannels.callModel.channelName,
     module: {
@@ -2544,6 +2741,18 @@ var defaultInstrumentationConfigGroups = [
     integrations: ["claudeAgentSDK"],
     configs: claudeAgentSDKConfigs
   },
+  {
+    integrations: ["cloudflareAIChat"],
+    configs: cloudflareAIChatConfigs
+  },
+  {
+    integrations: ["cloudflareAgents"],
+    configs: cloudflareAgentsConfigs
+  },
+  {
+    integrations: ["cloudflareThink"],
+    configs: cloudflareThinkConfigs
+  },
   { integrations: ["cursor", "cursorSDK"], configs: cursorSDKConfigs },
   {
     integrations: ["openAIAgents"],
@@ -2553,7 +2762,10 @@ var defaultInstrumentationConfigGroups = [
     integrations: ["google", "googleGenAI"],
     configs: googleGenAIConfigs
   },
-  { integrations: ["huggingface"], configs: huggingFaceConfigs },
+  {
+    integrations: ["huggingface"],
+    configs: [...huggingFaceConfigs, ...huggingFaceTransformersConfigs]
+  },
   {
     integrations: ["langchain", "langgraph"],
     configs: langchainConfigs
@@ -2565,6 +2777,7 @@ var defaultInstrumentationConfigGroups = [
     configs: openRouterAgentConfigs
   },
   { integrations: ["mistral"], configs: mistralConfigs },
+  { integrations: ["ollama"], configs: ollamaConfigs },
   { integrations: ["googleADK"], configs: googleADKConfigs },
   { integrations: ["cohere"], configs: cohereConfigs },
   { integrations: ["groq"], configs: groqConfigs },
@@ -2631,52 +2844,76 @@ import { SourceMapGenerator } from "source-map";
 // src/auto-instrumentations/orchestrion-js/transforms.ts
 import esquery from "esquery";
 import { parse } from "meriyah";
-var tracingChannelPredicate = (node) => node.declarations?.[0]?.id?.properties?.[0]?.value?.name === "tr_ch_apm_tracingChannel";
 var CHANNEL_REGEX = /[^\w]/g;
+var SHARED_HOOK_LOOKUP = "tr_ch_bt$get_hook";
 function formatChannelVariable(channelName) {
-  return `tr_ch_apm$${channelName.replace(CHANNEL_REGEX, "_")}`;
+  return `tr_ch_bt$${channelName.replace(CHANNEL_REGEX, "_")}`;
+}
+function formatChannelGetter(channelName) {
+  return `tr_ch_bt$get_${channelName.replace(CHANNEL_REGEX, "_")}`;
 }
 var transforms = {
-  tracingChannelImport({ dcModule, moduleType }, node) {
-    if (node.body.some(tracingChannelPredicate)) {
-      return;
-    }
-    const options = { module: moduleType === "esm" };
-    const index = node.body.findIndex(
-      (child) => child.directive === "use strict"
-    );
-    const dc = moduleType === "esm" ? `import tr_ch_apm_dc from "${dcModule}"` : `const tr_ch_apm_dc = ${"require"}("${dcModule}")`;
-    const tracingChannel2 = "const { tracingChannel: tr_ch_apm_tracingChannel } = tr_ch_apm_dc";
-    const hasSubscribers = `const tr_ch_apm_hasSubscribers = ch => ch.start.hasSubscribers
-      || ch.end.hasSubscribers
-      || ch.asyncStart.hasSubscribers
-      || ch.asyncEnd.hasSubscribers
-      || ch.error.hasSubscribers`;
-    node.body.splice(
-      index + 1,
-      0,
-      parse(dc, options).body[0],
-      parse(tracingChannel2, options).body[0],
-      parse(hasSubscribers, options).body[0]
-    );
-  },
-  tracingChannelDeclaration(state2, node) {
+  tracingHookDeclaration(state2, node) {
     const {
       channelName,
       module: { name }
     } = state2;
     const channelVariable = formatChannelVariable(channelName);
+    const channelGetter = formatChannelGetter(channelName);
+    const hasSharedHookLookup = node.body.some(
+      (child) => child.declarations?.[0]?.id?.name === SHARED_HOOK_LOOKUP
+    );
     if (node.body.some(
-      (child) => child.declarations?.[0]?.id?.name === channelVariable
+      (child) => child.declarations?.[0]?.id?.name === channelGetter
     )) {
       return;
     }
-    transforms.tracingChannelImport(state2, node, null, []);
-    const index = node.body.findIndex(tracingChannelPredicate);
+    const sharedHookLookup = hasSharedHookLookup ? "" : `
+      const ${SHARED_HOOK_LOOKUP} = (__bt$hookName) => {
+        try {
+          const __bt$hooks = globalThis[${JSON.stringify(
+      GLOBAL_INSTRUMENTATION_HOOKS_KEY
+    )}];
+          if (
+            !(__bt$hooks instanceof Map) ||
+            __bt$hooks[Symbol.for(${JSON.stringify(
+      GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND
+    )})] !== ${GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION}
+          ) return undefined;
+          const __bt$hook = Map.prototype.get.call(
+            __bt$hooks,
+            __bt$hookName
+          );
+          if (
+            (__bt$hook === null ||
+              (typeof __bt$hook !== "object" &&
+                typeof __bt$hook !== "function")) ||
+            __bt$hook[Symbol.for(${JSON.stringify(
+      GLOBAL_INSTRUMENTATION_HOOK_BRAND
+    )})] !== ${GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION} ||
+            typeof __bt$hook.traceInvocation !== "function"
+          ) return undefined;
+          return __bt$hook;
+        } catch {
+          return undefined;
+        }
+      };
+    `;
     const code = `
-      const ${channelVariable} = tr_ch_apm_tracingChannel("orchestrion:${name}:${channelName}")
+      ${sharedHookLookup}
+      let ${channelVariable};
+      const ${channelGetter} = () =>
+        ${channelVariable} ??= ${SHARED_HOOK_LOOKUP}(
+          ${JSON.stringify(`orchestrion:${name}:${channelName}`)}
+        );
     `;
-    node.body.splice(index + 1, 0, parse(code).body[0]);
+    const sharedHookLookupIndex = node.body.findIndex(
+      (child) => child.declarations?.[0]?.id?.name === SHARED_HOOK_LOOKUP
+    );
+    const index = sharedHookLookupIndex === -1 ? node.body.findIndex(
+      (child) => child.directive === "use strict"
+    ) : sharedHookLookupIndex;
+    node.body.splice(index + 1, 0, ...parse(code).body);
   },
   traceCallback: traceAny,
   tracePromise: traceAny,
@@ -2691,25 +2928,21 @@ function traceAny(state2, node, _parent, ancestry) {
   }
 }
 function traceFunction(state2, node, program) {
-  transforms.tracingChannelDeclaration(state2, program, null, []);
+  transforms.tracingHookDeclaration(state2, program, null, []);
   const { functionQuery } = state2;
   const methodName = "methodName" in functionQuery ? functionQuery.methodName : void 0;
   const privateMethodName = "privateMethodName" in functionQuery ? functionQuery.privateMethodName : void 0;
   const functionName = "functionName" in functionQuery ? functionQuery.functionName : void 0;
   const isConstructor = methodName === "constructor" || !methodName && !privateMethodName && !functionName;
   const type = isConstructor ? "ArrowFunctionExpression" : "FunctionExpression";
-  node.body = wrap(
-    state2,
-    {
-      type,
-      params: node.params,
-      body: node.body,
-      async: node.async,
-      expression: false,
-      generator: node.generator
-    },
-    program
-  );
+  node.body = wrap(state2, {
+    type,
+    params: node.params,
+    body: node.body,
+    async: node.async,
+    expression: false,
+    generator: node.generator
+  });
   node.generator = false;
   node.async = false;
   wrapSuper(node);
@@ -2721,11 +2954,11 @@ function traceInstanceMethod(state2, node, program) {
     return;
   }
   const classBody = node.body;
-  if (classBody.body.some(({ key }) => key.name === methodName)) {
+  if (classBody.body.some(({ key }) => key?.name === methodName)) {
     return;
   }
   let ctor = classBody.body.find(({ kind }) => kind === "constructor");
-  transforms.tracingChannelDeclaration(state2, program, null, []);
+  transforms.tracingHookDeclaration(state2, program, null, []);
   if (!ctor) {
     ctor = parse(
       node.superClass ? "class A extends Object { constructor (...args) { super(...args) } }" : "class A { constructor () {} }"
@@ -2733,47 +2966,36 @@ function traceInstanceMethod(state2, node, program) {
     classBody.body.unshift(ctor);
   }
   const ctorBody = parse(`
-    const __apm$${methodName} = this["${methodName}"]
+    const __bt$${methodName} = this["${methodName}"]
     this["${methodName}"] = function () {}
   `).body;
   const fn = ctorBody[1].expression.right;
   fn.async = operator === "tracePromise";
-  fn.body = wrap(
-    state2,
-    { type: "Identifier", name: `__apm$${methodName}` },
-    program
-  );
+  fn.body = wrap(state2, {
+    type: "Identifier",
+    name: `__bt$${methodName}`
+  });
   wrapSuper(fn);
   ctor.value.body.body.push(...ctorBody);
 }
-function wrap(state2, node, program) {
-  const { operator, moduleVersion } = state2;
-  const wrapper = operator === "traceCallback" ? wrapCallback(state2) : operator === "tracePromise" ? wrapPromise(state2) : wrapSync(state2);
+function wrap(state2, node) {
+  const wrapper = wrapInvocation(state2);
   const block = wrapper.body[0].body;
   const common = parse(
     node.type === "ArrowFunctionExpression" ? `
-    const __apm$ctx = {
-      arguments,
-      moduleVersion: ${JSON.stringify(moduleVersion)}
-    };
-    const __apm$traced = () => {
-      const __apm$wrapped = () => {};
-      return __apm$wrapped(...arguments);
+    const __bt$target = (...__bt$args) => {
+      const __bt$wrapped = () => {};
+      return __bt$wrapped(...__bt$args);
     };
   ` : `
-    const __apm$ctx = {
-      arguments,
-      self: this,
-      moduleVersion: ${JSON.stringify(moduleVersion)}
-    };
-    const __apm$traced = () => {
-      const __apm$wrapped = () => {};
-      return __apm$wrapped.apply(this, arguments);
+    const __bt$target = function (...__bt$args) {
+      const __bt$wrapped = () => {};
+      return __bt$wrapped.apply(this, __bt$args);
     };
   `
   ).body;
   block.body.unshift(...common);
-  esquery.query(block, "[id.name=__apm$wrapped]")[0].init = node;
+  esquery.query(block, "[id.name=__bt$wrapped]")[0].init = node;
   return block;
 }
 function wrapSuper(node) {
@@ -2785,11 +3007,11 @@ function wrapSuper(node) {
       const { name } = node2.property;
       let child;
       if (parent.callee) {
-        const { expression } = parse(`__apm$super['${name}'].call(this)`).body[0];
+        const { expression } = parse(`__bt$super['${name}'].call(this)`).body[0];
         parent.callee = child = expression.callee;
         parent.arguments.unshift(...expression.arguments);
       } else {
-        parent.expression = child = parse(`__apm$super['${name}']`).body[0];
+        parent.expression = child = parse(`__bt$super['${name}']`).body[0];
       }
       child.computed = parent.callee.computed;
       child.optional = parent.callee.optional;
@@ -2800,151 +3022,32 @@ function wrapSuper(node) {
     const member = parse(`
       class Wrapper {
         wrapper () {
-          __apm$super['${name}'] = super['${name}']
+          __bt$super['${name}'] = super['${name}']
         }
       }
     `).body[0].body.body[0].value.body.body[0];
     node.body.body.unshift(member);
   }
   if (members.size > 0) {
-    node.body.body.unshift(parse("const __apm$super = {}").body[0]);
+    node.body.body.unshift(parse("const __bt$super = {}").body[0]);
   }
 }
-function wrapCallback(state2) {
-  const {
-    channelName,
-    functionQuery: { callbackIndex = -1 }
-  } = state2;
-  const channelVariable = formatChannelVariable(channelName);
-  return parse(`
-    function wrapper () {
-      const __apm$cb = Array.prototype.at.call(arguments, ${callbackIndex});
-
-      if (!${channelVariable}.start.hasSubscribers) return __apm$traced();
-
-      function __apm$wrappedCb(err, res) {
-        if (err) {
-          __apm$ctx.error = err;
-          ${channelVariable}.error.publish(__apm$ctx);
-        } else {
-          __apm$ctx.result = res;
-        }
-
-        ${channelVariable}.asyncStart.runStores(__apm$ctx, () => {
-          try {
-            if (__apm$cb) {
-              return __apm$cb.apply(this, arguments);
-            }
-          } finally {
-            ${channelVariable}.asyncEnd.publish(__apm$ctx);
-          }
-        });
-      }
-
-      if (typeof __apm$cb !== 'function') {
-        return __apm$traced();
-      }
-      Array.prototype.splice.call(arguments, ${callbackIndex}, 1, __apm$wrappedCb);
-
-      return ${channelVariable}.start.runStores(__apm$ctx, () => {
-        try {
-          return __apm$traced();
-        } catch (err) {
-          __apm$ctx.error = err;
-          ${channelVariable}.error.publish(__apm$ctx);
-          throw err;
-        } finally {
-          __apm$ctx.self ??= this;
-          ${channelVariable}.end.publish(__apm$ctx);
-        }
-      });
-    }
-  `);
-}
-function wrapPromise(state2) {
-  const { channelName } = state2;
-  const channelVariable = formatChannelVariable(channelName);
+function wrapInvocation(state2) {
+  const { channelName, moduleVersion, operator, functionQuery } = state2;
+  const channelGetter = formatChannelGetter(channelName);
+  const callbackIndex = functionQuery.callbackIndex ?? -1;
   return parse(`
     function wrapper () {
-      if (!tr_ch_apm_hasSubscribers(${channelVariable})) return __apm$traced();
-
-      return ${channelVariable}.start.runStores(__apm$ctx, () => {
-        try {
-          let promise = __apm$traced();
-          if (typeof promise?.then !== 'function') {
-            __apm$ctx.result = promise;
-            return promise;
-          }
-          // Mirror Node.js core diagnostics_channel behaviour: for native Promise
-          // instances, chain normally (safe since there is no subclass API to
-          // preserve). For Promise subclasses and other thenables, side-chain the
-          // callbacks for event publishing and return the original so that any
-          // subclass-specific methods (e.g. APIPromise.withResponse()) remain
-          // accessible to the caller.
-          if (promise instanceof Promise && promise.constructor === Promise) {
-            return promise.then(
-              result => {
-                __apm$ctx.result = result;
-                ${channelVariable}.asyncStart.publish(__apm$ctx);
-                ${channelVariable}.asyncEnd.publish(__apm$ctx);
-                return result;
-              },
-              err => {
-                __apm$ctx.error = err;
-                ${channelVariable}.error.publish(__apm$ctx);
-                ${channelVariable}.asyncStart.publish(__apm$ctx);
-                ${channelVariable}.asyncEnd.publish(__apm$ctx);
-                throw err;
-              }
-            );
-          }
-          promise.then(
-            result => {
-              __apm$ctx.result = result;
-              ${channelVariable}.asyncStart.publish(__apm$ctx);
-              ${channelVariable}.asyncEnd.publish(__apm$ctx);
-            },
-            err => {
-              __apm$ctx.error = err;
-              ${channelVariable}.error.publish(__apm$ctx);
-              ${channelVariable}.asyncStart.publish(__apm$ctx);
-              ${channelVariable}.asyncEnd.publish(__apm$ctx);
-            }
-          );
-          return promise;
-        } catch (err) {
-          __apm$ctx.error = err;
-          ${channelVariable}.error.publish(__apm$ctx);
-          throw err;
-        } finally {
-          __apm$ctx.self ??= this;
-          ${channelVariable}.end.publish(__apm$ctx);
-        }
-      });
-    }
-  `);
-}
-function wrapSync(state2) {
-  const { channelName } = state2;
-  const channelVariable = formatChannelVariable(channelName);
-  return parse(`
-    function wrapper () {
-      if (!tr_ch_apm_hasSubscribers(${channelVariable})) return __apm$traced();
-
-      return ${channelVariable}.start.runStores(__apm$ctx, () => {
-        try {
-          const result = __apm$traced();
-          __apm$ctx.result = result;
-          return result;
-        } catch (err) {
-          __apm$ctx.error = err;
-          ${channelVariable}.error.publish(__apm$ctx);
-          throw err;
-        } finally {
-         __apm$ctx.self ??= this;
-          ${channelVariable}.end.publish(__apm$ctx);
-        }
-      });
+      const __bt$hook = ${channelGetter}();
+      if (!__bt$hook) return __bt$target.apply(this, arguments);
+      return __bt$hook.traceInvocation(
+        ${JSON.stringify(operator)},
+        __bt$target,
+        this,
+        arguments,
+        { moduleVersion: ${JSON.stringify(moduleVersion)} },
+        ${callbackIndex}
+      );
     }
   `);
 }
@@ -2955,16 +3058,14 @@ var Transformer = class {
   version;
   filePath;
   configs = [];
-  dcModule;
-  constructor(moduleName, version, filePath, configs, dcModule) {
+  constructor(moduleName, version, filePath, configs) {
     this.moduleName = moduleName;
     this.version = version;
     this.filePath = filePath;
     this.configs = configs;
-    this.dcModule = dcModule;
   }
   /**
-   * Instruments `code` by injecting diagnostics_channel tracing around the
+   * Instruments `code` by injecting global tracing hooks around the
    * target functions defined by this transformer's configs.
    */
   transform(code, moduleType) {
@@ -3002,8 +3103,6 @@ var Transformer = class {
       const query = astQuery || this.fromFunctionQuery(resolvedFunctionQuery);
       const state2 = {
         ...config,
-        dcModule: this.dcModule,
-        moduleType,
         moduleVersion: this.version,
         functionQuery: resolvedFunctionQuery,
         operator: this.getOperator(resolvedFunctionQuery.kind)
@@ -3153,11 +3252,9 @@ var Transformer = class {
 // src/auto-instrumentations/orchestrion-js/matcher.ts
 var InstrumentationMatcher = class {
   configs = [];
-  dcModule;
   transformers = {};
-  constructor(configs, dcModule) {
+  constructor(configs) {
     this.configs = configs;
-    this.dcModule = dcModule || "diagnostics_channel";
   }
   /**
    * Returns a Transformer for the given module/file/version, or undefined if no
@@ -3179,8 +3276,7 @@ var InstrumentationMatcher = class {
       moduleName,
       version,
       filePath,
-      configs,
-      this.dcModule
+      configs
     );
     return this.transformers[id];
   }
@@ -3190,8 +3286,8 @@ var InstrumentationMatcher = class {
 };
 
 // src/auto-instrumentations/orchestrion-js/index.ts
-function create(configs, dcModule) {
-  return new InstrumentationMatcher(configs, dcModule);
+function create(configs) {
+  return new InstrumentationMatcher(configs);
 }
 
 // src/auto-instrumentations/loader/cjs-patch.ts
@@ -3280,6 +3376,9 @@ function applySpecialCasePatch(input) {
   if (input.packageName === "openai" && input.modulePath.includes("api-promise")) {
     return input.source + OPENAI_API_PROMISE_PATCH;
   }
+  if (input.browser) {
+    return null;
+  }
   const mastraTarget = classifyMastraTarget(
     input.packageName,
     input.modulePath
@@ -3308,7 +3407,7 @@ var ModulePatch = class {
   /**
    * Patches the Node.js module class method that is responsible for compiling code.
    * If a module is found that has an instrumentator, it will transform the code before compiling it
-   * with tracing channel methods.
+   * with global hook calls.
    */
   patch() {
     const self = this;
@@ -3367,7 +3466,9 @@ function resolveModulePrototype() {
 }
 
 // src/node/apply-auto-instrumentation-entry.ts
-var stateKey = /* @__PURE__ */ Symbol.for("braintrust.applyAutoInstrumentation");
+var stateKey = /* @__PURE__ */ Symbol.for(
+  `braintrust.applyAutoInstrumentation.global-hooks.v${GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION}`
+);
 var existingState = Object.getOwnPropertyDescriptor(
   globalThis,
   stateKey
@@ -3384,7 +3485,6 @@ if (state !== existingState) {
   });
 }
 if (!state.applied) {
-  patchTracingChannel(diagnostics_channel.tracingChannel);
   const allConfigs = getDefaultAutoInstrumentationConfigs();
   const currentModuleUrl = getCurrentModuleUrl();
   register("./auto-instrumentations/loader/esm-hook.mjs", {