braintrust 3.26.0 → 3.28.0

package/dist/instrumentation/index.js

@@ -49,8 +49,10 @@ var GLOBAL_INSTRUMENTATION_HOOKS_KEY = "__braintrust_instrumentation_hooks";
 var GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION = 1;
 var GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND = "braintrust.global-instrumentation-hooks.registry";
 var GLOBAL_INSTRUMENTATION_HOOK_BRAND = "braintrust.global-instrumentation-hooks.hook";
+var GLOBAL_INVOCATION_HOOK_BRAND = "braintrust.global-instrumentation-hooks.invocation-hook";
 var registryBrand = Symbol.for(GLOBAL_INSTRUMENTATION_HOOKS_REGISTRY_BRAND);
 var hookBrand = Symbol.for(GLOBAL_INSTRUMENTATION_HOOK_BRAND);
+var invocationHookBrand = Symbol.for(GLOBAL_INVOCATION_HOOK_BRAND);
 var errorReporter;
 function setGlobalHookErrorReporter(reporter) {
   const previousReporter = errorReporter;
@@ -195,12 +197,69 @@ var traceEvents = [
   "asyncEnd",
   "error"
 ];
+function traceInvocation(hook, operator, target, thisArg, args, additional, callbackIndex = -1) {
+  const context = {
+    ...additional,
+    arguments: args,
+    self: thisArg
+  };
+  const invoke = () => hook.invoke(target, thisArg, args, additional);
+  if (operator === "traceCallback") {
+    return hook.traceCallback(invoke, callbackIndex, context);
+  }
+  if (operator === "tracePromise") {
+    return hook.tracePromise(invoke, context);
+  }
+  return hook.traceSync(invoke, context);
+}
+var InvocationHook = class {
+  interceptors = [];
+  get hasInterceptors() {
+    return this.interceptors.length > 0;
+  }
+  intercept(interceptor) {
+    if (typeof interceptor !== "function") {
+      throw new TypeError("interceptor must be a function");
+    }
+    this.interceptors = [...this.interceptors, interceptor];
+    let active = true;
+    return () => {
+      if (!active) {
+        return;
+      }
+      active = false;
+      const index = this.interceptors.indexOf(interceptor);
+      if (index !== -1) {
+        this.interceptors = [
+          ...this.interceptors.slice(0, index),
+          ...this.interceptors.slice(index + 1)
+        ];
+      }
+    };
+  }
+  invoke(target, thisArg, args, additional) {
+    const interceptors = this.interceptors;
+    if (interceptors.length === 0) {
+      return Reflect.apply(target, thisArg, args);
+    }
+    let next = target;
+    for (let index = interceptors.length - 1; index >= 0; index -= 1) {
+      const interceptor = interceptors[index];
+      const downstream = next;
+      next = function(...nextArgs) {
+        return interceptor(downstream, this, nextArgs, additional);
+      };
+    }
+    return Reflect.apply(next, thisArg, args);
+  }
+};
 var TracingHook = class {
   start;
   end;
   asyncStart;
   asyncEnd;
   error;
+  invocationHook = new InvocationHook();
   constructor(nameOrChannels) {
     Object.defineProperty(this, hookBrand, {
       configurable: false,
@@ -208,6 +267,12 @@ var TracingHook = class {
       value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
       writable: false
     });
+    Object.defineProperty(this, invocationHookBrand, {
+      configurable: false,
+      enumerable: false,
+      value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+      writable: false
+    });
     if (typeof nameOrChannels === "string") {
       this.start = new HookChannel(`tracing:${nameOrChannels}:start`);
       this.end = new HookChannel(`tracing:${nameOrChannels}:end`);
@@ -225,6 +290,26 @@ var TracingHook = class {
   get hasSubscribers() {
     return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
   }
+  get hasInterceptors() {
+    return this.invocationHook.hasInterceptors;
+  }
+  intercept(interceptor) {
+    return this.invocationHook.intercept(interceptor);
+  }
+  invoke(target, thisArg, args, additional) {
+    return this.invocationHook.invoke(target, thisArg, args, additional);
+  }
+  traceInvocation(operator, target, thisArg, args, additional, callbackIndex = -1) {
+    return traceInvocation(
+      this,
+      operator,
+      target,
+      thisArg,
+      args,
+      additional,
+      callbackIndex
+    );
+  }
   subscribe(handlers) {
     for (const eventName of traceEvents) {
       const handler = handlers[eventName];
@@ -446,6 +531,60 @@ function hasTracingHookShape(value) {
     return false;
   }
 }
+function hasInvocationHookShape(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  try {
+    const hook = value;
+    return value[invocationHookBrand] === GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION && typeof hook.hasInterceptors === "boolean" && typeof hook.intercept === "function" && typeof hook.invoke === "function";
+  } catch {
+    return false;
+  }
+}
+function installInvocationHook(value) {
+  const hasInvocationHook = hasInvocationHookShape(value);
+  const invocationHook = new InvocationHook();
+  try {
+    if (!hasInvocationHook) {
+      Object.defineProperties(value, {
+        [invocationHookBrand]: {
+          configurable: false,
+          enumerable: false,
+          value: GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION,
+          writable: false
+        },
+        hasInterceptors: {
+          configurable: false,
+          enumerable: false,
+          get: () => invocationHook.hasInterceptors
+        },
+        intercept: {
+          configurable: false,
+          enumerable: false,
+          value: invocationHook.intercept.bind(invocationHook),
+          writable: false
+        },
+        invoke: {
+          configurable: false,
+          enumerable: false,
+          value: invocationHook.invoke.bind(invocationHook),
+          writable: false
+        }
+      });
+    }
+    if (typeof value.traceInvocation !== "function") {
+      Object.defineProperty(value, "traceInvocation", {
+        configurable: false,
+        enumerable: false,
+        value: traceInvocation.bind(void 0, value),
+        writable: false
+      });
+    }
+  } catch (error) {
+    reportError(error);
+  }
+}
 function isCompatibleTracingHook(value) {
   try {
     return value[hookBrand] === GLOBAL_INSTRUMENTATION_HOOKS_PROTOCOL_VERSION && hasTracingHookShape(value);
@@ -532,6 +671,7 @@ function newGlobalTracingChannel(nameOrChannels) {
     return inertTracingHook;
   }
   if (isCompatibleTracingHook(existing)) {
+    installInvocationHook(existing);
     return existing;
   }
   if (existing !== void 0) {
@@ -587,6 +727,114 @@ var iso = {
 };
 var isomorph_default = iso;
 
+// src/debug-logger.ts
+var PREFIX = "[braintrust]";
+var DEBUG_LOG_LEVEL_SYMBOL = /* @__PURE__ */ Symbol.for("braintrust-debug-log-level");
+var LOG_LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+var hasWarnedAboutInvalidEnvValue = false;
+var debugLogStateResolver = void 0;
+function warnInvalidEnvValue(value) {
+  if (hasWarnedAboutInvalidEnvValue) {
+    return;
+  }
+  hasWarnedAboutInvalidEnvValue = true;
+  console.warn(
+    PREFIX,
+    `Invalid BRAINTRUST_DEBUG_LOG_LEVEL value "${value}". Expected "error", "warn", "info", or "debug".`
+  );
+}
+function normalizeDebugLogLevelOption(option) {
+  if (option === false) {
+    return void 0;
+  }
+  if (option === "error" || option === "warn" || option === "info" || option === "debug") {
+    return option;
+  }
+  throw new Error(
+    `Invalid debugLogLevel value "${option}". Expected false, "error", "warn", "info", or "debug".`
+  );
+}
+function parseDebugLogLevelEnv(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (value === "error" || value === "warn" || value === "info" || value === "debug") {
+    return value;
+  }
+  warnInvalidEnvValue(value);
+  return void 0;
+}
+function getEnvDebugLogLevel() {
+  return parseDebugLogLevelEnv(isomorph_default.getEnv("BRAINTRUST_DEBUG_LOG_LEVEL"));
+}
+function setGlobalDebugLogLevel(level) {
+  globalThis[DEBUG_LOG_LEVEL_SYMBOL] = level;
+}
+function setDebugLogStateResolver(resolver) {
+  debugLogStateResolver = resolver;
+}
+function resolveDebugLogLevel(state) {
+  const stateLevel = state?.getDebugLogLevel?.();
+  const hasStateOverride = state?.hasDebugLogLevelOverride?.() ?? false;
+  if (hasStateOverride) {
+    return stateLevel;
+  }
+  const globalLevel = (
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    globalThis[DEBUG_LOG_LEVEL_SYMBOL]
+  );
+  if (globalLevel !== void 0) {
+    return globalLevel === false ? void 0 : globalLevel;
+  }
+  return getEnvDebugLogLevel();
+}
+function emit(method, state, args) {
+  const level = resolveDebugLogLevel(state);
+  if (!level || LOG_LEVEL_PRIORITY[method] > LOG_LEVEL_PRIORITY[level]) {
+    return;
+  }
+  if (method === "info") {
+    console.log(PREFIX, ...args);
+  } else if (method === "debug") {
+    console.debug(PREFIX, ...args);
+  } else if (method === "warn") {
+    console.warn(PREFIX, ...args);
+  } else {
+    console.error(PREFIX, ...args);
+  }
+}
+function createDebugLogger(state) {
+  const resolveState = () => state ?? debugLogStateResolver?.();
+  return {
+    info(...args) {
+      emit("info", resolveState(), args);
+    },
+    debug(...args) {
+      emit("debug", resolveState(), args);
+    },
+    warn(...args) {
+      emit("warn", resolveState(), args);
+    },
+    error(...args) {
+      emit("error", resolveState(), args);
+    }
+  };
+}
+var debugLogger = {
+  ...createDebugLogger(),
+  forState(state) {
+    return createDebugLogger(state);
+  }
+};
+setGlobalHookErrorReporter((error) => {
+  debugLogger.error("Global instrumentation hook error:", error);
+});
+
 // src/instrumentation/core/stream-patcher.ts
 function isAsyncIterable(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
@@ -611,112 +859,133 @@ function patchStreamIfNeeded(stream, options) {
     );
     return stream;
   }
-  if (hasAsyncIteratorMethods(stream) && isSelfAsyncIterator(stream)) {
-    if ("__braintrust_patched_iterator_methods" in stream) {
-      return stream;
+  const chunks = [];
+  let completed = false;
+  const notifyCancellation = async () => {
+    try {
+      await (options.onCancel ?? options.onComplete)(chunks);
+    } catch (error) {
+      debugLogger.error("Error in stream cancellation handler:", error);
     }
+  };
+  const patchAbortIfPresent = () => {
     try {
-      const originalNext = stream.next.bind(stream);
-      const originalReturn = typeof stream.return === "function" ? stream.return.bind(stream) : null;
-      const originalThrow = typeof stream.throw === "function" ? stream.throw.bind(stream) : null;
-      const chunks = [];
-      let completed = false;
-      stream.next = async (...args) => {
-        try {
-          const result = await runNextWithWrapper(
-            options,
-            () => originalNext(...args)
-          );
-          if (result.done) {
+      if ("abort" in stream && typeof stream.abort === "function") {
+        const originalAbort = stream.abort.bind(stream);
+        stream.abort = (...args) => {
+          try {
+            return originalAbort(...args);
+          } finally {
             if (!completed) {
               completed = true;
-              try {
-                await options.onComplete(chunks);
-              } catch (error) {
-                console.error("Error in stream onComplete handler:", error);
-              }
-            }
-          } else {
-            const chunk = result.value;
-            const shouldCollect = options.shouldCollect ? options.shouldCollect(chunk) : true;
-            if (shouldCollect) {
-              chunks.push(chunk);
-              if (options.onChunk) {
-                try {
-                  await options.onChunk(chunk);
-                } catch (error) {
-                  console.error("Error in stream onChunk handler:", error);
-                }
-              }
+              void notifyCancellation();
             }
           }
-          return result;
-        } catch (error) {
-          if (!completed) {
-            completed = true;
-            if (options.onError) {
-              try {
-                await options.onError(
-                  error instanceof Error ? error : new Error(String(error)),
-                  chunks
-                );
-              } catch (handlerError) {
-                console.error("Error in stream onError handler:", handlerError);
-              }
-            }
-          }
-          throw error;
-        }
-      };
-      if (originalReturn) {
-        stream.return = async (...args) => {
-          if (!completed) {
-            completed = true;
-            try {
-              await options.onComplete(chunks);
-            } catch (error) {
-              console.error("Error in stream onComplete handler:", error);
-            }
-          }
-          return originalReturn(...args);
-        };
-      }
-      if (originalThrow) {
-        stream.throw = async (...args) => {
-          if (!completed) {
-            completed = true;
-            const rawError = args[0];
-            const error = rawError instanceof Error ? rawError : new Error(String(rawError));
-            if (options.onError) {
-              try {
-                await options.onError(error, chunks);
-              } catch (handlerError) {
-                console.error("Error in stream onError handler:", handlerError);
-              }
-            }
-          }
-          return originalThrow(...args);
         };
       }
-      Object.defineProperty(stream, "__braintrust_patched_iterator_methods", {
-        value: true
-      });
-      return stream;
     } catch (error) {
-      console.warn("Failed to patch stream iterator methods:", error);
+      debugLogger.warn("Failed to patch stream abort method:", error);
     }
-  }
-  const originalIteratorFn = stream[Symbol.asyncIterator];
-  if ("__braintrust_patched" in originalIteratorFn && originalIteratorFn["__braintrust_patched"]) {
-    return stream;
-  }
-  try {
-    const patchedIteratorFn = function() {
-      const iterator = originalIteratorFn.call(this);
-      const originalNext = iterator.next.bind(iterator);
-      const chunks = [];
-      let completed = false;
-      iterator.next = async function(...args) {
+  };
+  if (hasAsyncIteratorMethods(stream) && isSelfAsyncIterator(stream)) {
+    if ("__braintrust_patched_iterator_methods" in stream) {
+      return stream;
+    }
+    try {
+      const originalNext = stream.next.bind(stream);
+      const originalReturn = typeof stream.return === "function" ? stream.return.bind(stream) : null;
+      const originalThrow = typeof stream.throw === "function" ? stream.throw.bind(stream) : null;
+      stream.next = async (...args) => {
+        try {
+          const result = await runNextWithWrapper(
+            options,
+            () => originalNext(...args)
+          );
+          if (result.done) {
+            if (!completed) {
+              completed = true;
+              try {
+                await options.onComplete(chunks);
+              } catch (error) {
+                console.error("Error in stream onComplete handler:", error);
+              }
+            }
+          } else {
+            const chunk = result.value;
+            const shouldCollect = options.shouldCollect ? options.shouldCollect(chunk) : true;
+            if (shouldCollect) {
+              chunks.push(chunk);
+              if (options.onChunk) {
+                try {
+                  await options.onChunk(chunk);
+                } catch (error) {
+                  console.error("Error in stream onChunk handler:", error);
+                }
+              }
+            }
+          }
+          return result;
+        } catch (error) {
+          if (!completed) {
+            completed = true;
+            if (options.onError) {
+              try {
+                await options.onError(
+                  error instanceof Error ? error : new Error(String(error)),
+                  chunks
+                );
+              } catch (handlerError) {
+                console.error("Error in stream onError handler:", handlerError);
+              }
+            }
+          }
+          throw error;
+        }
+      };
+      if (originalReturn) {
+        stream.return = async (...args) => {
+          if (!completed) {
+            completed = true;
+            await notifyCancellation();
+          }
+          return originalReturn(...args);
+        };
+      }
+      if (originalThrow) {
+        stream.throw = async (...args) => {
+          if (!completed) {
+            completed = true;
+            const rawError = args[0];
+            const error = rawError instanceof Error ? rawError : new Error(String(rawError));
+            if (options.onError) {
+              try {
+                await options.onError(error, chunks);
+              } catch (handlerError) {
+                console.error("Error in stream onError handler:", handlerError);
+              }
+            }
+          }
+          return originalThrow(...args);
+        };
+      }
+      Object.defineProperty(stream, "__braintrust_patched_iterator_methods", {
+        value: true
+      });
+      patchAbortIfPresent();
+      return stream;
+    } catch (error) {
+      console.warn("Failed to patch stream iterator methods:", error);
+    }
+  }
+  const originalIteratorFn = stream[Symbol.asyncIterator];
+  if ("__braintrust_patched" in originalIteratorFn && originalIteratorFn["__braintrust_patched"]) {
+    return stream;
+  }
+  try {
+    const patchedIteratorFn = function() {
+      const iterator = originalIteratorFn.call(this);
+      const originalNext = iterator.next.bind(iterator);
+      iterator.next = async function(...args) {
         try {
           const result = await runNextWithWrapper(
             options,
@@ -768,11 +1037,7 @@ function patchStreamIfNeeded(stream, options) {
         iterator.return = async function(...args) {
           if (!completed) {
             completed = true;
-            try {
-              await options.onComplete(chunks);
-            } catch (error) {
-              console.error("Error in stream onComplete handler:", error);
-            }
+            await notifyCancellation();
           }
           return originalReturn(...args);
         };
@@ -801,6 +1066,7 @@ function patchStreamIfNeeded(stream, options) {
       value: true
     });
     stream[Symbol.asyncIterator] = patchedIteratorFn;
+    patchAbortIfPresent();
     return stream;
   } catch (error) {
     console.warn("Failed to patch stream:", error);
@@ -814,114 +1080,6 @@ function runNextWithWrapper(options, callback) {
 // src/logger.ts
 var import_uuid2 = require("uuid");
 
-// src/debug-logger.ts
-var PREFIX = "[braintrust]";
-var DEBUG_LOG_LEVEL_SYMBOL = /* @__PURE__ */ Symbol.for("braintrust-debug-log-level");
-var LOG_LEVEL_PRIORITY = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3
-};
-var hasWarnedAboutInvalidEnvValue = false;
-var debugLogStateResolver = void 0;
-function warnInvalidEnvValue(value) {
-  if (hasWarnedAboutInvalidEnvValue) {
-    return;
-  }
-  hasWarnedAboutInvalidEnvValue = true;
-  console.warn(
-    PREFIX,
-    `Invalid BRAINTRUST_DEBUG_LOG_LEVEL value "${value}". Expected "error", "warn", "info", or "debug".`
-  );
-}
-function normalizeDebugLogLevelOption(option) {
-  if (option === false) {
-    return void 0;
-  }
-  if (option === "error" || option === "warn" || option === "info" || option === "debug") {
-    return option;
-  }
-  throw new Error(
-    `Invalid debugLogLevel value "${option}". Expected false, "error", "warn", "info", or "debug".`
-  );
-}
-function parseDebugLogLevelEnv(value) {
-  if (!value) {
-    return void 0;
-  }
-  if (value === "error" || value === "warn" || value === "info" || value === "debug") {
-    return value;
-  }
-  warnInvalidEnvValue(value);
-  return void 0;
-}
-function getEnvDebugLogLevel() {
-  return parseDebugLogLevelEnv(isomorph_default.getEnv("BRAINTRUST_DEBUG_LOG_LEVEL"));
-}
-function setGlobalDebugLogLevel(level) {
-  globalThis[DEBUG_LOG_LEVEL_SYMBOL] = level;
-}
-function setDebugLogStateResolver(resolver) {
-  debugLogStateResolver = resolver;
-}
-function resolveDebugLogLevel(state) {
-  const stateLevel = state?.getDebugLogLevel?.();
-  const hasStateOverride = state?.hasDebugLogLevelOverride?.() ?? false;
-  if (hasStateOverride) {
-    return stateLevel;
-  }
-  const globalLevel = (
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    globalThis[DEBUG_LOG_LEVEL_SYMBOL]
-  );
-  if (globalLevel !== void 0) {
-    return globalLevel === false ? void 0 : globalLevel;
-  }
-  return getEnvDebugLogLevel();
-}
-function emit(method, state, args) {
-  const level = resolveDebugLogLevel(state);
-  if (!level || LOG_LEVEL_PRIORITY[method] > LOG_LEVEL_PRIORITY[level]) {
-    return;
-  }
-  if (method === "info") {
-    console.log(PREFIX, ...args);
-  } else if (method === "debug") {
-    console.debug(PREFIX, ...args);
-  } else if (method === "warn") {
-    console.warn(PREFIX, ...args);
-  } else {
-    console.error(PREFIX, ...args);
-  }
-}
-function createDebugLogger(state) {
-  const resolveState = () => state ?? debugLogStateResolver?.();
-  return {
-    info(...args) {
-      emit("info", resolveState(), args);
-    },
-    debug(...args) {
-      emit("debug", resolveState(), args);
-    },
-    warn(...args) {
-      emit("warn", resolveState(), args);
-    },
-    error(...args) {
-      emit("error", resolveState(), args);
-    }
-  };
-}
-var debugLogger = {
-  ...createDebugLogger(),
-  forState(state) {
-    return createDebugLogger(state);
-  }
-};
-setGlobalHookErrorReporter((error) => {
-  debugLogger.error("Global instrumentation hook error:", error);
-});
-
 // src/queue.ts
 var DEFAULT_QUEUE_SIZE = 15e3;
 var Queue = class {
@@ -2463,7 +2621,8 @@ var AclObjectType = import_v36.z.union([
     "org_member",
     "project_log",
     "org_project",
-    "org_audit_logs"
+    "org_audit_logs",
+    "project_group"
   ]),
   import_v36.z.null()
 ]);
@@ -2592,7 +2751,8 @@ var AsyncScoringState = import_v36.z.union([
     token: import_v36.z.string(),
     function_ids: import_v36.z.array(import_v36.z.unknown()),
     skip_logging: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]).optional(),
-    triggered_functions: import_v36.z.union([import_v36.z.record(TriggeredFunctionState), import_v36.z.null()]).optional()
+    triggered_functions: import_v36.z.union([import_v36.z.record(TriggeredFunctionState), import_v36.z.null()]).optional(),
+    last_triggered_xact_id: import_v36.z.union([import_v36.z.string(), import_v36.z.number(), import_v36.z.null()]).optional()
   }),
   import_v36.z.object({ status: import_v36.z.literal("disabled") }),
   import_v36.z.null(),
@@ -2661,7 +2821,7 @@ var FunctionTypeEnum = import_v36.z.enum([
   "parameters",
   "sandbox"
 ]);
-var NullableSavedFunctionId = import_v36.z.union([
+var FacetPreprocessorId = import_v36.z.union([
   import_v36.z.object({
     type: import_v36.z.literal("function"),
     id: import_v36.z.string(),
@@ -2672,10 +2832,23 @@ var NullableSavedFunctionId = import_v36.z.union([
     name: import_v36.z.string(),
     function_type: FunctionTypeEnum.optional().default("scorer")
   }),
+  import_v36.z.object({ type: import_v36.z.literal("inline"), code: import_v36.z.string().min(1) }),
   import_v36.z.null()
 ]);
+var SavedFunctionId = 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: FunctionTypeEnum.optional().default("scorer")
+  })
+]);
 var TopicMapGenerationSettings = import_v36.z.object({
-  algorithm: import_v36.z.enum(["hdbscan", "kmeans"]),
+  algorithm: import_v36.z.enum(["hdbscan", "kmeans", "community"]),
   dimension_reduction: import_v36.z.enum(["umap", "pca", "none"]),
   sample_size: import_v36.z.number().int().gt(0).optional(),
   n_clusters: import_v36.z.number().int().gt(0).optional(),
@@ -2687,6 +2860,7 @@ var TopicMapGenerationSettings = import_v36.z.object({
 var TopicMapData = import_v36.z.object({
   type: import_v36.z.literal("topic_map"),
   source_facet: import_v36.z.string(),
+  source_facet_function: SavedFunctionId.and(import_v36.z.unknown()).optional(),
   embedding_model: import_v36.z.string(),
   bundle_key: import_v36.z.string().optional(),
   report_key: import_v36.z.string().optional(),
@@ -2700,7 +2874,7 @@ var TopicMapData = import_v36.z.object({
 });
 var BatchedFacetData = import_v36.z.object({
   type: import_v36.z.literal("batched_facet"),
-  preprocessor: NullableSavedFunctionId.and(import_v36.z.unknown()).optional(),
+  preprocessor: FacetPreprocessorId.optional(),
   facets: import_v36.z.array(
     import_v36.z.object({
       name: import_v36.z.string(),
@@ -2961,18 +3135,6 @@ var ObjectReferenceNullish = import_v36.z.union([
   }),
   import_v36.z.null()
 ]);
-var SavedFunctionId = 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: FunctionTypeEnum.optional().default("scorer")
-  })
-]);
 var DatasetEvent = import_v36.z.object({
   id: import_v36.z.string(),
   _xact_id: import_v36.z.string(),
@@ -3194,7 +3356,7 @@ var ExtendedSavedFunctionId = import_v36.z.union([
 ]);
 var FacetData = import_v36.z.object({
   type: import_v36.z.literal("facet"),
-  preprocessor: NullableSavedFunctionId.and(import_v36.z.unknown()).optional(),
+  preprocessor: FacetPreprocessorId.optional(),
   prompt: import_v36.z.string(),
   model: import_v36.z.string().optional(),
   embedding_model: import_v36.z.string().optional(),
@@ -3699,6 +3861,19 @@ var MessageRole = import_v36.z.enum([
   "model",
   "developer"
 ]);
+var NullableSavedFunctionId = 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: FunctionTypeEnum.optional().default("scorer")
+  }),
+  import_v36.z.null()
+]);
 var ObjectReference = import_v36.z.object({
   object_type: import_v36.z.enum([
     "project_logs",
@@ -3720,6 +3895,7 @@ var TraceScope = import_v36.z.object({
 });
 var OnlineScoreConfig = import_v36.z.union([
   import_v36.z.object({
+    status: AutomationStatus.optional(),
     sampling_rate: import_v36.z.number().gte(0).lte(1),
     scorers: import_v36.z.array(SavedFunctionId),
     btql_filter: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
@@ -3800,6 +3976,72 @@ 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 WindowedAutomationConfig = import_v36.z.object({
+  event_type: import_v36.z.literal("windowed"),
+  product_origin: import_v36.z.union([import_v36.z.literal("patterns"), import_v36.z.null()]).optional(),
+  status: AutomationStatus.optional(),
+  threshold: import_v36.z.object({
+    calculation: import_v36.z.object({
+      type: import_v36.z.literal("btql"),
+      btql_query: import_v36.z.string().min(1),
+      output: import_v36.z.object({
+        type: import_v36.z.literal("scalar"),
+        value_column: import_v36.z.string().min(1)
+      })
+    }),
+    policy: import_v36.z.object({
+      condition: import_v36.z.object({
+        type: import_v36.z.literal("threshold"),
+        operator: import_v36.z.enum(["lt", "lte", "gt", "gte", "eq", "neq"]),
+        threshold: import_v36.z.number()
+      }),
+      pending_seconds: import_v36.z.number().int().gte(0).lte(2592e3),
+      no_data_behavior: import_v36.z.enum(["keep_last", "resolve", "alert"]),
+      renotify_interval_seconds: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional(),
+      notify_on_recovery: import_v36.z.boolean().optional().default(true)
+    })
+  }).optional(),
+  window: import_v36.z.object({
+    window_seconds: import_v36.z.number().int().gte(1).lte(2592e3),
+    schedule: import_v36.z.union([
+      import_v36.z.object({
+        type: import_v36.z.literal("interval"),
+        evaluation_interval_seconds: import_v36.z.number().int().gte(1).lte(2592e3)
+      }),
+      import_v36.z.object({
+        type: import_v36.z.literal("cron"),
+        cron_expression: import_v36.z.string().min(1),
+        timezone: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
+      })
+    ]),
+    evaluation_delay_seconds: import_v36.z.number().int().gte(0).lte(2592e3)
+  }),
+  loop: import_v36.z.object({
+    prompt: import_v36.z.string().min(1).max(1e4),
+    include_trigger_input: import_v36.z.boolean().optional().default(false),
+    agent_slug: import_v36.z.string().min(1),
+    auto_approve_tools: import_v36.z.array(import_v36.z.string().min(1)).optional().default([]),
+    harness: import_v36.z.enum(["native", "codex", "claude-code"]).optional(),
+    model: import_v36.z.string().min(1).optional(),
+    reasoning_effort: import_v36.z.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional()
+  }).optional(),
+  actions: import_v36.z.array(
+    import_v36.z.union([
+      import_v36.z.object({
+        type: import_v36.z.literal("webhook"),
+        url: import_v36.z.string(),
+        formatting_prompt: import_v36.z.string().min(1).max(1e4).optional()
+      }),
+      import_v36.z.object({
+        type: import_v36.z.literal("slack"),
+        workspace_id: import_v36.z.string(),
+        channel: import_v36.z.string(),
+        message_template: import_v36.z.string().optional(),
+        formatting_prompt: import_v36.z.string().min(1).max(1e4).optional()
+      })
+    ])
+  ).max(20).optional().default([])
+});
 var TopicAutomationFacetModel = import_v36.z.union([
   import_v36.z.enum(["brain-facet-latest", "brain-facet-1", "brain-facet-2"]),
   import_v36.z.null()
@@ -3841,7 +4083,8 @@ var TopicDigestAutomationConfig = import_v36.z.object({
     type: import_v36.z.literal("slack"),
     workspace_id: import_v36.z.string(),
     channel: import_v36.z.string(),
-    message_template: import_v36.z.string().optional()
+    message_template: import_v36.z.string().optional(),
+    formatting_prompt: import_v36.z.string().min(1).max(1e4).optional()
   }),
   topic_map_function_ids: import_v36.z.array(import_v36.z.string()).max(10).optional()
 });
@@ -3855,15 +4098,21 @@ var ProjectAutomation = import_v36.z.object({
   config: import_v36.z.union([
     import_v36.z.object({
       event_type: import_v36.z.literal("logs"),
+      status: AutomationStatus.optional(),
       btql_filter: import_v36.z.string(),
       interval_seconds: import_v36.z.number().gte(1).lte(2592e3),
       action: import_v36.z.union([
-        import_v36.z.object({ type: import_v36.z.literal("webhook"), url: import_v36.z.string() }),
+        import_v36.z.object({
+          type: import_v36.z.literal("webhook"),
+          url: import_v36.z.string(),
+          formatting_prompt: import_v36.z.string().min(1).max(1e4).optional()
+        }),
         import_v36.z.object({
           type: import_v36.z.literal("slack"),
           workspace_id: import_v36.z.string(),
           channel: import_v36.z.string(),
-          message_template: import_v36.z.string().optional()
+          message_template: import_v36.z.string().optional(),
+          formatting_prompt: import_v36.z.string().min(1).max(1e4).optional()
         })
       ])
     }),
@@ -3914,21 +4163,38 @@ var ProjectAutomation = import_v36.z.object({
     }),
     import_v36.z.object({
       event_type: import_v36.z.literal("environment_update"),
+      status: AutomationStatus.optional(),
       environment_filter: import_v36.z.array(import_v36.z.string()).optional(),
       action: import_v36.z.union([
-        import_v36.z.object({ type: import_v36.z.literal("webhook"), url: import_v36.z.string() }),
+        import_v36.z.object({
+          type: import_v36.z.literal("webhook"),
+          url: import_v36.z.string(),
+          formatting_prompt: import_v36.z.string().min(1).max(1e4).optional()
+        }),
         import_v36.z.object({
           type: import_v36.z.literal("slack"),
           workspace_id: import_v36.z.string(),
           channel: import_v36.z.string(),
-          message_template: import_v36.z.string().optional()
+          message_template: import_v36.z.string().optional(),
+          formatting_prompt: import_v36.z.string().min(1).max(1e4).optional()
         })
       ])
     }),
+    WindowedAutomationConfig,
     TopicAutomationConfig,
     TopicDigestAutomationConfig
   ])
 });
+var ProjectGroup = 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(),
+  deleted_at: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  member_projects: import_v36.z.array(import_v36.z.string().uuid()).max(1e4)
+});
 var ProjectLogsEvent = import_v36.z.object({
   id: import_v36.z.string(),
   _xact_id: import_v36.z.string(),
@@ -4146,7 +4412,8 @@ var RunEval = import_v36.z.object({
       dataset_environment: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
       _internal_btql: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional()
     }),
-    import_v36.z.object({ data: import_v36.z.array(import_v36.z.unknown()) })
+    import_v36.z.object({ data: import_v36.z.array(import_v36.z.unknown()) }),
+    import_v36.z.object({ experiment_name: import_v36.z.string() })
   ]),
   name: import_v36.z.string().optional(),
   parameters: import_v36.z.object({}).partial().passthrough().optional(),
@@ -4351,7 +4618,9 @@ var View = import_v36.z.object({
     "for_review_datasets"
   ]),
   name: import_v36.z.string(),
+  description: 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(),
+  updated_at: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   view_data: ViewData.optional(),
   options: ViewOptions.optional(),
   user_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
@@ -5426,6 +5695,7 @@ var INSTRUMENTATION_NAMES = {
   CLAUDE_AGENT_SDK: "claude-agent-sdk",
   CLOUDFLARE_AI_CHAT: "cloudflare-ai-chat",
   CLOUDFLARE_AGENTS: "cloudflare-agents",
+  CLOUDFLARE_THINK: "cloudflare-think",
   COHERE: "cohere",
   CURSOR_SDK: "cursor-sdk",
   EVE: "eve",
@@ -5440,18 +5710,20 @@ var INSTRUMENTATION_NAMES = {
   LANGSMITH: "langsmith",
   MASTRA: "mastra",
   MISTRAL: "mistral",
+  OLLAMA: "ollama",
   OPENAI: "openai",
   OPENAI_AGENTS: "openai-agents",
   OPENAI_CODEX: "openai-codex",
   OPENROUTER: "openrouter",
   OPENROUTER_AGENT: "openrouter-agent",
   PI_CODING_AGENT: "pi-coding-agent",
-  STRANDS_AGENT_SDK: "strands-agent-sdk"
+  STRANDS_AGENT_SDK: "strands-agent-sdk",
+  VOYAGEAI: "voyageai"
 };
 var INTERNAL_SPAN_INSTRUMENTATION_NAME = /* @__PURE__ */ Symbol.for(
   "braintrust.spanInstrumentationName"
 );
-var SDK_VERSION = true ? "3.26.0" : "0.0.0";
+var SDK_VERSION = true ? "3.28.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -5646,6 +5918,9 @@ function applyMaskingToField(maskingFunction, data, fieldName) {
 var INITIAL_SPAN_WRITE_AS_MERGE = /* @__PURE__ */ Symbol(
   "braintrust.initial-span-write-as-merge"
 );
+var RESUME_SPAN_WITHOUT_INITIAL_WRITE = /* @__PURE__ */ Symbol(
+  "braintrust.resume-span-without-initial-write"
+);
 var INTERNAL_SPAN_CONTEXT = /* @__PURE__ */ Symbol("braintrust.internal-span-context");
 var BRAINTRUST_CURRENT_SPAN_STORE = /* @__PURE__ */ Symbol.for(
   "braintrust.currentSpanStore"
@@ -8495,7 +8770,7 @@ var ObjectFetcher = class {
     const objectId = await this.id;
     const batchLimit = batchSize ?? DEFAULT_FETCH_BATCH_SIZE;
     const internalLimit = getInternalBtqlLimit(this._internal_btql);
-    const limit = batchSize !== void 0 ? batchSize : internalLimit ?? batchLimit;
+    let remainingLimit = internalLimit;
     const internalBtqlWithoutReservedQueryKeys = Object.fromEntries(
       Object.entries(this._internal_btql ?? {}).filter(
         ([key]) => key !== "cursor" && key !== "limit" && key !== "select" && key !== "from"
@@ -8504,6 +8779,10 @@ var ObjectFetcher = class {
     let cursor = void 0;
     let iterations = 0;
     while (true) {
+      if (remainingLimit !== void 0 && remainingLimit <= 0) {
+        return;
+      }
+      const limit = remainingLimit === void 0 ? batchLimit : Math.min(batchLimit, remainingLimit);
       const resp = await state.apiConn().post(
         `btql`,
         {
@@ -8543,7 +8822,14 @@ var ObjectFetcher = class {
       const respJson = await resp.json();
       const mutate = this.mutateRecord;
       for (const record of respJson.data ?? []) {
-        yield mutate ? mutate(record) : record;
+        if (remainingLimit !== void 0 && remainingLimit <= 0) {
+          return;
+        }
+        const mutatedRecord = mutate ? mutate(record) : record;
+        if (remainingLimit !== void 0) {
+          remainingLimit--;
+        }
+        yield mutatedRecord;
       }
       if (!respJson.cursor) {
         break;
@@ -9020,7 +9306,9 @@ var SpanImpl = class _SpanImpl {
     this._rootSpanId = resolvedIds.rootSpanId;
     this._spanParents = resolvedIds.spanParents;
     this.isMerge = args[INITIAL_SPAN_WRITE_AS_MERGE] === true;
-    this.logInternal({ event, internalData });
+    if (!args[RESUME_SPAN_WITHOUT_INITIAL_WRITE]) {
+      this.logInternal({ event, internalData });
+    }
     this.isMerge = true;
   }
   getParentInfo() {
@@ -10472,6 +10760,33 @@ function traceStreamingChannel(channel2, config) {
       const { span, startTime } = spanData;
       if (isAsyncIterable(asyncEndEvent.result)) {
         let firstChunkTime;
+        const handleStreamError = (error) => {
+          try {
+            span.log({ error });
+          } catch (loggingError) {
+            debugLogger.error(
+              `Error logging failure for ${channelName}:`,
+              loggingError
+            );
+          }
+          try {
+            span.end();
+          } catch (endingError) {
+            debugLogger.error(
+              `Error ending span for ${channelName}:`,
+              endingError
+            );
+          }
+          states.delete(event);
+          runStreamingErrorHook({
+            channelName,
+            config,
+            error,
+            event: asyncEndEvent,
+            span,
+            startTime
+          });
+        };
         patchStreamIfNeeded(asyncEndEvent.result, {
           onChunk: () => {
             if (firstChunkTime === void 0) {
@@ -10551,33 +10866,12 @@ function traceStreamingChannel(channel2, config) {
               });
             }
           },
-          onError: (error) => {
-            try {
-              span.log({ error });
-            } catch (loggingError) {
-              debugLogger.error(
-                `Error logging failure for ${channelName}:`,
-                loggingError
-              );
-            }
-            try {
-              span.end();
-            } catch (endingError) {
-              debugLogger.error(
-                `Error ending span for ${channelName}:`,
-                endingError
-              );
-            }
-            states.delete(event);
-            runStreamingErrorHook({
-              channelName,
-              config,
-              error,
-              event: asyncEndEvent,
-              span,
-              startTime
-            });
-          }
+          onCancel: () => {
+            const error = new Error("Stream cancelled before completion");
+            error.name = "AbortError";
+            handleStreamError(error);
+          },
+          onError: handleStreamError
         });
         return;
       }
@@ -10893,6 +11187,22 @@ function processInputAttachments(input) {
         };
       }
     }
+    const voyageBase64Key = node.type === "image_base64" ? Object.hasOwn(node, "imageBase64") ? "imageBase64" : "image_base64" : node.type === "video_base64" ? Object.hasOwn(node, "videoBase64") ? "videoBase64" : "video_base64" : void 0;
+    const voyageBase64Value = voyageBase64Key ? node[voyageBase64Key] : void 0;
+    if (voyageBase64Key && typeof voyageBase64Value === "string" && voyageBase64Value.startsWith("data:")) {
+      const mediaType = inferMediaTypeFromDataUrl(
+        voyageBase64Value,
+        node.type === "video_base64" ? "video/mp4" : "image/png"
+      );
+      const filename = `${node.type === "video_base64" ? "video" : "image"}.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(voyageBase64Value, mediaType, filename);
+      if (attachment) {
+        return {
+          ...node,
+          [voyageBase64Key]: attachment
+        };
+      }
+    }
     if (node.type === "file" && node.file && typeof node.file === "object" && typeof node.file.file_data === "string" && node.file.file_data.startsWith("data:")) {
       const mediaType = inferMediaTypeFromDataUrl(
         node.file.file_data,
@@ -10965,11 +11275,21 @@ function defineChannels(pkg, channels, options) {
         const tracingChannel2 = () => isomorph_default.newTracingChannel(
           fullChannelName
         );
+        const intercept2 = (interceptor) => {
+          const hook = tracingChannel2();
+          return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
+          };
+        };
         return [
           key,
           {
             ...asyncSpec,
             instrumentationName,
+            intercept: intercept2,
+            invoke: (target, thisArg, args, additional) => {
+              const hook = tracingChannel2();
+              return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
+            },
             tracingChannel: tracingChannel2,
             tracePromise: (fn, context) => tracingChannel2().tracePromise(
               fn,
@@ -10983,11 +11303,21 @@ function defineChannels(pkg, channels, options) {
       const tracingChannel = () => isomorph_default.newTracingChannel(
         fullChannelName
       );
+      const intercept = (interceptor) => {
+        const hook = tracingChannel();
+        return typeof hook.intercept === "function" ? hook.intercept(interceptor) : () => {
+        };
+      };
       return [
         key,
         {
           ...syncSpec,
           instrumentationName,
+          intercept,
+          invoke: (target, thisArg, args, additional) => {
+            const hook = tracingChannel();
+            return typeof hook.invoke === "function" ? hook.invoke(target, thisArg, args, additional) : Reflect.apply(target, thisArg, args);
+          },
           tracingChannel,
           traceSync: (fn, context) => tracingChannel().traceSync(
             fn,
@@ -12220,12 +12550,30 @@ function logInstrumentationError(context, error) {
 
 // src/wrappers/anthropic-tokens-util.ts
 function finalizeAnthropicTokens(metrics) {
-  const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + (metrics.prompt_cache_creation_tokens || 0);
-  return {
+  const hasSplitCacheCreationTokens = metrics.prompt_cache_creation_5m_tokens !== void 0 || metrics.prompt_cache_creation_1h_tokens !== void 0;
+  const splitCacheCreationTokens = (metrics.prompt_cache_creation_5m_tokens || 0) + (metrics.prompt_cache_creation_1h_tokens || 0);
+  const aggregateCacheCreationTokens = metrics.prompt_cache_creation_tokens || 0;
+  const effectiveCacheCreationTokens = Math.max(
+    aggregateCacheCreationTokens,
+    splitCacheCreationTokens
+  );
+  const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + effectiveCacheCreationTokens;
+  const finalized = {
     ...metrics,
     prompt_tokens,
     tokens: prompt_tokens + (metrics.completion_tokens || 0)
   };
+  if (hasSplitCacheCreationTokens && splitCacheCreationTokens >= aggregateCacheCreationTokens) {
+    delete finalized.prompt_cache_creation_tokens;
+  }
+  return finalized;
+}
+function toNumericMetrics(metrics) {
+  return Object.fromEntries(
+    Object.entries(metrics).filter(
+      (entry) => entry[1] !== void 0
+    )
+  );
 }
 function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens = 0) {
   const cacheTokens = {};
@@ -12238,6 +12586,12 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
   return cacheTokens;
 }
 
+// src/wrappers/anthropic-session-collector.ts
+var sessionStreamCollectors = /* @__PURE__ */ new WeakMap();
+function registerAnthropicSessionStreamCollector(stream, collector) {
+  sessionStreamCollectors.set(stream, collector);
+}
+
 // src/instrumentation/plugins/anthropic-channels.ts
 var anthropicChannels = defineChannels(
   "@anthropic-ai/sdk",
@@ -12253,6 +12607,14 @@ var anthropicChannels = defineChannels(
     betaMessagesToolRunner: channel({
       channelName: "beta.messages.toolRunner",
       kind: "sync-stream"
+    }),
+    betaSessionsEventsStream: channel({
+      channelName: "beta.sessions.events.stream",
+      kind: "async"
+    }),
+    betaSessionsThreadsEventsStream: channel({
+      channelName: "beta.sessions.threads.events.stream",
+      kind: "async"
     })
   },
   { instrumentationName: INSTRUMENTATION_NAMES.ANTHROPIC }
@@ -12266,6 +12628,7 @@ var AnthropicPlugin = class extends BasePlugin {
   onEnable() {
     this.subscribeToAnthropicChannels();
     this.subscribeToAnthropicToolRunner();
+    this.subscribeToAnthropicSessionStreams();
   }
   onDisable() {
     this.unsubscribers = unsubscribeAll(this.unsubscribers);
@@ -12383,7 +12746,411 @@ var AnthropicPlugin = class extends BasePlugin {
       tracingChannel.unsubscribe(handlers);
     });
   }
+  subscribeToAnthropicSessionStreams() {
+    this.subscribeToAnthropicSessionStream(
+      anthropicChannels.betaSessionsEventsStream,
+      false
+    );
+    this.subscribeToAnthropicSessionStream(
+      anthropicChannels.betaSessionsThreadsEventsStream,
+      true
+    );
+  }
+  subscribeToAnthropicSessionStream(channel2, isThread) {
+    const tracingChannel = channel2.tracingChannel();
+    const pending = /* @__PURE__ */ new WeakSet();
+    const handlers = {
+      start: (event) => {
+        if (isAutoInstrumentationSuppressed()) {
+          return;
+        }
+        pending.add(event);
+      },
+      asyncEnd: (event) => {
+        if (!pending.delete(event)) {
+          return;
+        }
+        const stream = event.result;
+        if (!isAsyncIterable(stream)) {
+          return;
+        }
+        registerAnthropicSessionStreamCollector(stream, () => {
+          wrapAnthropicSessionEventStream(stream, isThread);
+        });
+      },
+      error: (event) => {
+        pending.delete(event);
+      }
+    };
+    tracingChannel.subscribe(handlers);
+    this.unsubscribers.push(() => tracingChannel.unsubscribe(handlers));
+  }
 };
+function wrapAnthropicSessionEventStream(stream, isThread) {
+  const state = {
+    history: [],
+    isThread,
+    pendingInput: [],
+    seenEventIds: /* @__PURE__ */ new Set()
+  };
+  patchStreamIfNeeded(stream, {
+    onChunk: (event) => handleAnthropicSessionEvent(state, event),
+    onComplete: () => finalizeAnthropicSessionTurn(state),
+    onError: (error) => finalizeAnthropicSessionTurn(state, error)
+  });
+  return stream;
+}
+function handleAnthropicSessionEvent(state, event) {
+  try {
+    if (typeof event.id === "string" && event.type !== "event_delta" && state.seenEventIds.has(event.id)) {
+      return;
+    }
+    if (typeof event.id === "string" && event.type !== "event_delta") {
+      state.seenEventIds.add(event.id);
+    }
+    switch (event.type) {
+      case "user.message":
+      case "system.message":
+        recordAnthropicSessionInput(
+          state,
+          event
+        );
+        break;
+      case "session.status_running":
+        if (!state.isThread) {
+          ensureAnthropicSessionTurn(state);
+        }
+        break;
+      case "session.thread_status_running":
+        if (state.isThread) {
+          ensureAnthropicSessionTurn(state);
+        }
+        break;
+      case "span.model_request_start":
+        if (typeof event.id === "string") {
+          startAnthropicSessionModel(state, event.id);
+        }
+        break;
+      case "event_delta":
+        recordAnthropicSessionFirstToken(state, event);
+        break;
+      case "agent.message":
+        recordAnthropicSessionMessage(
+          state,
+          event
+        );
+        break;
+      case "agent.custom_tool_use":
+      case "agent.mcp_tool_use":
+      case "agent.tool_use":
+        startAnthropicSessionTool(state, event);
+        break;
+      case "user.tool_confirmation":
+        recordAnthropicSessionToolConfirmation(state, event);
+        break;
+      case "agent.mcp_tool_result":
+      case "agent.tool_result":
+      case "user.custom_tool_result":
+      case "user.tool_result":
+        finalizeAnthropicSessionTool(
+          state,
+          event
+        );
+        break;
+      case "span.model_request_end":
+        finalizeAnthropicSessionModel(
+          state,
+          event
+        );
+        break;
+      case "session.status_idle":
+      case "session.thread_status_idle": {
+        if (event.type === "session.status_idle" && state.isThread || event.type === "session.thread_status_idle" && !state.isThread) {
+          break;
+        }
+        const stopReason = isObject(event.stop_reason) ? event.stop_reason.type : void 0;
+        if (stopReason === "end_turn") {
+          finalizeAnthropicSessionTurn(state);
+        } else if (stopReason === "retries_exhausted") {
+          finalizeAnthropicSessionTurn(
+            state,
+            "Anthropic session retries exhausted"
+          );
+        }
+        break;
+      }
+      case "session.error":
+        finalizeAnthropicSessionTurn(state, event.error);
+        break;
+      case "session.deleted":
+      case "session.status_terminated":
+      case "session.thread_status_terminated":
+        if (event.type === "session.deleted" || event.type === "session.status_terminated" && !state.isThread || event.type === "session.thread_status_terminated" && state.isThread) {
+          finalizeAnthropicSessionTurn(state);
+        }
+        break;
+      default:
+        break;
+    }
+  } catch (error) {
+    debugLogger.debug("Error processing Anthropic Sessions event:", error);
+  }
+}
+function ensureAnthropicSessionTurn(state) {
+  if (state.activeTurn) {
+    return state.activeTurn;
+  }
+  const input = state.pendingInput;
+  state.pendingInput = [];
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          ...input.length > 0 ? { input } : {},
+          metadata: { provider: "anthropic" }
+        },
+        name: state.isThread ? "anthropic.beta.sessions.thread.turn" : "anthropic.beta.sessions.turn",
+        spanAttributes: { type: "task" /* TASK */ }
+      },
+      INSTRUMENTATION_NAMES.ANTHROPIC
+    )
+  );
+  state.activeTurn = {
+    activeTools: /* @__PURE__ */ new Map(),
+    input: input.slice(),
+    metrics: {},
+    span
+  };
+  return state.activeTurn;
+}
+function recordAnthropicSessionInput(state, event) {
+  const content = processAttachmentsInInput(event.content);
+  const message = {
+    role: event.type === "system.message" ? "system" : "user",
+    content
+  };
+  state.history.push(message);
+  if (state.activeTurn) {
+    state.activeTurn.input.push(message);
+  } else {
+    state.pendingInput.push(message);
+  }
+}
+function startAnthropicSessionModel(state, startEventId) {
+  const turn = ensureAnthropicSessionTurn(state);
+  if (turn.activeModel) {
+    finalizeAnthropicSessionModelState(state, turn);
+  }
+  const span = withCurrent(
+    turn.span,
+    () => startSpan(
+      withSpanInstrumentationName(
+        {
+          event: {
+            ...state.history.length > 0 ? { input: state.history.slice() } : {},
+            metadata: { provider: "anthropic" }
+          },
+          name: "anthropic.messages.create",
+          spanAttributes: { type: "llm" /* LLM */ }
+        },
+        INSTRUMENTATION_NAMES.ANTHROPIC
+      )
+    )
+  );
+  turn.activeModel = {
+    output: [],
+    span,
+    startEventId,
+    startTime: getCurrentUnixTimestamp()
+  };
+}
+function recordAnthropicSessionFirstToken(state, event) {
+  const model = state.activeTurn?.activeModel;
+  if (!model || model.firstTokenTime !== void 0 || !isObject(event.delta) || !isObject(event.delta.content) || typeof event.delta.content.text !== "string") {
+    return;
+  }
+  model.firstTokenTime = getCurrentUnixTimestamp();
+}
+function recordAnthropicSessionMessage(state, event) {
+  const turn = ensureAnthropicSessionTurn(state);
+  const content = processAttachmentsInInput(
+    event.content
+  );
+  if (turn.activeModel) {
+    turn.activeModel.output.push(...content);
+  } else {
+    const output = { role: "assistant", content };
+    turn.lastOutput = output;
+    state.history.push(output);
+  }
+}
+function startAnthropicSessionTool(state, event) {
+  const turn = ensureAnthropicSessionTurn(state);
+  if (turn.activeModel) {
+    turn.activeModel.output.push({
+      type: "tool_use",
+      id: event.id,
+      name: event.name,
+      input: event.input
+    });
+  }
+  const existing = turn.activeTools.get(event.id);
+  if (existing) {
+    existing.span.end();
+    turn.activeTools.delete(event.id);
+  }
+  const span = withCurrent(
+    turn.span,
+    () => startSpan(
+      withSpanInstrumentationName(
+        {
+          event: { input: event.input },
+          name: event.name,
+          spanAttributes: { type: "tool" /* TOOL */ }
+        },
+        INSTRUMENTATION_NAMES.ANTHROPIC
+      )
+    )
+  );
+  const toolState = {
+    approval: event.evaluated_permission === "allow" ? "approved" : event.evaluated_permission === "deny" ? "denied" : void 0,
+    span
+  };
+  turn.activeTools.set(event.id, toolState);
+  if (toolState.approval === "denied") {
+    finalizeAnthropicSessionToolState(toolState);
+    turn.activeTools.delete(event.id);
+  }
+}
+function recordAnthropicSessionToolConfirmation(state, event) {
+  if (typeof event.tool_use_id !== "string" || event.result !== "allow" && event.result !== "deny") {
+    return;
+  }
+  const turn = state.activeTurn;
+  const tool = turn?.activeTools.get(event.tool_use_id);
+  if (!turn || !tool) {
+    return;
+  }
+  tool.approval = event.result === "allow" ? "approved" : "denied";
+  if (tool.approval === "denied") {
+    finalizeAnthropicSessionToolState(tool);
+    turn.activeTools.delete(event.tool_use_id);
+  }
+}
+function finalizeAnthropicSessionTool(state, event) {
+  const toolUseId = event.tool_use_id ?? event.mcp_tool_use_id ?? event.custom_tool_use_id;
+  if (!toolUseId) {
+    return;
+  }
+  const content = processAttachmentsInInput(event.content);
+  const turn = state.activeTurn;
+  const tool = turn?.activeTools.get(toolUseId);
+  if (turn && tool) {
+    finalizeAnthropicSessionToolState(tool, event, content);
+    turn.activeTools.delete(toolUseId);
+  }
+  const toolResult = {
+    type: "tool_result",
+    tool_use_id: toolUseId,
+    ...content !== void 0 ? { content } : {},
+    ...event.is_error === true ? { is_error: true } : {}
+  };
+  state.history.push({
+    role: "user",
+    content: [toolResult]
+  });
+}
+function finalizeAnthropicSessionToolState(state, event, content = event?.content) {
+  safeAnthropicSessionLog(state.span, {
+    ...event?.is_error === true ? {
+      error: content ?? "Anthropic session tool execution failed"
+    } : {},
+    ...state.approval ? { metadata: { tool_approval: state.approval } } : {},
+    ...content !== void 0 ? { output: content } : {}
+  });
+  state.span.end();
+}
+function finalizeAnthropicSessionModel(state, event) {
+  const turn = state.activeTurn;
+  const model = turn?.activeModel;
+  if (!turn || !model || model.startEventId !== event.model_request_start_id) {
+    return;
+  }
+  finalizeAnthropicSessionModelState(state, turn, event);
+}
+function finalizeAnthropicSessionModelState(state, turn, event) {
+  const model = turn.activeModel;
+  if (!model) {
+    return;
+  }
+  turn.activeModel = void 0;
+  const metrics = event ? parseAnthropicSessionModelUsage(event.model_usage) : {};
+  if (model.firstTokenTime !== void 0) {
+    metrics.time_to_first_token = model.firstTokenTime - model.startTime;
+  }
+  const output = model.output.length > 0 ? { role: "assistant", content: model.output } : void 0;
+  safeAnthropicSessionLog(model.span, {
+    ...event?.is_error ? { error: "Anthropic session model request failed" } : {},
+    ...Object.keys(metrics).length > 0 ? { metrics } : {},
+    ...output ? { output } : {}
+  });
+  model.span.end();
+  if (output) {
+    turn.lastOutput = output;
+    state.history.push(output);
+  }
+  for (const key of [
+    "prompt_tokens",
+    "completion_tokens",
+    "tokens",
+    "prompt_cached_tokens",
+    "prompt_cache_creation_tokens"
+  ]) {
+    const value = metrics[key];
+    if (typeof value === "number") {
+      turn.metrics[key] = (turn.metrics[key] ?? 0) + value;
+    }
+  }
+}
+function parseAnthropicSessionModelUsage(usage) {
+  const finalized = finalizeAnthropicTokens({
+    completion_tokens: usage.output_tokens,
+    prompt_cache_creation_tokens: usage.cache_creation_input_tokens,
+    prompt_cached_tokens: usage.cache_read_input_tokens,
+    prompt_tokens: usage.input_tokens
+  });
+  return Object.fromEntries(
+    Object.entries(finalized).filter(
+      (entry) => entry[1] !== void 0
+    )
+  );
+}
+function finalizeAnthropicSessionTurn(state, error) {
+  const turn = state.activeTurn;
+  if (!turn) {
+    return;
+  }
+  state.activeTurn = void 0;
+  finalizeAnthropicSessionModelState(state, turn);
+  for (const tool of turn.activeTools.values()) {
+    finalizeAnthropicSessionToolState(tool);
+  }
+  turn.activeTools.clear();
+  safeAnthropicSessionLog(turn.span, {
+    ...error !== void 0 ? { error: error instanceof Error ? error : toLoggedError(error) } : {},
+    ...turn.input.length > 0 ? { input: turn.input } : {},
+    ...turn.lastOutput ? { output: turn.lastOutput } : {},
+    ...Object.keys(turn.metrics).length > 0 ? { metrics: turn.metrics } : {}
+  });
+  turn.span.end();
+}
+function safeAnthropicSessionLog(span, event) {
+  try {
+    span.log(event);
+  } catch (error) {
+    debugLogger.debug("Error logging Anthropic Sessions span:", error);
+  }
+}
 function parseMetricsFromUsage2(usage) {
   if (!usage) {
     return {};
@@ -12399,6 +13166,18 @@ function parseMetricsFromUsage2(usage) {
   saveIfExistsTo("output_tokens", "completion_tokens");
   saveIfExistsTo("cache_read_input_tokens", "prompt_cached_tokens");
   saveIfExistsTo("cache_creation_input_tokens", "prompt_cache_creation_tokens");
+  if (isObject(usage.cache_creation)) {
+    const cacheCreation = usage.cache_creation;
+    for (const [source, target] of [
+      ["ephemeral_5m_input_tokens", "prompt_cache_creation_5m_tokens"],
+      ["ephemeral_1h_input_tokens", "prompt_cache_creation_1h_tokens"]
+    ]) {
+      const value = cacheCreation[source];
+      if (typeof value === "number") {
+        metrics[target] = value;
+      }
+    }
+  }
   if (isObject(usage.server_tool_use)) {
     for (const [name, value] of Object.entries(usage.server_tool_use)) {
       if (typeof value === "number") {
@@ -14257,6 +15036,29 @@ var harnessAgentChannels = defineChannels(
   { instrumentationName: INSTRUMENTATION_NAMES.AI_SDK }
 );
 
+// src/instrumentation/plugins/cloudflare-think-context.ts
+var cloudflareThinkSpans = /* @__PURE__ */ new Map();
+function registerCloudflareThinkSpan(span) {
+  if (span.spanId) {
+    cloudflareThinkSpans.set(span.spanId, span);
+  }
+}
+function unregisterCloudflareThinkSpan(span) {
+  if (span.spanId) {
+    cloudflareThinkSpans.delete(span.spanId);
+  }
+}
+function currentCloudflareThinkSpan() {
+  const parentSpanIds = _internalGetGlobalState()?.contextManager.getParentSpanIds()?.spanParents ?? [];
+  for (const parentSpanId of parentSpanIds) {
+    const span = cloudflareThinkSpans.get(parentSpanId);
+    if (span) {
+      return span;
+    }
+  }
+  return void 0;
+}
+
 // src/instrumentation/plugins/ai-sdk-plugin.ts
 var DEFAULT_DENY_OUTPUT_PATHS = [
   // v3
@@ -14363,6 +15165,7 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.streamText, {
         name: "streamText",
         type: "function" /* FUNCTION */,
+        shouldTrace: () => currentCloudflareThinkSpan() === void 0,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
@@ -14383,6 +15186,7 @@ var AISDKPlugin = class extends BasePlugin {
       traceSyncStreamChannel(aiSDKChannels.streamTextSync, {
         name: "streamText",
         type: "function" /* FUNCTION */,
+        shouldTrace: () => currentCloudflareThinkSpan() === void 0,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
           defaultDenyOutputPaths: denyOutputPaths,
@@ -15368,6 +16172,23 @@ function prepareAISDKWorkflowAgentStreamInput(params, event, span, defaultDenyOu
     metadata
   };
 }
+function prepareAISDKAgentCallInput(params, event, span, defaultDenyOutputPaths = DEFAULT_DENY_OUTPUT_PATHS) {
+  const { input } = processAISDKWorkflowAgentCallInput(params);
+  const metadata = extractMetadataFromCallParams(params, event.self);
+  const childTracing = prepareAISDKChildTracing(
+    params,
+    event.self,
+    span,
+    defaultDenyOutputPaths,
+    event.aiSDK,
+    { agentOwner: true }
+  );
+  event.modelWrapped = childTracing.modelWrapped;
+  if (childTracing.cleanup) {
+    event.__braintrust_ai_sdk_cleanup = childTracing.cleanup;
+  }
+  return { input, metadata };
+}
 function prepareAISDKEmbedInput(params, self) {
   return {
     input: { ...params },
@@ -15391,6 +16212,18 @@ function extractTopLevelAISDKMetrics(result, event, startTime) {
   }
   return metrics;
 }
+async function extractResolvedAISDKTokenMetrics(result) {
+  for (const field of ["totalUsage", "usage"]) {
+    try {
+      const usage = await Promise.resolve(result[field]);
+      if (usage !== void 0) {
+        return extractTokenMetrics({ [field]: usage });
+      }
+    } catch {
+    }
+  }
+  return extractTokenMetrics(result);
+}
 function hasModelChildTracing(event) {
   return event?.modelWrapped === true || event?.__braintrust_ai_sdk_model_wrapped === true;
 }
@@ -16208,13 +17041,15 @@ function patchAISDKStreamingResult(args) {
   const {
     defaultDenyOutputPaths,
     endEvent,
+    forceTopLevelMetrics,
     onComplete,
     onCancel,
     onError,
     result,
     resolvePromiseUsage,
     span,
-    startTime
+    startTime,
+    transformOutput
   } = args;
   if (!result || typeof result !== "object") {
     return false;
@@ -16267,8 +17102,8 @@ function patchAISDKStreamingResult(args) {
     }
     outputLogged = true;
     try {
-      const metrics = extractTopLevelAISDKMetrics(result, endEvent);
-      if (resolvePromiseUsage) {
+      const metrics = forceTopLevelMetrics ? await extractResolvedAISDKTokenMetrics(result) : extractTopLevelAISDKMetrics(result, endEvent);
+      if (resolvePromiseUsage && !forceTopLevelMetrics) {
         try {
           const resultRecord2 = result;
           const pendingUsage = resultRecord2.totalUsage ?? resultRecord2.usage;
@@ -16287,10 +17122,11 @@ function patchAISDKStreamingResult(args) {
       if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
         metrics.time_to_first_token = firstChunkTime - startTime;
       }
-      const output = await processAISDKStreamingOutput(
+      const processedOutput = await processAISDKStreamingOutput(
         result,
         resolveDenyOutputPaths(endEvent, defaultDenyOutputPaths)
       );
+      const output = transformOutput ? transformOutput(processedOutput) : processedOutput;
       const metadata = buildResolvedMetadataPayload(result).metadata;
       try {
         span.log({
@@ -17640,37 +18476,97 @@ function seedTaskToolUseIdMapping(taskIdToToolUseId, message) {
     taskIdToToolUseId.set(message.task_id, message.tool_use_id);
   }
 }
-function extractUsageFromMessage(message) {
-  const metrics = {};
-  let usage;
-  if (message.type === "assistant") {
-    usage = message.message?.usage;
-  } else if (message.type === "result") {
-    usage = message.usage;
-  }
+function tokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function copyUsage(usage) {
   if (!usage || typeof usage !== "object") {
-    return metrics;
+    return void 0;
+  }
+  const copy = {};
+  for (const key of [
+    "input_tokens",
+    "output_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens"
+  ]) {
+    const value = tokenCount(Reflect.get(usage, key));
+    if (value !== void 0) {
+      copy[key] = value;
+    }
+  }
+  const cacheCreation = Reflect.get(usage, "cache_creation");
+  if (cacheCreation && typeof cacheCreation === "object") {
+    const cacheCreationCopy = {};
+    for (const key of [
+      "ephemeral_5m_input_tokens",
+      "ephemeral_1h_input_tokens"
+    ]) {
+      const value = tokenCount(Reflect.get(cacheCreation, key));
+      if (value !== void 0) {
+        cacheCreationCopy[key] = value;
+      }
+    }
+    if (Object.keys(cacheCreationCopy).length > 0) {
+      copy.cache_creation = cacheCreationCopy;
+    }
+  }
+  return Object.keys(copy).length > 0 ? copy : void 0;
+}
+function mergeUsage(base, override) {
+  if (!base || !override) {
+    return override ?? base;
+  }
+  const cacheCreation = base.cache_creation || override.cache_creation ? { ...base.cache_creation, ...override.cache_creation } : void 0;
+  return {
+    ...base,
+    ...override,
+    ...cacheCreation && { cache_creation: cacheCreation }
+  };
+}
+function extractUsage(usage, includeOutput) {
+  const metrics = {};
+  if (!usage) {
+    return {};
   }
   const inputTokens = getNumberProperty(usage, "input_tokens");
   if (inputTokens !== void 0) {
     metrics.prompt_tokens = inputTokens;
   }
-  const outputTokens = getNumberProperty(usage, "output_tokens");
-  if (outputTokens !== void 0) {
-    metrics.completion_tokens = outputTokens;
+  if (includeOutput) {
+    const outputTokens = getNumberProperty(usage, "output_tokens");
+    if (outputTokens !== void 0) {
+      metrics.completion_tokens = outputTokens;
+    }
   }
   const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
   const cacheCreationTokens = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
-  if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
-    Object.assign(
-      metrics,
-      extractAnthropicCacheTokens(cacheReadTokens, cacheCreationTokens)
-    );
+  Object.assign(
+    metrics,
+    extractAnthropicCacheTokens(cacheReadTokens, cacheCreationTokens)
+  );
+  const cacheCreation5mTokens = getNumberProperty(
+    usage.cache_creation,
+    "ephemeral_5m_input_tokens"
+  );
+  const cacheCreation1hTokens = getNumberProperty(
+    usage.cache_creation,
+    "ephemeral_1h_input_tokens"
+  );
+  if (cacheCreation5mTokens !== void 0) {
+    metrics.prompt_cache_creation_5m_tokens = cacheCreation5mTokens;
   }
-  if (Object.keys(metrics).length > 0) {
-    Object.assign(metrics, finalizeAnthropicTokens(metrics));
+  if (cacheCreation1hTokens !== void 0) {
+    metrics.prompt_cache_creation_1h_tokens = cacheCreation1hTokens;
   }
-  return metrics;
+  if (Object.keys(metrics).length === 0) {
+    return {};
+  }
+  const finalized = finalizeAnthropicTokens(metrics);
+  if (metrics.completion_tokens === void 0) {
+    delete finalized.tokens;
+  }
+  return toNumericMetrics(finalized);
 }
 function buildLLMInput(promptMessages, conversationHistory) {
   const inputParts = [...promptMessages, ...conversationHistory];
@@ -17704,16 +18600,16 @@ function buildRootPromptMessages(prompt, capturedPromptMessages) {
 function formatCapturedMessages(messages) {
   return messages.length > 0 ? messages : [];
 }
-async function createLLMSpanForMessages(messages, promptMessages, conversationHistory, options, startTime, parentSpan, existingSpan) {
+async function createLLMSpanForMessages(messages, promptMessages, conversationHistory, options, startTime, parentSpan, usage, hasFinalOutputUsage, existingSpan) {
   if (messages.length === 0) {
     return void 0;
   }
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !lastMessage.message?.usage) {
+  if (lastMessage.type !== "assistant") {
     return void 0;
   }
-  const model = lastMessage.message.model || options.model;
-  const usage = extractUsageFromMessage(lastMessage);
+  const model = lastMessage.message?.model || options.model;
+  const metrics = options.includePartialMessages ? extractUsage(usage, hasFinalOutputUsage) : {};
   const input = buildLLMInput(promptMessages, conversationHistory);
   const outputs = messages.map(
     (m) => m.message?.content && m.message?.role ? { content: m.message.content, role: m.message.role } : void 0
@@ -17735,8 +18631,8 @@ async function createLLMSpanForMessages(messages, promptMessages, conversationHi
   );
   span.log({
     input,
-    metadata: model ? { model } : void 0,
-    metrics: usage,
+    metadata: { ...model && { model }, provider: "anthropic" },
+    ...Object.keys(metrics).length > 0 ? { metrics } : {},
     output: outputs
   });
   const spanExport = await span.export();
@@ -17826,11 +18722,17 @@ function prepareLocalToolHandlersInMcpServers(mcpServers) {
   }
   return { hasLocalToolHandlers, localToolHookNames };
 }
-function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
+function createToolTracingHooks(resolveParentSpan, taskIdToToolUseId, toolUseToParent, activeToolSpans, mcpServers, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
   const preToolUse = async (input, toolUseID) => {
     if (input.hook_event_name !== "PreToolUse" || !toolUseID) {
       return {};
     }
+    if (!toolUseToParent.has(toolUseID) && input.agent_id) {
+      const parentToolUseId = taskIdToToolUseId.get(input.agent_id);
+      if (parentToolUseId) {
+        toolUseToParent.set(toolUseID, parentToolUseId);
+      }
+    }
     if (skipLocalToolHooks && (isLocalToolUse(input.tool_name, mcpServers) || localToolHookNames.has(input.tool_name))) {
       return {};
     }
@@ -18026,9 +18928,6 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
     }
     const metadata = {
       ...subAgentDetailsToMetadata(details),
-      ...input.agent_transcript_path && {
-        "claude_agent_sdk.agent_transcript_path": input.agent_transcript_path
-      },
       "claude_agent_sdk.stop_hook_active": input.stop_hook_active
     };
     try {
@@ -18050,7 +18949,7 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
     subagentStop
   };
 }
-function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
+function injectTracingHooks(options, resolveParentSpan, taskIdToToolUseId, toolUseToParent, activeToolSpans, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
   const {
     preToolUse,
     postToolUse,
@@ -18059,6 +18958,8 @@ function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localTo
     subagentStop
   } = createToolTracingHooks(
     resolveParentSpan,
+    taskIdToToolUseId,
+    toolUseToParent,
     activeToolSpans,
     options.mcpServers,
     localToolHookNames,
@@ -18140,6 +19041,13 @@ async function finalizeCurrentMessageGroup(state) {
     }
   }
   const existingLlmSpan = state.activeLlmSpansByParentToolUse.get(parentKey);
+  const lastMessage = state.currentMessages[state.currentMessages.length - 1];
+  const messageId = lastMessage?.message?.id;
+  const usage = state.options.includePartialMessages ? mergeUsage(
+    copyUsage(lastMessage?.message?.usage),
+    messageId ? state.usageByMessageId.get(messageId) : void 0
+  ) : void 0;
+  const hasFinalOutputUsage = messageId !== void 0 && state.finalOutputUsageMessageIds.has(messageId);
   const llmSpanResult = await createLLMSpanForMessages(
     state.currentMessages,
     promptMessages,
@@ -18147,6 +19055,8 @@ async function finalizeCurrentMessageGroup(state) {
     state.options,
     state.currentMessageStartTime,
     parentSpan,
+    usage,
+    hasFinalOutputUsage,
     existingLlmSpan
   );
   if (llmSpanResult) {
@@ -18164,9 +19074,17 @@ async function finalizeCurrentMessageGroup(state) {
     }
   }
   state.activeLlmSpansByParentToolUse.delete(parentKey);
-  const lastMessage = state.currentMessages[state.currentMessages.length - 1];
-  if (lastMessage?.message?.usage) {
-    state.accumulatedOutputTokens += getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
+  if (messageId) {
+    state.usageByMessageId.delete(messageId);
+    state.finalOutputUsageMessageIds.delete(messageId);
+    for (const [
+      parent,
+      activeMessageId
+    ] of state.activePartialMessageIdByParentKey) {
+      if (activeMessageId === messageId) {
+        state.activePartialMessageIdByParentKey.delete(parent);
+      }
+    }
   }
   state.currentMessages.length = 0;
 }
@@ -18257,6 +19175,10 @@ async function ensureActiveLlmSpanForParentToolUse(rootSpan, activeLlmSpansByPar
     );
     llmParentSpan = await subAgentSpan.export();
   }
+  const racedLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
+  if (racedLlmSpan) {
+    return racedLlmSpan;
+  }
   const llmSpan = startSpan(
     withSpanInstrumentationName(
       {
@@ -18376,7 +19298,49 @@ async function maybeHandleTaskLifecycleMessage(state, message) {
   }
   return true;
 }
+function handlePartialUsageMessage(state, message) {
+  if (message.type !== "stream_event") {
+    return false;
+  }
+  const event = message.event;
+  if (!event || typeof event !== "object") {
+    return true;
+  }
+  const parentKey = llmParentKey(message.parent_tool_use_id ?? null);
+  if (event.type === "message_start") {
+    const messageId2 = event.message?.id;
+    const usage = copyUsage(event.message?.usage);
+    if (messageId2) {
+      state.activePartialMessageIdByParentKey.set(parentKey, messageId2);
+      if (usage) {
+        state.usageByMessageId.set(messageId2, usage);
+      }
+    }
+    return true;
+  }
+  const messageId = state.activePartialMessageIdByParentKey.get(parentKey);
+  if (!messageId) {
+    return true;
+  }
+  if (event.type === "message_delta") {
+    const update = copyUsage(event.usage);
+    if (update) {
+      const usage = state.usageByMessageId.get(messageId) ?? {};
+      Object.assign(usage, update);
+      state.usageByMessageId.set(messageId, usage);
+      if (update.output_tokens !== void 0) {
+        state.finalOutputUsageMessageIds.add(messageId);
+      }
+    }
+  } else if (event.type === "message_stop") {
+    state.activePartialMessageIdByParentKey.delete(parentKey);
+  }
+  return true;
+}
 async function handleStreamMessage(state, message) {
+  if (handlePartialUsageMessage(state, message)) {
+    return;
+  }
   maybeTrackToolUseContext(state, message);
   if (await maybeHandleTaskLifecycleMessage(state, message)) {
     return;
@@ -18423,36 +19387,9 @@ async function handleStreamMessage(state, message) {
     );
     state.currentMessages.push(message);
   }
-  if (message.type !== "result" || !message.usage) {
+  if (message.type !== "result") {
     return;
   }
-  const finalUsageMetrics = extractUsageFromMessage(message);
-  if (state.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
-    const lastMessage = state.currentMessages[state.currentMessages.length - 1];
-    if (lastMessage?.message?.usage) {
-      const adjustedTokens = finalUsageMetrics.completion_tokens - state.accumulatedOutputTokens;
-      if (adjustedTokens >= 0) {
-        lastMessage.message.usage.output_tokens = adjustedTokens;
-      }
-      const resultUsage = message.usage;
-      if (resultUsage && typeof resultUsage === "object") {
-        const cacheReadTokens = getNumberProperty(
-          resultUsage,
-          "cache_read_input_tokens"
-        );
-        if (cacheReadTokens !== void 0) {
-          lastMessage.message.usage.cache_read_input_tokens = cacheReadTokens;
-        }
-        const cacheCreationTokens = getNumberProperty(
-          resultUsage,
-          "cache_creation_input_tokens"
-        );
-        if (cacheCreationTokens !== void 0) {
-          lastMessage.message.usage.cache_creation_input_tokens = cacheCreationTokens;
-        }
-      }
-    }
-  }
   const metadata = {};
   if (message.num_turns !== void 0) {
     metadata.num_turns = message.num_turns;
@@ -18460,8 +19397,12 @@ async function handleStreamMessage(state, message) {
   if (message.session_id !== void 0) {
     metadata.session_id = message.session_id;
   }
-  if (Object.keys(metadata).length > 0) {
-    state.span.log({ metadata });
+  const metrics = state.options.includePartialMessages ? {} : extractUsage(copyUsage(message.usage), true);
+  if (Object.keys(metadata).length > 0 || Object.keys(metrics).length > 0) {
+    state.span.log({
+      ...Object.keys(metadata).length > 0 ? { metadata } : {},
+      ...Object.keys(metrics).length > 0 ? { metrics } : {}
+    });
   }
 }
 async function finalizeQuerySpan(state) {
@@ -18485,6 +19426,9 @@ async function finalizeQuerySpan(state) {
       llmSpan.end();
     }
     state.activeLlmSpansByParentToolUse.clear();
+    state.activePartialMessageIdByParentKey.clear();
+    state.finalOutputUsageMessageIds.clear();
+    state.usageByMessageId.clear();
     for (const toolSpan of state.activeToolSpans.values()) {
       toolSpan.end();
     }
@@ -18609,6 +19553,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         const optionsWithHooks = injectTracingHooks(
           options,
           resolveToolUseParentSpan,
+          taskIdToToolUseId,
+          toolUseToParent,
           activeToolSpans,
           localToolHookNames,
           skipLocalToolHooks,
@@ -18619,8 +19565,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         params.options = optionsWithHooks;
         event.arguments[0] = params;
         spans.set(event, {
-          accumulatedOutputTokens: 0,
           activeLlmSpansByParentToolUse,
+          activePartialMessageIdByParentKey: /* @__PURE__ */ new Map(),
           activeToolSpans,
           conversationHistoryByParentKey,
           capturedPromptMessages,
@@ -18628,6 +19574,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           currentMessageStartTime: startTime,
           currentMessages: [],
           endedSubAgentSpans,
+          finalOutputUsageMessageIds: /* @__PURE__ */ new Set(),
           finalResults: [],
           options: optionsWithHooks,
           originalPrompt,
@@ -18643,6 +19590,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           latestLlmParentBySubAgentToolUse,
           latestRootLlmParentRef,
           toolUseToParent,
+          usageByMessageId: /* @__PURE__ */ new Map(),
           localToolContext
         });
       },
@@ -18712,6 +19660,295 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
   }
 };
 
+// src/instrumentation/plugins/cloudflare-think-channels.ts
+var cloudflareThinkChannels = defineChannels(
+  "@cloudflare/think",
+  {
+    runInferenceLoop: channel({
+      channelName: "Think.runInferenceLoop",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.CLOUDFLARE_THINK }
+);
+
+// src/instrumentation/plugins/cloudflare-think-plugin.ts
+var THINK_STATE_ID = /* @__PURE__ */ Symbol.for("braintrust.cloudflare-think.state-id");
+var CloudflareThinkPlugin = class extends BasePlugin {
+  statesBySpanId = /* @__PURE__ */ new Map();
+  onEnable() {
+    this.subscribeToThinkRuns();
+    this.subscribeToAISDKStreamTextSync();
+    this.subscribeToAISDKStreamTextAsync();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    for (const state of this.statesBySpanId.values()) {
+      this.finishState(state);
+    }
+    this.statesBySpanId.clear();
+  }
+  subscribeToThinkRuns() {
+    const channel2 = cloudflareThinkChannels.runInferenceLoop.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const state = _internalGetGlobalState();
+    const contextManager = state?.contextManager;
+    const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+    const ensureState2 = (event) => {
+      if (isAutoInstrumentationSuppressed()) {
+        return void 0;
+      }
+      const existing = states.get(event);
+      if (existing) {
+        return existing;
+      }
+      const span = startSpan(
+        withSpanInstrumentationName(
+          {
+            name: "Think.runTurn",
+            spanAttributes: { type: "task" /* TASK */ }
+          },
+          INSTRUMENTATION_NAMES.CLOUDFLARE_THINK
+        )
+      );
+      const runState = {
+        aiResultPatched: false,
+        fallbackInput: extractFallbackInput(event.self?.messages),
+        finalized: false,
+        inputLogged: false,
+        span,
+        startTime: getCurrentUnixTimestamp()
+      };
+      const metadata = {
+        braintrust: {
+          integration_name: "cloudflare-think",
+          sdk_language: "typescript"
+        }
+      };
+      if (typeof event.moduleVersion === "string") {
+        metadata["cloudflare_think.version"] = event.moduleVersion;
+      }
+      span.log({ metadata });
+      states.set(event, runState);
+      if (span.spanId) {
+        this.statesBySpanId.set(span.spanId, runState);
+      }
+      registerCloudflareThinkSpan(span);
+      return runState;
+    };
+    if (contextManager && currentSpanStore && channel2.start) {
+      channel2.start.bindStore(currentSpanStore, (event) => {
+        const runState = ensureState2(event);
+        return runState ? contextManager.wrapSpanForStore(runState.span) : currentSpanStore.getStore();
+      });
+      this.unsubscribers.push(
+        () => channel2.start?.unbindStore(currentSpanStore)
+      );
+    }
+    const handlers = {
+      start: (event) => {
+        ensureState2(event);
+      },
+      asyncEnd: (event) => {
+        const runState = states.get(event);
+        states.delete(event);
+        if (!runState || runState.finalized || runState.aiResultPatched) {
+          return;
+        }
+        this.finishState(runState, void 0, event.result);
+      },
+      error: (event) => {
+        const runState = states.get(event);
+        states.delete(event);
+        if (runState) {
+          this.finishState(runState, event.error);
+        }
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => channel2.unsubscribe(handlers));
+  }
+  subscribeToAISDKStreamTextSync() {
+    const channel2 = aiSDKChannels.streamTextSync.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        this.startAISDKStream(event);
+      },
+      end: (event) => {
+        this.endAISDKStream(event);
+      },
+      error: (event) => {
+        this.errorAISDKStream(event);
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => channel2.unsubscribe(handlers));
+  }
+  subscribeToAISDKStreamTextAsync() {
+    const channel2 = aiSDKChannels.streamText.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        this.startAISDKStream(event);
+      },
+      asyncEnd: (event) => {
+        this.endAISDKStream(event);
+      },
+      error: (event) => {
+        this.errorAISDKStream(event);
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => channel2.unsubscribe(handlers));
+  }
+  startAISDKStream(event) {
+    const runState = this.currentState();
+    if (!runState || runState.finalized) {
+      return;
+    }
+    try {
+      const prepared = prepareAISDKAgentCallInput(
+        event.arguments[0],
+        event,
+        runState.span
+      );
+      runState.span.log({
+        input: extractThinkTaskInput(prepared.input),
+        metadata: {
+          ...prepared.metadata,
+          braintrust: {
+            integration_name: "cloudflare-think",
+            sdk_language: "typescript"
+          }
+        }
+      });
+      runState.inputLogged = true;
+      runState.aiEvent = event;
+      Reflect.set(event, THINK_STATE_ID, runState.span.spanId);
+    } catch (error) {
+      debugLogger.error(
+        "Error preparing @cloudflare/think AI SDK tracing:",
+        error
+      );
+    }
+  }
+  endAISDKStream(event) {
+    const runState = this.stateForAISDKEvent(event);
+    if (!runState || runState.finalized) {
+      return;
+    }
+    const patched = patchAISDKStreamingResult({
+      defaultDenyOutputPaths: DEFAULT_DENY_OUTPUT_PATHS,
+      endEvent: event,
+      forceTopLevelMetrics: true,
+      onComplete: () => this.releaseState(runState),
+      result: event.result,
+      span: runState.span,
+      startTime: runState.startTime,
+      transformOutput: extractThinkTaskOutput
+    });
+    runState.aiResultPatched = patched;
+    if (!patched) {
+      this.finishState(runState, void 0, event.result);
+    }
+  }
+  errorAISDKStream(event) {
+    const runState = this.stateForAISDKEvent(event);
+    if (runState) {
+      this.finishState(runState, event.error);
+    }
+  }
+  currentState() {
+    const parentIds = _internalGetGlobalState()?.contextManager.getParentSpanIds()?.spanParents ?? [];
+    for (const parentId of parentIds) {
+      const state = this.statesBySpanId.get(parentId);
+      if (state) {
+        return state;
+      }
+    }
+    return void 0;
+  }
+  stateForAISDKEvent(event) {
+    const spanId = Reflect.get(event, THINK_STATE_ID);
+    return typeof spanId === "string" ? this.statesBySpanId.get(spanId) : void 0;
+  }
+  finishState(state, error, output) {
+    if (state.finalized) {
+      return;
+    }
+    state.finalized = true;
+    try {
+      if (!state.inputLogged && state.fallbackInput !== void 0) {
+        state.span.log({ input: state.fallbackInput });
+      }
+      if (error !== void 0) {
+        state.span.log({ error });
+      } else if (output !== void 0) {
+        state.span.log({ output: extractThinkTaskOutput(output) });
+      }
+      finalizeAISDKChildTracing(state.aiEvent);
+      state.span.end();
+    } finally {
+      this.releaseState(state);
+    }
+  }
+  releaseState(state) {
+    state.finalized = true;
+    unregisterCloudflareThinkSpan(state.span);
+    if (state.span.spanId) {
+      this.statesBySpanId.delete(state.span.spanId);
+    }
+  }
+};
+function extractFallbackInput(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return void 0;
+  }
+  let latestUserIndex = -1;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (messages[index]?.role === "user") {
+      latestUserIndex = index;
+      break;
+    }
+  }
+  const selected = latestUserIndex >= 0 ? messages.slice(latestUserIndex) : [];
+  return selected.map((message) => ({
+    role: message.role,
+    content: message.content ?? message.parts
+  }));
+}
+function extractThinkTaskOutput(output) {
+  if (!isObject(output)) {
+    return output;
+  }
+  if (typeof output.text === "string") {
+    return { role: "assistant", content: output.text };
+  }
+  if (output.object !== void 0) {
+    return output.object;
+  }
+  return output;
+}
+function extractThinkTaskInput(input) {
+  if (!isObject(input)) {
+    return input;
+  }
+  const system = input.instructions ?? input.system;
+  if (Array.isArray(input.messages)) {
+    return system === void 0 ? input.messages : [{ role: "system", content: system }, ...input.messages];
+  }
+  if (Array.isArray(input.prompt)) {
+    return system === void 0 ? input.prompt : [{ role: "system", content: system }, ...input.prompt];
+  }
+  if (typeof input.prompt === "string") {
+    const messages = [{ role: "user", content: input.prompt }];
+    return system === void 0 ? messages : [{ role: "system", content: system }, ...messages];
+  }
+  return input;
+}
+
 // src/instrumentation/plugins/cursor-sdk-channels.ts
 var cursorSDKChannels = defineChannels(
   "@cursor/sdk",
@@ -20828,9 +22065,9 @@ function extractEmbedPromptTokenCount(response) {
   let sawAny = false;
   for (const embedding of embeddings) {
     const embeddingStats = tryToDict(tryToDict(embedding)?.statistics);
-    const tokenCount = embeddingStats?.tokenCount;
-    if (typeof tokenCount === "number" && Number.isFinite(tokenCount)) {
-      total += tokenCount;
+    const tokenCount2 = embeddingStats?.tokenCount;
+    if (typeof tokenCount2 === "number" && Number.isFinite(tokenCount2)) {
+      total += tokenCount2;
       sawAny = true;
     }
   }
@@ -24477,6 +25714,470 @@ function aggregateMistralStreamChunks(chunks) {
   };
 }
 
+// src/instrumentation/plugins/ollama-channels.ts
+var ollamaChannels = defineChannels(
+  "ollama",
+  {
+    chat: channel({
+      channelName: "chat",
+      kind: "async"
+    }),
+    generate: channel({
+      channelName: "generate",
+      kind: "async"
+    }),
+    embed: channel({
+      channelName: "embed",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.OLLAMA }
+);
+
+// src/instrumentation/plugins/ollama-plugin.ts
+var OllamaPlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(
+      traceStreamingChannel(ollamaChannels.chat, {
+        name: "ollama.chat",
+        type: "llm" /* LLM */,
+        extractInput: extractOllamaChatInput,
+        extractOutput: (result, event) => extractOllamaChatOutput(
+          result,
+          countOllamaToolCalls(event?.arguments?.[0]?.messages)
+        ),
+        extractMetadata: extractOllamaResponseMetadata,
+        extractMetrics: extractOllamaMetrics,
+        aggregateChunks: aggregateOllamaChatChunks
+      }),
+      traceStreamingChannel(ollamaChannels.generate, {
+        name: "ollama.generate",
+        type: "llm" /* LLM */,
+        extractInput: extractOllamaGenerateInput,
+        extractOutput: extractOllamaGenerateOutput,
+        extractMetadata: extractOllamaResponseMetadata,
+        extractMetrics: extractOllamaMetrics,
+        aggregateChunks: aggregateOllamaGenerateChunks
+      }),
+      traceAsyncChannel(ollamaChannels.embed, {
+        name: "ollama.embed",
+        type: "llm" /* LLM */,
+        extractInput: extractOllamaEmbedInput,
+        extractOutput: extractOllamaEmbedOutput,
+        extractMetadata: extractOllamaResponseMetadata,
+        extractMetrics: extractOllamaMetrics
+      })
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function isNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function normalizeFinishReason(response, hasToolCalls = false) {
+  if (hasToolCalls) {
+    return "tool_calls";
+  }
+  return response?.done_reason || "stop";
+}
+function stringifyArguments(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value ?? {});
+  } catch {
+    return String(value);
+  }
+}
+function syntheticToolCallId(name, index) {
+  const normalizedName = name.replace(/[^a-zA-Z0-9_-]/g, "_") || "tool";
+  return `ollama_call_${normalizedName}_${index}`;
+}
+function normalizeToolCall(toolCall, index) {
+  const name = toolCall.function?.name;
+  if (typeof name !== "string" || name.length === 0) {
+    return void 0;
+  }
+  return {
+    id: typeof toolCall.id === "string" && toolCall.id.length > 0 ? toolCall.id : syntheticToolCallId(name, index),
+    type: "function",
+    function: {
+      name,
+      arguments: stringifyArguments(toolCall.function?.arguments)
+    }
+  };
+}
+function normalizeToolCalls(toolCalls, syntheticIdOffset = 0) {
+  if (!Array.isArray(toolCalls)) {
+    return [];
+  }
+  return toolCalls.flatMap((toolCall, index) => {
+    const normalized = normalizeToolCall(toolCall, syntheticIdOffset + index);
+    return normalized ? [normalized] : [];
+  });
+}
+function countOllamaToolCalls(messages) {
+  if (!Array.isArray(messages)) {
+    return 0;
+  }
+  return messages.reduce(
+    (count, message) => count + (isObject(message) && Array.isArray(message.tool_calls) ? message.tool_calls.length : 0),
+    0
+  );
+}
+function imageBytes(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (typeof value !== "string" || value.startsWith("data:")) {
+    return void 0;
+  }
+  try {
+    const decoded = atob(value.slice(0, 24));
+    return Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+  } catch {
+    return void 0;
+  }
+}
+function inferImageMediaType(value) {
+  if (typeof value === "string") {
+    const dataUrlType = value.match(/^data:(image\/[^;]+);base64,/i)?.[1];
+    if (dataUrlType) {
+      return dataUrlType;
+    }
+  }
+  const bytes = imageBytes(value);
+  if (!bytes) {
+    return void 0;
+  }
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "image/png";
+  }
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  const signature = String.fromCharCode(...bytes.slice(0, 12));
+  if (signature.startsWith("GIF87a") || signature.startsWith("GIF89a")) {
+    return "image/gif";
+  }
+  if (signature.startsWith("RIFF") && signature.slice(8, 12) === "WEBP") {
+    return "image/webp";
+  }
+  return void 0;
+}
+function normalizeTextAndImages(content, images) {
+  if (!images || images.length === 0) {
+    return { content };
+  }
+  const imageParts = [];
+  const unrecognizedImages = [];
+  for (const image of images) {
+    let localImagePath;
+    let localPathMediaType;
+    if (typeof image === "string" && !/^data:/i.test(image) && !/^https?:\/\//i.test(image)) {
+      const extension = image.match(/\.([a-z0-9]+)$/i)?.[1]?.toLowerCase();
+      const extensionMediaType = {
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        webp: "image/webp"
+      }[extension ?? ""];
+      if (extensionMediaType && isomorph_default.statSync) {
+        try {
+          if (isomorph_default.statSync(image).isFile()) {
+            localImagePath = image;
+            localPathMediaType = extensionMediaType;
+          }
+        } catch {
+        }
+      }
+    }
+    const mediaType = localPathMediaType ?? inferImageMediaType(image);
+    if (!mediaType) {
+      unrecognizedImages.push(image);
+      continue;
+    }
+    const processedImage = localImagePath ? new Attachment({
+      data: localImagePath,
+      filename: localImagePath.split(/[\\/]/).at(-1) ?? "image",
+      contentType: mediaType
+    }) : processInputAttachments({
+      type: "image",
+      image,
+      mediaType
+    }).image;
+    imageParts.push({
+      type: "image_url",
+      image_url: { url: processedImage }
+    });
+  }
+  return {
+    content: imageParts.length > 0 ? [...content ? [{ type: "text", text: content }] : [], ...imageParts] : content,
+    ...unrecognizedImages.length > 0 ? { unrecognizedImages } : {}
+  };
+}
+function normalizeMessage(message, toolCallId, syntheticToolCallIdOffset = 0) {
+  if (typeof message.role !== "string") {
+    return void 0;
+  }
+  const toolCalls = normalizeToolCalls(
+    message.tool_calls,
+    syntheticToolCallIdOffset
+  );
+  if (message.role === "tool") {
+    const toolName = typeof message.tool_name === "string" && message.tool_name.length > 0 ? message.tool_name : "tool";
+    return {
+      role: "tool",
+      tool_call_id: toolCallId ?? syntheticToolCallId(toolName, 0),
+      content: typeof message.content === "string" ? message.content : ""
+    };
+  }
+  const normalizedContent = normalizeTextAndImages(
+    typeof message.content === "string" ? message.content || (toolCalls.length > 0 ? null : "") : toolCalls.length > 0 ? null : "",
+    message.images
+  );
+  return {
+    role: message.role,
+    content: normalizedContent.content,
+    ...typeof message.thinking === "string" && message.thinking.length > 0 ? { reasoning: message.thinking } : {},
+    ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {},
+    ...normalizedContent.unrecognizedImages ? { images: normalizedContent.unrecognizedImages } : {}
+  };
+}
+function normalizeMessages(messages) {
+  if (!Array.isArray(messages)) {
+    return [];
+  }
+  const pendingToolCallIds = /* @__PURE__ */ new Map();
+  let syntheticToolCallIdOffset = 0;
+  return messages.flatMap((message) => {
+    if (!isObject(message)) {
+      return [];
+    }
+    const ollamaMessage = message;
+    let toolCallId;
+    if (ollamaMessage.role === "tool") {
+      const toolName = ollamaMessage.tool_name;
+      if (typeof toolName === "string") {
+        toolCallId = pendingToolCallIds.get(toolName)?.shift();
+      }
+    }
+    const normalized = normalizeMessage(
+      ollamaMessage,
+      toolCallId,
+      syntheticToolCallIdOffset
+    );
+    if (Array.isArray(ollamaMessage.tool_calls)) {
+      syntheticToolCallIdOffset += ollamaMessage.tool_calls.length;
+    }
+    if (ollamaMessage.role === "assistant" && normalized) {
+      const toolCalls = Array.isArray(normalized.tool_calls) ? normalized.tool_calls : [];
+      for (const toolCall of toolCalls) {
+        if (!isObject(toolCall) || !isObject(toolCall.function)) {
+          continue;
+        }
+        const name = toolCall.function.name;
+        const id = toolCall.id;
+        if (typeof name === "string" && typeof id === "string") {
+          const ids = pendingToolCallIds.get(name) ?? [];
+          ids.push(id);
+          pendingToolCallIds.set(name, ids);
+        }
+      }
+    }
+    return normalized ? [normalized] : [];
+  });
+}
+function normalizeToolDefinition(tool) {
+  const fn = tool.function;
+  if (!fn || typeof fn.name !== "string" || fn.name.length === 0) {
+    return void 0;
+  }
+  return {
+    type: "function",
+    function: {
+      name: fn.name,
+      ...typeof fn.description === "string" ? { description: fn.description } : {},
+      ...isObject(fn.parameters) ? { parameters: fn.parameters } : {}
+    }
+  };
+}
+function extractToolsMetadata(tools) {
+  if (!Array.isArray(tools)) {
+    return {};
+  }
+  const normalized = tools.flatMap((tool) => {
+    if (!isObject(tool)) {
+      return [];
+    }
+    const definition = normalizeToolDefinition(tool);
+    return definition ? [definition] : [];
+  });
+  return normalized.length > 0 ? { tools: normalized } : {};
+}
+function extractOptionsMetadata(options) {
+  if (!isObject(options)) {
+    return {};
+  }
+  const metadata = {};
+  const mappings = [
+    ["temperature", "temperature"],
+    ["top_p", "top_p"],
+    ["num_predict", "max_tokens"],
+    ["frequency_penalty", "frequency_penalty"],
+    ["presence_penalty", "presence_penalty"],
+    ["stop", "stop"]
+  ];
+  for (const [source, target] of mappings) {
+    if (options[source] !== void 0) {
+      metadata[target] = options[source];
+    }
+  }
+  return metadata;
+}
+function extractRequestMetadata(request) {
+  return {
+    provider: "ollama",
+    ...typeof request?.model === "string" ? { model: request.model } : {},
+    ...extractOptionsMetadata(request?.options),
+    ...request?.format !== void 0 ? { response_format: request.format } : {}
+  };
+}
+function extractOllamaChatInput([request]) {
+  return {
+    input: normalizeMessages(request.messages),
+    metadata: {
+      ...extractRequestMetadata(request),
+      ...extractToolsMetadata(request.tools)
+    }
+  };
+}
+function extractOllamaGenerateInput([request]) {
+  const normalizedPrompt = normalizeTextAndImages(
+    typeof request.prompt === "string" ? request.prompt : "",
+    Array.isArray(request.images) ? request.images : void 0
+  );
+  const input = [
+    ...typeof request.system === "string" ? [{ role: "system", content: request.system }] : [],
+    {
+      role: "user",
+      content: normalizedPrompt.content,
+      ...typeof request.suffix === "string" ? { suffix: request.suffix } : {},
+      ...normalizedPrompt.unrecognizedImages ? { images: normalizedPrompt.unrecognizedImages } : {}
+    }
+  ];
+  return {
+    input,
+    metadata: extractRequestMetadata(request)
+  };
+}
+function extractOllamaEmbedInput([request]) {
+  return {
+    input: request.input,
+    metadata: extractRequestMetadata(request)
+  };
+}
+function extractOllamaChatOutput(result, syntheticToolCallIdOffset = 0) {
+  if (!isObject(result) || !isObject(result.message)) {
+    return void 0;
+  }
+  const message = normalizeMessage(
+    result.message,
+    void 0,
+    syntheticToolCallIdOffset
+  );
+  if (!message) {
+    return void 0;
+  }
+  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+  return [
+    {
+      index: 0,
+      finish_reason: normalizeFinishReason(result, toolCalls.length > 0),
+      message
+    }
+  ];
+}
+function extractOllamaGenerateOutput(result) {
+  if (!isObject(result) || typeof result.response !== "string") {
+    return void 0;
+  }
+  return [
+    {
+      index: 0,
+      finish_reason: normalizeFinishReason(result),
+      message: {
+        role: "assistant",
+        content: result.response,
+        ...typeof result.thinking === "string" && result.thinking.length > 0 ? { reasoning: result.thinking } : {}
+      }
+    }
+  ];
+}
+function extractOllamaEmbedOutput(result) {
+  const embedding = Array.isArray(result?.embeddings) ? result.embeddings[0] : void 0;
+  return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
+}
+function extractOllamaResponseMetadata(result) {
+  return typeof result?.model === "string" ? { model: result.model } : void 0;
+}
+function extractOllamaMetrics(result) {
+  const metrics = {};
+  const promptTokens = result?.prompt_eval_count;
+  const completionTokens = result?.eval_count;
+  if (isNonNegativeNumber(promptTokens)) {
+    metrics.prompt_tokens = promptTokens;
+  }
+  if (isNonNegativeNumber(completionTokens)) {
+    metrics.completion_tokens = completionTokens;
+  }
+  if (isNonNegativeNumber(promptTokens) || isNonNegativeNumber(completionTokens)) {
+    metrics.tokens = (isNonNegativeNumber(promptTokens) ? promptTokens : 0) + (isNonNegativeNumber(completionTokens) ? completionTokens : 0);
+  }
+  return metrics;
+}
+function aggregateOllamaChatChunks(chunks, _result, event, _startTime) {
+  const last = chunks.at(-1);
+  const message = {
+    role: "assistant",
+    content: chunks.map((chunk) => chunk.message?.content ?? "").join(""),
+    thinking: chunks.map((chunk) => chunk.message?.thinking ?? "").join(""),
+    tool_calls: chunks.flatMap((chunk) => chunk.message?.tool_calls ?? [])
+  };
+  const response = {
+    ...last,
+    message
+  };
+  return {
+    output: extractOllamaChatOutput(
+      response,
+      countOllamaToolCalls(event?.arguments?.[0]?.messages)
+    ),
+    metrics: extractOllamaMetrics(last ?? {}),
+    metadata: extractOllamaResponseMetadata(last ?? {})
+  };
+}
+function aggregateOllamaGenerateChunks(chunks, _result, _event, _startTime) {
+  const last = chunks.at(-1);
+  const response = {
+    ...last,
+    response: chunks.map((chunk) => chunk.response ?? "").join(""),
+    thinking: chunks.map((chunk) => chunk.thinking ?? "").join("")
+  };
+  return {
+    output: extractOllamaGenerateOutput(response),
+    metrics: extractOllamaMetrics(last ?? {}),
+    metadata: extractOllamaResponseMetadata(last ?? {})
+  };
+}
+
 // src/instrumentation/plugins/google-adk-channels.ts
 var googleADKChannels = defineChannels(
   "@google/adk",
@@ -27261,7 +28962,7 @@ function getStringProperty2(obj, key) {
   return typeof value === "string" ? value : void 0;
 }
 function extractMetricsFromUsage(usage) {
-  const metrics = {
+  const rawMetrics = {
     prompt_tokens: usage.inputTokens,
     completion_tokens: usage.outputTokens,
     ...extractAnthropicCacheTokens(
@@ -27270,10 +28971,10 @@ function extractMetricsFromUsage(usage) {
     )
   };
   if (usage.reasoningTokens !== void 0) {
-    metrics.completion_reasoning_tokens = usage.reasoningTokens;
-    metrics.reasoning_tokens = usage.reasoningTokens;
+    rawMetrics.completion_reasoning_tokens = usage.reasoningTokens;
+    rawMetrics.reasoning_tokens = usage.reasoningTokens;
   }
-  Object.assign(metrics, finalizeAnthropicTokens(metrics));
+  const metrics = finalizeAnthropicTokens(rawMetrics);
   const metadata = {
     model: usage.model
   };
@@ -28212,17 +29913,20 @@ var FlueObserveBridge = class {
       return;
     }
     const metadata = {
+      ...event.runId ? this.runsById.get(event.runId)?.metadata : {},
       ...extractEventMetadata(event),
       "flue.operation": event.operationKind,
       provider: "flue"
     };
     const parent = this.parentSpanForEvent(event);
-    const span = startFlueSpan(parent, {
+    const args = {
       name: `flue.${event.operationKind}`,
       spanAttributes: { type: "task" /* TASK */ },
       startTime: eventTime(event.timestamp),
       event: { metadata }
-    });
+    };
+    const runSpan = event.runId ? this.runsById.get(event.runId)?.span : void 0;
+    const span = event.operationKind === "prompt" && (!parent || parent === runSpan) ? startFlueRootSpan(args) : startFlueSpan(parent, args);
     this.operationsById.set(event.operationId, { metadata, span });
   }
   handleOperation(event) {
@@ -28230,16 +29934,21 @@ var FlueObserveBridge = class {
       return;
     }
     const state = this.operationsById.get(event.operationId) ?? this.startSyntheticOperation(event);
-    const output = operationOutput(event);
+    const output = operationOutput(event) ?? outputFromAgentTurn(state.latestAgentOutput);
     const metadata = {
       ...state.metadata,
       ...extractEventMetadata(event),
       ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {},
       ...event.usage ? { "flue.usage": event.usage } : {}
     };
+    const input = flueOperationInput(event);
+    if (!state.loggedInput && input !== void 0) {
+      safeLog3(state.span, { input });
+      state.loggedInput = true;
+    }
     this.finishPendingChildrenForOperation(event, output);
     safeLog3(state.span, {
-      ...event.isError ? { error: toLoggedError(event.error) } : {},
+      ...event.isError ? { error: toLoggedError(event.errorInfo ?? event.error) } : {},
       metadata,
       metrics: durationMetrics2(event.durationMs),
       output
@@ -28253,6 +29962,8 @@ var FlueObserveBridge = class {
       return;
     }
     const input = flueTurnRequestInput(event);
+    const operation = event.operationId ? this.operationsById.get(event.operationId) : void 0;
+    const turnInput = prepareFlueTurnInput(event, input, operation);
     const model = flueTurnRequestModel(event);
     const provider = flueTurnRequestProvider(event);
     const api = flueTurnRequestApi(event);
@@ -28265,20 +29976,22 @@ var FlueObserveBridge = class {
       ...provider ? { "flue.provider": provider } : {},
       ...event.purpose ? { "flue.turn_purpose": event.purpose } : {},
       ...reasoning ? { reasoning } : {},
-      ...input?.systemPrompt ? { "flue.system_prompt": input.systemPrompt } : {},
-      ...input?.tools ? { tools: input.tools } : {}
+      ...turnInput.metadata
     };
     const parent = this.parentSpanForTurn(event);
     const span = startFlueSpan(parent, {
-      name: `llm:${model ?? event.purpose ?? "unknown"}`,
+      name: "flue.turn",
       spanAttributes: { type: "llm" /* LLM */ },
       startTime: eventTime(event.timestamp),
       event: {
-        input: input?.messages,
+        input: turnInput.messages,
         metadata
       }
     });
-    this.logOperationInput(event.operationId, input?.messages ?? input);
+    this.logOperationInput(
+      event.operationId,
+      latestUserMessageInput(input?.messages)
+    );
     this.turnsByKey.set(key, { metadata, span });
   }
   handleTurn(event) {
@@ -28314,6 +30027,12 @@ var FlueObserveBridge = class {
       },
       output
     });
+    if (event.purpose === "agent" && event.operationId) {
+      const operation = this.operationsById.get(event.operationId);
+      if (operation) {
+        operation.latestAgentOutput = output;
+      }
+    }
     safeEnd(state.span, eventTime(event.timestamp));
     this.turnsByKey.delete(key);
   }
@@ -28393,7 +30112,7 @@ var FlueObserveBridge = class {
       return;
     }
     safeLog3(state.span, {
-      ...event.isError ? { error: toLoggedError(event.result) } : {},
+      ...event.isError ? { error: toLoggedError(event.errorInfo ?? event.result) } : {},
       metadata: {
         ...state.metadata,
         ...extractEventMetadata(event),
@@ -28439,6 +30158,7 @@ var FlueObserveBridge = class {
       ...event.usage ? { "flue.usage": event.usage } : {}
     };
     safeLog3(state.span, {
+      ...event.isError ? { error: toLoggedError(event.errorInfo ?? event.error) } : {},
       metadata,
       metrics: {
         ...durationMetrics2(event.durationMs),
@@ -28518,16 +30238,20 @@ var FlueObserveBridge = class {
   }
   startSyntheticOperation(event) {
     const metadata = {
+      ...event.runId ? this.runsById.get(event.runId)?.metadata : {},
       ...extractEventMetadata(event),
       "flue.operation": event.operationKind,
       provider: "flue"
     };
-    const span = startFlueSpan(this.parentSpanForEvent(event), {
+    const args = {
       name: `flue.${event.operationKind}`,
       spanAttributes: { type: "task" /* TASK */ },
       startTime: eventTime(event.timestamp),
       event: { metadata }
-    });
+    };
+    const parent = this.parentSpanForEvent(event);
+    const runSpan = event.runId ? this.runsById.get(event.runId)?.span : void 0;
+    const span = event.operationKind === "prompt" && (!parent || parent === runSpan) ? startFlueRootSpan(args) : startFlueSpan(parent, args);
     return { metadata, span };
   }
   startSyntheticTurn(event) {
@@ -28543,7 +30267,7 @@ var FlueObserveBridge = class {
       ...event.purpose ? { "flue.turn_purpose": event.purpose } : {}
     };
     const span = startFlueSpan(this.parentSpanForEvent(event), {
-      name: `llm:${model ?? event.purpose ?? "unknown"}`,
+      name: "flue.turn",
       spanAttributes: { type: "llm" /* LLM */ },
       startTime: eventTime(event.timestamp),
       event: { metadata }
@@ -28675,7 +30399,10 @@ function extractEventMetadata(event, ctx) {
   return {
     ...event.runId ? { "flue.run_id": event.runId } : {},
     ...event.instanceId ? { "flue.instance_id": event.instanceId } : {},
+    ...event.submissionId ? { "flue.submission_id": event.submissionId } : {},
     ...event.dispatchId ? { "flue.dispatch_id": event.dispatchId } : {},
+    ...event.agentName ? { "flue.agent_name": event.agentName } : {},
+    ...event.conversationId ? { "flue.conversation_id": event.conversationId } : {},
     ...typeof event.eventIndex === "number" ? { "flue.event_index": event.eventIndex } : {},
     ...event.session ? { "flue.session": event.session } : {},
     ...event.parentSession ? { "flue.parent_session": event.parentSession } : {},
@@ -28703,8 +30430,73 @@ function flueRunInput(event) {
 function flueTurnRequestInput(event) {
   return event.request?.input ?? event.input;
 }
+function prepareFlueTurnInput(event, input, operation) {
+  const messages = input?.messages;
+  const tracksUserTurn = event.purpose === "agent" && operation?.metadata["flue.operation"] === "prompt" && Array.isArray(messages);
+  if (!tracksUserTurn) {
+    return {
+      messages,
+      metadata: {
+        ...input?.systemPrompt ? { "flue.system_prompt": input.systemPrompt } : {},
+        ...input?.tools ? { tools: input.tools } : {}
+      }
+    };
+  }
+  const previous = operation.turnInputState;
+  const previousMessageCount = previous?.messageCount ?? 0;
+  const boundaryFingerprint = messages.length > 0 ? fingerprintJsonValue(messages[messages.length - 1]) : void 0;
+  const continuesPreviousInput = previous !== void 0 && messages.length >= previousMessageCount && (previousMessageCount === 0 || previous.boundaryFingerprint !== void 0 && previous.boundaryFingerprint === fingerprintJsonValue(messages[previousMessageCount - 1]));
+  const inputMode = previous === void 0 ? "full" : continuesPreviousInput ? "delta" : "reset";
+  const systemPromptFingerprint = fingerprintJsonValue(input?.systemPrompt);
+  const toolsFingerprint = fingerprintJsonValue(input?.tools);
+  operation.turnInputState = {
+    ...boundaryFingerprint !== void 0 ? { boundaryFingerprint } : {},
+    messageCount: messages.length,
+    ...systemPromptFingerprint !== void 0 ? { systemPromptFingerprint } : {},
+    ...toolsFingerprint !== void 0 ? { toolsFingerprint } : {}
+  };
+  return {
+    messages: continuesPreviousInput ? messages.slice(previousMessageCount) : messages,
+    metadata: {
+      "flue.input_mode": inputMode,
+      ...continuesPreviousInput ? { "flue.input_message_offset": previousMessageCount } : {},
+      ...input?.systemPrompt && (!continuesPreviousInput || systemPromptFingerprint !== previous?.systemPromptFingerprint) ? { "flue.system_prompt": input.systemPrompt } : {},
+      ...input?.tools && (!continuesPreviousInput || toolsFingerprint !== previous?.toolsFingerprint) ? { tools: input.tools } : {}
+    }
+  };
+}
+function fingerprintJsonValue(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      return void 0;
+    }
+    let hash = 2166136261;
+    for (let i = 0; i < serialized.length; i++) {
+      hash = Math.imul(hash ^ serialized.charCodeAt(i), 16777619);
+    }
+    return `${serialized.length}:${hash >>> 0}`;
+  } catch {
+    return void 0;
+  }
+}
+function latestUserMessageInput(messages) {
+  if (!messages) {
+    return void 0;
+  }
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (isObjectLike(message) && Reflect.get(message, "role") === "user") {
+      return [message];
+    }
+  }
+  return void 0;
+}
+function flueOperationInput(event) {
+  return typeof event.agentInput?.text === "string" ? [{ content: event.agentInput.text, role: "user" }] : void 0;
+}
 function flueTurnRequestModel(event) {
-  return event.request?.model ?? event.model;
+  return event.request?.requestedModel ?? event.request?.model ?? event.model;
 }
 function flueTurnRequestProvider(event) {
   return event.request?.providerName ?? event.provider ?? event.request?.providerId;
@@ -28713,10 +30505,10 @@ function flueTurnRequestApi(event) {
   return event.request?.api ?? event.api;
 }
 function flueTurnRequestReasoning(event) {
-  return event.request?.reasoning ?? event.reasoning;
+  return event.request?.reasoningLevel ?? event.request?.reasoning ?? event.reasoning;
 }
 function flueTurnModel(event) {
-  return event.request?.model ?? event.model;
+  return event.response?.responseModel ?? event.request?.requestedModel ?? event.request?.model ?? event.model;
 }
 function flueTurnProvider(event) {
   return event.request?.providerName ?? event.provider ?? event.request?.providerId;
@@ -28731,7 +30523,7 @@ function flueTurnOutput(event) {
   return event.response?.output ?? event.output;
 }
 function flueTurnStopReason(event) {
-  return event.response?.stopReason ?? event.stopReason;
+  return event.response?.finishReason ?? event.response?.stopReason ?? event.stopReason;
 }
 function flueTurnError(event) {
   return event.response?.error ?? event.response?.errorInfo?.message ?? event.error;
@@ -28746,6 +30538,9 @@ function flueToolInput(event) {
   return event.input;
 }
 function flueToolOutput(event) {
+  if (Object.hasOwn(event, "effectiveResult")) {
+    return event.effectiveResult;
+  }
   return event.output !== void 0 ? event.output : event.result;
 }
 function flueToolError(event) {
@@ -28753,10 +30548,36 @@ function flueToolError(event) {
 }
 function operationOutput(event) {
   if (event.operationKind === "prompt" || event.operationKind === "skill") {
-    return llmResultFromOperationResult(event.result);
+    return outputFromAgentInvocation(event.agentOutput) ?? llmResultFromOperationResult(event.result);
   }
   return event.result ?? (event.operationKind === "compact" ? { completed: true } : void 0);
 }
+function outputFromAgentInvocation(output) {
+  if (output?.type === "text") {
+    return output.text;
+  }
+  if (output?.type === "data") {
+    return output.data;
+  }
+  return void 0;
+}
+function outputFromAgentTurn(output) {
+  if (!isObjectLike(output)) {
+    return output;
+  }
+  const content = Reflect.get(output, "content");
+  if (!Array.isArray(content)) {
+    return output;
+  }
+  const text = content.flatMap((part) => {
+    if (!isObjectLike(part) || Reflect.get(part, "type") !== "text") {
+      return [];
+    }
+    const value = Reflect.get(part, "text");
+    return typeof value === "string" ? [value] : [];
+  });
+  return text.length > 0 ? text.join("") : output;
+}
 function llmResultFromOperationResult(result) {
   if (!isObjectLike(result)) {
     return result;
@@ -28831,6 +30652,21 @@ function startFlueSpan(parent, args) {
     withSpanInstrumentationName(args, INSTRUMENTATION_NAMES.FLUE)
   );
 }
+function startFlueRootSpan(args) {
+  const state = _internalGetGlobalState();
+  const spanId = state.idGenerator.getSpanId();
+  const rootSpanId = state.idGenerator.shareRootSpanId() ? spanId : state.idGenerator.getTraceId();
+  return withCurrent(
+    NOOP_SPAN,
+    () => startSpan({
+      ...withSpanInstrumentationName(args, INSTRUMENTATION_NAMES.FLUE),
+      parentSpanIds: { parentSpanIds: [], rootSpanId },
+      spanId,
+      state
+    }),
+    state
+  );
+}
 function runWithCurrentSpanStore(span, next) {
   const state = _internalGetGlobalState();
   const contextManager = state?.contextManager;
@@ -28855,7 +30691,7 @@ function safeEnd(span, endTime) {
   }
 }
 function logInstrumentationError3(label, error) {
-  console.error(`Error in ${label} instrumentation:`, error);
+  debugLogger.debug(`Error in ${label} instrumentation:`, error);
 }
 
 // src/wrappers/langchain/callback-handler.ts
@@ -29784,12 +31620,13 @@ var piCodingAgentChannels = defineChannels(
 );
 
 // src/instrumentation/plugins/pi-coding-agent-plugin.ts
-var piStreamPatchStates = /* @__PURE__ */ new WeakMap();
+var piAgentPatchStates = /* @__PURE__ */ new WeakMap();
+var piAgentEventSubscriptions = /* @__PURE__ */ new WeakSet();
 var piPromptContextStore;
 var PiCodingAgentPlugin = class extends BasePlugin {
   activePromptStates = /* @__PURE__ */ new Set();
   onEnable() {
-    this.subscribeToPrompt();
+    this.interceptPrompt();
   }
   onDisable() {
     for (const unsubscribe of this.unsubscribers) {
@@ -29797,65 +31634,74 @@ var PiCodingAgentPlugin = class extends BasePlugin {
     }
     this.unsubscribers = [];
     for (const state of [...this.activePromptStates]) {
-      void finalizePiPromptRun(state).catch((error) => {
-        logInstrumentationError4("Pi Coding Agent disable cleanup", error);
-      });
+      finishPiPromptRun(state);
     }
   }
-  subscribeToPrompt() {
-    const channel2 = piCodingAgentChannels.prompt.tracingChannel();
-    const states = /* @__PURE__ */ new WeakMap();
-    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(channel2);
-    const handlers = {
-      start: (event) => {
-        const state = startPiPromptRun(event, (state2) => {
-          this.activePromptStates.delete(state2);
-        });
-        if (state) {
-          this.activePromptStates.add(state);
-          states.set(event, state);
-        }
-      },
-      asyncEnd: async (event) => {
-        const state = states.get(event);
-        if (!state) {
-          return;
-        }
-        states.delete(event);
-        state.promptCallEnded = true;
-        if (!state.finalized && state.deferCompletionUntilTurnEnd && !state.turnEnded) {
-          if (!state.sawStreamFn) {
-            state.queued = true;
-            if (!state.streamPatchState.queuedPromptStates.includes(state)) {
-              state.streamPatchState.queuedPromptStates.push(state);
-            }
+  interceptPrompt() {
+    this.unsubscribers.push(
+      piCodingAgentChannels.prompt.intercept(
+        (target, thisArg, args, additional) => {
+          const invokeTarget = () => Reflect.apply(target, thisArg, args);
+          let state;
+          try {
+            state = startPiPromptRun(
+              {
+                ...additional,
+                arguments: args,
+                self: thisArg
+              },
+              (finalizedState) => {
+                this.activePromptStates.delete(finalizedState);
+              }
+            );
+          } catch (error) {
+            logInstrumentationError4("Pi Coding Agent prompt start", error);
           }
-          return;
-        }
-        await finalizePiPromptRun(state);
-      },
-      error: async (event) => {
-        const state = states.get(event);
-        if (!state) {
-          return;
+          if (!state) {
+            return runWithAutoInstrumentationSuppressed(invokeTarget);
+          }
+          this.activePromptStates.add(state);
+          return promptContextStore().run(
+            state,
+            () => runWithAutoInstrumentationSuppressed(() => {
+              let result;
+              try {
+                result = invokeTarget();
+              } catch (error) {
+                finishPiPromptRun(state, error);
+                throw error;
+              }
+              return Promise.resolve(result).then(
+                (value) => {
+                  finishPiPromptCall(state);
+                  return value;
+                },
+                (error) => {
+                  finishPiPromptRun(state, error);
+                  throw error;
+                }
+              );
+            })
+          );
         }
-        states.delete(event);
-        await finalizePiPromptRun(state, event.error);
-      }
-    };
-    channel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      unbindAutoInstrumentationSuppression?.();
-      channel2.unsubscribe(handlers);
-    });
+      )
+    );
   }
 };
+function finishPiPromptCall(state) {
+  state.promptCallEnded = true;
+  if (state.deferCompletionUntilTurnEnd && !state.turnEnded) {
+    return;
+  }
+  finishPiPromptRun(state);
+}
 function startPiPromptRun(event, onFinalize) {
   const session = extractSession(event);
   const agent = session?.agent;
   if (!session || !isPiAgent(agent)) {
     return void 0;
   }
+  installPiAgentInstrumentation(agent);
   const metadata = {
     ...extractSessionMetadata(session),
     ...extractPromptOptionsMetadata(event.arguments[1]),
@@ -29877,9 +31723,7 @@ function startPiPromptRun(event, onFinalize) {
       INSTRUMENTATION_NAMES.PI_CODING_AGENT
     )
   );
-  const streamPatchState = installPiStreamPatch(agent);
   const options = event.arguments[1];
-  const promptText = event.arguments[0];
   const state = {
     activeLlmSpans: /* @__PURE__ */ new Set(),
     activeToolSpans: /* @__PURE__ */ new Map(),
@@ -29891,29 +31735,10 @@ function startPiPromptRun(event, onFinalize) {
     metrics: {},
     onFinalize,
     promptCallEnded: false,
-    ...typeof promptText === "string" ? { promptText } : {},
-    queued: false,
     span,
-    sawStreamFn: false,
     startTime: getCurrentUnixTimestamp(),
-    streamPatchState,
     turnEnded: false
   };
-  state.restorePromptContext = enterPiPromptContext(state);
-  streamPatchState.activePromptStates.add(state);
-  try {
-    state.unsubscribeAgent = agent.subscribe(async (agentEvent) => {
-      try {
-        await runWithAutoInstrumentationSuppressed(
-          () => handlePiAgentEvent(state, agentEvent)
-        );
-      } catch (error) {
-        logInstrumentationError4("Pi Coding Agent event", error);
-      }
-    });
-  } catch (error) {
-    logInstrumentationError4("Pi Coding Agent event subscription", error);
-  }
   return state;
 }
 function extractSession(event) {
@@ -29927,111 +31752,55 @@ function promptContextStore() {
   piPromptContextStore ??= isomorph_default.newAsyncLocalStorage();
   return piPromptContextStore;
 }
-function currentPromptContextFrames() {
-  return promptContextStore().getStore()?.frames ?? [];
-}
 function currentPiPromptState() {
-  const frames = currentPromptContextFrames();
-  return frames[frames.length - 1]?.state;
-}
-function enterPiPromptContext(state) {
-  const frame = {
-    id: /* @__PURE__ */ Symbol("braintrust.pi-coding-agent.prompt"),
-    state
-  };
-  promptContextStore().enterWith({
-    frames: [...currentPromptContextFrames(), frame]
-  });
-  return () => {
-    const frames = currentPromptContextFrames().filter(
-      (candidate) => candidate.id !== frame.id
-    );
-    promptContextStore().enterWith(frames.length > 0 ? { frames } : void 0);
-  };
-}
-function installPiStreamPatch(agent) {
-  const existing = piStreamPatchStates.get(agent);
-  if (existing) {
-    if (agent.streamFn !== existing.wrappedStreamFn) {
-      debugLogger.debug(
-        "Pi Coding Agent streamFn changed while Braintrust instrumentation was active; preserving existing patch state."
-      );
-    }
-    return existing;
-  }
-  const patchState = {
-    activePromptStates: /* @__PURE__ */ new Set(),
-    agent,
-    originalStreamFn: agent.streamFn,
-    queuedPromptStates: [],
-    wrappedStreamFn: agent.streamFn
-  };
-  patchState.wrappedStreamFn = makeSharedInstrumentedStreamFn(patchState);
-  agent.streamFn = patchState.wrappedStreamFn;
-  piStreamPatchStates.set(agent, patchState);
-  return patchState;
-}
-function resolveStreamPromptState(patchState, context) {
-  let lastUserText;
-  if (Array.isArray(context.messages)) {
-    for (let i = context.messages.length - 1; i >= 0; i--) {
-      const message = context.messages[i];
-      if (isPiUserMessage(message)) {
-        if (typeof message.content === "string") {
-          lastUserText = message.content;
-        } else {
-          lastUserText = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
-        }
-        break;
-      }
-    }
-  }
-  if (lastUserText !== void 0) {
-    const queuedMatch = patchState.queuedPromptStates.find(
-      (state) => state.promptText === lastUserText
-    );
-    if (queuedMatch) {
-      return queuedMatch;
-    }
-    const matches = [...patchState.activePromptStates].filter(
-      (state) => state.promptText === lastUserText
+  return promptContextStore().getStore();
+}
+function installPiAgentInstrumentation(agent) {
+  const existing = piAgentPatchStates.get(agent);
+  if (!existing || agent.streamFn !== existing.wrappedStreamFn) {
+    const patchState = {
+      originalStreamFn: agent.streamFn,
+      wrappedStreamFn: agent.streamFn
+    };
+    patchState.wrappedStreamFn = makeInstrumentedStreamFn(
+      agent,
+      patchState.originalStreamFn
     );
-    if (matches.length === 1) {
-      return matches[0];
-    }
+    agent.streamFn = patchState.wrappedStreamFn;
+    piAgentPatchStates.set(agent, patchState);
   }
-  const contextState = currentPiPromptState();
-  if (contextState && patchState.activePromptStates.has(contextState) && (!contextState.queued || lastUserText !== void 0 && contextState.promptText === lastUserText)) {
-    return contextState;
+  if (piAgentEventSubscriptions.has(agent)) {
+    return;
   }
-  if (patchState.activePromptStates.size === 1) {
-    return [...patchState.activePromptStates][0];
+  try {
+    agent.subscribe(async (event) => {
+      const state = currentPiPromptState();
+      if (!state || state.agent !== agent || state.finalized) {
+        return;
+      }
+      try {
+        await runWithAutoInstrumentationSuppressed(
+          () => handlePiAgentEvent(state, event)
+        );
+      } catch (error) {
+        logInstrumentationError4("Pi Coding Agent event", error);
+      }
+    });
+    piAgentEventSubscriptions.add(agent);
+  } catch (error) {
+    logInstrumentationError4("Pi Coding Agent event subscription", error);
   }
-  return void 0;
 }
-function makeSharedInstrumentedStreamFn(patchState) {
+function makeInstrumentedStreamFn(agent, originalStreamFn) {
   return async function instrumentedPiStreamFn(model, context, options) {
-    const state = resolveStreamPromptState(patchState, context);
-    if (!state) {
-      const invokeOriginal = () => Reflect.apply(patchState.originalStreamFn, this, [
-        model,
-        context,
-        options
-      ]);
-      return patchState.activePromptStates.size > 0 ? runWithAutoInstrumentationSuppressed(invokeOriginal) : invokeOriginal();
+    const invokeOriginal = () => Reflect.apply(originalStreamFn, this, [model, context, options]);
+    const state = currentPiPromptState();
+    if (!state || state.agent !== agent || state.finalized) {
+      return invokeOriginal();
     }
-    state.sawStreamFn = true;
-    removeQueuedPromptState(state);
-    state.streamPatchState.eventPromptState = state;
     const llmState = await startPiLlmSpan(state, model, context, options);
     try {
-      const stream = await runWithAutoInstrumentationSuppressed(
-        () => Reflect.apply(patchState.originalStreamFn, this, [
-          model,
-          context,
-          options
-        ])
-      );
+      const stream = await runWithAutoInstrumentationSuppressed(invokeOriginal);
       return patchAssistantMessageStream(stream, state, llmState);
     } catch (error) {
       finishPiLlmSpan(state, llmState, void 0, error);
@@ -30178,13 +31947,6 @@ async function handlePiAgentEvent(state, event) {
   if (state.finalized) {
     return;
   }
-  const eventPromptState = state.streamPatchState.eventPromptState;
-  if (eventPromptState && eventPromptState !== state) {
-    return;
-  }
-  if (!eventPromptState && (state.queued || state.streamPatchState.activePromptStates.size > 1 && currentPiPromptState() !== state)) {
-    return;
-  }
   switch (event.type) {
     case "message_end":
       if (isPiAssistantMessage(event.message)) {
@@ -30199,11 +31961,8 @@ async function handlePiAgentEvent(state, event) {
           addMetrics(state.metrics, extractUsageMetrics2(event.message.usage));
         }
       }
-      if (state.streamPatchState.eventPromptState === state) {
-        state.streamPatchState.eventPromptState = void 0;
-      }
       if (state.promptCallEnded && state.deferCompletionUntilTurnEnd) {
-        await finalizePiPromptRun(state);
+        finishPiPromptRun(state);
       }
       return;
     case "tool_execution_start":
@@ -30276,19 +32035,13 @@ function finishPiToolSpan(state, event) {
     }
   }
 }
-async function finalizePiPromptRun(state, error) {
+function finishPiPromptRun(state, error) {
   if (state.finalized) {
     return;
   }
   state.finalized = true;
   state.onFinalize?.(state);
-  restorePiStreamFn(state);
-  try {
-    state.unsubscribeAgent?.();
-  } catch (unsubscribeError) {
-    logInstrumentationError4("Pi Coding Agent unsubscribe", unsubscribeError);
-  }
-  await finishOpenLlmSpans(state, error);
+  finishOpenLlmSpans(state, error);
   finishOpenToolSpans(state, error);
   const metadata = {
     ...state.metadata,
@@ -30305,34 +32058,14 @@ async function finalizePiPromptRun(state, error) {
       output: state.output
     });
   } finally {
-    state.span.end();
-  }
-}
-function restorePiStreamFn(state) {
-  const patchState = state.streamPatchState;
-  patchState.activePromptStates.delete(state);
-  removeQueuedPromptState(state);
-  if (patchState.eventPromptState === state) {
-    patchState.eventPromptState = void 0;
-  }
-  state.restorePromptContext?.();
-  if (patchState.activePromptStates.size > 0) {
-    return;
-  }
-  if (patchState.agent.streamFn === patchState.wrappedStreamFn) {
-    patchState.agent.streamFn = patchState.originalStreamFn;
-  }
-  piStreamPatchStates.delete(patchState.agent);
-}
-function removeQueuedPromptState(state) {
-  state.queued = false;
-  const queuedPromptStates = state.streamPatchState.queuedPromptStates;
-  const index = queuedPromptStates.indexOf(state);
-  if (index >= 0) {
-    queuedPromptStates.splice(index, 1);
+    try {
+      state.span.end();
+    } catch (endError) {
+      logInstrumentationError4("Pi Coding Agent prompt end", endError);
+    }
   }
 }
-async function finishOpenLlmSpans(state, error) {
+function finishOpenLlmSpans(state, error) {
   for (const llmState of [...state.activeLlmSpans]) {
     finishPiLlmSpan(state, llmState, void 0, error);
   }
@@ -30413,7 +32146,7 @@ function normalizeAssistantMessage(message) {
     (part) => part.type === "thinking" && !part.redacted ? [part.thinking] : []
   ).join("");
   const toolCalls = message.content.flatMap(
-    (part) => part.type === "toolCall" ? [normalizeToolCall(part)] : []
+    (part) => part.type === "toolCall" ? [normalizeToolCall2(part)] : []
   );
   return {
     role: "assistant",
@@ -30448,13 +32181,13 @@ function normalizeUserContent(content) {
     return part;
   });
 }
-function normalizeToolCall(toolCall) {
+function normalizeToolCall2(toolCall) {
   return {
     id: toolCall.id,
     type: "function",
     function: {
       name: toolCall.name,
-      arguments: stringifyArguments(toolCall.arguments)
+      arguments: stringifyArguments2(toolCall.arguments)
     }
   };
 }
@@ -30637,7 +32370,7 @@ function cleanMetrics5(metrics) {
   }
   return cleaned;
 }
-function stringifyArguments(value) {
+function stringifyArguments2(value) {
   if (typeof value === "string") {
     return value;
   }
@@ -30833,8 +32566,7 @@ function startAgentStream(event, activeChildParents) {
     ...extractAgentMetadata2(agent),
     ...extractModelMetadata3(model),
     "strands.operation": "Agent.stream",
-    provider: extractProvider(model),
-    ...event.moduleVersion ? { "strands_agent_sdk.version": event.moduleVersion } : {}
+    provider: extractProvider(model)
   };
   const parentSpan = agent ? getOnlyChildParent(activeChildParents, agent) : void 0;
   const attachmentCache = createStrandsAttachmentCache();
@@ -30884,8 +32616,7 @@ function startMultiAgentStream(event, operation, activeChildParents) {
   const metadata = {
     "strands.operation": operation,
     provider: "strands",
-    ...orchestrator?.id ? { "strands.orchestrator.id": orchestrator.id } : {},
-    ...event.moduleVersion ? { "strands_agent_sdk.version": event.moduleVersion } : {}
+    ...orchestrator?.id ? { "strands.orchestrator.id": orchestrator.id } : {}
   };
   const parentSpan = orchestrator ? getOnlyChildParent(activeChildParents, orchestrator) : void 0;
   const input = processStrandsInputAttachments(event.arguments[0]);
@@ -31671,6 +33402,320 @@ function logInstrumentationError5(context, error) {
   debugLogger.debug(`${context}:`, error);
 }
 
+// src/instrumentation/plugins/voyageai-channels.ts
+var voyageAIChannels = defineChannels(
+  "voyageai",
+  {
+    embed: channel({
+      channelName: "embed",
+      kind: "async"
+    }),
+    multimodalEmbed: channel({
+      channelName: "multimodalEmbed",
+      kind: "async"
+    }),
+    rerank: channel({
+      channelName: "rerank",
+      kind: "async"
+    }),
+    contextualizedEmbed: channel({
+      channelName: "contextualizedEmbed",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.VOYAGEAI }
+);
+
+// src/instrumentation/plugins/voyageai-plugin.ts
+var RERANK_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "model",
+  "returnDocuments",
+  "topK",
+  "truncation"
+]);
+var VoyageAIPlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(
+      interceptVoyageAICall(
+        voyageAIChannels.embed,
+        "voyageai.embed",
+        extractTextEmbeddingInput,
+        summarizeEmbeddingOutput,
+        extractEmbeddingUsageMetrics
+      ),
+      interceptVoyageAICall(
+        voyageAIChannels.multimodalEmbed,
+        "voyageai.multimodalEmbed",
+        extractMultimodalEmbeddingInput,
+        summarizeEmbeddingOutput,
+        extractEmbeddingUsageMetrics
+      ),
+      interceptVoyageAICall(
+        voyageAIChannels.rerank,
+        "voyageai.rerank",
+        extractRerankInput,
+        summarizeRerankOutput
+      ),
+      interceptVoyageAICall(
+        voyageAIChannels.contextualizedEmbed,
+        "voyageai.contextualizedEmbed",
+        extractContextualizedEmbeddingInput,
+        summarizeContextualizedEmbeddingOutput,
+        extractEmbeddingUsageMetrics
+      )
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function interceptVoyageAICall(channel2, name, extractInput2, extractOutput2, extractMetrics2 = extractUsageMetrics3) {
+  return channel2.intercept((target, thisArg, args) => {
+    const invokeTarget = () => Reflect.apply(target, thisArg, args);
+    if (isAutoInstrumentationSuppressed()) {
+      return invokeTarget();
+    }
+    let span;
+    try {
+      const { input, metadata } = extractInput2(args);
+      span = startSpan(
+        withSpanInstrumentationName(
+          {
+            event: { input, metadata },
+            name,
+            spanAttributes: { type: "llm" /* LLM */ }
+          },
+          INSTRUMENTATION_NAMES.VOYAGEAI
+        )
+      );
+    } catch (error) {
+      debugLogger.error(`Error starting span for ${name}:`, error);
+      return invokeTarget();
+    }
+    let result;
+    try {
+      result = withCurrent(
+        span,
+        () => runWithAutoInstrumentationSuppressed(invokeTarget)
+      );
+    } catch (error) {
+      finishVoyageAISpan(span, name, () => span.log({ error }));
+      throw error;
+    }
+    void Promise.resolve(result).then(
+      (value) => finishVoyageAISpan(span, name, () => {
+        const metadata = extractResponseMetadata3(value);
+        span.log({
+          output: extractOutput2(value),
+          ...metadata ? { metadata } : {},
+          metrics: extractMetrics2(value)
+        });
+      }),
+      (error) => finishVoyageAISpan(span, name, () => span.log({ error }))
+    );
+    return result;
+  });
+}
+function finishVoyageAISpan(span, name, log) {
+  try {
+    log();
+  } catch (error) {
+    debugLogger.error(`Error logging span for ${name}:`, error);
+  }
+  try {
+    span.end();
+  } catch (error) {
+    debugLogger.error(`Error ending span for ${name}:`, error);
+  }
+}
+function getRequestArg2(args) {
+  if (Array.isArray(args)) {
+    return isObject(args[0]) ? args[0] : void 0;
+  }
+  if (!isObject(args)) {
+    return void 0;
+  }
+  const firstArg = Reflect.get(args, "0");
+  return isObject(firstArg) ? firstArg : void 0;
+}
+function pickMetadata(request, allowlist) {
+  const metadata = {};
+  if (request) {
+    for (const key of allowlist) {
+      if (!Object.hasOwn(request, key)) {
+        continue;
+      }
+      const value = request[key];
+      if (value !== void 0) {
+        metadata[key] = value;
+      }
+    }
+  }
+  return {
+    ...metadata,
+    provider: "voyage"
+  };
+}
+function buildEmbeddingInput(inputs, request) {
+  const outputDimensions = request?.outputDimension;
+  return {
+    inputs,
+    ...typeof outputDimensions === "number" && Number.isFinite(outputDimensions) ? { output_dimensions: outputDimensions } : {}
+  };
+}
+function embeddingMetadata(request) {
+  return {
+    ...typeof request?.model === "string" ? { model: request.model } : {},
+    provider: "voyage"
+  };
+}
+function extractTextEmbeddingInput(args) {
+  const request = getRequestArg2(args);
+  const rawInput = request?.input;
+  const values = Array.isArray(rawInput) ? rawInput : [rawInput];
+  return {
+    input: buildEmbeddingInput(
+      values.flatMap(
+        (value) => typeof value === "string" ? [{ content: value }] : []
+      ),
+      request
+    ),
+    metadata: embeddingMetadata(request)
+  };
+}
+function extractContextualizedEmbeddingInput(args) {
+  const request = getRequestArg2(args);
+  const rawInputs = request?.inputs;
+  const values = Array.isArray(rawInputs) ? rawInputs.flatMap((value) => Array.isArray(value) ? value : [value]) : [];
+  return {
+    input: buildEmbeddingInput(
+      values.flatMap(
+        (value) => typeof value === "string" ? [{ content: value }] : []
+      ),
+      request
+    ),
+    metadata: embeddingMetadata(request)
+  };
+}
+function extractMultimodalEmbeddingInput(args) {
+  const request = getRequestArg2(args);
+  const rawInputs = request?.inputs;
+  const inputs = Array.isArray(rawInputs) ? rawInputs.map((rawInput) => {
+    const rawContent = isObject(rawInput) ? rawInput.content : void 0;
+    return {
+      content: Array.isArray(rawContent) ? rawContent.flatMap(normalizeMultimodalContentPart) : []
+    };
+  }) : [];
+  const input = buildEmbeddingInput(inputs, request);
+  const processedInput = processInputAttachments(input);
+  return {
+    input: hasInlineEmbeddingMedia(processedInput) ? input : processedInput,
+    metadata: embeddingMetadata(request)
+  };
+}
+function normalizeMultimodalContentPart(part) {
+  if (!isObject(part) || typeof part.type !== "string") {
+    return [];
+  }
+  if (part.type === "text") {
+    return typeof part.text === "string" ? [{ type: "text", text: part.text }] : [];
+  }
+  const camelCaseField = {
+    image_base64: "imageBase64",
+    image_url: "imageUrl",
+    video_base64: "videoBase64",
+    video_url: "videoUrl"
+  };
+  const field = camelCaseField[part.type];
+  if (!field) {
+    return [];
+  }
+  const data = typeof part[field] === "string" ? part[field] : part[part.type];
+  if (typeof data !== "string") {
+    return [];
+  }
+  return part.type.startsWith("image_") ? [{ type: "image_url", image_url: { url: data } }] : [{ type: "file", file: { file_data: data } }];
+}
+function hasInlineEmbeddingMedia(input) {
+  return input.inputs.some(
+    ({ content }) => Array.isArray(content) ? content.some((part) => {
+      const value = part.type === "image_url" ? part.image_url.url : part.type === "file" ? part.file.file_data : void 0;
+      return typeof value === "string" && value.startsWith("data:");
+    }) : false
+  );
+}
+function extractRerankInput(args) {
+  const request = getRequestArg2(args);
+  const documents = request?.documents;
+  return {
+    input: {
+      documents,
+      query: request?.query
+    },
+    metadata: {
+      ...pickMetadata(request, RERANK_METADATA_ALLOWLIST),
+      ...Array.isArray(documents) ? { document_count: documents.length } : {}
+    }
+  };
+}
+function extractResponseMetadata3(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const rawResponse = isObject(result.rawResponse) ? result.rawResponse : void 0;
+  const model = typeof result.model === "string" ? result.model : typeof rawResponse?.model === "string" ? rawResponse.model : void 0;
+  return model ? { model } : void 0;
+}
+function summarizeEmbeddingOutput(result) {
+  return {
+    count: isObject(result) && Array.isArray(result.data) ? result.data.length : 0
+  };
+}
+function summarizeRerankOutput(result) {
+  if (!isObject(result) || !Array.isArray(result.data)) {
+    return void 0;
+  }
+  return result.data.slice(0, 100).map((item) => ({
+    index: isObject(item) ? item.index : void 0,
+    relevance_score: isObject(item) ? (typeof item.relevanceScore === "number" ? item.relevanceScore : item.relevance_score) ?? null : null
+  }));
+}
+function summarizeContextualizedEmbeddingOutput(result) {
+  if (!isObject(result)) {
+    return { count: 0 };
+  }
+  if (Array.isArray(result.results)) {
+    return {
+      count: result.results.reduce(
+        (count, item) => count + (isObject(item) && Array.isArray(item.embeddings) ? item.embeddings.length : 0),
+        0
+      )
+    };
+  }
+  if (!Array.isArray(result.data)) {
+    return { count: 0 };
+  }
+  return {
+    count: result.data.reduce(
+      (count, item) => count + (isObject(item) && Array.isArray(item.data) ? item.data.length : 0),
+      0
+    )
+  };
+}
+function extractEmbeddingUsageMetrics(result) {
+  const metrics = extractUsageMetrics3(result);
+  return typeof metrics.tokens === "number" ? { prompt_tokens: metrics.tokens, tokens: metrics.tokens } : {};
+}
+function extractUsageMetrics3(result) {
+  if (!isObject(result)) {
+    return {};
+  }
+  const rawResponse = isObject(result.rawResponse) ? result.rawResponse : void 0;
+  const usage = isObject(result.usage) ? result.usage : isObject(rawResponse?.usage) ? rawResponse.usage : void 0;
+  const tokens = typeof result.totalTokens === "number" ? result.totalTokens : usage?.totalTokens ?? usage?.total_tokens;
+  return typeof tokens === "number" && Number.isFinite(tokens) && tokens >= 0 ? { tokens } : {};
+}
+
 // src/instrumentation/plugins/cloudflare-ai-chat-channels.ts
 var cloudflareAIChatChannels = defineChannels(
   "@cloudflare/ai-chat",
@@ -32205,6 +34250,7 @@ var BraintrustPlugin = class extends BasePlugin {
   anthropicPlugin = null;
   aiSDKPlugin = null;
   claudeAgentSDKPlugin = null;
+  cloudflareThinkPlugin = null;
   cursorSDKPlugin = null;
   openAIAgentsPlugin = null;
   googleGenAIPlugin = null;
@@ -32213,6 +34259,7 @@ var BraintrustPlugin = class extends BasePlugin {
   openRouterPlugin = null;
   openRouterAgentPlugin = null;
   mistralPlugin = null;
+  ollamaPlugin = null;
   googleADKPlugin = null;
   coherePlugin = null;
   groqPlugin = null;
@@ -32224,6 +34271,7 @@ var BraintrustPlugin = class extends BasePlugin {
   langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
+  voyageAIPlugin = null;
   cloudflareAIChatPlugin = null;
   cloudflareAgentsPlugin = null;
   constructor(config = {}) {
@@ -32252,6 +34300,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.claudeAgentSDKPlugin = new ClaudeAgentSDKPlugin();
       this.claudeAgentSDKPlugin.enable();
     }
+    if (integrations.cloudflareThink !== false) {
+      this.cloudflareThinkPlugin = new CloudflareThinkPlugin();
+      this.cloudflareThinkPlugin.enable();
+    }
     if (integrations.cursorSDK !== false && integrations.cursor !== false) {
       this.cursorSDKPlugin = new CursorSDKPlugin();
       this.cursorSDKPlugin.enable();
@@ -32282,6 +34334,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.mistralPlugin = new MistralPlugin();
       this.mistralPlugin.enable();
     }
+    if (integrations.ollama !== false) {
+      this.ollamaPlugin = new OllamaPlugin();
+      this.ollamaPlugin.enable();
+    }
     if (integrations.googleADK !== false) {
       this.googleADKPlugin = new GoogleADKPlugin();
       this.googleADKPlugin.enable();
@@ -32290,6 +34346,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.coherePlugin = new CoherePlugin();
       this.coherePlugin.enable();
     }
+    if (integrations.voyageai !== false) {
+      this.voyageAIPlugin = new VoyageAIPlugin();
+      this.voyageAIPlugin.enable();
+    }
     if (integrations.groq !== false) {
       this.groqPlugin = new GroqPlugin();
       this.groqPlugin.enable();
@@ -32358,6 +34418,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.claudeAgentSDKPlugin.disable();
       this.claudeAgentSDKPlugin = null;
     }
+    if (this.cloudflareThinkPlugin) {
+      this.cloudflareThinkPlugin.disable();
+      this.cloudflareThinkPlugin = null;
+    }
     if (this.cursorSDKPlugin) {
       this.cursorSDKPlugin.disable();
       this.cursorSDKPlugin = null;
@@ -32390,6 +34454,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.mistralPlugin.disable();
       this.mistralPlugin = null;
     }
+    if (this.ollamaPlugin) {
+      this.ollamaPlugin.disable();
+      this.ollamaPlugin = null;
+    }
     if (this.googleADKPlugin) {
       this.googleADKPlugin.disable();
       this.googleADKPlugin = null;
@@ -32398,6 +34466,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.coherePlugin.disable();
       this.coherePlugin = null;
     }
+    if (this.voyageAIPlugin) {
+      this.voyageAIPlugin.disable();
+      this.voyageAIPlugin = null;
+    }
     if (this.groqPlugin) {
       this.groqPlugin.disable();
       this.groqPlugin = null;
@@ -34126,6 +36198,7 @@ var envIntegrationAliases = {
   cloudflareaichat: "cloudflareAIChat",
   "cloudflare-ai-chat": "cloudflareAIChat",
   "@cloudflare/ai-chat": "cloudflareAIChat",
+  cloudflarethink: "cloudflareThink",
   cursor: "cursor",
   "cursor-sdk": "cursorSDK",
   cursorsdk: "cursorSDK",
@@ -34146,6 +36219,7 @@ var envIntegrationAliases = {
   openrouteragent: "openrouterAgent",
   "openrouter-agent": "openrouterAgent",
   mistral: "mistral",
+  ollama: "ollama",
   googleadk: "googleADK",
   "google-adk": "googleADK",
   cohere: "cohere",
@@ -34166,7 +36240,10 @@ var envIntegrationAliases = {
   "langchain-js": "langchain",
   "@langchain": "langchain",
   langgraph: "langgraph",
-  langsmith: "langsmith"
+  langsmith: "langsmith",
+  voyage: "voyageai",
+  "voyage-ai": "voyageai",
+  voyageai: "voyageai"
 };
 function getDefaultInstrumentationIntegrations() {
   return {
@@ -34181,6 +36258,7 @@ function getDefaultInstrumentationIntegrations() {
     huggingface: true,
     claudeAgentSDK: true,
     cloudflareAIChat: true,
+    cloudflareThink: true,
     cursor: true,
     cursorSDK: true,
     flue: true,
@@ -34189,6 +36267,7 @@ function getDefaultInstrumentationIntegrations() {
     openrouter: true,
     openrouterAgent: true,
     mistral: true,
+    ollama: true,
     cohere: true,
     groq: true,
     bedrock: true,
@@ -34199,6 +36278,7 @@ function getDefaultInstrumentationIntegrations() {
     langchain: true,
     langgraph: true,
     langsmith: true,
+    voyageai: true,
     piCodingAgent: true,
     strandsAgentSDK: true,
     cloudflareAgents: true