braintrust 3.11.0 → 3.13.0

package/dev/dist/index.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27;// src/node/config.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28; var _class29; var _class30; var _class31; var _class32;// src/node/config.ts
 var _nodeasync_hooks = require('node:async_hooks');
 var _nodediagnostics_channel = require('node:diagnostics_channel'); var diagnostics_channel = _interopRequireWildcard(_nodediagnostics_channel);
 var _nodepath = require('node:path'); var path = _interopRequireWildcard(_nodepath);
@@ -96,6 +96,7 @@ var _nodefs = require('node:fs'); var fsSync = _interopRequireWildcard(_nodefs);
 var _nodecrypto = require('node:crypto'); var crypto = _interopRequireWildcard(_nodecrypto);
 var _nodeutil = require('node:util');
 var _nodezlib = require('node:zlib'); var zlib = _interopRequireWildcard(_nodezlib);
+var _dotenv = require('dotenv'); var dotenv = _interopRequireWildcard(_dotenv);
 
 // src/isomorph.ts
 var DefaultAsyncLocalStorage = class {
@@ -182,6 +183,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
@@ -406,11 +408,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 = {};
@@ -1228,6 +1230,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,
@@ -1250,6 +1257,7 @@ function mergeDictsWithPathsHelper({
   mergePaths
 }) {
   Object.entries(mergeFrom).forEach(([k, mergeFromV]) => {
+    if (FORBIDDEN_MERGE_KEYS.has(k)) return;
     const fullPath = path2.concat([k]);
     const fullPathSerialized = JSON.stringify(fullPath);
     const mergeIntoV = recordFind(mergeInto, k);
@@ -5306,6 +5314,13 @@ var HTTPConnection = class _HTTPConnection {
           debugLogger.debug(
             `Retrying API request ${object_type} ${JSON.stringify(args)} ${e.status} ${e.text}`
           );
+          const sleepTimeS = HTTP_RETRY_BASE_SLEEP_TIME_S * 2 ** i;
+          debugLogger.info(
+            `Sleeping for ${sleepTimeS}s before retrying API request`
+          );
+          await new Promise(
+            (resolve) => setTimeout(resolve, sleepTimeS * 1e3)
+          );
           continue;
         }
         throw e;
@@ -5828,20 +5843,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,
@@ -6170,6 +6172,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 = (_class10 = class _HTTPBackgroundLogger {
   
   
@@ -6800,17 +6803,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 ? _nullishCoalesce(gitMetadataSettings, () => ( { collect: "none" })) : mergeGitMetadataSettings(
+          state.gitMetadataSettings,
+          _nullishCoalesce(gitMetadataSettings, () => ( { collect: "all" }))
+        );
         return await isomorph_default.getRepoInfo(mergedGitMetadataSettings);
       })();
       if (repoInfoArg) {
@@ -7192,6 +7188,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 = _nullishCoalesce(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 (_nullishCoalesce(options.setCurrent, () => ( true))) {
+    state.currentLogger = ret;
+  }
+  return ret;
+}
 async function login(options = {}) {
   const { forceLogin = false } = options || {};
   if (!_internalGetGlobalState()) {
@@ -7223,10 +7268,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();
@@ -8245,9 +8291,15 @@ var SpanImpl = (_class13 = 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(
@@ -8583,6 +8635,7 @@ var Dataset2 = (_class14 = class extends ObjectFetcher {
     metadata,
     tags,
     output,
+    origin,
     isMerge
   }) {
     return new LazyValue(async () => {
@@ -8597,6 +8650,7 @@ var Dataset2 = (_class14 = 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
         } : {}
@@ -8616,6 +8670,7 @@ var Dataset2 = (_class14 = 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.
@@ -8626,7 +8681,8 @@ var Dataset2 = (_class14 = class extends ObjectFetcher {
     metadata,
     tags,
     id,
-    output
+    output,
+    origin
   }) {
     this.validateEvent({ metadata, expected, output, tags });
     const rowId = id || _uuid.v4.call(void 0, );
@@ -8638,6 +8694,7 @@ var Dataset2 = (_class14 = class extends ObjectFetcher {
         metadata,
         tags,
         output,
+        origin,
         isMerge: false
       })
     );
@@ -12877,11 +12934,11 @@ function resolveDenyOutputPaths(event, defaultDenyOutputPaths) {
   if (Array.isArray(_optionalChain([event, 'optionalAccess', _212 => _212.denyOutputPaths]))) {
     return event.denyOutputPaths;
   }
-  const firstArgument = _optionalChain([event, 'optionalAccess', _213 => _213.arguments]) && event.arguments.length > 0 ? event.arguments[0] : void 0;
-  if (!firstArgument || typeof firstArgument !== "object") {
+  const firstArgument2 = _optionalChain([event, 'optionalAccess', _213 => _213.arguments]) && event.arguments.length > 0 ? event.arguments[0] : void 0;
+  if (!firstArgument2 || typeof firstArgument2 !== "object") {
     return defaultDenyOutputPaths;
   }
-  const runtimeDenyOutputPaths = firstArgument[RUNTIME_DENY_OUTPUT_PATHS];
+  const runtimeDenyOutputPaths = firstArgument2[RUNTIME_DENY_OUTPUT_PATHS];
   if (Array.isArray(runtimeDenyOutputPaths) && runtimeDenyOutputPaths.every((path2) => typeof path2 === "string")) {
     return runtimeDenyOutputPaths;
   }
@@ -16540,6 +16597,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 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(getNumberProperty2(usage, "prompt_tokens"), () => ( getNumberProperty2(usage, "input_tokens"))), () => ( getNumberProperty2(usage, "promptTokens"))), () => ( getNumberProperty2(usage, "inputTokens")));
+  const completionTokens = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(getNumberProperty2(usage, "completion_tokens"), () => ( getNumberProperty2(usage, "output_tokens"))), () => ( getNumberProperty2(usage, "completionTokens"))), () => ( getNumberProperty2(usage, "outputTokens")));
+  const totalTokens = _nullishCoalesce(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 = (_class19 = class _OpenAIAgentsTraceProcessor {
+  static __initStatic() {this.DEFAULT_MAX_TRACES = 1e4}
+  
+  
+  __init65() {this.traceSpans = /* @__PURE__ */ new Map()}
+  __init66() {this.traceOrder = []}
+  __init67() {this._traceSpans = this.traceSpans}
+  constructor(options = {}) {;_class19.prototype.__init65.call(this);_class19.prototype.__init66.call(this);_class19.prototype.__init67.call(this);
+    this.logger = options.logger;
+    this.maxTraces = _nullishCoalesce(options.maxTraces, () => ( _OpenAIAgentsTraceProcessor.DEFAULT_MAX_TRACES));
+  }
+  evictOldestTrace() {
+    const oldestTraceId = this.traceOrder.shift();
+    if (oldestTraceId) {
+      this.traceSpans.delete(oldestTraceId);
+    }
+  }
+  onTraceStart(trace) {
+    if (!_optionalChain([trace, 'optionalAccess', _368 => _368.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(_optionalChain([trace, 'optionalAccess', _369 => _369.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 (!_optionalChain([span, 'optionalAccess', _370 => _370.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 (!_optionalChain([span, 'optionalAccess', _371 => _371.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(
+      _nullishCoalesce(span.endedAt, () => ( void 0)),
+      _nullishCoalesce(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;
+  }
+}, _class19.__initStatic(), _class19);
+
+// 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 = (_class20 = class extends BasePlugin {constructor(...args4) { super(...args4); _class20.prototype.__init68.call(this); }
+  __init68() {this.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));
+  }
+}, _class20);
+
 // src/instrumentation/plugins/google-genai-channels.ts
 var googleGenAIChannels = defineChannels("@google/genai", {
   generateContent: channel({
@@ -16651,7 +17169,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
     };
     tracingChannel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _368 => _368()]);
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _372 => _372()]);
       tracingChannel2.unsubscribe(handlers);
     });
   }
@@ -16748,7 +17266,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
     };
     tracingChannel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _369 => _369()]);
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _373 => _373()]);
       tracingChannel2.unsubscribe(handlers);
     });
   }
@@ -16764,10 +17282,10 @@ function ensureSpanState(states, event, create) {
 }
 function bindCurrentSpanStoreToStart2(tracingChannel2, states, create) {
   const state = _internalGetGlobalState();
-  const contextManager = _optionalChain([state, 'optionalAccess', _370 => _370.contextManager]);
+  const contextManager = _optionalChain([state, 'optionalAccess', _374 => _374.contextManager]);
   const startChannel = tracingChannel2.start;
   const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
-  if (!_optionalChain([startChannel, 'optionalAccess', _371 => _371.bindStore]) || !currentSpanStore) {
+  if (!_optionalChain([startChannel, 'optionalAccess', _375 => _375.bindStore]) || !currentSpanStore) {
     return void 0;
   }
   startChannel.bindStore(currentSpanStore, (event) => {
@@ -16779,7 +17297,7 @@ function bindCurrentSpanStoreToStart2(tracingChannel2, states, create) {
     return contextManager.wrapSpanForStore(span);
   });
   return () => {
-    _optionalChain([startChannel, 'access', _372 => _372.unbindStore, 'optionalCall', _373 => _373(currentSpanStore)]);
+    _optionalChain([startChannel, 'access', _376 => _376.unbindStore, 'optionalCall', _377 => _377(currentSpanStore)]);
   };
 }
 function logErrorAndEndSpan(states, event) {
@@ -17014,7 +17532,7 @@ function serializePart(part) {
 }
 function serializeGenerateContentTools(params) {
   const config = params.config ? tryToDict(params.config) : null;
-  const tools = _optionalChain([config, 'optionalAccess', _374 => _374.tools]);
+  const tools = _optionalChain([config, 'optionalAccess', _378 => _378.tools]);
   if (!Array.isArray(tools)) {
     return null;
   }
@@ -17073,7 +17591,7 @@ function extractGenerateContentMetrics(response, startTime) {
     metrics.end = end;
     metrics.duration = end - startTime;
   }
-  if (_optionalChain([response, 'optionalAccess', _375 => _375.usageMetadata])) {
+  if (_optionalChain([response, 'optionalAccess', _379 => _379.usageMetadata])) {
     populateUsageMetrics(metrics, response.usageMetadata);
   }
   return metrics;
@@ -17086,7 +17604,7 @@ function extractEmbedContentMetrics(response, startTime) {
     metrics.end = end;
     metrics.duration = end - startTime;
   }
-  if (_optionalChain([response, 'optionalAccess', _376 => _376.usageMetadata])) {
+  if (_optionalChain([response, 'optionalAccess', _380 => _380.usageMetadata])) {
     populateUsageMetrics(metrics, response.usageMetadata);
   }
   const embeddingTokenCount = extractEmbedPromptTokenCount(response);
@@ -17100,11 +17618,11 @@ function extractEmbedPromptTokenCount(response) {
   if (!response) {
     return void 0;
   }
-  const usagePromptTokens = _optionalChain([response, 'access', _377 => _377.usageMetadata, 'optionalAccess', _378 => _378.promptTokenCount]);
+  const usagePromptTokens = _optionalChain([response, 'access', _381 => _381.usageMetadata, 'optionalAccess', _382 => _382.promptTokenCount]);
   if (typeof usagePromptTokens === "number" && Number.isFinite(usagePromptTokens)) {
     return usagePromptTokens;
   }
-  const usageTotalTokens = _optionalChain([response, 'access', _379 => _379.usageMetadata, 'optionalAccess', _380 => _380.totalTokenCount]);
+  const usageTotalTokens = _optionalChain([response, 'access', _383 => _383.usageMetadata, 'optionalAccess', _384 => _384.totalTokenCount]);
   if (typeof usageTotalTokens === "number" && Number.isFinite(usageTotalTokens)) {
     return usageTotalTokens;
   }
@@ -17115,8 +17633,8 @@ function extractEmbedPromptTokenCount(response) {
   let total = 0;
   let sawAny = false;
   for (const embedding of embeddings) {
-    const embeddingStats = tryToDict(_optionalChain([tryToDict, 'call', _381 => _381(embedding), 'optionalAccess', _382 => _382.statistics]));
-    const tokenCount = _optionalChain([embeddingStats, 'optionalAccess', _383 => _383.tokenCount]);
+    const embeddingStats = tryToDict(_optionalChain([tryToDict, 'call', _385 => _385(embedding), 'optionalAccess', _386 => _386.statistics]));
+    const tokenCount = _optionalChain([embeddingStats, 'optionalAccess', _387 => _387.tokenCount]);
     if (typeof tokenCount === "number" && Number.isFinite(tokenCount)) {
       total += tokenCount;
       sawAny = true;
@@ -17132,7 +17650,7 @@ function summarizeEmbedContentOutput(response) {
   if (embeddings.length === 0) {
     return void 0;
   }
-  const firstValues = _optionalChain([embeddings, 'access', _384 => _384[0], 'optionalAccess', _385 => _385.values]);
+  const firstValues = _optionalChain([embeddings, 'access', _388 => _388[0], 'optionalAccess', _389 => _389.values]);
   if (!Array.isArray(firstValues)) {
     return void 0;
   }
@@ -17187,7 +17705,7 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _386 => _386.content, 'optionalAccess', _387 => _387.parts])) {
+        if (_optionalChain([candidate, 'access', _390 => _390.content, 'optionalAccess', _391 => _391.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -17218,7 +17736,7 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _388 => _388.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _392 => _392.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -17275,7 +17793,7 @@ function extractResponseMetadata(response) {
   if (Array.isArray(responseDict.candidates)) {
     for (const candidate of responseDict.candidates) {
       const candidateDict = tryToDict(candidate);
-      if (_optionalChain([candidateDict, 'optionalAccess', _389 => _389.groundingMetadata]) !== void 0) {
+      if (_optionalChain([candidateDict, 'optionalAccess', _393 => _393.groundingMetadata]) !== void 0) {
         candidateGroundingMetadata.push(candidateDict.groundingMetadata);
       }
     }
@@ -17356,9 +17874,9 @@ var HuggingFacePlugin = class extends BasePlugin {
         name: "huggingface.chat_completion",
         type: "llm" /* LLM */,
         extractInput: extractChatInputWithMetadata,
-        extractOutput: (result) => _optionalChain([result, 'optionalAccess', _390 => _390.choices]),
+        extractOutput: (result) => _optionalChain([result, 'optionalAccess', _394 => _394.choices]),
         extractMetadata: (result) => extractResponseMetadata2(result),
-        extractMetrics: (result) => parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _391 => _391.usage]))
+        extractMetrics: (result) => parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _395 => _395.usage]))
       }),
       traceSyncStreamChannel(huggingFaceChannels.chatCompletionStream, {
         name: "huggingface.chat_completion_stream",
@@ -17376,7 +17894,7 @@ var HuggingFacePlugin = class extends BasePlugin {
         extractInput: extractTextGenerationInputWithMetadata,
         extractOutput: (result) => isObject(result) ? { generated_text: result.generated_text } : result,
         extractMetadata: extractTextGenerationMetadata,
-        extractMetrics: (result) => extractTextGenerationMetrics(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _392 => _392.details]), () => ( null)))
+        extractMetrics: (result) => extractTextGenerationMetrics(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _396 => _396.details]), () => ( null)))
       }),
       traceSyncStreamChannel(huggingFaceChannels.textGenerationStream, {
         name: "huggingface.text_generation_stream",
@@ -17495,7 +18013,7 @@ function extractTextGenerationMetrics(details) {
   return metrics;
 }
 function extractTextGenerationMetadata(result) {
-  if (!isObject(_optionalChain([result, 'optionalAccess', _393 => _393.details]))) {
+  if (!isObject(_optionalChain([result, 'optionalAccess', _397 => _397.details]))) {
     return void 0;
   }
   return typeof result.details.finish_reason === "string" ? {
@@ -17541,7 +18059,7 @@ function patchChatCompletionStream(args) {
       const lastChunk = chunks.at(-1);
       const responseMetadata = extractResponseMetadata2(lastChunk);
       const metrics = {
-        ...parseMetricsFromUsage(_optionalChain([lastChunk, 'optionalAccess', _394 => _394.usage])),
+        ...parseMetricsFromUsage(_optionalChain([lastChunk, 'optionalAccess', _398 => _398.usage])),
         ...firstChunkTime !== void 0 ? { time_to_first_token: firstChunkTime - startTime } : {}
       };
       span.log({
@@ -17579,8 +18097,8 @@ function patchTextGenerationStream(args) {
         output: aggregateTextGenerationStreamChunks(chunks),
         ...streamMetadata ? { metadata: streamMetadata } : {},
         metrics: {
-          ...extractTextGenerationMetrics(_nullishCoalesce(_optionalChain([lastChunk, 'optionalAccess', _395 => _395.details]), () => ( null))),
-          ...parseMetricsFromUsage(_optionalChain([lastChunk, 'optionalAccess', _396 => _396.usage])),
+          ...extractTextGenerationMetrics(_nullishCoalesce(_optionalChain([lastChunk, 'optionalAccess', _399 => _399.details]), () => ( null))),
+          ...parseMetricsFromUsage(_optionalChain([lastChunk, 'optionalAccess', _400 => _400.usage])),
           ...firstChunkTime !== void 0 ? { time_to_first_token: firstChunkTime - startTime } : {}
         }
       });
@@ -17609,14 +18127,14 @@ function aggregateChatCompletionChunks2(chunks) {
       }));
       const delta = isObject(choice.delta) ? choice.delta : void 0;
       const message = isObject(choice.message) ? choice.message : void 0;
-      if (typeof _optionalChain([delta, 'optionalAccess', _397 => _397.content]) === "string") {
+      if (typeof _optionalChain([delta, 'optionalAccess', _401 => _401.content]) === "string") {
         existing.content += delta.content;
-      } else if (typeof _optionalChain([message, 'optionalAccess', _398 => _398.content]) === "string") {
+      } else if (typeof _optionalChain([message, 'optionalAccess', _402 => _402.content]) === "string") {
         existing.content = message.content;
       }
-      if (typeof _optionalChain([delta, 'optionalAccess', _399 => _399.role]) === "string") {
+      if (typeof _optionalChain([delta, 'optionalAccess', _403 => _403.role]) === "string") {
         existing.role = delta.role;
-      } else if (typeof _optionalChain([message, 'optionalAccess', _400 => _400.role]) === "string") {
+      } else if (typeof _optionalChain([message, 'optionalAccess', _404 => _404.role]) === "string") {
         existing.role = message.role;
       }
       if (choice.finish_reason !== void 0) {
@@ -17644,7 +18162,7 @@ function aggregateChatCompletionChunks2(chunks) {
   };
 }
 function getChatToolCallDeltas(value) {
-  if (!Array.isArray(_optionalChain([value, 'optionalAccess', _401 => _401.tool_calls]))) {
+  if (!Array.isArray(_optionalChain([value, 'optionalAccess', _405 => _405.tool_calls]))) {
     return void 0;
   }
   const toolCalls = value.tool_calls.filter((toolCall) => isObject(toolCall));
@@ -17709,7 +18227,7 @@ function aggregateTextGenerationStreamChunks(chunks) {
   for (const chunk of chunks) {
     if (typeof chunk.generated_text === "string") {
       generatedText = chunk.generated_text;
-    } else if (typeof _optionalChain([chunk, 'access', _402 => _402.token, 'optionalAccess', _403 => _403.text]) === "string" && !chunk.token.special) {
+    } else if (typeof _optionalChain([chunk, 'access', _406 => _406.token, 'optionalAccess', _407 => _407.text]) === "string" && !chunk.token.special) {
       generatedText += chunk.token.text;
     } else if (Array.isArray(chunk.choices)) {
       for (const choice of chunk.choices) {
@@ -17733,17 +18251,17 @@ function aggregateTextGenerationStreamChunks(chunks) {
 function extractTextGenerationStreamMetadata(chunks) {
   for (let index = chunks.length - 1; index >= 0; index--) {
     const chunk = chunks[index];
-    if (isObject(_optionalChain([chunk, 'optionalAccess', _404 => _404.details])) && typeof chunk.details.finish_reason === "string") {
+    if (isObject(_optionalChain([chunk, 'optionalAccess', _408 => _408.details])) && typeof chunk.details.finish_reason === "string") {
       return {
         finish_reason: chunk.details.finish_reason
       };
     }
-    if (!Array.isArray(_optionalChain([chunk, 'optionalAccess', _405 => _405.choices]))) {
+    if (!Array.isArray(_optionalChain([chunk, 'optionalAccess', _409 => _409.choices]))) {
       continue;
     }
     for (let choiceIndex = chunk.choices.length - 1; choiceIndex >= 0; choiceIndex--) {
       const choice = chunk.choices[choiceIndex];
-      if (_optionalChain([choice, 'optionalAccess', _406 => _406.finish_reason]) !== void 0) {
+      if (_optionalChain([choice, 'optionalAccess', _410 => _410.finish_reason]) !== void 0) {
         return { finish_reason: choice.finish_reason };
       }
     }
@@ -17819,14 +18337,14 @@ var OpenRouterAgentPlugin = class extends BasePlugin {
         extractMetadata: (result, event) => {
           if (!isObject(result)) {
             return {
-              step: _optionalChain([event, 'optionalAccess', _407 => _407.step]),
-              step_type: _optionalChain([event, 'optionalAccess', _408 => _408.stepType])
+              step: _optionalChain([event, 'optionalAccess', _411 => _411.step]),
+              step_type: _optionalChain([event, 'optionalAccess', _412 => _412.stepType])
             };
           }
           return {
             ...extractOpenRouterResponseMetadata(result) || {},
-            ..._optionalChain([event, 'optionalAccess', _409 => _409.step]) !== void 0 ? { step: event.step } : {},
-            ..._optionalChain([event, 'optionalAccess', _410 => _410.stepType]) ? { step_type: event.stepType } : {}
+            ..._optionalChain([event, 'optionalAccess', _413 => _413.step]) !== void 0 ? { step: event.step } : {},
+            ..._optionalChain([event, 'optionalAccess', _414 => _414.stepType]) ? { step_type: event.stepType } : {}
           };
         },
         extractMetrics: (result) => isObject(result) ? parseOpenRouterMetricsFromUsage(result.usage) : {}
@@ -18187,7 +18705,7 @@ function publishToolResult(tracingChannel2, event, result) {
 }
 function getToolCallId(context) {
   const toolContext = context;
-  return typeof _optionalChain([toolContext, 'optionalAccess', _411 => _411.toolCall, 'optionalAccess', _412 => _412.id]) === "string" ? toolContext.toolCall.id : void 0;
+  return typeof _optionalChain([toolContext, 'optionalAccess', _415 => _415.toolCall, 'optionalAccess', _416 => _416.id]) === "string" ? toolContext.toolCall.id : void 0;
 }
 var OPENROUTER_WRAPPED_CALL_MODEL_RESULT = /* @__PURE__ */ Symbol(
   "braintrust.openrouter.wrappedCallModelResult"
@@ -18585,9 +19103,9 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _413 => _413.chatGenerationParams])) ? request.chatGenerationParams : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _414 => _414.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _415 => _415.xTitle]);
+          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _417 => _417.chatGenerationParams])) ? request.chatGenerationParams : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _418 => _418.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _419 => _419.xTitle]);
           const { messages, ...metadata } = chatGenerationParams;
           return {
             input: messages,
@@ -18598,7 +19116,7 @@ var OpenRouterPlugin = class extends BasePlugin {
           return isObject(result) ? result.choices : void 0;
         },
         extractMetrics: (result, startTime) => {
-          const metrics = parseOpenRouterMetricsFromUsage2(_optionalChain([result, 'optionalAccess', _416 => _416.usage]));
+          const metrics = parseOpenRouterMetricsFromUsage2(_optionalChain([result, 'optionalAccess', _420 => _420.usage]));
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
@@ -18613,9 +19131,9 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _417 => _417.requestBody])) ? request.requestBody : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _418 => _418.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _419 => _419.xTitle]);
+          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _421 => _421.requestBody])) ? request.requestBody : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _422 => _422.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _423 => _423.xTitle]);
           const { input, ...metadata } = requestBody;
           return {
             input,
@@ -18630,7 +19148,7 @@ var OpenRouterPlugin = class extends BasePlugin {
           if (!isObject(result)) {
             return void 0;
           }
-          const embedding = _optionalChain([result, 'access', _420 => _420.data, 'optionalAccess', _421 => _421[0], 'optionalAccess', _422 => _422.embedding]);
+          const embedding = _optionalChain([result, 'access', _424 => _424.data, 'optionalAccess', _425 => _425[0], 'optionalAccess', _426 => _426.embedding]);
           return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
         },
         extractMetadata: (result) => {
@@ -18650,9 +19168,9 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _423 => _423.requestBody])) ? request.requestBody : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _424 => _424.httpReferer]);
-          const xTitle = _nullishCoalesce(_optionalChain([request, 'optionalAccess', _425 => _425.xTitle]), () => ( _optionalChain([request, 'optionalAccess', _426 => _426.appTitle])));
+          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _427 => _427.requestBody])) ? request.requestBody : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _428 => _428.httpReferer]);
+          const xTitle = _nullishCoalesce(_optionalChain([request, 'optionalAccess', _429 => _429.xTitle]), () => ( _optionalChain([request, 'optionalAccess', _430 => _430.appTitle])));
           const { documents, query, ...metadata } = requestBody;
           return {
             input: {
@@ -18678,9 +19196,9 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const openResponsesRequest = isObject(_optionalChain([request, 'optionalAccess', _427 => _427.openResponsesRequest])) ? request.openResponsesRequest : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _428 => _428.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _429 => _429.xTitle]);
+          const openResponsesRequest = isObject(_optionalChain([request, 'optionalAccess', _431 => _431.openResponsesRequest])) ? request.openResponsesRequest : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _432 => _432.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _433 => _433.xTitle]);
           const { input, ...metadata } = openResponsesRequest;
           return {
             input,
@@ -18690,7 +19208,7 @@ var OpenRouterPlugin = class extends BasePlugin {
         extractOutput: (result) => extractOpenRouterResponseOutput2(result),
         extractMetadata: (result) => extractOpenRouterResponseMetadata2(result),
         extractMetrics: (result, startTime) => {
-          const metrics = parseOpenRouterMetricsFromUsage2(_optionalChain([result, 'optionalAccess', _430 => _430.usage]));
+          const metrics = parseOpenRouterMetricsFromUsage2(_optionalChain([result, 'optionalAccess', _434 => _434.usage]));
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
@@ -18742,14 +19260,14 @@ var OpenRouterPlugin = class extends BasePlugin {
         extractMetadata: (result, event) => {
           if (!isObject(result)) {
             return {
-              step: _optionalChain([event, 'optionalAccess', _431 => _431.step]),
-              step_type: _optionalChain([event, 'optionalAccess', _432 => _432.stepType])
+              step: _optionalChain([event, 'optionalAccess', _435 => _435.step]),
+              step_type: _optionalChain([event, 'optionalAccess', _436 => _436.stepType])
             };
           }
           return {
             ...extractOpenRouterResponseMetadata2(result) || {},
-            ..._optionalChain([event, 'optionalAccess', _433 => _433.step]) !== void 0 ? { step: event.step } : {},
-            ..._optionalChain([event, 'optionalAccess', _434 => _434.stepType]) ? { step_type: event.stepType } : {}
+            ..._optionalChain([event, 'optionalAccess', _437 => _437.step]) !== void 0 ? { step: event.step } : {},
+            ..._optionalChain([event, 'optionalAccess', _438 => _438.stepType]) ? { step_type: event.stepType } : {}
           };
         },
         extractMetrics: (result) => isObject(result) ? parseOpenRouterMetricsFromUsage2(result.usage) : {}
@@ -19129,7 +19647,7 @@ function publishToolResult2(tracingChannel2, event, result) {
 }
 function getToolCallId2(context) {
   const toolContext = context;
-  return typeof _optionalChain([toolContext, 'optionalAccess', _435 => _435.toolCall, 'optionalAccess', _436 => _436.id]) === "string" ? toolContext.toolCall.id : void 0;
+  return typeof _optionalChain([toolContext, 'optionalAccess', _439 => _439.toolCall, 'optionalAccess', _440 => _440.id]) === "string" ? toolContext.toolCall.id : void 0;
 }
 function aggregateOpenRouterChatChunks(chunks) {
   let role;
@@ -19145,12 +19663,12 @@ function aggregateOpenRouterChatChunks(chunks) {
   for (const chunk of chunks) {
     metrics = {
       ...metrics,
-      ...parseOpenRouterMetricsFromUsage2(_optionalChain([chunk, 'optionalAccess', _437 => _437.usage]))
+      ...parseOpenRouterMetricsFromUsage2(_optionalChain([chunk, 'optionalAccess', _441 => _441.usage]))
     };
-    const choice = _optionalChain([chunk, 'optionalAccess', _438 => _438.choices, 'optionalAccess', _439 => _439[0]]);
-    const delta = _optionalChain([choice, 'optionalAccess', _440 => _440.delta]);
+    const choice = _optionalChain([chunk, 'optionalAccess', _442 => _442.choices, 'optionalAccess', _443 => _443[0]]);
+    const delta = _optionalChain([choice, 'optionalAccess', _444 => _444.delta]);
     if (!delta) {
-      if (_optionalChain([choice, 'optionalAccess', _441 => _441.finish_reason]) !== void 0) {
+      if (_optionalChain([choice, 'optionalAccess', _445 => _445.finish_reason]) !== void 0) {
         finishReason = choice.finish_reason;
       }
       continue;
@@ -19176,7 +19694,7 @@ function aggregateOpenRouterChatChunks(chunks) {
         ...delta.reasoning_details
       ];
     }
-    const choiceFinishReason = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _442 => _442.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _443 => _443.finish_reason]))), () => ( void 0));
+    const choiceFinishReason = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _446 => _446.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _447 => _447.finish_reason]))), () => ( void 0));
     const deltaFinishReason = _nullishCoalesce(_nullishCoalesce(delta.finishReason, () => ( delta.finish_reason)), () => ( void 0));
     if (choiceFinishReason !== void 0) {
       finishReason = choiceFinishReason;
@@ -19188,11 +19706,11 @@ function aggregateOpenRouterChatChunks(chunks) {
       continue;
     }
     for (const toolDelta of toolCallDeltas) {
-      if (!_optionalChain([toolDelta, 'optionalAccess', _444 => _444.function])) {
+      if (!_optionalChain([toolDelta, 'optionalAccess', _448 => _448.function])) {
         continue;
       }
       const toolIndex = _nullishCoalesce(toolDelta.index, () => ( 0));
-      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _445 => _445[toolIndex]]);
+      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _449 => _449[toolIndex]]);
       if (!existingToolCall || toolDelta.id && existingToolCall.id !== void 0 && existingToolCall.id !== toolDelta.id) {
         const nextToolCalls = [...toolCalls || []];
         nextToolCalls[toolIndex] = {
@@ -19242,7 +19760,7 @@ function aggregateOpenRouterChatChunks(chunks) {
 function aggregateOpenRouterResponseStreamEvents(chunks) {
   let finalResponse;
   for (const chunk of chunks) {
-    const response = _optionalChain([chunk, 'optionalAccess', _446 => _446.response]);
+    const response = _optionalChain([chunk, 'optionalAccess', _450 => _450.response]);
     if (!response) {
       continue;
     }
@@ -19672,10 +20190,10 @@ var MistralPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: extractMessagesInputWithMetadata,
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _447 => _447.choices]);
+          return _optionalChain([result, 'optionalAccess', _451 => _451.choices]);
         },
         extractMetadata: (result) => extractMistralResponseMetadata(result),
-        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _448 => _448.usage]), startTime)
+        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _452 => _452.usage]), startTime)
       })
     );
     this.unsubscribers.push(
@@ -19695,11 +20213,11 @@ var MistralPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: extractEmbeddingInputWithMetadata,
         extractOutput: (result) => {
-          const embedding = _optionalChain([result, 'optionalAccess', _449 => _449.data, 'optionalAccess', _450 => _450[0], 'optionalAccess', _451 => _451.embedding]);
+          const embedding = _optionalChain([result, 'optionalAccess', _453 => _453.data, 'optionalAccess', _454 => _454[0], 'optionalAccess', _455 => _455.embedding]);
           return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
         },
         extractMetadata: (result) => extractMistralResponseMetadata(result),
-        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _452 => _452.usage]))
+        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _456 => _456.usage]))
       })
     );
     this.unsubscribers.push(
@@ -19709,7 +20227,7 @@ var MistralPlugin = class extends BasePlugin {
         extractInput: extractClassifierInputWithMetadata,
         extractOutput: extractClassifierOutput,
         extractMetadata: (result) => extractMistralResponseMetadata(result),
-        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _453 => _453.usage]))
+        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _457 => _457.usage]))
       })
     );
     this.unsubscribers.push(
@@ -19719,7 +20237,7 @@ var MistralPlugin = class extends BasePlugin {
         extractInput: extractClassifierInputWithMetadata,
         extractOutput: extractClassifierOutput,
         extractMetadata: (result) => extractMistralResponseMetadata(result),
-        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _454 => _454.usage]))
+        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _458 => _458.usage]))
       })
     );
     this.unsubscribers.push(
@@ -19729,7 +20247,7 @@ var MistralPlugin = class extends BasePlugin {
         extractInput: extractClassifierInputWithMetadata,
         extractOutput: extractClassifierOutput,
         extractMetadata: (result) => extractMistralResponseMetadata(result),
-        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _455 => _455.usage]))
+        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _459 => _459.usage]))
       })
     );
     this.unsubscribers.push(
@@ -19739,7 +20257,7 @@ var MistralPlugin = class extends BasePlugin {
         extractInput: extractClassifierInputWithMetadata,
         extractOutput: extractClassifierOutput,
         extractMetadata: (result) => extractMistralResponseMetadata(result),
-        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _456 => _456.usage]))
+        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _460 => _460.usage]))
       })
     );
     this.unsubscribers.push(
@@ -19748,10 +20266,10 @@ var MistralPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: extractPromptInputWithMetadata,
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _457 => _457.choices]);
+          return _optionalChain([result, 'optionalAccess', _461 => _461.choices]);
         },
         extractMetadata: (result) => extractMistralResponseMetadata(result),
