braintrust 3.25.0 → 3.26.0

package/dist/instrumentation/index.mjs

@@ -1,81 +1,525 @@
-// src/isomorph.ts
-var DefaultAsyncLocalStorage = class {
-  constructor() {
-  }
-  enterWith(_) {
-  }
-  run(_, callback) {
-    return callback();
+// 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 setGlobalHookErrorReporter(reporter) {
+  const previousReporter = errorReporter;
+  errorReporter = reporter;
+  return () => {
+    if (errorReporter === reporter) {
+      errorReporter = previousReporter;
+    }
+  };
+}
+function reportError(error) {
+  try {
+    errorReporter?.(error);
+  } catch {
   }
-  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];
+  }
+  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) {
+  bindStore(store, transform) {
+    if (!store || typeof store.run !== "function") {
+      throw new TypeError("store must have a run method");
+    }
+    this.stores.set(
+      store,
+      transform
+    );
   }
-  unbindStore(_store) {
-    return false;
+  unbindStore(store) {
+    return this.stores.delete(store);
   }
-  publish(_message) {
+  publish(message) {
+    const subscribers = this.subscribers;
+    for (const subscriber of subscribers) {
+      try {
+        subscriber(message, this.name);
+      } catch (error) {
+        reportError(error);
+      }
+    }
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runStores(_message, fn, thisArg, ...args) {
-    return fn.apply(thisArg, args);
+  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;
+    });
   }
-  unsubscribe(_handlers) {
+  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);
   }
-  // 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 registry2 = /* @__PURE__ */ new Map();
+  try {
+    Object.defineProperty(registry2, 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: registry2,
+      writable: false
+    });
+    return registry2;
+  } catch (error) {
+    reportError(error);
+    return void 0;
+  }
+}
+function newGlobalTracingChannel(nameOrChannels) {
+  if (typeof nameOrChannels !== "string") {
+    return new TracingHook(nameOrChannels);
+  }
+  const registry2 = getHookRegistry();
+  if (!registry2) {
+    return inertTracingHook;
+  }
+  let existing;
+  try {
+    existing = Map.prototype.get.call(registry2, 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(registry2, nameOrChannels);
+    } catch (error) {
+      reportError(error);
+      return inertTracingHook;
+    }
+  }
+  const hook = new TracingHook(nameOrChannels);
+  try {
+    Map.prototype.set.call(registry2, 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 = {
@@ -88,7 +532,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,
@@ -428,6 +872,9 @@ var debugLogger = {
     return createDebugLogger(state);
   }
 };
+setGlobalHookErrorReporter((error) => {
+  debugLogger.error("Global instrumentation hook error:", error);
+});
 
 // src/queue.ts
 var DEFAULT_QUEUE_SIZE = 15e3;
@@ -2079,7 +2526,8 @@ var ApiKey = z6.object({
   user_email: z6.union([z6.string(), z6.null()]).optional(),
   user_given_name: z6.union([z6.string(), z6.null()]).optional(),
   user_family_name: z6.union([z6.string(), z6.null()]).optional(),
-  org_id: z6.union([z6.string(), z6.null()]).optional()
+  org_id: z6.union([z6.string(), z6.null()]).optional(),
+  expires_at: z6.union([z6.string(), z6.null()]).optional()
 });
 var TriggeredFunctionState = z6.object({
   triggered_xact_id: z6.string(),
@@ -2199,6 +2647,7 @@ var TopicMapData = z6.object({
   topic_names: z6.record(z6.string()).optional(),
   generation_settings: TopicMapGenerationSettings.optional(),
   disable_reconciliation: z6.boolean().optional(),
+  reconcile_mode: z6.enum(["evolve", "names_only"]).optional(),
   distance_threshold: z6.number().optional(),
   btql_filter: z6.string().optional(),
   automation_btql_filter: z6.string().optional()
@@ -2779,7 +3228,12 @@ var ModelParams = z6.union([
   }).partial().passthrough()
 ]);
 var PromptOptionsNullish = z6.union([
-  z6.object({ model: z6.string(), params: ModelParams, position: z6.string() }).partial(),
+  z6.object({
+    model: z6.string(),
+    params: ModelParams,
+    position: z6.string(),
+    endpoint_name: z6.union([z6.string(), z6.null()])
+  }).partial(),
   z6.null()
 ]);
 var PromptParserNullish = z6.union([
@@ -2793,11 +3247,25 @@ var PromptParserNullish = z6.union([
   }),
   z6.null()
 ]);
+var PreprocessorSavedFunctionId = z6.union([
+  z6.object({
+    type: z6.literal("function"),
+    id: z6.string(),
+    version: z6.string().optional()
+  }),
+  z6.object({
+    type: z6.literal("global"),
+    name: z6.string(),
+    function_type: z6.literal("preprocessor").optional().default("preprocessor")
+  }),
+  z6.null()
+]);
 var PromptDataNullish = z6.union([
   z6.object({
     prompt: PromptBlockDataNullish,
     options: PromptOptionsNullish,
     parser: PromptParserNullish,
+    preprocessor: PreprocessorSavedFunctionId,
     tool_functions: z6.union([z6.array(SavedFunctionId), z6.null()]),
     template_format: z6.union([
       z6.enum(["mustache", "nunjucks", "none"]),
@@ -2999,6 +3467,7 @@ var PromptData = z6.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
   parser: PromptParserNullish,
+  preprocessor: PreprocessorSavedFunctionId,
   tool_functions: z6.union([z6.array(SavedFunctionId), z6.null()]),
   template_format: z6.union([
     z6.enum(["mustache", "nunjucks", "none"]),
@@ -3161,7 +3630,8 @@ var InvokeFunction = FunctionId.and(
     mode: StreamingMode,
     strict: z6.union([z6.boolean(), z6.null()]),
     mcp_auth: z6.record(z6.object({ oauth_token: z6.string() }).partial()),
-    overrides: z6.union([z6.object({}).partial().passthrough(), z6.null()])
+    overrides: z6.union([z6.object({}).partial().passthrough(), z6.null()]),
+    endpoint_name: z6.union([z6.string(), z6.null()])
   }).partial()
 );
 var MCPServer = z6.object({
@@ -3225,6 +3695,24 @@ var Organization = z6.object({
   created: z6.union([z6.string(), z6.null()]).optional(),
   image_rendering_mode: ImageRenderingMode.optional()
 });
+var RetentionObjectType = z6.enum([
+  "project_logs",
+  "experiment",
+  "dataset"
+]);
+var OrgAutomation = z6.object({
+  id: z6.string().uuid(),
+  org_id: z6.string().uuid(),
+  user_id: z6.union([z6.string(), z6.null()]).optional(),
+  created: z6.union([z6.string(), z6.null()]).optional(),
+  name: z6.string(),
+  description: z6.union([z6.string(), z6.null()]).optional(),
+  config: z6.object({
+    event_type: z6.literal("retention"),
+    object_type: RetentionObjectType,
+    retention_days: z6.number().int().gte(0)
+  })
+});
 var ProjectSettings = z6.union([
   z6.object({
     comparison_key: z6.union([z6.string(), z6.null()]),
@@ -3251,6 +3739,7 @@ var ProjectSettings = z6.union([
       z6.null()
     ]),
     disable_realtime_queries: z6.union([z6.boolean(), z6.null()]),
+    monitor_charts_use_metrics_start: z6.union([z6.boolean(), z6.null()]),
     default_preprocessor: NullableSavedFunctionId
   }).partial(),
   z6.null()
@@ -3265,11 +3754,6 @@ var Project = z6.object({
   user_id: z6.union([z6.string(), z6.null()]).optional(),
   settings: ProjectSettings.optional()
 });
-var RetentionObjectType = z6.enum([
-  "project_logs",
-  "experiment",
-  "dataset"
-]);
 var TopicAutomationFacetModel = z6.union([
   z6.enum(["brain-facet-latest", "brain-facet-1", "brain-facet-2"]),
   z6.null()
@@ -3380,7 +3864,7 @@ var ProjectAutomation = z6.object({
     z6.object({
       event_type: z6.literal("retention"),
       object_type: RetentionObjectType,
-      retention_days: z6.number().gte(0)
+      retention_days: z6.number().int().gte(0)
     }),
     z6.object({
       event_type: z6.literal("environment_update"),
@@ -3552,7 +4036,12 @@ var Prompt = z6.object({
   metadata: z6.union([z6.object({}).partial().passthrough(), z6.null()]).optional(),
   function_type: FunctionTypeEnumNullish.optional()
 });
-var PromptOptions = z6.object({ model: z6.string(), params: ModelParams, position: z6.string() }).partial();
+var PromptOptions = z6.object({
+  model: z6.string(),
+  params: ModelParams,
+  position: z6.string(),
+  endpoint_name: z6.union([z6.string(), z6.null()])
+}).partial();
 var PromptSessionEvent = z6.object({
   id: z6.string(),
   _xact_id: z6.string(),
@@ -3635,7 +4124,8 @@ var RunEval = z6.object({
   stop_token: z6.union([z6.string(), z6.null()]).optional(),
   extra_messages: z6.string().optional(),
   tags: z6.array(z6.string()).optional(),
-  mcp_auth: z6.record(z6.object({ oauth_token: z6.string() }).partial()).optional()
+  mcp_auth: z6.record(z6.object({ oauth_token: z6.string() }).partial()).optional(),
+  endpoint_name: z6.union([z6.string(), z6.null()]).optional()
 });
 var ServiceToken = z6.object({
   id: z6.string().uuid(),
@@ -3645,7 +4135,8 @@ var ServiceToken = z6.object({
   service_account_id: z6.union([z6.string(), z6.null()]).optional(),
   service_account_email: z6.union([z6.string(), z6.null()]).optional(),
   service_account_name: z6.union([z6.string(), z6.null()]).optional(),
-  org_id: z6.union([z6.string(), z6.null()]).optional()
+  org_id: z6.union([z6.string(), z6.null()]).optional(),
+  expires_at: z6.union([z6.string(), z6.null()]).optional()
 });
 var SpanIFrame = z6.object({
   id: z6.string().uuid(),
@@ -3767,6 +4258,13 @@ var ViewOptions = z6.union([
       }),
       z6.null()
     ]),
+    pointSizeMetric: z6.union([
+      z6.object({
+        type: z6.enum(["none", "score", "metric", "metadata"]),
+        value: z6.string()
+      }),
+      z6.null()
+    ]),
     xAxisAggregation: z6.union([z6.string(), z6.null()]),
     chartAnnotations: z6.union([
       z6.array(z6.object({ id: z6.string(), text: z6.string() })),
@@ -4882,6 +5380,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",
@@ -4907,7 +5407,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.26.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -5102,12 +5602,13 @@ function applyMaskingToField(maskingFunction, data, fieldName) {
 var INITIAL_SPAN_WRITE_AS_MERGE = /* @__PURE__ */ Symbol(
   "braintrust.initial-span-write-as-merge"
 );
+var INTERNAL_SPAN_CONTEXT = /* @__PURE__ */ Symbol("braintrust.internal-span-context");
 var BRAINTRUST_CURRENT_SPAN_STORE = /* @__PURE__ */ Symbol.for(
   "braintrust.currentSpanStore"
 );
 var ContextManager = class {
   /**
-   * Returns the value to store in the ALS bound to a TracingChannel's start event.
+   * Returns the value to store in the ALS bound to a global hook's start event.
    * In default mode this is the Span itself; in OTEL mode it is the OTEL Context
    * containing the span so that OTEL's own ALS stores a proper Context object.
    */
@@ -7651,6 +8152,12 @@ function _internalStartSpanWithInitialMerge(args) {
     [INITIAL_SPAN_WRITE_AS_MERGE]: true
   }).span;
 }
+function _internalStartSpanWithContext(args, context) {
+  return startSpanAndIsLogger({
+    ...args,
+    [INTERNAL_SPAN_CONTEXT]: context
+  }).span;
+}
 async function flush(options) {
   const state = options?.state ?? _globalState;
   return await state.bgLogger().flush();
@@ -8444,7 +8951,7 @@ var SpanImpl = class _SpanImpl {
         start: args.startTime ?? getCurrentUnixTimestamp()
       },
       context: mergeSpanOriginContext(
-        { ...callerLocation },
+        { ...callerLocation, ...args[INTERNAL_SPAN_CONTEXT] },
         instrumentationName,
         this._state.spanOriginEnvironment
       ),
@@ -20303,11 +20810,11 @@ function summarizeEmbedContentOutput(response) {
   };
 }
 function populateUsageMetrics(metrics, usage) {
-  if (usage.promptTokenCount !== void 0) {
-    metrics.prompt_tokens = usage.promptTokenCount;
+  if (usage.promptTokenCount !== void 0 || usage.toolUsePromptTokenCount !== void 0) {
+    metrics.prompt_tokens = (usage.promptTokenCount ?? 0) + (usage.toolUsePromptTokenCount ?? 0);
   }
-  if (usage.candidatesTokenCount !== void 0) {
-    metrics.completion_tokens = usage.candidatesTokenCount;
+  if (usage.candidatesTokenCount !== void 0 || usage.thoughtsTokenCount !== void 0) {
+    metrics.completion_tokens = (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0);
   }
   if (usage.totalTokenCount !== void 0) {
     metrics.tokens = usage.totalTokenCount;
@@ -20318,13 +20825,26 @@ function populateUsageMetrics(metrics, usage) {
   if (usage.thoughtsTokenCount !== void 0) {
     metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
   }
+  for (const detail of usage.promptTokensDetails ?? []) {
+    if (detail.modality === "AUDIO" && detail.tokenCount !== void 0) {
+      metrics.prompt_audio_tokens = (metrics.prompt_audio_tokens ?? 0) + detail.tokenCount;
+    }
+  }
+  for (const detail of usage.candidatesTokensDetails ?? []) {
+    if (detail.modality === "AUDIO" && detail.tokenCount !== void 0) {
+      metrics.completion_audio_tokens = (metrics.completion_audio_tokens ?? 0) + detail.tokenCount;
+    }
+    if (detail.modality === "IMAGE" && detail.tokenCount !== void 0) {
+      metrics.completion_image_tokens = (metrics.completion_image_tokens ?? 0) + detail.tokenCount;
+    }
+  }
 }
 function populateInteractionUsageMetrics(metrics, usage) {
   if (typeof usage.total_input_tokens === "number") {
     metrics.prompt_tokens = usage.total_input_tokens;
   }
   if (typeof usage.total_output_tokens === "number") {
-    metrics.completion_tokens = usage.total_output_tokens;
+    metrics.completion_tokens = usage.total_output_tokens + (typeof usage.total_thought_tokens === "number" ? usage.total_thought_tokens : 0);
   }
   if (typeof usage.total_tokens === "number") {
     metrics.tokens = usage.total_tokens;
@@ -20335,6 +20855,24 @@ function populateInteractionUsageMetrics(metrics, usage) {
   if (typeof usage.total_thought_tokens === "number") {
     metrics.completion_reasoning_tokens = usage.total_thought_tokens;
   }
+  for (const detail of Array.isArray(usage.input_tokens_by_modality) ? usage.input_tokens_by_modality : []) {
+    if (typeof detail?.modality === "string" && detail.modality.toLowerCase() === "audio" && typeof detail.tokens === "number") {
+      metrics.prompt_audio_tokens = (metrics.prompt_audio_tokens ?? 0) + detail.tokens;
+    }
+  }
+  for (const detail of Array.isArray(usage.output_tokens_by_modality) ? usage.output_tokens_by_modality : []) {
+    if (typeof detail?.modality !== "string" || typeof detail.tokens !== "number") {
+      continue;
+    }
+    switch (detail.modality.toLowerCase()) {
+      case "audio":
+        metrics.completion_audio_tokens = (metrics.completion_audio_tokens ?? 0) + detail.tokens;
+        break;
+      case "image":
+        metrics.completion_image_tokens = (metrics.completion_image_tokens ?? 0) + detail.tokens;
+        break;
+    }
+  }
 }
 function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
   const end = getCurrentUnixTimestamp();
@@ -21073,6 +21611,299 @@ function extractTextGenerationStreamMetadata(chunks) {
   return void 0;
 }
 
+// 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/huggingface-transformers-plugin.ts
+var REQUEST_METADATA_KEYS = [
+  "temperature",
+  "top_p",
+  "max_tokens",
+  "stop"
+];
+var HuggingFaceTransformersPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToPipelineFactory();
+    this.unsubscribers.push(
+      traceAsyncChannel(huggingFaceTransformersChannels.pipelineCall, {
+        name: (_args, event) => {
+          const task = getTask(event);
+          const operation = task?.replaceAll("-", "_") ?? "unknown";
+          return `huggingface.transformers.${operation}`;
+        },
+        type: "llm" /* LLM */,
+        shouldTrace: (_args, event) => isSupportedHuggingFaceTransformersTask(
+          getTask(event)
+        ),
+        extractInput: (args, event) => ({
+          input: extractInput(
+            getTask(event),
+            args
+          ),
+          metadata: extractMetadata(
+            event,
+            args
+          )
+        }),
+        extractOutput: (result, event) => extractOutput(
+          getTask(event),
+          result
+        ),
+        extractMetrics: () => ({})
+      })
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToPipelineFactory() {
+    const channel2 = huggingFaceTransformersChannels.pipeline.tracingChannel();
+    const handlers = {
+      asyncEnd: (event) => {
+        if (typeof event.result !== "function") {
+          return;
+        }
+        registerHuggingFaceTransformersPipeline(
+          event.result,
+          event.arguments?.[0],
+          event.arguments?.[1]
+        );
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => channel2.unsubscribe(handlers));
+  }
+};
+function getTask(event) {
+  const self = event.self;
+  const registeredTask = getHuggingFaceTransformersPipelineInfo(self)?.task;
+  if (registeredTask !== void 0) {
+    return registeredTask;
+  }
+  if (typeof self?.task === "string") {
+    return self.task;
+  }
+  return void 0;
+}
+function extractMetadata(event, args) {
+  const metadata = {
+    provider: "huggingface"
+  };
+  const registeredModel = getHuggingFaceTransformersPipelineInfo(
+    event.self
+  )?.model;
+  const model = registeredModel ?? modelIdentifier(event.self);
+  if (model) {
+    metadata.model = model;
+  }
+  const task = getTask(event);
+  const options = task === "question-answering" ? args[2] : args[1];
+  if (isObject(options)) {
+    for (const key of REQUEST_METADATA_KEYS) {
+      if (options[key] !== void 0) {
+        metadata[key] = options[key];
+      }
+    }
+  }
+  return metadata;
+}
+function modelIdentifier(pipeline) {
+  const model = pipeline?.model;
+  if (!isObject(model)) {
+    return void 0;
+  }
+  const config = isObject(model.config) ? model.config : void 0;
+  for (const value of [
+    config?._name_or_path,
+    config?.name_or_path,
+    config?.model_id,
+    config?.modelId,
+    model.name
+  ]) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function extractInput(task, args) {
+  switch (task) {
+    case "feature-extraction":
+      return args[0];
+    case "question-answering": {
+      const question = args[0];
+      const context = args[1];
+      if (Array.isArray(question) && Array.isArray(context) && question.every((value) => typeof value === "string") && context.every((value) => typeof value === "string")) {
+        return question.map((value, index) => [
+          {
+            role: "user",
+            content: `Context:
+${context[index] ?? ""}
+
+Question:
+${value}`
+          }
+        ]);
+      }
+      if (typeof question === "string" && typeof context === "string") {
+        return [
+          {
+            role: "user",
+            content: `Context:
+${context}
+
+Question:
+${question}`
+          }
+        ];
+      }
+      return { context, question };
+    }
+  }
+  const input = args[0];
+  if (task === "text-generation" && isChat(input)) {
+    return input;
+  }
+  if (task === "text-generation" && Array.isArray(input) && input.every(isChat)) {
+    return input;
+  }
+  if (typeof input === "string") {
+    return [{ role: "user", content: input }];
+  }
+  if (Array.isArray(input) && input.every((value) => typeof value === "string")) {
+    return input.map((value) => [
+      {
+        role: "user",
+        content: value
+      }
+    ]);
+  }
+  return input;
+}
+function isChat(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(
+    (message) => isObject(message) && typeof message.role === "string" && "content" in message
+  );
+}
+function extractOutput(task, result) {
+  switch (task) {
+    case "feature-extraction":
+      return summarizeEmbedding(result);
+    case "question-answering":
+      return choicesFromAnswers(result);
+    default:
+      return choicesFromGenerations(result);
+  }
+}
+function summarizeEmbedding(result) {
+  if (!isObject(result) || !Array.isArray(result.dims)) {
+    return void 0;
+  }
+  const { dims } = result;
+  if (dims.length === 0 || !dims.every((dimension) => typeof dimension === "number")) {
+    return void 0;
+  }
+  if (dims.length === 1) {
+    return { embedding_length: dims[0] };
+  }
+  if (dims.length === 2) {
+    return {
+      embedding_count: dims[0],
+      embedding_length: dims[1]
+    };
+  }
+  return {
+    embedding_batch_count: dims[0],
+    embedding_count: dims[1],
+    embedding_length: dims.at(-1) ?? 0
+  };
+}
+function choicesFromAnswers(result) {
+  const answers = Array.isArray(result) ? result.flat() : [result];
+  const choices = answers.flatMap((answer, index) => {
+    if (!isObject(answer) || typeof answer.answer !== "string") {
+      return [];
+    }
+    return [
+      {
+        index,
+        finish_reason: "stop",
+        message: {
+          role: "assistant",
+          content: answer.answer
+        }
+      }
+    ];
+  });
+  return choices.length > 0 ? choices : void 0;
+}
+function choicesFromGenerations(result) {
+  const generations = Array.isArray(result) ? result.flat() : [result];
+  const choices = generations.flatMap((generation, index) => {
+    if (!isObject(generation)) {
+      return [];
+    }
+    const generated = generation.generated_text ?? generation.summary_text;
+    let content;
+    if (typeof generated === "string") {
+      content = generated;
+    } else if (isChat(generated)) {
+      content = generated.at(-1)?.content;
+    }
+    if (typeof content !== "string") {
+      return [];
+    }
+    return [
+      {
+        index,
+        finish_reason: "stop",
+        message: {
+          role: "assistant",
+          content
+        }
+      }
+    ];
+  });
+  return choices.length > 0 ? choices : void 0;
+}
+
 // src/instrumentation/plugins/openrouter-agent-channels.ts
 var openRouterAgentChannels = defineChannels(
   "@openrouter/agent",
@@ -24238,15 +25069,32 @@ function aggregateUsageFromEvents(events) {
     if (usage.thoughtsTokenCount !== void 0) {
       aggregated.thoughtsTokenCount = (aggregated.thoughtsTokenCount ?? 0) + usage.thoughtsTokenCount;
     }
+    if (usage.toolUsePromptTokenCount !== void 0) {
+      aggregated.toolUsePromptTokenCount = (aggregated.toolUsePromptTokenCount ?? 0) + usage.toolUsePromptTokenCount;
+    }
+    for (const detailsField of [
+      "promptTokensDetails",
+      "cacheTokensDetails",
+      "candidatesTokensDetails",
+      "toolUsePromptTokensDetails"
+    ]) {
+      const details = usage[detailsField];
+      if (details !== void 0) {
+        aggregated[detailsField] = [
+          ...aggregated[detailsField] ?? [],
+          ...details
+        ];
+      }
+    }
   }
   return hasUsage ? aggregated : void 0;
 }
 function populateUsageMetrics2(metrics, usage) {
-  if (usage.promptTokenCount !== void 0) {
-    metrics.prompt_tokens = usage.promptTokenCount;
+  if (usage.promptTokenCount !== void 0 || usage.toolUsePromptTokenCount !== void 0) {
+    metrics.prompt_tokens = (usage.promptTokenCount ?? 0) + (usage.toolUsePromptTokenCount ?? 0);
   }
-  if (usage.candidatesTokenCount !== void 0) {
-    metrics.completion_tokens = usage.candidatesTokenCount;
+  if (usage.candidatesTokenCount !== void 0 || usage.thoughtsTokenCount !== void 0) {
+    metrics.completion_tokens = (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0);
   }
   if (usage.totalTokenCount !== void 0) {
     metrics.tokens = usage.totalTokenCount;
@@ -24257,6 +25105,19 @@ function populateUsageMetrics2(metrics, usage) {
   if (usage.thoughtsTokenCount !== void 0) {
     metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
   }
+  for (const detail of usage.promptTokensDetails ?? []) {
+    if (detail.modality === "AUDIO" && detail.tokenCount !== void 0) {
+      metrics.prompt_audio_tokens = (metrics.prompt_audio_tokens ?? 0) + detail.tokenCount;
+    }
+  }
+  for (const detail of usage.candidatesTokensDetails ?? []) {
+    if (detail.modality === "AUDIO" && detail.tokenCount !== void 0) {
+      metrics.completion_audio_tokens = (metrics.completion_audio_tokens ?? 0) + detail.tokenCount;
+    }
+    if (detail.modality === "IMAGE" && detail.tokenCount !== void 0) {
+      metrics.completion_image_tokens = (metrics.completion_image_tokens ?? 0) + detail.tokenCount;
+    }
+  }
 }
 function cleanMetrics4(metrics) {
   const cleaned = {};
@@ -28622,7 +29483,7 @@ var LangSmithPlugin = class extends BasePlugin {
     const inputs = preferOwnValue(run, previous, "inputs");
     const outputs = preferOwnValue(run, previous, "outputs");
     const error = errorMessage(preferOwnValue(run, previous, "error"));
-    const metadata = extractMetadata(run, previous);
+    const metadata = extractMetadata2(run, previous);
     const tags = extractTags(preferOwnValue(run, previous, "tags"));
     const metrics = extractMetrics(run, previous);
     span.log({
@@ -28727,7 +29588,7 @@ function mapRunType(runType) {
       return "task" /* TASK */;
   }
 }
-function extractMetadata(run, previous) {
+function extractMetadata2(run, previous) {
   const extra = preferOwnValue(run, previous, "extra");
   const rawMetadata = ownValue(extra, "metadata");
   if (!isRecord2(rawMetadata)) {
@@ -30100,6 +30961,15 @@ function handleMultiAgentStreamEvent(state, event, activeChildParents) {
     logInstrumentationError5("Strands Agent SDK multi-agent event", error);
   }
 }
+function buildModelSpanInput(event, attachmentCache) {
+  const systemPrompt = typeof event.agent?.systemPrompt === "string" && event.agent.systemPrompt.length > 0 ? event.agent.systemPrompt : void 0;
+  const processedMessages = Array.isArray(event.agent?.messages) ? processStrandsInputAttachments(event.agent.messages, attachmentCache) : void 0;
+  if (!systemPrompt) {
+    return processedMessages;
+  }
+  const systemMessage = { role: "system", content: systemPrompt };
+  return Array.isArray(processedMessages) ? [systemMessage, ...processedMessages] : [systemMessage];
+}
 function startModelSpan(state, event) {
   if (state.activeModel) {
     finalizeModelSpan(state);
@@ -30117,10 +30987,7 @@ function startModelSpan(state, event) {
       withSpanInstrumentationName(
         {
           event: {
-            input: Array.isArray(event.agent?.messages) ? processStrandsInputAttachments(
-              event.agent.messages,
-              state.attachmentCache
-            ) : void 0,
+            input: buildModelSpanInput(event, state.attachmentCache),
             metadata
           },
           name: formatModelSpanName(model),
@@ -30760,6 +31627,532 @@ function logInstrumentationError5(context, error) {
   debugLogger.debug(`${context}:`, error);
 }
 
+// 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/instrumentation/plugins/cloudflare-ai-chat-instrumentation.ts
+var wrappedResponseHooks = /* @__PURE__ */ new WeakSet();
+function instrumentCloudflareAIChatResponseHook(agent) {
+  try {
+    const original = Reflect.get(agent, "onChatResponse");
+    if (typeof original !== "function" || wrappedResponseHooks.has(original)) {
+      return;
+    }
+    const wrapped = function(result) {
+      const args = [result];
+      return cloudflareAIChatChannels.onChatResponse.traceSync(
+        () => Reflect.apply(original, this, args),
+        {
+          arguments: args,
+          self: this
+        }
+      );
+    };
+    wrappedResponseHooks.add(wrapped);
+    defineWrappedMethod(agent, "onChatResponse", original, wrapped);
+  } catch (error) {
+    debugLogger.debug(
+      "Failed to wrap @cloudflare/ai-chat response hook:",
+      error
+    );
+  }
+}
+function defineWrappedMethod(target, property, original, wrapped) {
+  const ownDescriptor = Object.getOwnPropertyDescriptor(target, property);
+  Object.defineProperty(target, property, {
+    configurable: ownDescriptor?.configurable ?? true,
+    enumerable: ownDescriptor?.enumerable ?? false,
+    value: wrapped,
+    writable: ownDescriptor && "writable" in ownDescriptor ? ownDescriptor.writable : true
+  });
+  try {
+    Object.defineProperty(wrapped, "name", {
+      configurable: true,
+      value: original.name
+    });
+  } catch {
+  }
+}
+
+// src/instrumentation/plugins/cloudflare-ai-chat-plugin.ts
+var BLOCKED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var RESPONSE_STATE_RETENTION_MS = 6e4;
+var CloudflareAIChatPlugin = class extends BasePlugin {
+  activeStates = /* @__PURE__ */ new Set();
+  activeTurns = /* @__PURE__ */ new WeakMap();
+  eventStates = /* @__PURE__ */ new WeakMap();
+  onEnable() {
+    this.subscribeToResponseHook();
+    this.subscribeToTurnRunner();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    for (const state of this.activeStates) {
+      this.cleanupState(state);
+    }
+    this.activeStates.clear();
+  }
+  subscribeToTurnRunner() {
+    const tracingChannel = cloudflareAIChatChannels.runExclusiveChatTurn.tracingChannel();
+    const unbindCurrentSpanStore = this.bindCurrentSpanStore(tracingChannel);
+    const handlers = {
+      start: (event) => {
+        this.ensureEventState(event);
+      },
+      asyncEnd: (event) => {
+        this.finishEvent(event);
+      },
+      error: (event) => {
+        this.finishEvent(event, event.error);
+      }
+    };
+    tracingChannel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel.unsubscribe(handlers);
+    });
+  }
+  subscribeToResponseHook() {
+    const tracingChannel = cloudflareAIChatChannels.onChatResponse.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        let state;
+        try {
+          const agent = asObject(event.self);
+          const result = event.arguments[0];
+          state = agent ? this.findResponseState(
+            agent,
+            stringValue3(ownValue2(result, "requestId"))
+          ) : void 0;
+          if (!state) {
+            return;
+          }
+          state.responseObserved = true;
+          const output = serializeMessage(ownValue2(result, "message"));
+          const status = stringValue3(ownValue2(result, "status"));
+          const error = ownValue2(result, "error");
+          const input = ownValue2(result, "continuation") === true ? state.input : serializeMessages(readProperty(agent, "messages"))?.filter(
+            (message) => typeof output?.id !== "string" || message.id !== output.id
+          );
+          state.span.log({
+            ...input !== void 0 ? { input } : {},
+            ...output !== void 0 ? { output } : {},
+            ...status === "error" && error !== void 0 ? { error } : {}
+          });
+        } catch (error) {
+          debugLogger.debug(
+            "Failed to process @cloudflare/ai-chat response hook:",
+            error
+          );
+        } finally {
+          if (state?.settled) {
+            this.cleanupState(state);
+          }
+        }
+      }
+    };
+    tracingChannel.subscribe(handlers);
+    this.unsubscribers.push(() => tracingChannel.unsubscribe(handlers));
+  }
+  bindCurrentSpanStore(tracingChannel) {
+    const globalState = _internalGetGlobalState();
+    const contextManager = globalState?.contextManager;
+    const startChannel = tracingChannel.start;
+    const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+    if (!startChannel || !currentSpanStore || !contextManager) {
+      return void 0;
+    }
+    startChannel.bindStore(currentSpanStore, (event) => {
+      const state = this.ensureEventState(event);
+      return state ? contextManager.wrapSpanForStore(state.span) : currentSpanStore.getStore();
+    });
+    return () => startChannel.unbindStore(currentSpanStore);
+  }
+  ensureEventState(event) {
+    const eventKey = event;
+    const known = this.eventStates.get(eventKey);
+    if (known) {
+      return known;
+    }
+    try {
+      const agent = asObject(event.self);
+      const requestId = stringValue3(event.arguments[0]);
+      const key = requestId ?? /* @__PURE__ */ Symbol("cloudflare-ai-chat-turn");
+      const activeForAgent = agent ? this.getActiveTurns(agent) : void 0;
+      const existing = activeForAgent?.get(key);
+      const state = existing && !existing.settled ? existing : this.createTurnState(agent, key);
+      if (existing && !existing.settled) {
+        state.depth += 1;
+      }
+      this.eventStates.set(eventKey, state);
+      this.bindTurnCallback(event, agent, state);
+      if (agent) {
+        instrumentCloudflareAIChatResponseHook(agent);
+      }
+      return state;
+    } catch (error) {
+      debugLogger.debug(
+        "Failed to start @cloudflare/ai-chat instrumentation:",
+        error
+      );
+      return void 0;
+    }
+  }
+  createTurnState(agent, key) {
+    const span = startSpan(
+      withSpanInstrumentationName(
+        {
+          name: "AIChatAgent.onChatMessage",
+          spanAttributes: { type: "task" /* TASK */ }
+        },
+        INSTRUMENTATION_NAMES.CLOUDFLARE_AI_CHAT
+      )
+    );
+    const state = {
+      agent,
+      depth: 1,
+      ended: false,
+      key,
+      responseObserved: false,
+      settled: false,
+      span
+    };
+    this.activeStates.add(state);
+    if (agent) {
+      this.getActiveTurns(agent).set(key, state);
+    }
+    return state;
+  }
+  bindTurnCallback(event, agent, state) {
+    const callback = event.arguments[1];
+    if (typeof callback !== "function") {
+      return;
+    }
+    try {
+      event.arguments[1] = function(...args) {
+        return withCurrent(state.span, () => {
+          try {
+            const input = serializeMessages(readProperty(agent, "messages"));
+            if (input !== void 0 && state.input === void 0) {
+              state.input = input;
+              state.span.log({ input });
+            }
+          } catch (error) {
+            debugLogger.debug(
+              "Failed to capture @cloudflare/ai-chat messages:",
+              error
+            );
+          }
+          return Reflect.apply(callback, this, args);
+        });
+      };
+    } catch (error) {
+      debugLogger.debug(
+        "Failed to bind @cloudflare/ai-chat turn callback context:",
+        error
+      );
+    }
+  }
+  finishEvent(event, error) {
+    const eventKey = event;
+    const state = this.eventStates.get(eventKey);
+    if (!state || state.ended) {
+      return;
+    }
+    this.eventStates.delete(eventKey);
+    if (error !== void 0 && state.pendingError === void 0) {
+      state.pendingError = error;
+    }
+    state.depth -= 1;
+    if (state.depth === 0) {
+      state.settled = true;
+      this.endState(state);
+      if (state.responseObserved || error !== void 0) {
+        this.cleanupState(state);
+      } else {
+        state.cleanupTimer = setTimeout(
+          () => this.cleanupState(state),
+          RESPONSE_STATE_RETENTION_MS
+        );
+        if (typeof state.cleanupTimer === "object" && state.cleanupTimer !== null && "unref" in state.cleanupTimer && typeof state.cleanupTimer.unref === "function") {
+          state.cleanupTimer.unref();
+        }
+      }
+    }
+  }
+  endState(state) {
+    if (state.ended) {
+      return;
+    }
+    state.ended = true;
+    try {
+      if (state.pendingError !== void 0) {
+        state.span.log({ error: state.pendingError });
+      }
+    } finally {
+      state.span.end();
+    }
+  }
+  cleanupState(state) {
+    if (state.cleanupTimer !== void 0) {
+      clearTimeout(state.cleanupTimer);
+      state.cleanupTimer = void 0;
+    }
+    try {
+      this.endState(state);
+    } finally {
+      this.activeStates.delete(state);
+      if (state.agent) {
+        const activeForAgent = this.activeTurns.get(state.agent);
+        if (activeForAgent?.get(state.key) === state) {
+          activeForAgent.delete(state.key);
+        }
+      }
+    }
+  }
+  getActiveTurns(agent) {
+    let turns = this.activeTurns.get(agent);
+    if (!turns) {
+      turns = /* @__PURE__ */ new Map();
+      this.activeTurns.set(agent, turns);
+    }
+    return turns;
+  }
+  findResponseState(agent, requestId) {
+    const turns = this.activeTurns.get(agent);
+    if (!turns) {
+      return void 0;
+    }
+    if (requestId !== void 0) {
+      return turns.get(requestId);
+    }
+    const active = [...turns.values()];
+    return active.length === 1 ? active[0] : void 0;
+  }
+};
+function asObject(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") ? value : void 0;
+}
+function readProperty(value, key) {
+  const object = asObject(value);
+  return object ? Reflect.get(object, key) : void 0;
+}
+function ownValue2(value, key) {
+  const object = asObject(value);
+  if (!object) {
+    return void 0;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(object, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function stringValue3(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function serializeMessages(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.flatMap((message) => {
+    const serialized = serializeMessage(message);
+    return serialized === void 0 ? [] : [serialized];
+  });
+}
+function serializeMessage(value) {
+  const message = asObject(value);
+  if (!message) {
+    return void 0;
+  }
+  const serialized = [];
+  const id = ownValue2(message, "id");
+  const role = ownValue2(message, "role");
+  const parts = ownValue2(message, "parts");
+  if (typeof id === "string") {
+    serialized.push(["id", id]);
+  }
+  if (typeof role === "string") {
+    serialized.push(["role", role]);
+  }
+  const sanitizedParts = sanitizeLoggedValue2(parts);
+  if (sanitizedParts !== void 0) {
+    serialized.push(["parts", sanitizedParts]);
+  }
+  return serialized.length > 0 ? Object.fromEntries(serialized) : void 0;
+}
+function sanitizeLoggedValue2(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  const object = asObject(value);
+  if (!object || depth >= 20 || typeof value === "function") {
+    return void 0;
+  }
+  if (seen.has(object)) {
+    return "[Circular]";
+  }
+  seen.add(object);
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeLoggedValue2(entry, seen, depth + 1));
+  }
+  const entries = [];
+  for (const [key, descriptor] of Object.entries(
+    Object.getOwnPropertyDescriptors(object)
+  )) {
+    if (BLOCKED_KEYS.has(key) || !descriptor.enumerable || !("value" in descriptor)) {
+      continue;
+    }
+    const sanitized = sanitizeLoggedValue2(descriptor.value, seen, depth + 1);
+    if (sanitized !== void 0) {
+      entries.push([key, sanitized]);
+    }
+  }
+  return Object.fromEntries(entries);
+}
+
+// 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/plugins/cloudflare-agents-plugin.ts
+var CLOUDFLARE_WORKERS_CONTEXT = {
+  span_origin: {
+    environment: { type: "server", name: "cloudflare_workers" }
+  }
+};
+var CloudflareAgentsPlugin = class extends BasePlugin {
+  onEnable() {
+    const channel2 = cloudflareAgentsChannels.runAgentTool.tracingChannel();
+    const spans = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        try {
+          const agentClass = event.arguments[0];
+          const options = event.arguments[1];
+          if (ownValue3(options, "detached")) {
+            return;
+          }
+          const name = ownValue3(agentClass, "name");
+          if (typeof name !== "string" || name.length === 0) {
+            debugLogger.warn(
+              "Skipping Cloudflare Agents runAgentTool span because the child agent class has no name."
+            );
+            return;
+          }
+          const span = _internalStartSpanWithContext(
+            withSpanInstrumentationName(
+              {
+                name,
+                spanAttributes: { type: "tool" /* TOOL */ },
+                event: {
+                  input: ownValue3(options, "input")
+                }
+              },
+              INSTRUMENTATION_NAMES.CLOUDFLARE_AGENTS
+            ),
+            CLOUDFLARE_WORKERS_CONTEXT
+          );
+          spans.set(event, span);
+        } catch (error) {
+          logInstrumentationError6("start", error);
+        }
+      },
+      asyncEnd: (event) => {
+        const span = spans.get(event);
+        if (!span) {
+          return;
+        }
+        spans.delete(event);
+        try {
+          const status = ownValue3(event.result, "status");
+          if (status === "completed") {
+            span.log({ output: ownValue3(event.result, "output") });
+          } else {
+            const error = ownValue3(event.result, "error");
+            if (typeof error === "string") {
+              span.log({ error });
+            }
+          }
+        } catch (error) {
+          logInstrumentationError6("completion", error);
+        } finally {
+          safelyEndSpan(span);
+        }
+      },
+      error: (event) => {
+        const span = spans.get(event);
+        if (!span) {
+          return;
+        }
+        spans.delete(event);
+        try {
+          span.log({ error: event.error });
+        } catch (error) {
+          logInstrumentationError6("rejection", error);
+        } finally {
+          safelyEndSpan(span);
+        }
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => channel2.unsubscribe(handlers));
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+};
+function ownValue3(value, key) {
+  if (!isObjectLike2(value)) {
+    return void 0;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function isObjectLike2(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function safelyEndSpan(span) {
+  try {
+    span.end();
+  } catch (error) {
+    logInstrumentationError6("span end", error);
+  }
+}
+function logInstrumentationError6(operation, error) {
+  debugLogger.error(
+    `Failed to process Cloudflare Agents ${operation} instrumentation:`,
+    error
+  );
+}
+
 // src/instrumentation/braintrust-plugin.ts
 var BraintrustPlugin = class extends BasePlugin {
   config;
@@ -30772,6 +32165,7 @@ var BraintrustPlugin = class extends BasePlugin {
   openAIAgentsPlugin = null;
   googleGenAIPlugin = null;
   huggingFacePlugin = null;
+  huggingFaceTransformersPlugin = null;
   openRouterPlugin = null;
   openRouterAgentPlugin = null;
   mistralPlugin = null;
@@ -30786,6 +32180,8 @@ var BraintrustPlugin = class extends BasePlugin {
   langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
+  cloudflareAIChatPlugin = null;
+  cloudflareAgentsPlugin = null;
   constructor(config = {}) {
     super();
     this.config = config;
@@ -30827,6 +32223,8 @@ var BraintrustPlugin = class extends BasePlugin {
     if (integrations.huggingface !== false) {
       this.huggingFacePlugin = new HuggingFacePlugin();
       this.huggingFacePlugin.enable();
+      this.huggingFaceTransformersPlugin = new HuggingFaceTransformersPlugin();
+      this.huggingFaceTransformersPlugin.enable();
     }
     if (integrations.openrouter !== false) {
       this.openRouterPlugin = new OpenRouterPlugin();
@@ -30872,6 +32270,14 @@ var BraintrustPlugin = class extends BasePlugin {
       this.strandsAgentSDKPlugin = new StrandsAgentSDKPlugin();
       this.strandsAgentSDKPlugin.enable();
     }
+    if (integrations.cloudflareAIChat !== false) {
+      this.cloudflareAIChatPlugin = new CloudflareAIChatPlugin();
+      this.cloudflareAIChatPlugin.enable();
+    }
+    if (integrations.cloudflareAgents !== false) {
+      this.cloudflareAgentsPlugin = new CloudflareAgentsPlugin();
+      this.cloudflareAgentsPlugin.enable();
+    }
     if (integrations.flue !== false) {
       this.fluePlugin = new FluePlugin();
       this.fluePlugin.enable();
@@ -30924,6 +32330,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.huggingFacePlugin.disable();
       this.huggingFacePlugin = null;
     }
+    if (this.huggingFaceTransformersPlugin) {
+      this.huggingFaceTransformersPlugin.disable();
+      this.huggingFaceTransformersPlugin = null;
+    }
     if (this.openRouterPlugin) {
       this.openRouterPlugin.disable();
       this.openRouterPlugin = null;
@@ -30968,6 +32378,14 @@ var BraintrustPlugin = class extends BasePlugin {
       this.strandsAgentSDKPlugin.disable();
       this.strandsAgentSDKPlugin = null;
     }
+    if (this.cloudflareAIChatPlugin) {
+      this.cloudflareAIChatPlugin.disable();
+      this.cloudflareAIChatPlugin = null;
+    }
+    if (this.cloudflareAgentsPlugin) {
+      this.cloudflareAgentsPlugin.disable();
+      this.cloudflareAgentsPlugin = null;
+    }
     if (this.fluePlugin) {
       this.fluePlugin.disable();
       this.fluePlugin = null;
@@ -32651,6 +34069,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",
@@ -32658,6 +34079,9 @@ var envIntegrationAliases = {
   vercel: "vercel",
   claudeagentsdk: "claudeAgentSDK",
   "claude-agent-sdk": "claudeAgentSDK",
+  cloudflareaichat: "cloudflareAIChat",
+  "cloudflare-ai-chat": "cloudflareAIChat",
+  "@cloudflare/ai-chat": "cloudflareAIChat",
   cursor: "cursor",
   "cursor-sdk": "cursorSDK",
   cursorsdk: "cursorSDK",
@@ -32672,6 +34096,8 @@ var envIntegrationAliases = {
   "google-genai": "googleGenAI",
   googlegenai: "googleGenAI",
   huggingface: "huggingface",
+  "@huggingface/transformers": "huggingface",
+  transformers: "huggingface",
   openrouter: "openrouter",
   openrouteragent: "openrouterAgent",
   "openrouter-agent": "openrouterAgent",
@@ -32710,6 +34136,7 @@ function getDefaultInstrumentationIntegrations() {
     googleADK: true,
     huggingface: true,
     claudeAgentSDK: true,
+    cloudflareAIChat: true,
     cursor: true,
     cursorSDK: true,
     flue: true,
@@ -32729,7 +34156,8 @@ function getDefaultInstrumentationIntegrations() {
     langgraph: true,
     langsmith: true,
     piCodingAgent: true,
-    strandsAgentSDK: true
+    strandsAgentSDK: true,
+    cloudflareAgents: true
   };
 }
 function readDisabledInstrumentationEnvConfig(disabledList) {
@@ -32747,7 +34175,9 @@ function readDisabledInstrumentationEnvConfig(disabledList) {
 }
 
 // src/instrumentation/registry.ts
-var REGISTRY_STATE_KEY = /* @__PURE__ */ Symbol.for("braintrust.registry");
+var REGISTRY_STATE_KEY = /* @__PURE__ */ Symbol.for(
+  `braintrust.registry.global-hooks.v${GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION}`
+);
 function getSharedState() {
   const state = globalThis[/* @__PURE__ */ Symbol.for("braintrust-state")];
   return state && typeof state === "object" ? state : void 0;