braintrust 3.11.0 → 3.13.0

package/dist/cli.js

@@ -1232,7 +1232,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "3.11.0",
+      version: "3.13.0",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
@@ -1243,6 +1243,7 @@ var require_package = __commonJS({
       main: "./dist/index.js",
       module: "./dist/index.mjs",
       types: "./dist/index.d.ts",
+      sideEffects: true,
       browser: {
         "./dist/index.js": "./dist/browser.js",
         "./dist/index.d.ts": "./dist/browser.d.ts",
@@ -1282,6 +1283,19 @@ var require_package = __commonJS({
           require: "./dist/browser.js",
           default: "./dist/browser.mjs"
         },
+        "./apply-auto-instrumentation": {
+          types: "./dist/apply-auto-instrumentation.d.ts",
+          "edge-light": "./dist/apply-auto-instrumentation.browser.mjs",
+          workerd: "./dist/apply-auto-instrumentation.browser.mjs",
+          node: {
+            import: "./dist/apply-auto-instrumentation.mjs",
+            require: "./dist/apply-auto-instrumentation.js"
+          },
+          browser: "./dist/apply-auto-instrumentation.browser.mjs",
+          import: "./dist/apply-auto-instrumentation.mjs",
+          require: "./dist/apply-auto-instrumentation.js",
+          default: "./dist/apply-auto-instrumentation.mjs"
+        },
         "./node": {
           types: "./dist/index.d.ts",
           import: "./dist/index.mjs",
@@ -1319,6 +1333,12 @@ var require_package = __commonJS({
           module: "./dist/auto-instrumentations/bundler/webpack.mjs",
           require: "./dist/auto-instrumentations/bundler/webpack.cjs"
         },
+        "./next": {
+          types: "./dist/auto-instrumentations/bundler/next.d.ts",
+          import: "./dist/auto-instrumentations/bundler/next.mjs",
+          module: "./dist/auto-instrumentations/bundler/next.mjs",
+          require: "./dist/auto-instrumentations/bundler/next.cjs"
+        },
         "./webpack-loader": {
           types: "./dist/auto-instrumentations/bundler/webpack-loader.d.ts",
           require: "./dist/auto-instrumentations/bundler/webpack-loader.cjs"
@@ -1350,28 +1370,16 @@ var require_package = __commonJS({
         test: 'vitest run --exclude "src/wrappers/**/*.test.ts" --exclude "src/otel/**/*.test.ts" --exclude "smoke/**/*.test.ts" --exclude "src/zod/**/*.test.ts" --exclude "tests/api-compatibility/**"',
         "test:core": "pnpm prune && pnpm test",
         "test:checks": "pnpm run test:core && pnpm run test:vitest",
-        "test:external": "pnpm run test:external:openai && pnpm run test:external:anthropic && pnpm run test:external:google-genai && pnpm run test:external:ai-sdk && pnpm run test:external:claude-agent-sdk",
-        "test:external:openai": "bash scripts/test-provider.sh test:openai openai",
-        "test:external:anthropic": "bash scripts/test-provider.sh test:anthropic @anthropic-ai/sdk",
-        "test:external:google-genai": "bash scripts/test-provider.sh test:google-genai @google/genai",
-        "test:external:ai-sdk": "pnpm run test:external:ai-sdk-v5 && pnpm run test:external:ai-sdk-v6",
-        "test:external:ai-sdk-v5": "cd src/wrappers/ai-sdk/tests/v5 && pnpm install --ignore-workspace && pnpm test",
-        "test:external:ai-sdk-v6": "cd src/wrappers/ai-sdk/tests/v6 && pnpm install --ignore-workspace && pnpm test",
-        "test:external:claude-agent-sdk": "cd src/wrappers/claude-agent-sdk && pnpm install && pnpm test",
-        "test:all": "pnpm run test:checks && pnpm run test:external",
+        "test:all": "pnpm run test:checks",
         "test:api-compat": "vitest run tests/api-compatibility/api-compatibility.test.ts",
-        "test:anthropic": "vitest run src/wrappers/anthropic.test.ts",
-        "test:openai": "vitest run src/wrappers/oai.test.ts",
         "test:otel": "vitest run --dir src/otel",
         "test:otel-no-deps": "vitest run src/otel/otel-no-deps.test.ts --reporter=verbose",
-        "test:google-genai": "vitest run src/wrappers/google-genai.test.ts",
         "test:ai-sdk-v1": "vitest run src/wrappers/ai-sdk-v1.test.ts",
         "test:ai-sdk-v2": "vitest run src/wrappers/ai-sdk-v2.test.ts src/wrappers/ai-sdk-v1.test.ts",
         "test:ai-sdk-v3": "vitest run src/wrappers/ai-sdk-v3.test.ts",
         "test:zod-v3": "vitest run src/zod/zod-v3-serialization.test.ts",
         "test:zod-v4": "vitest run src/zod/zod-v4-serialization.test.ts",
         "test:mastra": "vitest run src/wrappers/mastra.test.ts",
-        "test:claude-agent-sdk": "pnpm --filter @braintrust/claude-agent-sdk-tests test",
         "test:vitest": "pnpm --filter @braintrust/vitest-wrapper-tests test",
         "test:output": "tsx scripts/test-output.ts --with-comparison --with-metrics --with-progress",
         bench: "tsx src/queue.bench.ts",
@@ -1402,7 +1410,6 @@ var require_package = __commonJS({
         "@types/node": "^20.10.5",
         "@types/pluralize": "^0.0.30",
         "@types/tar": "^6.1.13",
-        "@types/uuid": "^9.0.7",
         "@typescript-eslint/eslint-plugin": "^8.49.0",
         "@typescript-eslint/parser": "^8.49.0",
         ai: "^6.0.0",
@@ -1411,7 +1418,6 @@ var require_package = __commonJS({
         "cross-env": "^7.0.3",
         "eslint-plugin-node-import": "^1.0.5",
         openai: "6.25.0",
-        "openapi-zod-client": "^1.18.3",
         rollup: "^4.60.3",
         tar: "^7.5.2",
         tinybench: "^4.0.1",
@@ -1450,7 +1456,7 @@ var require_package = __commonJS({
         "source-map": "^0.7.4",
         "termi-link": "^1.0.1",
         unplugin: "^2.3.5",
-        uuid: "^9.0.1",
+        uuid: "^11.1.1",
         "zod-to-json-schema": "^3.25.0"
       },
       peerDependencies: {
@@ -1474,7 +1480,7 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 var esbuild = __toESM(require("esbuild"));
-var dotenv2 = __toESM(require("dotenv"));
+var dotenv3 = __toESM(require("dotenv"));
 var import_node_fs2 = __toESM(require("node:fs"));
 var import_node_os = __toESM(require("node:os"));
 var import_node_path5 = __toESM(require("node:path"));
@@ -1573,6 +1579,7 @@ var iso = {
   getRepoInfo: async (_settings) => void 0,
   getPastNAncestors: async () => [],
   getEnv: (_name) => void 0,
+  getBraintrustApiKey: async () => void 0,
   getCallerLocation: () => void 0,
   newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -2405,6 +2412,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,
@@ -2427,6 +2439,7 @@ function mergeDictsWithPathsHelper({
   mergePaths
 }) {
   Object.entries(mergeFrom).forEach(([k, mergeFromV]) => {
+    if (FORBIDDEN_MERGE_KEYS.has(k)) return;
     const fullPath = path8.concat([k]);
     const fullPathSerialized = JSON.stringify(fullPath);
     const mergeIntoV = recordFind(mergeInto, k);
@@ -6490,6 +6503,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(
+            (resolve2) => setTimeout(resolve2, sleepTimeS * 1e3)
+          );
           continue;
         }
         throw e;
@@ -7012,20 +7032,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,
@@ -7354,6 +7361,7 @@ function now() {
 }
 var DEFAULT_FLUSH_BACKPRESSURE_BYTES = 10 * 1024 * 1024;
 var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
+var HTTP_RETRY_BASE_SLEEP_TIME_S = 1;
 var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
   apiConn;
   queue;
@@ -7984,17 +7992,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) {
@@ -8376,6 +8377,55 @@ async function computeLoggerMetadata(state, {
     };
   }
 }
+function initLogger(options = {}) {
+  const {
+    projectName,
+    projectId,
+    asyncFlush: asyncFlushArg,
+    appUrl,
+    apiKey,
+    orgName,
+    forceLogin,
+    debugLogLevel,
+    fetch: fetch2,
+    state: stateArg
+  } = options || {};
+  const asyncFlush = asyncFlushArg === void 0 ? true : asyncFlushArg;
+  const computeMetadataArgs = {
+    project_name: projectName,
+    project_id: projectId
+  };
+  const linkArgs = {
+    org_name: orgName,
+    app_url: appUrl,
+    project_name: projectName,
+    project_id: projectId
+  };
+  const state = stateArg ?? _globalState;
+  state.setDebugLogLevel(debugLogLevel);
+  state.enforceQueueSizeLimit(true);
+  const lazyMetadata = new LazyValue(
+    async () => {
+      await state.login({
+        orgName,
+        apiKey,
+        appUrl,
+        forceLogin,
+        fetch: fetch2
+      });
+      return computeLoggerMetadata(state, computeMetadataArgs);
+    }
+  );
+  const ret = new Logger(state, lazyMetadata, {
+    asyncFlush,
+    computeMetadataArgs,
+    linkArgs
+  });
+  if (options.setCurrent ?? true) {
+    state.currentLogger = ret;
+  }
+  return ret;
+}
 async function login(options = {}) {
   const { forceLogin = false } = options || {};
   if (!_internalGetGlobalState()) {
@@ -8407,10 +8457,11 @@ async function login(options = {}) {
 async function loginToState(options = {}) {
   const {
     appUrl = isomorph_default.getEnv("BRAINTRUST_APP_URL") || "https://www.braintrust.dev",
-    apiKey = isomorph_default.getEnv("BRAINTRUST_API_KEY"),
+    apiKey: apiKeyArg,
     orgName = isomorph_default.getEnv("BRAINTRUST_ORG_NAME"),
     fetch: fetch2 = globalThis.fetch
   } = options || {};
+  const apiKey = apiKeyArg !== void 0 ? apiKeyArg : await isomorph_default.getBraintrustApiKey();
   const appPublicUrl = isomorph_default.getEnv("BRAINTRUST_APP_PUBLIC_URL") || appUrl;
   const state = new BraintrustState(options);
   state.resetLoginInfo();
@@ -9429,9 +9480,15 @@ var SpanImpl = class _SpanImpl {
       const cachedSpan = {
         input: partialRecord.input,
         output: partialRecord.output,
+        expected: partialRecord.expected,
+        error: partialRecord.error,
+        scores: partialRecord.scores,
+        metrics: partialRecord.metrics,
         metadata: partialRecord.metadata,
+        tags: partialRecord.tags,
         span_id: this._spanId,
         span_parents: this._spanParents,
+        is_root: this._spanId === this._rootSpanId,
         span_attributes: partialRecord.span_attributes
       };
       this._state.spanCache.queueWrite(
@@ -9767,6 +9824,7 @@ var Dataset2 = class extends ObjectFetcher {
     metadata,
     tags,
     output,
+    origin,
     isMerge
   }) {
     return new LazyValue(async () => {
@@ -9781,6 +9839,7 @@ var Dataset2 = class extends ObjectFetcher {
         created: !isMerge ? (/* @__PURE__ */ new Date()).toISOString() : void 0,
         //if we're merging/updating an event we will not add this ts
         metadata,
+        origin,
         ...!!isMerge ? {
           [IS_MERGE_FIELD]: true
         } : {}
@@ -9800,6 +9859,7 @@ var Dataset2 = class extends ObjectFetcher {
    * about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the
    * `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any
    * JSON-serializable type, but its keys must be strings.
+   * @param event.origin (Optional) a reference to the source object this dataset record was derived from.
    * @param event.id (Optional) a unique identifier for the event. If you don't provide one, Braintrust will generate one for you.
    * @param event.output: (Deprecated) The output of your application. Use `expected` instead.
    * @returns The `id` of the logged record.
@@ -9810,7 +9870,8 @@ var Dataset2 = class extends ObjectFetcher {
     metadata,
     tags,
     id,
-    output
+    output,
+    origin
   }) {
     this.validateEvent({ metadata, expected, output, tags });
     const rowId = id || (0, import_uuid2.v4)();
@@ -9822,6 +9883,7 @@ var Dataset2 = class extends ObjectFetcher {
         metadata,
         tags,
         output,
+        origin,
         isMerge: false
       })
     );
@@ -11643,8 +11705,12 @@ async function invoke(args) {
 
 // src/trace.ts
 var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
-  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter) {
-    const filterExpr = _SpanFetcher.buildFilter(rootSpanId, spanTypeFilter);
+  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false) {
+    const filterExpr = _SpanFetcher.buildFilter(
+      rootSpanId,
+      spanTypeFilter,
+      includeScorers
+    );
     super(objectType, void 0, void 0, {
       filter: filterExpr
     });
@@ -11653,16 +11719,17 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
     this._state = _state;
     this.spanTypeFilter = spanTypeFilter;
   }
-  static buildFilter(rootSpanId, spanTypeFilter) {
+  static buildFilter(rootSpanId, spanTypeFilter, includeScorers = false) {
     const children = [
       // Base filter: root_span_id = 'value'
       {
         op: "eq",
         left: { op: "ident", name: ["root_span_id"] },
         right: { op: "literal", value: rootSpanId }
-      },
-      // Exclude span_attributes.purpose = 'score'
-      {
+      }
+    ];
+    if (!includeScorers) {
+      children.push({
         op: "or",
         children: [
           {
@@ -11675,8 +11742,8 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
             right: { op: "literal", value: "scorer" }
           }
         ]
-      }
-    ];
+      });
+    }
     if (spanTypeFilter && spanTypeFilter.length > 0) {
       children.push({
         op: "in",
@@ -11702,35 +11769,49 @@ var CachedSpanFetcher = class {
   fetchFn;
   constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {
     if (typeof objectTypeOrFetchFn === "function") {
-      this.fetchFn = objectTypeOrFetchFn;
+      this.fetchFn = (spanType) => objectTypeOrFetchFn(spanType);
     } else {
       const objectType = objectTypeOrFetchFn;
-      this.fetchFn = async (spanType) => {
+      this.fetchFn = async (spanType, includeScorers) => {
         const state = await getState();
         const fetcher = new SpanFetcher(
           objectType,
           objectId,
           rootSpanId,
           state,
-          spanType
+          spanType,
+          includeScorers
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => row.span_attributes?.purpose !== "scorer").map((row) => ({
+        return rows.map((row) => ({
           input: row.input,
           output: row.output,
+          expected: row.expected,
+          error: row.error,
+          scores: row.scores,
+          metrics: row.metrics,
           metadata: row.metadata,
           span_id: row.span_id,
           span_parents: row.span_parents,
+          is_root: row.is_root,
           span_attributes: row.span_attributes,
           id: row.id,
           _xact_id: row._xact_id,
           _pagination_key: row._pagination_key,
-          root_span_id: row.root_span_id
+          root_span_id: row.root_span_id,
+          created: row.created,
+          tags: row.tags
         }));
       };
     }
   }
-  async getSpans({ spanType } = {}) {
+  async getSpans({
+    spanType,
+    includeScorers = false
+  } = {}) {
+    if (includeScorers) {
+      return this.fetchFn(spanType, true);
+    }
     if (this.allFetched) {
       return this.getFromCache(spanType);
     }
@@ -11747,7 +11828,7 @@ var CachedSpanFetcher = class {
     return this.getFromCache(spanType);
   }
   async fetchSpans(spanType) {
-    const spans = await this.fetchFn(spanType);
+    const spans = await this.fetchFn(spanType, false);
     for (const span of spans) {
       const type = span.span_attributes?.type ?? "";
       const existing = this.spanCache.get(type) ?? [];
@@ -11825,10 +11906,13 @@ var LocalTrace = class {
    * First checks the local span cache for recently logged spans, then falls
    * back to CachedSpanFetcher which handles BTQL fetching and caching.
    */
-  async getSpans({ spanType } = {}) {
+  async getSpans({
+    spanType,
+    includeScorers = false
+  } = {}) {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
-      let spans = cachedSpans.filter(
+      let spans = includeScorers ? cachedSpans : cachedSpans.filter(
         (span) => span.span_attributes?.purpose !== "scorer"
       );
       if (spanType && spanType.length > 0) {
@@ -11839,13 +11923,19 @@ var LocalTrace = class {
       return spans.map((span) => ({
         input: span.input,
         output: span.output,
+        expected: span.expected,
+        error: span.error,
+        scores: span.scores,
+        metrics: span.metrics,
         metadata: span.metadata,
         span_id: span.span_id,
         span_parents: span.span_parents,
-        span_attributes: span.span_attributes
+        is_root: span.is_root,
+        span_attributes: span.span_attributes,
+        tags: span.tags
       }));
     }
-    return this.cachedFetcher.getSpans({ spanType });
+    return this.cachedFetcher.getSpans({ spanType, includeScorers });
   }
   /**
    * Get the thread (preprocessed messages) for this trace.
@@ -13290,6 +13380,7 @@ var fsSync = __toESM(require("node:fs"));
 var crypto = __toESM(require("node:crypto"));
 var import_node_util3 = require("node:util");
 var zlib = __toESM(require("node:zlib"));
+var dotenv = __toESM(require("dotenv"));
 
 // src/gitutil.ts
 var import_simple_git = require("simple-git");
@@ -13398,11 +13489,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 = {};
@@ -17099,11 +17190,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((path8) => typeof path8 === "string")) {
     return runtimeDenyOutputPaths;
   }
@@ -20762,6 +20853,467 @@ function cleanMetrics2(metrics) {
   return cleaned;
 }
 
+// src/instrumentation/plugins/openai-agents-channels.ts
+var openAIAgentsCoreChannels = defineChannels("@openai/agents-core", {
+  onTraceStart: channel({
+    channelName: "tracing.processor.onTraceStart",
+    kind: "async"
+  }),
+  onTraceEnd: channel({
+    channelName: "tracing.processor.onTraceEnd",
+    kind: "async"
+  }),
+  onSpanStart: channel({
+    channelName: "tracing.processor.onSpanStart",
+    kind: "async"
+  }),
+  onSpanEnd: channel({
+    channelName: "tracing.processor.onSpanEnd",
+    kind: "async"
+  })
+});
+
+// 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";
+  }
+}
+function getTimeElapsed(end, start) {
+  if (!start || !end) {
+    return void 0;
+  }
+  const startTime = new Date(start).getTime();
+  const endTime = new Date(end).getTime();
+  if (Number.isNaN(startTime) || Number.isNaN(endTime)) {
+    return void 0;
+  }
+  return (endTime - startTime) / 1e3;
+}
+function getNumberProperty2(obj, key) {
+  if (!isObject(obj) || !(key in obj)) {
+    return void 0;
+  }
+  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 || {}
+      }
+    });
+    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-channels.ts
 var googleGenAIChannels = defineChannels("@google/genai", {
   generateContent: channel({
@@ -27054,18 +27606,1726 @@ var GitHubCopilotPlugin = class extends BasePlugin {
   }
 };
 
-// src/instrumentation/braintrust-plugin.ts
-function getIntegrationConfig(integrations, key) {
-  return integrations[key];
+// src/instrumentation/plugins/flue-channels.ts
+var flueChannels = defineChannels("@flue/runtime", {
+  createContext: channel({
+    channelName: "createFlueContext",
+    kind: "sync-stream"
+  }),
+  openSession: channel({
+    channelName: "Harness.openSession",
+    kind: "async"
+  }),
+  contextEvent: channel({
+    channelName: "context.event",
+    kind: "sync-stream"
+  }),
+  prompt: channel({
+    channelName: "session.prompt",
+    kind: "async"
+  }),
+  skill: channel({
+    channelName: "session.skill",
+    kind: "async"
+  }),
+  task: channel({
+    channelName: "session.task",
+    kind: "async"
+  }),
+  compact: channel({
+    channelName: "session.compact",
+    kind: "async"
+  })
+});
+
+// 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 patchFlueContextInPlace(ctx) {
+  const context2 = ctx;
+  if (context2[WRAPPED_FLUE_CONTEXT]) {
+    return ctx;
+  }
+  const originalInit = context2.init.bind(context2);
+  try {
+    Object.defineProperty(context2, WRAPPED_FLUE_CONTEXT, {
+      configurable: false,
+      enumerable: false,
+      value: true
+    });
+    Object.defineProperty(context2, "init", {
+      configurable: true,
+      value: async function wrappedFlueInit(options) {
+        const harness = await originalInit(options);
+        return wrapFlueHarness(harness);
+      },
+      writable: true
+    });
+  } catch {
+  }
+  return ctx;
 }
-var BraintrustPlugin = class extends BasePlugin {
-  config;
-  openaiPlugin = null;
-  openAICodexPlugin = null;
-  anthropicPlugin = null;
-  aiSDKPlugin = null;
-  claudeAgentSDKPlugin = null;
+function subscribeFlueContextEvents(ctx, options = {}) {
+  if (!ctx || typeof ctx !== "object" || typeof ctx.subscribeEvent !== "function") {
+    return void 0;
+  }
+  const context2 = ctx;
+  const captureTurnSpans = options.captureTurnSpans ?? true;
+  const existingSubscription = context2[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(context2, 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, channel2) {
+  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(channel2, {
+        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 context2 = {
+        arguments: [],
+        operation: "compact",
+        session
+      };
+      return flueChannels.compact.tracePromise(() => bound(), context2);
+    },
+    writable: true
+  });
+}
+function traceFlueOperation(channel2, args) {
+  const tracingChannel2 = channel2.tracingChannel();
+  const context2 = args.context;
+  let originalResult;
+  let traced2;
+  const run2 = () => {
+    try {
+      originalResult = args.run();
+      tracingChannel2.end?.publish(context2);
+    } catch (error2) {
+      context2.error = normalizeError3(error2);
+      tracingChannel2.error?.publish(context2);
+      tracingChannel2.end?.publish(context2);
+      throw error2;
+    }
+    traced2 = Promise.resolve(originalResult).then(
+      (result) => {
+        context2.result = result;
+        tracingChannel2.asyncStart?.publish(context2);
+        tracingChannel2.asyncEnd?.publish(context2);
+        return result;
+      },
+      (error2) => {
+        context2.error = normalizeError3(error2);
+        tracingChannel2.error?.publish(context2);
+        tracingChannel2.asyncStart?.publish(context2);
+        tracingChannel2.asyncEnd?.publish(context2);
+        throw error2;
+      }
+    );
+  };
+  if (tracingChannel2.start?.runStores) {
+    tracingChannel2.start.runStores(context2, run2);
+  } else {
+    tracingChannel2.start?.publish(context2);
+    run2();
+  }
+  return { originalResult, traced: traced2 };
+}
+function normalizeError3(error2) {
+  return error2 instanceof Error ? error2 : new Error(String(error2));
+}
+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 isPlausibleFlueHarness(value) {
+  return !!value && typeof value === "object" && typeof value.session === "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 channel2 = flueChannels.createContext.tracingChannel();
+    const handlers = {
+      end: (event) => {
+        const ctx = event.result;
+        if (!ctx) {
+          return;
+        }
+        subscribeFlueContextEvents(ctx, { captureTurnSpans: false });
+        patchFlueContextInPlace(ctx);
+      },
+      error: () => {
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToSessionCreation() {
+    const channel2 = flueChannels.openSession.tracingChannel();
+    const handlers = {
+      asyncEnd: (event) => {
+        if (event.result) {
+          patchFlueSessionInPlace(
+            event.result
+          );
+        }
+        if (event.harness) {
+          wrapFlueHarness(event.harness);
+        }
+      },
+      error: () => {
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToSessionOperations() {
+    this.subscribeToSessionOperation(flueChannels.prompt);
+    this.subscribeToSessionOperation(flueChannels.skill);
+    this.subscribeToSessionOperation(flueChannels.task);
+    this.subscribeToCompact();
+  }
+  subscribeToSessionOperation(channel2) {
+    const tracingChannel2 = channel2.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 channel2 = flueChannels.contextEvent.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        const flueEvent = event.arguments[0];
+        if (!flueEvent) {
+          return;
+        }
+        try {
+          this.handleFlueEvent(flueEvent, {
+            captureTurnSpans: event.captureTurnSpans !== false
+          });
+        } catch (error2) {
+          logInstrumentationError3("Flue event", error2);
+        }
+      },
+      error: () => {
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel2.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 (error2) {
+    logInstrumentationError3("Flue span log", error2);
+  }
+}
+function errorToString(error2) {
+  if (error2 instanceof Error) {
+    return error2.message;
+  }
+  if (typeof error2 === "string") {
+    return error2;
+  }
+  try {
+    return JSON.stringify(error2);
+  } catch {
+    return String(error2);
+  }
+}
+function logInstrumentationError3(label, error2) {
+  console.error(`Error in ${label} instrumentation:`, error2);
+}
+
+// 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
+      }
+    });
+  }
+  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);
+      }
+    }
+  }
+};
+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;
+      }
+      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 getModelNameFromResponse(response) {
+  for (const generation of walkGenerations(response)) {
+    const message = generation.message;
+    if (!isRecord(message)) {
+      continue;
+    }
+    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 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
+    });
+  }
+  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 safeJsonParse(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return input;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/instrumentation/plugins/langchain-channels.ts
+var langChainChannels = defineChannels("@langchain/core", {
+  configure: channel({
+    channelName: "CallbackManager.configure",
+    kind: "sync-stream"
+  }),
+  configureSync: channel({
+    channelName: "CallbackManager._configureSync",
+    kind: "sync-stream"
+  })
+});
+
+// src/instrumentation/plugins/langchain-plugin.ts
+var LangChainPlugin = class extends BasePlugin {
+  injectedManagers = /* @__PURE__ */ new WeakSet();
+  onEnable() {
+    this.subscribeToConfigure(langChainChannels.configure);
+    this.subscribeToConfigure(langChainChannels.configureSync);
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    this.injectedManagers = /* @__PURE__ */ new WeakSet();
+  }
+  subscribeToConfigure(channel2) {
+    const tracingChannel2 = channel2.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) {
+  return integrations[key];
+}
+var BraintrustPlugin = class extends BasePlugin {
+  config;
+  openaiPlugin = null;
+  openAICodexPlugin = null;
+  anthropicPlugin = null;
+  aiSDKPlugin = null;
+  claudeAgentSDKPlugin = null;
   cursorSDKPlugin = null;
+  openAIAgentsPlugin = null;
   googleGenAIPlugin = null;
   huggingFacePlugin = null;
   openRouterPlugin = null;
@@ -27076,6 +29336,8 @@ var BraintrustPlugin = class extends BasePlugin {
   groqPlugin = null;
   genkitPlugin = null;
   gitHubCopilotPlugin = null;
+  fluePlugin = null;
+  langChainPlugin = null;
   constructor(config3 = {}) {
     super();
     this.config = config3;
@@ -27106,6 +29368,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();
@@ -27146,6 +29412,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) {
@@ -27172,6 +29446,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;
@@ -27212,9 +29490,104 @@ 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;
+    }
   }
 };
 
+// src/instrumentation/config.ts
+var envIntegrationAliases = {
+  openai: "openai",
+  "openai-codex": "openaiCodexSDK",
+  "openai-codex-sdk": "openaiCodexSDK",
+  openaicodexsdk: "openaiCodexSDK",
+  codex: "openaiCodexSDK",
+  "codex-sdk": "openaiCodexSDK",
+  anthropic: "anthropic",
+  aisdk: "aisdk",
+  "ai-sdk": "aisdk",
+  "vercel-ai": "aisdk",
+  vercel: "vercel",
+  claudeagentsdk: "claudeAgentSDK",
+  "claude-agent-sdk": "claudeAgentSDK",
+  cursor: "cursor",
+  "cursor-sdk": "cursorSDK",
+  cursorsdk: "cursorSDK",
+  flue: "flue",
+  "flue-runtime": "flue",
+  "openai-agents": "openAIAgents",
+  openaiagents: "openAIAgents",
+  "openai-agents-core": "openAIAgents",
+  openaiagentscore: "openAIAgents",
+  google: "google",
+  "google-genai": "googleGenAI",
+  googlegenai: "googleGenAI",
+  huggingface: "huggingface",
+  openrouter: "openrouter",
+  openrouteragent: "openrouterAgent",
+  "openrouter-agent": "openrouterAgent",
+  mistral: "mistral",
+  googleadk: "googleADK",
+  "google-adk": "googleADK",
+  cohere: "cohere",
+  groq: "groq",
+  "groq-sdk": "groq",
+  genkit: "genkit",
+  "firebase-genkit": "genkit",
+  githubcopilot: "gitHubCopilot",
+  "github-copilot": "gitHubCopilot",
+  "copilot-sdk": "gitHubCopilot",
+  langchain: "langchain",
+  "langchain-js": "langchain",
+  "@langchain": "langchain",
+  langgraph: "langgraph"
+};
+function getDefaultInstrumentationIntegrations() {
+  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,
+    flue: true,
+    openAIAgents: true,
+    openrouter: true,
+    openrouterAgent: true,
+    mistral: true,
+    cohere: true,
+    groq: true,
+    genkit: true,
+    gitHubCopilot: true,
+    langchain: true,
+    langgraph: true
+  };
+}
+function readDisabledInstrumentationEnvConfig(disabledList) {
+  const integrations = {};
+  if (disabledList) {
+    for (const value of disabledList.split(",")) {
+      const sdk = value.trim().toLowerCase();
+      if (sdk.length > 0) {
+        integrations[envIntegrationAliases[sdk] ?? sdk] = false;
+      }
+    }
+  }
+  return { integrations };
+}
+
 // src/instrumentation/registry.ts
 var REGISTRY_STATE_KEY = /* @__PURE__ */ Symbol.for("braintrust.registry");
 function getSharedState() {
@@ -27293,60 +29666,75 @@ 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();
 
 // src/node/config.ts
+var BRAINTRUST_ENV_SEARCH_PARENT_LIMIT = 64;
 function configureNode() {
   isomorph_default.buildType = "node";
   isomorph_default.getRepoInfo = getRepoInfo;
   isomorph_default.getPastNAncestors = getPastNAncestors;
-  isomorph_default.getEnv = (name) => process.env[name];
+  isomorph_default.getEnv = (name) => {
+    const value = process.env[name];
+    return name === "BRAINTRUST_API_KEY" && !value?.trim() ? void 0 : value;
+  };
+  isomorph_default.getBraintrustApiKey = async () => {
+    const value = process.env.BRAINTRUST_API_KEY;
+    if (value?.trim()) {
+      return value;
+    }
+    const envPaths = [];
+    for (let dir2 = process.cwd(), depth = 0; depth <= BRAINTRUST_ENV_SEARCH_PARENT_LIMIT; dir2 = path.dirname(dir2), depth++) {
+      envPaths.push(path.join(dir2, ".env.braintrust"));
+      if (path.dirname(dir2) === dir2) {
+        break;
+      }
+    }
+    const pending = /* @__PURE__ */ new Map();
+    envPaths.forEach((envPath, index) => {
+      pending.set(
+        index,
+        fs.readFile(envPath, "utf8").then(
+          (contents) => ({ contents, envPath, index }),
+          (error2) => ({ error: error2, envPath, index })
+        )
+      );
+    });
+    const results = [];
+    let nearestUnresolvedIndex = 0;
+    while (pending.size > 0) {
+      const result = await Promise.race(pending.values());
+      pending.delete(result.index);
+      results[result.index] = result;
+      while (results[nearestUnresolvedIndex]) {
+        const nearestResult = results[nearestUnresolvedIndex];
+        if ("contents" in nearestResult) {
+          const parsed = dotenv.parse(nearestResult.contents);
+          const apiKey = parsed.BRAINTRUST_API_KEY;
+          return apiKey?.trim() ? apiKey : void 0;
+        }
+        const e = nearestResult.error;
+        if (typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT") {
+          nearestUnresolvedIndex++;
+          continue;
+        }
+        return void 0;
+      }
+    }
+    return void 0;
+  };
   isomorph_default.getCallerLocation = getCallerLocation;
   isomorph_default.newAsyncLocalStorage = () => new import_node_async_hooks.AsyncLocalStorage();
   isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
@@ -28506,7 +30894,7 @@ async function buildBundledFunctionEntry({
 
 // src/cli/util/bundle.ts
 var import_env = require("@next/env");
-var dotenv = __toESM(require("dotenv"));
+var dotenv2 = __toESM(require("dotenv"));
 
 // src/cli/util/debug-logging.ts
 var VERBOSE_DEPRECATION_MESSAGE = "--verbose is deprecated and will be removed in a future version of braintrust. Use --debug-logging debug to see full stack traces and troubleshooting details.";
@@ -28533,7 +30921,7 @@ async function loadCLIEnv(args) {
   normalizeDebugLoggingArgs(args);
   (0, import_env.loadEnvConfig)(process.cwd(), true);
   if (args.env_file) {
-    const loaded = dotenv.config({ path: args.env_file });
+    const loaded = dotenv2.config({ path: args.env_file });
     if (loaded.error) {
       console.error(error(`Error loading ${args.env_file}: ${loaded.error}`));
       process.exit(1);
@@ -30084,7 +32472,7 @@ async function run(args) {
   normalizeDebugLoggingArgs(args);
   (0, import_env2.loadEnvConfig)(process.cwd(), true);
   if (args.env_file) {
-    const loaded = dotenv2.config({ path: args.env_file });
+    const loaded = dotenv3.config({ path: args.env_file });
     if (loaded.error) {
       console.error(error(`Error loading ${args.env_file}: ${loaded.error}`));
       process.exit(1);
@@ -30162,7 +32550,7 @@ async function run(args) {
 }
 function addAuthArgs(parser) {
   parser.add_argument("--api-key", {
-    help: "Specify a braintrust api key. If the parameter is not specified, the BRAINTRUST_API_KEY environment variable will be used."
+    help: "Specify a braintrust api key. If the parameter is not specified, BRAINTRUST_API_KEY or the nearest .env.braintrust file will be used."
   });
   parser.add_argument("--org-name", {
     help: "The name of a specific organization to connect to. This is useful if you belong to multiple."