-        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _458 => _458.usage]), startTime)
+        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _462 => _462.usage]), startTime)
       })
     );
     this.unsubscribers.push(
@@ -19771,10 +20289,10 @@ var MistralPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: extractMessagesInputWithMetadata,
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _459 => _459.choices]);
+          return _optionalChain([result, 'optionalAccess', _463 => _463.choices]);
         },
         extractMetadata: (result) => extractMistralResponseMetadata(result),
-        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _460 => _460.usage]), startTime)
+        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _464 => _464.usage]), startTime)
       })
     );
     this.unsubscribers.push(
@@ -20029,11 +20547,11 @@ function mergeMistralContentParts(left, right) {
   const merged = [...(left || []).map((part) => structuredClone(part))];
   for (const part of right) {
     const lastPart = merged[merged.length - 1];
-    if (part.type === "text" && _optionalChain([lastPart, 'optionalAccess', _461 => _461.type]) === "text" && typeof lastPart.text === "string" && typeof part.text === "string") {
+    if (part.type === "text" && _optionalChain([lastPart, 'optionalAccess', _465 => _465.type]) === "text" && typeof lastPart.text === "string" && typeof part.text === "string") {
       lastPart.text += part.text;
       continue;
     }
-    if (part.type === "thinking" && _optionalChain([lastPart, 'optionalAccess', _462 => _462.type]) === "thinking" && Array.isArray(lastPart.thinking) && Array.isArray(part.thinking)) {
+    if (part.type === "thinking" && _optionalChain([lastPart, 'optionalAccess', _466 => _466.type]) === "thinking" && Array.isArray(lastPart.thinking) && Array.isArray(part.thinking)) {
       lastPart.thinking = mergeMistralTextSegments(
         lastPart.thinking,
         part.thinking
@@ -20088,13 +20606,13 @@ function createMergedToolCallDelta(delta) {
     ...delta,
     function: {
       ...delta.function,
-      arguments: typeof _optionalChain([delta, 'access', _463 => _463.function, 'optionalAccess', _464 => _464.arguments]) === "string" ? delta.function.arguments : ""
+      arguments: typeof _optionalChain([delta, 'access', _467 => _467.function, 'optionalAccess', _468 => _468.arguments]) === "string" ? delta.function.arguments : ""
     }
   };
 }
 function mergeToolCallDeltaPair(current, delta) {
-  const currentArguments = typeof _optionalChain([current, 'access', _465 => _465.function, 'optionalAccess', _466 => _466.arguments]) === "string" ? current.function.arguments : "";
-  const deltaArguments = typeof _optionalChain([delta, 'access', _467 => _467.function, 'optionalAccess', _468 => _468.arguments]) === "string" ? delta.function.arguments : "";
+  const currentArguments = typeof _optionalChain([current, 'access', _469 => _469.function, 'optionalAccess', _470 => _470.arguments]) === "string" ? current.function.arguments : "";
+  const deltaArguments = typeof _optionalChain([delta, 'access', _471 => _471.function, 'optionalAccess', _472 => _472.arguments]) === "string" ? delta.function.arguments : "";
   return {
     ...current,
     ...delta,
@@ -20197,7 +20715,7 @@ function aggregateMistralStreamChunks(chunks) {
   let metrics = {};
   let metadata;
   for (const event of chunks) {
-    const chunk = isMistralChatCompletionChunk(_optionalChain([event, 'optionalAccess', _469 => _469.data])) ? event.data : void 0;
+    const chunk = isMistralChatCompletionChunk(_optionalChain([event, 'optionalAccess', _473 => _473.data])) ? event.data : void 0;
     if (!chunk) {
       continue;
     }
@@ -20291,9 +20809,9 @@ var googleADKChannels = defineChannels("@google/adk", {
 });
 
 // src/instrumentation/plugins/google-adk-plugin.ts
-var GoogleADKPlugin = (_class19 = class extends BasePlugin {constructor(...args4) { super(...args4); _class19.prototype.__init65.call(this);_class19.prototype.__init66.call(this); }
-  __init65() {this.activeRunnerSpans = /* @__PURE__ */ new Map()}
-  __init66() {this.activeAgentSpans = /* @__PURE__ */ new Map()}
+var GoogleADKPlugin = (_class21 = class extends BasePlugin {constructor(...args5) { super(...args5); _class21.prototype.__init69.call(this);_class21.prototype.__init70.call(this); }
+  __init69() {this.activeRunnerSpans = /* @__PURE__ */ new Map()}
+  __init70() {this.activeAgentSpans = /* @__PURE__ */ new Map()}
   onEnable() {
     this.subscribeToRunnerRunAsync();
     this.subscribeToAgentRunAsync();
@@ -20388,7 +20906,7 @@ var GoogleADKPlugin = (_class19 = class extends BasePlugin {constructor(...args4
     };
     tracingChannel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _470 => _470()]);
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _474 => _474()]);
       tracingChannel2.unsubscribe(handlers);
     });
   }
@@ -20491,7 +21009,7 @@ var GoogleADKPlugin = (_class19 = class extends BasePlugin {constructor(...args4
     };
     tracingChannel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _471 => _471()]);
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _475 => _475()]);
       tracingChannel2.unsubscribe(handlers);
     });
   }
@@ -20563,7 +21081,7 @@ var GoogleADKPlugin = (_class19 = class extends BasePlugin {constructor(...args4
       tracingChannel2.unsubscribe(handlers);
     });
   }
-}, _class19);
+}, _class21);
 function ensureState(states, event, create) {
   const existing = states.get(event);
   if (existing) {
@@ -20638,10 +21156,10 @@ function bindAsyncIterableToCurrentSpan(stream, span) {
 }
 function bindCurrentSpanStoreToStart3(tracingChannel2, states, create) {
   const state = _internalGetGlobalState();
-  const contextManager = _optionalChain([state, 'optionalAccess', _472 => _472.contextManager]);
+  const contextManager = _optionalChain([state, 'optionalAccess', _476 => _476.contextManager]);
   const startChannel = tracingChannel2.start;
   const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
-  if (!_optionalChain([startChannel, 'optionalAccess', _473 => _473.bindStore]) || !currentSpanStore) {
+  if (!_optionalChain([startChannel, 'optionalAccess', _477 => _477.bindStore]) || !currentSpanStore) {
     return void 0;
   }
   startChannel.bindStore(currentSpanStore, (event) => {
@@ -20653,7 +21171,7 @@ function bindCurrentSpanStoreToStart3(tracingChannel2, states, create) {
     return contextManager.wrapSpanForStore(span);
   });
   return () => {
-    _optionalChain([startChannel, 'access', _474 => _474.unbindStore, 'optionalCall', _475 => _475(currentSpanStore)]);
+    _optionalChain([startChannel, 'access', _478 => _478.unbindStore, 'optionalCall', _479 => _479(currentSpanStore)]);
   };
 }
 function extractRunnerContextKey(paramsOrContext) {
@@ -20666,9 +21184,9 @@ function extractRunnerContextKey(paramsOrContext) {
   return extractInvocationContextKey(invocationContext);
 }
 function extractInvocationContextKey(parentContext) {
-  const session = _optionalChain([parentContext, 'optionalAccess', _476 => _476.session]);
-  const userId = _optionalChain([session, 'optionalAccess', _477 => _477.userId]);
-  const sessionId = _optionalChain([session, 'optionalAccess', _478 => _478.id]);
+  const session = _optionalChain([parentContext, 'optionalAccess', _480 => _480.session]);
+  const userId = _optionalChain([session, 'optionalAccess', _481 => _481.userId]);
+  const sessionId = _optionalChain([session, 'optionalAccess', _482 => _482.id]);
   if (typeof userId !== "string" || typeof sessionId !== "string") {
     return void 0;
   }
@@ -20725,27 +21243,27 @@ function extractRunnerMetadata(paramsOrContext) {
     metadata["google_adk.session_id"] = directSessionId;
   }
   const session = "session" in paramsOrContext ? paramsOrContext.session : void 0;
-  if (metadata["google_adk.user_id"] === void 0 && typeof _optionalChain([session, 'optionalAccess', _479 => _479.userId]) === "string") {
+  if (metadata["google_adk.user_id"] === void 0 && typeof _optionalChain([session, 'optionalAccess', _483 => _483.userId]) === "string") {
     metadata["google_adk.user_id"] = session.userId;
   }
-  if (metadata["google_adk.session_id"] === void 0 && typeof _optionalChain([session, 'optionalAccess', _480 => _480.id]) === "string") {
+  if (metadata["google_adk.session_id"] === void 0 && typeof _optionalChain([session, 'optionalAccess', _484 => _484.id]) === "string") {
     metadata["google_adk.session_id"] = session.id;
   }
   return metadata;
 }
 function extractAgentName(agent, parentContext) {
-  if (typeof _optionalChain([agent, 'optionalAccess', _481 => _481.name]) === "string" && agent.name.length > 0) {
+  if (typeof _optionalChain([agent, 'optionalAccess', _485 => _485.name]) === "string" && agent.name.length > 0) {
     return agent.name;
   }
   if (!parentContext) {
     return void 0;
   }
   const contextAgent = parentContext.agent;
-  return typeof _optionalChain([contextAgent, 'optionalAccess', _482 => _482.name]) === "string" && contextAgent.name.length > 0 ? contextAgent.name : void 0;
+  return typeof _optionalChain([contextAgent, 'optionalAccess', _486 => _486.name]) === "string" && contextAgent.name.length > 0 ? contextAgent.name : void 0;
 }
 function extractModelName(agent, parentContext) {
-  const modelAgent = _nullishCoalesce(agent, () => ( _optionalChain([parentContext, 'optionalAccess', _483 => _483.agent])));
-  if (!_optionalChain([modelAgent, 'optionalAccess', _484 => _484.model])) {
+  const modelAgent = _nullishCoalesce(agent, () => ( _optionalChain([parentContext, 'optionalAccess', _487 => _487.agent])));
+  if (!_optionalChain([modelAgent, 'optionalAccess', _488 => _488.model])) {
     return;
   }
   if (typeof modelAgent.model === "string") {
@@ -20758,30 +21276,30 @@ function extractModelName(agent, parentContext) {
 }
 function extractToolCallId(req) {
   const toolContext = req.toolContext;
-  return _optionalChain([toolContext, 'optionalAccess', _485 => _485.functionCallId]);
+  return _optionalChain([toolContext, 'optionalAccess', _489 => _489.functionCallId]);
 }
 function extractToolName2(req, tool) {
-  if (typeof _optionalChain([tool, 'optionalAccess', _486 => _486.name]) === "string" && tool.name.length > 0) {
+  if (typeof _optionalChain([tool, 'optionalAccess', _490 => _490.name]) === "string" && tool.name.length > 0) {
     return tool.name;
   }
   const toolContext = req.toolContext;
-  const invocationContext = _optionalChain([toolContext, 'optionalAccess', _487 => _487.invocationContext]);
-  const invocationTool = _optionalChain([invocationContext, 'optionalAccess', _488 => _488.tool]);
-  const toolName = _optionalChain([invocationTool, 'optionalAccess', _489 => _489.name]);
+  const invocationContext = _optionalChain([toolContext, 'optionalAccess', _491 => _491.invocationContext]);
+  const invocationTool = _optionalChain([invocationContext, 'optionalAccess', _492 => _492.tool]);
+  const toolName = _optionalChain([invocationTool, 'optionalAccess', _493 => _493.name]);
   return typeof toolName === "string" && toolName.length > 0 ? toolName : void 0;
 }
 function extractToolAgentName(req) {
   const toolContext = req.toolContext;
-  const directName = _optionalChain([toolContext, 'optionalAccess', _490 => _490.agentName]);
+  const directName = _optionalChain([toolContext, 'optionalAccess', _494 => _494.agentName]);
   if (typeof directName === "string" && directName.length > 0) {
     return directName;
   }
-  const invocationContext = _optionalChain([toolContext, 'optionalAccess', _491 => _491.invocationContext]);
+  const invocationContext = _optionalChain([toolContext, 'optionalAccess', _495 => _495.invocationContext]);
   return extractAgentName(void 0, invocationContext);
 }
 function findToolParentSpan(req, activeAgentSpans, activeRunnerSpans) {
   const toolContext = req.toolContext;
-  const invocationContext = _optionalChain([toolContext, 'optionalAccess', _492 => _492.invocationContext]);
+  const invocationContext = _optionalChain([toolContext, 'optionalAccess', _496 => _496.invocationContext]);
   const contextKey = extractInvocationContextKey(invocationContext);
   const agentName = extractToolAgentName(req);
   if (contextKey && agentName) {
@@ -21163,7 +21681,7 @@ function extractCohereResponseMetadata(result) {
     RESPONSE_METADATA_ALLOWLIST2
   );
   const meta = isObject(result.meta) ? result.meta : void 0;
-  const apiVersion = isObject(_optionalChain([meta, 'optionalAccess', _493 => _493.apiVersion])) && typeof meta.apiVersion.version === "string" && meta.apiVersion.version || isObject(_optionalChain([meta, 'optionalAccess', _494 => _494.api_version])) && typeof meta.api_version.version === "string" && meta.api_version.version;
+  const apiVersion = isObject(_optionalChain([meta, 'optionalAccess', _497 => _497.apiVersion])) && typeof meta.apiVersion.version === "string" && meta.apiVersion.version || isObject(_optionalChain([meta, 'optionalAccess', _498 => _498.api_version])) && typeof meta.api_version.version === "string" && meta.api_version.version;
   const metadata = {
     ...responseMetadata,
     ...apiVersion ? { api_version: apiVersion } : {}
@@ -21324,13 +21842,13 @@ function getToolCallIndex2(toolCall, fallbackIndex) {
   return typeof toolCall.index === "number" && Number.isInteger(toolCall.index) ? toolCall.index : fallbackIndex;
 }
 function appendToolCallDelta(existing, incoming) {
-  const currentArguments = isObject(_optionalChain([existing, 'optionalAccess', _495 => _495.function])) && typeof existing.function.arguments === "string" ? existing.function.arguments : "";
+  const currentArguments = isObject(_optionalChain([existing, 'optionalAccess', _499 => _499.function])) && typeof existing.function.arguments === "string" ? existing.function.arguments : "";
   const incomingArguments = isObject(incoming.function) && typeof incoming.function.arguments === "string" ? incoming.function.arguments : "";
   return {
     ...existing,
     ...incoming,
     function: {
-      ...isObject(_optionalChain([existing, 'optionalAccess', _496 => _496.function])) ? existing.function : {},
+      ...isObject(_optionalChain([existing, 'optionalAccess', _500 => _500.function])) ? existing.function : {},
       ...isObject(incoming.function) ? incoming.function : {},
       ...incomingArguments ? { arguments: `${currentArguments}${incomingArguments}` } : {}
     }
@@ -21586,7 +22104,7 @@ function aggregateCohereChatStreamChunks(chunks) {
         ...mergedToolCalls.length > 0 ? { toolCalls: mergedToolCalls } : {}
       };
     } else if (mergedToolCalls.length > 0 || role || mergedText.length > 0 || aggregatedContentBlocks.length > 0) {
-      const textContent = mergedText.length > 0 ? mergedText : _optionalChain([aggregatedContentBlocks, 'access', _497 => _497[0], 'optionalAccess', _498 => _498.type]) === "text" ? aggregatedContentBlocks[0].text : void 0;
+      const textContent = mergedText.length > 0 ? mergedText : _optionalChain([aggregatedContentBlocks, 'access', _501 => _501[0], 'optionalAccess', _502 => _502.type]) === "text" ? aggregatedContentBlocks[0].text : void 0;
       output = {
         ...role ? { role } : {},
         ...textContent ? { content: textContent } : {},
@@ -21635,7 +22153,7 @@ var GroqPlugin = class extends BasePlugin {
             metadata: { ...metadata, provider: "groq" }
           };
         },
-        extractOutput: (result) => _optionalChain([result, 'optionalAccess', _499 => _499.choices]),
+        extractOutput: (result) => _optionalChain([result, 'optionalAccess', _503 => _503.choices]),
         extractMetrics: (result, startTime) => {
           const metrics = parseGroqMetrics(result);
           if (startTime) {
@@ -21658,7 +22176,7 @@ var GroqPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          const embedding = _optionalChain([result, 'optionalAccess', _500 => _500.data, 'optionalAccess', _501 => _501[0], 'optionalAccess', _502 => _502.embedding]);
+          const embedding = _optionalChain([result, 'optionalAccess', _504 => _504.data, 'optionalAccess', _505 => _505[0], 'optionalAccess', _506 => _506.embedding]);
           return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
         },
         extractMetrics: (result) => parseGroqMetrics(result)
@@ -21670,8 +22188,8 @@ var GroqPlugin = class extends BasePlugin {
   }
 };
 function parseGroqMetrics(result) {
-  const metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _503 => _503.usage]));
-  const xGroq = _optionalChain([result, 'optionalAccess', _504 => _504.x_groq]);
+  const metrics = parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _507 => _507.usage]));
+  const xGroq = _optionalChain([result, 'optionalAccess', _508 => _508.x_groq]);
   if (!xGroq || typeof xGroq !== "object") {
     return metrics;
   }
@@ -21695,7 +22213,7 @@ function aggregateGroqChatCompletionChunks(chunks, streamResult, endEvent) {
   );
   const reasoning = aggregateGroqReasoning(chunks);
   if (reasoning !== void 0) {
-    const message = _optionalChain([aggregated, 'access', _505 => _505.output, 'access', _506 => _506[0], 'optionalAccess', _507 => _507.message]);
+    const message = _optionalChain([aggregated, 'access', _509 => _509.output, 'access', _510 => _510[0], 'optionalAccess', _511 => _511.message]);
     if (message) {
       message.reasoning = reasoning;
     }
@@ -21708,8 +22226,8 @@ function aggregateGroqChatCompletionChunks(chunks, streamResult, endEvent) {
 function aggregateGroqReasoning(chunks) {
   let reasoning = "";
   for (const chunk of chunks) {
-    const delta = _optionalChain([chunk, 'access', _508 => _508.choices, 'optionalAccess', _509 => _509[0], 'optionalAccess', _510 => _510.delta]);
-    const deltaReasoning = _optionalChain([delta, 'optionalAccess', _511 => _511.reasoning]);
+    const delta = _optionalChain([chunk, 'access', _512 => _512.choices, 'optionalAccess', _513 => _513[0], 'optionalAccess', _514 => _514.delta]);
+    const deltaReasoning = _optionalChain([delta, 'optionalAccess', _515 => _515.reasoning]);
     if (typeof deltaReasoning === "string") {
       reasoning += deltaReasoning;
     }
@@ -21766,8 +22284,8 @@ var GenkitPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: ([input]) => extractGenerateInput(input),
         extractOutput: extractGenerateOutput,
-        extractMetadata: (result, event) => extractGenerateResponseMetadata(result, _optionalChain([event, 'optionalAccess', _512 => _512.arguments, 'optionalAccess', _513 => _513[0]])),
-        extractMetrics: (result) => parseGenkitUsageMetrics(_optionalChain([result, 'optionalAccess', _514 => _514.usage]))
+        extractMetadata: (result, event) => extractGenerateResponseMetadata(result, _optionalChain([event, 'optionalAccess', _516 => _516.arguments, 'optionalAccess', _517 => _517[0]])),
+        extractMetrics: (result) => parseGenkitUsageMetrics(_optionalChain([result, 'optionalAccess', _518 => _518.usage]))
       })
     );
     this.unsubscribers.push(
@@ -21784,7 +22302,7 @@ var GenkitPlugin = class extends BasePlugin {
         type: "function" /* FUNCTION */,
         extractInput: ([params]) => extractEmbedInput(params),
         extractOutput: (result) => summarizeEmbeddingResult(result),
-        extractMetadata: (_result, event) => extractEmbedMetadata(_optionalChain([event, 'optionalAccess', _515 => _515.arguments, 'optionalAccess', _516 => _516[0]])),
+        extractMetadata: (_result, event) => extractEmbedMetadata(_optionalChain([event, 'optionalAccess', _519 => _519.arguments, 'optionalAccess', _520 => _520[0]])),
         extractMetrics: () => ({})
       })
     );
@@ -21794,7 +22312,7 @@ var GenkitPlugin = class extends BasePlugin {
         type: "function" /* FUNCTION */,
         extractInput: ([params]) => extractEmbedManyInput(params),
         extractOutput: summarizeEmbeddingResult,
-        extractMetadata: (_result, event) => extractEmbedMetadata(_optionalChain([event, 'optionalAccess', _517 => _517.arguments, 'optionalAccess', _518 => _518[0]])),
+        extractMetadata: (_result, event) => extractEmbedMetadata(_optionalChain([event, 'optionalAccess', _521 => _521.arguments, 'optionalAccess', _522 => _522[0]])),
         extractMetrics: () => ({})
       })
     );
@@ -21845,7 +22363,7 @@ var GenkitPlugin = class extends BasePlugin {
     };
     tracingChannel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _519 => _519()]);
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _523 => _523()]);
       tracingChannel2.unsubscribe(handlers);
     });
   }
@@ -21893,7 +22411,7 @@ var GenkitPlugin = class extends BasePlugin {
     };
     tracingChannel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _520 => _520()]);
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _524 => _524()]);
       tracingChannel2.unsubscribe(handlers);
     });
   }
