braintrust 3.25.0 → 3.26.0

package/dist/auto-instrumentations/index.cjs

@@ -24,6 +24,8 @@ __export(index_exports, {
   anthropicConfigs: () => anthropicConfigs,
   bedrockRuntimeConfigs: () => bedrockRuntimeConfigs,
   claudeAgentSDKConfigs: () => claudeAgentSDKConfigs,
+  cloudflareAIChatConfigs: () => cloudflareAIChatConfigs,
+  cloudflareAgentsConfigs: () => cloudflareAgentsConfigs,
   cohereConfigs: () => cohereConfigs,
   cursorSDKConfigs: () => cursorSDKConfigs,
   genkitConfigs: () => genkitConfigs,
@@ -44,84 +46,519 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/isomorph.ts
-var DefaultAsyncLocalStorage = class {
-  constructor() {
-  }
-  enterWith(_) {
+// 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 registryBrand = Symbol.for(GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND);
+var hookBrand = Symbol.for(GLOBAL_INSTRUMENTATION_HOOK_BRAND);
+var errorReporter;
+function reportError(error) {
+  try {
+    errorReporter?.(error);
+  } catch {
   }
-  run(_, callback) {
-    return callback();
-  }
-  getStore() {
-    return void 0;
+}
+function setContextValue(context, key, value) {
+  try {
+    context[key] = value;
+  } catch (error) {
+    reportError(error);
   }
-};
-var DefaultChannel = class {
+}
+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);
+      }
+    }
+    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;
-  hasSubscribers = false;
-  subscribe(_subscription) {
+  subscribers = [];
+  stores = /* @__PURE__ */ new Map();
+  get hasSubscribers() {
+    return this.subscribers.length > 0 || this.stores.size > 0;
   }
-  unsubscribe(_subscription) {
-    return false;
+  subscribe(subscription) {
+    if (typeof subscription !== "function") {
+      throw new TypeError("subscription must be a function");
+    }
+    this.subscribers = [...this.subscribers, subscription];
   }
-  bindStore(_store, _transform) {
+  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;
   }
-  unbindStore(_store) {
-    return false;
+  bindStore(store, transform) {
+    if (!store || typeof store.run !== "function") {
+      throw new TypeError("store must have a run method");
+    }
+    this.stores.set(
+      store,
+      transform
+    );
   }
-  publish(_message) {
+  unbindStore(store) {
+    return this.stores.delete(store);
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runStores(_message, fn, thisArg, ...args) {
-    return fn.apply(thisArg, args);
+  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 DefaultTracingChannel = class {
+var traceEvents = [
+  "start",
+  "end",
+  "asyncStart",
+  "asyncEnd",
+  "error"
+];
+var TracingHook = class {
   start;
   end;
   asyncStart;
   asyncEnd;
   error;
   constructor(nameOrChannels) {
+    Object.defineProperty(this, hookBrand, {
+      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) {
+  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);
+      }
+    });
   }
-  unsubscribe(_handlers) {
+};
+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);
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  traceSync(fn, _message, thisArg, ...args) {
-    return fn.apply(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;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  tracePromise(fn, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
+  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
-  traceCallback(fn, _position, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
+}
+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 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)) {
+    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 = {
@@ -134,7 +571,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,
@@ -199,6 +636,8 @@ 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",
   COHERE: "cohere",
   CURSOR_SDK: "cursor-sdk",
   EVE: "eve",
@@ -1246,6 +1685,36 @@ var claudeAgentSDKConfigs = [
   }
 ];
 
+// 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/cursor-sdk-channels.ts
 var cursorSDKChannels = defineChannels(
   "@cursor/sdk",
@@ -2468,6 +2937,44 @@ var googleADKConfigs = [
   }
 ];
 
+// 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/cohere-channels.ts
 var cohereChannels = defineChannels(
   "cohere-ai",
@@ -3248,6 +3755,8 @@ var piCodingAgentConfigs = [
   anthropicConfigs,
   bedrockRuntimeConfigs,
   claudeAgentSDKConfigs,
+  cloudflareAIChatConfigs,
+  cloudflareAgentsConfigs,
   cohereConfigs,
   cursorSDKConfigs,
   genkitConfigs,