braintrust 3.25.0 → 3.27.0

package/dist/auto-instrumentations/bundler/esbuild.cjs

@@ -50,52 +50,720 @@ var import_source_map = require("source-map");
 // src/auto-instrumentations/orchestrion-js/transforms.ts
 var import_esquery = __toESM(require("esquery"));
 var import_meriyah = require("meriyah");
-var tracingChannelPredicate = (node) => node.declarations?.[0]?.id?.properties?.[0]?.value?.name === "tr_ch_apm_tracingChannel";
-var CHANNEL_REGEX = /[^\w]/g;
-function formatChannelVariable(channelName) {
-  return `tr_ch_apm$${channelName.replace(CHANNEL_REGEX, "_")}`;
+
+// src/global-instrumentation-hooks.ts
+var GLOBAL_INSTRUMENTATION_HOOKS_KEY = "__braintrust_instrumentation_hooks";
+var GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION = 1;
+var GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND = "braintrust.global-instrumentation-hooks.registry";
+var GLOBAL_INSTRUMENTATION_HOOK_BRAND = "braintrust.global-instrumentation-hooks.hook";
+var GLOBAL_INVOCATION_HOOK_BRAND = "braintrust.global-instrumentation-hooks.invocation-hook";
+var registryBrand = Symbol.for(GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND);
+var hookBrand = Symbol.for(GLOBAL_INSTRUMENTATION_HOOK_BRAND);
+var invocationHookBrand = Symbol.for(GLOBAL_INVOCATION_HOOK_BRAND);
+var errorReporter;
+function reportError(error) {
+  try {
+    errorReporter?.(error);
+  } catch {
+  }
 }
-var transforms = {
-  tracingChannelImport({ dcModule, moduleType }, node) {
-    if (node.body.some(tracingChannelPredicate)) {
-      return;
+function setContextValue(context, key, value) {
+  try {
+    context[key] = value;
+  } catch (error) {
+    reportError(error);
+  }
+}
+function wrapStoreRun(store, message, next, transform) {
+  return () => {
+    let context;
+    try {
+      context = transform ? transform(message) : message;
+    } catch (error) {
+      reportError(error);
+      return next();
+    }
+    let called = false;
+    let result;
+    let providerError;
+    let providerThrew = false;
+    const runNext = () => {
+      if (called) {
+        reportError(
+          new Error(
+            "Instrumentation store invoked its callback more than once"
+          )
+        );
+        if (providerThrew) {
+          throw providerError;
+        }
+        return result;
+      }
+      called = true;
+      try {
+        result = next();
+        return result;
+      } catch (error) {
+        providerThrew = true;
+        providerError = error;
+        throw error;
+      }
+    };
+    try {
+      store.run(context, runNext);
+    } catch (error) {
+      if (!providerThrew || error !== providerError) {
+        reportError(error);
+      }
     }
-    const options = { module: moduleType === "esm" };
-    const index = node.body.findIndex(
-      (child) => child.directive === "use strict"
+    if (!called) {
+      reportError(
+        new Error("Instrumentation store did not invoke its callback")
+      );
+      return runNext();
+    }
+    if (providerThrew) {
+      throw providerError;
+    }
+    return result;
+  };
+}
+var HookChannel = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+  subscribers = [];
+  stores = /* @__PURE__ */ new Map();
+  get hasSubscribers() {
+    return this.subscribers.length > 0 || this.stores.size > 0;
+  }
+  subscribe(subscription) {
+    if (typeof subscription !== "function") {
+      throw new TypeError("subscription must be a function");
+    }
+    this.subscribers = [...this.subscribers, subscription];
+  }
+  unsubscribe(subscription) {
+    const index = this.subscribers.indexOf(subscription);
+    if (index === -1) {
+      return false;
+    }
+    this.subscribers = [
+      ...this.subscribers.slice(0, index),
+      ...this.subscribers.slice(index + 1)
+    ];
+    return true;
+  }
+  bindStore(store, transform) {
+    if (!store || typeof store.run !== "function") {
+      throw new TypeError("store must have a run method");
+    }
+    this.stores.set(
+      store,
+      transform
     );
-    const dc = moduleType === "esm" ? `import tr_ch_apm_dc from "${dcModule}"` : `const tr_ch_apm_dc = ${"require"}("${dcModule}")`;
-    const tracingChannel = "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,
-      (0, import_meriyah.parse)(dc, options).body[0],
-      (0, import_meriyah.parse)(tracingChannel, options).body[0],
-      (0, import_meriyah.parse)(hasSubscribers, options).body[0]
+  }
+  unbindStore(store) {
+    return this.stores.delete(store);
+  }
+  publish(message) {
+    const subscribers = this.subscribers;
+    for (const subscriber of subscribers) {
+      try {
+        subscriber(message, this.name);
+      } catch (error) {
+        reportError(error);
+      }
+    }
+  }
+  runStores(message, fn, thisArg, ...args) {
+    let run = () => {
+      this.publish(message);
+      return Reflect.apply(fn, thisArg, args);
+    };
+    for (const [store, transform] of this.stores.entries()) {
+      run = wrapStoreRun(store, message, run, transform);
+    }
+    return run();
+  }
+};
+var traceEvents = [
+  "start",
+  "end",
+  "asyncStart",
+  "asyncEnd",
+  "error"
+];
+function traceInvocation(hook, operator, target, thisArg, args, additional, callbackIndex = -1) {
+  const context = {
+    ...additional,
+    arguments: args,
+    self: thisArg
+  };
+  const invoke = () => hook.invoke(target, thisArg, args, additional);
+  if (operator === "traceCallback") {
+    return hook.traceCallback(invoke, callbackIndex, context);
+  }
+  if (operator === "tracePromise") {
+    return hook.tracePromise(invoke, context);
+  }
+  return hook.traceSync(invoke, context);
+}
+var InvocationHook = class {
+  interceptors = [];
+  get hasInterceptors() {
+    return this.interceptors.length > 0;
+  }
+  intercept(interceptor) {
+    if (typeof interceptor !== "function") {
+      throw new TypeError("interceptor must be a function");
+    }
+    this.interceptors = [...this.interceptors, interceptor];
+    let active = true;
+    return () => {
+      if (!active) {
+        return;
+      }
+      active = false;
+      const index = this.interceptors.indexOf(interceptor);
+      if (index !== -1) {
+        this.interceptors = [
+          ...this.interceptors.slice(0, index),
+          ...this.interceptors.slice(index + 1)
+        ];
+      }
+    };
+  }
+  invoke(target, thisArg, args, additional) {
+    const interceptors = this.interceptors;
+    if (interceptors.length === 0) {
+      return Reflect.apply(target, thisArg, args);
+    }
+    let next = target;
+    for (let index = interceptors.length - 1; index >= 0; index -= 1) {
+      const interceptor = interceptors[index];
+      const downstream = next;
+      next = function(...nextArgs) {
+        return interceptor(downstream, this, nextArgs, additional);
+      };
+    }
+    return Reflect.apply(next, thisArg, args);
+  }
+};
+var TracingHook = class {
+  start;
+  end;
+  asyncStart;
+  asyncEnd;
+  error;
+  invocationHook = new InvocationHook();
+  constructor(nameOrChannels) {
+    Object.defineProperty(this, hookBrand, {
+      configurable: false,
+      enumerable: false,
+      value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+      writable: false
+    });
+    Object.defineProperty(this, invocationHookBrand, {
+      configurable: false,
+      enumerable: false,
+      value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+      writable: false
+    });
+    if (typeof nameOrChannels === "string") {
+      this.start = new HookChannel(`tracing:${nameOrChannels}:start`);
+      this.end = new HookChannel(`tracing:${nameOrChannels}:end`);
+      this.asyncStart = new HookChannel(`tracing:${nameOrChannels}:asyncStart`);
+      this.asyncEnd = new HookChannel(`tracing:${nameOrChannels}:asyncEnd`);
+      this.error = new HookChannel(`tracing:${nameOrChannels}:error`);
+      return;
+    }
+    this.start = nameOrChannels.start ?? new HookChannel("tracing:start");
+    this.end = nameOrChannels.end ?? new HookChannel("tracing:end");
+    this.asyncStart = nameOrChannels.asyncStart ?? new HookChannel("tracing:asyncStart");
+    this.asyncEnd = nameOrChannels.asyncEnd ?? new HookChannel("tracing:asyncEnd");
+    this.error = nameOrChannels.error ?? new HookChannel("tracing:error");
+  }
+  get hasSubscribers() {
+    return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
+  }
+  get hasInterceptors() {
+    return this.invocationHook.hasInterceptors;
+  }
+  intercept(interceptor) {
+    return this.invocationHook.intercept(interceptor);
+  }
+  invoke(target, thisArg, args, additional) {
+    return this.invocationHook.invoke(target, thisArg, args, additional);
+  }
+  traceInvocation(operator, target, thisArg, args, additional, callbackIndex = -1) {
+    return traceInvocation(
+      this,
+      operator,
+      target,
+      thisArg,
+      args,
+      additional,
+      callbackIndex
     );
+  }
+  subscribe(handlers) {
+    for (const eventName of traceEvents) {
+      const handler = handlers[eventName];
+      if (handler) {
+        this[eventName].subscribe(handler);
+      }
+    }
+  }
+  unsubscribe(handlers) {
+    let done = true;
+    for (const eventName of traceEvents) {
+      const handler = handlers[eventName];
+      if (handler && !this[eventName].unsubscribe(handler)) {
+        done = false;
+      }
+    }
+    return done;
+  }
+  traceSync(fn, message = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return Reflect.apply(fn, thisArg, args);
+    }
+    const context = message;
+    return this.start.runStores(message, () => {
+      try {
+        const result = Reflect.apply(fn, thisArg, args);
+        setContextValue(context, "result", result);
+        return result;
+      } catch (error) {
+        setContextValue(context, "error", error);
+        this.error.publish(message);
+        throw error;
+      } finally {
+        this.end.publish(message);
+      }
+    });
+  }
+  tracePromise(fn, message = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return Reflect.apply(fn, thisArg, args);
+    }
+    const context = message;
+    return this.start.runStores(message, () => {
+      let result;
+      try {
+        result = Reflect.apply(fn, thisArg, args);
+      } catch (error) {
+        setContextValue(context, "error", error);
+        this.error.publish(message);
+        this.end.publish(message);
+        throw error;
+      }
+      this.end.publish(message);
+      if (!result || typeof result !== "object" && typeof result !== "function") {
+        setContextValue(context, "result", result);
+        this.asyncStart.publish(message);
+        this.asyncEnd.publish(message);
+        return result;
+      }
+      let terminalPublished = false;
+      const finishUnobservedResult = (error) => {
+        reportError(error);
+        if (!terminalPublished) {
+          terminalPublished = true;
+          setContextValue(context, "result", result);
+          this.asyncStart.publish(message);
+          this.asyncEnd.publish(message);
+        }
+        return result;
+      };
+      let then;
+      try {
+        then = result.then;
+      } catch (error) {
+        return finishUnobservedResult(error);
+      }
+      if (typeof then !== "function") {
+        setContextValue(context, "result", result);
+        this.asyncStart.publish(message);
+        this.asyncEnd.publish(message);
+        return result;
+      }
+      const resolve = (resolved) => {
+        if (!terminalPublished) {
+          terminalPublished = true;
+          setContextValue(context, "result", resolved);
+          this.asyncStart.publish(message);
+          this.asyncEnd.publish(message);
+        }
+        return resolved;
+      };
+      let rejectionThrown = false;
+      let rejectionError;
+      const reject = (error) => {
+        if (!terminalPublished) {
+          terminalPublished = true;
+          setContextValue(context, "error", error);
+          this.error.publish(message);
+          this.asyncStart.publish(message);
+          this.asyncEnd.publish(message);
+        }
+        rejectionThrown = true;
+        rejectionError = error;
+        throw error;
+      };
+      let isPlainPromise;
+      try {
+        isPlainPromise = result instanceof Promise && result.constructor === Promise;
+      } catch (error) {
+        return finishUnobservedResult(error);
+      }
+      try {
+        if (isPlainPromise) {
+          return Reflect.apply(then, result, [resolve, reject]);
+        }
+        Reflect.apply(then, result, [
+          resolve,
+          (error) => {
+            try {
+              reject(error);
+            } catch {
+            }
+          }
+        ]);
+      } catch (error) {
+        if (rejectionThrown && error === rejectionError) {
+          return result;
+        }
+        return finishUnobservedResult(error);
+      }
+      return result;
+    });
+  }
+  traceCallback(fn, position = -1, message = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return Reflect.apply(fn, thisArg, args);
+    }
+    const context = message;
+    const callArgs = args.length > 0 ? args : context.arguments ?? args;
+    const callback = Array.prototype.at.call(callArgs, position);
+    if (typeof callback !== "function") {
+      return Reflect.apply(fn, thisArg, args);
+    }
+    const { asyncStart, asyncEnd, error: errorChannel } = this;
+    function wrappedCallback(error, result) {
+      if (error) {
+        setContextValue(context, "error", error);
+        errorChannel.publish(message);
+      } else {
+        setContextValue(context, "result", result);
+      }
+      return asyncStart.runStores(message, () => {
+        try {
+          return Reflect.apply(callback, this, arguments);
+        } finally {
+          asyncEnd.publish(message);
+        }
+      });
+    }
+    Array.prototype.splice.call(callArgs, position, 1, wrappedCallback);
+    return this.start.runStores(message, () => {
+      try {
+        return Reflect.apply(fn, thisArg, args);
+      } catch (error) {
+        setContextValue(context, "error", error);
+        this.error.publish(message);
+        throw error;
+      } finally {
+        this.end.publish(message);
+      }
+    });
+  }
+};
+var inertChannel = Object.freeze({
+  name: "braintrust:inert",
+  hasSubscribers: false,
+  subscribe() {
+  },
+  unsubscribe() {
+    return false;
+  },
+  bindStore() {
   },
-  tracingChannelDeclaration(state, node) {
+  unbindStore() {
+    return false;
+  },
+  publish() {
+  },
+  runStores(_message, fn, thisArg, ...args) {
+    return Reflect.apply(fn, thisArg, args);
+  }
+});
+var inertTracingHook = new TracingHook({
+  start: inertChannel,
+  end: inertChannel,
+  asyncStart: inertChannel,
+  asyncEnd: inertChannel,
+  error: inertChannel
+});
+function isHookChannel(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  try {
+    const channel2 = value;
+    return typeof channel2.hasSubscribers === "boolean" && typeof channel2.subscribe === "function" && typeof channel2.unsubscribe === "function" && typeof channel2.bindStore === "function" && typeof channel2.unbindStore === "function" && typeof channel2.publish === "function" && typeof channel2.runStores === "function";
+  } catch {
+    return false;
+  }
+}
+function hasTracingHookShape(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  try {
+    const hook = value;
+    return typeof hook.hasSubscribers === "boolean" && typeof hook.subscribe === "function" && typeof hook.unsubscribe === "function" && typeof hook.traceSync === "function" && typeof hook.tracePromise === "function" && typeof hook.traceCallback === "function" && isHookChannel(hook.start) && isHookChannel(hook.end) && isHookChannel(hook.asyncStart) && isHookChannel(hook.asyncEnd) && isHookChannel(hook.error);
+  } catch {
+    return false;
+  }
+}
+function hasInvocationHookShape(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  try {
+    const hook = value;
+    return value[invocationHookBrand] === GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION && typeof hook.hasInterceptors === "boolean" && typeof hook.intercept === "function" && typeof hook.invoke === "function";
+  } catch {
+    return false;
+  }
+}
+function installInvocationHook(value) {
+  const hasInvocationHook = hasInvocationHookShape(value);
+  const invocationHook = new InvocationHook();
+  try {
+    if (!hasInvocationHook) {
+      Object.defineProperties(value, {
+        [invocationHookBrand]: {
+          configurable: false,
+          enumerable: false,
+          value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+          writable: false
+        },
+        hasInterceptors: {
+          configurable: false,
+          enumerable: false,
+          get: () => invocationHook.hasInterceptors
+        },
+        intercept: {
+          configurable: false,
+          enumerable: false,
+          value: invocationHook.intercept.bind(invocationHook),
+          writable: false
+        },
+        invoke: {
+          configurable: false,
+          enumerable: false,
+          value: invocationHook.invoke.bind(invocationHook),
+          writable: false
+        }
+      });
+    }
+    if (typeof value.traceInvocation !== "function") {
+      Object.defineProperty(value, "traceInvocation", {
+        configurable: false,
+        enumerable: false,
+        value: traceInvocation.bind(void 0, value),
+        writable: false
+      });
+    }
+  } catch (error) {
+    reportError(error);
+  }
+}
+function isCompatibleTracingHook(value) {
+  try {
+    return value[hookBrand] === GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION && hasTracingHookShape(value);
+  } catch {
+    return false;
+  }
+}
+function isCompatibleHookRegistry(value) {
+  try {
+    return value instanceof Map && value[registryBrand] === GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION;
+  } catch {
+    return false;
+  }
+}
+function getHookRegistry() {
+  let descriptor;
+  try {
+    descriptor = Object.getOwnPropertyDescriptor(
+      globalThis,
+      GLOBAL_INSTRUMENTATION_HOOKS_KEY
+    );
+  } catch (error) {
+    reportError(error);
+    return void 0;
+  }
+  if (descriptor && "value" in descriptor && isCompatibleHookRegistry(descriptor.value) && (descriptor.configurable || descriptor.enumerable === false)) {
+    if (descriptor.configurable || descriptor.writable) {
+      try {
+        Object.defineProperty(globalThis, GLOBAL_INSTRUMENTATION_HOOKS_KEY, {
+          configurable: false,
+          enumerable: false,
+          value: descriptor.value,
+          writable: false
+        });
+      } catch (error) {
+        reportError(error);
+        return void 0;
+      }
+    }
+    return descriptor.value;
+  }
+  if (descriptor && !descriptor.configurable) {
+    reportError(new Error("Incompatible global instrumentation hook registry"));
+    return void 0;
+  }
+  const registry = /* @__PURE__ */ new Map();
+  try {
+    Object.defineProperty(registry, registryBrand, {
+      configurable: false,
+      enumerable: false,
+      value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+      writable: false
+    });
+  } catch (error) {
+    reportError(error);
+    return void 0;
+  }
+  try {
+    Object.defineProperty(globalThis, GLOBAL_INSTRUMENTATION_HOOKS_KEY, {
+      configurable: false,
+      enumerable: false,
+      value: registry,
+      writable: false
+    });
+    return registry;
+  } catch (error) {
+    reportError(error);
+    return void 0;
+  }
+}
+function newGlobalTracingChannel(nameOrChannels) {
+  if (typeof nameOrChannels !== "string") {
+    return new TracingHook(nameOrChannels);
+  }
+  const registry = getHookRegistry();
+  if (!registry) {
+    return inertTracingHook;
+  }
+  let existing;
+  try {
+    existing = Map.prototype.get.call(registry, nameOrChannels);
+  } catch (error) {
+    reportError(error);
+    return inertTracingHook;
+  }
+  if (isCompatibleTracingHook(existing)) {
+    installInvocationHook(existing);
+    return existing;
+  }
+  if (existing !== void 0) {
+    reportError(
+      new Error(`Invalid global instrumentation hook: ${nameOrChannels}`)
+    );
+    try {
+      Map.prototype.delete.call(registry, nameOrChannels);
+    } catch (error) {
+      reportError(error);
+      return inertTracingHook;
+    }
+  }
+  const hook = new TracingHook(nameOrChannels);
+  try {
+    Map.prototype.set.call(registry, nameOrChannels, hook);
+  } catch (error) {
+    reportError(error);
+    return inertTracingHook;
+  }
+  return hook;
+}
+
+// src/auto-instrumentations/orchestrion-js/transforms.ts
+var CHANNEL_REGEX = /[^\w]/g;
+var SHARED_HOOK_LOOKUP = "tr_ch_bt$get_hook";
+function formatChannelVariable(channelName) {
+  return `tr_ch_bt$${channelName.replace(CHANNEL_REGEX, "_")}`;
+}
+function formatChannelGetter(channelName) {
+  return `tr_ch_bt$get_${channelName.replace(CHANNEL_REGEX, "_")}`;
+}
+var transforms = {
+  tracingHookDeclaration(state, node) {
     const {
       channelName,
       module: { name }
     } = state;
     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(state, 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, (0, import_meriyah.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, ...(0, import_meriyah.parse)(code).body);
   },
   traceCallback: traceAny,
   tracePromise: traceAny,
@@ -110,25 +778,21 @@ function traceAny(state, node, _parent, ancestry) {
   }
 }
 function traceFunction(state, node, program) {
-  transforms.tracingChannelDeclaration(state, program, null, []);
+  transforms.tracingHookDeclaration(state, program, null, []);
   const { functionQuery } = state;
   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(
-    state,
-    {
-      type,
-      params: node.params,
-      body: node.body,
-      async: node.async,
-      expression: false,
-      generator: node.generator
-    },
-    program
-  );
+  node.body = wrap(state, {
+    type,
+    params: node.params,
+    body: node.body,
+    async: node.async,
+    expression: false,
+    generator: node.generator
+  });
   node.generator = false;
   node.async = false;
   wrapSuper(node);
@@ -140,11 +804,11 @@ function traceInstanceMethod(state, 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(state, program, null, []);
+  transforms.tracingHookDeclaration(state, program, null, []);
   if (!ctor) {
     ctor = (0, import_meriyah.parse)(
       node.superClass ? "class A extends Object { constructor (...args) { super(...args) } }" : "class A { constructor () {} }"
@@ -152,47 +816,36 @@ function traceInstanceMethod(state, node, program) {
     classBody.body.unshift(ctor);
   }
   const ctorBody = (0, import_meriyah.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(
-    state,
-    { type: "Identifier", name: `__apm$${methodName}` },
-    program
-  );
+  fn.body = wrap(state, {
+    type: "Identifier",
+    name: `__bt$${methodName}`
+  });
   wrapSuper(fn);
   ctor.value.body.body.push(...ctorBody);
 }
-function wrap(state, node, program) {
-  const { operator, moduleVersion } = state;
-  const wrapper = operator === "traceCallback" ? wrapCallback(state) : operator === "tracePromise" ? wrapPromise(state) : wrapSync(state);
+function wrap(state, node) {
+  const wrapper = wrapInvocation(state);
   const block = wrapper.body[0].body;
   const common = (0, import_meriyah.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);
-  import_esquery.default.query(block, "[id.name=__apm$wrapped]")[0].init = node;
+  import_esquery.default.query(block, "[id.name=__bt$wrapped]")[0].init = node;
   return block;
 }
 function wrapSuper(node) {
@@ -204,11 +857,11 @@ function wrapSuper(node) {
       const { name } = node2.property;
       let child;
       if (parent.callee) {
-        const { expression } = (0, import_meriyah.parse)(`__apm$super['${name}'].call(this)`).body[0];
+        const { expression } = (0, import_meriyah.parse)(`__bt$super['${name}'].call(this)`).body[0];
         parent.callee = child = expression.callee;
         parent.arguments.unshift(...expression.arguments);
       } else {
-        parent.expression = child = (0, import_meriyah.parse)(`__apm$super['${name}']`).body[0];
+        parent.expression = child = (0, import_meriyah.parse)(`__bt$super['${name}']`).body[0];
       }
       child.computed = parent.callee.computed;
       child.optional = parent.callee.optional;
@@ -219,151 +872,32 @@ function wrapSuper(node) {
     const member = (0, import_meriyah.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((0, import_meriyah.parse)("const __apm$super = {}").body[0]);
+    node.body.body.unshift((0, import_meriyah.parse)("const __bt$super = {}").body[0]);
   }
 }
-function wrapCallback(state) {
-  const {
-    channelName,
-    functionQuery: { callbackIndex = -1 }
-  } = state;
-  const channelVariable = formatChannelVariable(channelName);
-  return (0, import_meriyah.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(state) {
-  const { channelName } = state;
-  const channelVariable = formatChannelVariable(channelName);
-  return (0, import_meriyah.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(state) {
-  const { channelName } = state;
-  const channelVariable = formatChannelVariable(channelName);
+function wrapInvocation(state) {
+  const { channelName, moduleVersion, operator, functionQuery } = state;
+  const channelGetter = formatChannelGetter(channelName);
+  const callbackIndex = functionQuery.callbackIndex ?? -1;
   return (0, import_meriyah.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}
+      );
     }
   `);
 }
@@ -374,16 +908,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) {
@@ -421,8 +953,6 @@ var Transformer = class {
       const query = astQuery || this.fromFunctionQuery(resolvedFunctionQuery);
       const state = {
         ...config,
-        dcModule: this.dcModule,
-        moduleType,
         moduleVersion: this.version,
         functionQuery: resolvedFunctionQuery,
         operator: this.getOperator(resolvedFunctionQuery.kind)
@@ -572,11 +1102,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
@@ -598,8 +1126,7 @@ var InstrumentationMatcher = class {
       moduleName,
       version,
       filePath,
-      configs,
-      this.dcModule
+      configs
     );
     return this.transformers[id];
   }
@@ -609,8 +1136,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/bundler/plugin.ts
@@ -636,6 +1163,9 @@ var envIntegrationAliases = {
   strandsagentsdk: "strandsAgentSDK",
   "strands-agent-sdk": "strandsAgentSDK",
   "@strands-agents/sdk": "strandsAgentSDK",
+  agents: "cloudflareAgents",
+  "cloudflare-agents": "cloudflareAgents",
+  cloudflareagents: "cloudflareAgents",
   anthropic: "anthropic",
   aisdk: "aisdk",
   "ai-sdk": "aisdk",
@@ -643,6 +1173,10 @@ var envIntegrationAliases = {
   vercel: "vercel",
   claudeagentsdk: "claudeAgentSDK",
   "claude-agent-sdk": "claudeAgentSDK",
+  cloudflareaichat: "cloudflareAIChat",
+  "cloudflare-ai-chat": "cloudflareAIChat",
+  "@cloudflare/ai-chat": "cloudflareAIChat",
+  cloudflarethink: "cloudflareThink",
   cursor: "cursor",
   "cursor-sdk": "cursorSDK",
   cursorsdk: "cursorSDK",
@@ -657,10 +1191,13 @@ var envIntegrationAliases = {
   "google-genai": "googleGenAI",
   googlegenai: "googleGenAI",
   huggingface: "huggingface",
+  "@huggingface/transformers": "huggingface",
+  transformers: "huggingface",
   openrouter: "openrouter",
   openrouteragent: "openrouterAgent",
   "openrouter-agent": "openrouterAgent",
   mistral: "mistral",
+  ollama: "ollama",
   googleadk: "googleADK",
   "google-adk": "googleADK",
   cohere: "cohere",
@@ -713,73 +1250,6 @@ var DefaultAsyncLocalStorage = class {
     return void 0;
   }
 };
-var DefaultChannel = class {
-  constructor(name) {
-    this.name = name;
-  }
-  name;
-  hasSubscribers = false;
-  subscribe(_subscription) {
-  }
-  unsubscribe(_subscription) {
-    return false;
-  }
-  bindStore(_store, _transform) {
-  }
-  unbindStore(_store) {
-    return false;
-  }
-  publish(_message) {
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runStores(_message, fn, thisArg, ...args) {
-    return fn.apply(thisArg, args);
-  }
-};
-var DefaultTracingChannel = class {
-  start;
-  end;
-  asyncStart;
-  asyncEnd;
-  error;
-  constructor(nameOrChannels) {
-    if (typeof nameOrChannels === "string") {
-      this.start = new DefaultChannel(`tracing:${nameOrChannels}:start`);
-      this.end = new DefaultChannel(`tracing:${nameOrChannels}:end`);
-      this.asyncStart = new DefaultChannel(
-        `tracing:${nameOrChannels}:asyncStart`
-      );
-      this.asyncEnd = new DefaultChannel(`tracing:${nameOrChannels}:asyncEnd`);
-      this.error = new DefaultChannel(`tracing:${nameOrChannels}:error`);
-      return;
-    }
-    this.start = nameOrChannels.start ?? new DefaultChannel("tracing:start");
-    this.end = nameOrChannels.end ?? new DefaultChannel("tracing:end");
-    this.asyncStart = nameOrChannels.asyncStart ?? new DefaultChannel("tracing:asyncStart");
-    this.asyncEnd = nameOrChannels.asyncEnd ?? new DefaultChannel("tracing:asyncEnd");
-    this.error = nameOrChannels.error ?? new DefaultChannel("tracing:error");
-  }
-  get hasSubscribers() {
-    return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
-  }
-  subscribe(_handlers) {
-  }
-  unsubscribe(_handlers) {
-    return false;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  traceSync(fn, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  tracePromise(fn, _message, thisArg, ...args) {
-    return 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()
@@ -790,7 +1260,7 @@ var iso = {
   getCallerLocation: () => void 0,
   newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  newTracingChannel: (nameOrChannels) => new DefaultTracingChannel(nameOrChannels),
+  newTracingChannel: (nameOrChannels) => newGlobalTracingChannel(nameOrChannels),
   processOn: (_0, _1) => {
   },
   basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
@@ -813,11 +1283,21 @@ function defineChannels(pkg, channels, options) {
         const tracingChannel2 = () => isomorph_default.newTracingChannel(
           fullChannelName
         );
+        const intercept2 = (interceptor) => {
+          const hook = tracingChannel2();
+          return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
+          };
+        };
         return [
           key,
           {
             ...asyncSpec,
             instrumentationName,
+            intercept: intercept2,
+            invoke: (target, thisArg, args, additional) => {
+              const hook = tracingChannel2();
+              return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
+            },
             tracingChannel: tracingChannel2,
             tracePromise: (fn, context) => tracingChannel2().tracePromise(
               fn,
@@ -831,11 +1311,21 @@ function defineChannels(pkg, channels, options) {
       const tracingChannel = () => isomorph_default.newTracingChannel(
         fullChannelName
       );
+      const intercept = (interceptor) => {
+        const hook = tracingChannel();
+        return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
+        };
+      };
       return [
         key,
         {
           ...syncSpec,
           instrumentationName,
+          intercept,
+          invoke: (target, thisArg, args, additional) => {
+            const hook = tracingChannel();
+            return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
+          },
           tracingChannel,
           traceSync: (fn, context) => tracingChannel().traceSync(
             fn,
@@ -855,6 +1345,9 @@ var INSTRUMENTATION_NAMES = {
   BEDROCK_RUNTIME: "bedrock-runtime",
   BRAINTRUST_JS_LOGGER: "braintrust-js-logger",
   CLAUDE_AGENT_SDK: "claude-agent-sdk",
+  CLOUDFLARE_AI_CHAT: "cloudflare-ai-chat",
+  CLOUDFLARE_AGENTS: "cloudflare-agents",
+  CLOUDFLARE_THINK: "cloudflare-think",
   COHERE: "cohere",
   CURSOR_SDK: "cursor-sdk",
   EVE: "eve",
@@ -869,6 +1362,7 @@ var INSTRUMENTATION_NAMES = {
   LANGSMITH: "langsmith",
   MASTRA: "mastra",
   MISTRAL: "mistral",
+  OLLAMA: "ollama",
   OPENAI: "openai",
   OPENAI_AGENTS: "openai-agents",
   OPENAI_CODEX: "openai-codex",
@@ -1385,6 +1879,14 @@ var anthropicChannels = defineChannels(
     betaMessagesToolRunner: channel({
       channelName: "beta.messages.toolRunner",
       kind: "sync-stream"
+    }),
+    betaSessionsEventsStream: channel({
+      channelName: "beta.sessions.events.stream",
+      kind: "async"
+    }),
+    betaSessionsThreadsEventsStream: channel({
+      channelName: "beta.sessions.threads.events.stream",
+      kind: "async"
     })
   },
   { instrumentationName: INSTRUMENTATION_NAMES.ANTHROPIC }
@@ -1503,7 +2005,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/instrumentation/plugins/bedrock-runtime-channels.ts
@@ -1632,6 +2167,104 @@ var claudeAgentSDKConfigs = [
   }
 ];
 
+// src/instrumentation/plugins/cloudflare-ai-chat-channels.ts
+var cloudflareAIChatChannels = defineChannels(
+  "@cloudflare/ai-chat",
+  {
+    runExclusiveChatTurn: channel({
+      channelName: "AIChatAgent._runExclusiveChatTurn",
+      kind: "async"
+    }),
+    onChatResponse: channel({
+      channelName: "AIChatAgent.onChatResponse",
+      kind: "sync-stream"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLOUDFLARE_AI_CHAT }
+);
+
+// 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/instrumentation/plugins/cloudflare-agents-channels.ts
+var cloudflareAgentsChannels = defineChannels(
+  "agents",
+  {
+    runAgentTool: channel({
+      channelName: "Agent.runAgentTool",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLOUDFLARE_AGENTS }
+);
+
+// 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/instrumentation/plugins/cloudflare-think-channels.ts
+var cloudflareThinkChannels = defineChannels(
+  "@cloudflare/think",
+  {
+    runInferenceLoop: channel({
+      channelName: "Think.runInferenceLoop",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLOUDFLARE_THINK }
+);
+
+// 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/instrumentation/plugins/cohere-channels.ts
 var cohereChannels = defineChannels(
   "cohere-ai",
@@ -2994,6 +3627,83 @@ var huggingFaceConfigs = [
   }
 ];
 
+// src/instrumentation/plugins/huggingface-transformers-channels.ts
+var huggingFaceTransformersChannels = defineChannels(
+  "@huggingface/transformers",
+  {
+    pipeline: channel({
+      channelName: "pipeline",
+      kind: "async"
+    }),
+    pipelineCall: channel({
+      channelName: "pipeline.call",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.HUGGINGFACE }
+);
+
+// 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/instrumentation/plugins/langchain-channels.ts
 var langChainChannels = defineChannels(
   "@langchain/core",
@@ -3438,6 +4148,51 @@ var mistralConfigs = [
   }
 ];
 
+// src/instrumentation/plugins/ollama-channels.ts
+var ollamaChannels = defineChannels(
+  "ollama",
+  {
+    chat: channel({
+      channelName: "chat",
+      kind: "async"
+    }),
+    generate: channel({
+      channelName: "generate",
+      kind: "async"
+    }),
+    embed: channel({
+      channelName: "embed",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OLLAMA }
+);
+
+// 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/instrumentation/plugins/openai-agents-channels.ts
 var openAIAgentsCoreChannels = defineChannels(
   "@openai/agents-core",
@@ -3847,6 +4602,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: {
@@ -4012,6 +4780,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"],
@@ -4021,7 +4801,10 @@ var defaultInstrumentationConfigGroups = [
     integrations: ["google", "googleGenAI"],
     configs: googleGenAIConfigs
   },
-  { integrations: ["huggingface"], configs: huggingFaceConfigs },
+  {
+    integrations: ["huggingface"],
+    configs: [...huggingFaceConfigs, ...huggingFaceTransformersConfigs]
+  },
   {
     integrations: ["langchain", "langgraph"],
     configs: langchainConfigs
@@ -4033,6 +4816,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 },
@@ -4275,6 +5059,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
@@ -4285,6 +5072,49 @@ function applySpecialCasePatch(input) {
   return null;
 }
 
+// src/auto-instrumentations/loader/get-package-version.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var packageNames = /* @__PURE__ */ new Map();
+function readPackageJson(baseDir) {
+  try {
+    const packageJsonPath = (0, import_node_path.join)(baseDir, "package.json");
+    const jsonFile = (0, import_node_fs.readFileSync)(packageJsonPath, "utf8");
+    return JSON.parse(jsonFile);
+  } catch {
+    return void 0;
+  }
+}
+function resolvePackageBaseDir(baseDir) {
+  try {
+    return (0, import_node_fs.realpathSync)(baseDir);
+  } catch {
+    return baseDir;
+  }
+}
+function readPackageJsonWithFallback(baseDir) {
+  const packageJson = readPackageJson(baseDir);
+  if (packageJson) {
+    return packageJson;
+  }
+  const resolvedBaseDir = resolvePackageBaseDir(baseDir);
+  if (resolvedBaseDir === baseDir) {
+    return void 0;
+  }
+  return readPackageJson(resolvedBaseDir);
+}
+function getPackageName(baseDir) {
+  if (packageNames.has(baseDir)) {
+    return packageNames.get(baseDir);
+  }
+  const packageJson = readPackageJsonWithFallback(baseDir);
+  if (typeof packageJson?.name === "string") {
+    packageNames.set(baseDir, packageJson.name);
+    return packageJson.name;
+  }
+  return void 0;
+}
+
 // src/auto-instrumentations/bundler/plugin.ts
 function getModuleVersion(basedir) {
   try {
@@ -4297,86 +5127,90 @@ function getModuleVersion(basedir) {
   }
   return void 0;
 }
-var unplugin = (0, import_unplugin.createUnplugin)(
-  (options = {}) => {
-    const allInstrumentations = getDefaultInstrumentationConfigs({
-      additionalInstrumentations: options.instrumentations
-    });
-    const dcModule = options.browser === false ? void 0 : "dc-browser";
-    const instrumentationMatcher = create(allInstrumentations, dcModule);
-    return {
-      name: "code-transformer",
-      enforce: "pre",
-      transform(code, id) {
-        if (!id) {
-          return null;
-        }
-        const filePath = id.startsWith("file:") ? (0, import_url.fileURLToPath)(id) : id;
-        const ext = (0, import_path.extname)(filePath);
-        let isModule = ext === ".mjs" || ext === ".ts" || ext === ".tsx";
-        if (ext === ".js") {
-          isModule = code.includes("export ") || code.includes("import ");
-        }
-        const normalizedForPlatform = filePath.split("/").join(import_path.sep);
-        const moduleDetails = (0, import_module_details_from_path.default)(normalizedForPlatform);
-        if (!moduleDetails) {
-          return null;
-        }
-        const moduleName = moduleDetails.name;
-        const normalizedModulePath = moduleDetails.path.replace(/\\/g, "/");
-        const moduleVersion = getModuleVersion(moduleDetails.basedir);
-        if (options.browser !== true) {
-          const patched = applySpecialCasePatch({
-            packageName: moduleName,
-            modulePath: normalizedModulePath,
-            source: code,
-            format: isModule ? "esm" : "cjs"
-          });
-          if (patched !== null) {
-            return { code: patched, map: null };
-          }
-        }
-        if (!moduleVersion) {
-          console.warn(
-            `No 'package.json' version found for module ${moduleName} at ${moduleDetails.basedir}. Skipping transformation.`
-          );
-          return null;
-        }
-        const transformer = instrumentationMatcher.getTransformer(
-          moduleName,
-          moduleVersion,
-          normalizedModulePath
-        );
-        if (!transformer) {
-          return null;
-        }
+var unplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
+  const browser = options.browser ?? options.useDiagnosticChannelCompatShim ?? false;
+  const allInstrumentations = getDefaultInstrumentationConfigs({
+    additionalInstrumentations: options.instrumentations
+  });
+  const instrumentationMatcher = create(allInstrumentations);
+  return {
+    name: "code-transformer",
+    enforce: "pre",
+    transformInclude(id) {
+      const pathWithoutQuery = id.split("?", 1)[0];
+      if (!pathWithoutQuery) {
+        return false;
+      }
+      if (pathWithoutQuery.startsWith("file:")) {
         try {
-          const moduleType = isModule ? "esm" : "cjs";
-          const result = transformer.transform(code, moduleType);
-          const transformedCode = result.code.replace(
-            /const \{tracingChannel: ([A-Za-z_$][\w$]*)\} = ([A-Za-z_$][\w$]*);/g,
-            "const $1 = $2.tracingChannel;"
-          );
-          return {
-            code: transformedCode,
-            map: result.map
-          };
-        } catch (error) {
-          console.warn(`Code transformation failed for ${id}: ${error}`);
-          return null;
+          return (0, import_path.isAbsolute)((0, import_url.fileURLToPath)(pathWithoutQuery));
+        } catch {
+          return false;
         }
       }
-    };
-  }
-);
+      return (0, import_path.isAbsolute)(pathWithoutQuery);
+    },
+    transform(code, id) {
+      if (!id) {
+        return null;
+      }
+      const cleanId = id.replace(/[?#].*$/, "");
+      const filePath = cleanId.startsWith("file:") ? (0, import_url.fileURLToPath)(cleanId) : cleanId;
+      const ext = (0, import_path.extname)(filePath);
+      let isModule = ext === ".mjs" || ext === ".ts" || ext === ".tsx";
+      if (ext === ".js") {
+        isModule = code.includes("export ") || code.includes("import ");
+      }
+      const normalizedForPlatform = filePath.split("/").join(import_path.sep);
+      const moduleDetails = (0, import_module_details_from_path.default)(normalizedForPlatform);
+      if (!moduleDetails) {
+        return null;
+      }
+      const moduleName = getPackageName(moduleDetails.basedir) ?? moduleDetails.name;
+      const normalizedModulePath = moduleDetails.path.replace(/\\/g, "/");
+      const moduleVersion = getModuleVersion(moduleDetails.basedir);
+      const patched = applySpecialCasePatch({
+        packageName: moduleName,
+        modulePath: normalizedModulePath,
+        source: code,
+        format: isModule ? "esm" : "cjs",
+        browser
+      });
+      if (patched !== null) {
+        return { code: patched, map: null };
+      }
+      if (!moduleVersion) {
+        console.warn(
+          `No 'package.json' version found for module ${moduleName} at ${moduleDetails.basedir}. Skipping transformation.`
+        );
+        return null;
+      }
+      const transformer = instrumentationMatcher.getTransformer(
+        moduleName,
+        moduleVersion,
+        normalizedModulePath
+      );
+      if (!transformer) {
+        return null;
+      }
+      try {
+        const moduleType = isModule ? "esm" : "cjs";
+        const result = transformer.transform(code, moduleType);
+        return {
+          code: result.code,
+          map: result.map
+        };
+      } catch (error) {
+        console.warn(`Code transformation failed for ${id}: ${error}`);
+        return null;
+      }
+    }
+  };
+});
 
 // src/auto-instrumentations/bundler/esbuild.ts
 function braintrustEsbuildPlugin(options = {}) {
-  const { useDiagnosticChannelCompatShim = false, ...pluginOptions } = options;
-  return unplugin.esbuild({
-    ...pluginOptions,
-    browser: useDiagnosticChannelCompatShim
-  });
+  return unplugin.esbuild(options);
 }
 var esbuildPlugin = unplugin.esbuild;
 // Annotate the CommonJS export names for ESM import in node: