braintrust 3.11.0 → 3.12.0

package/dist/index.mjs

@@ -1,101 +1,35 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export,
+  aiSDKChannels,
+  anthropicChannels,
+  claudeAgentSDKChannels,
+  cohereChannels,
+  cursorSDKChannels,
+  flueChannels,
+  genkitChannels,
+  genkitCoreChannels,
+  getDefaultInstrumentationIntegrations,
+  gitHubCopilotChannels,
+  googleADKChannels,
+  googleGenAIChannels,
+  groqChannels,
+  huggingFaceChannels,
+  isomorph_default,
+  langChainChannels,
+  mistralChannels,
+  openAIAgentsCoreChannels,
+  openAIChannels,
+  openAICodexChannels,
+  openRouterAgentChannels,
+  openRouterChannels,
+  patchTracingChannel,
+  readDisabledInstrumentationEnvConfig
+} from "./chunk-MSLBGITU.mjs";
 
 // src/node/config.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as diagnostics_channel from "node:diagnostics_channel";
 import * as path from "node:path";
-
-// src/auto-instrumentations/patch-tracing-channel.ts
-function patchTracingChannel(tracingChannelFn) {
-  const dummyChannel = tracingChannelFn("__braintrust_probe__");
-  const TracingChannel = dummyChannel?.constructor;
-  if (!TracingChannel?.prototype) {
-    return;
-  }
-  if (!Object.getOwnPropertyDescriptor(TracingChannel.prototype, "hasSubscribers")) {
-    Object.defineProperty(TracingChannel.prototype, "hasSubscribers", {
-      configurable: true,
-      enumerable: false,
-      get() {
-        return Boolean(
-          this.start?.hasSubscribers || this.end?.hasSubscribers || this.asyncStart?.hasSubscribers || this.asyncEnd?.hasSubscribers || this.error?.hasSubscribers
-        );
-      }
-    });
-  }
-  if (TracingChannel.prototype.tracePromise) {
-    TracingChannel.prototype.tracePromise = function(fn, context = {}, thisArg, ...args) {
-      const start = this.start;
-      const end = this.end;
-      const asyncStart = this.asyncStart;
-      const asyncEnd = this.asyncEnd;
-      const error = this.error;
-      function publishRejected(err) {
-        context.error = err;
-        error?.publish(context);
-        asyncStart?.publish(context);
-        asyncEnd?.publish(context);
-      }
-      function publishResolved(result) {
-        context.result = result;
-        asyncStart?.publish(context);
-        asyncEnd?.publish(context);
-      }
-      return start.runStores(context, () => {
-        try {
-          const result = Reflect.apply(fn, thisArg, args);
-          end?.publish(context);
-          if (result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function") {
-            if (result.constructor === Promise) {
-              return result.then(
-                (res) => {
-                  publishResolved(res);
-                  return res;
-                },
-                (err) => {
-                  publishRejected(err);
-                  return Promise.reject(err);
-                }
-              );
-            }
-            void result.then(
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              (resolved) => {
-                try {
-                  publishResolved(resolved);
-                } catch {
-                }
-              },
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              (err) => {
-                try {
-                  publishRejected(err);
-                } catch {
-                }
-              }
-            );
-            return result;
-          }
-          context.result = result;
-          asyncStart?.publish(context);
-          asyncEnd?.publish(context);
-          return result;
-        } catch (err) {
-          context.error = err;
-          error?.publish(context);
-          end?.publish(context);
-          throw err;
-        }
-      });
-    };
-  }
-}
-
-// src/node/config.ts
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as fsSync from "node:fs";
@@ -103,103 +37,6 @@ import * as crypto from "node:crypto";
 import { promisify } from "node:util";
 import * as zlib from "node:zlib";
 
-// src/isomorph.ts
-var DefaultAsyncLocalStorage = class {
-  constructor() {
-  }
-  enterWith(_) {
-  }
-  run(_, callback) {
-    return callback();
-  }
-  getStore() {
-    return void 0;
-  }
-};
-var DefaultChannel = class {
-  constructor(name) {
-    this.name = name;
-  }
-  hasSubscribers = false;
-  subscribe(_subscription) {
-  }
-  unsubscribe(_subscription) {
-    return false;
-  }
-  bindStore(_store, _transform) {
-  }
-  unbindStore(_store) {
-    return false;
-  }
-  publish(_message) {
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runStores(_message, fn, thisArg, ...args) {
-    return fn.apply(thisArg, args);
-  }
-};
-var DefaultTracingChannel = class {
-  start;
-  end;
-  asyncStart;
-  asyncEnd;
-  error;
-  constructor(nameOrChannels) {
-    if (typeof nameOrChannels === "string") {
-      this.start = new DefaultChannel(`tracing:${nameOrChannels}:start`);
-      this.end = new DefaultChannel(`tracing:${nameOrChannels}:end`);
-      this.asyncStart = new DefaultChannel(
-        `tracing:${nameOrChannels}:asyncStart`
-      );
-      this.asyncEnd = new DefaultChannel(`tracing:${nameOrChannels}:asyncEnd`);
-      this.error = new DefaultChannel(`tracing:${nameOrChannels}:error`);
-      return;
-    }
-    this.start = nameOrChannels.start ?? new DefaultChannel("tracing:start");
-    this.end = nameOrChannels.end ?? new DefaultChannel("tracing:end");
-    this.asyncStart = nameOrChannels.asyncStart ?? new DefaultChannel("tracing:asyncStart");
-    this.asyncEnd = nameOrChannels.asyncEnd ?? new DefaultChannel("tracing:asyncEnd");
-    this.error = nameOrChannels.error ?? new DefaultChannel("tracing:error");
-  }
-  get hasSubscribers() {
-    return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
-  }
-  subscribe(_handlers) {
-  }
-  unsubscribe(_handlers) {
-    return false;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  traceSync(fn, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  tracePromise(fn, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  traceCallback(fn, _position, _message, thisArg, ...args) {
-    return fn.apply(thisArg, args);
-  }
-};
-var iso = {
-  buildType: "unknown",
-  // Will be set by configureBrowser() or configureNode()
-  getRepoInfo: async (_settings) => void 0,
-  getPastNAncestors: async () => [],
-  getEnv: (_name) => void 0,
-  getCallerLocation: () => void 0,
-  newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  newTracingChannel: (nameOrChannels) => new DefaultTracingChannel(nameOrChannels),
-  processOn: (_0, _1) => {
-  },
-  basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
-  // eslint-disable-next-line no-restricted-properties -- preserving intentional console usage.
-  writeln: (text) => console.log(text)
-};
-var isomorph_default = iso;
-
 // src/debug-logger.ts
 var PREFIX = "[braintrust]";
 var DEBUG_LOG_LEVEL_SYMBOL = /* @__PURE__ */ Symbol.for("braintrust-debug-log-level");
@@ -416,11 +253,11 @@ function truncateToByteLimit(s, byteLimit = 65536) {
   return new TextDecoder().decode(truncated);
 }
 async function getRepoInfo(settings) {
-  if (settings && settings.collect === "none") {
+  if (!settings || settings.collect === "none") {
     return void 0;
   }
   const repo = await repoInfo();
-  if (!repo || !settings || settings.collect === "all") {
+  if (!repo || settings.collect === "all") {
     return repo;
   }
   let sanitized = {};
@@ -1234,6 +1071,11 @@ function isPromiseLike(value) {
 
 // util/object_util.ts
 var SET_UNION_FIELDS = /* @__PURE__ */ new Set(["tags"]);
+var FORBIDDEN_MERGE_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
 function mergeDictsWithPaths({
   mergeInto,
   mergeFrom,
@@ -1256,6 +1098,7 @@ function mergeDictsWithPathsHelper({
   mergePaths
 }) {
   Object.entries(mergeFrom).forEach(([k, mergeFromV]) => {
+    if (FORBIDDEN_MERGE_KEYS.has(k)) return;
     const fullPath = path2.concat([k]);
     const fullPathSerialized = JSON.stringify(fullPath);
     const mergeIntoV = recordFind(mergeInto, k);
@@ -5329,6 +5172,13 @@ var HTTPConnection = class _HTTPConnection {
           debugLogger.debug(
             `Retrying API request ${object_type} ${JSON.stringify(args)} ${e.status} ${e.text}`
           );
+          const sleepTimeS = HTTP_RETRY_BASE_SLEEP_TIME_S * 2 ** i;
+          debugLogger.info(
+            `Sleeping for ${sleepTimeS}s before retrying API request`
+          );
+          await new Promise(
+            (resolve) => setTimeout(resolve, sleepTimeS * 1e3)
+          );
           continue;
         }
         throw e;
@@ -5978,20 +5828,7 @@ function startSpanParentArgs(args) {
         `Mismatch between expected span parent object type ${args.parentObjectType} and provided type ${parentComponents.data.object_type}`
       );
     }
-    const parentComponentsObjectIdLambda = spanComponentsToObjectIdLambda(
-      args.state,
-      parentComponents
-    );
-    const computeParentObjectId = async () => {
-      const parentComponentsObjectId = await parentComponentsObjectIdLambda();
-      if (await args.parentObjectId.get() !== parentComponentsObjectId) {
-        throw new Error(
-          `Mismatch between expected span parent object id ${await args.parentObjectId.get()} and provided id ${parentComponentsObjectId}`
-        );
-      }
-      return await args.parentObjectId.get();
-    };
-    argParentObjectId = new LazyValue(computeParentObjectId);
+    argParentObjectId = args.parentObjectId;
     if (parentComponents.data.row_id) {
       argParentSpanIds = {
         spanId: parentComponents.data.span_id,
@@ -6377,6 +6214,7 @@ var TestBackgroundLogger = class {
   }
 };
 var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
+var HTTP_RETRY_BASE_SLEEP_TIME_S = 1;
 var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
   apiConn;
   queue;
@@ -7007,17 +6845,10 @@ function init(projectOrOptions, optionalOptions) {
         if (repoInfo2) {
           return repoInfo2;
         }
-        let mergedGitMetadataSettings = {
-          ...state.gitMetadataSettings || {
-            collect: "all"
-          }
-        };
-        if (gitMetadataSettings) {
-          mergedGitMetadataSettings = mergeGitMetadataSettings(
-            mergedGitMetadataSettings,
-            gitMetadataSettings
-          );
-        }
+        const mergedGitMetadataSettings = state.gitMetadataSettings == null ? gitMetadataSettings ?? { collect: "none" } : mergeGitMetadataSettings(
+          state.gitMetadataSettings,
+          gitMetadataSettings ?? { collect: "all" }
+        );
         return await isomorph_default.getRepoInfo(mergedGitMetadataSettings);
       })();
       if (repoInfoArg) {
@@ -10408,15 +10239,15 @@ var BasePlugin = class {
    * @param handlers - Event handlers
    */
   subscribe(channelName, handlers) {
-    const channel2 = isomorph_default.newTracingChannel(channelName);
-    channel2.subscribe(handlers);
+    const channel = isomorph_default.newTracingChannel(channelName);
+    channel.subscribe(handlers);
   }
   /**
    * Subscribe to a channel for async methods (non-streaming).
    * Creates a span and logs input/output/metrics.
    */
   subscribeToChannel(channelName, config) {
-    const channel2 = isomorph_default.newTracingChannel(channelName);
+    const channel = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -10475,9 +10306,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel2.subscribe(handlers);
+    channel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+      channel.unsubscribe(handlers);
     });
   }
   /**
@@ -10485,7 +10316,7 @@ var BasePlugin = class {
    * Handles both streaming and non-streaming responses.
    */
   subscribeToStreamingChannel(channelName, config) {
-    const channel2 = isomorph_default.newTracingChannel(channelName);
+    const channel = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -10602,9 +10433,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel2.subscribe(handlers);
+    channel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+      channel.unsubscribe(handlers);
     });
   }
   /**
@@ -10612,7 +10443,7 @@ var BasePlugin = class {
    * Used for methods like beta.chat.completions.stream() and responses.stream().
    */
   subscribeToSyncStreamChannel(channelName, config) {
-    const channel2 = isomorph_default.newTracingChannel(channelName);
+    const channel = isomorph_default.newTracingChannel(channelName);
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -10714,9 +10545,9 @@ var BasePlugin = class {
         spans.delete(event);
       }
     };
-    channel2.subscribe(handlers);
+    channel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+      channel.unsubscribe(handlers);
     });
   }
 };
@@ -10821,10 +10652,10 @@ function runStreamingCompletionHook(args) {
     console.error(`Error in onComplete hook for ${args.channelName}:`, error);
   }
 }
-function traceAsyncChannel(channel2, config) {
-  const tracingChannel2 = channel2.tracingChannel();
+function traceAsyncChannel(channel, config) {
+  const tracingChannel2 = channel.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
-  const channelName = channel2.channelName;
+  const channelName = channel.channelName;
   const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
     tracingChannel2,
     states,
@@ -10883,10 +10714,10 @@ function traceAsyncChannel(channel2, config) {
     tracingChannel2.unsubscribe(handlers);
   };
 }
-function traceStreamingChannel(channel2, config) {
-  const tracingChannel2 = channel2.tracingChannel();
+function traceStreamingChannel(channel, config) {
+  const tracingChannel2 = channel.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
-  const channelName = channel2.channelName;
+  const channelName = channel.channelName;
   const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
     tracingChannel2,
     states,
@@ -11042,10 +10873,10 @@ function traceStreamingChannel(channel2, config) {
     tracingChannel2.unsubscribe(handlers);
   };
 }
-function traceSyncStreamChannel(channel2, config) {
-  const tracingChannel2 = channel2.tracingChannel();
+function traceSyncStreamChannel(channel, config) {
+  const tracingChannel2 = channel.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
-  const channelName = channel2.channelName;
+  const channelName = channel.channelName;
   const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
     tracingChannel2,
     states,
@@ -11324,92 +11155,6 @@ function processInputAttachments(input) {
   return processNode(input);
 }
 
-// src/instrumentation/core/channel-definitions.ts
-function channel(spec) {
-  return spec;
-}
-function defineChannels(pkg, channels) {
-  return Object.fromEntries(
-    Object.entries(channels).map(([key, spec]) => {
-      const fullChannelName = `orchestrion:${pkg}:${spec.channelName}`;
-      if (spec.kind === "async") {
-        const asyncSpec = spec;
-        const tracingChannel3 = () => isomorph_default.newTracingChannel(
-          fullChannelName
-        );
-        return [
-          key,
-          {
-            ...asyncSpec,
-            tracingChannel: tracingChannel3,
-            tracePromise: (fn, context) => tracingChannel3().tracePromise(
-              fn,
-              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-              context
-            )
-          }
-        ];
-      }
-      const syncSpec = spec;
-      const tracingChannel2 = () => isomorph_default.newTracingChannel(
-        fullChannelName
-      );
-      return [
-        key,
-        {
-          ...syncSpec,
-          tracingChannel: tracingChannel2,
-          traceSync: (fn, context) => tracingChannel2().traceSync(
-            fn,
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            context
-          )
-        }
-      ];
-    })
-  );
-}
-
-// src/instrumentation/plugins/openai-channels.ts
-var openAIChannels = defineChannels("openai", {
-  chatCompletionsCreate: channel({
-    channelName: "chat.completions.create",
-    kind: "async"
-  }),
-  embeddingsCreate: channel({
-    channelName: "embeddings.create",
-    kind: "async"
-  }),
-  betaChatCompletionsParse: channel({
-    channelName: "beta.chat.completions.parse",
-    kind: "async"
-  }),
-  betaChatCompletionsStream: channel({
-    channelName: "beta.chat.completions.stream",
-    kind: "sync-stream"
-  }),
-  moderationsCreate: channel({
-    channelName: "moderations.create",
-    kind: "async"
-  }),
-  responsesCreate: channel({
-    channelName: "responses.create",
-    kind: "async"
-  }),
-  responsesStream: channel({
-    channelName: "responses.stream",
-    kind: "sync-stream"
-  }),
-  responsesParse: channel({
-    channelName: "responses.parse",
-    kind: "async"
-  }),
-  responsesCompact: channel({
-    channelName: "responses.compact",
-    kind: "async"
-  })
-});
-
 // src/openai-utils.ts
 var BRAINTRUST_CACHED_STREAM_METRIC = "__braintrust_cached_metric";
 var LEGACY_CACHED_HEADER = "x-cached";
@@ -11922,18 +11667,6 @@ function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
   };
 }
 
-// src/instrumentation/plugins/openai-codex-channels.ts
-var openAICodexChannels = defineChannels("@openai/codex-sdk", {
-  run: channel({
-    channelName: "Thread.run",
-    kind: "async"
-  }),
-  runStreamed: channel({
-    channelName: "Thread.runStreamed",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/openai-codex-plugin.ts
 var PATCHED_STREAMED_TURN = /* @__PURE__ */ Symbol.for(
   "braintrust.openai-codex.patched-streamed-turn"
@@ -11950,7 +11683,7 @@ var OpenAICodexPlugin = class extends BasePlugin {
     this.unsubscribers = [];
   }
   subscribeToRun() {
-    const channel2 = openAICodexChannels.run.tracingChannel();
+    const channel = openAICodexChannels.run.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -11973,13 +11706,13 @@ var OpenAICodexPlugin = class extends BasePlugin {
         await finalizeCodexRun(state, { error: event.error });
       }
     };
-    channel2.subscribe(handlers);
+    channel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+      channel.unsubscribe(handlers);
     });
   }
   subscribeToRunStreamed() {
-    const channel2 = openAICodexChannels.runStreamed.tracingChannel();
+    const channel = openAICodexChannels.runStreamed.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -12002,9 +11735,9 @@ var OpenAICodexPlugin = class extends BasePlugin {
         await finalizeCodexRun(state, { error: event.error });
       }
     };
-    channel2.subscribe(handlers);
+    channel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+      channel.unsubscribe(handlers);
     });
   }
 };
@@ -12577,22 +12310,6 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
   return cacheTokens;
 }
 
-// src/instrumentation/plugins/anthropic-channels.ts
-var anthropicChannels = defineChannels("@anthropic-ai/sdk", {
-  messagesCreate: channel({
-    channelName: "messages.create",
-    kind: "async"
-  }),
-  betaMessagesCreate: channel({
-    channelName: "beta.messages.create",
-    kind: "async"
-  }),
-  betaMessagesToolRunner: channel({
-    channelName: "beta.messages.toolRunner",
-    kind: "sync-stream"
-  })
-});
-
 // src/instrumentation/plugins/anthropic-plugin.ts
 var ANTHROPIC_TOOL_RUNNER_TOOL_WRAPPED = /* @__PURE__ */ Symbol.for(
   "braintrust.anthropic_tool_runner_tool_wrapped"
@@ -13389,68 +13106,6 @@ function serializeAISDKToolsForLogging(tools) {
   return serialized;
 }
 
-// src/instrumentation/plugins/ai-sdk-channels.ts
-var aiSDKChannels = defineChannels("ai", {
-  generateText: channel({
-    channelName: "generateText",
-    kind: "async"
-  }),
-  streamText: channel({
-    channelName: "streamText",
-    kind: "async"
-  }),
-  streamTextSync: channel({
-    channelName: "streamText.sync",
-    kind: "sync-stream"
-  }),
-  generateObject: channel({
-    channelName: "generateObject",
-    kind: "async"
-  }),
-  streamObject: channel({
-    channelName: "streamObject",
-    kind: "async"
-  }),
-  streamObjectSync: channel({
-    channelName: "streamObject.sync",
-    kind: "sync-stream"
-  }),
-  embed: channel(
-    {
-      channelName: "embed",
-      kind: "async"
-    }
-  ),
-  embedMany: channel({
-    channelName: "embedMany",
-    kind: "async"
-  }),
-  rerank: channel({
-    channelName: "rerank",
-    kind: "async"
-  }),
-  agentGenerate: channel({
-    channelName: "Agent.generate",
-    kind: "async"
-  }),
-  agentStream: channel({
-    channelName: "Agent.stream",
-    kind: "async"
-  }),
-  agentStreamSync: channel({
-    channelName: "Agent.stream.sync",
-    kind: "sync-stream"
-  }),
-  toolLoopAgentGenerate: channel({
-    channelName: "ToolLoopAgent.generate",
-    kind: "async"
-  }),
-  toolLoopAgentStream: channel({
-    channelName: "ToolLoopAgent.stream",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/ai-sdk-plugin.ts
 var DEFAULT_DENY_OUTPUT_PATHS = [
   // v3
@@ -13713,11 +13368,11 @@ function resolveDenyOutputPaths(event, defaultDenyOutputPaths) {
   if (Array.isArray(event?.denyOutputPaths)) {
     return event.denyOutputPaths;
   }
-  const firstArgument = event?.arguments && event.arguments.length > 0 ? event.arguments[0] : void 0;
-  if (!firstArgument || typeof firstArgument !== "object") {
+  const firstArgument2 = event?.arguments && event.arguments.length > 0 ? event.arguments[0] : void 0;
+  if (!firstArgument2 || typeof firstArgument2 !== "object") {
     return defaultDenyOutputPaths;
   }
-  const runtimeDenyOutputPaths = firstArgument[RUNTIME_DENY_OUTPUT_PATHS];
+  const runtimeDenyOutputPaths = firstArgument2[RUNTIME_DENY_OUTPUT_PATHS];
   if (Array.isArray(runtimeDenyOutputPaths) && runtimeDenyOutputPaths.every((path2) => typeof path2 === "string")) {
     return runtimeDenyOutputPaths;
   }
@@ -15088,17 +14743,6 @@ function omit(obj, paths) {
   return result;
 }
 
-// src/instrumentation/plugins/claude-agent-sdk-channels.ts
-var claudeAgentSDKChannels = defineChannels(
-  "@anthropic-ai/claude-agent-sdk",
-  {
-    query: channel({
-      channelName: "query",
-      kind: "sync-stream"
-    })
-  }
-);
-
 // src/instrumentation/plugins/claude-agent-sdk-instrumentation-constants.ts
 var CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION = "__braintrust_skip_local_tool_hooks";
 
@@ -16284,7 +15928,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
     this.unsubscribers = [];
   }
   subscribeToQuery() {
-    const channel2 = claudeAgentSDKChannels.query.tracingChannel();
+    const channel = claudeAgentSDKChannels.query.tracingChannel();
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -16491,33 +16135,13 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         spans.delete(event);
       }
     };
-    channel2.subscribe(handlers);
+    channel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+      channel.unsubscribe(handlers);
     });
   }
 };
 
-// src/instrumentation/plugins/cursor-sdk-channels.ts
-var cursorSDKChannels = defineChannels("@cursor/sdk", {
-  create: channel({
-    channelName: "Agent.create",
-    kind: "async"
-  }),
-  resume: channel({
-    channelName: "Agent.resume",
-    kind: "async"
-  }),
-  prompt: channel({
-    channelName: "Agent.prompt",
-    kind: "async"
-  }),
-  send: channel({
-    channelName: "agent.send",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/cursor-sdk-plugin.ts
 var PATCHED_AGENT = /* @__PURE__ */ Symbol.for("braintrust.cursor-sdk.auto-patched-agent");
 var PATCHED_RUN = /* @__PURE__ */ Symbol.for("braintrust.cursor-sdk.patched-run");
@@ -16540,8 +16164,8 @@ var CursorSDKPlugin = class extends BasePlugin {
     this.subscribeToAgentFactory(cursorSDKChannels.create);
     this.subscribeToAgentFactory(cursorSDKChannels.resume);
   }
-  subscribeToAgentFactory(channel2) {
-    const tracingChannel2 = channel2.tracingChannel();
+  subscribeToAgentFactory(channel) {
+    const tracingChannel2 = channel.tracingChannel();
     const handlers = {
       asyncEnd: (event) => {
         patchCursorAgentInPlace(event.result);
@@ -16555,7 +16179,7 @@ var CursorSDKPlugin = class extends BasePlugin {
     });
   }
   subscribeToPrompt() {
-    const channel2 = cursorSDKChannels.prompt.tracingChannel();
+    const channel = cursorSDKChannels.prompt.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -16610,13 +16234,13 @@ var CursorSDKPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    channel2.subscribe(handlers);
+    channel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+      channel.unsubscribe(handlers);
     });
   }
   subscribeToSend() {
-    const channel2 = cursorSDKChannels.send.tracingChannel();
+    const channel = cursorSDKChannels.send.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
@@ -16690,9 +16314,9 @@ var CursorSDKPlugin = class extends BasePlugin {
         states.delete(event);
       }
     };
-    channel2.subscribe(handlers);
+    channel.subscribe(handlers);
     this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
+      channel.unsubscribe(handlers);
     });
   }
 };
@@ -17376,88 +17000,513 @@ function cleanMetrics2(metrics) {
   return cleaned;
 }
 
-// src/instrumentation/plugins/google-genai-channels.ts
-var googleGenAIChannels = defineChannels("@google/genai", {
-  generateContent: channel({
-    channelName: "models.generateContent",
-    kind: "async"
-  }),
-  generateContentStream: channel({
-    channelName: "models.generateContentStream",
-    kind: "async"
-  }),
-  embedContent: channel({
-    channelName: "models.embedContent",
-    kind: "async"
-  })
-});
-
-// src/instrumentation/plugins/google-genai-plugin.ts
-var GOOGLE_GENAI_INTERNAL_CONTEXT = {
-  caller_filename: "<node-internal>",
-  caller_functionname: "<node-internal>",
-  caller_lineno: 0
-};
-function createWrapperParityEvent(args) {
-  return {
-    context: GOOGLE_GENAI_INTERNAL_CONTEXT,
-    input: args.input,
-    metadata: args.metadata
-  };
+// src/instrumentation/plugins/openai-agents-trace-processor.ts
+function isSpanData(spanData, type) {
+  return spanData.type === type;
+}
+function spanTypeFromAgents(span) {
+  const spanType = span.spanData.type;
+  if (spanType === "function" || spanType === "guardrail" || spanType === "mcp_tools") {
+    return "tool" /* TOOL */;
+  }
+  if (spanType === "generation" || spanType === "response" || spanType === "transcription" || spanType === "speech") {
+    return "llm" /* LLM */;
+  }
+  return "task" /* TASK */;
+}
+function spanNameFromAgents(span) {
+  const spanData = span.spanData;
+  if ("name" in spanData && spanData.name) {
+    return spanData.name;
+  }
+  switch (spanData.type) {
+    case "generation":
+      return "Generation";
+    case "response":
+      return "Response";
+    case "handoff":
+      return "Handoff";
+    case "mcp_tools":
+      return isSpanData(spanData, "mcp_tools") && spanData.server ? `List Tools (${spanData.server})` : "MCP List Tools";
+    case "transcription":
+      return "Transcription";
+    case "speech":
+      return "Speech";
+    case "speech_group":
+      return "Speech Group";
+    default:
+      return "Unknown";
+  }
 }
-var GoogleGenAIPlugin = class extends BasePlugin {
-  onEnable() {
-    this.subscribeToGoogleGenAIChannels();
+function getTimeElapsed(end, start) {
+  if (!start || !end) {
+    return void 0;
   }
-  onDisable() {
-    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  const startTime = new Date(start).getTime();
+  const endTime = new Date(end).getTime();
+  if (Number.isNaN(startTime) || Number.isNaN(endTime)) {
+    return void 0;
   }
-  subscribeToGoogleGenAIChannels() {
-    this.subscribeToGenerateContentChannel();
-    this.subscribeToGenerateContentStreamChannel();
-    this.subscribeToEmbedContentChannel();
+  return (endTime - startTime) / 1e3;
+}
+function getNumberProperty2(obj, key) {
+  if (!isObject(obj) || !(key in obj)) {
+    return void 0;
   }
-  subscribeToGenerateContentChannel() {
-    const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
-    const states = /* @__PURE__ */ new WeakMap();
-    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
-      tracingChannel2,
-      states,
-      (event) => {
-        const params = event.arguments[0];
-        const input = serializeGenerateContentInput(params);
-        const metadata = extractGenerateContentMetadata(params);
-        const span = startSpan({
-          name: "generate_content",
-          spanAttributes: {
-            type: "llm" /* LLM */
-          },
-          event: createWrapperParityEvent({ input, metadata })
-        });
-        return {
-          span,
-          startTime: getCurrentUnixTimestamp()
-        };
+  const value = obj[key];
+  return typeof value === "number" ? value : void 0;
+}
+function parseUsageMetrics(usage) {
+  const metrics = {};
+  if (!isObject(usage)) {
+    return metrics;
+  }
+  const promptTokens = getNumberProperty2(usage, "prompt_tokens") ?? getNumberProperty2(usage, "input_tokens") ?? getNumberProperty2(usage, "promptTokens") ?? getNumberProperty2(usage, "inputTokens");
+  const completionTokens = getNumberProperty2(usage, "completion_tokens") ?? getNumberProperty2(usage, "output_tokens") ?? getNumberProperty2(usage, "completionTokens") ?? getNumberProperty2(usage, "outputTokens");
+  const totalTokens = getNumberProperty2(usage, "total_tokens") ?? getNumberProperty2(usage, "totalTokens");
+  if (promptTokens !== void 0) {
+    metrics.prompt_tokens = promptTokens;
+  }
+  if (completionTokens !== void 0) {
+    metrics.completion_tokens = completionTokens;
+  }
+  if (totalTokens !== void 0) {
+    metrics.tokens = totalTokens;
+  } else if (promptTokens !== void 0 && completionTokens !== void 0) {
+    metrics.tokens = promptTokens + completionTokens;
+  }
+  const inputDetails = usage.input_tokens_details;
+  const cachedTokens = getNumberProperty2(inputDetails, "cached_tokens");
+  const cacheWriteTokens = getNumberProperty2(
+    inputDetails,
+    "cache_write_tokens"
+  );
+  if (cachedTokens !== void 0) {
+    metrics.prompt_cached_tokens = cachedTokens;
+  }
+  if (cacheWriteTokens !== void 0) {
+    metrics.prompt_cache_creation_tokens = cacheWriteTokens;
+  }
+  return metrics;
+}
+var OpenAIAgentsTraceProcessor = class _OpenAIAgentsTraceProcessor {
+  static DEFAULT_MAX_TRACES = 1e4;
+  logger;
+  maxTraces;
+  traceSpans = /* @__PURE__ */ new Map();
+  traceOrder = [];
+  _traceSpans = this.traceSpans;
+  constructor(options = {}) {
+    this.logger = options.logger;
+    this.maxTraces = options.maxTraces ?? _OpenAIAgentsTraceProcessor.DEFAULT_MAX_TRACES;
+  }
+  evictOldestTrace() {
+    const oldestTraceId = this.traceOrder.shift();
+    if (oldestTraceId) {
+      this.traceSpans.delete(oldestTraceId);
+    }
+  }
+  onTraceStart(trace) {
+    if (!trace?.traceId) {
+      return Promise.resolve();
+    }
+    if (this.traceOrder.length >= this.maxTraces) {
+      this.evictOldestTrace();
+    }
+    const current = currentSpan();
+    const span = current && current !== NOOP_SPAN ? current.startSpan({
+      name: trace.name,
+      type: "task" /* TASK */
+    }) : this.logger ? this.logger.startSpan({
+      name: trace.name,
+      type: "task" /* TASK */
+    }) : startSpan({
+      name: trace.name,
+      type: "task" /* TASK */
+    });
+    span.log({
+      input: "Agent workflow started",
+      metadata: {
+        group_id: trace.groupId,
+        ...trace.metadata || {}
       }
-    );
-    const handlers = {
-      start: (event) => {
-        ensureSpanState(states, event, () => {
-          const params = event.arguments[0];
-          const input = serializeGenerateContentInput(params);
-          const metadata = extractGenerateContentMetadata(params);
-          const span = startSpan({
-            name: "generate_content",
-            spanAttributes: {
-              type: "llm" /* LLM */
-            },
-            event: createWrapperParityEvent({ input, metadata })
-          });
-          return {
-            span,
-            startTime: getCurrentUnixTimestamp()
-          };
-        });
+    });
+    this.traceSpans.set(trace.traceId, {
+      rootSpan: span,
+      childSpans: /* @__PURE__ */ new Map(),
+      metadata: {
+        firstInput: null,
+        lastOutput: null
+      }
+    });
+    this.traceOrder.push(trace.traceId);
+    return Promise.resolve();
+  }
+  async onTraceEnd(trace) {
+    const traceData = this.traceSpans.get(trace?.traceId);
+    if (!traceData) {
+      return;
+    }
+    try {
+      traceData.rootSpan.log({
+        input: traceData.metadata.firstInput,
+        output: traceData.metadata.lastOutput
+      });
+      traceData.rootSpan.end();
+      await traceData.rootSpan.flush();
+    } finally {
+      this.traceSpans.delete(trace.traceId);
+      const orderIndex = this.traceOrder.indexOf(trace.traceId);
+      if (orderIndex > -1) {
+        this.traceOrder.splice(orderIndex, 1);
+      }
+    }
+  }
+  onSpanStart(span) {
+    if (!span?.spanId || !span.traceId) {
+      return Promise.resolve();
+    }
+    const traceData = this.traceSpans.get(span.traceId);
+    if (!traceData) {
+      return Promise.resolve();
+    }
+    const parentSpan = span.parentId ? traceData.childSpans.get(span.parentId) : traceData.rootSpan;
+    if (!parentSpan) {
+      return Promise.resolve();
+    }
+    const childSpan = parentSpan.startSpan({
+      name: spanNameFromAgents(span),
+      type: spanTypeFromAgents(span)
+    });
+    traceData.childSpans.set(span.spanId, childSpan);
+    return Promise.resolve();
+  }
+  onSpanEnd(span) {
+    if (!span?.spanId || !span.traceId) {
+      return Promise.resolve();
+    }
+    const traceData = this.traceSpans.get(span.traceId);
+    if (!traceData) {
+      return Promise.resolve();
+    }
+    const braintrustSpan = traceData.childSpans.get(span.spanId);
+    if (!braintrustSpan) {
+      return Promise.resolve();
+    }
+    const logData = this.extractLogData(span);
+    braintrustSpan.log({
+      error: span.error,
+      ...logData
+    });
+    braintrustSpan.end();
+    traceData.childSpans.delete(span.spanId);
+    const input = logData.input;
+    const output = logData.output;
+    if (traceData.metadata.firstInput === null && input != null) {
+      traceData.metadata.firstInput = input;
+    }
+    if (output != null) {
+      traceData.metadata.lastOutput = output;
+    }
+    return Promise.resolve();
+  }
+  async shutdown() {
+    if (this.logger && typeof this.logger.flush === "function") {
+      await this.logger.flush();
+    }
+  }
+  async forceFlush() {
+    if (this.logger && typeof this.logger.flush === "function") {
+      await this.logger.flush();
+    }
+  }
+  extractLogData(span) {
+    const spanData = span.spanData;
+    switch (spanData.type) {
+      case "agent":
+        return this.extractAgentLogData(spanData);
+      case "response":
+        return this.extractResponseLogData(spanData, span);
+      case "function":
+        return this.extractFunctionLogData(spanData);
+      case "handoff":
+        return this.extractHandoffLogData(spanData);
+      case "guardrail":
+        return this.extractGuardrailLogData(spanData);
+      case "generation":
+        return this.extractGenerationLogData(spanData, span);
+      case "custom":
+        return this.extractCustomLogData(spanData);
+      case "mcp_tools":
+        return this.extractMCPListToolsLogData(spanData);
+      case "transcription":
+        return this.extractTranscriptionLogData(spanData);
+      case "speech":
+        return this.extractSpeechLogData(spanData);
+      case "speech_group":
+        return this.extractSpeechGroupLogData(spanData);
+      default:
+        return {};
+    }
+  }
+  extractAgentLogData(spanData) {
+    return {
+      metadata: {
+        tools: spanData.tools,
+        handoffs: spanData.handoffs,
+        output_type: spanData.output_type
+      }
+    };
+  }
+  extractResponseLogData(spanData, span) {
+    const response = spanData._response;
+    const output = isObject(response) ? response.output : void 0;
+    const usage = isObject(response) ? response.usage : void 0;
+    const metrics = {
+      ...this.extractTimingMetrics(span),
+      ...parseUsageMetrics(usage)
+    };
+    return {
+      input: spanData._input,
+      output,
+      metadata: isObject(response) ? this.omitKeys(response, ["output", "usage"]) : {},
+      metrics
+    };
+  }
+  extractFunctionLogData(spanData) {
+    return {
+      input: spanData.input,
+      output: spanData.output
+    };
+  }
+  extractHandoffLogData(spanData) {
+    return {
+      metadata: {
+        from_agent: spanData.from_agent,
+        to_agent: spanData.to_agent
+      }
+    };
+  }
+  extractGuardrailLogData(spanData) {
+    return {
+      metadata: {
+        triggered: spanData.triggered
+      }
+    };
+  }
+  extractGenerationLogData(spanData, span) {
+    return {
+      input: spanData.input,
+      output: spanData.output,
+      metadata: {
+        model: spanData.model,
+        model_config: spanData.model_config
+      },
+      metrics: {
+        ...this.extractTimingMetrics(span),
+        ...parseUsageMetrics(spanData.usage)
+      }
+    };
+  }
+  extractCustomLogData(spanData) {
+    return spanData.data || {};
+  }
+  extractMCPListToolsLogData(spanData) {
+    return {
+      output: spanData.result,
+      metadata: {
+        server: spanData.server
+      }
+    };
+  }
+  extractTranscriptionLogData(spanData) {
+    return {
+      input: spanData.input,
+      output: spanData.output,
+      metadata: {
+        model: spanData.model,
+        model_config: spanData.model_config
+      }
+    };
+  }
+  extractSpeechLogData(spanData) {
+    return {
+      input: spanData.input,
+      output: spanData.output,
+      metadata: {
+        model: spanData.model,
+        model_config: spanData.model_config
+      }
+    };
+  }
+  extractSpeechGroupLogData(spanData) {
+    return {
+      input: spanData.input
+    };
+  }
+  extractTimingMetrics(span) {
+    const timeToFirstToken = getTimeElapsed(
+      span.endedAt ?? void 0,
+      span.startedAt ?? void 0
+    );
+    return timeToFirstToken === void 0 ? {} : { time_to_first_token: timeToFirstToken };
+  }
+  omitKeys(value, keys) {
+    const result = {};
+    for (const [key, fieldValue] of Object.entries(value)) {
+      if (!keys.includes(key)) {
+        result[key] = fieldValue;
+      }
+    }
+    return result;
+  }
+};
+
+// src/instrumentation/plugins/openai-agents-plugin.ts
+function firstArgument(args) {
+  if (Array.isArray(args)) {
+    return args[0];
+  }
+  if (isObject(args) && "length" in args && typeof args.length === "number" && Number.isInteger(args.length) && args.length >= 0) {
+    return Array.from(args)[0];
+  }
+  return void 0;
+}
+function isOpenAIAgentsTrace(value) {
+  return isObject(value) && value.type === "trace" && typeof value.traceId === "string";
+}
+function isOpenAIAgentsSpan(value) {
+  return isObject(value) && value.type === "trace.span" && typeof value.traceId === "string" && typeof value.spanId === "string";
+}
+var OpenAIAgentsPlugin = class extends BasePlugin {
+  processor = new OpenAIAgentsTraceProcessor();
+  onEnable() {
+    this.subscribeToTraceLifecycle();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+    void this.processor.shutdown();
+  }
+  subscribeToTraceLifecycle() {
+    const traceStartChannel = openAIAgentsCoreChannels.onTraceStart.tracingChannel();
+    const traceStartHandlers = {
+      start: (event) => {
+        const trace = firstArgument(event.arguments);
+        if (isOpenAIAgentsTrace(trace)) {
+          void this.processor.onTraceStart(trace);
+        }
+      }
+    };
+    traceStartChannel.subscribe(traceStartHandlers);
+    this.unsubscribers.push(
+      () => traceStartChannel.unsubscribe(traceStartHandlers)
+    );
+    const traceEndChannel = openAIAgentsCoreChannels.onTraceEnd.tracingChannel();
+    const traceEndHandlers = {
+      start: (event) => {
+        const trace = firstArgument(event.arguments);
+        if (isOpenAIAgentsTrace(trace)) {
+          void this.processor.onTraceEnd(trace);
+        }
+      }
+    };
+    traceEndChannel.subscribe(traceEndHandlers);
+    this.unsubscribers.push(
+      () => traceEndChannel.unsubscribe(traceEndHandlers)
+    );
+    const spanStartChannel = openAIAgentsCoreChannels.onSpanStart.tracingChannel();
+    const spanStartHandlers = {
+      start: (event) => {
+        const span = firstArgument(event.arguments);
+        if (isOpenAIAgentsSpan(span)) {
+          void this.processor.onSpanStart(span);
+        }
+      }
+    };
+    spanStartChannel.subscribe(spanStartHandlers);
+    this.unsubscribers.push(
+      () => spanStartChannel.unsubscribe(spanStartHandlers)
+    );
+    const spanEndChannel = openAIAgentsCoreChannels.onSpanEnd.tracingChannel();
+    const spanEndHandlers = {
+      start: (event) => {
+        const span = firstArgument(event.arguments);
+        if (isOpenAIAgentsSpan(span)) {
+          void this.processor.onSpanEnd(span);
+        }
+      }
+    };
+    spanEndChannel.subscribe(spanEndHandlers);
+    this.unsubscribers.push(() => spanEndChannel.unsubscribe(spanEndHandlers));
+  }
+};
+
+// src/instrumentation/plugins/google-genai-plugin.ts
+var GOOGLE_GENAI_INTERNAL_CONTEXT = {
+  caller_filename: "<node-internal>",
+  caller_functionname: "<node-internal>",
+  caller_lineno: 0
+};
+function createWrapperParityEvent(args) {
+  return {
+    context: GOOGLE_GENAI_INTERNAL_CONTEXT,
+    input: args.input,
+    metadata: args.metadata
+  };
+}
+var GoogleGenAIPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToGoogleGenAIChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToGoogleGenAIChannels() {
+    this.subscribeToGenerateContentChannel();
+    this.subscribeToGenerateContentStreamChannel();
+    this.subscribeToEmbedContentChannel();
+  }
+  subscribeToGenerateContentChannel() {
+    const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
+      tracingChannel2,
+      states,
+      (event) => {
+        const params = event.arguments[0];
+        const input = serializeGenerateContentInput(params);
+        const metadata = extractGenerateContentMetadata(params);
+        const span = startSpan({
+          name: "generate_content",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: createWrapperParityEvent({ input, metadata })
+        });
+        return {
+          span,
+          startTime: getCurrentUnixTimestamp()
+        };
+      }
+    );
+    const handlers = {
+      start: (event) => {
+        ensureSpanState(states, event, () => {
+          const params = event.arguments[0];
+          const input = serializeGenerateContentInput(params);
+          const metadata = extractGenerateContentMetadata(params);
+          const span = startSpan({
+            name: "generate_content",
+            spanAttributes: {
+              type: "llm" /* LLM */
+            },
+            event: createWrapperParityEvent({ input, metadata })
+          });
+          return {
+            span,
+            startTime: getCurrentUnixTimestamp()
+          };
+        });
       },
       asyncEnd: (event) => {
         const spanState = states.get(event);
@@ -18139,30 +18188,6 @@ function tryToDict(obj) {
   return null;
 }
 
-// src/instrumentation/plugins/huggingface-channels.ts
-var huggingFaceChannels = defineChannels("@huggingface/inference", {
-  chatCompletion: channel({
-    channelName: "chatCompletion",
-    kind: "async"
-  }),
-  chatCompletionStream: channel({
-    channelName: "chatCompletionStream",
-    kind: "sync-stream"
-  }),
-  textGeneration: channel({
-    channelName: "textGeneration",
-    kind: "async"
-  }),
-  textGenerationStream: channel({
-    channelName: "textGenerationStream",
-    kind: "sync-stream"
-  }),
-  featureExtraction: channel({
-    channelName: "featureExtraction",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/huggingface-plugin.ts
 var REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
   "dimensions",
@@ -18587,22 +18612,6 @@ function extractTextGenerationStreamMetadata(chunks) {
   return void 0;
 }
 
-// src/instrumentation/plugins/openrouter-agent-channels.ts
-var openRouterAgentChannels = defineChannels("@openrouter/agent", {
-  callModel: channel({
-    channelName: "callModel",
-    kind: "sync-stream"
-  }),
-  callModelTurn: channel({
-    channelName: "callModel.turn",
-    kind: "async"
-  }),
-  toolExecute: channel({
-    channelName: "tool.execute",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/openrouter-agent-plugin.ts
 var OpenRouterAgentPlugin = class extends BasePlugin {
   onEnable() {
@@ -19372,40 +19381,6 @@ function normalizeError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
 
-// src/instrumentation/plugins/openrouter-channels.ts
-var openRouterChannels = defineChannels("@openrouter/sdk", {
-  chatSend: channel({
-    channelName: "chat.send",
-    kind: "async"
-  }),
-  embeddingsGenerate: channel({
-    channelName: "embeddings.generate",
-    kind: "async"
-  }),
-  rerankRerank: channel(
-    {
-      channelName: "rerank.rerank",
-      kind: "async"
-    }
-  ),
-  betaResponsesSend: channel({
-    channelName: "beta.responses.send",
-    kind: "async"
-  }),
-  callModel: channel({
-    channelName: "callModel",
-    kind: "sync-stream"
-  }),
-  callModelTurn: channel({
-    channelName: "callModel.turn",
-    kind: "async"
-  }),
-  toolExecute: channel({
-    channelName: "tool.execute",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/openrouter-plugin.ts
 var OpenRouterPlugin = class extends BasePlugin {
   onEnable() {
@@ -20445,54 +20420,6 @@ function normalizeError2(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
 
-// src/instrumentation/plugins/mistral-channels.ts
-var mistralChannels = defineChannels("@mistralai/mistralai", {
-  chatComplete: channel({
-    channelName: "chat.complete",
-    kind: "async"
-  }),
-  chatStream: channel({
-    channelName: "chat.stream",
-    kind: "async"
-  }),
-  embeddingsCreate: channel({
-    channelName: "embeddings.create",
-    kind: "async"
-  }),
-  classifiersModerate: channel({
-    channelName: "classifiers.moderate",
-    kind: "async"
-  }),
-  classifiersModerateChat: channel({
-    channelName: "classifiers.moderateChat",
-    kind: "async"
-  }),
-  classifiersClassify: channel({
-    channelName: "classifiers.classify",
-    kind: "async"
-  }),
-  classifiersClassifyChat: channel({
-    channelName: "classifiers.classifyChat",
-    kind: "async"
-  }),
-  fimComplete: channel({
-    channelName: "fim.complete",
-    kind: "async"
-  }),
-  fimStream: channel({
-    channelName: "fim.stream",
-    kind: "async"
-  }),
-  agentsComplete: channel({
-    channelName: "agents.complete",
-    kind: "async"
-  }),
-  agentsStream: channel({
-    channelName: "agents.stream",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/mistral-plugin.ts
 var MistralPlugin = class extends BasePlugin {
   onEnable() {
@@ -21110,22 +21037,6 @@ function aggregateMistralStreamChunks(chunks) {
   };
 }
 
-// src/instrumentation/plugins/google-adk-channels.ts
-var googleADKChannels = defineChannels("@google/adk", {
-  runnerRunAsync: channel({
-    channelName: "runner.runAsync",
-    kind: "sync-stream"
-  }),
-  agentRunAsync: channel({
-    channelName: "agent.runAsync",
-    kind: "sync-stream"
-  }),
-  toolRunAsync: channel({
-    channelName: "tool.runAsync",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/google-adk-plugin.ts
 var GoogleADKPlugin = class extends BasePlugin {
   activeRunnerSpans = /* @__PURE__ */ new Map();
@@ -21757,26 +21668,6 @@ function cleanMetrics4(metrics) {
   return cleaned;
 }
 
-// src/instrumentation/plugins/cohere-channels.ts
-var cohereChannels = defineChannels("cohere-ai", {
-  chat: channel({
-    channelName: "chat",
-    kind: "async"
-  }),
-  chatStream: channel({
-    channelName: "chatStream",
-    kind: "async"
-  }),
-  embed: channel({
-    channelName: "embed",
-    kind: "async"
-  }),
-  rerank: channel({
-    channelName: "rerank",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/cohere-plugin.ts
 var CoherePlugin = class extends BasePlugin {
   onEnable() {
@@ -22443,20 +22334,6 @@ function aggregateCohereChatStreamChunks(chunks) {
   };
 }
 
-// src/instrumentation/plugins/groq-channels.ts
-var groqChannels = defineChannels("groq-sdk", {
-  chatCompletionsCreate: channel({
-    channelName: "chat.completions.create",
-    kind: "async"
-  }),
-  embeddingsCreate: channel(
-    {
-      channelName: "embeddings.create",
-      kind: "async"
-    }
-  )
-});
-
 // src/instrumentation/plugins/groq-plugin.ts
 var GroqPlugin = class extends BasePlugin {
   onEnable() {
@@ -22553,40 +22430,6 @@ function aggregateGroqReasoning(chunks) {
   return reasoning.length > 0 ? reasoning : void 0;
 }
 
-// src/instrumentation/plugins/genkit-channels.ts
-var genkitChannels = defineChannels("@genkit-ai/ai", {
-  generate: channel({
-    channelName: "generate",
-    kind: "async"
-  }),
-  generateStream: channel({
-    channelName: "generateStream",
-    kind: "sync-stream"
-  }),
-  embed: channel({
-    channelName: "embed",
-    kind: "async"
-  }),
-  embedMany: channel({
-    channelName: "embedMany",
-    kind: "async"
-  }),
-  actionRun: channel({
-    channelName: "action.run",
-    kind: "async"
-  }),
-  actionStream: channel({
-    channelName: "action.stream",
-    kind: "sync-stream"
-  })
-});
-var genkitCoreChannels = defineChannels("@genkit-ai/core", {
-  actionSpan: channel({
-    channelName: "action.span",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/genkit-plugin.ts
 var GenkitPlugin = class extends BasePlugin {
   onEnable() {
@@ -23138,22 +22981,6 @@ function stringValue(value) {
   return typeof value === "string" ? value : void 0;
 }
 
-// src/instrumentation/plugins/github-copilot-channels.ts
-var gitHubCopilotChannels = defineChannels("@github/copilot-sdk", {
-  createSession: channel({
-    channelName: "client.createSession",
-    kind: "async"
-  }),
-  resumeSession: channel({
-    channelName: "client.resumeSession",
-    kind: "async"
-  }),
-  sendAndWait: channel({
-    channelName: "session.sendAndWait",
-    kind: "async"
-  })
-});
-
 // src/instrumentation/plugins/github-copilot-plugin.ts
 var ROOT_AGENT_KEY = "__root__";
 function agentKey(agentId) {
@@ -23498,175 +23325,1860 @@ async function dispatchEvent(state, event) {
           d.agentDescription ?? ""
         );
       }
-      break;
-    }
-    case "subagent.completed": {
-      const d = event.data;
-      if (d && typeof d.toolCallId === "string") {
-        handleSubagentCompleted(
-          state,
-          d.toolCallId,
-          d.model,
-          d.totalTokens,
-          d.totalToolCalls,
-          d.durationMs
-        );
+      break;
+    }
+    case "subagent.completed": {
+      const d = event.data;
+      if (d && typeof d.toolCallId === "string") {
+        handleSubagentCompleted(
+          state,
+          d.toolCallId,
+          d.model,
+          d.totalTokens,
+          d.totalToolCalls,
+          d.durationMs
+        );
+      }
+      break;
+    }
+    case "subagent.failed": {
+      const d = event.data;
+      if (d && typeof d.toolCallId === "string") {
+        handleSubagentFailed(
+          state,
+          d.toolCallId,
+          d.error ?? "sub-agent failed"
+        );
+      }
+      break;
+    }
+    case "session.usage_info": {
+      const d = event.data;
+      if (d && typeof d.currentTokens === "number") {
+        state.session.span.log({
+          metadata: {
+            "github_copilot.context_window.limit": d.tokenLimit,
+            "github_copilot.context_window.current": d.currentTokens,
+            "github_copilot.context_window.messages": d.messagesLength
+          }
+        });
+      }
+      break;
+    }
+  }
+}
+function injectTracingHooks2(config, state) {
+  const existingHooks = config.hooks ?? {};
+  const onSessionEnd = async (input, invocation) => {
+    try {
+      await existingHooks.onSessionEnd?.(input, invocation);
+    } finally {
+      handleSessionEnd(state, input.reason, input.error);
+      state.unsubscribeEvents?.();
+    }
+  };
+  config.hooks = {
+    ...existingHooks,
+    onSessionEnd
+  };
+}
+function attachSessionEventListener(session, state) {
+  const handler = (event) => {
+    state.processing = state.processing.then(() => dispatchEvent(state, event)).catch((err) => {
+      console.error(
+        "[Braintrust] Error processing GitHub Copilot SDK event:",
+        err
+      );
+    });
+  };
+  state.unsubscribeEvents = session.on(
+    handler
+  );
+}
+function isGitHubCopilotSession(value) {
+  return value !== null && typeof value === "object" && typeof value.on === "function";
+}
+function makeSessionHandlers(sessionStates, configArgIndex, includeProviderMetadata) {
+  return {
+    start: (event) => {
+      const config = event.arguments[configArgIndex];
+      if (!config || typeof config !== "object") {
+        return;
+      }
+      const sessionSpan = startSpan({
+        name: "Copilot Session",
+        spanAttributes: { type: "task" /* TASK */ }
+      });
+      const metadata = {};
+      if (config.model) {
+        metadata["github_copilot.model"] = config.model;
+      }
+      if (includeProviderMetadata && config.provider?.type) {
+        metadata["github_copilot.provider_type"] = config.provider.type;
+      }
+      if (Object.keys(metadata).length > 0) {
+        sessionSpan.log({ metadata });
+      }
+      const state = {
+        session: makeSpanWithId(sessionSpan),
+        activeTurns: /* @__PURE__ */ new Map(),
+        pendingUserMessages: /* @__PURE__ */ new Map(),
+        currentMessageContent: /* @__PURE__ */ new Map(),
+        activeTools: /* @__PURE__ */ new Map(),
+        subAgents: /* @__PURE__ */ new Map(),
+        agentIdToToolCallId: /* @__PURE__ */ new Map(),
+        processing: Promise.resolve(),
+        totalInputTokens: 0,
+        totalOutputTokens: 0
+      };
+      injectTracingHooks2(config, state);
+      sessionStates.set(event, state);
+    },
+    asyncEnd: (event) => {
+      const state = sessionStates.get(event);
+      if (!state) {
+        return;
+      }
+      const session = event.result;
+      if (isGitHubCopilotSession(session)) {
+        attachSessionEventListener(session, state);
+      } else {
+        state.session.span.end();
+      }
+      sessionStates.delete(event);
+    },
+    error: (event) => {
+      const state = sessionStates.get(event);
+      if (!state || !event.error) {
+        return;
+      }
+      state.session.span.log({ error: event.error.message });
+      state.session.span.end();
+      sessionStates.delete(event);
+    }
+  };
+}
+var GitHubCopilotPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToSessionChannels();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+  subscribeToSessionChannels() {
+    const createChannel = gitHubCopilotChannels.createSession.tracingChannel();
+    const resumeChannel = gitHubCopilotChannels.resumeSession.tracingChannel();
+    const sessionStates = /* @__PURE__ */ new WeakMap();
+    const createHandlers = makeSessionHandlers(
+      sessionStates,
+      0,
+      // config is arg 0 of createSession(config)
+      true
+      // include provider metadata
+    );
+    const resumeHandlers = makeSessionHandlers(
+      sessionStates,
+      1,
+      // config is arg 1 of resumeSession(sessionId, config)
+      false
+      // resumeSession config has no provider field
+    );
+    createChannel.subscribe(createHandlers);
+    resumeChannel.subscribe(resumeHandlers);
+    this.unsubscribers.push(
+      () => createChannel.unsubscribe(createHandlers),
+      () => resumeChannel.unsubscribe(resumeHandlers)
+    );
+  }
+};
+
+// src/wrappers/flue.ts
+var WRAPPED_FLUE_CONTEXT = /* @__PURE__ */ Symbol.for("braintrust.flue.wrapped-context");
+var WRAPPED_FLUE_HARNESS = /* @__PURE__ */ Symbol.for("braintrust.flue.wrapped-harness");
+var WRAPPED_FLUE_SESSION = /* @__PURE__ */ Symbol.for("braintrust.flue.wrapped-session");
+var SUBSCRIBED_FLUE_CONTEXT_EVENTS = /* @__PURE__ */ Symbol.for(
+  "braintrust.flue.subscribed-context-events"
+);
+function wrapFlueContext(ctx) {
+  if (!isPlausibleFlueContext(ctx)) {
+    console.warn("Unsupported Flue context. Not wrapping.");
+    return ctx;
+  }
+  const context = ctx;
+  subscribeFlueContextEvents(context, { captureTurnSpans: true });
+  return patchFlueContextInPlace(context);
+}
+function patchFlueContextInPlace(ctx) {
+  const context = ctx;
+  if (context[WRAPPED_FLUE_CONTEXT]) {
+    return ctx;
+  }
+  const originalInit = context.init.bind(context);
+  try {
+    Object.defineProperty(context, WRAPPED_FLUE_CONTEXT, {
+      configurable: false,
+      enumerable: false,
+      value: true
+    });
+    Object.defineProperty(context, "init", {
+      configurable: true,
+      value: async function wrappedFlueInit(options) {
+        const harness = await originalInit(options);
+        return wrapFlueHarness(harness);
+      },
+      writable: true
+    });
+  } catch {
+  }
+  return ctx;
+}
+function wrapFlueSession(session) {
+  if (!isPlausibleFlueSession(session)) {
+    console.warn("Unsupported Flue session. Not wrapping.");
+    return session;
+  }
+  return patchFlueSessionInPlace(session);
+}
+function subscribeFlueContextEvents(ctx, options = {}) {
+  if (!ctx || typeof ctx !== "object" || typeof ctx.subscribeEvent !== "function") {
+    return void 0;
+  }
+  const context = ctx;
+  const captureTurnSpans = options.captureTurnSpans ?? true;
+  const existingSubscription = context[SUBSCRIBED_FLUE_CONTEXT_EVENTS];
+  if (existingSubscription) {
+    if (existingSubscription.captureTurnSpans || !captureTurnSpans) {
+      return void 0;
+    }
+    try {
+      existingSubscription.unsubscribe();
+    } catch {
+    }
+  }
+  try {
+    const unsubscribe = ctx.subscribeEvent((event) => {
+      flueChannels.contextEvent.traceSync(() => void 0, {
+        arguments: [event],
+        captureTurnSpans,
+        context: ctx
+      });
+    });
+    if (existingSubscription) {
+      existingSubscription.captureTurnSpans = captureTurnSpans;
+      existingSubscription.unsubscribe = unsubscribe;
+    } else {
+      Object.defineProperty(context, SUBSCRIBED_FLUE_CONTEXT_EVENTS, {
+        configurable: false,
+        enumerable: false,
+        value: {
+          captureTurnSpans,
+          unsubscribe
+        }
+      });
+    }
+    return unsubscribe;
+  } catch {
+    return void 0;
+  }
+}
+function wrapFlueHarness(harness) {
+  if (!isPlausibleFlueHarness(harness)) {
+    return harness;
+  }
+  const target = harness;
+  if (target[WRAPPED_FLUE_HARNESS]) {
+    return harness;
+  }
+  const originalSession = target.session.bind(target);
+  try {
+    Object.defineProperty(target, WRAPPED_FLUE_HARNESS, {
+      configurable: false,
+      enumerable: false,
+      value: true
+    });
+    Object.defineProperty(target, "session", {
+      configurable: true,
+      value: async function wrappedFlueHarnessSession(name, options) {
+        const session = await originalSession(name, options);
+        return patchFlueSessionInPlace(session);
+      },
+      writable: true
+    });
+    const sessions = target.sessions;
+    if (sessions && typeof sessions === "object") {
+      patchFlueSessionFactory(sessions, "get");
+      patchFlueSessionFactory(sessions, "create");
+    }
+  } catch {
+  }
+  return harness;
+}
+function patchFlueSessionInPlace(session) {
+  if (session[WRAPPED_FLUE_SESSION]) {
+    return session;
+  }
+  try {
+    Object.defineProperty(session, WRAPPED_FLUE_SESSION, {
+      configurable: false,
+      enumerable: false,
+      value: true
+    });
+    patchCallHandleMethod(session, "prompt", flueChannels.prompt);
+    patchCallHandleMethod(session, "skill", flueChannels.skill);
+    patchCallHandleMethod(session, "task", flueChannels.task);
+    patchCompact(session);
+  } catch {
+  }
+  return session;
+}
+function patchFlueSessionFactory(sessions, method) {
+  const original = sessions[method];
+  if (typeof original !== "function") {
+    return;
+  }
+  const bound = original.bind(sessions);
+  Object.defineProperty(sessions, method, {
+    configurable: true,
+    value: async function wrappedFlueSessionFactory(name, options) {
+      const session = await bound(name, options);
+      return patchFlueSessionInPlace(session);
+    },
+    writable: true
+  });
+}
+function patchCallHandleMethod(session, method, channel) {
+  const original = session[method];
+  if (typeof original !== "function") {
+    return;
+  }
+  const bound = original.bind(session);
+  Object.defineProperty(session, method, {
+    configurable: true,
+    value(input, options) {
+      const args = [input, options];
+      const { originalResult, traced: traced2 } = traceFlueOperation(channel, {
+        context: {
+          arguments: args,
+          operation: method,
+          session
+        },
+        run: () => bound(input, options)
+      });
+      return preserveCallHandle(originalResult, traced2);
+    },
+    writable: true
+  });
+}
+function patchCompact(session) {
+  const original = session.compact;
+  if (typeof original !== "function") {
+    return;
+  }
+  const bound = original.bind(session);
+  Object.defineProperty(session, "compact", {
+    configurable: true,
+    value() {
+      const context = {
+        arguments: [],
+        operation: "compact",
+        session
+      };
+      return flueChannels.compact.tracePromise(() => bound(), context);
+    },
+    writable: true
+  });
+}
+function traceFlueOperation(channel, args) {
+  const tracingChannel2 = channel.tracingChannel();
+  const context = args.context;
+  let originalResult;
+  let traced2;
+  const run = () => {
+    try {
+      originalResult = args.run();
+      tracingChannel2.end?.publish(context);
+    } catch (error) {
+      context.error = normalizeError3(error);
+      tracingChannel2.error?.publish(context);
+      tracingChannel2.end?.publish(context);
+      throw error;
+    }
+    traced2 = Promise.resolve(originalResult).then(
+      (result) => {
+        context.result = result;
+        tracingChannel2.asyncStart?.publish(context);
+        tracingChannel2.asyncEnd?.publish(context);
+        return result;
+      },
+      (error) => {
+        context.error = normalizeError3(error);
+        tracingChannel2.error?.publish(context);
+        tracingChannel2.asyncStart?.publish(context);
+        tracingChannel2.asyncEnd?.publish(context);
+        throw error;
+      }
+    );
+  };
+  if (tracingChannel2.start?.runStores) {
+    tracingChannel2.start.runStores(context, run);
+  } else {
+    tracingChannel2.start?.publish(context);
+    run();
+  }
+  return { originalResult, traced: traced2 };
+}
+function normalizeError3(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function preserveCallHandle(originalHandle, traced2) {
+  if (!isFlueCallHandle(originalHandle)) {
+    return traced2;
+  }
+  const handle = originalHandle;
+  const wrapped = {
+    get signal() {
+      return handle.signal;
+    },
+    abort(reason) {
+      return handle.abort(reason);
+    },
+    then(onfulfilled, onrejected) {
+      return traced2.then(onfulfilled, onrejected);
+    }
+  };
+  return wrapped;
+}
+function isPlausibleFlueContext(value) {
+  return !!value && typeof value === "object" && typeof value.init === "function";
+}
+function isPlausibleFlueHarness(value) {
+  return !!value && typeof value === "object" && typeof value.session === "function";
+}
+function isPlausibleFlueSession(value) {
+  return !!value && typeof value === "object" && typeof value.prompt === "function" && typeof value.skill === "function" && typeof value.task === "function" && typeof value.compact === "function";
+}
+function isFlueCallHandle(value) {
+  return !!value && typeof value === "object" && typeof value.then === "function" && typeof value.abort === "function" && "signal" in value;
+}
+
+// src/instrumentation/plugins/flue-plugin.ts
+var FluePlugin = class extends BasePlugin {
+  activeOperationsById = /* @__PURE__ */ new Map();
+  activeOperationsByScope = /* @__PURE__ */ new Map();
+  compactionsByScope = /* @__PURE__ */ new Map();
+  pendingOperationsByKey = /* @__PURE__ */ new Map();
+  tasksById = /* @__PURE__ */ new Map();
+  toolsById = /* @__PURE__ */ new Map();
+  turnsByScope = /* @__PURE__ */ new Map();
+  onEnable() {
+    this.subscribeToContextCreation();
+    this.subscribeToSessionCreation();
+    this.subscribeToContextEvents();
+    this.subscribeToSessionOperations();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    this.activeOperationsById.clear();
+    this.activeOperationsByScope.clear();
+    this.compactionsByScope.clear();
+    this.pendingOperationsByKey.clear();
+    this.tasksById.clear();
+    this.toolsById.clear();
+    this.turnsByScope.clear();
+  }
+  subscribeToContextCreation() {
+    const channel = flueChannels.createContext.tracingChannel();
+    const handlers = {
+      end: (event) => {
+        const ctx = event.result;
+        if (!ctx) {
+          return;
+        }
+        subscribeFlueContextEvents(ctx, { captureTurnSpans: false });
+        patchFlueContextInPlace(ctx);
+      },
+      error: () => {
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+  subscribeToSessionCreation() {
+    const channel = flueChannels.openSession.tracingChannel();
+    const handlers = {
+      asyncEnd: (event) => {
+        if (event.result) {
+          patchFlueSessionInPlace(
+            event.result
+          );
+        }
+        if (event.harness) {
+          wrapFlueHarness(event.harness);
+        }
+      },
+      error: () => {
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+  subscribeToSessionOperations() {
+    this.subscribeToSessionOperation(flueChannels.prompt);
+    this.subscribeToSessionOperation(flueChannels.skill);
+    this.subscribeToSessionOperation(flueChannels.task);
+    this.subscribeToCompact();
+  }
+  subscribeToSessionOperation(channel) {
+    const tracingChannel2 = channel.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const ensureState2 = (event) => {
+      const existing = states.get(event);
+      if (existing) {
+        return existing;
+      }
+      const state = this.startOperationState({
+        args: event.arguments,
+        moduleVersion: typeof event.moduleVersion === "string" ? event.moduleVersion : void 0,
+        operation: event.operation,
+        session: event.session
+      });
+      states.set(event, state);
+      return state;
+    };
+    const unbindCurrentSpanStore = this.bindCurrentSpanStoreToOperationStart(
+      tracingChannel2,
+      ensureState2
+    );
+    const handlers = {
+      start: (event) => {
+        ensureState2(event);
+      },
+      asyncEnd: (event) => {
+        this.endOperationState(states.get(event), event.result);
+        states.delete(event);
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (state && event.error) {
+          safeLog3(state.span, { error: errorToString(event.error) });
+          this.finishOperationState(state);
+        }
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToCompact() {
+    const tracingChannel2 = flueChannels.compact.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const ensureState2 = (event) => {
+      const existing = states.get(event);
+      if (existing) {
+        return existing;
+      }
+      const state = this.startOperationState({
+        args: [],
+        moduleVersion: typeof event.moduleVersion === "string" ? event.moduleVersion : void 0,
+        operation: event.operation,
+        session: event.session
+      });
+      states.set(event, state);
+      return state;
+    };
+    const unbindCurrentSpanStore = this.bindCurrentSpanStoreToOperationStart(
+      tracingChannel2,
+      ensureState2
+    );
+    const handlers = {
+      start: (event) => {
+        ensureState2(event);
+      },
+      asyncEnd: (event) => {
+        this.endOperationState(states.get(event), void 0);
+        states.delete(event);
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (state && event.error) {
+          safeLog3(state.span, { error: errorToString(event.error) });
+          this.finishOperationState(state);
+        }
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToContextEvents() {
+    const channel = flueChannels.contextEvent.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        const flueEvent = event.arguments[0];
+        if (!flueEvent) {
+          return;
+        }
+        try {
+          this.handleFlueEvent(flueEvent, {
+            captureTurnSpans: event.captureTurnSpans !== false
+          });
+        } catch (error) {
+          logInstrumentationError3("Flue event", error);
+        }
+      },
+      error: () => {
+      }
+    };
+    channel.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel.unsubscribe(handlers);
+    });
+  }
+  bindCurrentSpanStoreToOperationStart(tracingChannel2, ensureState2) {
+    const state = _internalGetGlobalState();
+    const startChannel = tracingChannel2.start;
+    const contextManager = state?.contextManager;
+    const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+    if (!currentSpanStore || !startChannel) {
+      return void 0;
+    }
+    startChannel.bindStore(currentSpanStore, (event) => {
+      const operationState = ensureState2(event);
+      return contextManager.wrapSpanForStore(operationState.span);
+    });
+    return () => {
+      startChannel.unbindStore(currentSpanStore);
+    };
+  }
+  startOperationState(args) {
+    const sessionName = getSessionName(args.session);
+    const metadata = {
+      ...extractOperationInputMetadata(args.operation, args.args),
+      ...extractSessionMetadata(args.session),
+      "flue.operation": args.operation,
+      provider: "flue",
+      ...args.moduleVersion ? { "flue.version": args.moduleVersion } : {}
+    };
+    const span = startSpan({
+      name: `flue.session.${args.operation}`,
+      spanAttributes: { type: "task" /* TASK */ }
+    });
+    const state = {
+      metadata,
+      operation: args.operation,
+      sessionName,
+      span,
+      startTime: getCurrentUnixTimestamp()
+    };
+    safeLog3(span, {
+      input: extractOperationInput(args.operation, args.args),
+      metadata
+    });
+    this.pendingOperationQueue(operationKey(sessionName, args.operation)).push(
+      state
+    );
+    addOperationToScope(
+      this.activeOperationsByScope,
+      sessionName ?? "unknown",
+      state
+    );
+    return state;
+  }
+  endOperationState(state, result) {
+    if (!state) {
+      return;
+    }
+    const metadata = {
+      ...state.metadata,
+      ...extractPromptResponseMetadata(result)
+    };
+    const metrics = {
+      ...buildDurationMetrics3(state.startTime),
+      ...metricsFromUsage(result?.usage)
+    };
+    safeLog3(state.span, {
+      metadata,
+      metrics,
+      output: extractOperationOutput(result)
+    });
+    this.finishCompactionsForOperation(state);
+    this.finishOperationState(state);
+  }
+  finishOperationState(state) {
+    removePendingOperation(this.pendingOperationsByKey, state);
+    if (state.operationId) {
+      this.activeOperationsById.delete(state.operationId);
+    }
+    removeScopedOperation(this.activeOperationsByScope, state);
+    state.span.end();
+  }
+  handleFlueEvent(event, options) {
+    switch (event.type) {
+      case "operation_start":
+        this.handleOperationStart(event);
+        return;
+      case "operation":
+        this.handleOperation(event);
+        return;
+      case "text_delta":
+        if (!options.captureTurnSpans) {
+          return;
+        }
+        this.ensureTurnState(event).text.push(
+          typeof event.text === "string" ? event.text : ""
+        );
+        return;
+      case "thinking_start":
+        if (!options.captureTurnSpans) {
+          return;
+        }
+        this.handleThinkingStart(event);
+        return;
+      case "thinking_delta":
+        if (!options.captureTurnSpans) {
+          return;
+        }
+        this.handleThinkingDelta(event);
+        return;
+      case "thinking_end":
+        if (!options.captureTurnSpans) {
+          return;
+        }
+        this.handleThinkingEnd(event);
+        return;
+      case "turn":
+        if (!options.captureTurnSpans) {
+          return;
+        }
+        this.handleTurn(event);
+        return;
+      case "tool_start":
+        this.handleToolStart(event, options);
+        return;
+      case "tool_call":
+        this.handleToolCall(event);
+        return;
+      case "task_start":
+        this.handleTaskStart(event);
+        return;
+      case "task":
+        this.handleTask(event);
+        return;
+      case "compaction_start":
+        this.handleCompactionStart(event);
+        return;
+      case "compaction":
+        this.handleCompaction(event);
+        return;
+      default:
+        return;
+    }
+  }
+  handleOperationStart(event) {
+    if (!isInstrumentedOperation(event.operationKind)) {
+      return;
+    }
+    const state = this.takePendingOperationForEvent(event);
+    if (!state) {
+      return;
+    }
+    state.operationId = event.operationId;
+    this.activeOperationsById.set(event.operationId, state);
+    addScopedOperation(this.activeOperationsByScope, event, state);
+    state.metadata = {
+      ...state.metadata,
+      ...extractEventMetadata(event),
+      "flue.operation_id": event.operationId
+    };
+    safeLog3(state.span, { metadata: state.metadata });
+  }
+  handleOperation(event) {
+    const state = event.operationId ? this.activeOperationsById.get(event.operationId) : void 0;
+    if (!state) {
+      return;
+    }
+    const metadata = {
+      ...state.metadata,
+      ...extractEventMetadata(event),
+      ...typeof event.durationMs === "number" ? { "flue.duration_ms": event.durationMs } : {},
+      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
+    };
+    const metrics = metricsFromUsage(event.usage);
+    safeLog3(state.span, {
+      ...event.error ? { error: errorToString(event.error) } : {},
+      metadata,
+      ...Object.keys(metrics).length ? { metrics } : {}
+    });
+  }
+  ensureTurnState(event) {
+    const scope = scopeKey(event);
+    const existing = this.turnsByScope.get(scope);
+    if (existing) {
+      return existing;
+    }
+    const parent = this.parentSpanForEvent(event);
+    const metadata = {
+      ...extractEventMetadata(event),
+      provider: "flue"
+    };
+    const span = startFlueSpan(parent, {
+      name: "flue.turn",
+      spanAttributes: { type: "llm" /* LLM */ }
+    });
+    const state = {
+      metadata,
+      span,
+      hasThinking: false,
+      startTime: getCurrentUnixTimestamp(),
+      text: [],
+      thinking: [],
+      toolCalls: []
+    };
+    safeLog3(span, { metadata });
+    this.turnsByScope.set(scope, state);
+    return state;
+  }
+  handleTurn(event) {
+    const scope = scopeKey(event);
+    const state = this.ensureTurnState(event);
+    const text = state.text.join("");
+    const reasoning = state.finalThinking ?? state.thinking.join("");
+    const outputReasoning = reasoning || (state.hasThinking ? "[reasoning stream present; content unavailable]" : void 0);
+    const metadata = {
+      ...state.metadata,
+      ...extractEventMetadata(event),
+      ...event.model ? { model: event.model, "flue.model": event.model } : {},
+      ...event.stopReason ? { "flue.stop_reason": event.stopReason } : {},
+      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {},
+      provider: "flue"
+    };
+    safeLog3(state.span, {
+      ...event.error ? { error: errorToString(event.error) } : {},
+      metadata,
+      metrics: {
+        ...durationMsMetrics(event.durationMs),
+        ...metricsFromUsage(event.usage)
+      },
+      output: toAssistantOutput(
+        text,
+        event.stopReason,
+        outputReasoning,
+        state.toolCalls
+      )
+    });
+    state.span.end();
+    this.turnsByScope.delete(scope);
+  }
+  handleThinkingDelta(event) {
+    const delta = event.delta;
+    if (typeof delta !== "string" || !delta) {
+      return;
+    }
+    const state = this.ensureTurnState(event);
+    state.hasThinking = true;
+    state.metadata["flue.thinking"] = true;
+    state.thinking.push(delta);
+  }
+  handleThinkingStart(event) {
+    const state = this.ensureTurnState(event);
+    state.hasThinking = true;
+    state.metadata["flue.thinking"] = true;
+  }
+  handleThinkingEnd(event) {
+    const state = this.ensureTurnState(event);
+    state.hasThinking = true;
+    state.metadata["flue.thinking"] = true;
+    if (typeof event.content === "string" && event.content) {
+      state.finalThinking = event.content;
+    }
+  }
+  handleToolStart(event, options) {
+    const toolCallId = event.toolCallId;
+    if (!toolCallId) {
+      return;
+    }
+    const parent = this.parentSpanForEvent(event);
+    const scope = scopeKey(event);
+    let turnState = this.turnsByScope.get(scope);
+    if (!turnState && parent && options.captureTurnSpans) {
+      turnState = this.ensureTurnState(event);
+    }
+    const metadata = {
+      ...extractEventMetadata(event),
+      ...event.toolName ? { "flue.tool_name": event.toolName } : {},
+      "flue.tool_call_id": toolCallId,
+      provider: "flue"
+    };
+    const span = startFlueSpan(parent, {
+      name: `tool: ${event.toolName ?? "unknown"}`,
+      spanAttributes: { type: "tool" /* TOOL */ }
+    });
+    if (turnState) {
+      turnState.toolCalls.push({
+        args: event.args,
+        toolCallId,
+        toolName: event.toolName
+      });
+    }
+    safeLog3(span, {
+      input: event.args,
+      metadata
+    });
+    this.toolsById.set(toolKey(event), {
+      metadata,
+      span,
+      startTime: getCurrentUnixTimestamp()
+    });
+  }
+  handleToolCall(event) {
+    const key = toolKey(event);
+    const state = this.toolsById.get(key) ?? this.startSyntheticToolState(event, event.toolName ?? "unknown");
+    const metadata = {
+      ...state.metadata,
+      ...extractEventMetadata(event),
+      ...event.toolName ? { "flue.tool_name": event.toolName } : {},
+      ...event.toolCallId ? { "flue.tool_call_id": event.toolCallId } : {},
+      ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
+    };
+    safeLog3(state.span, {
+      ...event.isError ? { error: errorToString(event.result) } : {},
+      metadata,
+      metrics: durationMsMetrics(event.durationMs),
+      output: event.result
+    });
+    state.span.end();
+    this.toolsById.delete(key);
+  }
+  handleTaskStart(event) {
+    const parent = this.parentSpanForEvent(event);
+    const metadata = {
+      ...extractEventMetadata(event),
+      ...event.role ? { "flue.role": event.role } : {},
+      ...event.cwd ? { "flue.cwd": event.cwd } : {},
+      "flue.task_id": event.taskId,
+      provider: "flue"
+    };
+    const span = startFlueSpan(parent, {
+      name: "flue.task",
+      spanAttributes: { type: "task" /* TASK */ }
+    });
+    safeLog3(span, {
+      input: event.prompt,
+      metadata
+    });
+    this.tasksById.set(event.taskId, {
+      metadata,
+      span,
+      startTime: getCurrentUnixTimestamp()
+    });
+  }
+  handleTask(event) {
+    const state = this.tasksById.get(event.taskId);
+    if (!state) {
+      return;
+    }
+    safeLog3(state.span, {
+      ...event.isError ? { error: errorToString(event.result) } : {},
+      metadata: {
+        ...state.metadata,
+        ...extractEventMetadata(event),
+        ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {}
+      },
+      metrics: durationMsMetrics(event.durationMs),
+      output: event.result
+    });
+    state.span.end();
+    this.tasksById.delete(event.taskId);
+  }
+  handleCompactionStart(event) {
+    const operationState = this.operationStateForEvent(event);
+    const parent = operationState?.span ?? this.parentSpanForEvent(event);
+    const metadata = {
+      ...extractEventMetadata(event),
+      ...event.reason ? { "flue.compaction_reason": event.reason } : {},
+      provider: "flue"
+    };
+    const input = {
+      ...typeof event.estimatedTokens === "number" ? { estimatedTokens: event.estimatedTokens } : {},
+      ...event.reason ? { reason: event.reason } : {}
+    };
+    const span = startFlueSpan(parent, {
+      name: "flue.compaction",
+      spanAttributes: { type: "task" /* TASK */ }
+    });
+    safeLog3(span, {
+      input,
+      metadata
+    });
+    this.compactionsByScope.set(scopeKey(event), {
+      input,
+      metadata,
+      operationState,
+      span,
+      startTime: getCurrentUnixTimestamp()
+    });
+  }
+  handleCompaction(event) {
+    const key = scopeKey(event);
+    const state = this.compactionsByScope.get(key) ?? this.findCompactionState(event);
+    if (!state) {
+      return;
+    }
+    safeLog3(state.span, {
+      metadata: {
+        ...state.metadata,
+        ...extractEventMetadata(event),
+        ...typeof event.messagesBefore === "number" ? { "flue.messages_before": event.messagesBefore } : {},
+        ...typeof event.messagesAfter === "number" ? { "flue.messages_after": event.messagesAfter } : {}
+      },
+      metrics: {
+        ...durationMsMetrics(event.durationMs),
+        ...metricsFromUsage(event.usage)
+      },
+      output: {
+        messagesAfter: event.messagesAfter,
+        messagesBefore: event.messagesBefore
+      }
+    });
+    state.span.end();
+    this.deleteCompactionState(state);
+  }
+  findCompactionState(event) {
+    const operationState = this.operationStateForEvent(event);
+    for (const state of this.compactionsByScope.values()) {
+      if (operationState && state.operationState === operationState) {
+        return state;
+      }
+    }
+    return void 0;
+  }
+  finishCompactionsForOperation(operationState) {
+    for (const state of [...this.compactionsByScope.values()]) {
+      if (state.operationState !== operationState) {
+        continue;
+      }
+      safeLog3(state.span, {
+        input: state.input,
+        metadata: state.metadata,
+        metrics: {
+          ...buildDurationMetrics3(state.startTime)
+        },
+        output: { completed: true }
+      });
+      state.span.end();
+      this.deleteCompactionState(state);
+    }
+  }
+  deleteCompactionState(state) {
+    for (const [key, candidate] of this.compactionsByScope) {
+      if (candidate !== state) {
+        continue;
+      }
+      this.compactionsByScope.delete(key);
+      return;
+    }
+  }
+  startSyntheticToolState(event, toolName) {
+    const parent = this.parentSpanForEvent(event);
+    const metadata = {
+      ...extractEventMetadata(event),
+      ...event.toolCallId ? { "flue.tool_call_id": event.toolCallId } : {},
+      "flue.tool_name": toolName,
+      provider: "flue"
+    };
+    const span = startFlueSpan(parent, {
+      name: `tool: ${toolName}`,
+      spanAttributes: { type: "tool" /* TOOL */ }
+    });
+    safeLog3(span, { metadata });
+    return { metadata, span, startTime: getCurrentUnixTimestamp() };
+  }
+  operationStateForEvent(event) {
+    if (event.operationId) {
+      const operation = this.activeOperationsById.get(event.operationId) ?? this.promotePendingOperationForEvent(event);
+      if (operation) {
+        return operation;
+      }
+    }
+    return this.activeOperationForEventScope(event) ?? this.pendingOperationForEventScope(event);
+  }
+  parentSpanForEvent(event) {
+    if (event.operationId) {
+      const operation = this.operationStateForEvent(event);
+      if (operation) {
+        return operation.span;
+      }
+    }
+    if (event.taskId) {
+      return this.tasksById.get(event.taskId)?.span;
+    }
+    return this.operationStateForEvent(event)?.span;
+  }
+  promotePendingOperationForEvent(event) {
+    if (!event.operationId) {
+      return void 0;
+    }
+    const scopePrefixes = operationScopePrefixes(event);
+    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
+      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+        continue;
+      }
+      const state = candidateQueue.shift();
+      if (!state) {
+        return void 0;
+      }
+      state.operationId = event.operationId;
+      this.activeOperationsById.set(event.operationId, state);
+      addScopedOperation(this.activeOperationsByScope, event, state);
+      state.metadata = {
+        ...state.metadata,
+        ...extractEventMetadata(event),
+        "flue.operation_id": event.operationId
+      };
+      safeLog3(state.span, { metadata: state.metadata });
+      return state;
+    }
+    return void 0;
+  }
+  activeOperationForEventScope(event) {
+    for (const scope of operationScopeNames(event)) {
+      const operations = this.activeOperationsByScope.get(scope);
+      if (operations?.length) {
+        return operations[operations.length - 1];
+      }
+    }
+    return void 0;
+  }
+  pendingOperationForEventScope(event) {
+    const scopePrefixes = operationScopePrefixes(event);
+    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
+      if (!candidateQueue.length || !operationKeyMatchesScopes(candidateKey, scopePrefixes)) {
+        continue;
+      }
+      return candidateQueue[0];
+    }
+    return void 0;
+  }
+  takePendingOperationForEvent(event) {
+    const key = operationKey(event.session, event.operationKind);
+    const queue2 = this.pendingOperationsByKey.get(key);
+    if (queue2?.length) {
+      return queue2.shift();
+    }
+    for (const [candidateKey, candidateQueue] of this.pendingOperationsByKey) {
+      if (candidateKey.endsWith(`::${event.operationKind}`) && candidateQueue.length) {
+        return candidateQueue.shift();
+      }
+    }
+    return void 0;
+  }
+  pendingOperationQueue(key) {
+    const existing = this.pendingOperationsByKey.get(key);
+    if (existing) {
+      return existing;
+    }
+    const queue2 = [];
+    this.pendingOperationsByKey.set(key, queue2);
+    return queue2;
+  }
+};
+function isInstrumentedOperation(operation) {
+  return operation === "prompt" || operation === "skill" || operation === "task" || operation === "compact";
+}
+function getSessionName(session) {
+  return typeof session?.name === "string" ? session.name : void 0;
+}
+function operationKey(sessionName, operation) {
+  return `${sessionName ?? "unknown"}::${operation}`;
+}
+function operationScopePrefixes(event) {
+  const scopes = /* @__PURE__ */ new Set();
+  for (const scope of operationScopeNames(event)) {
+    scopes.add(`${scope}::`);
+  }
+  return scopes;
+}
+function operationKeyMatchesScopes(key, scopes) {
+  for (const scope of scopes) {
+    if (key.startsWith(scope)) {
+      return true;
+    }
+  }
+  return false;
+}
+function operationScopeNames(event) {
+  const scopes = /* @__PURE__ */ new Set();
+  if (event.session) {
+    scopes.add(event.session);
+  }
+  if (event.parentSession) {
+    scopes.add(event.parentSession);
+  }
+  if (!scopes.size) {
+    scopes.add("unknown");
+  }
+  return scopes;
+}
+function addScopedOperation(operationsByScope, event, state) {
+  for (const scope of operationScopeNames(event)) {
+    addOperationToScope(operationsByScope, scope, state);
+  }
+}
+function addOperationToScope(operationsByScope, scope, state) {
+  const operations = operationsByScope.get(scope);
+  if (operations) {
+    if (!operations.includes(state)) {
+      operations.push(state);
+    }
+  } else {
+    operationsByScope.set(scope, [state]);
+  }
+}
+function removeScopedOperation(operationsByScope, state) {
+  for (const [scope, operations] of operationsByScope) {
+    const index = operations.indexOf(state);
+    if (index === -1) {
+      continue;
+    }
+    operations.splice(index, 1);
+    if (operations.length === 0) {
+      operationsByScope.delete(scope);
+    }
+  }
+}
+function removePendingOperation(pendingOperationsByKey, state) {
+  for (const [key, queue2] of pendingOperationsByKey) {
+    const index = queue2.indexOf(state);
+    if (index === -1) {
+      continue;
+    }
+    queue2.splice(index, 1);
+    if (queue2.length === 0) {
+      pendingOperationsByKey.delete(key);
+    }
+    return;
+  }
+}
+function extractSessionMetadata(session) {
+  const sessionName = getSessionName(session);
+  return sessionName ? { "flue.session": sessionName } : {};
+}
+function extractEventMetadata(event) {
+  return {
+    ...event.runId ? { "flue.run_id": event.runId } : {},
+    ...typeof event.eventIndex === "number" ? { "flue.event_index": event.eventIndex } : {},
+    ...event.session ? { "flue.session": event.session } : {},
+    ...event.parentSession ? { "flue.parent_session": event.parentSession } : {},
+    ...event.harness ? { "flue.harness": event.harness } : {},
+    ...event.taskId ? { "flue.task_id": event.taskId } : {},
+    ...event.operationId ? { "flue.operation_id": event.operationId } : {}
+  };
+}
+function extractOperationInput(operation, args) {
+  switch (operation) {
+    case "prompt":
+    case "task":
+      return args[0];
+    case "skill":
+      return {
+        args: getOptionObject(args[1])?.args,
+        name: args[0]
+      };
+    case "compact":
+      return void 0;
+  }
+}
+function extractOperationInputMetadata(operation, args) {
+  const options = getOptionObject(args[1]);
+  return {
+    ...operation === "skill" && typeof args[0] === "string" ? { "flue.skill_name": args[0] } : {},
+    ...options?.model ? { model: options.model, "flue.model": options.model } : {},
+    ...options?.role ? { "flue.role": options.role } : {},
+    ...options?.thinkingLevel ? { "flue.thinking_level": options.thinkingLevel } : {},
+    ...typeof options?.cwd === "string" ? { "flue.cwd": options.cwd } : {},
+    ...Array.isArray(options?.tools) ? {
+      "flue.tools_count": options.tools.length,
+      tools: summarizeTools(options.tools)
+    } : {},
+    ...Array.isArray(options?.images) ? { "flue.images_count": options.images.length } : {},
+    ...options?.result || options?.schema ? { "flue.result_schema": true } : {}
+  };
+}
+function getOptionObject(value) {
+  return isObject(value) ? value : void 0;
+}
+function summarizeTools(tools) {
+  return tools.flatMap((tool) => {
+    if (!isObject(tool)) {
+      return [];
+    }
+    const name = typeof tool.name === "string" ? tool.name : void 0;
+    if (!name) {
+      return [];
+    }
+    return [
+      {
+        function: {
+          description: typeof tool.description === "string" ? tool.description : void 0,
+          name,
+          parameters: tool.parameters
+        },
+        type: "function"
+      }
+    ];
+  });
+}
+function extractPromptResponseMetadata(result) {
+  const modelId = result?.model && typeof result.model.id === "string" ? result.model.id : void 0;
+  return modelId ? {
+    model: modelId,
+    "flue.model": modelId
+  } : {};
+}
+function extractOperationOutput(result) {
+  if (!result) {
+    return void 0;
+  }
+  if ("data" in result) {
+    return result.data;
+  }
+  if ("text" in result) {
+    return result.text;
+  }
+  return result;
+}
+function metricsFromUsage(usage) {
+  return {
+    ...typeof usage?.input === "number" ? { prompt_tokens: usage.input } : {},
+    ...typeof usage?.output === "number" ? { completion_tokens: usage.output } : {},
+    ...typeof usage?.cacheRead === "number" ? { prompt_cached_tokens: usage.cacheRead } : {},
+    ...typeof usage?.cacheWrite === "number" ? { prompt_cache_creation_tokens: usage.cacheWrite } : {},
+    ...typeof usage?.totalTokens === "number" ? { tokens: usage.totalTokens } : {},
+    ...typeof usage?.cost?.total === "number" ? { estimated_cost: usage.cost.total } : {}
+  };
+}
+function buildDurationMetrics3(startTime) {
+  return {
+    duration_ms: Math.max(0, (getCurrentUnixTimestamp() - startTime) * 1e3)
+  };
+}
+function durationMsMetrics(durationMs) {
+  return typeof durationMs === "number" ? { duration_ms: durationMs } : {};
+}
+function scopeKey(event) {
+  if (event.operationId) {
+    return `operation:${event.operationId}`;
+  }
+  if (event.taskId) {
+    return `task:${event.taskId}`;
+  }
+  if (event.session) {
+    return `session:${event.session}`;
+  }
+  return "flue:unknown";
+}
+function toolKey(event) {
+  return `${scopeKey(event)}::tool:${event.toolCallId ?? "unknown"}`;
+}
+function toAssistantOutput(text, finishReason, reasoning, toolCalls) {
+  return [
+    {
+      finish_reason: finishReason ?? "stop",
+      index: 0,
+      message: {
+        content: text,
+        ...reasoning ? { reasoning } : {},
+        role: "assistant",
+        ...toolCalls?.length ? {
+          tool_calls: toolCalls.map((toolCall) => ({
+            function: {
+              arguments: toolCall.args === void 0 ? "{}" : JSON.stringify(toolCall.args),
+              name: toolCall.toolName ?? "unknown"
+            },
+            ...toolCall.toolCallId ? { id: toolCall.toolCallId } : {},
+            type: "function"
+          }))
+        } : {}
+      }
+    }
+  ];
+}
+function startFlueSpan(parent, args) {
+  return parent ? withCurrent(parent, () => startSpan(args)) : startSpan(args);
+}
+function safeLog3(span, event) {
+  try {
+    span.log(event);
+  } catch (error) {
+    logInstrumentationError3("Flue span log", error);
+  }
+}
+function errorToString(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function logInstrumentationError3(label, error) {
+  console.error(`Error in ${label} instrumentation:`, error);
+}
+
+// src/wrappers/langchain/callback-handler.ts
+var BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME = "BraintrustCallbackHandler";
+var BraintrustLangChainCallbackHandler = class {
+  name = BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
+  spans = /* @__PURE__ */ new Map();
+  skippedRuns = /* @__PURE__ */ new Set();
+  parent;
+  rootRunId;
+  options;
+  startTimes = /* @__PURE__ */ new Map();
+  firstTokenTimes = /* @__PURE__ */ new Map();
+  ttftMs = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.parent = options?.parent;
+    this.options = {
+      debug: options?.debug ?? false,
+      excludeMetadataProps: options?.excludeMetadataProps ?? /^(l[sc]_|langgraph_|__pregel_|checkpoint_ns)/,
+      logger: options?.logger
+    };
+  }
+  startSpan({
+    runId,
+    parentRunId,
+    ...args
+  }) {
+    if (this.spans.has(runId)) {
+      return;
+    }
+    if (!parentRunId) {
+      this.rootRunId = runId;
+    }
+    const tags = args.event?.tags;
+    const spanAttributes = args.spanAttributes || {};
+    spanAttributes.type = args.type || spanAttributes.type || "task";
+    args.type = spanAttributes.type;
+    const currentParent = (typeof this.parent === "function" ? this.parent() : this.parent) ?? currentSpan();
+    let parentSpan;
+    if (parentRunId && this.spans.has(parentRunId)) {
+      parentSpan = this.spans.get(parentRunId);
+    } else if (!Object.is(currentParent, NOOP_SPAN)) {
+      parentSpan = currentParent;
+    } else if (this.options.logger) {
+      parentSpan = this.options.logger;
+    } else {
+      parentSpan = { startSpan };
+    }
+    args.event = {
+      ...args.event,
+      tags: void 0,
+      metadata: {
+        ...tags ? { tags } : {},
+        ...args.event?.metadata,
+        braintrust: {
+          integration_name: "langchain-js",
+          sdk_language: "javascript"
+        },
+        run_id: runId,
+        parent_run_id: parentRunId,
+        ...this.options.debug ? { runId, parentRunId } : {}
+      }
+    };
+    let span = parentSpan.startSpan(args);
+    if (!Object.is(this.options.logger, NOOP_SPAN) && Object.is(span, NOOP_SPAN)) {
+      span = initLogger().startSpan(args);
+    }
+    this.spans.set(runId, span);
+  }
+  endSpan({
+    runId,
+    parentRunId,
+    tags,
+    metadata,
+    ...args
+  }) {
+    if (!this.spans.has(runId)) {
+      return;
+    }
+    if (this.skippedRuns.has(runId)) {
+      this.skippedRuns.delete(runId);
+      return;
+    }
+    const span = this.spans.get(runId);
+    this.spans.delete(runId);
+    if (runId === this.rootRunId) {
+      this.rootRunId = void 0;
+    }
+    span.log({ ...args, metadata: { tags, ...metadata } });
+    span.end();
+  }
+  async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, runName) {
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: runName ?? getSerializedName(llm) ?? "LLM",
+      type: "llm",
+      event: {
+        input: prompts,
+        tags,
+        metadata: {
+          serialized: llm,
+          name: runName,
+          metadata,
+          ...extraParams
+        }
+      }
+    });
+  }
+  async handleLLMError(err, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, error: err, tags });
+  }
+  async handleLLMEnd(output, runId, parentRunId, tags) {
+    const metrics = getMetricsFromResponse(output);
+    const modelName2 = getModelNameFromResponse(output);
+    const ttft = this.ttftMs.get(runId);
+    if (ttft !== void 0) {
+      metrics.time_to_first_token = ttft;
+    }
+    this.startTimes.delete(runId);
+    this.firstTokenTimes.delete(runId);
+    this.ttftMs.delete(runId);
+    this.endSpan({
+      runId,
+      parentRunId,
+      output,
+      metrics,
+      tags,
+      metadata: {
+        model: modelName2
+      }
+    });
+  }
+  async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, runName) {
+    this.startTimes.set(runId, Date.now());
+    this.firstTokenTimes.delete(runId);
+    this.ttftMs.delete(runId);
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: runName ?? getSerializedName(llm) ?? "Chat Model",
+      type: "llm",
+      event: {
+        input: messages,
+        tags,
+        metadata: {
+          serialized: llm,
+          name: runName,
+          metadata,
+          ...extraParams
+        }
+      }
+    });
+  }
+  async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, runName) {
+    if (tags?.includes("langsmith:hidden")) {
+      this.skippedRuns.add(runId);
+      return;
+    }
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: runName ?? getSerializedName(chain) ?? "Chain",
+      event: {
+        input: inputs,
+        tags,
+        metadata: {
+          serialized: chain,
+          name: runName,
+          metadata,
+          run_type: runType
+        }
+      }
+    });
+  }
+  async handleChainError(err, runId, parentRunId, tags, kwargs) {
+    this.endSpan({ runId, parentRunId, error: err, tags, metadata: kwargs });
+  }
+  async handleChainEnd(outputs, runId, parentRunId, tags, kwargs) {
+    this.endSpan({
+      runId,
+      parentRunId,
+      tags,
+      output: outputs,
+      metadata: { ...kwargs }
+    });
+  }
+  async handleToolStart(tool, input, runId, parentRunId, tags, metadata, runName) {
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: runName ?? getSerializedName(tool) ?? "Tool",
+      type: "llm",
+      event: {
+        input: safeJsonParse(input),
+        tags,
+        metadata: {
+          metadata,
+          serialized: tool,
+          input_str: input,
+          input: safeJsonParse(input),
+          name: runName
+        }
+      }
+    });
+  }
+  async handleToolError(err, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, error: err, tags });
+  }
+  async handleToolEnd(output, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, output, tags });
+  }
+  async handleAgentAction(action, runId, parentRunId, tags) {
+    this.startSpan({
+      runId,
+      parentRunId,
+      type: "llm",
+      name: typeof action.tool === "string" ? action.tool : "Agent",
+      event: {
+        input: action,
+        tags
       }
-      break;
-    }
-    case "subagent.failed": {
-      const d = event.data;
-      if (d && typeof d.toolCallId === "string") {
-        handleSubagentFailed(
-          state,
-          d.toolCallId,
-          d.error ?? "sub-agent failed"
-        );
+    });
+  }
+  async handleAgentEnd(action, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, output: action, tags });
+  }
+  async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: name ?? getSerializedName(retriever) ?? "Retriever",
+      type: "function",
+      event: {
+        input: query,
+        tags,
+        metadata: {
+          serialized: retriever,
+          metadata,
+          name
+        }
+      }
+    });
+  }
+  async handleRetrieverEnd(documents, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, output: documents, tags });
+  }
+  async handleRetrieverError(err, runId, parentRunId, tags) {
+    this.endSpan({ runId, parentRunId, error: err, tags });
+  }
+  async handleLLMNewToken(_token, _idx, runId, _parentRunId, _tags) {
+    if (!this.firstTokenTimes.has(runId)) {
+      const now2 = Date.now();
+      this.firstTokenTimes.set(runId, now2);
+      const start = this.startTimes.get(runId);
+      if (start !== void 0) {
+        this.ttftMs.set(runId, (now2 - start) / 1e3);
       }
-      break;
     }
-    case "session.usage_info": {
-      const d = event.data;
-      if (d && typeof d.currentTokens === "number") {
-        state.session.span.log({
-          metadata: {
-            "github_copilot.context_window.limit": d.tokenLimit,
-            "github_copilot.context_window.current": d.currentTokens,
-            "github_copilot.context_window.messages": d.messagesLength
-          }
-        });
+  }
+};
+function getSerializedName(serialized) {
+  if (typeof serialized.name === "string") {
+    return serialized.name;
+  }
+  const lastIdPart = serialized.id?.at(-1);
+  return typeof lastIdPart === "string" ? lastIdPart : void 0;
+}
+function cleanObject(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, value]) => {
+      if (typeof value !== "number") {
+        return false;
       }
-      break;
+      return Number.isFinite(value);
+    })
+  );
+}
+function walkGenerations(response) {
+  const result = [];
+  const generations = response.generations || [];
+  for (const batch of generations) {
+    if (Array.isArray(batch)) {
+      for (const generation of batch) {
+        if (isRecord(generation)) {
+          result.push(generation);
+        }
+      }
+    } else if (isRecord(batch)) {
+      result.push(batch);
     }
   }
+  return result;
 }
-function injectTracingHooks2(config, state) {
-  const existingHooks = config.hooks ?? {};
-  const onSessionEnd = async (input, invocation) => {
-    try {
-      await existingHooks.onSessionEnd?.(input, invocation);
-    } finally {
-      handleSessionEnd(state, input.reason, input.error);
-      state.unsubscribeEvents?.();
+function getModelNameFromResponse(response) {
+  for (const generation of walkGenerations(response)) {
+    const message = generation.message;
+    if (!isRecord(message)) {
+      continue;
     }
-  };
-  config.hooks = {
-    ...existingHooks,
-    onSessionEnd
-  };
+    const responseMetadata = message.response_metadata;
+    if (!isRecord(responseMetadata)) {
+      continue;
+    }
+    const modelName3 = responseMetadata.model_name ?? responseMetadata.model;
+    if (typeof modelName3 === "string") {
+      return modelName3;
+    }
+  }
+  const llmOutput = response.llmOutput || {};
+  const modelName2 = llmOutput.model_name ?? llmOutput.model;
+  return typeof modelName2 === "string" ? modelName2 : void 0;
 }
-function attachSessionEventListener(session, state) {
-  const handler = (event) => {
-    state.processing = state.processing.then(() => dispatchEvent(state, event)).catch((err) => {
-      console.error(
-        "[Braintrust] Error processing GitHub Copilot SDK event:",
-        err
-      );
+function getMetricsFromResponse(response) {
+  for (const generation of walkGenerations(response)) {
+    const message = generation.message;
+    if (!isRecord(message)) {
+      continue;
+    }
+    const usageMetadata = message.usage_metadata;
+    if (!isRecord(usageMetadata)) {
+      continue;
+    }
+    const inputTokenDetails = usageMetadata.input_token_details;
+    return cleanObject({
+      total_tokens: usageMetadata.total_tokens,
+      prompt_tokens: usageMetadata.input_tokens,
+      completion_tokens: usageMetadata.output_tokens,
+      prompt_cache_creation_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_creation : void 0,
+      prompt_cached_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_read : void 0
     });
-  };
-  state.unsubscribeEvents = session.on(
-    handler
-  );
+  }
+  const llmOutput = response.llmOutput || {};
+  const tokenUsage = isRecord(llmOutput.tokenUsage) ? llmOutput.tokenUsage : isRecord(llmOutput.estimatedTokens) ? llmOutput.estimatedTokens : {};
+  return cleanObject({
+    total_tokens: tokenUsage.totalTokens,
+    prompt_tokens: tokenUsage.promptTokens,
+    completion_tokens: tokenUsage.completionTokens
+  });
 }
-function isGitHubCopilotSession(value) {
-  return value !== null && typeof value === "object" && typeof value.on === "function";
+function safeJsonParse(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return input;
+  }
 }
-function makeSessionHandlers(sessionStates, configArgIndex, includeProviderMetadata) {
-  return {
-    start: (event) => {
-      const config = event.arguments[configArgIndex];
-      if (!config || typeof config !== "object") {
-        return;
-      }
-      const sessionSpan = startSpan({
-        name: "Copilot Session",
-        spanAttributes: { type: "task" /* TASK */ }
-      });
-      const metadata = {};
-      if (config.model) {
-        metadata["github_copilot.model"] = config.model;
-      }
-      if (includeProviderMetadata && config.provider?.type) {
-        metadata["github_copilot.provider_type"] = config.provider.type;
-      }
-      if (Object.keys(metadata).length > 0) {
-        sessionSpan.log({ metadata });
-      }
-      const state = {
-        session: makeSpanWithId(sessionSpan),
-        activeTurns: /* @__PURE__ */ new Map(),
-        pendingUserMessages: /* @__PURE__ */ new Map(),
-        currentMessageContent: /* @__PURE__ */ new Map(),
-        activeTools: /* @__PURE__ */ new Map(),
-        subAgents: /* @__PURE__ */ new Map(),
-        agentIdToToolCallId: /* @__PURE__ */ new Map(),
-        processing: Promise.resolve(),
-        totalInputTokens: 0,
-        totalOutputTokens: 0
-      };
-      injectTracingHooks2(config, state);
-      sessionStates.set(event, state);
-    },
-    asyncEnd: (event) => {
-      const state = sessionStates.get(event);
-      if (!state) {
-        return;
-      }
-      const session = event.result;
-      if (isGitHubCopilotSession(session)) {
-        attachSessionEventListener(session, state);
-      } else {
-        state.session.span.end();
-      }
-      sessionStates.delete(event);
-    },
-    error: (event) => {
-      const state = sessionStates.get(event);
-      if (!state || !event.error) {
-        return;
-      }
-      state.session.span.log({ error: event.error.message });
-      state.session.span.end();
-      sessionStates.delete(event);
-    }
-  };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var GitHubCopilotPlugin = class extends BasePlugin {
+
+// src/instrumentation/plugins/langchain-plugin.ts
+var LangChainPlugin = class extends BasePlugin {
+  injectedManagers = /* @__PURE__ */ new WeakSet();
   onEnable() {
-    this.subscribeToSessionChannels();
+    this.subscribeToConfigure(langChainChannels.configure);
+    this.subscribeToConfigure(langChainChannels.configureSync);
   }
   onDisable() {
     for (const unsubscribe of this.unsubscribers) {
       unsubscribe();
     }
     this.unsubscribers = [];
+    this.injectedManagers = /* @__PURE__ */ new WeakSet();
   }
-  subscribeToSessionChannels() {
-    const createChannel = gitHubCopilotChannels.createSession.tracingChannel();
-    const resumeChannel = gitHubCopilotChannels.resumeSession.tracingChannel();
-    const sessionStates = /* @__PURE__ */ new WeakMap();
-    const createHandlers = makeSessionHandlers(
-      sessionStates,
-      0,
-      // config is arg 0 of createSession(config)
-      true
-      // include provider metadata
-    );
-    const resumeHandlers = makeSessionHandlers(
-      sessionStates,
-      1,
-      // config is arg 1 of resumeSession(sessionId, config)
-      false
-      // resumeSession config has no provider field
-    );
-    createChannel.subscribe(createHandlers);
-    resumeChannel.subscribe(resumeHandlers);
-    this.unsubscribers.push(
-      () => createChannel.unsubscribe(createHandlers),
-      () => resumeChannel.unsubscribe(resumeHandlers)
-    );
+  subscribeToConfigure(channel) {
+    const tracingChannel2 = channel.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        injectHandlerIntoArguments(event.arguments);
+      },
+      end: (event) => {
+        this.injectHandler(event.result);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  injectHandler(result) {
+    if (!isCallbackManager(result)) {
+      return;
+    }
+    if (this.injectedManagers.has(result) || hasBraintrustHandler(result)) {
+      return;
+    }
+    try {
+      result.addHandler(new BraintrustLangChainCallbackHandler(), true);
+      this.injectedManagers.add(result);
+    } catch {
+    }
   }
 };
+function isCallbackManager(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const maybeManager = value;
+  return typeof maybeManager.addHandler === "function";
+}
+function hasBraintrustHandler(manager) {
+  return manager.handlers?.some((handler) => {
+    if (typeof handler !== "object" || handler === null) {
+      return false;
+    }
+    const name = Reflect.get(handler, "name");
+    return name === BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
+  }) ?? false;
+}
+function injectHandlerIntoArguments(args) {
+  if (!isWritableArgumentsObject(args)) {
+    return;
+  }
+  const inheritedHandlers = Reflect.get(args, "0");
+  const handler = new BraintrustLangChainCallbackHandler();
+  if (inheritedHandlers === void 0 || inheritedHandlers === null) {
+    Reflect.set(args, "0", [handler]);
+    return;
+  }
+  if (Array.isArray(inheritedHandlers)) {
+    if (!inheritedHandlers.some(isBraintrustHandler)) {
+      inheritedHandlers.push(handler);
+    }
+  }
+}
+function isWritableArgumentsObject(args) {
+  return typeof args === "object" && args !== null;
+}
+function isBraintrustHandler(handler) {
+  if (typeof handler !== "object" || handler === null) {
+    return false;
+  }
+  return Reflect.get(handler, "name") === BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME;
+}
 
 // src/instrumentation/braintrust-plugin.ts
 function getIntegrationConfig(integrations, key) {
@@ -23680,6 +25192,7 @@ var BraintrustPlugin = class extends BasePlugin {
   aiSDKPlugin = null;
   claudeAgentSDKPlugin = null;
   cursorSDKPlugin = null;
+  openAIAgentsPlugin = null;
   googleGenAIPlugin = null;
   huggingFacePlugin = null;
   openRouterPlugin = null;
@@ -23690,6 +25203,8 @@ var BraintrustPlugin = class extends BasePlugin {
   groqPlugin = null;
   genkitPlugin = null;
   gitHubCopilotPlugin = null;
+  fluePlugin = null;
+  langChainPlugin = null;
   constructor(config = {}) {
     super();
     this.config = config;
@@ -23720,6 +25235,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.cursorSDKPlugin = new CursorSDKPlugin();
       this.cursorSDKPlugin.enable();
     }
+    if (integrations.openAIAgents !== false) {
+      this.openAIAgentsPlugin = new OpenAIAgentsPlugin();
+      this.openAIAgentsPlugin.enable();
+    }
     if (integrations.googleGenAI !== false && integrations.google !== false) {
       this.googleGenAIPlugin = new GoogleGenAIPlugin();
       this.googleGenAIPlugin.enable();
@@ -23760,6 +25279,14 @@ var BraintrustPlugin = class extends BasePlugin {
       this.gitHubCopilotPlugin = new GitHubCopilotPlugin();
       this.gitHubCopilotPlugin.enable();
     }
+    if (getIntegrationConfig(integrations, "flue") !== false) {
+      this.fluePlugin = new FluePlugin();
+      this.fluePlugin.enable();
+    }
+    if (integrations.langchain !== false && integrations.langgraph !== false) {
+      this.langChainPlugin = new LangChainPlugin();
+      this.langChainPlugin.enable();
+    }
   }
   onDisable() {
     if (this.openaiPlugin) {
@@ -23786,6 +25313,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.cursorSDKPlugin.disable();
       this.cursorSDKPlugin = null;
     }
+    if (this.openAIAgentsPlugin) {
+      this.openAIAgentsPlugin.disable();
+      this.openAIAgentsPlugin = null;
+    }
     if (this.googleGenAIPlugin) {
       this.googleGenAIPlugin.disable();
       this.googleGenAIPlugin = null;
@@ -23826,6 +25357,14 @@ var BraintrustPlugin = class extends BasePlugin {
       this.gitHubCopilotPlugin.disable();
       this.gitHubCopilotPlugin = null;
     }
+    if (this.fluePlugin) {
+      this.fluePlugin.disable();
+      this.fluePlugin = null;
+    }
+    if (this.langChainPlugin) {
+      this.langChainPlugin.disable();
+      this.langChainPlugin = null;
+    }
   }
 };
 
@@ -23907,50 +25446,16 @@ var PluginRegistry = class {
    * Get default configuration (all integrations enabled).
    */
   getDefaultConfig() {
-    return {
-      openai: true,
-      openaiCodexSDK: true,
-      anthropic: true,
-      vercel: true,
-      aisdk: true,
-      google: true,
-      googleGenAI: true,
-      googleADK: true,
-      huggingface: true,
-      claudeAgentSDK: true,
-      cursor: true,
-      cursorSDK: true,
-      openrouter: true,
-      openrouterAgent: true,
-      mistral: true,
-      cohere: true,
-      groq: true,
-      genkit: true,
-      gitHubCopilot: true
-    };
+    return getDefaultInstrumentationIntegrations();
   }
   /**
    * Read configuration from environment variables.
    * Supports: BRAINTRUST_DISABLE_INSTRUMENTATION=openai,anthropic,...
    */
   readEnvConfig() {
-    const integrations = {};
-    const disabledList = isomorph_default.getEnv("BRAINTRUST_DISABLE_INSTRUMENTATION");
-    if (disabledList) {
-      const disabled = disabledList.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0);
-      for (const sdk of disabled) {
-        if (sdk === "cursor-sdk") {
-          integrations.cursorSDK = false;
-        } else if (sdk === "githubcopilot" || sdk === "github-copilot" || sdk === "copilot-sdk") {
-          integrations.gitHubCopilot = false;
-        } else if (sdk === "openai-codex-sdk") {
-          integrations.openaiCodexSDK = false;
-        } else {
-          integrations[sdk] = false;
-        }
-      }
-    }
-    return { integrations };
+    return readDisabledInstrumentationEnvConfig(
+      isomorph_default.getEnv("BRAINTRUST_DISABLE_INSTRUMENTATION")
+    );
   }
 };
 var registry = new PluginRegistry();
@@ -24003,8 +25508,10 @@ __export(exports_exports, {
   Attachment: () => Attachment,
   AttachmentReference: () => AttachmentReference,
   BRAINTRUST_CURRENT_SPAN_STORE: () => BRAINTRUST_CURRENT_SPAN_STORE,
+  BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME: () => BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
   BaseAttachment: () => BaseAttachment,
   BaseExperiment: () => BaseExperiment,
+  BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
@@ -24130,6 +25637,8 @@ __export(exports_exports, {
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
+  wrapFlueContext: () => wrapFlueContext,
+  wrapFlueSession: () => wrapFlueSession,
   wrapGenkit: () => wrapGenkit,
   wrapGoogleADK: () => wrapGoogleADK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
@@ -24357,11 +25866,11 @@ function createChannelContext(_channel, params, span_info) {
     span_info
   };
 }
-async function tracePromiseWithResponse(channel2, traceContext, apiPromise) {
+async function tracePromiseWithResponse(channel, traceContext, apiPromise) {
   let enhancedResponse;
   const tracePromise = (
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    channel2.tracePromise
+    channel.tracePromise
   );
   const data = await tracePromise(async () => {
     enhancedResponse = await apiPromise.withResponse();
@@ -24424,16 +25933,16 @@ function responsesProxy(openai) {
     }
   });
 }
-function wrapResponsesAsync(target, channel2) {
+function wrapResponsesAsync(target, channel) {
   return (allParams, options) => {
     const { span_info, params } = splitSpanInfo(allParams);
     let executionPromise = null;
     const ensureExecuted = () => {
       if (!executionPromise) {
         executionPromise = (async () => {
-          const traceContext = createChannelContext(channel2, params, span_info);
+          const traceContext = createChannelContext(channel, params, span_info);
           const apiPromise = target(params, options);
-          return tracePromiseWithResponse(channel2, traceContext, apiPromise);
+          return tracePromiseWithResponse(channel, traceContext, apiPromise);
         })();
       }
       return executionPromise;
@@ -24441,10 +25950,10 @@ function wrapResponsesAsync(target, channel2) {
     return createLazyAPIPromise(ensureExecuted);
   };
 }
-function wrapResponsesSyncStream(target, channel2) {
+function wrapResponsesSyncStream(target, channel) {
   return (allParams, options) => {
     const { span_info, params } = splitSpanInfo(allParams);
-    return channel2.traceSync(() => target(params, options), {
+    return channel.traceSync(() => target(params, options), {
       arguments: [params],
       span_info
     });
@@ -24632,16 +26141,16 @@ function createEndpointProxy(target, wrapperFn) {
     }
   });
 }
-function wrapApiCreateWithChannel(create, channel2) {
+function wrapApiCreateWithChannel(create, channel) {
   return (allParams, options) => {
     const { span_info, params } = splitSpanInfo(allParams);
     let executionPromise = null;
     const ensureExecuted = () => {
       if (!executionPromise) {
         executionPromise = (async () => {
-          const traceContext = createChannelContext(channel2, params, span_info);
+          const traceContext = createChannelContext(channel, params, span_info);
           return tracePromiseWithResponse(
-            channel2,
+            channel,
             traceContext,
             create(params, options)
           );
@@ -24763,11 +26272,11 @@ var wrapAgentStream = (stream, instance, options = {}) => {
     options
   )({ ...instance.settings, ...params });
 };
-var makeGenerateTextWrapper = (channel2, name, generateText, contextOptions = {}, options = {}) => {
+var makeGenerateTextWrapper = (channel, name, generateText, contextOptions = {}, options = {}) => {
   const wrapper = async function(allParams) {
     const { span_info, ...params } = allParams;
     const tracedParams = { ...params };
-    return channel2.tracePromise(
+    return channel.tracePromise(
       () => generateText(tracedParams),
       createAISDKChannelContext(tracedParams, {
         aiSDK: contextOptions.aiSDK,
@@ -24801,11 +26310,11 @@ var wrapGenerateObject = (generateObject, options = {}, aiSDK) => {
     options
   );
 };
-var makeEmbedWrapper = (channel2, name, embed, contextOptions = {}, options = {}) => {
+var makeEmbedWrapper = (channel, name, embed, contextOptions = {}, options = {}) => {
   const wrapper = async function(allParams) {
     const { span_info, ...params } = allParams;
     const tracedParams = { ...params };
-    return channel2.tracePromise(
+    return channel.tracePromise(
       () => embed(tracedParams),
       createAISDKChannelContext(tracedParams, {
         aiSDK: contextOptions.aiSDK,
@@ -24862,7 +26371,7 @@ var makeRerankWrapper = (rerank, contextOptions = {}, options = {}) => {
 var wrapRerank = (rerank, options = {}, aiSDK) => {
   return makeRerankWrapper(rerank, { aiSDK }, options);
 };
-var makeStreamWrapper = (channel2, name, streamText, contextOptions = {}, options = {}) => {
+var makeStreamWrapper = (channel, name, streamText, contextOptions = {}, options = {}) => {
   const wrapper = function(allParams) {
     const { span_info, ...params } = allParams;
     const tracedParams = { ...params };
@@ -24875,7 +26384,7 @@ var makeStreamWrapper = (channel2, name, streamText, contextOptions = {}, option
         spanType: contextOptions.spanType
       })
     });
-    return channel2.tracePromise(() => streamText(tracedParams), context);
+    return channel.tracePromise(() => streamText(tracedParams), context);
   };
   Object.defineProperty(wrapper, "name", { value: name, writable: false });
   return wrapper;
@@ -25229,7 +26738,7 @@ function extractModelParameters(params, excludeKeys) {
   }
   return modelParams;
 }
-function getNumberProperty2(obj, key) {
+function getNumberProperty3(obj, key) {
   if (!obj || typeof obj !== "object" || !(key in obj)) {
     return void 0;
   }
@@ -25238,31 +26747,31 @@ function getNumberProperty2(obj, key) {
 }
 function normalizeUsageMetrics(usage, provider, providerMetadata) {
   const metrics = {};
-  const inputTokens = getNumberProperty2(usage, "inputTokens");
+  const inputTokens = getNumberProperty3(usage, "inputTokens");
   if (inputTokens !== void 0) {
     metrics.prompt_tokens = inputTokens;
   }
-  const outputTokens = getNumberProperty2(usage, "outputTokens");
+  const outputTokens = getNumberProperty3(usage, "outputTokens");
   if (outputTokens !== void 0) {
     metrics.completion_tokens = outputTokens;
   }
-  const totalTokens = getNumberProperty2(usage, "totalTokens");
+  const totalTokens = getNumberProperty3(usage, "totalTokens");
   if (totalTokens !== void 0) {
     metrics.tokens = totalTokens;
   }
-  const reasoningTokens = getNumberProperty2(usage, "reasoningTokens");
+  const reasoningTokens = getNumberProperty3(usage, "reasoningTokens");
   if (reasoningTokens !== void 0) {
     metrics.completion_reasoning_tokens = reasoningTokens;
   }
-  const cachedInputTokens = getNumberProperty2(usage, "cachedInputTokens");
+  const cachedInputTokens = getNumberProperty3(usage, "cachedInputTokens");
   if (cachedInputTokens !== void 0) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
   if (provider === "anthropic") {
     const anthropicMetadata = providerMetadata?.anthropic;
     if (anthropicMetadata) {
-      const cacheReadTokens = getNumberProperty2(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
-      const cacheCreationTokens = getNumberProperty2(
+      const cacheReadTokens = getNumberProperty3(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
+      const cacheCreationTokens = getNumberProperty3(
         anthropicMetadata.usage,
         "cache_creation_input_tokens"
       ) || 0;
@@ -25585,10 +27094,10 @@ function betaMessagesProxy(messages, anthropic) {
     }
   });
 }
-function createProxy(create, channel2) {
+function createProxy(create, channel) {
   return new TypedApplyProxy(create, {
     apply(target, thisArg, argArray) {
-      return channel2.tracePromise(
+      return channel.tracePromise(
         () => Reflect.apply(target, thisArg, argArray),
         {
           arguments: argArray
@@ -25597,7 +27106,7 @@ function createProxy(create, channel2) {
     }
   });
 }
-function toolRunnerProxy(toolRunner, anthropic, channel2) {
+function toolRunnerProxy(toolRunner, anthropic, channel) {
   return new TypedApplyProxy(toolRunner, {
     apply(target, thisArg, argArray) {
       const invocationTarget = thisArg && typeof thisArg === "object" ? new Proxy(thisArg, {
@@ -25608,7 +27117,7 @@ function toolRunnerProxy(toolRunner, anthropic, channel2) {
           return Reflect.get(currentTarget, prop, receiver);
         }
       }) : { _client: anthropic };
-      return channel2.traceSync(
+      return channel.traceSync(
         () => Reflect.apply(target, invocationTarget, argArray),
         {
           arguments: argArray
@@ -26237,17 +27746,17 @@ function wrapGenkit(genkit) {
   console.warn("Unsupported Genkit object. Not wrapping.");
   return genkit;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function isPropertyBag(value) {
-  return isRecord(value) || typeof value === "function";
+  return isRecord2(value) || typeof value === "function";
 }
 function hasFunction(value, methodName) {
   return isPropertyBag(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isGenkitInstance(value) {
-  return isRecord(value) && (hasFunction(value, "generate") || hasFunction(value, "generateStream") || hasFunction(value, "defineFlow") || hasFunction(value, "defineTool"));
+  return isRecord2(value) && (hasFunction(value, "generate") || hasFunction(value, "generateStream") || hasFunction(value, "defineFlow") || hasFunction(value, "defineTool"));
 }
 function isGenkitModule(value) {
   return hasFunction(value, "genkit");
@@ -26301,7 +27810,7 @@ function patchGenkitRegistry(instance) {
   patchGenkitRegistryConstructor(registry2);
 }
 function patchGenkitRegistryLookup(registry2) {
-  if (!isRecord(registry2) || hasRegistryPatchedFlag(registry2) || !hasFunction(registry2, "lookupAction")) {
+  if (!isRecord2(registry2) || hasRegistryPatchedFlag(registry2) || !hasFunction(registry2, "lookupAction")) {
     return;
   }
   const originalLookupAction = registry2.lookupAction;
@@ -26327,7 +27836,7 @@ function patchGenkitRegistryLookup(registry2) {
   }
 }
 function patchGenkitRegistryConstructor(registry2) {
-  if (!isRecord(registry2)) {
+  if (!isRecord2(registry2)) {
     return;
   }
   const constructor = registry2.constructor;
@@ -26343,7 +27852,7 @@ function patchGenkitRegistryConstructor(registry2) {
       configurable: true,
       value: (...args) => {
         const childRegistry = originalWithParent.apply(constructor, args);
-        if (args.some((arg) => isRecord(arg) && hasRegistryPatchedFlag(arg))) {
+        if (args.some((arg) => isRecord2(arg) && hasRegistryPatchedFlag(arg))) {
           patchGenkitRegistryLookup(childRegistry);
           patchGenkitRegistryConstructor(childRegistry);
         }
@@ -26442,7 +27951,7 @@ function hasRegistryConstructorPatchedFlag(value) {
   );
 }
 function isPromiseLike2(value) {
-  return isRecord(value) && "then" in value && typeof value.then === "function";
+  return isRecord2(value) && "then" in value && typeof value.then === "function";
 }
 
 // src/wrappers/huggingface.ts
@@ -26805,14 +28314,14 @@ function wrapMistral(mistral) {
   console.warn("Unsupported Mistral library. Not wrapping.");
   return mistral;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction3(value, methodName) {
-  return isRecord2(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord3(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedMistralClient(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return false;
   }
   return value.chat !== void 0 && hasChat(value.chat) || value.embeddings !== void 0 && hasEmbeddings(value.embeddings) || value.fim !== void 0 && hasFim(value.fim) || value.agents !== void 0 && hasAgents(value.agents) || value.classifiers !== void 0 && hasClassifiers(value.classifiers);
@@ -26996,14 +28505,14 @@ function wrapCohere(cohere) {
   return cohere;
 }
 var cohereProxyCache = /* @__PURE__ */ new WeakMap();
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction4(value, methodName) {
-  return isRecord3(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord4(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedCohereClient(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return false;
   }
   return hasFunction4(value, "chat") || hasFunction4(value, "chatStream") || hasFunction4(value, "embed") || hasFunction4(value, "rerank");
@@ -27063,20 +28572,20 @@ function wrapGroq(groq) {
   console.warn("Unsupported Groq library. Not wrapping.");
   return groq;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction5(value, methodName) {
-  return isRecord4(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord5(value) && methodName in value && typeof value[methodName] === "function";
 }
 function hasChat2(value) {
-  return isRecord4(value) && isRecord4(value.completions) && hasFunction5(value.completions, "create");
+  return isRecord5(value) && isRecord5(value.completions) && hasFunction5(value.completions, "create");
 }
 function hasEmbeddings2(value) {
   return hasFunction5(value, "create");
 }
 function isSupportedGroqClient(value) {
-  return isRecord4(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
+  return isRecord5(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
 }
 function groqProxy(groq) {
   const privateMethodWorkaroundCache = /* @__PURE__ */ new WeakMap();
@@ -31054,8 +32563,10 @@ export {
   Attachment,
   AttachmentReference,
   BRAINTRUST_CURRENT_SPAN_STORE,
+  BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
   BaseAttachment,
   BaseExperiment,
+  BraintrustLangChainCallbackHandler,
   BraintrustMiddleware,
   BraintrustState,
   BraintrustStream,
@@ -31182,6 +32693,8 @@ export {
   wrapCohere,
   wrapCopilotClient,
   wrapCursorSDK,
+  wrapFlueContext,
+  wrapFlueSession,
   wrapGenkit,
   wrapGoogleADK,
   wrapGoogleGenAI,