@@ -21960,10 +22478,10 @@ function ensureActionSpanState(states, event, create) {
 }
 function bindActionCurrentSpanStoreToStart(tracingChannel2, states, create) {
   const state = _internalGetGlobalState();
-  const contextManager = _optionalChain([state, 'optionalAccess', _521 => _521.contextManager]);
+  const contextManager = _optionalChain([state, 'optionalAccess', _525 => _525.contextManager]);
   const startChannel = tracingChannel2.start;
   const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
-  if (!_optionalChain([startChannel, 'optionalAccess', _522 => _522.bindStore]) || !currentSpanStore) {
+  if (!_optionalChain([startChannel, 'optionalAccess', _526 => _526.bindStore]) || !currentSpanStore) {
     return void 0;
   }
   startChannel.bindStore(currentSpanStore, (event) => {
@@ -21975,7 +22493,7 @@ function bindActionCurrentSpanStoreToStart(tracingChannel2, states, create) {
     return state2 ? contextManager.wrapSpanForStore(state2.span) : currentSpanStore.getStore();
   });
   return () => {
-    _optionalChain([startChannel, 'access', _523 => _523.unbindStore, 'optionalCall', _524 => _524(currentSpanStore)]);
+    _optionalChain([startChannel, 'access', _527 => _527.unbindStore, 'optionalCall', _528 => _528(currentSpanStore)]);
   };
 }
 function normalizeInput(input) {
@@ -22022,25 +22540,25 @@ function extractGenerateOutput(result) {
 }
 function extractGenerateResponseMetadata(result, input) {
   const normalized = input ? normalizeInput(input) : void 0;
-  const request = isObject(_optionalChain([result, 'optionalAccess', _525 => _525.request])) ? _optionalChain([result, 'optionalAccess', _526 => _526.request]) : isObject(normalized) ? normalized : void 0;
+  const request = isObject(_optionalChain([result, 'optionalAccess', _529 => _529.request])) ? _optionalChain([result, 'optionalAccess', _530 => _530.request]) : isObject(normalized) ? normalized : void 0;
   return {
     ...genkitProviderMetadata(),
     ...pickDefined({
-      model: modelName(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _527 => _527.model]), () => ( _optionalChain([request, 'optionalAccess', _528 => _528.model])))),
-      finishReason: _optionalChain([result, 'optionalAccess', _529 => _529.finishReason]),
-      finishMessage: _optionalChain([result, 'optionalAccess', _530 => _530.finishMessage])
+      model: modelName(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _531 => _531.model]), () => ( _optionalChain([request, 'optionalAccess', _532 => _532.model])))),
+      finishReason: _optionalChain([result, 'optionalAccess', _533 => _533.finishReason]),
+      finishMessage: _optionalChain([result, 'optionalAccess', _534 => _534.finishMessage])
     })
   };
 }
 function extractEmbedInput(params) {
   return {
-    input: processInputAttachments(_optionalChain([params, 'optionalAccess', _531 => _531.content])),
+    input: processInputAttachments(_optionalChain([params, 'optionalAccess', _535 => _535.content])),
     metadata: extractEmbedMetadata(params)
   };
 }
 function extractEmbedManyInput(params) {
   return {
-    input: processInputAttachments(_optionalChain([params, 'optionalAccess', _532 => _532.content])),
+    input: processInputAttachments(_optionalChain([params, 'optionalAccess', _536 => _536.content])),
     metadata: extractEmbedMetadata(params)
   };
 }
