braintrust 3.25.0 → 3.26.0

package/dist/browser.js

@@ -177,6 +177,8 @@ __export(browser_exports, {
   wrapAnthropic: () => wrapAnthropic,
   wrapBedrockRuntime: () => wrapBedrockRuntime,
   wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
+  wrapCloudflareAIChat: () => wrapCloudflareAIChat,
+  wrapCloudflareAgent: () => wrapCloudflareAgent,
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
@@ -185,6 +187,7 @@ __export(browser_exports, {
   wrapGoogleGenAI: () => wrapGoogleGenAI,
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
+  wrapHuggingFaceTransformers: () => wrapHuggingFaceTransformers,
   wrapLangSmithClient: () => wrapLangSmithClient,
   wrapLangSmithRunTrees: () => wrapLangSmithRunTrees,
   wrapLangSmithTraceable: () => wrapLangSmithTraceable,
@@ -202,87 +205,528 @@ __export(browser_exports, {
 });
 module.exports = __toCommonJS(browser_exports);
 
-// src/browser/config.ts
-var import_dc_browser = require("dc-browser");
-
-// 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];
   }
-  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;
   }
-  unsubscribe(_handlers) {
+  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 reject2 = (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, reject2]);
+        }
+        Reflect.apply(then, result, [
+          resolve,
+          (error) => {
+            try {
+              reject2(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);
   }
-  // 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 = {
@@ -295,7 +739,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,
@@ -415,6 +859,9 @@ var debugLogger = {
     return createDebugLogger(state);
   }
 };
+setGlobalHookErrorReporter((error) => {
+  debugLogger.error("Global instrumentation hook error:", error);
+});
 
 // src/queue.ts
 var DEFAULT_QUEUE_SIZE = 15e3;
@@ -2199,7 +2646,8 @@ var ApiKey = import_v36.z.object({
   user_email: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   user_given_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   user_family_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
-  org_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
+  org_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  expires_at: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
 });
 var TriggeredFunctionState = import_v36.z.object({
   triggered_xact_id: import_v36.z.string(),
@@ -2319,6 +2767,7 @@ var TopicMapData = import_v36.z.object({
   topic_names: import_v36.z.record(import_v36.z.string()).optional(),
   generation_settings: TopicMapGenerationSettings.optional(),
   disable_reconciliation: import_v36.z.boolean().optional(),
+  reconcile_mode: import_v36.z.enum(["evolve", "names_only"]).optional(),
   distance_threshold: import_v36.z.number().optional(),
   btql_filter: import_v36.z.string().optional(),
   automation_btql_filter: import_v36.z.string().optional()
@@ -2899,7 +3348,12 @@ var ModelParams = import_v36.z.union([
   }).partial().passthrough()
 ]);
 var PromptOptionsNullish = import_v36.z.union([
-  import_v36.z.object({ model: import_v36.z.string(), params: ModelParams, position: import_v36.z.string() }).partial(),
+  import_v36.z.object({
+    model: import_v36.z.string(),
+    params: ModelParams,
+    position: import_v36.z.string(),
+    endpoint_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()])
+  }).partial(),
   import_v36.z.null()
 ]);
 var PromptParserNullish = import_v36.z.union([
@@ -2913,11 +3367,25 @@ var PromptParserNullish = import_v36.z.union([
   }),
   import_v36.z.null()
 ]);
+var PreprocessorSavedFunctionId = import_v36.z.union([
+  import_v36.z.object({
+    type: import_v36.z.literal("function"),
+    id: import_v36.z.string(),
+    version: import_v36.z.string().optional()
+  }),
+  import_v36.z.object({
+    type: import_v36.z.literal("global"),
+    name: import_v36.z.string(),
+    function_type: import_v36.z.literal("preprocessor").optional().default("preprocessor")
+  }),
+  import_v36.z.null()
+]);
 var PromptDataNullish = import_v36.z.union([
   import_v36.z.object({
     prompt: PromptBlockDataNullish,
     options: PromptOptionsNullish,
     parser: PromptParserNullish,
+    preprocessor: PreprocessorSavedFunctionId,
     tool_functions: import_v36.z.union([import_v36.z.array(SavedFunctionId), import_v36.z.null()]),
     template_format: import_v36.z.union([
       import_v36.z.enum(["mustache", "nunjucks", "none"]),
@@ -3119,6 +3587,7 @@ var PromptData = import_v36.z.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
   parser: PromptParserNullish,
+  preprocessor: PreprocessorSavedFunctionId,
   tool_functions: import_v36.z.union([import_v36.z.array(SavedFunctionId), import_v36.z.null()]),
   template_format: import_v36.z.union([
     import_v36.z.enum(["mustache", "nunjucks", "none"]),
@@ -3281,7 +3750,8 @@ var InvokeFunction = FunctionId.and(
     mode: StreamingMode,
     strict: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
     mcp_auth: import_v36.z.record(import_v36.z.object({ oauth_token: import_v36.z.string() }).partial()),
-    overrides: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()])
+    overrides: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]),
+    endpoint_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()])
   }).partial()
 );
 var MCPServer = import_v36.z.object({
@@ -3345,6 +3815,24 @@ var Organization = import_v36.z.object({
   created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   image_rendering_mode: ImageRenderingMode.optional()
 });
+var RetentionObjectType = import_v36.z.enum([
+  "project_logs",
+  "experiment",
+  "dataset"
+]);
+var OrgAutomation = import_v36.z.object({
+  id: import_v36.z.string().uuid(),
+  org_id: import_v36.z.string().uuid(),
+  user_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  name: import_v36.z.string(),
+  description: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  config: import_v36.z.object({
+    event_type: import_v36.z.literal("retention"),
+    object_type: RetentionObjectType,
+    retention_days: import_v36.z.number().int().gte(0)
+  })
+});
 var ProjectSettings = import_v36.z.union([
   import_v36.z.object({
     comparison_key: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
@@ -3371,6 +3859,7 @@ var ProjectSettings = import_v36.z.union([
       import_v36.z.null()
     ]),
     disable_realtime_queries: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
+    monitor_charts_use_metrics_start: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
     default_preprocessor: NullableSavedFunctionId
   }).partial(),
   import_v36.z.null()
@@ -3385,11 +3874,6 @@ var Project = import_v36.z.object({
   user_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   settings: ProjectSettings.optional()
 });
-var RetentionObjectType = import_v36.z.enum([
-  "project_logs",
-  "experiment",
-  "dataset"
-]);
 var TopicAutomationFacetModel = import_v36.z.union([
   import_v36.z.enum(["brain-facet-latest", "brain-facet-1", "brain-facet-2"]),
   import_v36.z.null()
@@ -3500,7 +3984,7 @@ var ProjectAutomation = import_v36.z.object({
     import_v36.z.object({
       event_type: import_v36.z.literal("retention"),
       object_type: RetentionObjectType,
-      retention_days: import_v36.z.number().gte(0)
+      retention_days: import_v36.z.number().int().gte(0)
     }),
     import_v36.z.object({
       event_type: import_v36.z.literal("environment_update"),
@@ -3672,7 +4156,12 @@ var Prompt = import_v36.z.object({
   metadata: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
   function_type: FunctionTypeEnumNullish.optional()
 });
-var PromptOptions = import_v36.z.object({ model: import_v36.z.string(), params: ModelParams, position: import_v36.z.string() }).partial();
+var PromptOptions = import_v36.z.object({
+  model: import_v36.z.string(),
+  params: ModelParams,
+  position: import_v36.z.string(),
+  endpoint_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()])
+}).partial();
 var PromptSessionEvent = import_v36.z.object({
   id: import_v36.z.string(),
   _xact_id: import_v36.z.string(),
@@ -3755,7 +4244,8 @@ var RunEval = import_v36.z.object({
   stop_token: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   extra_messages: import_v36.z.string().optional(),
   tags: import_v36.z.array(import_v36.z.string()).optional(),
-  mcp_auth: import_v36.z.record(import_v36.z.object({ oauth_token: import_v36.z.string() }).partial()).optional()
+  mcp_auth: import_v36.z.record(import_v36.z.object({ oauth_token: import_v36.z.string() }).partial()).optional(),
+  endpoint_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
 });
 var ServiceToken = import_v36.z.object({
   id: import_v36.z.string().uuid(),
@@ -3765,7 +4255,8 @@ var ServiceToken = import_v36.z.object({
   service_account_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   service_account_email: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   service_account_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
-  org_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
+  org_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  expires_at: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
 });
 var SpanIFrame = import_v36.z.object({
   id: import_v36.z.string().uuid(),
@@ -3887,6 +4378,13 @@ var ViewOptions = import_v36.z.union([
       }),
       import_v36.z.null()
     ]),
+    pointSizeMetric: import_v36.z.union([
+      import_v36.z.object({
+        type: import_v36.z.enum(["none", "score", "metric", "metadata"]),
+        value: import_v36.z.string()
+      }),
+      import_v36.z.null()
+    ]),
     xAxisAggregation: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
     chartAnnotations: import_v36.z.union([
       import_v36.z.array(import_v36.z.object({ id: import_v36.z.string(), text: import_v36.z.string() })),
@@ -5028,6 +5526,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",
@@ -5053,7 +5553,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,
@@ -5248,12 +5748,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.
    */
@@ -8986,6 +9487,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();
@@ -9887,7 +10394,7 @@ var SpanImpl = class _SpanImpl {
         start: args.startTime ?? getCurrentUnixTimestamp()
       },
       context: mergeSpanOriginContext(
-        { ...callerLocation },
+        { ...callerLocation, ...args[INTERNAL_SPAN_CONTEXT] },
         instrumentationName,
         this._state.spanOriginEnvironment
       ),
@@ -11827,8 +12334,8 @@ function runWithAutoInstrumentationSuppressed(callback) {
     callback
   );
 }
-function bindAutoInstrumentationSuppressionToStart(tracingChannel2) {
-  const startChannel = tracingChannel2.start;
+function bindAutoInstrumentationSuppressionToStart(tracingChannel) {
+  const startChannel = tracingChannel.start;
   if (!startChannel) {
     return void 0;
   }
@@ -11939,9 +12446,9 @@ function ensureSpanStateForEvent(states, config, event, channelName, instrumenta
   states.set(key, created);
   return created;
 }
-function bindCurrentSpanStoreToStart(tracingChannel2, states, config, channelName, instrumentationName) {
+function bindCurrentSpanStoreToStart(tracingChannel, states, config, channelName, instrumentationName) {
   const state = _internalGetGlobalState();
-  const startChannel = tracingChannel2.start;
+  const startChannel = tracingChannel.start;
   const contextManager = state?.contextManager;
   const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
   if (!currentSpanStore || !startChannel) {
@@ -12024,11 +12531,11 @@ function runStreamingErrorHook(args) {
   }
 }
 function traceAsyncChannel(channel2, config) {
-  const tracingChannel2 = channel2.tracingChannel();
+  const tracingChannel = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
   const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
-    tracingChannel2,
+    tracingChannel,
     states,
     config,
     channelName,
@@ -12084,18 +12591,18 @@ function traceAsyncChannel(channel2, config) {
       logErrorAndEnd(states, event, channelName);
     }
   };
-  tracingChannel2.subscribe(handlers);
+  tracingChannel.subscribe(handlers);
   return () => {
     unbindCurrentSpanStore?.();
-    tracingChannel2.unsubscribe(handlers);
+    tracingChannel.unsubscribe(handlers);
   };
 }
 function traceStreamingChannel(channel2, config) {
-  const tracingChannel2 = channel2.tracingChannel();
+  const tracingChannel = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
   const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
-    tracingChannel2,
+    tracingChannel,
     states,
     config,
     channelName,
@@ -12306,18 +12813,18 @@ function traceStreamingChannel(channel2, config) {
       }
     }
   };
-  tracingChannel2.subscribe(handlers);
+  tracingChannel.subscribe(handlers);
   return () => {
     unbindCurrentSpanStore?.();
-    tracingChannel2.unsubscribe(handlers);
+    tracingChannel.unsubscribe(handlers);
   };
 }
 function traceSyncStreamChannel(channel2, config) {
-  const tracingChannel2 = channel2.tracingChannel();
+  const tracingChannel = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
   const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
-    tracingChannel2,
+    tracingChannel,
     states,
     config,
     channelName,
@@ -12430,10 +12937,10 @@ function traceSyncStreamChannel(channel2, config) {
       logErrorAndEnd(states, event, channelName);
     }
   };
-  tracingChannel2.subscribe(handlers);
+  tracingChannel.subscribe(handlers);
   return () => {
     unbindCurrentSpanStore?.();
-    tracingChannel2.unsubscribe(handlers);
+    tracingChannel.unsubscribe(handlers);
   };
 }
 function unsubscribeAll(unsubscribers) {
@@ -12613,7 +13120,7 @@ function defineChannels(pkg, channels, options) {
       const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
       if (spec.kind === "async") {
         const asyncSpec = spec;
-        const tracingChannel3 = () => isomorph_default.newTracingChannel(
+        const tracingChannel2 = () => isomorph_default.newTracingChannel(
           fullChannelName
         );
         return [
@@ -12621,8 +13128,8 @@ function defineChannels(pkg, channels, options) {
           {
             ...asyncSpec,
             instrumentationName,
-            tracingChannel: tracingChannel3,
-            tracePromise: (fn, context) => tracingChannel3().tracePromise(
+            tracingChannel: tracingChannel2,
+            tracePromise: (fn, context) => tracingChannel2().tracePromise(
               fn,
               // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
               context
@@ -12631,7 +13138,7 @@ function defineChannels(pkg, channels, options) {
         ];
       }
       const syncSpec = spec;
-      const tracingChannel2 = () => isomorph_default.newTracingChannel(
+      const tracingChannel = () => isomorph_default.newTracingChannel(
         fullChannelName
       );
       return [
@@ -12639,8 +13146,8 @@ function defineChannels(pkg, channels, options) {
         {
           ...syncSpec,
           instrumentationName,
-          tracingChannel: tracingChannel2,
-          traceSync: (fn, context) => tracingChannel2().traceSync(
+          tracingChannel,
+          traceSync: (fn, context) => tracingChannel().traceSync(
             fn,
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             context
@@ -13972,7 +14479,7 @@ var AnthropicPlugin = class extends BasePlugin {
     );
   }
   subscribeToAnthropicToolRunner() {
-    const tracingChannel2 = anthropicChannels.betaMessagesToolRunner.tracingChannel();
+    const tracingChannel = anthropicChannels.betaMessagesToolRunner.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -14029,9 +14536,9 @@ var AnthropicPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
 };
@@ -14943,8 +15450,8 @@ function registerHarnessSessionParent(session, parent) {
 function currentHarnessTurnParent() {
   return harnessTurnParentStore?.getStore() ?? wrapperTurnParents.get(currentSpan());
 }
-function bindHarnessTurnParentToStart(tracingChannel2, parentFromEvent) {
-  const startChannel = tracingChannel2.start;
+function bindHarnessTurnParentToStart(tracingChannel, parentFromEvent) {
+  const startChannel = tracingChannel.start;
   if (!startChannel) {
     return () => {
     };
@@ -20410,7 +20917,7 @@ var CursorSDKPlugin = class extends BasePlugin {
     this.subscribeToAgentFactory(cursorSDKChannels.resume);
   }
   subscribeToAgentFactory(channel2) {
-    const tracingChannel2 = channel2.tracingChannel();
+    const tracingChannel = channel2.tracingChannel();
     const handlers = {
       asyncEnd: (event) => {
         patchCursorAgentInPlace(event.result);
@@ -20418,9 +20925,9 @@ var CursorSDKPlugin = class extends BasePlugin {
       error: () => {
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   subscribeToPrompt() {
@@ -21776,10 +22283,10 @@ var GoogleGenAIPlugin = class extends BasePlugin {
     this.subscribeToInteractionsCreateChannel();
   }
   subscribeToGenerateContentChannel() {
-    const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
+    const tracingChannel = googleGenAIChannels.generateContent.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
-      tracingChannel2,
+      tracingChannel,
       states,
       (event) => {
         const params = event.arguments[0];
@@ -21853,14 +22360,14 @@ var GoogleGenAIPlugin = class extends BasePlugin {
         logErrorAndEndSpan(states, event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
       unbindCurrentSpanStore?.();
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   subscribeToGenerateContentStreamChannel() {
-    const tracingChannel2 = googleGenAIChannels.generateContentStream.tracingChannel();
+    const tracingChannel = googleGenAIChannels.generateContentStream.tracingChannel();
     const handlers = {
       start: (event) => {
         const streamEvent = event;
@@ -21881,16 +22388,16 @@ var GoogleGenAIPlugin = class extends BasePlugin {
       error: () => {
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   subscribeToEmbedContentChannel() {
-    const tracingChannel2 = googleGenAIChannels.embedContent.tracingChannel();
+    const tracingChannel = googleGenAIChannels.embedContent.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
-      tracingChannel2,
+      tracingChannel,
       states,
       (event) => {
         const params = event.arguments[0];
@@ -21960,10 +22467,10 @@ var GoogleGenAIPlugin = class extends BasePlugin {
         logErrorAndEndSpan(states, event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
       unbindCurrentSpanStore?.();
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   subscribeToInteractionsCreateChannel() {
@@ -21999,10 +22506,10 @@ function ensureSpanState(states, event, create) {
   states.set(event, created);
   return created;
 }
-function bindCurrentSpanStoreToStart2(tracingChannel2, states, create) {
+function bindCurrentSpanStoreToStart2(tracingChannel, states, create) {
   const state = _internalGetGlobalState();
   const contextManager = state?.contextManager;
-  const startChannel = tracingChannel2.start;
+  const startChannel = tracingChannel.start;
   const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
   if (!startChannel?.bindStore || !currentSpanStore) {
     return void 0;
@@ -22505,11 +23012,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;
@@ -22520,13 +23027,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;
@@ -22537,6 +23057,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();
@@ -23275,6 +23813,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",
@@ -23674,7 +24505,7 @@ function isWrappedTool(tool) {
   return Boolean(tool[OPENROUTER_WRAPPED_TOOL]);
 }
 function traceToolExecution(args) {
-  const tracingChannel2 = openRouterAgentChannels.toolExecute.tracingChannel();
+  const tracingChannel = openRouterAgentChannels.toolExecute.tracingChannel();
   const input = args.args.length > 0 ? args.args[0] : void 0;
   const event = {
     arguments: [input],
@@ -23684,33 +24515,33 @@ function traceToolExecution(args) {
     toolCallId: args.toolCallId,
     toolName: args.toolName
   };
-  tracingChannel2.start.publish(event);
+  tracingChannel.start.publish(event);
   try {
     const result = args.execute();
-    return publishToolResult(tracingChannel2, event, result);
+    return publishToolResult(tracingChannel, event, result);
   } catch (error) {
     event.error = normalizeError(error);
-    tracingChannel2.error.publish(event);
+    tracingChannel.error.publish(event);
     throw error;
   }
 }
-function publishToolResult(tracingChannel2, event, result) {
+function publishToolResult(tracingChannel, event, result) {
   if (isPromiseLike(result)) {
     return result.then(
       (resolved) => {
         event.result = resolved;
-        tracingChannel2.asyncEnd.publish(event);
+        tracingChannel.asyncEnd.publish(event);
         return resolved;
       },
       (error) => {
         event.error = normalizeError(error);
-        tracingChannel2.error.publish(event);
+        tracingChannel.error.publish(event);
         throw error;
       }
     );
   }
   event.result = result;
-  tracingChannel2.asyncEnd.publish(event);
+  tracingChannel.asyncEnd.publish(event);
   return result;
 }
 function getToolCallId(context) {
@@ -24616,7 +25447,7 @@ function isWrappedTool2(tool) {
   return Boolean(tool[OPENROUTER_WRAPPED_TOOL2]);
 }
 function traceToolExecution2(args) {
-  const tracingChannel2 = openRouterChannels.toolExecute.tracingChannel();
+  const tracingChannel = openRouterChannels.toolExecute.tracingChannel();
   const input = args.args.length > 0 ? args.args[0] : void 0;
   const event = {
     arguments: [input],
@@ -24626,33 +25457,33 @@ function traceToolExecution2(args) {
     toolCallId: args.toolCallId,
     toolName: args.toolName
   };
-  tracingChannel2.start.publish(event);
+  tracingChannel.start.publish(event);
   try {
     const result = args.execute();
-    return publishToolResult2(tracingChannel2, event, result);
+    return publishToolResult2(tracingChannel, event, result);
   } catch (error) {
     event.error = normalizeError2(error);
-    tracingChannel2.error.publish(event);
+    tracingChannel.error.publish(event);
     throw error;
   }
 }
-function publishToolResult2(tracingChannel2, event, result) {
+function publishToolResult2(tracingChannel, event, result) {
   if (isPromiseLike(result)) {
     return result.then(
       (resolved) => {
         event.result = resolved;
-        tracingChannel2.asyncEnd.publish(event);
+        tracingChannel.asyncEnd.publish(event);
         return resolved;
       },
       (error) => {
         event.error = normalizeError2(error);
-        tracingChannel2.error.publish(event);
+        tracingChannel.error.publish(event);
         throw error;
       }
     );
   }
   event.result = result;
-  tracingChannel2.asyncEnd.publish(event);
+  tracingChannel.asyncEnd.publish(event);
   return result;
 }
 function getToolCallId2(context) {
@@ -25842,7 +26673,7 @@ var GoogleADKPlugin = class extends BasePlugin {
     this.activeAgentSpans.clear();
   }
   subscribeToRunnerRunAsync() {
-    const tracingChannel2 = googleADKChannels.runnerRunAsync.tracingChannel();
+    const tracingChannel = googleADKChannels.runnerRunAsync.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const createState = (event) => {
       const params = event.arguments[0] ?? {};
@@ -25873,7 +26704,7 @@ var GoogleADKPlugin = class extends BasePlugin {
       return { span, startTime, events: [], contextKey };
     };
     const unbindCurrentSpanStore = bindCurrentSpanStoreToStart3(
-      tracingChannel2,
+      tracingChannel,
       states,
       createState
     );
@@ -25925,14 +26756,14 @@ var GoogleADKPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
       unbindCurrentSpanStore?.();
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   subscribeToAgentRunAsync() {
-    const tracingChannel2 = googleADKChannels.agentRunAsync.tracingChannel();
+    const tracingChannel = googleADKChannels.agentRunAsync.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const createState = (event) => {
       const parentContext = event.arguments[0];
@@ -25981,7 +26812,7 @@ var GoogleADKPlugin = class extends BasePlugin {
       return { span, startTime, events: [], contextKey, name: agentName };
     };
     const unbindCurrentSpanStore = bindCurrentSpanStoreToStart3(
-      tracingChannel2,
+      tracingChannel,
       states,
       createState
     );
@@ -26033,14 +26864,14 @@ var GoogleADKPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
       unbindCurrentSpanStore?.();
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   subscribeToToolRunAsync() {
-    const tracingChannel2 = googleADKChannels.toolRunAsync.tracingChannel();
+    const tracingChannel = googleADKChannels.toolRunAsync.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -26107,9 +26938,9 @@ var GoogleADKPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
 };
@@ -26185,10 +27016,10 @@ function bindAsyncIterableToCurrentSpan(stream, span) {
   }
   return stream;
 }
-function bindCurrentSpanStoreToStart3(tracingChannel2, states, create) {
+function bindCurrentSpanStoreToStart3(tracingChannel, states, create) {
   const state = _internalGetGlobalState();
   const contextManager = state?.contextManager;
-  const startChannel = tracingChannel2.start;
+  const startChannel = tracingChannel.start;
   const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
   if (!startChannel?.bindStore || !currentSpanStore) {
     return void 0;
@@ -26440,15 +27271,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;
@@ -26459,6 +27307,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 = {};
@@ -28024,10 +28885,10 @@ var GenkitPlugin = class extends BasePlugin {
     this.subscribeToActionStream();
   }
   subscribeToActionRun() {
-    const tracingChannel2 = genkitChannels.actionRun.tracingChannel();
+    const tracingChannel = genkitChannels.actionRun.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const unbindCurrentSpanStore = bindActionCurrentSpanStoreToStart(
-      tracingChannel2,
+      tracingChannel,
       states,
       (event) => startActionRunSpan(event)
     );
@@ -28064,17 +28925,17 @@ var GenkitPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
       unbindCurrentSpanStore?.();
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   subscribeToActionSpan() {
-    const tracingChannel2 = genkitCoreChannels.actionSpan.tracingChannel();
+    const tracingChannel = genkitCoreChannels.actionSpan.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const unbindCurrentSpanStore = bindActionCurrentSpanStoreToStart(
-      tracingChannel2,
+      tracingChannel,
       states,
       (event) => startActionSpan(event)
     );
@@ -28112,10 +28973,10 @@ var GenkitPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
       unbindCurrentSpanStore?.();
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   subscribeToActionStream() {
@@ -28184,10 +29045,10 @@ function ensureActionSpanState(states, event, create) {
   }
   return created;
 }
-function bindActionCurrentSpanStoreToStart(tracingChannel2, states, create) {
+function bindActionCurrentSpanStoreToStart(tracingChannel, states, create) {
   const state = _internalGetGlobalState();
   const contextManager = state?.contextManager;
-  const startChannel = tracingChannel2.start;
+  const startChannel = tracingChannel.start;
   const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
   if (!startChannel?.bindStore || !currentSpanStore) {
     return void 0;
@@ -30549,7 +31410,7 @@ var LangChainPlugin = class extends BasePlugin {
     this.injectedManagers = /* @__PURE__ */ new WeakSet();
   }
   subscribeToConfigure(channel2) {
-    const tracingChannel2 = channel2.tracingChannel();
+    const tracingChannel = channel2.tracingChannel();
     const handlers = {
       start: (event) => {
         injectHandlerIntoArguments(event.arguments);
@@ -30558,9 +31419,9 @@ var LangChainPlugin = class extends BasePlugin {
         this.injectHandler(event.result);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
   injectHandler(result) {
@@ -30824,7 +31685,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({
@@ -30929,7 +31790,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)) {
@@ -32060,9 +32921,9 @@ var StrandsAgentSDKPlugin = class extends BasePlugin {
     });
   }
   subscribeToMultiAgentStream(channel2, operation) {
-    const tracingChannel2 = channel2.tracingChannel();
+    const tracingChannel = channel2.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
-    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(tracingChannel2);
+    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(tracingChannel);
     const handlers = {
       start: (event) => {
         const state = startMultiAgentStream(
@@ -32116,10 +32977,10 @@ var StrandsAgentSDKPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    tracingChannel2.subscribe(handlers);
+    tracingChannel.subscribe(handlers);
     this.unsubscribers.push(() => {
       unbindAutoInstrumentationSuppression?.();
-      tracingChannel2.unsubscribe(handlers);
+      tracingChannel.unsubscribe(handlers);
     });
   }
 };
@@ -32302,6 +33163,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);
@@ -32319,10 +33189,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),
@@ -32962,6 +33829,555 @@ 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 wrappedTurnRunners = /* @__PURE__ */ new WeakSet();
+var wrappedResponseHooks = /* @__PURE__ */ new WeakSet();
+function instrumentCloudflareAIChatAgent(agent) {
+  try {
+    const original = Reflect.get(agent, "_runExclusiveChatTurn");
+    if (typeof original !== "function" || wrappedTurnRunners.has(original)) {
+      return agent;
+    }
+    const wrapped = async function(...args) {
+      return cloudflareAIChatChannels.runExclusiveChatTurn.tracePromise(
+        () => Reflect.apply(original, this, args),
+        {
+          arguments: args,
+          self: this
+        }
+      );
+    };
+    wrappedTurnRunners.add(wrapped);
+    defineWrappedMethod(agent, "_runExclusiveChatTurn", original, wrapped);
+  } catch (error) {
+    debugLogger.debug("Failed to wrap @cloudflare/ai-chat turn runner:", error);
+  }
+  return agent;
+}
+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;
@@ -32974,6 +34390,7 @@ var BraintrustPlugin = class extends BasePlugin {
   openAIAgentsPlugin = null;
   googleGenAIPlugin = null;
   huggingFacePlugin = null;
+  huggingFaceTransformersPlugin = null;
   openRouterPlugin = null;
   openRouterAgentPlugin = null;
   mistralPlugin = null;
@@ -32988,6 +34405,8 @@ var BraintrustPlugin = class extends BasePlugin {
   langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
+  cloudflareAIChatPlugin = null;
+  cloudflareAgentsPlugin = null;
   constructor(config = {}) {
     super();
     this.config = config;
@@ -33029,6 +34448,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();
@@ -33074,6 +34495,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();
@@ -33126,6 +34555,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;
@@ -33170,6 +34603,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;
@@ -33202,6 +34643,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",
@@ -33209,6 +34653,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",
@@ -33223,6 +34670,8 @@ var envIntegrationAliases = {
   "google-genai": "googleGenAI",
   googlegenai: "googleGenAI",
   huggingface: "huggingface",
+  "@huggingface/transformers": "huggingface",
+  transformers: "huggingface",
   openrouter: "openrouter",
   openrouteragent: "openrouterAgent",
   "openrouter-agent": "openrouterAgent",
@@ -33261,6 +34710,7 @@ function getDefaultInstrumentationIntegrations() {
     googleADK: true,
     huggingface: true,
     claudeAgentSDK: true,
+    cloudflareAIChat: true,
     cursor: true,
     cursorSDK: true,
     flue: true,
@@ -33280,7 +34730,8 @@ function getDefaultInstrumentationIntegrations() {
     langgraph: true,
     langsmith: true,
     piCodingAgent: true,
-    strandsAgentSDK: true
+    strandsAgentSDK: true,
+    cloudflareAgents: true
   };
 }
 function readDisabledInstrumentationEnvConfig(disabledList) {
@@ -33298,7 +34749,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;
@@ -33392,92 +34845,6 @@ function configureInstrumentation(config) {
   registry.configure(config);
 }
 
-// src/auto-instrumentations/patch-tracing-channel.ts
-function patchTracingChannel(tracingChannelFn) {
-  const dummyChannel = tracingChannelFn("__braintrust_probe__");
-  const TracingChannel = dummyChannel?.constructor;
-  if (!TracingChannel?.prototype) {
-    return;
-  }
-  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
-        );
-      }
-    });
-  }
-  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 publishResolved(result) {
-        context.result = result;
-        asyncStart?.publish(context);
-        asyncEnd?.publish(context);
-      }
-      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;
-        }
-      });
-    };
-  }
-}
-
 // src/browser/config.ts
 var browserConfigured = false;
 function configureBrowser() {
@@ -33491,8 +34858,6 @@ function configureBrowser() {
     }
   } catch {
   }
-  isomorph_default.newTracingChannel = (nameOrChannels) => (0, import_dc_browser.tracingChannel)(nameOrChannels);
-  patchTracingChannel(import_dc_browser.tracingChannel);
   isomorph_default.getEnv = (name) => {
     if (typeof process === "undefined" || typeof process.env === "undefined") {
       return void 0;
@@ -33667,6 +35032,8 @@ __export(exports_exports, {
   wrapAnthropic: () => wrapAnthropic,
   wrapBedrockRuntime: () => wrapBedrockRuntime,
   wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
+  wrapCloudflareAIChat: () => wrapCloudflareAIChat,
+  wrapCloudflareAgent: () => wrapCloudflareAgent,
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
@@ -33675,6 +35042,7 @@ __export(exports_exports, {
   wrapGoogleGenAI: () => wrapGoogleGenAI,
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
+  wrapHuggingFaceTransformers: () => wrapHuggingFaceTransformers,
   wrapLangSmithClient: () => wrapLangSmithClient,
   wrapLangSmithRunTrees: () => wrapLangSmithRunTrees,
   wrapLangSmithTraceable: () => wrapLangSmithTraceable,
@@ -34998,7 +36366,7 @@ function extractToolCallsFromBlocks(blocks) {
   if (!Array.isArray(blocks)) return [];
   return extractToolCallsFromSteps([{ content: blocks }]);
 }
-function extractInput(params) {
+function extractInput2(params) {
   return params?.prompt ?? params?.messages ?? params?.system;
 }
 var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
@@ -35020,7 +36388,7 @@ function BraintrustMiddleware(config = {}) {
       params,
       model: modelFromWrapGenerate
     }) => {
-      const rawInput = extractInput(params);
+      const rawInput = extractInput2(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
         name: config.spanInfo?.name || "ai-sdk.doGenerate",
@@ -35084,7 +36452,7 @@ function BraintrustMiddleware(config = {}) {
       }
     },
     wrapStream: async ({ doStream, params }) => {
-      const rawInput = extractInput(params);
+      const rawInput = extractInput2(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
         name: config.spanInfo?.name || "ai-sdk.doStream",
@@ -37606,6 +38974,67 @@ function patchAgentSessionClass(AgentSession) {
   });
 }
 
+// src/wrappers/cloudflare-agent.ts
+var WRAPPED_RUN_AGENT_TOOL = /* @__PURE__ */ Symbol.for(
+  "braintrust.cloudflare-agents.wrapped-run-agent-tool"
+);
+function wrapCloudflareAgent(Agent2) {
+  if (typeof Agent2 !== "function") {
+    warnUnsupportedAgent();
+    return Agent2;
+  }
+  const prototypeDescriptor = Object.getOwnPropertyDescriptor(
+    Agent2,
+    "prototype"
+  );
+  const prototype = prototypeDescriptor && "value" in prototypeDescriptor ? prototypeDescriptor.value : void 0;
+  if (!isObjectLike3(prototype)) {
+    warnUnsupportedAgent();
+    return Agent2;
+  }
+  if (ownValue4(prototype, WRAPPED_RUN_AGENT_TOOL) === true) {
+    return Agent2;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(prototype, "runAgentTool");
+  if (!descriptor || typeof descriptor.value !== "function") {
+    warnUnsupportedAgent();
+    return Agent2;
+  }
+  const originalRunAgentTool = descriptor.value;
+  Object.defineProperty(prototype, "runAgentTool", {
+    ...descriptor,
+    value: function wrappedRunAgentTool(...args) {
+      const options = args[1];
+      if (ownValue4(options, "detached")) {
+        return Reflect.apply(originalRunAgentTool, this, args);
+      }
+      return cloudflareAgentsChannels.runAgentTool.tracePromise(
+        () => Reflect.apply(originalRunAgentTool, this, args),
+        { arguments: args, self: this }
+      );
+    }
+  });
+  Object.defineProperty(prototype, WRAPPED_RUN_AGENT_TOOL, {
+    configurable: false,
+    enumerable: false,
+    value: true
+  });
+  return Agent2;
+}
+function ownValue4(value, key) {
+  if (!isObjectLike3(value)) {
+    return void 0;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function isObjectLike3(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function warnUnsupportedAgent() {
+  debugLogger.warn("Unsupported Cloudflare Agents Agent class. Not wrapping.");
+}
+
 // src/wrappers/strands-agent-sdk.ts
 var WRAPPED_CLASS = /* @__PURE__ */ Symbol.for("braintrust.strands-agent-sdk.wrapped-class");
 var WRAPPED_INSTANCE = /* @__PURE__ */ Symbol.for(
@@ -37774,6 +39203,81 @@ async function consumeAsyncGenerator(generator) {
   return result.value;
 }
 
+// src/wrappers/cloudflare-ai-chat.ts
+var wrappedClasses = /* @__PURE__ */ new WeakMap();
+function wrapCloudflareAIChat(module2) {
+  if (!module2 || typeof module2 !== "object") {
+    return module2;
+  }
+  const candidate = module2;
+  let AIChatAgent;
+  try {
+    AIChatAgent = Reflect.get(candidate, "AIChatAgent");
+  } catch (error) {
+    debugLogger.debug("Failed to inspect @cloudflare/ai-chat module:", error);
+    return module2;
+  }
+  if (typeof AIChatAgent !== "function") {
+    debugLogger.warn(
+      "Unsupported @cloudflare/ai-chat module. AIChatAgent was not found; not wrapping."
+    );
+    return module2;
+  }
+  const target = isModuleNamespace5(module2) ? Object.setPrototypeOf({}, module2) : candidate;
+  return new Proxy(target, {
+    get(target2, property, receiver) {
+      const value = Reflect.get(target2, property, receiver);
+      if (property === "AIChatAgent" && typeof value === "function") {
+        return wrapAIChatAgentClass(
+          value
+        );
+      }
+      return value;
+    }
+  });
+}
+function wrapAIChatAgentClass(AgentClass) {
+  const cached = wrappedClasses.get(AgentClass);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = new Proxy(AgentClass, {
+    get(target, property) {
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    construct(target, args, newTarget) {
+      const instance = Reflect.construct(
+        target,
+        args,
+        newTarget
+      );
+      return instrumentCloudflareAIChatAgent(instance);
+    }
+  });
+  wrappedClasses.set(AgentClass, wrapped);
+  wrappedClasses.set(wrapped, wrapped);
+  return wrapped;
+}
+function isModuleNamespace5(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  try {
+    if (Reflect.get(value, Symbol.toStringTag) === "Module") {
+      return true;
+    }
+    const keys = Object.keys(value);
+    if (keys.length === 0) {
+      return false;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, keys[0]);
+    return descriptor ? !descriptor.configurable && !descriptor.writable : false;
+  } catch {
+    return false;
+  }
+}
+
 // src/wrappers/google-genai.ts
 function wrapGoogleGenAI(googleGenAI) {
   if (!googleGenAI || typeof googleGenAI !== "object") {
@@ -38426,6 +39930,120 @@ function wrapFeatureExtraction(original, endpointUrl) {
   };
 }
 
+// src/wrappers/huggingface-transformers.ts
+var PIPELINE_CONSTRUCTOR_KEYS = /* @__PURE__ */ new Set([
+  "TextGenerationPipeline",
+  "Text2TextGenerationPipeline",
+  "SummarizationPipeline",
+  "FeatureExtractionPipeline",
+  "QuestionAnsweringPipeline"
+]);
+var wrappedValues = /* @__PURE__ */ new WeakMap();
+function wrapHuggingFaceTransformers(transformers) {
+  const pipelineTask = transformers?.task;
+  if (typeof transformers === "function" && isSupportedHuggingFaceTransformersTask(pipelineTask)) {
+    return wrapPipeline(transformers);
+  }
+  if (!isSupportedModule(transformers)) {
+    return transformers;
+  }
+  const existing = wrappedValues.get(transformers);
+  if (existing) {
+    return existing;
+  }
+  const proxy = new Proxy(Object.create(transformers), {
+    get(_target, property, receiver) {
+      const value = Reflect.get(transformers, property, receiver);
+      if (property === "pipeline" && typeof value === "function") {
+        return wrapPipelineFactory(value);
+      }
+      if (typeof property === "string" && PIPELINE_CONSTRUCTOR_KEYS.has(property) && typeof value === "function") {
+        return wrapPipelineConstructor(
+          value
+        );
+      }
+      return value;
+    }
+  });
+  wrappedValues.set(transformers, proxy);
+  wrappedValues.set(proxy, proxy);
+  return proxy;
+}
+function isSupportedModule(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  if (typeof Reflect.get(value, "pipeline") === "function") {
+    return true;
+  }
+  for (const key of PIPELINE_CONSTRUCTOR_KEYS) {
+    if (typeof Reflect.get(value, key) === "function") {
+      return true;
+    }
+  }
+  return false;
+}
+function wrapPipelineFactory(factory) {
+  const existing = wrappedValues.get(factory);
+  if (existing) {
+    return existing;
+  }
+  const wrapped = function(...args) {
+    const [task] = args;
+    const context = {
+      arguments: args
+    };
+    return huggingFaceTransformersChannels.pipeline.tracePromise(() => Reflect.apply(factory, this, args), context).then((pipeline) => {
+      if (isSupportedHuggingFaceTransformersTask(pipeline.task ?? task)) {
+        return wrapPipeline(pipeline);
+      }
+      return pipeline;
+    });
+  };
+  wrappedValues.set(factory, wrapped);
+  wrappedValues.set(wrapped, wrapped);
+  return wrapped;
+}
+function wrapPipelineConstructor(constructor) {
+  const existing = wrappedValues.get(constructor);
+  if (existing) {
+    return existing;
+  }
+  const proxy = new Proxy(constructor, {
+    construct(target, args, newTarget) {
+      const pipeline = Reflect.construct(target, args, newTarget);
+      if (isSupportedHuggingFaceTransformersTask(pipeline.task)) {
+        return wrapPipeline(pipeline);
+      }
+      return pipeline;
+    }
+  });
+  wrappedValues.set(constructor, proxy);
+  wrappedValues.set(proxy, proxy);
+  return proxy;
+}
+function wrapPipeline(pipeline) {
+  const existing = wrappedValues.get(pipeline);
+  if (existing) {
+    return existing;
+  }
+  const proxy = new Proxy(pipeline, {
+    apply(target, thisArg, args) {
+      const context = {
+        arguments: args,
+        self: target
+      };
+      return huggingFaceTransformersChannels.pipelineCall.tracePromise(
+        () => Reflect.apply(target, thisArg, args),
+        context
+      );
+    }
+  });
+  wrappedValues.set(pipeline, proxy);
+  wrappedValues.set(proxy, proxy);
+  return proxy;
+}
+
 // src/wrappers/openrouter-agent.ts
 function wrapOpenRouterAgent(agent) {
   const candidate = agent;
@@ -39142,7 +40760,7 @@ function wrapNamespaceExport(namespace, exportName, marker, wrap2) {
     );
     return namespace;
   }
-  const target = isModuleNamespace5(namespace) ? Object.setPrototypeOf({}, namespace) : candidate;
+  const target = isModuleNamespace6(namespace) ? Object.setPrototypeOf({}, namespace) : candidate;
   const moduleNamespace = target !== candidate;
   let wrappedExport;
   return new Proxy(target, {
@@ -39176,7 +40794,7 @@ function wrapNamespaceExport(namespace, exportName, marker, wrap2) {
     }
   });
 }
-function isModuleNamespace5(value) {
+function isModuleNamespace6(value) {
   if (!value || typeof value !== "object") {
     return false;
   }