braintrust 3.25.0 → 3.27.0

package/dist/{chunk-ABR2QWDP.mjs → chunk-CZM5JIQL.mjs}

@@ -4,170 +4,668 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/auto-instrumentations/patch-tracing-channel.ts
-function patchTracingChannel(tracingChannelFn) {
-  const dummyChannel = tracingChannelFn("__braintrust_probe__");
-  const TracingChannel = dummyChannel?.constructor;
-  if (!TracingChannel?.prototype) {
-    return;
+// 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 setGlobalHookErrorReporter(reporter) {
+  const previousReporter = errorReporter;
+  errorReporter = reporter;
+  return () => {
+    if (errorReporter === reporter) {
+      errorReporter = previousReporter;
+    }
+  };
+}
+function reportError(error) {
+  try {
+    errorReporter?.(error);
+  } catch {
   }
-  if (!Object.getOwnPropertyDescriptor(TracingChannel.prototype, "hasSubscribers")) {
-    Object.defineProperty(TracingChannel.prototype, "hasSubscribers", {
-      configurable: true,
-      enumerable: false,
-      get() {
-        return Boolean(
-          this.start?.hasSubscribers || this.end?.hasSubscribers || this.asyncStart?.hasSubscribers || this.asyncEnd?.hasSubscribers || this.error?.hasSubscribers
-        );
-      }
-    });
+}
+function setContextValue(context, key, value) {
+  try {
+    context[key] = value;
+  } catch (error) {
+    reportError(error);
   }
-  if (TracingChannel.prototype.tracePromise) {
-    TracingChannel.prototype.tracePromise = function(fn, context = {}, thisArg, ...args) {
-      const start = this.start;
-      const end = this.end;
-      const asyncStart = this.asyncStart;
-      const asyncEnd = this.asyncEnd;
-      const error = this.error;
-      function publishRejected(err) {
-        context.error = err;
-        error?.publish(context);
-        asyncStart?.publish(context);
-        asyncEnd?.publish(context);
+}
+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;
       }
-      function publishResolved(result) {
-        context.result = result;
-        asyncStart?.publish(context);
-        asyncEnd?.publish(context);
+      called = true;
+      try {
+        result = next();
+        return result;
+      } catch (error) {
+        providerThrew = true;
+        providerError = error;
+        throw error;
       }
-      return start.runStores(context, () => {
-        try {
-          const result = Reflect.apply(fn, thisArg, args);
-          end?.publish(context);
-          if (result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function") {
-            if (result.constructor === Promise) {
-              return result.then(
-                (res) => {
-                  publishResolved(res);
-                  return res;
-                },
-                (err) => {
-                  publishRejected(err);
-                  return Promise.reject(err);
-                }
-              );
-            }
-            void result.then(
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              (resolved) => {
-                try {
-                  publishResolved(resolved);
-                } catch {
-                }
-              },
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              (err) => {
-                try {
-                  publishRejected(err);
-                } catch {
-                }
-              }
-            );
-            return result;
-          }
-          context.result = result;
-          asyncStart?.publish(context);
-          asyncEnd?.publish(context);
-          return result;
-        } catch (err) {
-          context.error = err;
-          error?.publish(context);
-          end?.publish(context);
-          throw err;
-        }
-      });
     };
-  }
+    try {
+      store.run(context, runNext);
+    } catch (error) {
+      if (!providerThrew || error !== providerError) {
+        reportError(error);
+      }
+    }
+    if (!called) {
+      reportError(
+        new Error("Instrumentation store did not invoke its callback")
+      );
+      return runNext();
+    }
+    if (providerThrew) {
+      throw providerError;
+    }
+    return result;
+  };
 }
-
-// src/isomorph.ts
-var DefaultAsyncLocalStorage = class {
-  constructor() {
+var HookChannel = class {
+  constructor(name) {
+    this.name = name;
   }
-  enterWith(_) {
+  name;
+  subscribers = [];
+  stores = /* @__PURE__ */ new Map();
+  get hasSubscribers() {
+    return this.subscribers.length > 0 || this.stores.size > 0;
   }
-  run(_, callback) {
-    return callback();
+  subscribe(subscription) {
+    if (typeof subscription !== "function") {
+      throw new TypeError("subscription must be a function");
+    }
+    this.subscribers = [...this.subscribers, subscription];
   }
-  getStore() {
-    return void 0;
+  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;
   }
-};
-var DefaultChannel = class {
-  constructor(name) {
-    this.name = name;
+  bindStore(store, transform) {
+    if (!store || typeof store.run !== "function") {
+      throw new TypeError("store must have a run method");
+    }
+    this.stores.set(
+      store,
+      transform
+    );
   }
-  name;
-  hasSubscribers = false;
-  subscribe(_subscription) {
+  unbindStore(store) {
+    return this.stores.delete(store);
   }
-  unsubscribe(_subscription) {
-    return false;
+  publish(message) {
+    const subscribers = this.subscribers;
+    for (const subscriber of subscribers) {
+      try {
+        subscriber(message, this.name);
+      } catch (error) {
+        reportError(error);
+      }
+    }
   }
-  bindStore(_store, _transform) {
+  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();
   }
-  unbindStore(_store) {
-    return false;
+};
+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);
   }
-  publish(_message) {
+  if (operator === "tracePromise") {
+    return hook.tracePromise(invoke, context);
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runStores(_message, fn, thisArg, ...args) {
-    return fn.apply(thisArg, args);
+  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 DefaultTracingChannel = class {
+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 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`);
+      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 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");
+    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;
   }
-  subscribe(_handlers) {
+  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() {
+  },
+  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;
   }
-  unsubscribe(_handlers) {
+  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;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  traceSync(fn, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
+}
+function hasTracingHookShape(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  tracePromise(fn, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
+  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;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  traceCallback(fn, _position, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
+}
+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/isomorph.ts
+var DefaultAsyncLocalStorage = class {
+  constructor() {
+  }
+  enterWith(_) {
+  }
+  run(_, callback) {
+    return callback();
+  }
+  getStore() {
+    return void 0;
   }
 };
 var iso = {
@@ -180,7 +678,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,
@@ -196,6 +694,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",
@@ -210,6 +711,7 @@ var INSTRUMENTATION_NAMES = {
   LANGSMITH: "langsmith",
   MASTRA: "mastra",
   MISTRAL: "mistral",
+  OLLAMA: "ollama",
   OPENAI: "openai",
   OPENAI_AGENTS: "openai-agents",
   OPENAI_CODEX: "openai-codex",
@@ -221,7 +723,7 @@ var INSTRUMENTATION_NAMES = {
 var INTERNAL_SPAN_INSTRUMENTATION_NAME = /* @__PURE__ */ Symbol.for(
   "braintrust.spanInstrumentationName"
 );
-var SDK_VERSION = true ? "3.25.0" : "0.0.0";
+var SDK_VERSION = true ? "3.27.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -341,11 +843,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,
@@ -359,11 +871,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,
@@ -451,6 +973,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 }
@@ -566,6 +1096,18 @@ var claudeAgentSDKChannels = defineChannels(
   { instrumentationName: INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK }
 );
 
+// 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/instrumentation/plugins/cursor-sdk-channels.ts
 var cursorSDKChannels = defineChannels(
   "@cursor/sdk",
@@ -642,6 +1184,46 @@ var huggingFaceChannels = defineChannels(
   { instrumentationName: INSTRUMENTATION_NAMES.HUGGINGFACE }
 );
 
+// src/instrumentation/plugins/huggingface-transformers-channels.ts
+var SUPPORTED_TASKS = /* @__PURE__ */ new Set([
+  "text-generation",
+  "text2text-generation",
+  "summarization",
+  "feature-extraction",
+  "question-answering"
+]);
+var pipelineInfo = /* @__PURE__ */ new WeakMap();
+function isSupportedHuggingFaceTransformersTask(task) {
+  return typeof task === "string" && SUPPORTED_TASKS.has(task);
+}
+function registerHuggingFaceTransformersPipeline(pipeline, task, model) {
+  if (typeof task !== "string") {
+    return;
+  }
+  const info = { task };
+  if (typeof model === "string") {
+    info.model = model;
+  }
+  pipelineInfo.set(pipeline, info);
+}
+function getHuggingFaceTransformersPipelineInfo(pipeline) {
+  return pipeline ? pipelineInfo.get(pipeline) : void 0;
+}
+var huggingFaceTransformersChannels = defineChannels(
+  "@huggingface/transformers",
+  {
+    pipeline: channel({
+      channelName: "pipeline",
+      kind: "async"
+    }),
+    pipelineCall: channel({
+      channelName: "pipeline.call",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.HUGGINGFACE }
+);
+
 // src/instrumentation/plugins/openrouter-agent-channels.ts
 var openRouterAgentChannels = defineChannels(
   "@openrouter/agent",
@@ -750,6 +1332,26 @@ var mistralChannels = defineChannels(
   { instrumentationName: INSTRUMENTATION_NAMES.MISTRAL }
 );
 
+// 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/instrumentation/plugins/google-adk-channels.ts
 var googleADKChannels = defineChannels(
   "@google/adk",
@@ -963,6 +1565,18 @@ var strandsAgentSDKChannels = defineChannels(
   { instrumentationName: INSTRUMENTATION_NAMES.STRANDS_AGENT_SDK }
 );
 
+// src/instrumentation/plugins/cloudflare-agents-channels.ts
+var cloudflareAgentsChannels = defineChannels(
+  "agents",
+  {
+    runAgentTool: channel({
+      channelName: "Agent.runAgentTool",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLOUDFLARE_AGENTS }
+);
+
 // src/instrumentation/config.ts
 var envIntegrationAliases = {
   openai: "openai",
@@ -980,6 +1594,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",
@@ -987,6 +1604,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",
@@ -1001,10 +1622,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",
@@ -1039,6 +1663,8 @@ function getDefaultInstrumentationIntegrations() {
     googleADK: true,
     huggingface: true,
     claudeAgentSDK: true,
+    cloudflareAIChat: true,
+    cloudflareThink: true,
     cursor: true,
     cursorSDK: true,
     flue: true,
@@ -1047,6 +1673,7 @@ function getDefaultInstrumentationIntegrations() {
     openrouter: true,
     openrouterAgent: true,
     mistral: true,
+    ollama: true,
     cohere: true,
     groq: true,
     bedrock: true,
@@ -1058,7 +1685,8 @@ function getDefaultInstrumentationIntegrations() {
     langgraph: true,
     langsmith: true,
     piCodingAgent: true,
-    strandsAgentSDK: true
+    strandsAgentSDK: true,
+    cloudflareAgents: true
   };
 }
 function readDisabledInstrumentationEnvConfig(disabledList) {
@@ -1291,9 +1919,29 @@ var langChainChannels = defineChannels(
   { instrumentationName: INSTRUMENTATION_NAMES.LANGCHAIN }
 );
 
+// 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 }
+);
+
 export {
   __export,
-  patchTracingChannel,
+  GLOBAL_INSTRUMENTATION_HOOKS_KEY,
+  GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+  GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND,
+  GLOBAL_INSTRUMENTATION_HOOK_BRAND,
+  setGlobalHookErrorReporter,
   isomorph_default,
   INSTRUMENTATION_NAMES,
   withSpanInstrumentationName,
@@ -1306,13 +1954,19 @@ export {
   aiSDKChannels,
   harnessAgentChannels,
   claudeAgentSDKChannels,
+  cloudflareThinkChannels,
   cursorSDKChannels,
   openAIAgentsCoreChannels,
   googleGenAIChannels,
   huggingFaceChannels,
+  isSupportedHuggingFaceTransformersTask,
+  registerHuggingFaceTransformersPipeline,
+  getHuggingFaceTransformersPipelineInfo,
+  huggingFaceTransformersChannels,
   openRouterAgentChannels,
   openRouterChannels,
   mistralChannels,
+  ollamaChannels,
   googleADKChannels,
   cohereChannels,
   groqChannels,
@@ -1327,6 +1981,8 @@ export {
   langSmithChannels,
   piCodingAgentChannels,
   strandsAgentSDKChannels,
+  cloudflareAIChatChannels,
+  cloudflareAgentsChannels,
   getDefaultInstrumentationIntegrations,
   readDisabledInstrumentationEnvConfig,
   isInstrumentationIntegrationDisabled,