@@ -22048,7 +22566,7 @@ function extractEmbedMetadata(params) {
   return {
     ...genkitProviderMetadata(),
     ...pickDefined({
-      model: modelName(_optionalChain([params, 'optionalAccess', _533 => _533.embedder]))
+      model: modelName(_optionalChain([params, 'optionalAccess', _537 => _537.embedder]))
     })
   };
 }
@@ -22056,7 +22574,7 @@ function summarizeEmbeddingResult(result) {
   if (Array.isArray(result)) {
     return {
       embedding_count: result.length,
-      dimensions: Array.isArray(result[0]) || Array.isArray(_optionalChain([result, 'access', _534 => _534[0], 'optionalAccess', _535 => _535.embedding])) ? result[0].length || _optionalChain([result, 'access', _536 => _536[0], 'optionalAccess', _537 => _537.embedding, 'optionalAccess', _538 => _538.length]) : void 0
+      dimensions: Array.isArray(result[0]) || Array.isArray(_optionalChain([result, 'access', _538 => _538[0], 'optionalAccess', _539 => _539.embedding])) ? result[0].length || _optionalChain([result, 'access', _540 => _540[0], 'optionalAccess', _541 => _541.embedding, 'optionalAccess', _542 => _542.length]) : void 0
     };
   }
   if (isObject(result) && Array.isArray(result.embeddings)) {
@@ -22083,7 +22601,7 @@ function patchGenerateStreamResult(result, span, startTime) {
       finishSpan(async () => {
         const streamedText = chunks.map((chunk) => safeGet(chunk, "text")).join("");
         const response = await result.response;
-        const metrics = parseGenkitUsageMetrics(_optionalChain([response, 'optionalAccess', _539 => _539.usage]));
+        const metrics = parseGenkitUsageMetrics(_optionalChain([response, 'optionalAccess', _543 => _543.usage]));
         if (firstChunkTime !== void 0) {
           metrics.time_to_first_token = firstChunkTime - startTime;
         }
@@ -22176,22 +22694,22 @@ function extractActionMetadata(self) {
 }
 function extractActionSpanMetadata(args) {
   const options = extractRunInNewSpanOptions(args);
-  const labels = isObject(_optionalChain([options, 'optionalAccess', _540 => _540.labels])) ? options.labels : void 0;
-  const metadata = isObject(_optionalChain([options, 'optionalAccess', _541 => _541.metadata])) ? options.metadata : void 0;
-  const actionType = stringValue(_optionalChain([labels, 'optionalAccess', _542 => _542["genkit:metadata:subtype"]]));
-  const name = stringValue(_optionalChain([metadata, 'optionalAccess', _543 => _543.name]));
+  const labels = isObject(_optionalChain([options, 'optionalAccess', _544 => _544.labels])) ? options.labels : void 0;
+  const metadata = isObject(_optionalChain([options, 'optionalAccess', _545 => _545.metadata])) ? options.metadata : void 0;
+  const actionType = stringValue(_optionalChain([labels, 'optionalAccess', _546 => _546["genkit:metadata:subtype"]]));
+  const name = stringValue(_optionalChain([metadata, 'optionalAccess', _547 => _547.name]));
   if (!actionType || !name) {
     return void 0;
   }
   return {
     actionType,
-    key: stringValue(_optionalChain([labels, 'optionalAccess', _544 => _544["genkit:key"]])),
+    key: stringValue(_optionalChain([labels, 'optionalAccess', _548 => _548["genkit:key"]])),
     name
   };
 }
 function extractActionSpanInput(args) {
   const options = extractRunInNewSpanOptions(args);
-  if (!isObject(_optionalChain([options, 'optionalAccess', _545 => _545.metadata]))) {
+  if (!isObject(_optionalChain([options, 'optionalAccess', _549 => _549.metadata]))) {
     return void 0;
   }
   return options.metadata.input;
@@ -22204,7 +22722,7 @@ function shouldTraceAction(metadata, runStepName) {
   if (runStepName) {
     return true;
   }
-  switch (_optionalChain([metadata, 'optionalAccess', _546 => _546.actionType])) {
+  switch (_optionalChain([metadata, 'optionalAccess', _550 => _550.actionType])) {
     case "model":
     case "background-model":
     case "embedder":
@@ -22214,8 +22732,8 @@ function shouldTraceAction(metadata, runStepName) {
   }
 }
 function actionSpanName(metadata, runStepName) {
-  const actionType = _optionalChain([metadata, 'optionalAccess', _547 => _547.actionType]);
-  const name = _optionalChain([metadata, 'optionalAccess', _548 => _548.name]);
+  const actionType = _optionalChain([metadata, 'optionalAccess', _551 => _551.actionType]);
+  const name = _optionalChain([metadata, 'optionalAccess', _552 => _552.name]);
   if (actionType && name) {
     return `genkit.${actionType}: ${name}`;
   }
@@ -22228,7 +22746,7 @@ function actionSpanName(metadata, runStepName) {
   return "genkit.action";
 }
 function actionSpanType(metadata) {
-  switch (_optionalChain([metadata, 'optionalAccess', _549 => _549.actionType])) {
+  switch (_optionalChain([metadata, 'optionalAccess', _553 => _553.actionType])) {
     case "tool":
     case "tool.v2":
       return "tool" /* TOOL */;
@@ -22243,9 +22761,9 @@ function actionMetadataForLog(metadata, runStepName) {
   return {
     ...genkitProviderMetadata(),
     ...pickDefined({
-      "genkit.action_type": _optionalChain([metadata, 'optionalAccess', _550 => _550.actionType]),
-      "genkit.action_name": _optionalChain([metadata, 'optionalAccess', _551 => _551.name]),
-      "genkit.action_key": _optionalChain([metadata, 'optionalAccess', _552 => _552.key]),
+      "genkit.action_type": _optionalChain([metadata, 'optionalAccess', _554 => _554.actionType]),
+      "genkit.action_name": _optionalChain([metadata, 'optionalAccess', _555 => _555.name]),
+      "genkit.action_key": _optionalChain([metadata, 'optionalAccess', _556 => _556.key]),
       "genkit.run_name": runStepName
     })
   };
@@ -22708,10 +23226,10 @@ function injectTracingHooks2(config, state) {
   const existingHooks = _nullishCoalesce(config.hooks, () => ( {}));
   const onSessionEnd = async (input, invocation) => {
     try {
-      await _optionalChain([existingHooks, 'access', _553 => _553.onSessionEnd, 'optionalCall', _554 => _554(input, invocation)]);
+      await _optionalChain([existingHooks, 'access', _557 => _557.onSessionEnd, 'optionalCall', _558 => _558(input, invocation)]);
     } finally {
       handleSessionEnd(state, input.reason, input.error);
-      _optionalChain([state, 'access', _555 => _555.unsubscribeEvents, 'optionalCall', _556 => _556()]);
+      _optionalChain([state, 'access', _559 => _559.unsubscribeEvents, 'optionalCall', _560 => _560()]);
     }
   };
   config.hooks = {
@@ -22750,7 +23268,7 @@ function makeSessionHandlers(sessionStates, configArgIndex, includeProviderMetad
       if (config.model) {
         metadata["github_copilot.model"] = config.model;
       }
-      if (includeProviderMetadata && _optionalChain([config, 'access', _557 => _557.provider, 'optionalAccess', _558 => _558.type])) {
+      if (includeProviderMetadata && _optionalChain([config, 'access', _561 => _561.provider, 'optionalAccess', _562 => _562.type])) {
         metadata["github_copilot.provider_type"] = config.provider.type;
       }
       if (Object.keys(metadata).length > 0) {
@@ -22832,43 +23350,1753 @@ 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 context = ctx;
+  if (context[WRAPPED_FLUE_CONTEXT]) {
+    return ctx;
+  }
+  const originalInit = context.init.bind(context);
+  try {
+    Object.defineProperty(context, WRAPPED_FLUE_CONTEXT, {
+      configurable: false,
+      enumerable: false,
+      value: true
+    });
+    Object.defineProperty(context, "init", {
+      configurable: true,
+      value: async function wrappedFlueInit(options) {
+        const harness = await originalInit(options);
+        return wrapFlueHarness(harness);
+      },
+      writable: true
+    });
+  } catch (e50) {
+  }
+  return ctx;
 }
-var BraintrustPlugin = (_class20 = class extends BasePlugin {
-  
-  __init67() {this.openaiPlugin = null}
-  __init68() {this.openAICodexPlugin = null}
-  __init69() {this.anthropicPlugin = null}
-  __init70() {this.aiSDKPlugin = null}
-  __init71() {this.claudeAgentSDKPlugin = null}
-  __init72() {this.cursorSDKPlugin = null}
-  __init73() {this.googleGenAIPlugin = null}
-  __init74() {this.huggingFacePlugin = null}
-  __init75() {this.openRouterPlugin = null}
-  __init76() {this.openRouterAgentPlugin = null}
-  __init77() {this.mistralPlugin = null}
-  __init78() {this.googleADKPlugin = null}
-  __init79() {this.coherePlugin = null}
-  __init80() {this.groqPlugin = null}
-  __init81() {this.genkitPlugin = null}
-  __init82() {this.gitHubCopilotPlugin = null}
-  constructor(config = {}) {
-    super();_class20.prototype.__init67.call(this);_class20.prototype.__init68.call(this);_class20.prototype.__init69.call(this);_class20.prototype.__init70.call(this);_class20.prototype.__init71.call(this);_class20.prototype.__init72.call(this);_class20.prototype.__init73.call(this);_class20.prototype.__init74.call(this);_class20.prototype.__init75.call(this);_class20.prototype.__init76.call(this);_class20.prototype.__init77.call(this);_class20.prototype.__init78.call(this);_class20.prototype.__init79.call(this);_class20.prototype.__init80.call(this);_class20.prototype.__init81.call(this);_class20.prototype.__init82.call(this);;
-    this.config = config;
+function subscribeFlueContextEvents(ctx, options = {}) {
+  if (!ctx || typeof ctx !== "object" || typeof ctx.subscribeEvent !== "function") {
+    return void 0;
   }
-  onEnable() {
-    const integrations = this.config.integrations || {};
-    if (integrations.openai !== false) {
-      this.openaiPlugin = new OpenAIPlugin();
-      this.openaiPlugin.enable();
+  const context = ctx;
+  const captureTurnSpans = _nullishCoalesce(options.captureTurnSpans, () => ( true));
+  const existingSubscription = context[SUBSCRIBED_FLUE_CONTEXT_EVENTS];
+  if (existingSubscription) {
+    if (existingSubscription.captureTurnSpans || !captureTurnSpans) {
+      return void 0;
     }
-    if (integrations.openaiCodexSDK !== false) {
-      this.openAICodexPlugin = new OpenAICodexPlugin();
-      this.openAICodexPlugin.enable();
+    try {
+      existingSubscription.unsubscribe();
+    } catch (e51) {
     }
-    if (integrations.anthropic !== false) {
+  }
+  try {
+    const unsubscribe = ctx.subscribeEvent((event) => {
+      flueChannels.contextEvent.traceSync(() => void 0, {
+        arguments: [event],
+        captureTurnSpans,
+        context: ctx
+      });
+    });
+    if (existingSubscription) {
+      existingSubscription.captureTurnSpans = captureTurnSpans;
+      existingSubscription.unsubscribe = unsubscribe;
+    } else {
+      Object.defineProperty(context, SUBSCRIBED_FLUE_CONTEXT_EVENTS, {
+        configurable: false,
+        enumerable: false,
+        value: {
+          captureTurnSpans,
+          unsubscribe
+        }
+      });
+    }
+    return unsubscribe;
+  } catch (e52) {
+    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 (e53) {
+  }
+  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 (e54) {
+  }
+  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 context = {
+        arguments: [],
+        operation: "compact",
+        session
+      };
+      return flueChannels.compact.tracePromise(() => bound(), context);
+    },
+    writable: true
+  });
+}
+function traceFlueOperation(channel2, args) {
+  const tracingChannel2 = channel2.tracingChannel();
+  const context = args.context;
+  let originalResult;
+  let traced2;
+  const run = () => {
+    try {
+      originalResult = args.run();
+      _optionalChain([tracingChannel2, 'access', _563 => _563.end, 'optionalAccess', _564 => _564.publish, 'call', _565 => _565(context)]);
+    } catch (error) {
+      context.error = normalizeError3(error);
+      _optionalChain([tracingChannel2, 'access', _566 => _566.error, 'optionalAccess', _567 => _567.publish, 'call', _568 => _568(context)]);
+      _optionalChain([tracingChannel2, 'access', _569 => _569.end, 'optionalAccess', _570 => _570.publish, 'call', _571 => _571(context)]);
+      throw error;
+    }
+    traced2 = Promise.resolve(originalResult).then(
+      (result) => {
+        context.result = result;
+        _optionalChain([tracingChannel2, 'access', _572 => _572.asyncStart, 'optionalAccess', _573 => _573.publish, 'call', _574 => _574(context)]);
+        _optionalChain([tracingChannel2, 'access', _575 => _575.asyncEnd, 'optionalAccess', _576 => _576.publish, 'call', _577 => _577(context)]);
+        return result;
+      },
+      (error) => {
+        context.error = normalizeError3(error);
+        _optionalChain([tracingChannel2, 'access', _578 => _578.error, 'optionalAccess', _579 => _579.publish, 'call', _580 => _580(context)]);
+        _optionalChain([tracingChannel2, 'access', _581 => _581.asyncStart, 'optionalAccess', _582 => _582.publish, 'call', _583 => _583(context)]);
+        _optionalChain([tracingChannel2, 'access', _584 => _584.asyncEnd, 'optionalAccess', _585 => _585.publish, 'call', _586 => _586(context)]);
+        throw error;
+      }
+    );
+  };
+  if (_optionalChain([tracingChannel2, 'access', _587 => _587.start, 'optionalAccess', _588 => _588.runStores])) {
+    tracingChannel2.start.runStores(context, run);
+  } else {
+    _optionalChain([tracingChannel2, 'access', _589 => _589.start, 'optionalAccess', _590 => _590.publish, 'call', _591 => _591(context)]);
+    run();
+  }
+  return { originalResult, traced: traced2 };
+}
+function normalizeError3(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function preserveCallHandle(originalHandle, traced2) {
+  if (!isFlueCallHandle(originalHandle)) {
+    return traced2;
+  }
+  const handle = originalHandle;
+  const wrapped = {
+    get signal() {
+      return handle.signal;
+    },
+    abort(reason) {
+      return handle.abort(reason);
+    },
+    then(onfulfilled, onrejected) {
+      return traced2.then(onfulfilled, onrejected);
+    }
+  };
+  return wrapped;
+}
+function 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 = (_class22 = class extends BasePlugin {constructor(...args6) { super(...args6); _class22.prototype.__init71.call(this);_class22.prototype.__init72.call(this);_class22.prototype.__init73.call(this);_class22.prototype.__init74.call(this);_class22.prototype.__init75.call(this);_class22.prototype.__init76.call(this);_class22.prototype.__init77.call(this); }
+  __init71() {this.activeOperationsById = /* @__PURE__ */ new Map()}
+  __init72() {this.activeOperationsByScope = /* @__PURE__ */ new Map()}
+  __init73() {this.compactionsByScope = /* @__PURE__ */ new Map()}
+  __init74() {this.pendingOperationsByKey = /* @__PURE__ */ new Map()}
+  __init75() {this.tasksById = /* @__PURE__ */ new Map()}
+  __init76() {this.toolsById = /* @__PURE__ */ new Map()}
+  __init77() {this.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(() => {
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _592 => _592()]);
+      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(() => {
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _593 => _593()]);
+      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 (error) {
+          logInstrumentationError3("Flue event", error);
+        }
+      },
+      error: () => {
+      }
+    };
+    channel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      channel2.unsubscribe(handlers);
+    });
+  }
+  bindCurrentSpanStoreToOperationStart(tracingChannel2, ensureState2) {
+    const state = _internalGetGlobalState();
+    const startChannel = tracingChannel2.start;
+    const contextManager = _optionalChain([state, 'optionalAccess', _594 => _594.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,
+      _nullishCoalesce(sessionName, () => ( "unknown")),
+      state
+    );
+    return state;
+  }
+  endOperationState(state, result) {
+    if (!state) {
+      return;
+    }
+    const metadata = {
+      ...state.metadata,
+      ...extractPromptResponseMetadata(result)
+    };
+    const metrics = {
+      ...buildDurationMetrics3(state.startTime),
+      ...metricsFromUsage(_optionalChain([result, 'optionalAccess', _595 => _595.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 = _nullishCoalesce(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: ${_nullishCoalesce(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 = _nullishCoalesce(this.toolsById.get(key), () => ( this.startSyntheticToolState(event, _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([operationState, 'optionalAccess', _596 => _596.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 = _nullishCoalesce(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 = _nullishCoalesce(this.activeOperationsById.get(event.operationId), () => ( this.promotePendingOperationForEvent(event)));
+      if (operation) {
+        return operation;
+      }
+    }
+    return _nullishCoalesce(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 _optionalChain([this, 'access', _597 => _597.tasksById, 'access', _598 => _598.get, 'call', _599 => _599(event.taskId), 'optionalAccess', _600 => _600.span]);
+    }
+    return _optionalChain([this, 'access', _601 => _601.operationStateForEvent, 'call', _602 => _602(event), 'optionalAccess', _603 => _603.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 (_optionalChain([operations, 'optionalAccess', _604 => _604.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 (_optionalChain([queue2, 'optionalAccess', _605 => _605.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;
+  }
+}, _class22);
+function isInstrumentedOperation(operation) {
+  return operation === "prompt" || operation === "skill" || operation === "task" || operation === "compact";
+}
+function getSessionName(session) {
+  return typeof _optionalChain([session, 'optionalAccess', _606 => _606.name]) === "string" ? session.name : void 0;
+}
+function operationKey(sessionName, operation) {
+  return `${_nullishCoalesce(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: _optionalChain([getOptionObject, 'call', _607 => _607(args[1]), 'optionalAccess', _608 => _608.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] } : {},
+    ..._optionalChain([options, 'optionalAccess', _609 => _609.model]) ? { model: options.model, "flue.model": options.model } : {},
+    ..._optionalChain([options, 'optionalAccess', _610 => _610.role]) ? { "flue.role": options.role } : {},
+    ..._optionalChain([options, 'optionalAccess', _611 => _611.thinkingLevel]) ? { "flue.thinking_level": options.thinkingLevel } : {},
+    ...typeof _optionalChain([options, 'optionalAccess', _612 => _612.cwd]) === "string" ? { "flue.cwd": options.cwd } : {},
+    ...Array.isArray(_optionalChain([options, 'optionalAccess', _613 => _613.tools])) ? {
+      "flue.tools_count": options.tools.length,
+      tools: summarizeTools(options.tools)
+    } : {},
+    ...Array.isArray(_optionalChain([options, 'optionalAccess', _614 => _614.images])) ? { "flue.images_count": options.images.length } : {},
+    ..._optionalChain([options, 'optionalAccess', _615 => _615.result]) || _optionalChain([options, 'optionalAccess', _616 => _616.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 = _optionalChain([result, 'optionalAccess', _617 => _617.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 _optionalChain([usage, 'optionalAccess', _618 => _618.input]) === "number" ? { prompt_tokens: usage.input } : {},
+    ...typeof _optionalChain([usage, 'optionalAccess', _619 => _619.output]) === "number" ? { completion_tokens: usage.output } : {},
+    ...typeof _optionalChain([usage, 'optionalAccess', _620 => _620.cacheRead]) === "number" ? { prompt_cached_tokens: usage.cacheRead } : {},
+    ...typeof _optionalChain([usage, 'optionalAccess', _621 => _621.cacheWrite]) === "number" ? { prompt_cache_creation_tokens: usage.cacheWrite } : {},
+    ...typeof _optionalChain([usage, 'optionalAccess', _622 => _622.totalTokens]) === "number" ? { tokens: usage.totalTokens } : {},
+    ...typeof _optionalChain([usage, 'optionalAccess', _623 => _623.cost, 'optionalAccess', _624 => _624.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:${_nullishCoalesce(event.toolCallId, () => ( "unknown"))}`;
+}
+function toAssistantOutput(text, finishReason, reasoning, toolCalls) {
+  return [
+    {
+      finish_reason: _nullishCoalesce(finishReason, () => ( "stop")),
+      index: 0,
+      message: {
+        content: text,
+        ...reasoning ? { reasoning } : {},
+        role: "assistant",
+        ..._optionalChain([toolCalls, 'optionalAccess', _625 => _625.length]) ? {
+          tool_calls: toolCalls.map((toolCall) => ({
+            function: {
+              arguments: toolCall.args === void 0 ? "{}" : JSON.stringify(toolCall.args),
+              name: _nullishCoalesce(toolCall.toolName, () => ( "unknown"))
+            },
+            ...toolCall.toolCallId ? { id: toolCall.toolCallId } : {},
+            type: "function"
+          }))
+        } : {}
+      }
+    }
+  ];
+}
+function startFlueSpan(parent, args) {
+  return parent ? withCurrent(parent, () => startSpan(args)) : startSpan(args);
+}
+function safeLog3(span, event) {
+  try {
+    span.log(event);
+  } catch (error) {
+    logInstrumentationError3("Flue span log", error);
+  }
+}
+function errorToString(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch (e55) {
+    return String(error);
+  }
+}
+function logInstrumentationError3(label, error) {
+  console.error(`Error in ${label} instrumentation:`, error);
+}
+
+// src/wrappers/langchain/callback-handler.ts
+var BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME = "BraintrustCallbackHandler";
+var BraintrustLangChainCallbackHandler = (_class23 = class {
+  __init78() {this.name = BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME}
+  __init79() {this.spans = /* @__PURE__ */ new Map()}
+  __init80() {this.skippedRuns = /* @__PURE__ */ new Set()}
+  
+  
+  
+  __init81() {this.startTimes = /* @__PURE__ */ new Map()}
+  __init82() {this.firstTokenTimes = /* @__PURE__ */ new Map()}
+  __init83() {this.ttftMs = /* @__PURE__ */ new Map()}
+  constructor(options) {;_class23.prototype.__init78.call(this);_class23.prototype.__init79.call(this);_class23.prototype.__init80.call(this);_class23.prototype.__init81.call(this);_class23.prototype.__init82.call(this);_class23.prototype.__init83.call(this);
+    this.parent = _optionalChain([options, 'optionalAccess', _626 => _626.parent]);
+    this.options = {
+      debug: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _627 => _627.debug]), () => ( false)),
+      excludeMetadataProps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _628 => _628.excludeMetadataProps]), () => ( /^(l[sc]_|langgraph_|__pregel_|checkpoint_ns)/)),
+      logger: _optionalChain([options, 'optionalAccess', _629 => _629.logger])
+    };
+  }
+  startSpan({
+    runId,
+    parentRunId,
+    ...args
+  }) {
+    if (this.spans.has(runId)) {
+      return;
+    }
+    if (!parentRunId) {
+      this.rootRunId = runId;
+    }
+    const tags = _optionalChain([args, 'access', _630 => _630.event, 'optionalAccess', _631 => _631.tags]);
+    const spanAttributes = args.spanAttributes || {};
+    spanAttributes.type = args.type || spanAttributes.type || "task";
+    args.type = spanAttributes.type;
+    const currentParent = _nullishCoalesce((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 } : {},
+        ..._optionalChain([args, 'access', _632 => _632.event, 'optionalAccess', _633 => _633.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: _nullishCoalesce(_nullishCoalesce(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: _nullishCoalesce(_nullishCoalesce(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 (_optionalChain([tags, 'optionalAccess', _634 => _634.includes, 'call', _635 => _635("langsmith:hidden")])) {
+      this.skippedRuns.add(runId);
+      return;
+    }
+    this.startSpan({
+      runId,
+      parentRunId,
+      name: _nullishCoalesce(_nullishCoalesce(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: _nullishCoalesce(_nullishCoalesce(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: _nullishCoalesce(_nullishCoalesce(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);
+      }
+    }
+  }
+}, _class23);
+function getSerializedName(serialized) {
+  if (typeof serialized.name === "string") {
+    return serialized.name;
+  }
+  const lastIdPart = _optionalChain([serialized, 'access', _636 => _636.id, 'optionalAccess', _637 => _637.at, 'call', _638 => _638(-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 = _nullishCoalesce(responseMetadata.model_name, () => ( responseMetadata.model));
+    if (typeof modelName3 === "string") {
+      return modelName3;
+    }
+  }
+  const llmOutput = response.llmOutput || {};
+  const modelName2 = _nullishCoalesce(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 (e56) {
+    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 = (_class24 = class extends BasePlugin {constructor(...args7) { super(...args7); _class24.prototype.__init84.call(this); }
+  __init84() {this.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 (e57) {
+    }
+  }
+}, _class24);
+function isCallbackManager(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const maybeManager = value;
+  return typeof maybeManager.addHandler === "function";
+}
+function hasBraintrustHandler(manager) {
+  return _nullishCoalesce(_optionalChain([manager, 'access', _639 => _639.handlers, 'optionalAccess', _640 => _640.some, 'call', _641 => _641((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 = (_class25 = class extends BasePlugin {
+  
+  __init85() {this.openaiPlugin = null}
+  __init86() {this.openAICodexPlugin = null}
+  __init87() {this.anthropicPlugin = null}
+  __init88() {this.aiSDKPlugin = null}
+  __init89() {this.claudeAgentSDKPlugin = null}
+  __init90() {this.cursorSDKPlugin = null}
+  __init91() {this.openAIAgentsPlugin = null}
+  __init92() {this.googleGenAIPlugin = null}
+  __init93() {this.huggingFacePlugin = null}
+  __init94() {this.openRouterPlugin = null}
+  __init95() {this.openRouterAgentPlugin = null}
+  __init96() {this.mistralPlugin = null}
+  __init97() {this.googleADKPlugin = null}
+  __init98() {this.coherePlugin = null}
+  __init99() {this.groqPlugin = null}
+  __init100() {this.genkitPlugin = null}
+  __init101() {this.gitHubCopilotPlugin = null}
+  __init102() {this.fluePlugin = null}
+  __init103() {this.langChainPlugin = null}
+  constructor(config = {}) {
+    super();_class25.prototype.__init85.call(this);_class25.prototype.__init86.call(this);_class25.prototype.__init87.call(this);_class25.prototype.__init88.call(this);_class25.prototype.__init89.call(this);_class25.prototype.__init90.call(this);_class25.prototype.__init91.call(this);_class25.prototype.__init92.call(this);_class25.prototype.__init93.call(this);_class25.prototype.__init94.call(this);_class25.prototype.__init95.call(this);_class25.prototype.__init96.call(this);_class25.prototype.__init97.call(this);_class25.prototype.__init98.call(this);_class25.prototype.__init99.call(this);_class25.prototype.__init100.call(this);_class25.prototype.__init101.call(this);_class25.prototype.__init102.call(this);_class25.prototype.__init103.call(this);;
+    this.config = config;
+  }
+  onEnable() {
+    const integrations = this.config.integrations || {};
+    if (integrations.openai !== false) {
+      this.openaiPlugin = new OpenAIPlugin();
+      this.openaiPlugin.enable();
+    }
+    if (integrations.openaiCodexSDK !== false) {
+      this.openAICodexPlugin = new OpenAICodexPlugin();
+      this.openAICodexPlugin.enable();
+    }
+    if (integrations.anthropic !== false) {
       this.anthropicPlugin = new AnthropicPlugin();
       this.anthropicPlugin.enable();
     }
@@ -22884,6 +25112,10 @@ var BraintrustPlugin = (_class20 = 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();
@@ -22924,6 +25156,14 @@ var BraintrustPlugin = (_class20 = 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) {
@@ -22950,6 +25190,10 @@ var BraintrustPlugin = (_class20 = 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;
@@ -22990,8 +25234,103 @@ var BraintrustPlugin = (_class20 = 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;
+    }
   }
-}, _class20);
+}, _class25);
+
+// 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[_nullishCoalesce(envIntegrationAliases[sdk], () => ( sdk))] = false;
+      }
+    }
+  }
+  return { integrations };
+}
 
 // src/instrumentation/registry.ts
 var REGISTRY_STATE_KEY = /* @__PURE__ */ Symbol.for("braintrust.registry");
@@ -22999,10 +25338,10 @@ function getSharedState() {
   const state = globalThis[/* @__PURE__ */ Symbol.for("braintrust-state")];
   return state && typeof state === "object" ? state : void 0;
 }
-var PluginRegistry = (_class21 = class {constructor() { _class21.prototype.__init83.call(this);_class21.prototype.__init84.call(this);_class21.prototype.__init85.call(this); }
-  __init83() {this.braintrustPlugin = null}
-  __init84() {this.config = {}}
-  __init85() {this.enabled = false}
+var PluginRegistry = (_class26 = class {constructor() { _class26.prototype.__init104.call(this);_class26.prototype.__init105.call(this);_class26.prototype.__init106.call(this); }
+  __init104() {this.braintrustPlugin = null}
+  __init105() {this.config = {}}
+  __init106() {this.enabled = false}
   /**
    * Configure which integrations should be enabled.
    * This must be called before any SDK imports to take effect.
@@ -23071,60 +25410,75 @@ var PluginRegistry = (_class21 = class {constructor() { _class21.prototype.__ini
    * 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")
+    );
   }
-}, _class21);
+}, _class26);
 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" && !_optionalChain([value, 'optionalAccess', _642 => _642.trim, 'call', _643 => _643()]) ? void 0 : value;
+  };
+  isomorph_default.getBraintrustApiKey = async () => {
+    const value = process.env.BRAINTRUST_API_KEY;
+    if (_optionalChain([value, 'optionalAccess', _644 => _644.trim, 'call', _645 => _645()])) {
+      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 }),
+          (error) => ({ error, 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 _optionalChain([apiKey, 'optionalAccess', _646 => _646.trim, 'call', _647 => _647()]) ? 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 (0, _nodeasync_hooks.AsyncLocalStorage)();
   isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
@@ -24279,8 +26633,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
     });
@@ -24289,16 +26647,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: [
           {
@@ -24311,8 +26670,8 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
             right: { op: "literal", value: "scorer" }
           }
         ]
-      }
-    ];
+      });
+    }
     if (spanTypeFilter && spanTypeFilter.length > 0) {
       children.push({
         op: "in",
@@ -24332,41 +26691,55 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
     return this._state;
   }
 };
-var CachedSpanFetcher = (_class22 = class {
-  __init86() {this.spanCache = /* @__PURE__ */ new Map()}
-  __init87() {this.allFetched = false}
+var CachedSpanFetcher = (_class27 = class {
+  __init107() {this.spanCache = /* @__PURE__ */ new Map()}
+  __init108() {this.allFetched = false}
   
-  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class22.prototype.__init86.call(this);_class22.prototype.__init87.call(this);
+  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class27.prototype.__init107.call(this);_class27.prototype.__init108.call(this);
     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) => _optionalChain([row, 'access', _559 => _559.span_attributes, 'optionalAccess', _560 => _560.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);
     }
@@ -24383,9 +26756,9 @@ var CachedSpanFetcher = (_class22 = 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 = _nullishCoalesce(_optionalChain([span, 'access', _561 => _561.span_attributes, 'optionalAccess', _562 => _562.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _648 => _648.span_attributes, 'optionalAccess', _649 => _649.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -24402,24 +26775,24 @@ var CachedSpanFetcher = (_class22 = class {
     }
     return result;
   }
-}, _class22);
-var LocalTrace = (_class23 = class {
+}, _class27);
+var LocalTrace = (_class28 = class {
   
   
   
   
   
-  __init88() {this.spansFlushed = false}
-  __init89() {this.spansFlushPromise = null}
+  __init109() {this.spansFlushed = false}
+  __init110() {this.spansFlushPromise = null}
   
-  __init90() {this.threadCache = /* @__PURE__ */ new Map()}
+  __init111() {this.threadCache = /* @__PURE__ */ new Map()}
   constructor({
     objectType,
     objectId,
     rootSpanId,
     ensureSpansFlushed,
     state
-  }) {;_class23.prototype.__init88.call(this);_class23.prototype.__init89.call(this);_class23.prototype.__init90.call(this);
+  }) {;_class28.prototype.__init109.call(this);_class28.prototype.__init110.call(this);_class28.prototype.__init111.call(this);
     this.objectType = objectType;
     this.objectId = objectId;
     this.rootSpanId = rootSpanId;
@@ -24461,34 +26834,43 @@ var LocalTrace = (_class23 = 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(
-        (span) => _optionalChain([span, 'access', _563 => _563.span_attributes, 'optionalAccess', _564 => _564.purpose]) !== "scorer"
+      let spans = includeScorers ? cachedSpans : cachedSpans.filter(
+        (span) => _optionalChain([span, 'access', _650 => _650.span_attributes, 'optionalAccess', _651 => _651.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _565 => _565.span_attributes, 'optionalAccess', _566 => _566.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _652 => _652.span_attributes, 'optionalAccess', _653 => _653.type]), () => ( "")))
         );
       }
       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.
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _567 => _567.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _654 => _654.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -24499,7 +26881,7 @@ var LocalTrace = (_class23 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _568 => _568.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _655 => _655.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -24530,7 +26912,7 @@ var LocalTrace = (_class23 = class {
     }
     await this.spansFlushPromise;
   }
-}, _class23);
+}, _class28);
 
 // src/reporters/progress.ts
 var SimpleProgressReporter = class {
@@ -24675,10 +27057,10 @@ function validateParametersWithJsonSchema(parameters, schema) {
   const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
   const validate = ajv.compile(schema);
   if (!validate(parameters)) {
-    const errorMessages = _optionalChain([validate, 'access', _569 => _569.errors, 'optionalAccess', _570 => _570.map, 'call', _571 => _571((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _656 => _656.errors, 'optionalAccess', _657 => _657.map, 'call', _658 => _658((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _572 => _572.join, 'call', _573 => _573(", ")]);
+    }), 'access', _659 => _659.join, 'call', _660 => _660(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return rehydrateRemoteParameters(parameters, schema);
@@ -25018,7 +27400,7 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters, st
 }
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _574 => _574.spanCache, 'optionalAccess', _575 => _575.start, 'call', _576 => _576()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _661 => _661.spanCache, 'optionalAccess', _662 => _662.start, 'call', _663 => _663()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -25073,7 +27455,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const experimentIdPromise = experiment ? (async () => {
       try {
         return await experiment.id;
-      } catch (e50) {
+      } catch (e58) {
         return void 0;
       }
     })() : void 0;
@@ -25129,7 +27511,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _577 => _577.data, 'access', async _578 => _578.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _664 => _664.data, 'access', async _665 => _665.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -25159,10 +27541,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _579 => _579({
+                    _optionalChain([stream, 'optionalCall', _666 => _666({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _580 => _580.event, 'optionalAccess', _581 => _581.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _667 => _667.event, 'optionalAccess', _668 => _668.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -25350,7 +27732,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               tags: tags.length ? tags : void 0,
               metadata,
               error,
-              origin: _optionalChain([baseEvent, 'access', _582 => _582.event, 'optionalAccess', _583 => _583.origin])
+              origin: _optionalChain([baseEvent, 'access', _669 => _669.event, 'optionalAccess', _670 => _670.origin])
             };
             collectedResults.push({
               ...baseResult,
@@ -25390,7 +27772,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _584 => _584.setTotal, 'optionalCall', _585 => _585(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _671 => _671.setTotal, 'optionalCall', _672 => _672(evaluator.evalName, scheduledTrials)]);
           q.pushAsync({ datum, trialIndex }).catch((e) => {
             if (queueErrors.length < 5) {
               queueErrors.push(e);
@@ -25475,9 +27857,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _586 => _586.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _587 => _587.dispose, 'call', _588 => _588()]);
-      _optionalChain([spanCache, 'optionalAccess', _589 => _589.stop, 'call', _590 => _590()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _673 => _673.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _674 => _674.dispose, 'call', _675 => _675()]);
+      _optionalChain([spanCache, 'optionalAccess', _676 => _676.stop, 'call', _677 => _677()]);
     }
   }
 }
@@ -25717,7 +28099,7 @@ async function cachedLogin(options) {
 }
 function makeCheckAuthorized(allowedOrgName) {
   return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _591 => _591.ctx, 'optionalAccess', _592 => _592.token])) {
+    if (!_optionalChain([req, 'access', _678 => _678.ctx, 'optionalAccess', _679 => _679.token])) {
       return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
     try {
@@ -25730,7 +28112,7 @@ function makeCheckAuthorized(allowedOrgName) {
         return next(_httperrors2.default.call(void 0, 403, errorMessage2));
       }
       const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _593 => _593.ctx, 'optionalAccess', _594 => _594.token]),
+        apiKey: _optionalChain([req, 'access', _680 => _680.ctx, 'optionalAccess', _681 => _681.token]),
         orgName
       });
       req.ctx.state = state;
@@ -25922,17 +28304,17 @@ var ProjectBuilder = class {
   }
 };
 var projects = new ProjectBuilder();
-var Project2 = (_class24 = class {
+var Project2 = (_class29 = class {
   
   
   
   
   
   
-  __init91() {this._publishableCodeFunctions = []}
-  __init92() {this._publishablePrompts = []}
-  __init93() {this._publishableParameters = []}
-  constructor(args) {;_class24.prototype.__init91.call(this);_class24.prototype.__init92.call(this);_class24.prototype.__init93.call(this);
+  __init112() {this._publishableCodeFunctions = []}
+  __init113() {this._publishablePrompts = []}
+  __init114() {this._publishableParameters = []}
+  constructor(args) {;_class29.prototype.__init112.call(this);_class29.prototype.__init113.call(this);_class29.prototype.__init114.call(this);
     _initializeSpanContext();
     this.name = "name" in args ? args.name : void 0;
     this.id = "id" in args ? args.id : void 0;
@@ -25984,12 +28366,12 @@ var Project2 = (_class24 = class {
       functions: functionDefinitions
     });
   }
-}, _class24);
-var ToolBuilder = (_class25 = class {
-  constructor(project) {;_class25.prototype.__init94.call(this);
+}, _class29);
+var ToolBuilder = (_class30 = class {
+  constructor(project) {;_class30.prototype.__init115.call(this);
     this.project = project;
   }
-  __init94() {this.taskCounter = 0}
+  __init115() {this.taskCounter = 0}
   // This type definition is just a catch all so that the implementation can be
   // less specific than the two more specific declarations above.
   create(opts) {
@@ -26014,12 +28396,12 @@ var ToolBuilder = (_class25 = class {
     this.project.addCodeFunction(tool);
     return tool;
   }
-}, _class25);
-var ScorerBuilder = (_class26 = class {
-  constructor(project) {;_class26.prototype.__init95.call(this);
+}, _class30);
+var ScorerBuilder = (_class31 = class {
+  constructor(project) {;_class31.prototype.__init116.call(this);
     this.project = project;
   }
-  __init95() {this.taskCounter = 0}
+  __init116() {this.taskCounter = 0}
   create(opts) {
     this.taskCounter++;
     let resolvedName = opts.name;
@@ -26073,7 +28455,7 @@ var ScorerBuilder = (_class26 = class {
       this.project.addPrompt(codePrompt);
     }
   }
-}, _class26);
+}, _class31);
 var CodeFunction = class {
   constructor(project, opts) {
     this.project = project;
@@ -26375,9 +28757,9 @@ function serializeRemoteEvalParametersContainer(parameters) {
     source: null
   };
 }
-var ProjectNameIdMap = (_class27 = class {constructor() { _class27.prototype.__init96.call(this);_class27.prototype.__init97.call(this); }
-  __init96() {this.nameToId = {}}
-  __init97() {this.idToName = {}}
+var ProjectNameIdMap = (_class32 = class {constructor() { _class32.prototype.__init117.call(this);_class32.prototype.__init118.call(this); }
+  __init117() {this.nameToId = {}}
+  __init118() {this.idToName = {}}
   async getId(projectName) {
     if (!(projectName in this.nameToId)) {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
@@ -26410,7 +28792,7 @@ var ProjectNameIdMap = (_class27 = class {constructor() { _class27.prototype.__i
     }
     return this.getId(project.name);
   }
-}, _class27);
+}, _class32);
 
 // dev/server.ts
 function runDevServer(evaluators, opts) {
@@ -26485,7 +28867,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _595 => _595.ctx, 'optionalAccess', _596 => _596.state])) {
+      if (!_optionalChain([req, 'access', _682 => _682.ctx, 'optionalAccess', _683 => _683.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -26536,12 +28918,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: (_nullishCoalesce(evaluator.scores, () => ( []))).concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _597 => _597.map, 'call', _598 => _598(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _684 => _684.map, 'call', _685 => _685(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _599 => _599.ctx, 'optionalAccess', _600 => _600.projectId])
+                  _optionalChain([req, 'access', _686 => _686.ctx, 'optionalAccess', _687 => _687.projectId])
                 )
               )]), () => ( []))
             ),