braintrust 3.7.1 → 3.8.0

package/dev/dist/index.js

@@ -2102,6 +2102,16 @@ var NullableSavedFunctionId = _v3.z.union([
   }),
   _v3.z.null()
 ]);
+var TopicMapGenerationSettings = _v3.z.object({
+  algorithm: _v3.z.enum(["hdbscan", "kmeans"]),
+  dimension_reduction: _v3.z.enum(["umap", "pca", "none"]),
+  sample_size: _v3.z.number().int().gt(0).optional(),
+  n_clusters: _v3.z.number().int().gt(0).optional(),
+  min_cluster_size: _v3.z.number().int().gt(0).optional(),
+  min_samples: _v3.z.number().int().gt(0).optional(),
+  hierarchy_threshold: _v3.z.number().int().gt(0).optional(),
+  naming_model: _v3.z.string().optional()
+});
 var TopicMapData = _v3.z.object({
   type: _v3.z.literal("topic_map"),
   source_facet: _v3.z.string(),
@@ -2109,6 +2119,7 @@ var TopicMapData = _v3.z.object({
   bundle_key: _v3.z.string().optional(),
   report_key: _v3.z.string().optional(),
   topic_names: _v3.z.record(_v3.z.string()).optional(),
+  generation_settings: TopicMapGenerationSettings.optional(),
   distance_threshold: _v3.z.number().optional()
 });
 var BatchedFacetData = _v3.z.object({
@@ -2333,6 +2344,7 @@ var Dataset = _v3.z.object({
   created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   deleted_at: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   user_id: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  tags: _v3.z.union([_v3.z.array(_v3.z.string()), _v3.z.null()]).optional(),
   metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
   url_slug: _v3.z.string()
 });
@@ -2415,6 +2427,14 @@ var DatasetEvent = _v3.z.object({
     _v3.z.null()
   ]).optional()
 });
+var DatasetSnapshot = _v3.z.object({
+  id: _v3.z.string().uuid(),
+  dataset_id: _v3.z.string().uuid(),
+  name: _v3.z.string(),
+  description: _v3.z.union([_v3.z.string(), _v3.z.null()]),
+  xact_id: _v3.z.string(),
+  created: _v3.z.union([_v3.z.string(), _v3.z.null()])
+});
 var EnvVar = _v3.z.object({
   id: _v3.z.string().uuid(),
   object_type: _v3.z.enum(["organization", "project", "function"]),
@@ -3173,6 +3193,8 @@ var TopicAutomationConfig = _v3.z.object({
   scope: _v3.z.union([SpanScope, TraceScope, GroupScope, _v3.z.null()]).optional(),
   data_scope: TopicAutomationDataScope.optional(),
   btql_filter: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  rerun_seconds: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
+  relabel_overlap_seconds: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional(),
   backfill_time_range: _v3.z.union([
     _v3.z.string(),
     _v3.z.object({ from: _v3.z.string(), to: _v3.z.string() }),
@@ -3509,7 +3531,8 @@ var User = _v3.z.object({
   family_name: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   email: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   avatar_url: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
-  created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional()
+  created: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  last_active_at: _v3.z.union([_v3.z.number(), _v3.z.null()]).optional()
 });
 var ViewDataSearch = _v3.z.union([
   _v3.z.object({
@@ -4669,6 +4692,15 @@ var BRAINTRUST_CURRENT_SPAN_STORE = Symbol.for(
   "braintrust.currentSpanStore"
 );
 var ContextManager = class {
+  /**
+   * Returns the value to store in the ALS bound to a TracingChannel's start event.
+   * In default mode this is the Span itself; in OTEL mode it is the OTEL Context
+   * containing the span so that OTEL's own ALS stores a proper Context object.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  wrapSpanForStore(span) {
+    return span;
+  }
 };
 var BraintrustContextManager = class extends ContextManager {
   
@@ -9401,18 +9433,22 @@ function ensureSpanStateForEvent(states, config, event, channelName) {
 function bindCurrentSpanStoreToStart(tracingChannel2, states, config, channelName) {
   const state = _internalGetGlobalState();
   const startChannel = tracingChannel2.start;
-  const currentSpanStore = _optionalChain([state, 'optionalAccess', _145 => _145.contextManager]) ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  const contextManager = _optionalChain([state, 'optionalAccess', _145 => _145.contextManager]);
+  const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
   if (!currentSpanStore || !startChannel) {
     return void 0;
   }
   startChannel.bindStore(
     currentSpanStore,
-    (event) => ensureSpanStateForEvent(
-      states,
-      config,
-      event,
-      channelName
-    ).span
+    (event) => {
+      const span = ensureSpanStateForEvent(
+        states,
+        config,
+        event,
+        channelName
+      ).span;
+      return contextManager.wrapSpanForStore(span);
+    }
   );
   return () => {
     startChannel.unbindStore(currentSpanStore);
@@ -9429,6 +9465,26 @@ function logErrorAndEnd(states, event) {
   spanData.span.end();
   states.delete(event);
 }
+function runStreamingCompletionHook(args) {
+  if (!args.config.onComplete) {
+    return;
+  }
+  try {
+    args.config.onComplete({
+      channelName: args.channelName,
+      ...args.chunks ? { chunks: args.chunks } : {},
+      endEvent: args.endEvent,
+      ...args.metadata !== void 0 ? { metadata: args.metadata } : {},
+      metrics: args.metrics,
+      output: args.output,
+      result: args.result,
+      span: args.span,
+      startTime: args.startTime
+    });
+  } catch (error) {
+    console.error(`Error in onComplete hook for ${args.channelName}:`, error);
+  }
+}
 function traceAsyncChannel(channel2, config) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
@@ -9556,6 +9612,18 @@ function traceStreamingChannel(channel2, config) {
               } else if (metrics.time_to_first_token === void 0 && chunks.length > 0) {
                 metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
               }
+              runStreamingCompletionHook({
+                channelName,
+                chunks,
+                config,
+                endEvent: asyncEndEvent,
+                ...metadata !== void 0 ? { metadata } : {},
+                metrics,
+                output,
+                result: asyncEndEvent.result,
+                span,
+                startTime
+              });
               span.log({
                 output,
                 ...metadata !== void 0 ? { metadata } : {},
@@ -9605,6 +9673,17 @@ function traceStreamingChannel(channel2, config) {
           asyncEndEvent.result,
           asyncEndEvent
         )]);
+        runStreamingCompletionHook({
+          channelName,
+          config,
+          endEvent: asyncEndEvent,
+          ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
+          metrics,
+          output,
+          result: asyncEndEvent.result,
+          span,
+          startTime
+        });
         span.log({
           output,
           ...normalizeMetadata(metadata) !== void 0 ? { metadata: normalizeMetadata(metadata) } : {},
@@ -9988,6 +10067,10 @@ var openAIChannels = defineChannels("openai", {
   responsesParse: channel({
     channelName: "responses.parse",
     kind: "async"
+  }),
+  responsesCompact: channel({
+    channelName: "responses.compact",
+    kind: "async"
   })
 });
 
@@ -10267,6 +10350,40 @@ var OpenAIPlugin = class extends BasePlugin {
         aggregateChunks: aggregateResponseStreamEvents
       })
     );
+    this.unsubscribers.push(
+      traceAsyncChannel(openAIChannels.responsesCompact, {
+        name: "openai.responses.compact",
+        type: "llm" /* LLM */,
+        extractInput: ([params]) => {
+          const { input, ...metadata } = params;
+          return {
+            input: processInputAttachments(input),
+            metadata: { ...metadata, provider: "openai" }
+          };
+        },
+        extractOutput: (result) => {
+          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _172 => _172.output]));
+        },
+        extractMetadata: (result) => {
+          if (!result) {
+            return void 0;
+          }
+          const { output: _output, usage: _usage, ...metadata } = result;
+          return Object.keys(metadata).length > 0 ? metadata : void 0;
+        },
+        extractMetrics: (result, startTime, endEvent) => {
+          const metrics = withCachedMetric(
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _173 => _173.usage])),
+            result,
+            endEvent
+          );
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        }
+      })
+    );
   }
   onDisable() {
     this.unsubscribers = unsubscribeAll(this.unsubscribers);
@@ -10351,7 +10468,7 @@ function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
         ...parseMetricsFromUsage(chunk.usage)
       };
     }
-    const delta = _optionalChain([chunk, 'access', _172 => _172.choices, 'optionalAccess', _173 => _173[0], 'optionalAccess', _174 => _174.delta]);
+    const delta = _optionalChain([chunk, 'access', _174 => _174.choices, 'optionalAccess', _175 => _175[0], 'optionalAccess', _176 => _176.delta]);
     if (!delta) {
       continue;
     }
@@ -10409,14 +10526,14 @@ function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
       continue;
     }
     const response = chunk.response;
-    if (_optionalChain([response, 'optionalAccess', _175 => _175.output]) !== void 0) {
+    if (_optionalChain([response, 'optionalAccess', _177 => _177.output]) !== void 0) {
       output = processImagesInOutput(response.output);
     }
     const { usage: _usage, output: _output, ...rest } = response || {};
     if (Object.keys(rest).length > 0) {
       metadata = rest;
     }
-    metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _176 => _176.usage]));
+    metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _178 => _178.usage]));
   }
   return {
     output,
@@ -10482,7 +10599,7 @@ var AnthropicPlugin = class extends BasePlugin {
         return message ? { role: message.role, content: message.content } : null;
       },
       extractMetrics: (message, startTime) => {
-        const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _177 => _177.usage]));
+        const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _179 => _179.usage]));
         if (startTime) {
           metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
         }
@@ -10497,7 +10614,7 @@ var AnthropicPlugin = class extends BasePlugin {
         const metadata = {};
         const metas = ["stop_reason", "stop_sequence"];
         for (const m of metas) {
-          if (_optionalChain([message, 'optionalAccess', _178 => _178[m]]) !== void 0) {
+          if (_optionalChain([message, 'optionalAccess', _180 => _180[m]]) !== void 0) {
             metadata[m] = message[m];
           }
         }
@@ -10541,13 +10658,13 @@ function aggregateAnthropicStreamChunks(chunks) {
   let metadata = {};
   let role;
   for (const event of chunks) {
-    switch (_optionalChain([event, 'optionalAccess', _179 => _179.type])) {
+    switch (_optionalChain([event, 'optionalAccess', _181 => _181.type])) {
       case "message_start":
-        if (_optionalChain([event, 'access', _180 => _180.message, 'optionalAccess', _181 => _181.usage])) {
+        if (_optionalChain([event, 'access', _182 => _182.message, 'optionalAccess', _183 => _183.usage])) {
           const initialMetrics = parseMetricsFromUsage2(event.message.usage);
           metrics = { ...metrics, ...initialMetrics };
         }
-        if (typeof _optionalChain([event, 'access', _182 => _182.message, 'optionalAccess', _183 => _183.role]) === "string") {
+        if (typeof _optionalChain([event, 'access', _184 => _184.message, 'optionalAccess', _185 => _185.role]) === "string") {
           role = event.message.role;
         }
         break;
@@ -10613,7 +10730,7 @@ function aggregateAnthropicStreamChunks(chunks) {
   })).filter(({ block }) => block !== void 0).sort((left, right) => left.index - right.index).map(({ block }) => block);
   let output = fallbackTextDeltas.join("");
   if (orderedContent.length > 0) {
-    if (orderedContent.every(isTextContentBlock) && orderedContent.every((block) => !_optionalChain([block, 'access', _184 => _184.citations, 'optionalAccess', _185 => _185.length]))) {
+    if (orderedContent.every(isTextContentBlock) && orderedContent.every((block) => !_optionalChain([block, 'access', _186 => _186.citations, 'optionalAccess', _187 => _187.length]))) {
       output = orderedContent.map((block) => block.text).join("");
     } else {
       output = {
@@ -10640,7 +10757,7 @@ function finalizeContentBlock(index, contentBlocks, contentBlockDeltas, fallback
     return;
   }
   const acc = contentBlockDeltas[index];
-  const text = _nullishCoalesce(_optionalChain([acc, 'optionalAccess', _186 => _186.textDeltas, 'access', _187 => _187.join, 'call', _188 => _188("")]), () => ( ""));
+  const text = _nullishCoalesce(_optionalChain([acc, 'optionalAccess', _188 => _188.textDeltas, 'access', _189 => _189.join, 'call', _190 => _190("")]), () => ( ""));
   if (isToolUseContentBlock(contentBlock)) {
     if (!text) {
       return;
@@ -10662,7 +10779,7 @@ function finalizeContentBlock(index, contentBlocks, contentBlockDeltas, fallback
       return;
     }
     const updated = { ...contentBlock, text };
-    if (_optionalChain([acc, 'optionalAccess', _189 => _189.citations, 'access', _190 => _190.length])) {
+    if (_optionalChain([acc, 'optionalAccess', _191 => _191.citations, 'access', _192 => _192.length])) {
       updated.citations = acc.citations;
     }
     contentBlocks[index] = updated;
@@ -10856,6 +10973,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "streamText",
     kind: "async"
   }),
+  streamTextSync: channel({
+    channelName: "streamText.sync",
+    kind: "sync-stream"
+  }),
   generateObject: channel({
     channelName: "generateObject",
     kind: "async"
@@ -10864,6 +10985,20 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "streamObject",
     kind: "async"
   }),
+  streamObjectSync: channel({
+    channelName: "streamObject.sync",
+    kind: "sync-stream"
+  }),
+  embed: channel(
+    {
+      channelName: "embed",
+      kind: "async"
+    }
+  ),
+  embedMany: channel({
+    channelName: "embedMany",
+    kind: "async"
+  }),
   agentGenerate: channel({
     channelName: "Agent.generate",
     kind: "async"
@@ -10872,6 +11007,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "Agent.stream",
     kind: "async"
   }),
+  agentStreamSync: channel({
+    channelName: "Agent.stream.sync",
+    kind: "sync-stream"
+  }),
   toolLoopAgentGenerate: channel({
     channelName: "ToolLoopAgent.generate",
     kind: "async"
@@ -10920,7 +11059,7 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.generateText, {
         name: "generateText",
         type: "llm" /* LLM */,
-        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(
@@ -10936,7 +11075,7 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.streamText, {
         name: "streamText",
         type: "llm" /* LLM */,
-        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
           resolveDenyOutputPaths(endEvent, denyOutputPaths)
@@ -10952,11 +11091,25 @@ var AISDKPlugin = class extends BasePlugin {
         })
       })
     );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.streamTextSync, {
+        name: "streamText",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          defaultDenyOutputPaths: denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.generateObject, {
         name: "generateObject",
         type: "llm" /* LLM */,
-        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(
@@ -10972,7 +11125,7 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.streamObject, {
         name: "streamObject",
         type: "llm" /* LLM */,
-        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
           resolveDenyOutputPaths(endEvent, denyOutputPaths)
@@ -10988,11 +11141,49 @@ var AISDKPlugin = class extends BasePlugin {
         })
       })
     );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.streamObjectSync, {
+        name: "streamObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          defaultDenyOutputPaths: denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(aiSDKChannels.embed, {
+        name: "embed",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event) => prepareAISDKEmbedInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKEmbeddingOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent)
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(aiSDKChannels.embedMany, {
+        name: "embedMany",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event) => prepareAISDKEmbedInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKEmbeddingOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent)
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.agentGenerate, {
         name: "Agent.generate",
         type: "llm" /* LLM */,
-        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(
@@ -11008,7 +11199,7 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.agentStream, {
         name: "Agent.stream",
         type: "llm" /* LLM */,
-        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
           resolveDenyOutputPaths(endEvent, denyOutputPaths)
@@ -11024,11 +11215,25 @@ var AISDKPlugin = class extends BasePlugin {
         })
       })
     );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.agentStreamSync, {
+        name: "Agent.stream",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          defaultDenyOutputPaths: denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.toolLoopAgentGenerate, {
         name: "ToolLoopAgent.generate",
         type: "llm" /* LLM */,
-        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(
@@ -11044,7 +11249,7 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.toolLoopAgentStream, {
         name: "ToolLoopAgent.stream",
         type: "llm" /* LLM */,
-        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
           resolveDenyOutputPaths(endEvent, denyOutputPaths)
@@ -11063,10 +11268,10 @@ var AISDKPlugin = class extends BasePlugin {
   }
 };
 function resolveDenyOutputPaths(event, defaultDenyOutputPaths) {
-  if (Array.isArray(_optionalChain([event, 'optionalAccess', _191 => _191.denyOutputPaths]))) {
+  if (Array.isArray(_optionalChain([event, 'optionalAccess', _193 => _193.denyOutputPaths]))) {
     return event.denyOutputPaths;
   }
-  const firstArgument = _optionalChain([event, 'optionalAccess', _192 => _192.arguments]) && event.arguments.length > 0 ? event.arguments[0] : void 0;
+  const firstArgument = _optionalChain([event, 'optionalAccess', _194 => _194.arguments]) && event.arguments.length > 0 ? event.arguments[0] : void 0;
   if (!firstArgument || typeof firstArgument !== "object") {
     return defaultDenyOutputPaths;
   }
@@ -11281,7 +11486,7 @@ var convertImageToAttachment = (image, explicitMimeType) => {
   try {
     if (typeof image === "string" && image.startsWith("data:")) {
       const [mimeTypeSection, base64Data] = image.split(",");
-      const mimeType = _optionalChain([mimeTypeSection, 'access', _193 => _193.match, 'call', _194 => _194(/data:(.*?);/), 'optionalAccess', _195 => _195[1]]);
+      const mimeType = _optionalChain([mimeTypeSection, 'access', _195 => _195.match, 'call', _196 => _196(/data:(.*?);/), 'optionalAccess', _197 => _197[1]]);
       if (mimeType && base64Data) {
         const blob = convertDataToBlob(base64Data, mimeType);
         if (blob) {
@@ -11354,11 +11559,11 @@ var convertDataToAttachment = (data, mimeType, filename) => {
   }
   return null;
 };
-function processAISDKInput(params) {
+function processAISDKCallInput(params) {
   return processInputAttachmentsSync(params);
 }
-function prepareAISDKInput(params, event, span, defaultDenyOutputPaths) {
-  const { input, outputPromise } = processAISDKInput(params);
+function prepareAISDKCallInput(params, event, span, defaultDenyOutputPaths) {
+  const { input, outputPromise } = processAISDKCallInput(params);
   if (outputPromise && input && typeof input === "object") {
     outputPromise.then((resolvedData) => {
       span.log({
@@ -11370,7 +11575,7 @@ function prepareAISDKInput(params, event, span, defaultDenyOutputPaths) {
     }).catch(() => {
     });
   }
-  const metadata = extractMetadataFromParams(params, event.self);
+  const metadata = extractMetadataFromCallParams(params, event.self);
   const childTracing = prepareAISDKChildTracing(
     params,
     event.self,
@@ -11387,6 +11592,12 @@ function prepareAISDKInput(params, event, span, defaultDenyOutputPaths) {
     metadata
   };
 }
+function prepareAISDKEmbedInput(params, self) {
+  return {
+    input: { ...params },
+    metadata: extractMetadataFromEmbedParams(params, self)
+  };
+}
 function extractTopLevelAISDKMetrics(result, event, startTime) {
   const metrics = hasModelChildTracing(event) ? {} : extractTokenMetrics(result);
   if (startTime) {
@@ -11395,31 +11606,43 @@ function extractTopLevelAISDKMetrics(result, event, startTime) {
   return metrics;
 }
 function hasModelChildTracing(event) {
-  return _optionalChain([event, 'optionalAccess', _196 => _196.modelWrapped]) === true || _optionalChain([event, 'optionalAccess', _197 => _197.__braintrust_ai_sdk_model_wrapped]) === true;
+  return _optionalChain([event, 'optionalAccess', _198 => _198.modelWrapped]) === true || _optionalChain([event, 'optionalAccess', _199 => _199.__braintrust_ai_sdk_model_wrapped]) === true;
 }
-function extractMetadataFromParams(params, self) {
-  const metadata = {
+function createAISDKIntegrationMetadata() {
+  return {
     braintrust: {
       integration_name: "ai-sdk",
       sdk_language: "typescript"
     }
   };
-  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _198 => _198.settings, 'optionalAccess', _199 => _199.model]) ? _optionalChain([self, 'access', _200 => _200.settings, 'optionalAccess', _201 => _201.model]) : void 0;
-  const { model, provider } = serializeModelWithProvider(
-    _nullishCoalesce(params.model, () => ( agentModel))
+}
+function resolveModelFromSelf(self) {
+  return self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _200 => _200.settings, 'optionalAccess', _201 => _201.model]) ? _optionalChain([self, 'access', _202 => _202.settings, 'optionalAccess', _203 => _203.model]) : void 0;
+}
+function extractBaseMetadata(model, self) {
+  const metadata = createAISDKIntegrationMetadata();
+  const { model: modelId, provider } = serializeModelWithProvider(
+    _nullishCoalesce(model, () => ( resolveModelFromSelf(self)))
   );
-  if (model) {
-    metadata.model = model;
+  if (modelId) {
+    metadata.model = modelId;
   }
   if (provider) {
     metadata.provider = provider;
   }
+  return metadata;
+}
+function extractMetadataFromCallParams(params, self) {
+  const metadata = extractBaseMetadata(params.model, self);
   const tools = serializeAISDKToolsForLogging(params.tools);
   if (tools) {
     metadata.tools = tools;
   }
   return metadata;
 }
+function extractMetadataFromEmbedParams(params, self) {
+  return extractBaseMetadata(params.model, self);
+}
 function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiSDK) {
   const cleanup = [];
   const patchedModels = /* @__PURE__ */ new WeakSet();
@@ -11457,7 +11680,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
             type: "llm" /* LLM */
           },
           event: {
-            input: processAISDKInput(options).input,
+            input: processAISDKCallInput(options).input,
             metadata: baseMetadata
           }
         }
@@ -11471,7 +11694,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
             type: "llm" /* LLM */
           },
           event: {
-            input: processAISDKInput(options).input,
+            input: processAISDKCallInput(options).input,
             metadata: baseMetadata
           }
         });
@@ -11511,9 +11734,9 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
               case "raw":
                 if (chunk.rawValue) {
                   const rawVal = chunk.rawValue;
-                  if (_optionalChain([rawVal, 'access', _202 => _202.delta, 'optionalAccess', _203 => _203.content])) {
+                  if (_optionalChain([rawVal, 'access', _204 => _204.delta, 'optionalAccess', _205 => _205.content])) {
                     text += rawVal.delta.content;
-                  } else if (_optionalChain([rawVal, 'access', _204 => _204.choices, 'optionalAccess', _205 => _205[0], 'optionalAccess', _206 => _206.delta, 'optionalAccess', _207 => _207.content])) {
+                  } else if (_optionalChain([rawVal, 'access', _206 => _206.choices, 'optionalAccess', _207 => _207[0], 'optionalAccess', _208 => _208.delta, 'optionalAccess', _209 => _209.content])) {
                     text += rawVal.choices[0].delta.content;
                   } else if (typeof rawVal.text === "string") {
                     text += rawVal.text;
@@ -11667,14 +11890,14 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
   return {
     cleanup: cleanup.length > 0 ? () => {
       while (cleanup.length > 0) {
-        _optionalChain([cleanup, 'access', _208 => _208.pop, 'call', _209 => _209(), 'optionalCall', _210 => _210()]);
+        _optionalChain([cleanup, 'access', _210 => _210.pop, 'call', _211 => _211(), 'optionalCall', _212 => _212()]);
       }
     } : void 0,
     modelWrapped
   };
 }
 function finalizeAISDKChildTracing(event) {
-  const cleanup = _optionalChain([event, 'optionalAccess', _211 => _211.__braintrust_ai_sdk_cleanup]);
+  const cleanup = _optionalChain([event, 'optionalAccess', _213 => _213.__braintrust_ai_sdk_cleanup]);
   if (event && typeof cleanup === "function") {
     cleanup();
     delete event.__braintrust_ai_sdk_cleanup;
@@ -11780,9 +12003,14 @@ function attachKnownResultPromiseHandlers(result) {
     "content",
     "text",
     "object",
+    "value",
+    "values",
     "finishReason",
+    "embedding",
+    "embeddings",
     "usage",
     "totalUsage",
+    "responses",
     "steps"
   ];
   for (const field of promiseLikeFields) {
@@ -11885,10 +12113,10 @@ function buildAISDKChildMetadata(model) {
 function buildResolvedMetadataPayload(result) {
   const gatewayInfo = extractGatewayRoutingInfo(result);
   const metadata = {};
-  if (_optionalChain([gatewayInfo, 'optionalAccess', _212 => _212.provider])) {
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _214 => _214.provider])) {
     metadata.provider = gatewayInfo.provider;
   }
-  if (_optionalChain([gatewayInfo, 'optionalAccess', _213 => _213.model])) {
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _215 => _215.model])) {
     metadata.model = gatewayInfo.model;
   }
   let finishReason;
@@ -11909,7 +12137,7 @@ function resolveAISDKModel(model, aiSDK) {
   if (typeof model !== "string") {
     return model;
   }
-  const provider = _nullishCoalesce(_nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( _optionalChain([aiSDK, 'optionalAccess', _214 => _214.gateway]))), () => ( null));
+  const provider = _nullishCoalesce(_nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( _optionalChain([aiSDK, 'optionalAccess', _216 => _216.gateway]))), () => ( null));
   if (provider && typeof provider.languageModel === "function") {
     return provider.languageModel(model);
   }
@@ -11930,6 +12158,38 @@ function processAISDKOutput(output, denyOutputPaths) {
   const merged = extractSerializableOutputFields(output);
   return normalizeAISDKLoggedOutput(omit(merged, denyOutputPaths));
 }
+function processAISDKEmbeddingOutput(output, denyOutputPaths) {
+  if (!output || typeof output !== "object") {
+    return output;
+  }
+  const summarized = {};
+  const whitelistedFields = [
+    "usage",
+    "totalUsage",
+    "warnings",
+    "providerMetadata",
+    "experimental_providerMetadata"
+  ];
+  for (const field of whitelistedFields) {
+    const value = safeSerializableFieldRead(output, field);
+    if (value !== void 0 && isSerializableOutputValue(value)) {
+      summarized[field] = value;
+    }
+  }
+  const embedding = safeSerializableFieldRead(output, "embedding");
+  if (Array.isArray(embedding)) {
+    summarized.embedding_length = embedding.length;
+  }
+  const embeddings = safeSerializableFieldRead(output, "embeddings");
+  if (Array.isArray(embeddings)) {
+    summarized.embedding_count = embeddings.length;
+    const firstEmbedding = embeddings.find((item) => Array.isArray(item));
+    if (Array.isArray(firstEmbedding)) {
+      summarized.embedding_length = firstEmbedding.length;
+    }
+  }
+  return normalizeAISDKLoggedOutput(omit(summarized, denyOutputPaths));
+}
 function extractTokenMetrics(result) {
   const metrics = {};
   let usage;
@@ -11947,7 +12207,7 @@ function extractTokenMetrics(result) {
     return metrics;
   }
   const promptTokens = firstNumber(
-    _optionalChain([usage, 'access', _215 => _215.inputTokens, 'optionalAccess', _216 => _216.total]),
+    _optionalChain([usage, 'access', _217 => _217.inputTokens, 'optionalAccess', _218 => _218.total]),
     usage.inputTokens,
     usage.promptTokens,
     usage.prompt_tokens
@@ -11956,7 +12216,7 @@ function extractTokenMetrics(result) {
     metrics.prompt_tokens = promptTokens;
   }
   const completionTokens = firstNumber(
-    _optionalChain([usage, 'access', _217 => _217.outputTokens, 'optionalAccess', _218 => _218.total]),
+    _optionalChain([usage, 'access', _219 => _219.outputTokens, 'optionalAccess', _220 => _220.total]),
     usage.outputTokens,
     usage.completionTokens,
     usage.completion_tokens
@@ -11983,7 +12243,7 @@ function safeResultFieldRead(result, field) {
 }
 function safeSerializableFieldRead(obj, field) {
   try {
-    const value = _optionalChain([obj, 'optionalAccess', _219 => _219[field]]);
+    const value = _optionalChain([obj, 'optionalAccess', _221 => _221[field]]);
     if (isPromiseLike(value)) {
       void Promise.resolve(value).catch(() => {
       });
@@ -12028,12 +12288,17 @@ function extractGetterValues(obj) {
     "content",
     "text",
     "object",
+    "value",
+    "values",
+    "embedding",
+    "embeddings",
     "finishReason",
     "usage",
     "totalUsage",
     "toolCalls",
     "toolResults",
     "warnings",
+    "responses",
     "experimental_providerMetadata",
     "providerMetadata",
     "rawResponse",
@@ -12072,7 +12337,7 @@ function extractSerializableOutputFields(output) {
   ];
   for (const name of directFieldNames) {
     try {
-      const value = _optionalChain([output, 'optionalAccess', _220 => _220[name]]);
+      const value = _optionalChain([output, 'optionalAccess', _222 => _222[name]]);
       if (isPromiseLike(value)) {
         void Promise.resolve(value).catch(() => {
         });
@@ -12108,8 +12373,8 @@ function isSerializableOutputValue(value) {
   return true;
 }
 function serializeModelWithProvider(model) {
-  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _221 => _221.modelId]);
-  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _222 => _222.provider]) : void 0;
+  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _223 => _223.modelId]);
+  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _224 => _224.provider]) : void 0;
   if (!modelId) {
     return { model: modelId, provider: explicitProvider };
   }
@@ -12135,7 +12400,7 @@ function parseGatewayModelString(modelString) {
 function extractGatewayRoutingInfo(result) {
   const steps = safeSerializableFieldRead(result, "steps");
   if (Array.isArray(steps) && steps.length > 0) {
-    const routing2 = _optionalChain([steps, 'access', _223 => _223[0], 'optionalAccess', _224 => _224.providerMetadata, 'optionalAccess', _225 => _225.gateway, 'optionalAccess', _226 => _226.routing]);
+    const routing2 = _optionalChain([steps, 'access', _225 => _225[0], 'optionalAccess', _226 => _226.providerMetadata, 'optionalAccess', _227 => _227.gateway, 'optionalAccess', _228 => _228.routing]);
     if (routing2) {
       return {
         provider: routing2.resolvedProvider || routing2.finalProvider,
@@ -12147,7 +12412,7 @@ function extractGatewayRoutingInfo(result) {
     result,
     "providerMetadata"
   );
-  const routing = _optionalChain([providerMetadata, 'optionalAccess', _227 => _227.gateway, 'optionalAccess', _228 => _228.routing]);
+  const routing = _optionalChain([providerMetadata, 'optionalAccess', _229 => _229.gateway, 'optionalAccess', _230 => _230.routing]);
   if (routing) {
     return {
       provider: routing.resolvedProvider || routing.finalProvider,
@@ -12162,8 +12427,8 @@ function extractCostFromResult(result) {
     let totalCost = 0;
     let foundCost = false;
     for (const step of steps) {
-      const gateway2 = _optionalChain([step, 'optionalAccess', _229 => _229.providerMetadata, 'optionalAccess', _230 => _230.gateway]);
-      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _231 => _231.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _232 => _232.marketCost]));
+      const gateway2 = _optionalChain([step, 'optionalAccess', _231 => _231.providerMetadata, 'optionalAccess', _232 => _232.gateway]);
+      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _233 => _233.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _234 => _234.marketCost]));
       if (stepCost !== void 0 && stepCost > 0) {
         totalCost += stepCost;
         foundCost = true;
@@ -12177,8 +12442,8 @@ function extractCostFromResult(result) {
     result,
     "providerMetadata"
   );
-  const gateway = _optionalChain([providerMetadata, 'optionalAccess', _233 => _233.gateway]);
-  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _234 => _234.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _235 => _235.marketCost]));
+  const gateway = _optionalChain([providerMetadata, 'optionalAccess', _235 => _235.gateway]);
+  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _236 => _236.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _237 => _237.marketCost]));
   if (directCost !== void 0 && directCost > 0) {
     return directCost;
   }
@@ -12294,101 +12559,401 @@ var claudeAgentSDKChannels = defineChannels(
   }
 );
 
-// src/instrumentation/plugins/claude-agent-sdk-plugin.ts
-function isSubAgentToolName(toolName) {
-  return toolName === "Agent" || toolName === "Task";
-}
-function filterSerializableOptions(options) {
-  const allowedKeys = [
-    "model",
-    "maxTurns",
-    "cwd",
-    "continue",
-    "allowedTools",
-    "disallowedTools",
-    "additionalDirectories",
-    "permissionMode",
-    "debug",
-    "apiKey",
-    "apiKeySource",
-    "agentName",
-    "instructions"
-  ];
-  const filtered = {};
-  for (const key of allowedKeys) {
-    if (options[key] !== void 0) {
-      filtered[key] = options[key];
-    }
+// src/instrumentation/plugins/claude-agent-sdk-instrumentation-constants.ts
+var CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION = "__braintrust_skip_local_tool_hooks";
+
+// src/instrumentation/plugins/claude-agent-sdk-local-tool-context.ts
+var LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED = Symbol.for(
+  "braintrust.claude_agent_sdk.local_tool_context_async_iterator_patched"
+);
+function createLocalToolContextStore() {
+  const maybeIsoWithAsyncLocalStorage = isomorph_default;
+  if (typeof maybeIsoWithAsyncLocalStorage.newAsyncLocalStorage === "function") {
+    return maybeIsoWithAsyncLocalStorage.newAsyncLocalStorage();
   }
-  return filtered;
+  let currentStore;
+  return {
+    enterWith(store) {
+      currentStore = store;
+    },
+    getStore() {
+      return currentStore;
+    },
+    run(store, callback) {
+      const previousStore = currentStore;
+      currentStore = store;
+      try {
+        return callback();
+      } finally {
+        currentStore = previousStore;
+      }
+    }
+  };
 }
-function getNumberProperty(obj, key) {
-  if (!obj || typeof obj !== "object" || !(key in obj)) {
-    return void 0;
-  }
-  const value = Reflect.get(obj, key);
-  return typeof value === "number" ? value : void 0;
+var localToolContextStore = createLocalToolContextStore();
+var fallbackLocalToolParentResolver;
+function createClaudeLocalToolContext() {
+  return {};
 }
-function extractUsageFromMessage(message) {
-  const metrics = {};
-  let usage;
-  if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _236 => _236.message, 'optionalAccess', _237 => _237.usage]);
-  } else if (message.type === "result") {
-    usage = message.usage;
-  }
-  if (!usage || typeof usage !== "object") {
-    return metrics;
-  }
-  const inputTokens = getNumberProperty(usage, "input_tokens");
-  if (inputTokens !== void 0) {
-    metrics.prompt_tokens = inputTokens;
-  }
-  const outputTokens = getNumberProperty(usage, "output_tokens");
-  if (outputTokens !== void 0) {
-    metrics.completion_tokens = outputTokens;
-  }
-  const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
-  const cacheCreationTokens = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
-  if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
-    Object.assign(
-      metrics,
-      extractAnthropicCacheTokens(cacheReadTokens, cacheCreationTokens)
-    );
-  }
-  if (Object.keys(metrics).length > 0) {
-    Object.assign(metrics, finalizeAnthropicTokens(metrics));
+function runWithClaudeLocalToolContext(callback, context) {
+  return localToolContextStore.run(
+    _nullishCoalesce(context, () => ( createClaudeLocalToolContext())),
+    callback
+  );
+}
+function ensureClaudeLocalToolContext() {
+  const existing = localToolContextStore.getStore();
+  if (existing) {
+    return existing;
   }
-  return metrics;
+  const created = {};
+  localToolContextStore.enterWith(created);
+  return created;
 }
-function buildLLMInput(prompt, conversationHistory, capturedPromptMessages) {
-  const promptMessages = [];
-  if (typeof prompt === "string") {
-    promptMessages.push({ content: prompt, role: "user" });
-  } else if (capturedPromptMessages && capturedPromptMessages.length > 0) {
-    for (const msg of capturedPromptMessages) {
-      const role = _optionalChain([msg, 'access', _238 => _238.message, 'optionalAccess', _239 => _239.role]);
-      const content = _optionalChain([msg, 'access', _240 => _240.message, 'optionalAccess', _241 => _241.content]);
-      if (role && content !== void 0) {
-        promptMessages.push({ content, role });
-      }
-    }
+function setClaudeLocalToolParentResolver(resolver) {
+  fallbackLocalToolParentResolver = resolver;
+  const context = ensureClaudeLocalToolContext();
+  if (!context) {
+    return;
   }
-  const inputParts = [...promptMessages, ...conversationHistory];
-  return inputParts.length > 0 ? inputParts : void 0;
+  context.resolveLocalToolParent = resolver;
 }
-function formatCapturedMessages(messages) {
-  return messages.length > 0 ? messages : [];
+function getClaudeLocalToolParentResolver() {
+  return _nullishCoalesce(_optionalChain([localToolContextStore, 'access', _238 => _238.getStore, 'call', _239 => _239(), 'optionalAccess', _240 => _240.resolveLocalToolParent]), () => ( fallbackLocalToolParentResolver));
 }
-async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, capturedPromptMessages, parentSpan) {
-  if (messages.length === 0) {
-    return void 0;
+function isAsyncIterable2(value) {
+  return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function bindClaudeLocalToolContextToAsyncIterable(result, localToolContext) {
+  if (!isAsyncIterable2(result) || Object.isFrozen(result) || Object.isSealed(result)) {
+    return result;
   }
-  const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _242 => _242.message, 'optionalAccess', _243 => _243.usage])) {
-    return void 0;
+  const stream = result;
+  const originalAsyncIterator = stream[Symbol.asyncIterator];
+  if (originalAsyncIterator[LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED]) {
+    return result;
   }
-  const model = lastMessage.message.model || options.model;
+  const patchedAsyncIterator = function() {
+    return runWithClaudeLocalToolContext(() => {
+      const iterator = Reflect.apply(originalAsyncIterator, this, []);
+      if (!iterator || typeof iterator !== "object") {
+        return iterator;
+      }
+      const patchMethod = (methodName) => {
+        const originalMethod = Reflect.get(iterator, methodName);
+        if (typeof originalMethod !== "function") {
+          return;
+        }
+        Reflect.set(
+          iterator,
+          methodName,
+          (...args) => runWithClaudeLocalToolContext(
+            () => Reflect.apply(
+              originalMethod,
+              iterator,
+              args
+            ),
+            localToolContext
+          )
+        );
+      };
+      patchMethod("next");
+      patchMethod("return");
+      patchMethod("throw");
+      return iterator;
+    }, localToolContext);
+  };
+  Object.defineProperty(
+    patchedAsyncIterator,
+    LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED,
+    {
+      configurable: false,
+      enumerable: false,
+      value: true,
+      writable: false
+    }
+  );
+  Reflect.set(stream, Symbol.asyncIterator, patchedAsyncIterator);
+  return result;
+}
+
+// src/instrumentation/plugins/claude-agent-sdk-local-tool-spans.ts
+var LOCAL_TOOL_HANDLER_WRAPPED = Symbol.for(
+  "braintrust.claude_agent_sdk.local_tool_handler_wrapped"
+);
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isPromiseLike2(value) {
+  return value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+}
+function getToolUseIdFromExtra(extra) {
+  if (!extra || typeof extra !== "object" || !("_meta" in extra)) {
+    return void 0;
+  }
+  const meta = Reflect.get(extra, "_meta");
+  if (!meta || typeof meta !== "object") {
+    return void 0;
+  }
+  const toolUseId = Reflect.get(meta, "claudecode/toolUseId");
+  return typeof toolUseId === "string" ? toolUseId : void 0;
+}
+function wrapLocalClaudeToolHandler(handler, getMetadata) {
+  if (handler[LOCAL_TOOL_HANDLER_WRAPPED]) {
+    return handler;
+  }
+  const wrappedHandler = function wrappedLocalToolHandler(...handlerArgs) {
+    const metadata = getMetadata();
+    const rawToolName = metadata.serverName ? `mcp__${metadata.serverName}__${metadata.toolName}` : metadata.toolName;
+    const toolUseId = getToolUseIdFromExtra(handlerArgs[1]);
+    const localToolParentResolver = getClaudeLocalToolParentResolver();
+    const spanName = metadata.serverName ? `tool: ${metadata.serverName}/${metadata.toolName}` : `tool: ${metadata.toolName}`;
+    const runWithResolvedParent = async () => {
+      const parent = toolUseId && localToolParentResolver ? await localToolParentResolver(toolUseId).catch(() => void 0) : void 0;
+      const span = startSpan({
+        event: {
+          input: handlerArgs[0],
+          metadata: {
+            "claude_agent_sdk.raw_tool_name": rawToolName,
+            "gen_ai.tool.name": metadata.toolName,
+            ...toolUseId && { "gen_ai.tool.call.id": toolUseId },
+            ...metadata.serverName && {
+              "mcp.server": metadata.serverName
+            }
+          }
+        },
+        name: spanName,
+        ...parent && { parent },
+        spanAttributes: { type: "tool" /* TOOL */ }
+      });
+      const runHandler = () => Reflect.apply(handler, this, handlerArgs);
+      const finalizeSuccess = (result) => {
+        span.log({ output: result });
+        span.end();
+        return result;
+      };
+      const finalizeError = (error) => {
+        span.log({ error: toErrorMessage(error) });
+        span.end();
+        throw error;
+      };
+      return withCurrent(span, () => {
+        try {
+          const result = runHandler();
+          if (isPromiseLike2(result)) {
+            return result.then(finalizeSuccess, finalizeError);
+          }
+          return finalizeSuccess(result);
+        } catch (error) {
+          return finalizeError(error);
+        }
+      });
+    };
+    return runWithResolvedParent();
+  };
+  Object.defineProperty(wrappedHandler, LOCAL_TOOL_HANDLER_WRAPPED, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false
+  });
+  return wrappedHandler;
+}
+function getRegisteredTools(instance) {
+  if (!instance || typeof instance !== "object") {
+    return void 0;
+  }
+  if (!("_registeredTools" in instance)) {
+    return void 0;
+  }
+  const registeredTools = Reflect.get(instance, "_registeredTools");
+  if (registeredTools instanceof Map) {
+    return registeredTools;
+  }
+  if (registeredTools && typeof registeredTools === "object") {
+    return registeredTools;
+  }
+  return void 0;
+}
+function wrapLocalMcpServerToolHandlers(serverName, serverConfig) {
+  if (!serverConfig || typeof serverConfig !== "object") {
+    return false;
+  }
+  if (!("instance" in serverConfig)) {
+    return false;
+  }
+  const instance = Reflect.get(serverConfig, "instance");
+  const registeredTools = getRegisteredTools(instance);
+  if (!registeredTools) {
+    return false;
+  }
+  let wrappedAny = false;
+  const wrapHandler = (toolName, registration) => {
+    if (!registration || typeof registration !== "object") {
+      return;
+    }
+    const handler = Reflect.get(registration, "handler");
+    if (typeof handler !== "function") {
+      return;
+    }
+    const wrappedHandler = wrapLocalClaudeToolHandler(handler, () => ({
+      serverName,
+      toolName
+    }));
+    if (wrappedHandler !== handler) {
+      Reflect.set(registration, "handler", wrappedHandler);
+      wrappedAny = true;
+    }
+  };
+  if (registeredTools instanceof Map) {
+    for (const [toolName, registration] of registeredTools.entries()) {
+      wrapHandler(toolName, registration);
+    }
+    return wrappedAny;
+  }
+  for (const [toolName, registration] of Object.entries(registeredTools)) {
+    wrapHandler(toolName, registration);
+  }
+  return wrappedAny;
+}
+function collectLocalMcpServerToolHookNames(serverName, serverConfig) {
+  const toolNames = /* @__PURE__ */ new Set();
+  if (!serverConfig || typeof serverConfig !== "object") {
+    return toolNames;
+  }
+  if ("instance" in serverConfig) {
+    const instance = Reflect.get(serverConfig, "instance");
+    const registeredTools = getRegisteredTools(instance);
+    if (registeredTools instanceof Map) {
+      for (const toolName of registeredTools.keys()) {
+        toolNames.add(toolName);
+        toolNames.add(`mcp__${serverName}__${toolName}`);
+      }
+    } else if (registeredTools) {
+      for (const toolName of Object.keys(registeredTools)) {
+        toolNames.add(toolName);
+        toolNames.add(`mcp__${serverName}__${toolName}`);
+      }
+    }
+  }
+  if ("tools" in serverConfig) {
+    const rawTools = Reflect.get(serverConfig, "tools");
+    if (Array.isArray(rawTools)) {
+      for (const tool of rawTools) {
+        if (!tool || typeof tool !== "object") {
+          continue;
+        }
+        const toolName = Reflect.get(tool, "name");
+        if (typeof toolName !== "string") {
+          continue;
+        }
+        toolNames.add(toolName);
+        toolNames.add(`mcp__${serverName}__${toolName}`);
+      }
+    }
+  }
+  return toolNames;
+}
+
+// src/instrumentation/plugins/claude-agent-sdk-plugin.ts
+var ROOT_LLM_PARENT_KEY = "__root__";
+function llmParentKey(parentToolUseId) {
+  return _nullishCoalesce(parentToolUseId, () => ( ROOT_LLM_PARENT_KEY));
+}
+function isSubAgentToolName(toolName) {
+  return toolName === "Agent" || toolName === "Task";
+}
+function filterSerializableOptions(options) {
+  const allowedKeys = [
+    "model",
+    "maxTurns",
+    "cwd",
+    "continue",
+    "allowedTools",
+    "disallowedTools",
+    "additionalDirectories",
+    "permissionMode",
+    "debug",
+    "apiKey",
+    "apiKeySource",
+    "agentName",
+    "instructions"
+  ];
+  const filtered = {};
+  for (const key of allowedKeys) {
+    if (options[key] !== void 0) {
+      filtered[key] = options[key];
+    }
+  }
+  return filtered;
+}
+function getNumberProperty(obj, key) {
+  if (!obj || typeof obj !== "object" || !(key in obj)) {
+    return void 0;
+  }
+  const value = Reflect.get(obj, key);
+  return typeof value === "number" ? value : void 0;
+}
+function extractUsageFromMessage(message) {
+  const metrics = {};
+  let usage;
+  if (message.type === "assistant") {
+    usage = _optionalChain([message, 'access', _241 => _241.message, 'optionalAccess', _242 => _242.usage]);
+  } else if (message.type === "result") {
+    usage = message.usage;
+  }
+  if (!usage || typeof usage !== "object") {
+    return metrics;
+  }
+  const inputTokens = getNumberProperty(usage, "input_tokens");
+  if (inputTokens !== void 0) {
+    metrics.prompt_tokens = inputTokens;
+  }
+  const outputTokens = getNumberProperty(usage, "output_tokens");
+  if (outputTokens !== void 0) {
+    metrics.completion_tokens = outputTokens;
+  }
+  const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
+  const cacheCreationTokens = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
+  if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
+    Object.assign(
+      metrics,
+      extractAnthropicCacheTokens(cacheReadTokens, cacheCreationTokens)
+    );
+  }
+  if (Object.keys(metrics).length > 0) {
+    Object.assign(metrics, finalizeAnthropicTokens(metrics));
+  }
+  return metrics;
+}
+function buildLLMInput(prompt, conversationHistory, capturedPromptMessages) {
+  const promptMessages = [];
+  if (typeof prompt === "string") {
+    promptMessages.push({ content: prompt, role: "user" });
+  } else if (capturedPromptMessages && capturedPromptMessages.length > 0) {
+    for (const msg of capturedPromptMessages) {
+      const role = _optionalChain([msg, 'access', _243 => _243.message, 'optionalAccess', _244 => _244.role]);
+      const content = _optionalChain([msg, 'access', _245 => _245.message, 'optionalAccess', _246 => _246.content]);
+      if (role && content !== void 0) {
+        promptMessages.push({ content, role });
+      }
+    }
+  }
+  const inputParts = [...promptMessages, ...conversationHistory];
+  return inputParts.length > 0 ? inputParts : void 0;
+}
+function formatCapturedMessages(messages) {
+  return messages.length > 0 ? messages : [];
+}
+async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, capturedPromptMessages, parentSpan, existingSpan) {
+  if (messages.length === 0) {
+    return void 0;
+  }
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _247 => _247.message, 'optionalAccess', _248 => _248.usage])) {
+    return void 0;
+  }
+  const model = lastMessage.message.model || options.model;
   const usage = extractUsageFromMessage(lastMessage);
   const input = buildLLMInput(
     prompt,
@@ -12396,26 +12961,31 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
     capturedPromptMessages
   );
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _244 => _244.message, 'optionalAccess', _245 => _245.content]) && _optionalChain([m, 'access', _246 => _246.message, 'optionalAccess', _247 => _247.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _249 => _249.message, 'optionalAccess', _250 => _250.content]) && _optionalChain([m, 'access', _251 => _251.message, 'optionalAccess', _252 => _252.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter(
     (c) => c !== void 0
   );
-  const span = startSpan({
+  const span = _nullishCoalesce(existingSpan, () => ( startSpan({
     name: "anthropic.messages.create",
     parent: parentSpan,
     spanAttributes: {
       type: "llm" /* LLM */
     },
     startTime
-  });
+  })));
   span.log({
     input,
     metadata: model ? { model } : void 0,
     metrics: usage,
     output: outputs
   });
+  const spanExport = await span.export();
   await span.end();
-  return _optionalChain([lastMessage, 'access', _248 => _248.message, 'optionalAccess', _249 => _249.content]) && _optionalChain([lastMessage, 'access', _250 => _250.message, 'optionalAccess', _251 => _251.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  const finalMessage = _optionalChain([lastMessage, 'access', _253 => _253.message, 'optionalAccess', _254 => _254.content]) && _optionalChain([lastMessage, 'access', _255 => _255.message, 'optionalAccess', _256 => _256.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return {
+    finalMessage,
+    spanExport
+  };
 }
 function getMcpServerMetadata(serverName, mcpServers) {
   if (!serverName || !mcpServers) {
@@ -12459,11 +13029,51 @@ function parseToolName(rawToolName) {
     toolName: rawToolName
   };
 }
-function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, subAgentSpans, endedSubAgentSpans) {
+function isLocalToolUse(rawToolName, mcpServers) {
+  const parsed = parseToolName(rawToolName);
+  if (!parsed.mcpServer || !mcpServers) {
+    return false;
+  }
+  const serverConfig = mcpServers[parsed.mcpServer];
+  if (!serverConfig || typeof serverConfig !== "object") {
+    return false;
+  }
+  return serverConfig.type === "sdk" || "transport" in serverConfig;
+}
+function prepareLocalToolHandlersInMcpServers(mcpServers) {
+  const localToolHookNames = /* @__PURE__ */ new Set();
+  if (!mcpServers) {
+    return {
+      hasLocalToolHandlers: false,
+      localToolHookNames
+    };
+  }
+  let hasLocalToolHandlers = false;
+  for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+    const toolNames = collectLocalMcpServerToolHookNames(
+      serverName,
+      serverConfig
+    );
+    for (const toolName of toolNames) {
+      localToolHookNames.add(toolName);
+    }
+    if (toolNames.size > 0) {
+      hasLocalToolHandlers = true;
+    }
+    if (wrapLocalMcpServerToolHandlers(serverName, serverConfig)) {
+      hasLocalToolHandlers = true;
+    }
+  }
+  return { hasLocalToolHandlers, localToolHookNames };
+}
+function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, localToolHookNames, skipLocalToolHooks, subAgentSpans, endedSubAgentSpans) {
   const preToolUse = async (input, toolUseID) => {
     if (input.hook_event_name !== "PreToolUse" || !toolUseID) {
       return {};
     }
+    if (skipLocalToolHooks && (isLocalToolUse(input.tool_name, mcpServers) || localToolHookNames.has(input.tool_name))) {
+      return {};
+    }
     if (isSubAgentToolName(input.tool_name)) {
       return {};
     }
@@ -12492,23 +13102,26 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
     if (input.hook_event_name !== "PostToolUse" || !toolUseID) {
       return {};
     }
+    if (skipLocalToolHooks && (isLocalToolUse(input.tool_name, mcpServers) || localToolHookNames.has(input.tool_name))) {
+      return {};
+    }
     const subAgentSpan = subAgentSpans.get(toolUseID);
     if (subAgentSpan) {
       try {
         const response = input.tool_response;
         const metadata = {};
-        if (_optionalChain([response, 'optionalAccess', _252 => _252.status])) {
+        if (_optionalChain([response, 'optionalAccess', _257 => _257.status])) {
           metadata["claude_agent_sdk.status"] = response.status;
         }
-        if (_optionalChain([response, 'optionalAccess', _253 => _253.totalDurationMs])) {
+        if (_optionalChain([response, 'optionalAccess', _258 => _258.totalDurationMs])) {
           metadata["claude_agent_sdk.duration_ms"] = response.totalDurationMs;
         }
-        if (_optionalChain([response, 'optionalAccess', _254 => _254.totalToolUseCount]) !== void 0) {
+        if (_optionalChain([response, 'optionalAccess', _259 => _259.totalToolUseCount]) !== void 0) {
           metadata["claude_agent_sdk.tool_use_count"] = response.totalToolUseCount;
         }
         subAgentSpan.log({
           metadata,
-          output: _optionalChain([response, 'optionalAccess', _255 => _255.content])
+          output: _optionalChain([response, 'optionalAccess', _260 => _260.content])
         });
       } finally {
         subAgentSpan.end();
@@ -12532,6 +13145,9 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
     if (input.hook_event_name !== "PostToolUseFailure" || !toolUseID) {
       return {};
     }
+    if (skipLocalToolHooks && (isLocalToolUse(input.tool_name, mcpServers) || localToolHookNames.has(input.tool_name))) {
+      return {};
+    }
     const subAgentSpan = subAgentSpans.get(toolUseID);
     if (subAgentSpan) {
       try {
@@ -12566,11 +13182,13 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
   };
   return { postToolUse, postToolUseFailure, preToolUse };
 }
-function injectTracingHooks(options, resolveParentSpan, activeToolSpans, subAgentSpans, endedSubAgentSpans) {
+function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localToolHookNames, skipLocalToolHooks, subAgentSpans, endedSubAgentSpans) {
   const { preToolUse, postToolUse, postToolUseFailure } = createToolTracingHooks(
     resolveParentSpan,
     activeToolSpans,
     options.mcpServers,
+    localToolHookNames,
+    skipLocalToolHooks,
     subAgentSpans,
     endedSubAgentSpans
   );
@@ -12600,7 +13218,8 @@ async function finalizeCurrentMessageGroup(state) {
   if (state.currentMessages.length === 0) {
     return;
   }
-  const parentToolUseId = _nullishCoalesce(_optionalChain([state, 'access', _256 => _256.currentMessages, 'access', _257 => _257[0], 'optionalAccess', _258 => _258.parent_tool_use_id]), () => ( null));
+  const parentToolUseId = _nullishCoalesce(_optionalChain([state, 'access', _261 => _261.currentMessages, 'access', _262 => _262[0], 'optionalAccess', _263 => _263.parent_tool_use_id]), () => ( null));
+  const parentKey = llmParentKey(parentToolUseId);
   let parentSpan = await state.span.export();
   if (parentToolUseId) {
     const subAgentSpan = state.subAgentSpans.get(parentToolUseId);
@@ -12608,26 +13227,39 @@ async function finalizeCurrentMessageGroup(state) {
       parentSpan = await subAgentSpan.export();
     }
   }
-  const finalMessage = await createLLMSpanForMessages(
+  const existingLlmSpan = state.activeLlmSpansByParentToolUse.get(parentKey);
+  const llmSpanResult = await createLLMSpanForMessages(
     state.currentMessages,
     state.originalPrompt,
     state.finalResults,
     state.options,
     state.currentMessageStartTime,
     state.capturedPromptMessages,
-    parentSpan
+    parentSpan,
+    existingLlmSpan
   );
-  if (finalMessage) {
-    state.finalResults.push(finalMessage);
+  state.activeLlmSpansByParentToolUse.delete(parentKey);
+  if (llmSpanResult) {
+    if (parentToolUseId) {
+      state.latestLlmParentBySubAgentToolUse.set(
+        parentToolUseId,
+        llmSpanResult.spanExport
+      );
+    } else {
+      state.latestRootLlmParentRef.value = llmSpanResult.spanExport;
+    }
+    if (llmSpanResult.finalMessage) {
+      state.finalResults.push(llmSpanResult.finalMessage);
+    }
   }
   const lastMessage = state.currentMessages[state.currentMessages.length - 1];
-  if (_optionalChain([lastMessage, 'optionalAccess', _259 => _259.message, 'optionalAccess', _260 => _260.usage])) {
+  if (_optionalChain([lastMessage, 'optionalAccess', _264 => _264.message, 'optionalAccess', _265 => _265.usage])) {
     state.accumulatedOutputTokens += getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
   }
   state.currentMessages.length = 0;
 }
 function maybeTrackToolUseContext(state, message) {
-  if (message.type !== "assistant" || !Array.isArray(_optionalChain([message, 'access', _261 => _261.message, 'optionalAccess', _262 => _262.content]))) {
+  if (message.type !== "assistant" || !Array.isArray(_optionalChain([message, 'access', _266 => _266.message, 'optionalAccess', _267 => _267.content]))) {
     return;
   }
   const parentToolUseId = _nullishCoalesce(message.parent_tool_use_id, () => ( null));
@@ -12679,13 +13311,36 @@ async function ensureSubAgentSpan(pendingSubAgentNames, rootSpan, subAgentSpans,
 async function handleStreamMessage(state, message) {
   maybeTrackToolUseContext(state, message);
   await maybeStartSubAgentSpan(state, message);
-  const messageId = _optionalChain([message, 'access', _263 => _263.message, 'optionalAccess', _264 => _264.id]);
+  const messageId = _optionalChain([message, 'access', _268 => _268.message, 'optionalAccess', _269 => _269.id]);
   if (messageId && messageId !== state.currentMessageId) {
     await finalizeCurrentMessageGroup(state);
     state.currentMessageId = messageId;
     state.currentMessageStartTime = getCurrentUnixTimestamp();
   }
-  if (message.type === "assistant" && _optionalChain([message, 'access', _265 => _265.message, 'optionalAccess', _266 => _266.usage])) {
+  if (message.type === "assistant" && _optionalChain([message, 'access', _270 => _270.message, 'optionalAccess', _271 => _271.usage])) {
+    const parentToolUseId = _nullishCoalesce(message.parent_tool_use_id, () => ( null));
+    const parentKey = llmParentKey(parentToolUseId);
+    if (!state.activeLlmSpansByParentToolUse.has(parentKey)) {
+      let llmParentSpan = await state.span.export();
+      if (parentToolUseId) {
+        const subAgentSpan = await ensureSubAgentSpan(
+          state.pendingSubAgentNames,
+          state.span,
+          state.subAgentSpans,
+          parentToolUseId
+        );
+        llmParentSpan = await subAgentSpan.export();
+      }
+      const llmSpan = startSpan({
+        name: "anthropic.messages.create",
+        parent: llmParentSpan,
+        spanAttributes: {
+          type: "llm" /* LLM */
+        },
+        startTime: state.currentMessageStartTime
+      });
+      state.activeLlmSpansByParentToolUse.set(parentKey, llmSpan);
+    }
     state.currentMessages.push(message);
   }
   if (message.type !== "result" || !message.usage) {
@@ -12694,7 +13349,7 @@ async function handleStreamMessage(state, message) {
   const finalUsageMetrics = extractUsageFromMessage(message);
   if (state.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
     const lastMessage = state.currentMessages[state.currentMessages.length - 1];
-    if (_optionalChain([lastMessage, 'optionalAccess', _267 => _267.message, 'optionalAccess', _268 => _268.usage])) {
+    if (_optionalChain([lastMessage, 'optionalAccess', _272 => _272.message, 'optionalAccess', _273 => _273.usage])) {
       const adjustedTokens = finalUsageMetrics.completion_tokens - state.accumulatedOutputTokens;
       if (adjustedTokens >= 0) {
         lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -12746,6 +13401,10 @@ async function finalizeQuerySpan(state) {
       }
     }
   } finally {
+    for (const llmSpan of state.activeLlmSpansByParentToolUse.values()) {
+      llmSpan.end();
+    }
+    state.activeLlmSpansByParentToolUse.clear();
     for (const [id, subAgentSpan] of state.subAgentSpans) {
       if (!state.endedSubAgentSpans.has(id)) {
         subAgentSpan.end();
@@ -12791,7 +13450,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
                 yield message;
               }
             } finally {
-              _optionalChain([resolvePromptDone, 'optionalCall', _269 => _269()]);
+              _optionalChain([resolvePromptDone, 'optionalCall', _274 => _274()]);
             }
           })();
         }
@@ -12811,26 +13470,51 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           console.error("Error extracting input for Claude Agent SDK:", error);
         }
         const activeToolSpans = /* @__PURE__ */ new Map();
+        const activeLlmSpansByParentToolUse = /* @__PURE__ */ new Map();
         const subAgentSpans = /* @__PURE__ */ new Map();
         const endedSubAgentSpans = /* @__PURE__ */ new Set();
         const toolUseToParent = /* @__PURE__ */ new Map();
+        const latestLlmParentBySubAgentToolUse = /* @__PURE__ */ new Map();
+        const latestRootLlmParentRef = {
+          value: void 0
+        };
         const pendingSubAgentNames = /* @__PURE__ */ new Map();
+        const localToolContext = createClaudeLocalToolContext();
+        const { hasLocalToolHandlers, localToolHookNames } = prepareLocalToolHandlersInMcpServers(options.mcpServers);
+        const skipLocalToolHooks = options[CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION] === true || hasLocalToolHandlers;
+        const resolveToolUseParentSpan = async (toolUseID) => {
+          const parentToolUseId = _nullishCoalesce(toolUseToParent.get(toolUseID), () => ( null));
+          const parentKey = llmParentKey(parentToolUseId);
+          const activeLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
+          if (activeLlmSpan) {
+            return activeLlmSpan.export();
+          }
+          if (parentToolUseId) {
+            const parentLlm = latestLlmParentBySubAgentToolUse.get(parentToolUseId);
+            if (parentLlm) {
+              return parentLlm;
+            }
+            const subAgentSpan = await ensureSubAgentSpan(
+              pendingSubAgentNames,
+              span,
+              subAgentSpans,
+              parentToolUseId
+            );
+            return subAgentSpan.export();
+          }
+          if (latestRootLlmParentRef.value) {
+            return latestRootLlmParentRef.value;
+          }
+          return span.export();
+        };
+        localToolContext.resolveLocalToolParent = resolveToolUseParentSpan;
+        setClaudeLocalToolParentResolver(resolveToolUseParentSpan);
         const optionsWithHooks = injectTracingHooks(
           options,
-          async (toolUseID) => {
-            const parentToolUseId = toolUseToParent.get(toolUseID);
-            if (parentToolUseId) {
-              const subAgentSpan = await ensureSubAgentSpan(
-                pendingSubAgentNames,
-                span,
-                subAgentSpans,
-                parentToolUseId
-              );
-              return subAgentSpan.export();
-            }
-            return span.export();
-          },
+          resolveToolUseParentSpan,
           activeToolSpans,
+          localToolHookNames,
+          skipLocalToolHooks,
           subAgentSpans,
           endedSubAgentSpans
         );
@@ -12838,6 +13522,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         event.arguments[0] = params;
         spans.set(event, {
           accumulatedOutputTokens: 0,
+          activeLlmSpansByParentToolUse,
           activeToolSpans,
           capturedPromptMessages,
           currentMessageId: void 0,
@@ -12853,7 +13538,10 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           promptStarted: () => promptStarted,
           span,
           subAgentSpans,
-          toolUseToParent
+          latestLlmParentBySubAgentToolUse,
+          latestRootLlmParentRef,
+          toolUseToParent,
+          localToolContext
         });
       },
       end: (event) => {
@@ -12861,7 +13549,10 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         if (!state) {
           return;
         }
-        const eventResult = event.result;
+        const eventResult = bindClaudeLocalToolContextToAsyncIterable(
+          event.result,
+          state.localToolContext
+        );
         if (eventResult === void 0) {
           state.span.end();
           spans.delete(event);
@@ -13023,7 +13714,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
     };
     tracingChannel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _270 => _270()]);
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _275 => _275()]);
       tracingChannel2.unsubscribe(handlers);
     });
   }
@@ -13066,21 +13757,22 @@ function ensureSpanState(states, event, create) {
 }
 function bindCurrentSpanStoreToStart2(tracingChannel2, states, create) {
   const state = _internalGetGlobalState();
+  const contextManager = _optionalChain([state, 'optionalAccess', _276 => _276.contextManager]);
   const startChannel = tracingChannel2.start;
-  const currentSpanStore = _optionalChain([state, 'optionalAccess', _271 => _271.contextManager]) ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
-  if (!_optionalChain([startChannel, 'optionalAccess', _272 => _272.bindStore]) || !currentSpanStore) {
+  const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (!_optionalChain([startChannel, 'optionalAccess', _277 => _277.bindStore]) || !currentSpanStore) {
     return void 0;
   }
-  startChannel.bindStore(
-    currentSpanStore,
-    (event) => ensureSpanState(
+  startChannel.bindStore(currentSpanStore, (event) => {
+    const span = ensureSpanState(
       states,
       event,
       () => create(event)
-    ).span
-  );
+    ).span;
+    return contextManager.wrapSpanForStore(span);
+  });
   return () => {
-    _optionalChain([startChannel, 'access', _273 => _273.unbindStore, 'optionalCall', _274 => _274(currentSpanStore)]);
+    _optionalChain([startChannel, 'access', _278 => _278.unbindStore, 'optionalCall', _279 => _279(currentSpanStore)]);
   };
 }
 function logErrorAndEndSpan(states, event) {
@@ -13301,7 +13993,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _275 => _275.config, 'optionalAccess', _276 => _276.tools])) {
+  if (!_optionalChain([params, 'access', _280 => _280.config, 'optionalAccess', _281 => _281.tools])) {
     return null;
   }
   try {
@@ -13344,7 +14036,7 @@ function extractGenerateContentMetrics(response, startTime) {
     metrics.end = end;
     metrics.duration = end - startTime;
   }
-  if (_optionalChain([response, 'optionalAccess', _277 => _277.usageMetadata])) {
+  if (_optionalChain([response, 'optionalAccess', _282 => _282.usageMetadata])) {
     populateUsageMetrics(metrics, response.usageMetadata);
   }
   return metrics;
@@ -13391,7 +14083,7 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _278 => _278.content, 'optionalAccess', _279 => _279.parts])) {
+        if (_optionalChain([candidate, 'access', _283 => _283.content, 'optionalAccess', _284 => _284.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -13422,7 +14114,7 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _280 => _280.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _285 => _285.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -13473,20 +14165,8 @@ function tryToDict(obj) {
   return null;
 }
 
-// src/instrumentation/plugins/openrouter-channels.ts
-var openRouterChannels = defineChannels("@openrouter/sdk", {
-  chatSend: channel({
-    channelName: "chat.send",
-    kind: "async"
-  }),
-  embeddingsGenerate: channel({
-    channelName: "embeddings.generate",
-    kind: "async"
-  }),
-  betaResponsesSend: channel({
-    channelName: "beta.responses.send",
-    kind: "async"
-  }),
+// src/instrumentation/plugins/openrouter-agent-channels.ts
+var openRouterAgentChannels = defineChannels("@openrouter/agent", {
   callModel: channel({
     channelName: "callModel",
     kind: "sync-stream"
@@ -13501,35 +14181,832 @@ var openRouterChannels = defineChannels("@openrouter/sdk", {
   })
 });
 
-// src/instrumentation/plugins/openrouter-plugin.ts
-var OpenRouterPlugin = class extends BasePlugin {
+// src/instrumentation/plugins/openrouter-agent-plugin.ts
+var OpenRouterAgentPlugin = class extends BasePlugin {
   onEnable() {
-    this.subscribeToOpenRouterChannels();
+    this.subscribeToOpenRouterAgentChannels();
   }
   onDisable() {
     this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
-  subscribeToOpenRouterChannels() {
+  subscribeToOpenRouterAgentChannels() {
     this.unsubscribers.push(
-      traceStreamingChannel(openRouterChannels.chatSend, {
-        name: "openrouter.chat.send",
+      traceSyncStreamChannel(openRouterAgentChannels.callModel, {
+        name: "openrouter.callModel",
         type: "llm" /* LLM */,
         extractInput: (args) => {
-          const request = getOpenRouterRequestArg(args);
-          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _281 => _281.chatGenerationParams])) ? request.chatGenerationParams : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _282 => _282.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _283 => _283.xTitle]);
-          const { messages, ...metadata } = chatGenerationParams;
+          const request = getOpenRouterCallModelRequestArg(args);
           return {
-            input: messages,
-            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+            input: request ? extractOpenRouterCallModelInput(request) : void 0,
+            metadata: request ? extractOpenRouterCallModelMetadata(request) : { provider: "openrouter" }
+          };
+        },
+        patchResult: ({ endEvent, result, span }) => {
+          return patchOpenRouterCallModelResult({
+            request: getOpenRouterCallModelRequestArg(endEvent.arguments),
+            result,
+            span
+          });
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(openRouterAgentChannels.callModelTurn, {
+        name: "openrouter.beta.responses.send",
+        type: "llm" /* LLM */,
+        extractInput: (args, event) => {
+          const request = getOpenRouterCallModelRequestArg(args);
+          const metadata = request ? extractOpenRouterCallModelMetadata(request) : { provider: "openrouter" };
+          if (isObject(metadata) && "tools" in metadata) {
+            delete metadata.tools;
+          }
+          return {
+            input: request ? extractOpenRouterCallModelInput(request) : void 0,
+            metadata: {
+              ...metadata,
+              step: event.step,
+              step_type: event.stepType
+            }
+          };
+        },
+        extractOutput: (result) => extractOpenRouterResponseOutput(result),
+        extractMetadata: (result, event) => {
+          if (!isObject(result)) {
+            return {
+              step: _optionalChain([event, 'optionalAccess', _286 => _286.step]),
+              step_type: _optionalChain([event, 'optionalAccess', _287 => _287.stepType])
+            };
+          }
+          return {
+            ...extractOpenRouterResponseMetadata(result) || {},
+            ..._optionalChain([event, 'optionalAccess', _288 => _288.step]) !== void 0 ? { step: event.step } : {},
+            ..._optionalChain([event, 'optionalAccess', _289 => _289.stepType]) ? { step_type: event.stepType } : {}
+          };
+        },
+        extractMetrics: (result) => isObject(result) ? parseOpenRouterMetricsFromUsage(result.usage) : {}
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterAgentChannels.toolExecute, {
+        name: "openrouter.tool",
+        type: "tool" /* TOOL */,
+        extractInput: (args, event) => ({
+          input: args[0],
+          metadata: {
+            provider: "openrouter",
+            tool_name: event.toolName,
+            ...event.toolCallId ? { tool_call_id: event.toolCallId } : {}
+          }
+        }),
+        extractOutput: (result) => result,
+        extractMetrics: () => ({}),
+        aggregateChunks: (chunks) => ({
+          output: chunks.length > 0 ? chunks[chunks.length - 1] : void 0,
+          metrics: {}
+        })
+      })
+    );
+    const callModelChannel = openRouterAgentChannels.callModel.tracingChannel();
+    const callModelHandlers = {
+      start: (event) => {
+        const request = getOpenRouterCallModelRequestArg(event.arguments);
+        if (!request) {
+          return;
+        }
+        patchOpenRouterCallModelRequestTools(request);
+      }
+    };
+    callModelChannel.subscribe(callModelHandlers);
+    this.unsubscribers.push(() => {
+      callModelChannel.unsubscribe(callModelHandlers);
+    });
+  }
+};
+function normalizeArgs(args) {
+  if (Array.isArray(args)) {
+    return args;
+  }
+  if (isArrayLike(args)) {
+    return Array.from(args);
+  }
+  return [args];
+}
+function isArrayLike(value) {
+  return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
+}
+function getOpenRouterCallModelRequestArg(args) {
+  const normalizedArgs = normalizeArgs(args);
+  const keyedRequestArg = normalizedArgs.find(
+    (arg) => isObject(arg) && ("input" in arg || "model" in arg || "tools" in arg)
+  );
+  if (isObject(keyedRequestArg)) {
+    return keyedRequestArg;
+  }
+  const firstObjectArg = normalizedArgs.find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+var TOKEN_NAME_MAP2 = {
+  promptTokens: "prompt_tokens",
+  inputTokens: "prompt_tokens",
+  completionTokens: "completion_tokens",
+  outputTokens: "completion_tokens",
+  totalTokens: "tokens",
+  prompt_tokens: "prompt_tokens",
+  input_tokens: "prompt_tokens",
+  completion_tokens: "completion_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_DETAIL_PREFIX_MAP = {
+  promptTokensDetails: "prompt",
+  inputTokensDetails: "prompt",
+  completionTokensDetails: "completion",
+  outputTokensDetails: "completion",
+  costDetails: "cost",
+  prompt_tokens_details: "prompt",
+  input_tokens_details: "prompt",
+  completion_tokens_details: "completion",
+  output_tokens_details: "completion",
+  cost_details: "cost"
+};
+function camelToSnake(value) {
+  return value.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+}
+function parseOpenRouterMetricsFromUsage(usage) {
+  if (!isObject(usage)) {
+    return {};
+  }
+  const metrics = {};
+  for (const [name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      metrics[TOKEN_NAME_MAP2[name] || camelToSnake(name)] = value;
+      continue;
+    }
+    if (!isObject(value)) {
+      continue;
+    }
+    const prefix = TOKEN_DETAIL_PREFIX_MAP[name];
+    if (!prefix) {
+      continue;
+    }
+    for (const [nestedName, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${camelToSnake(nestedName)}`] = nestedValue;
+    }
+  }
+  return metrics;
+}
+function extractOpenRouterUsageMetadata(usage) {
+  if (!isObject(usage)) {
+    return void 0;
+  }
+  const metadata = {};
+  if (typeof usage.isByok === "boolean") {
+    metadata.is_byok = usage.isByok;
+  } else if (typeof usage.is_byok === "boolean") {
+    metadata.is_byok = usage.is_byok;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+var OMITTED_OPENROUTER_KEYS = /* @__PURE__ */ new Set([
+  "execute",
+  "render",
+  "nextTurnParams",
+  "requireApproval"
+]);
+function parseOpenRouterModelString(model) {
+  if (typeof model !== "string") {
+    return { model };
+  }
+  const slashIndex = model.indexOf("/");
+  if (slashIndex > 0 && slashIndex < model.length - 1) {
+    return {
+      provider: model.substring(0, slashIndex),
+      model: model.substring(slashIndex + 1)
+    };
+  }
+  return { model };
+}
+function isZodSchema3(value) {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function serializeZodSchema3(schema) {
+  try {
+    return zodToJsonSchema(schema);
+  } catch (e36) {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
+  }
+}
+function serializeOpenRouterTool(tool) {
+  if (!isObject(tool)) {
+    return tool;
+  }
+  const serialized = {};
+  for (const [key, value] of Object.entries(tool)) {
+    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+      continue;
+    }
+    if (key === "function" && isObject(value)) {
+      serialized.function = sanitizeOpenRouterLoggedValue(value);
+      continue;
+    }
+    serialized[key] = sanitizeOpenRouterLoggedValue(value);
+  }
+  return serialized;
+}
+function serializeOpenRouterToolsForLogging(tools) {
+  if (!Array.isArray(tools)) {
+    return void 0;
+  }
+  return tools.map((tool) => serializeOpenRouterTool(tool));
+}
+function sanitizeOpenRouterLoggedValue(value) {
+  if (isZodSchema3(value)) {
+    return serializeZodSchema3(value);
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeOpenRouterLoggedValue(entry));
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+      continue;
+    }
+    if (key === "tools" && Array.isArray(entry)) {
+      sanitized.tools = serializeOpenRouterToolsForLogging(entry);
+      continue;
+    }
+    sanitized[key] = sanitizeOpenRouterLoggedValue(entry);
+  }
+  return sanitized;
+}
+function buildOpenRouterMetadata(metadata, httpReferer, appTitle, appCategories, xTitle) {
+  const sanitized = sanitizeOpenRouterLoggedValue(metadata);
+  const metadataRecord = isObject(sanitized) ? sanitized : {};
+  const { model, provider: providerRouting, ...rest } = metadataRecord;
+  const normalizedModel = parseOpenRouterModelString(model);
+  return {
+    ...rest,
+    ...normalizedModel.model !== void 0 ? { model: normalizedModel.model } : {},
+    ...providerRouting !== void 0 ? { providerRouting } : {},
+    ...httpReferer !== void 0 ? { httpReferer } : {},
+    ...appTitle !== void 0 ? { appTitle } : {},
+    ...appCategories !== void 0 ? { appCategories } : {},
+    ...xTitle !== void 0 ? { xTitle } : {},
+    provider: normalizedModel.provider || "openrouter"
+  };
+}
+function extractOpenRouterCallModelInput(request) {
+  return isObject(request) && "input" in request ? sanitizeOpenRouterLoggedValue(request.input) : void 0;
+}
+function extractOpenRouterCallModelMetadata(request) {
+  if (!isObject(request)) {
+    return { provider: "openrouter" };
+  }
+  const { input: _input, ...metadata } = request;
+  return buildOpenRouterMetadata(
+    metadata,
+    void 0,
+    void 0,
+    void 0,
+    void 0
+  );
+}
+function extractOpenRouterResponseMetadata(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const { output: _output, data: _data, usage, ...metadata } = result;
+  const sanitized = sanitizeOpenRouterLoggedValue(metadata);
+  const metadataRecord = isObject(sanitized) ? sanitized : {};
+  const { model, provider, ...rest } = metadataRecord;
+  const normalizedModel = parseOpenRouterModelString(model);
+  const normalizedProvider = (typeof provider === "string" ? provider : void 0) || normalizedModel.provider;
+  const usageMetadata = extractOpenRouterUsageMetadata(usage);
+  const combined = {
+    ...rest,
+    ...normalizedModel.model !== void 0 ? { model: normalizedModel.model } : {},
+    ...usageMetadata || {},
+    ...normalizedProvider !== void 0 ? { provider: normalizedProvider } : {}
+  };
+  return Object.keys(combined).length > 0 ? combined : void 0;
+}
+function extractOpenRouterResponseOutput(response, fallbackOutput) {
+  if (isObject(response) && "output" in response && response.output !== void 0) {
+    return sanitizeOpenRouterLoggedValue(response.output);
+  }
+  if (fallbackOutput !== void 0) {
+    return sanitizeOpenRouterLoggedValue(fallbackOutput);
+  }
+  return void 0;
+}
+var OPENROUTER_WRAPPED_TOOL = Symbol("braintrust.openrouter.wrappedTool");
+function patchOpenRouterCallModelRequestTools(request) {
+  if (!Array.isArray(request.tools) || request.tools.length === 0) {
+    return void 0;
+  }
+  const originalTools = request.tools;
+  const wrappedTools = originalTools.map((tool) => wrapOpenRouterTool(tool));
+  const didPatch = wrappedTools.some(
+    (tool, index) => tool !== originalTools[index]
+  );
+  if (!didPatch) {
+    return void 0;
+  }
+  request.tools = wrappedTools;
+  return () => {
+    request.tools = originalTools;
+  };
+}
+function wrapOpenRouterTool(tool) {
+  if (isWrappedTool(tool) || !tool.function || typeof tool.function !== "object" || typeof tool.function.execute !== "function") {
+    return tool;
+  }
+  const toolName = tool.function.name || "tool";
+  const originalExecute = tool.function.execute;
+  const wrappedTool = {
+    ...tool,
+    function: {
+      ...tool.function,
+      execute(...args) {
+        return traceToolExecution({
+          args,
+          execute: () => Reflect.apply(originalExecute, this, args),
+          toolCallId: getToolCallId(args[1]),
+          toolName
+        });
+      }
+    }
+  };
+  Object.defineProperty(wrappedTool, OPENROUTER_WRAPPED_TOOL, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  return wrappedTool;
+}
+function isWrappedTool(tool) {
+  return Boolean(tool[OPENROUTER_WRAPPED_TOOL]);
+}
+function traceToolExecution(args) {
+  const tracingChannel2 = openRouterAgentChannels.toolExecute.tracingChannel();
+  const input = args.args.length > 0 ? args.args[0] : void 0;
+  const event = {
+    arguments: [input],
+    span_info: {
+      name: args.toolName
+    },
+    toolCallId: args.toolCallId,
+    toolName: args.toolName
+  };
+  tracingChannel2.start.publish(event);
+  try {
+    const result = args.execute();
+    return publishToolResult(tracingChannel2, event, result);
+  } catch (error) {
+    event.error = normalizeError(error);
+    tracingChannel2.error.publish(event);
+    throw error;
+  }
+}
+function publishToolResult(tracingChannel2, event, result) {
+  if (isPromiseLike3(result)) {
+    return result.then(
+      (resolved) => {
+        event.result = resolved;
+        tracingChannel2.asyncEnd.publish(event);
+        return resolved;
+      },
+      (error) => {
+        event.error = normalizeError(error);
+        tracingChannel2.error.publish(event);
+        throw error;
+      }
+    );
+  }
+  event.result = result;
+  tracingChannel2.asyncEnd.publish(event);
+  return result;
+}
+function getToolCallId(context) {
+  const toolContext = context;
+  return typeof _optionalChain([toolContext, 'optionalAccess', _290 => _290.toolCall, 'optionalAccess', _291 => _291.id]) === "string" ? toolContext.toolCall.id : void 0;
+}
+function isPromiseLike3(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+var OPENROUTER_WRAPPED_CALL_MODEL_RESULT = Symbol(
+  "braintrust.openrouter.wrappedCallModelResult"
+);
+var OPENROUTER_CALL_MODEL_STREAM_METHODS = [
+  "getFullResponsesStream",
+  "getItemsStream",
+  "getNewMessagesStream",
+  "getReasoningStream",
+  "getTextStream",
+  "getToolCallsStream",
+  "getToolStream"
+];
+var OPENROUTER_CALL_MODEL_CONTEXT_METHODS = [
+  "cancel",
+  "getPendingToolCalls",
+  "getState",
+  "getToolCalls",
+  "requiresApproval"
+];
+function patchOpenRouterCallModelResult(args) {
+  const { request, result, span } = args;
+  if (!isObject(result) || isWrappedCallModelResult(result)) {
+    return false;
+  }
+  const resultLike = result;
+  const hasInstrumentableMethod = typeof resultLike.getResponse === "function" || typeof resultLike.getText === "function" || OPENROUTER_CALL_MODEL_STREAM_METHODS.some(
+    (methodName) => typeof resultLike[methodName] === "function"
+  );
+  if (!hasInstrumentableMethod) {
+    return false;
+  }
+  Object.defineProperty(resultLike, OPENROUTER_WRAPPED_CALL_MODEL_RESULT, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  const originalGetResponse = typeof resultLike.getResponse === "function" ? resultLike.getResponse.bind(resultLike) : void 0;
+  const originalGetInitialResponse = typeof resultLike.getInitialResponse === "function" ? resultLike.getInitialResponse.bind(resultLike) : void 0;
+  const originalMakeFollowupRequest = typeof resultLike.makeFollowupRequest === "function" ? resultLike.makeFollowupRequest.bind(resultLike) : void 0;
+  let ended = false;
+  let tracedTurnCount = 0;
+  const endSpanWithResult = async (response, fallbackOutput) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    const finalResponse = getFinalOpenRouterCallModelResponse(
+      resultLike,
+      response
+    );
+    if (finalResponse) {
+      const rounds = getOpenRouterCallModelRounds(resultLike);
+      const metadata = extractOpenRouterCallModelResultMetadata(
+        finalResponse,
+        rounds.length + 1
+      );
+      span.log({
+        output: extractOpenRouterResponseOutput(finalResponse, fallbackOutput),
+        ...metadata ? { metadata } : {},
+        metrics: aggregateOpenRouterCallModelMetrics(rounds, finalResponse)
+      });
+      span.end();
+      return;
+    }
+    if (fallbackOutput !== void 0) {
+      span.log({
+        output: fallbackOutput
+      });
+    }
+    span.end();
+  };
+  const endSpanWithError = (error) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    span.log({
+      error: normalizeError(error).message
+    });
+    span.end();
+  };
+  const finalizeFromResponse = async (fallbackOutput) => {
+    if (!originalGetResponse) {
+      await endSpanWithResult(void 0, fallbackOutput);
+      return;
+    }
+    try {
+      await endSpanWithResult(await originalGetResponse(), fallbackOutput);
+    } catch (e37) {
+      await endSpanWithResult(void 0, fallbackOutput);
+    }
+  };
+  if (originalGetResponse) {
+    resultLike.getResponse = async (...args2) => {
+      return await withCurrent(span, async () => {
+        try {
+          const response = await originalGetResponse(...args2);
+          await endSpanWithResult(response);
+          return response;
+        } catch (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
+    };
+  }
+  if (typeof resultLike.getText === "function") {
+    const originalGetText = resultLike.getText.bind(resultLike);
+    resultLike.getText = async (...args2) => {
+      return await withCurrent(span, async () => {
+        try {
+          const text = await originalGetText(...args2);
+          await finalizeFromResponse(text);
+          return text;
+        } catch (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_CONTEXT_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
+      continue;
+    }
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = async (...args2) => {
+      return await withCurrent(span, async () => {
+        return await originalMethod.apply(resultLike, args2);
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_STREAM_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
+      continue;
+    }
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = (...args2) => {
+      const stream = withCurrent(
+        span,
+        () => originalMethod.apply(resultLike, args2)
+      );
+      if (!isAsyncIterable3(stream)) {
+        return stream;
+      }
+      return wrapAsyncIterableWithSpan({
+        finalize: finalizeFromResponse,
+        iteratorFactory: () => stream[Symbol.asyncIterator](),
+        onError: endSpanWithError,
+        span
+      });
+    };
+  }
+  if (originalGetInitialResponse) {
+    let initialTurnTraced = false;
+    resultLike.getInitialResponse = async (...args2) => {
+      if (initialTurnTraced) {
+        return await withCurrent(span, async () => {
+          return await originalGetInitialResponse(...args2);
+        });
+      }
+      initialTurnTraced = true;
+      const step = tracedTurnCount + 1;
+      const stepType = tracedTurnCount === 0 ? "initial" : "continue";
+      const response = await traceOpenRouterCallModelTurn({
+        fn: async () => {
+          const nextResponse = await originalGetInitialResponse(...args2);
+          tracedTurnCount++;
+          return nextResponse;
+        },
+        parentSpan: span,
+        request: getOpenRouterResolvedRequest(resultLike, request),
+        step,
+        stepType
+      });
+      return response;
+    };
+  }
+  if (originalMakeFollowupRequest) {
+    resultLike.makeFollowupRequest = async (...args2) => {
+      const currentResponse = args2[0];
+      const toolResults = Array.isArray(args2[1]) ? args2[1] : [];
+      const step = tracedTurnCount + 1;
+      const response = await traceOpenRouterCallModelTurn({
+        fn: async () => {
+          const nextResponse = await originalMakeFollowupRequest(...args2);
+          tracedTurnCount++;
+          return nextResponse;
+        },
+        parentSpan: span,
+        request: buildOpenRouterFollowupRequest(
+          getOpenRouterResolvedRequest(resultLike, request),
+          currentResponse,
+          toolResults
+        ),
+        step,
+        stepType: "continue"
+      });
+      return response;
+    };
+  }
+  return true;
+}
+async function traceOpenRouterCallModelTurn(args) {
+  const context = {
+    arguments: [args.request],
+    step: args.step,
+    stepType: args.stepType
+  };
+  return await withCurrent(
+    args.parentSpan,
+    () => openRouterAgentChannels.callModelTurn.tracePromise(args.fn, context)
+  );
+}
+function isWrappedCallModelResult(value) {
+  return Boolean(
+    isObject(value) && value[OPENROUTER_WRAPPED_CALL_MODEL_RESULT]
+  );
+}
+function extractOpenRouterCallModelResultMetadata(response, turnCount) {
+  const combined = {
+    ...extractOpenRouterResponseMetadata(response) || {},
+    ...turnCount !== void 0 ? { turn_count: turnCount } : {}
+  };
+  return Object.keys(combined).length > 0 ? combined : void 0;
+}
+function getFinalOpenRouterCallModelResponse(result, response) {
+  if (isObject(response)) {
+    return response;
+  }
+  return isObject(result.finalResponse) ? result.finalResponse : void 0;
+}
+function getOpenRouterCallModelRounds(result) {
+  if (!Array.isArray(result.allToolExecutionRounds)) {
+    return [];
+  }
+  return result.allToolExecutionRounds.filter((round) => isObject(round)).map((round) => ({
+    response: isObject(round.response) ? round.response : void 0,
+    round: typeof round.round === "number" ? round.round : void 0,
+    toolResults: Array.isArray(round.toolResults) ? round.toolResults : []
+  })).filter((round) => round.response !== void 0);
+}
+function aggregateOpenRouterCallModelMetrics(rounds, finalResponse) {
+  const metrics = {};
+  const responses = [
+    ...rounds.map((round) => round.response).filter(isObject),
+    finalResponse
+  ];
+  for (const response of responses) {
+    const responseMetrics = parseOpenRouterMetricsFromUsage(response.usage);
+    for (const [name, value] of Object.entries(responseMetrics)) {
+      metrics[name] = (metrics[name] || 0) + value;
+    }
+  }
+  return metrics;
+}
+function buildNextOpenRouterCallModelInput(currentInput, response, toolResults) {
+  const normalizedInput = Array.isArray(currentInput) ? [...currentInput] : currentInput === void 0 ? [] : [currentInput];
+  const responseOutput = Array.isArray(response.output) ? response.output : response.output === void 0 ? [] : [response.output];
+  return [...normalizedInput, ...responseOutput, ...toolResults].map(
+    (entry) => sanitizeOpenRouterLoggedValue(entry)
+  );
+}
+function getOpenRouterResolvedRequest(result, request) {
+  if (isObject(result.resolvedRequest)) {
+    return result.resolvedRequest;
+  }
+  return request;
+}
+function buildOpenRouterFollowupRequest(request, currentResponse, toolResults) {
+  if (!request) {
+    return void 0;
+  }
+  return {
+    ...request,
+    input: buildNextOpenRouterCallModelInput(
+      extractOpenRouterCallModelInput(request),
+      isObject(currentResponse) ? currentResponse : {},
+      toolResults
+    ),
+    stream: false
+  };
+}
+function wrapAsyncIterableWithSpan(args) {
+  return {
+    [Symbol.asyncIterator]() {
+      const iterator = args.iteratorFactory();
+      return {
+        next(value) {
+          return withCurrent(
+            args.span,
+            () => value === void 0 ? iterator.next() : iterator.next(value)
+          ).then(
+            async (result) => {
+              if (result.done) {
+                await args.finalize();
+              }
+              return result;
+            },
+            (error) => {
+              args.onError(error);
+              throw error;
+            }
+          );
+        },
+        return(value) {
+          if (typeof iterator.return !== "function") {
+            return args.finalize().then(() => ({
+              done: true,
+              value
+            }));
+          }
+          return withCurrent(args.span, () => iterator.return(value)).then(
+            async (result) => {
+              await args.finalize();
+              return result;
+            },
+            (error) => {
+              args.onError(error);
+              throw error;
+            }
+          );
+        },
+        throw(error) {
+          args.onError(error);
+          if (typeof iterator.throw !== "function") {
+            return Promise.reject(error);
+          }
+          return withCurrent(args.span, () => iterator.throw(error));
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    }
+  };
+}
+function isAsyncIterable3(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/instrumentation/plugins/openrouter-channels.ts
+var openRouterChannels = defineChannels("@openrouter/sdk", {
+  chatSend: channel({
+    channelName: "chat.send",
+    kind: "async"
+  }),
+  embeddingsGenerate: channel({
+    channelName: "embeddings.generate",
+    kind: "async"
+  }),
+  betaResponsesSend: channel({
+    channelName: "beta.responses.send",
+    kind: "async"
+  }),
+  callModel: channel({
+    channelName: "callModel",
+    kind: "sync-stream"
+  }),
+  callModelTurn: channel({
+    channelName: "callModel.turn",
+    kind: "async"
+  }),
+  toolExecute: channel({
+    channelName: "tool.execute",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/openrouter-plugin.ts
+var OpenRouterPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToOpenRouterChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToOpenRouterChannels() {
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.chatSend, {
+        name: "openrouter.chat.send",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _292 => _292.chatGenerationParams])) ? request.chatGenerationParams : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _293 => _293.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _294 => _294.xTitle]);
+          const { messages, ...metadata } = chatGenerationParams;
+          return {
+            input: messages,
+            metadata: buildOpenRouterMetadata2(metadata, httpReferer, xTitle)
           };
         },
         extractOutput: (result) => {
           return isObject(result) ? result.choices : void 0;
         },
         extractMetrics: (result, startTime) => {
-          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _284 => _284.usage]));
+          const metrics = parseOpenRouterMetricsFromUsage2(_optionalChain([result, 'optionalAccess', _295 => _295.usage]));
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
@@ -13544,9 +15021,9 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _285 => _285.requestBody])) ? request.requestBody : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _286 => _286.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _287 => _287.xTitle]);
+          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _296 => _296.requestBody])) ? request.requestBody : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _297 => _297.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _298 => _298.xTitle]);
           const { input, ...metadata } = requestBody;
           return {
             input,
@@ -13561,17 +15038,17 @@ var OpenRouterPlugin = class extends BasePlugin {
           if (!isObject(result)) {
             return void 0;
           }
-          const embedding = _optionalChain([result, 'access', _288 => _288.data, 'optionalAccess', _289 => _289[0], 'optionalAccess', _290 => _290.embedding]);
+          const embedding = _optionalChain([result, 'access', _299 => _299.data, 'optionalAccess', _300 => _300[0], 'optionalAccess', _301 => _301.embedding]);
           return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
         },
         extractMetadata: (result) => {
           if (!isObject(result)) {
             return void 0;
           }
-          return extractOpenRouterResponseMetadata(result);
+          return extractOpenRouterResponseMetadata2(result);
         },
         extractMetrics: (result) => {
-          return isObject(result) ? parseOpenRouterMetricsFromUsage(result.usage) : {};
+          return isObject(result) ? parseOpenRouterMetricsFromUsage2(result.usage) : {};
         }
       })
     );
@@ -13581,19 +15058,19 @@ var OpenRouterPlugin = class extends BasePlugin {
         type: "llm" /* LLM */,
         extractInput: (args) => {
           const request = getOpenRouterRequestArg(args);
-          const openResponsesRequest = isObject(_optionalChain([request, 'optionalAccess', _291 => _291.openResponsesRequest])) ? request.openResponsesRequest : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _292 => _292.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _293 => _293.xTitle]);
+          const openResponsesRequest = isObject(_optionalChain([request, 'optionalAccess', _302 => _302.openResponsesRequest])) ? request.openResponsesRequest : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _303 => _303.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _304 => _304.xTitle]);
           const { input, ...metadata } = openResponsesRequest;
           return {
             input,
-            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+            metadata: buildOpenRouterMetadata2(metadata, httpReferer, xTitle)
           };
         },
-        extractOutput: (result) => extractOpenRouterResponseOutput(result),
-        extractMetadata: (result) => extractOpenRouterResponseMetadata(result),
+        extractOutput: (result) => extractOpenRouterResponseOutput2(result),
+        extractMetadata: (result) => extractOpenRouterResponseMetadata2(result),
         extractMetrics: (result, startTime) => {
-          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _294 => _294.usage]));
+          const metrics = parseOpenRouterMetricsFromUsage2(_optionalChain([result, 'optionalAccess', _305 => _305.usage]));
           if (startTime) {
             metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
           }
@@ -13607,15 +15084,15 @@ var OpenRouterPlugin = class extends BasePlugin {
         name: "openrouter.callModel",
         type: "llm" /* LLM */,
         extractInput: (args) => {
-          const request = getOpenRouterCallModelRequestArg(args);
+          const request = getOpenRouterCallModelRequestArg2(args);
           return {
-            input: request ? extractOpenRouterCallModelInput(request) : void 0,
-            metadata: request ? extractOpenRouterCallModelMetadata(request) : { provider: "openrouter" }
+            input: request ? extractOpenRouterCallModelInput2(request) : void 0,
+            metadata: request ? extractOpenRouterCallModelMetadata2(request) : { provider: "openrouter" }
           };
         },
         patchResult: ({ endEvent, result, span }) => {
-          return patchOpenRouterCallModelResult({
-            request: getOpenRouterCallModelRequestArg(endEvent.arguments),
+          return patchOpenRouterCallModelResult2({
+            request: getOpenRouterCallModelRequestArg2(endEvent.arguments),
             result,
             span
           });
@@ -13627,13 +15104,13 @@ var OpenRouterPlugin = class extends BasePlugin {
         name: "openrouter.beta.responses.send",
         type: "llm" /* LLM */,
         extractInput: (args, event) => {
-          const request = getOpenRouterCallModelRequestArg(args);
-          const metadata = request ? extractOpenRouterCallModelMetadata(request) : { provider: "openrouter" };
+          const request = getOpenRouterCallModelRequestArg2(args);
+          const metadata = request ? extractOpenRouterCallModelMetadata2(request) : { provider: "openrouter" };
           if (isObject(metadata) && "tools" in metadata) {
             delete metadata.tools;
           }
           return {
-            input: request ? extractOpenRouterCallModelInput(request) : void 0,
+            input: request ? extractOpenRouterCallModelInput2(request) : void 0,
             metadata: {
               ...metadata,
               step: event.step,
@@ -13641,21 +15118,21 @@ var OpenRouterPlugin = class extends BasePlugin {
             }
           };
         },
-        extractOutput: (result) => extractOpenRouterResponseOutput(result),
+        extractOutput: (result) => extractOpenRouterResponseOutput2(result),
         extractMetadata: (result, event) => {
           if (!isObject(result)) {
             return {
-              step: _optionalChain([event, 'optionalAccess', _295 => _295.step]),
-              step_type: _optionalChain([event, 'optionalAccess', _296 => _296.stepType])
+              step: _optionalChain([event, 'optionalAccess', _306 => _306.step]),
+              step_type: _optionalChain([event, 'optionalAccess', _307 => _307.stepType])
             };
           }
           return {
-            ...extractOpenRouterResponseMetadata(result) || {},
-            ..._optionalChain([event, 'optionalAccess', _297 => _297.step]) !== void 0 ? { step: event.step } : {},
-            ..._optionalChain([event, 'optionalAccess', _298 => _298.stepType]) ? { step_type: event.stepType } : {}
+            ...extractOpenRouterResponseMetadata2(result) || {},
+            ..._optionalChain([event, 'optionalAccess', _308 => _308.step]) !== void 0 ? { step: event.step } : {},
+            ..._optionalChain([event, 'optionalAccess', _309 => _309.stepType]) ? { step_type: event.stepType } : {}
           };
         },
-        extractMetrics: (result) => isObject(result) ? parseOpenRouterMetricsFromUsage(result.usage) : {}
+        extractMetrics: (result) => isObject(result) ? parseOpenRouterMetricsFromUsage2(result.usage) : {}
       })
     );
     this.unsubscribers.push(
@@ -13681,11 +15158,11 @@ var OpenRouterPlugin = class extends BasePlugin {
     const callModelChannel = openRouterChannels.callModel.tracingChannel();
     const callModelHandlers = {
       start: (event) => {
-        const request = getOpenRouterCallModelRequestArg(event.arguments);
+        const request = getOpenRouterCallModelRequestArg2(event.arguments);
         if (!request) {
           return;
         }
-        patchOpenRouterCallModelRequestTools(request);
+        patchOpenRouterCallModelRequestTools2(request);
       }
     };
     callModelChannel.subscribe(callModelHandlers);
@@ -13694,20 +15171,20 @@ var OpenRouterPlugin = class extends BasePlugin {
     });
   }
 };
-function normalizeArgs(args) {
+function normalizeArgs2(args) {
   if (Array.isArray(args)) {
     return args;
   }
-  if (isArrayLike(args)) {
+  if (isArrayLike2(args)) {
     return Array.from(args);
   }
   return [args];
 }
-function isArrayLike(value) {
+function isArrayLike2(value) {
   return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
 }
 function getOpenRouterRequestArg(args) {
-  const normalizedArgs = normalizeArgs(args);
+  const normalizedArgs = normalizeArgs2(args);
   const keyedCandidate = normalizedArgs.find(
     (arg) => isObject(arg) && ("chatGenerationParams" in arg || "requestBody" in arg || "openResponsesRequest" in arg)
   );
@@ -13717,11 +15194,11 @@ function getOpenRouterRequestArg(args) {
   const firstObjectArg = normalizedArgs.find((arg) => isObject(arg));
   return isObject(firstObjectArg) ? firstObjectArg : void 0;
 }
-function getOpenRouterCallModelRequestArg(args) {
-  const firstObjectArg = normalizeArgs(args).find((arg) => isObject(arg));
+function getOpenRouterCallModelRequestArg2(args) {
+  const firstObjectArg = normalizeArgs2(args).find((arg) => isObject(arg));
   return isObject(firstObjectArg) ? firstObjectArg : void 0;
 }
-var TOKEN_NAME_MAP2 = {
+var TOKEN_NAME_MAP3 = {
   promptTokens: "prompt_tokens",
   inputTokens: "prompt_tokens",
   completionTokens: "completion_tokens",
@@ -13733,7 +15210,7 @@ var TOKEN_NAME_MAP2 = {
   output_tokens: "completion_tokens",
   total_tokens: "tokens"
 };
-var TOKEN_DETAIL_PREFIX_MAP = {
+var TOKEN_DETAIL_PREFIX_MAP2 = {
   promptTokensDetails: "prompt",
   inputTokensDetails: "prompt",
   completionTokensDetails: "completion",
@@ -13745,23 +15222,23 @@ var TOKEN_DETAIL_PREFIX_MAP = {
   output_tokens_details: "completion",
   cost_details: "cost"
 };
-function camelToSnake(value) {
+function camelToSnake2(value) {
   return value.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
 }
-function parseOpenRouterMetricsFromUsage(usage) {
+function parseOpenRouterMetricsFromUsage2(usage) {
   if (!isObject(usage)) {
     return {};
   }
   const metrics = {};
   for (const [name, value] of Object.entries(usage)) {
     if (typeof value === "number") {
-      metrics[TOKEN_NAME_MAP2[name] || camelToSnake(name)] = value;
+      metrics[TOKEN_NAME_MAP3[name] || camelToSnake2(name)] = value;
       continue;
     }
     if (!isObject(value)) {
       continue;
     }
-    const prefix = TOKEN_DETAIL_PREFIX_MAP[name];
+    const prefix = TOKEN_DETAIL_PREFIX_MAP2[name];
     if (!prefix) {
       continue;
     }
@@ -13769,12 +15246,12 @@ function parseOpenRouterMetricsFromUsage(usage) {
       if (typeof nestedValue !== "number") {
         continue;
       }
-      metrics[`${prefix}_${camelToSnake(nestedName)}`] = nestedValue;
+      metrics[`${prefix}_${camelToSnake2(nestedName)}`] = nestedValue;
     }
   }
   return metrics;
 }
-function extractOpenRouterUsageMetadata(usage) {
+function extractOpenRouterUsageMetadata2(usage) {
   if (!isObject(usage)) {
     return void 0;
   }
@@ -13786,13 +15263,13 @@ function extractOpenRouterUsageMetadata(usage) {
   }
   return Object.keys(metadata).length > 0 ? metadata : void 0;
 }
-var OMITTED_OPENROUTER_KEYS = /* @__PURE__ */ new Set([
+var OMITTED_OPENROUTER_KEYS2 = /* @__PURE__ */ new Set([
   "execute",
   "render",
   "nextTurnParams",
   "requireApproval"
 ]);
-function parseOpenRouterModelString(model) {
+function parseOpenRouterModelString2(model) {
   if (typeof model !== "string") {
     return { model };
   }
@@ -13805,73 +15282,73 @@ function parseOpenRouterModelString(model) {
   }
   return { model };
 }
-function isZodSchema3(value) {
+function isZodSchema4(value) {
   return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
 }
-function serializeZodSchema3(schema) {
+function serializeZodSchema4(schema) {
   try {
     return zodToJsonSchema(schema);
-  } catch (e36) {
+  } catch (e38) {
     return {
       type: "object",
       description: "Zod schema (conversion failed)"
     };
   }
 }
-function serializeOpenRouterTool(tool) {
+function serializeOpenRouterTool2(tool) {
   if (!isObject(tool)) {
     return tool;
   }
   const serialized = {};
   for (const [key, value] of Object.entries(tool)) {
-    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+    if (OMITTED_OPENROUTER_KEYS2.has(key)) {
       continue;
     }
     if (key === "function" && isObject(value)) {
-      serialized.function = sanitizeOpenRouterLoggedValue(value);
+      serialized.function = sanitizeOpenRouterLoggedValue2(value);
       continue;
     }
-    serialized[key] = sanitizeOpenRouterLoggedValue(value);
+    serialized[key] = sanitizeOpenRouterLoggedValue2(value);
   }
   return serialized;
 }
-function serializeOpenRouterToolsForLogging(tools) {
+function serializeOpenRouterToolsForLogging2(tools) {
   if (!Array.isArray(tools)) {
     return void 0;
   }
-  return tools.map((tool) => serializeOpenRouterTool(tool));
+  return tools.map((tool) => serializeOpenRouterTool2(tool));
 }
-function sanitizeOpenRouterLoggedValue(value) {
-  if (isZodSchema3(value)) {
-    return serializeZodSchema3(value);
+function sanitizeOpenRouterLoggedValue2(value) {
+  if (isZodSchema4(value)) {
+    return serializeZodSchema4(value);
   }
   if (typeof value === "function") {
     return "[Function]";
   }
   if (Array.isArray(value)) {
-    return value.map((entry) => sanitizeOpenRouterLoggedValue(entry));
+    return value.map((entry) => sanitizeOpenRouterLoggedValue2(entry));
   }
   if (!isObject(value)) {
     return value;
   }
   const sanitized = {};
   for (const [key, entry] of Object.entries(value)) {
-    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+    if (OMITTED_OPENROUTER_KEYS2.has(key)) {
       continue;
     }
     if (key === "tools" && Array.isArray(entry)) {
-      sanitized.tools = serializeOpenRouterToolsForLogging(entry);
+      sanitized.tools = serializeOpenRouterToolsForLogging2(entry);
       continue;
     }
-    sanitized[key] = sanitizeOpenRouterLoggedValue(entry);
+    sanitized[key] = sanitizeOpenRouterLoggedValue2(entry);
   }
   return sanitized;
 }
-function buildOpenRouterMetadata(metadata, httpReferer, xTitle) {
-  const sanitized = sanitizeOpenRouterLoggedValue(metadata);
+function buildOpenRouterMetadata2(metadata, httpReferer, xTitle) {
+  const sanitized = sanitizeOpenRouterLoggedValue2(metadata);
   const metadataRecord = isObject(sanitized) ? sanitized : {};
   const { model, provider: providerRouting, ...rest } = metadataRecord;
-  const normalizedModel = parseOpenRouterModelString(model);
+  const normalizedModel = parseOpenRouterModelString2(model);
   return {
     ...rest,
     ...normalizedModel.model !== void 0 ? { model: normalizedModel.model } : {},
@@ -13882,33 +15359,33 @@ function buildOpenRouterMetadata(metadata, httpReferer, xTitle) {
   };
 }
 function buildOpenRouterEmbeddingMetadata(metadata, httpReferer, xTitle) {
-  const normalized = buildOpenRouterMetadata(metadata, httpReferer, xTitle);
+  const normalized = buildOpenRouterMetadata2(metadata, httpReferer, xTitle);
   return typeof normalized.model === "string" ? {
     ...normalized,
     embedding_model: normalized.model
   } : normalized;
 }
-function extractOpenRouterCallModelInput(request) {
-  return isObject(request) && "input" in request ? sanitizeOpenRouterLoggedValue(request.input) : void 0;
+function extractOpenRouterCallModelInput2(request) {
+  return isObject(request) && "input" in request ? sanitizeOpenRouterLoggedValue2(request.input) : void 0;
 }
-function extractOpenRouterCallModelMetadata(request) {
+function extractOpenRouterCallModelMetadata2(request) {
   if (!isObject(request)) {
     return { provider: "openrouter" };
   }
   const { input: _input, ...metadata } = request;
-  return buildOpenRouterMetadata(metadata, void 0, void 0);
+  return buildOpenRouterMetadata2(metadata, void 0, void 0);
 }
-function extractOpenRouterResponseMetadata(result) {
+function extractOpenRouterResponseMetadata2(result) {
   if (!isObject(result)) {
     return void 0;
   }
   const { output: _output, data: _data, usage, ...metadata } = result;
-  const sanitized = sanitizeOpenRouterLoggedValue(metadata);
+  const sanitized = sanitizeOpenRouterLoggedValue2(metadata);
   const metadataRecord = isObject(sanitized) ? sanitized : {};
   const { model, provider, ...rest } = metadataRecord;
-  const normalizedModel = parseOpenRouterModelString(model);
+  const normalizedModel = parseOpenRouterModelString2(model);
   const normalizedProvider = (typeof provider === "string" ? provider : void 0) || normalizedModel.provider;
-  const usageMetadata = extractOpenRouterUsageMetadata(usage);
+  const usageMetadata = extractOpenRouterUsageMetadata2(usage);
   const combined = {
     ...rest,
     ...normalizedModel.model !== void 0 ? { model: normalizedModel.model } : {},
@@ -13917,22 +15394,22 @@ function extractOpenRouterResponseMetadata(result) {
   };
   return Object.keys(combined).length > 0 ? combined : void 0;
 }
-function extractOpenRouterResponseOutput(response, fallbackOutput) {
+function extractOpenRouterResponseOutput2(response, fallbackOutput) {
   if (isObject(response) && "output" in response && response.output !== void 0) {
-    return sanitizeOpenRouterLoggedValue(response.output);
+    return sanitizeOpenRouterLoggedValue2(response.output);
   }
   if (fallbackOutput !== void 0) {
-    return sanitizeOpenRouterLoggedValue(fallbackOutput);
+    return sanitizeOpenRouterLoggedValue2(fallbackOutput);
   }
   return void 0;
 }
-var OPENROUTER_WRAPPED_TOOL = Symbol("braintrust.openrouter.wrappedTool");
-function patchOpenRouterCallModelRequestTools(request) {
+var OPENROUTER_WRAPPED_TOOL2 = Symbol("braintrust.openrouter.wrappedTool");
+function patchOpenRouterCallModelRequestTools2(request) {
   if (!Array.isArray(request.tools) || request.tools.length === 0) {
     return void 0;
   }
   const originalTools = request.tools;
-  const wrappedTools = originalTools.map((tool) => wrapOpenRouterTool(tool));
+  const wrappedTools = originalTools.map((tool) => wrapOpenRouterTool2(tool));
   const didPatch = wrappedTools.some(
     (tool, index) => tool !== originalTools[index]
   );
@@ -13944,8 +15421,8 @@ function patchOpenRouterCallModelRequestTools(request) {
     request.tools = originalTools;
   };
 }
-function wrapOpenRouterTool(tool) {
-  if (isWrappedTool(tool) || !tool.function || typeof tool.function !== "object" || typeof tool.function.execute !== "function") {
+function wrapOpenRouterTool2(tool) {
+  if (isWrappedTool2(tool) || !tool.function || typeof tool.function !== "object" || typeof tool.function.execute !== "function") {
     return tool;
   }
   const toolName = tool.function.name || "tool";
@@ -13955,26 +15432,26 @@ function wrapOpenRouterTool(tool) {
     function: {
       ...tool.function,
       execute(...args) {
-        return traceToolExecution({
+        return traceToolExecution2({
           args,
           execute: () => Reflect.apply(originalExecute, this, args),
-          toolCallId: getToolCallId(args[1]),
+          toolCallId: getToolCallId2(args[1]),
           toolName
         });
       }
     }
   };
-  Object.defineProperty(wrappedTool, OPENROUTER_WRAPPED_TOOL, {
+  Object.defineProperty(wrappedTool, OPENROUTER_WRAPPED_TOOL2, {
     value: true,
     enumerable: false,
     configurable: false
   });
   return wrappedTool;
 }
-function isWrappedTool(tool) {
-  return Boolean(tool[OPENROUTER_WRAPPED_TOOL]);
+function isWrappedTool2(tool) {
+  return Boolean(tool[OPENROUTER_WRAPPED_TOOL2]);
 }
-function traceToolExecution(args) {
+function traceToolExecution2(args) {
   const tracingChannel2 = openRouterChannels.toolExecute.tracingChannel();
   const input = args.args.length > 0 ? args.args[0] : void 0;
   const event = {
@@ -13988,15 +15465,15 @@ function traceToolExecution(args) {
   tracingChannel2.start.publish(event);
   try {
     const result = args.execute();
-    return publishToolResult(tracingChannel2, event, result);
+    return publishToolResult2(tracingChannel2, event, result);
   } catch (error) {
-    event.error = normalizeError(error);
+    event.error = normalizeError2(error);
     tracingChannel2.error.publish(event);
     throw error;
   }
 }
-function publishToolResult(tracingChannel2, event, result) {
-  if (isPromiseLike2(result)) {
+function publishToolResult2(tracingChannel2, event, result) {
+  if (isPromiseLike4(result)) {
     return result.then(
       (resolved) => {
         event.result = resolved;
@@ -14004,7 +15481,7 @@ function publishToolResult(tracingChannel2, event, result) {
         return resolved;
       },
       (error) => {
-        event.error = normalizeError(error);
+        event.error = normalizeError2(error);
         tracingChannel2.error.publish(event);
         throw error;
       }
@@ -14014,11 +15491,11 @@ function publishToolResult(tracingChannel2, event, result) {
   tracingChannel2.asyncEnd.publish(event);
   return result;
 }
-function getToolCallId(context) {
+function getToolCallId2(context) {
   const toolContext = context;
-  return typeof _optionalChain([toolContext, 'optionalAccess', _299 => _299.toolCall, 'optionalAccess', _300 => _300.id]) === "string" ? toolContext.toolCall.id : void 0;
+  return typeof _optionalChain([toolContext, 'optionalAccess', _310 => _310.toolCall, 'optionalAccess', _311 => _311.id]) === "string" ? toolContext.toolCall.id : void 0;
 }
-function isPromiseLike2(value) {
+function isPromiseLike4(value) {
   return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
 }
 function aggregateOpenRouterChatChunks(chunks) {
@@ -14030,12 +15507,12 @@ function aggregateOpenRouterChatChunks(chunks) {
   for (const chunk of chunks) {
     metrics = {
       ...metrics,
-      ...parseOpenRouterMetricsFromUsage(_optionalChain([chunk, 'optionalAccess', _301 => _301.usage]))
+      ...parseOpenRouterMetricsFromUsage2(_optionalChain([chunk, 'optionalAccess', _312 => _312.usage]))
     };
-    const choice = _optionalChain([chunk, 'optionalAccess', _302 => _302.choices, 'optionalAccess', _303 => _303[0]]);
-    const delta = _optionalChain([choice, 'optionalAccess', _304 => _304.delta]);
+    const choice = _optionalChain([chunk, 'optionalAccess', _313 => _313.choices, 'optionalAccess', _314 => _314[0]]);
+    const delta = _optionalChain([choice, 'optionalAccess', _315 => _315.delta]);
     if (!delta) {
-      if (_optionalChain([choice, 'optionalAccess', _305 => _305.finish_reason]) !== void 0) {
+      if (_optionalChain([choice, 'optionalAccess', _316 => _316.finish_reason]) !== void 0) {
         finishReason = choice.finish_reason;
       }
       continue;
@@ -14046,7 +15523,7 @@ function aggregateOpenRouterChatChunks(chunks) {
     if (typeof delta.content === "string") {
       content += delta.content;
     }
-    const choiceFinishReason = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _306 => _306.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _307 => _307.finish_reason]))), () => ( void 0));
+    const choiceFinishReason = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _317 => _317.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _318 => _318.finish_reason]))), () => ( void 0));
     const deltaFinishReason = _nullishCoalesce(_nullishCoalesce(delta.finishReason, () => ( delta.finish_reason)), () => ( void 0));
     if (choiceFinishReason !== void 0) {
       finishReason = choiceFinishReason;
@@ -14058,11 +15535,11 @@ function aggregateOpenRouterChatChunks(chunks) {
       continue;
     }
     for (const toolDelta of toolCallDeltas) {
-      if (!_optionalChain([toolDelta, 'optionalAccess', _308 => _308.function])) {
+      if (!_optionalChain([toolDelta, 'optionalAccess', _319 => _319.function])) {
         continue;
       }
       const toolIndex = _nullishCoalesce(toolDelta.index, () => ( 0));
-      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _309 => _309[toolIndex]]);
+      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _320 => _320[toolIndex]]);
       if (!existingToolCall || toolDelta.id && existingToolCall.id !== void 0 && existingToolCall.id !== toolDelta.id) {
         const nextToolCalls = [...toolCalls || []];
         nextToolCalls[toolIndex] = {
@@ -14109,7 +15586,7 @@ function aggregateOpenRouterChatChunks(chunks) {
 function aggregateOpenRouterResponseStreamEvents(chunks) {
   let finalResponse;
   for (const chunk of chunks) {
-    const response = _optionalChain([chunk, 'optionalAccess', _310 => _310.response]);
+    const response = _optionalChain([chunk, 'optionalAccess', _321 => _321.response]);
     if (!response) {
       continue;
     }
@@ -14124,15 +15601,15 @@ function aggregateOpenRouterResponseStreamEvents(chunks) {
     };
   }
   return {
-    output: extractOpenRouterResponseOutput(finalResponse),
-    metrics: parseOpenRouterMetricsFromUsage(finalResponse.usage),
-    ...extractOpenRouterResponseMetadata(finalResponse) ? { metadata: extractOpenRouterResponseMetadata(finalResponse) } : {}
+    output: extractOpenRouterResponseOutput2(finalResponse),
+    metrics: parseOpenRouterMetricsFromUsage2(finalResponse.usage),
+    ...extractOpenRouterResponseMetadata2(finalResponse) ? { metadata: extractOpenRouterResponseMetadata2(finalResponse) } : {}
   };
 }
-var OPENROUTER_WRAPPED_CALL_MODEL_RESULT = Symbol(
+var OPENROUTER_WRAPPED_CALL_MODEL_RESULT2 = Symbol(
   "braintrust.openrouter.wrappedCallModelResult"
 );
-var OPENROUTER_CALL_MODEL_STREAM_METHODS = [
+var OPENROUTER_CALL_MODEL_STREAM_METHODS2 = [
   "getFullResponsesStream",
   "getItemsStream",
   "getNewMessagesStream",
@@ -14141,26 +15618,26 @@ var OPENROUTER_CALL_MODEL_STREAM_METHODS = [
   "getToolCallsStream",
   "getToolStream"
 ];
-var OPENROUTER_CALL_MODEL_CONTEXT_METHODS = [
+var OPENROUTER_CALL_MODEL_CONTEXT_METHODS2 = [
   "cancel",
   "getPendingToolCalls",
   "getState",
   "getToolCalls",
   "requiresApproval"
 ];
-function patchOpenRouterCallModelResult(args) {
+function patchOpenRouterCallModelResult2(args) {
   const { request, result, span } = args;
-  if (!isObject(result) || isWrappedCallModelResult(result)) {
+  if (!isObject(result) || isWrappedCallModelResult2(result)) {
     return false;
   }
   const resultLike = result;
-  const hasInstrumentableMethod = typeof resultLike.getResponse === "function" || typeof resultLike.getText === "function" || OPENROUTER_CALL_MODEL_STREAM_METHODS.some(
+  const hasInstrumentableMethod = typeof resultLike.getResponse === "function" || typeof resultLike.getText === "function" || OPENROUTER_CALL_MODEL_STREAM_METHODS2.some(
     (methodName) => typeof resultLike[methodName] === "function"
   );
   if (!hasInstrumentableMethod) {
     return false;
   }
-  Object.defineProperty(resultLike, OPENROUTER_WRAPPED_CALL_MODEL_RESULT, {
+  Object.defineProperty(resultLike, OPENROUTER_WRAPPED_CALL_MODEL_RESULT2, {
     value: true,
     enumerable: false,
     configurable: false
@@ -14175,20 +15652,20 @@ function patchOpenRouterCallModelResult(args) {
       return;
     }
     ended = true;
-    const finalResponse = getFinalOpenRouterCallModelResponse(
+    const finalResponse = getFinalOpenRouterCallModelResponse2(
       resultLike,
       response
     );
     if (finalResponse) {
-      const rounds = getOpenRouterCallModelRounds(resultLike);
-      const metadata = extractOpenRouterCallModelResultMetadata(
+      const rounds = getOpenRouterCallModelRounds2(resultLike);
+      const metadata = extractOpenRouterCallModelResultMetadata2(
         finalResponse,
         rounds.length + 1
       );
       span.log({
-        output: extractOpenRouterResponseOutput(finalResponse, fallbackOutput),
+        output: extractOpenRouterResponseOutput2(finalResponse, fallbackOutput),
         ...metadata ? { metadata } : {},
-        metrics: aggregateOpenRouterCallModelMetrics(rounds, finalResponse)
+        metrics: aggregateOpenRouterCallModelMetrics2(rounds, finalResponse)
       });
       span.end();
       return;
@@ -14206,7 +15683,7 @@ function patchOpenRouterCallModelResult(args) {
     }
     ended = true;
     span.log({
-      error: normalizeError(error).message
+      error: normalizeError2(error).message
     });
     span.end();
   };
@@ -14217,7 +15694,7 @@ function patchOpenRouterCallModelResult(args) {
     }
     try {
       await endSpanWithResult(await originalGetResponse(), fallbackOutput);
-    } catch (e37) {
+    } catch (e39) {
       await endSpanWithResult(void 0, fallbackOutput);
     }
   };
@@ -14250,7 +15727,7 @@ function patchOpenRouterCallModelResult(args) {
       });
     };
   }
-  for (const methodName of OPENROUTER_CALL_MODEL_CONTEXT_METHODS) {
+  for (const methodName of OPENROUTER_CALL_MODEL_CONTEXT_METHODS2) {
     if (typeof resultLike[methodName] !== "function") {
       continue;
     }
@@ -14261,7 +15738,7 @@ function patchOpenRouterCallModelResult(args) {
       });
     };
   }
-  for (const methodName of OPENROUTER_CALL_MODEL_STREAM_METHODS) {
+  for (const methodName of OPENROUTER_CALL_MODEL_STREAM_METHODS2) {
     if (typeof resultLike[methodName] !== "function") {
       continue;
     }
@@ -14271,10 +15748,10 @@ function patchOpenRouterCallModelResult(args) {
         span,
         () => originalMethod.apply(resultLike, args2)
       );
-      if (!isAsyncIterable2(stream)) {
+      if (!isAsyncIterable4(stream)) {
         return stream;
       }
-      return wrapAsyncIterableWithSpan({
+      return wrapAsyncIterableWithSpan2({
         finalize: finalizeFromResponse,
         iteratorFactory: () => stream[Symbol.asyncIterator](),
         onError: endSpanWithError,
@@ -14293,14 +15770,14 @@ function patchOpenRouterCallModelResult(args) {
       initialTurnTraced = true;
       const step = tracedTurnCount + 1;
       const stepType = tracedTurnCount === 0 ? "initial" : "continue";
-      const response = await traceOpenRouterCallModelTurn({
+      const response = await traceOpenRouterCallModelTurn2({
         fn: async () => {
           const nextResponse = await originalGetInitialResponse(...args2);
           tracedTurnCount++;
           return nextResponse;
         },
         parentSpan: span,
-        request: getOpenRouterResolvedRequest(resultLike, request),
+        request: getOpenRouterResolvedRequest2(resultLike, request),
         step,
         stepType
       });
@@ -14312,15 +15789,15 @@ function patchOpenRouterCallModelResult(args) {
       const currentResponse = args2[0];
       const toolResults = Array.isArray(args2[1]) ? args2[1] : [];
       const step = tracedTurnCount + 1;
-      const response = await traceOpenRouterCallModelTurn({
+      const response = await traceOpenRouterCallModelTurn2({
         fn: async () => {
           const nextResponse = await originalMakeFollowupRequest(...args2);
           tracedTurnCount++;
           return nextResponse;
         },
         parentSpan: span,
-        request: buildOpenRouterFollowupRequest(
-          getOpenRouterResolvedRequest(resultLike, request),
+        request: buildOpenRouterFollowupRequest2(
+          getOpenRouterResolvedRequest2(resultLike, request),
           currentResponse,
           toolResults
         ),
@@ -14332,7 +15809,7 @@ function patchOpenRouterCallModelResult(args) {
   }
   return true;
 }
-async function traceOpenRouterCallModelTurn(args) {
+async function traceOpenRouterCallModelTurn2(args) {
   const context = {
     arguments: [args.request],
     step: args.step,
@@ -14343,25 +15820,25 @@ async function traceOpenRouterCallModelTurn(args) {
     () => openRouterChannels.callModelTurn.tracePromise(args.fn, context)
   );
 }
-function isWrappedCallModelResult(value) {
+function isWrappedCallModelResult2(value) {
   return Boolean(
-    isObject(value) && value[OPENROUTER_WRAPPED_CALL_MODEL_RESULT]
+    isObject(value) && value[OPENROUTER_WRAPPED_CALL_MODEL_RESULT2]
   );
 }
-function extractOpenRouterCallModelResultMetadata(response, turnCount) {
+function extractOpenRouterCallModelResultMetadata2(response, turnCount) {
   const combined = {
-    ...extractOpenRouterResponseMetadata(response) || {},
+    ...extractOpenRouterResponseMetadata2(response) || {},
     ...turnCount !== void 0 ? { turn_count: turnCount } : {}
   };
   return Object.keys(combined).length > 0 ? combined : void 0;
 }
-function getFinalOpenRouterCallModelResponse(result, response) {
+function getFinalOpenRouterCallModelResponse2(result, response) {
   if (isObject(response)) {
     return response;
   }
   return isObject(result.finalResponse) ? result.finalResponse : void 0;
 }
-function getOpenRouterCallModelRounds(result) {
+function getOpenRouterCallModelRounds2(result) {
   if (!Array.isArray(result.allToolExecutionRounds)) {
     return [];
   }
@@ -14371,48 +15848,48 @@ function getOpenRouterCallModelRounds(result) {
     toolResults: Array.isArray(round.toolResults) ? round.toolResults : []
   })).filter((round) => round.response !== void 0);
 }
-function aggregateOpenRouterCallModelMetrics(rounds, finalResponse) {
+function aggregateOpenRouterCallModelMetrics2(rounds, finalResponse) {
   const metrics = {};
   const responses = [
     ...rounds.map((round) => round.response).filter(isObject),
     finalResponse
   ];
   for (const response of responses) {
-    const responseMetrics = parseOpenRouterMetricsFromUsage(response.usage);
+    const responseMetrics = parseOpenRouterMetricsFromUsage2(response.usage);
     for (const [name, value] of Object.entries(responseMetrics)) {
       metrics[name] = (metrics[name] || 0) + value;
     }
   }
   return metrics;
 }
-function buildNextOpenRouterCallModelInput(currentInput, response, toolResults) {
+function buildNextOpenRouterCallModelInput2(currentInput, response, toolResults) {
   const normalizedInput = Array.isArray(currentInput) ? [...currentInput] : currentInput === void 0 ? [] : [currentInput];
   const responseOutput = Array.isArray(response.output) ? response.output : response.output === void 0 ? [] : [response.output];
   return [...normalizedInput, ...responseOutput, ...toolResults].map(
-    (entry) => sanitizeOpenRouterLoggedValue(entry)
+    (entry) => sanitizeOpenRouterLoggedValue2(entry)
   );
 }
-function getOpenRouterResolvedRequest(result, request) {
+function getOpenRouterResolvedRequest2(result, request) {
   if (isObject(result.resolvedRequest)) {
     return result.resolvedRequest;
   }
   return request;
 }
-function buildOpenRouterFollowupRequest(request, currentResponse, toolResults) {
+function buildOpenRouterFollowupRequest2(request, currentResponse, toolResults) {
   if (!request) {
     return void 0;
   }
   return {
     ...request,
-    input: buildNextOpenRouterCallModelInput(
-      extractOpenRouterCallModelInput(request),
+    input: buildNextOpenRouterCallModelInput2(
+      extractOpenRouterCallModelInput2(request),
       isObject(currentResponse) ? currentResponse : {},
       toolResults
     ),
     stream: false
   };
 }
-function wrapAsyncIterableWithSpan(args) {
+function wrapAsyncIterableWithSpan2(args) {
   return {
     [Symbol.asyncIterator]() {
       const iterator = args.iteratorFactory();
@@ -14466,13 +15943,518 @@ function wrapAsyncIterableWithSpan(args) {
     }
   };
 }
-function isAsyncIterable2(value) {
+function isAsyncIterable4(value) {
   return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
-function normalizeError(error) {
+function normalizeError2(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
 
+// src/instrumentation/plugins/mistral-channels.ts
+var mistralChannels = defineChannels("@mistralai/mistralai", {
+  chatComplete: channel({
+    channelName: "chat.complete",
+    kind: "async"
+  }),
+  chatStream: channel({
+    channelName: "chat.stream",
+    kind: "async"
+  }),
+  embeddingsCreate: channel({
+    channelName: "embeddings.create",
+    kind: "async"
+  }),
+  fimComplete: channel({
+    channelName: "fim.complete",
+    kind: "async"
+  }),
+  fimStream: channel({
+    channelName: "fim.stream",
+    kind: "async"
+  }),
+  agentsComplete: channel({
+    channelName: "agents.complete",
+    kind: "async"
+  }),
+  agentsStream: channel({
+    channelName: "agents.stream",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/mistral-plugin.ts
+var MistralPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToMistralChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToMistralChannels() {
+    this.unsubscribers.push(
+      traceStreamingChannel(mistralChannels.chatComplete, {
+        name: "mistral.chat.complete",
+        type: "llm" /* LLM */,
+        extractInput: extractMessagesInputWithMetadata,
+        extractOutput: (result) => {
+          return _optionalChain([result, 'optionalAccess', _322 => _322.choices]);
+        },
+        extractMetadata: (result) => extractMistralResponseMetadata(result),
+        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _323 => _323.usage]), startTime)
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(mistralChannels.chatStream, {
+        name: "mistral.chat.stream",
+        type: "llm" /* LLM */,
+        extractInput: extractMessagesInputWithMetadata,
+        extractOutput: extractMistralStreamOutput,
+        extractMetadata: (result) => extractMistralResponseMetadata(result),
+        extractMetrics: (result, startTime) => extractMistralStreamingMetrics(result, startTime),
+        aggregateChunks: aggregateMistralStreamChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(mistralChannels.embeddingsCreate, {
+        name: "mistral.embeddings.create",
+        type: "llm" /* LLM */,
+        extractInput: extractEmbeddingInputWithMetadata,
+        extractOutput: (result) => {
+          const embedding = _optionalChain([result, 'optionalAccess', _324 => _324.data, 'optionalAccess', _325 => _325[0], 'optionalAccess', _326 => _326.embedding]);
+          return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
+        },
+        extractMetadata: (result) => extractMistralResponseMetadata(result),
+        extractMetrics: (result) => parseMistralMetricsFromUsage(_optionalChain([result, 'optionalAccess', _327 => _327.usage]))
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(mistralChannels.fimComplete, {
+        name: "mistral.fim.complete",
+        type: "llm" /* LLM */,
+        extractInput: extractPromptInputWithMetadata,
+        extractOutput: (result) => {
+          return _optionalChain([result, 'optionalAccess', _328 => _328.choices]);
+        },
+        extractMetadata: (result) => extractMistralResponseMetadata(result),
+        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _329 => _329.usage]), startTime)
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(mistralChannels.fimStream, {
+        name: "mistral.fim.stream",
+        type: "llm" /* LLM */,
+        extractInput: extractPromptInputWithMetadata,
+        extractOutput: extractMistralStreamOutput,
+        extractMetadata: (result) => extractMistralResponseMetadata(result),
+        extractMetrics: (result, startTime) => extractMistralStreamingMetrics(result, startTime),
+        aggregateChunks: aggregateMistralStreamChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(mistralChannels.agentsComplete, {
+        name: "mistral.agents.complete",
+        type: "llm" /* LLM */,
+        extractInput: extractMessagesInputWithMetadata,
+        extractOutput: (result) => {
+          return _optionalChain([result, 'optionalAccess', _330 => _330.choices]);
+        },
+        extractMetadata: (result) => extractMistralResponseMetadata(result),
+        extractMetrics: (result, startTime) => extractMistralMetrics(_optionalChain([result, 'optionalAccess', _331 => _331.usage]), startTime)
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(mistralChannels.agentsStream, {
+        name: "mistral.agents.stream",
+        type: "llm" /* LLM */,
+        extractInput: extractMessagesInputWithMetadata,
+        extractOutput: extractMistralStreamOutput,
+        extractMetadata: (result) => extractMistralResponseMetadata(result),
+        extractMetrics: (result, startTime) => extractMistralStreamingMetrics(result, startTime),
+        aggregateChunks: aggregateMistralStreamChunks
+      })
+    );
+  }
+};
+var TOKEN_NAME_MAP4 = {
+  promptTokens: "prompt_tokens",
+  inputTokens: "prompt_tokens",
+  completionTokens: "completion_tokens",
+  outputTokens: "completion_tokens",
+  totalTokens: "tokens",
+  prompt_tokens: "prompt_tokens",
+  input_tokens: "prompt_tokens",
+  completion_tokens: "completion_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens",
+  promptAudioSeconds: "prompt_audio_seconds",
+  prompt_audio_seconds: "prompt_audio_seconds"
+};
+var TOKEN_DETAIL_PREFIX_MAP3 = {
+  promptTokensDetails: "prompt",
+  inputTokensDetails: "prompt",
+  completionTokensDetails: "completion",
+  outputTokensDetails: "completion",
+  prompt_tokens_details: "prompt",
+  input_tokens_details: "prompt",
+  completion_tokens_details: "completion",
+  output_tokens_details: "completion"
+};
+var MISTRAL_REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "agentId",
+  "agent_id",
+  "encodingFormat",
+  "encoding_format",
+  "frequencyPenalty",
+  "frequency_penalty",
+  "maxTokens",
+  "max_tokens",
+  "model",
+  "n",
+  "presencePenalty",
+  "presence_penalty",
+  "randomSeed",
+  "random_seed",
+  "responseFormat",
+  "response_format",
+  "safePrompt",
+  "safe_prompt",
+  "stream",
+  "stop",
+  "temperature",
+  "toolChoice",
+  "tool_choice",
+  "topP",
+  "top_p"
+]);
+var MISTRAL_RESPONSE_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "agentId",
+  "agent_id",
+  "created",
+  "id",
+  "model",
+  "object"
+]);
+function camelToSnake3(value) {
+  return value.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+}
+function normalizeArgs3(args) {
+  if (Array.isArray(args)) {
+    return args;
+  }
+  if (isArrayLike3(args)) {
+    return Array.from(args);
+  }
+  return [args];
+}
+function isArrayLike3(value) {
+  return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
+}
+function getMistralRequestArg(args) {
+  const firstObjectArg = normalizeArgs3(args).find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function addMistralProviderMetadata(metadata) {
+  return {
+    ...metadata,
+    provider: "mistral"
+  };
+}
+function pickAllowedMetadata(metadata, allowlist) {
+  if (!metadata) {
+    return {};
+  }
+  const picked = {};
+  for (const key of allowlist) {
+    const value = metadata[key];
+    if (value !== void 0) {
+      picked[key] = value;
+    }
+  }
+  return picked;
+}
+function extractMistralRequestMetadata(metadata) {
+  return pickAllowedMetadata(metadata, MISTRAL_REQUEST_METADATA_ALLOWLIST);
+}
+function isMistralChatCompletionChunk(value) {
+  return isObject(value);
+}
+function isMistralChunkChoice(value) {
+  return isObject(value);
+}
+function extractMessagesInputWithMetadata(args) {
+  const params = getMistralRequestArg(args);
+  const { messages, ...rawMetadata } = params || {};
+  return {
+    input: processInputAttachments(messages),
+    metadata: addMistralProviderMetadata(
+      extractMistralRequestMetadata(rawMetadata)
+    )
+  };
+}
+function extractEmbeddingInputWithMetadata(args) {
+  const params = getMistralRequestArg(args);
+  const { inputs, ...rawMetadata } = params || {};
+  return {
+    input: inputs,
+    metadata: addMistralProviderMetadata(
+      extractMistralRequestMetadata(rawMetadata)
+    )
+  };
+}
+function extractPromptInputWithMetadata(args) {
+  const params = getMistralRequestArg(args);
+  const { prompt, ...rawMetadata } = params || {};
+  return {
+    input: prompt,
+    metadata: addMistralProviderMetadata(
+      extractMistralRequestMetadata(rawMetadata)
+    )
+  };
+}
+function extractMistralResponseMetadata(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const { choices: _choices, usage: _usage, data: _data, ...metadata } = result;
+  const picked = pickAllowedMetadata(
+    metadata,
+    MISTRAL_RESPONSE_METADATA_ALLOWLIST
+  );
+  return Object.keys(picked).length > 0 ? picked : void 0;
+}
+function extractMistralMetrics(usage, startTime) {
+  const metrics = parseMistralMetricsFromUsage(usage);
+  if (startTime) {
+    metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+  }
+  return metrics;
+}
+function extractMistralStreamOutput(result) {
+  return isObject(result) ? result.choices : void 0;
+}
+function extractMistralStreamingMetrics(result, startTime) {
+  const metrics = isObject(result) ? parseMistralMetricsFromUsage(result.usage) : {};
+  if (startTime) {
+    metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+  }
+  return metrics;
+}
+function extractDeltaText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const textParts = content.map((part) => {
+    if (!isObject(part) || part.type !== "text") {
+      return "";
+    }
+    return typeof part.text === "string" ? part.text : "";
+  }).filter((part) => part.length > 0);
+  return textParts.length > 0 ? textParts.join("") : void 0;
+}
+function getDeltaToolCalls(delta) {
+  const toolCalls = Array.isArray(delta.toolCalls) && delta.toolCalls || Array.isArray(delta.tool_calls) && delta.tool_calls || [];
+  return toolCalls.filter((toolCall) => isObject(toolCall));
+}
+function getToolCallIndex(toolCall) {
+  return typeof toolCall.index === "number" && toolCall.index >= 0 ? toolCall.index : void 0;
+}
+function createMergedToolCallDelta(delta) {
+  return {
+    ...delta,
+    function: {
+      ...delta.function,
+      arguments: typeof _optionalChain([delta, 'access', _332 => _332.function, 'optionalAccess', _333 => _333.arguments]) === "string" ? delta.function.arguments : ""
+    }
+  };
+}
+function mergeToolCallDeltaPair(current, delta) {
+  const currentArguments = typeof _optionalChain([current, 'access', _334 => _334.function, 'optionalAccess', _335 => _335.arguments]) === "string" ? current.function.arguments : "";
+  const deltaArguments = typeof _optionalChain([delta, 'access', _336 => _336.function, 'optionalAccess', _337 => _337.arguments]) === "string" ? delta.function.arguments : "";
+  return {
+    ...current,
+    ...delta,
+    function: {
+      ...current.function || {},
+      ...delta.function || {},
+      arguments: `${currentArguments}${deltaArguments}`
+    }
+  };
+}
+function mergeToolCallDeltas(toolCalls, deltas) {
+  if (deltas.length === 0) {
+    return toolCalls;
+  }
+  const merged = toolCalls ? [...toolCalls] : [];
+  const indexToPosition = /* @__PURE__ */ new Map();
+  const idToPosition = /* @__PURE__ */ new Map();
+  for (const [position, toolCall] of merged.entries()) {
+    const index = getToolCallIndex(toolCall);
+    if (index !== void 0 && !indexToPosition.has(index)) {
+      indexToPosition.set(index, position);
+    }
+    if (typeof toolCall.id === "string" && !idToPosition.has(toolCall.id)) {
+      idToPosition.set(toolCall.id, position);
+    }
+  }
+  for (const delta of deltas) {
+    const deltaIndex = getToolCallIndex(delta);
+    const existingByIndex = deltaIndex !== void 0 ? indexToPosition.get(deltaIndex) : void 0;
+    const existingById = typeof delta.id === "string" ? idToPosition.get(delta.id) : void 0;
+    const existingPosition = _nullishCoalesce(existingByIndex, () => ( existingById));
+    if (existingPosition === void 0) {
+      const newToolCall = createMergedToolCallDelta(delta);
+      merged.push(newToolCall);
+      const newPosition = merged.length - 1;
+      const newIndex = getToolCallIndex(newToolCall);
+      if (newIndex !== void 0 && !indexToPosition.has(newIndex)) {
+        indexToPosition.set(newIndex, newPosition);
+      }
+      if (typeof newToolCall.id === "string" && !idToPosition.has(newToolCall.id)) {
+        idToPosition.set(newToolCall.id, newPosition);
+      }
+      continue;
+    }
+    const mergedToolCall = mergeToolCallDeltaPair(
+      merged[existingPosition],
+      delta
+    );
+    merged[existingPosition] = mergedToolCall;
+    const mergedIndex = getToolCallIndex(mergedToolCall);
+    if (mergedIndex !== void 0 && !indexToPosition.has(mergedIndex)) {
+      indexToPosition.set(mergedIndex, existingPosition);
+    }
+    if (typeof mergedToolCall.id === "string" && !idToPosition.has(mergedToolCall.id)) {
+      idToPosition.set(mergedToolCall.id, existingPosition);
+    }
+  }
+  return merged.length > 0 ? merged : void 0;
+}
+function getChoiceFinishReason(choice) {
+  if (typeof choice.finishReason === "string" || choice.finishReason === null) {
+    return choice.finishReason;
+  }
+  if (typeof choice.finish_reason === "string" || choice.finish_reason === null) {
+    return choice.finish_reason;
+  }
+  return void 0;
+}
+function parseMistralMetricsFromUsage(usage) {
+  if (!isObject(usage)) {
+    return {};
+  }
+  const metrics = {};
+  for (const [name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      metrics[TOKEN_NAME_MAP4[name] || camelToSnake3(name)] = value;
+      continue;
+    }
+    if (!isObject(value)) {
+      continue;
+    }
+    const prefix = TOKEN_DETAIL_PREFIX_MAP3[name];
+    if (!prefix) {
+      continue;
+    }
+    for (const [nestedName, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${camelToSnake3(nestedName)}`] = nestedValue;
+    }
+  }
+  return metrics;
+}
+function aggregateMistralStreamChunks(chunks) {
+  const choiceAccumulators = /* @__PURE__ */ new Map();
+  const indexToAccumulatorKey = /* @__PURE__ */ new Map();
+  const positionToAccumulatorKey = /* @__PURE__ */ new Map();
+  let nextAccumulatorOrder = 0;
+  let metrics = {};
+  let metadata;
+  for (const event of chunks) {
+    const chunk = isMistralChatCompletionChunk(_optionalChain([event, 'optionalAccess', _338 => _338.data])) ? event.data : void 0;
+    if (!chunk) {
+      continue;
+    }
+    if (isObject(chunk.usage)) {
+      metrics = {
+        ...metrics,
+        ...parseMistralMetricsFromUsage(chunk.usage)
+      };
+    }
+    const chunkMetadata = extractMistralResponseMetadata(chunk);
+    if (chunkMetadata) {
+      metadata = { ...metadata || {}, ...chunkMetadata };
+    }
+    for (const [choicePosition, rawChoice] of (chunk.choices || []).entries()) {
+      if (!isMistralChunkChoice(rawChoice)) {
+        continue;
+      }
+      const choice = rawChoice;
+      const choiceIndex = typeof choice.index === "number" && choice.index >= 0 ? choice.index : void 0;
+      let accumulatorKey = choiceIndex !== void 0 ? indexToAccumulatorKey.get(choiceIndex) : void 0;
+      if (!accumulatorKey) {
+        accumulatorKey = positionToAccumulatorKey.get(choicePosition);
+      }
+      if (!accumulatorKey) {
+        const initialIndex = _nullishCoalesce(choiceIndex, () => ( choicePosition));
+        const keyPrefix = choiceIndex !== void 0 ? "index" : "position";
+        accumulatorKey = `${keyPrefix}:${initialIndex}`;
+        choiceAccumulators.set(accumulatorKey, {
+          index: initialIndex,
+          order: nextAccumulatorOrder++
+        });
+      }
+      const accumulator = choiceAccumulators.get(accumulatorKey);
+      if (!accumulator) {
+        continue;
+      }
+      if (choiceIndex !== void 0) {
+        accumulator.index = choiceIndex;
+        indexToAccumulatorKey.set(choiceIndex, accumulatorKey);
+      }
+      positionToAccumulatorKey.set(choicePosition, accumulatorKey);
+      const delta = isObject(choice.delta) ? choice.delta : void 0;
+      if (delta) {
+        if (!accumulator.role && typeof delta.role === "string") {
+          accumulator.role = delta.role;
+        }
+        const deltaText = extractDeltaText(delta.content);
+        if (deltaText) {
+          accumulator.content = `${accumulator.content || ""}${deltaText}`;
+        }
+        accumulator.toolCalls = mergeToolCallDeltas(
+          accumulator.toolCalls,
+          getDeltaToolCalls(delta)
+        );
+      }
+      const choiceFinishReason = getChoiceFinishReason(choice);
+      if (choiceFinishReason !== void 0) {
+        accumulator.finishReason = choiceFinishReason;
+      }
+    }
+  }
+  const output = Array.from(choiceAccumulators.values()).sort(
+    (left, right) => left.index === right.index ? left.order - right.order : left.index - right.index
+  ).map((choice) => ({
+    index: choice.index,
+    message: {
+      ...choice.role ? { role: choice.role } : {},
+      content: _nullishCoalesce(choice.content, () => ( null)),
+      ...choice.toolCalls ? { toolCalls: choice.toolCalls } : {}
+    },
+    ...choice.finishReason !== void 0 ? { finishReason: choice.finishReason } : {}
+  }));
+  return {
+    output,
+    metrics,
+    ...metadata ? { metadata } : {}
+  };
+}
+
 // src/instrumentation/braintrust-plugin.ts
 var BraintrustPlugin = (_class18 = class extends BasePlugin {
   
@@ -14482,8 +16464,10 @@ var BraintrustPlugin = (_class18 = class extends BasePlugin {
   __init67() {this.claudeAgentSDKPlugin = null}
   __init68() {this.googleGenAIPlugin = null}
   __init69() {this.openRouterPlugin = null}
+  __init70() {this.openRouterAgentPlugin = null}
+  __init71() {this.mistralPlugin = null}
   constructor(config = {}) {
-    super();_class18.prototype.__init64.call(this);_class18.prototype.__init65.call(this);_class18.prototype.__init66.call(this);_class18.prototype.__init67.call(this);_class18.prototype.__init68.call(this);_class18.prototype.__init69.call(this);;
+    super();_class18.prototype.__init64.call(this);_class18.prototype.__init65.call(this);_class18.prototype.__init66.call(this);_class18.prototype.__init67.call(this);_class18.prototype.__init68.call(this);_class18.prototype.__init69.call(this);_class18.prototype.__init70.call(this);_class18.prototype.__init71.call(this);;
     this.config = config;
   }
   onEnable() {
@@ -14512,6 +16496,14 @@ var BraintrustPlugin = (_class18 = class extends BasePlugin {
       this.openRouterPlugin = new OpenRouterPlugin();
       this.openRouterPlugin.enable();
     }
+    if (integrations.openrouterAgent !== false) {
+      this.openRouterAgentPlugin = new OpenRouterAgentPlugin();
+      this.openRouterAgentPlugin.enable();
+    }
+    if (integrations.mistral !== false) {
+      this.mistralPlugin = new MistralPlugin();
+      this.mistralPlugin.enable();
+    }
   }
   onDisable() {
     if (this.openaiPlugin) {
@@ -14538,14 +16530,22 @@ var BraintrustPlugin = (_class18 = class extends BasePlugin {
       this.openRouterPlugin.disable();
       this.openRouterPlugin = null;
     }
+    if (this.openRouterAgentPlugin) {
+      this.openRouterAgentPlugin.disable();
+      this.openRouterAgentPlugin = null;
+    }
+    if (this.mistralPlugin) {
+      this.mistralPlugin.disable();
+      this.mistralPlugin = null;
+    }
   }
 }, _class18);
 
 // src/instrumentation/registry.ts
-var PluginRegistry = (_class19 = class {constructor() { _class19.prototype.__init70.call(this);_class19.prototype.__init71.call(this);_class19.prototype.__init72.call(this); }
-  __init70() {this.braintrustPlugin = null}
-  __init71() {this.config = {}}
-  __init72() {this.enabled = false}
+var PluginRegistry = (_class19 = class {constructor() { _class19.prototype.__init72.call(this);_class19.prototype.__init73.call(this);_class19.prototype.__init74.call(this); }
+  __init72() {this.braintrustPlugin = null}
+  __init73() {this.config = {}}
+  __init74() {this.enabled = false}
   /**
    * Configure which integrations should be enabled.
    * This must be called before any SDK imports to take effect.
@@ -14610,7 +16610,9 @@ var PluginRegistry = (_class19 = class {constructor() { _class19.prototype.__ini
       aisdk: true,
       google: true,
       claudeAgentSDK: true,
-      openrouter: true
+      openrouter: true,
+      openrouterAgent: true,
+      mistral: true
     };
   }
   /**
@@ -14745,7 +16747,7 @@ function isAsync(fn) {
 function isAsyncGenerator2(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable3(obj) {
+function isAsyncIterable5(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -14795,7 +16797,7 @@ function _asyncMap(eachfn, arr, iteratee, callback) {
     callback(err, results);
   });
 }
-function isArrayLike2(value) {
+function isArrayLike4(value) {
   return value && typeof value.length === "number" && value.length >= 0 && value.length % 1 === 0;
 }
 var breakLoop = {};
@@ -14843,7 +16845,7 @@ function createObjectIterator(obj) {
   };
 }
 function createIterator(coll) {
-  if (isArrayLike2(coll)) {
+  if (isArrayLike4(coll)) {
     return createArrayIterator(coll);
   }
   var iterator = getIterator(coll);
@@ -14917,7 +16919,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator2(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable3(obj)) {
+    if (isAsyncIterable5(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -14989,7 +16991,7 @@ function eachOfGeneric(coll, iteratee, callback) {
   return eachOfLimit$1(coll, Infinity, iteratee, callback);
 }
 function eachOf(coll, iteratee, callback) {
-  var eachOfImplementation = isArrayLike2(coll) ? eachOfArrayLike : eachOfGeneric;
+  var eachOfImplementation = isArrayLike4(coll) ? eachOfArrayLike : eachOfGeneric;
   return eachOfImplementation(coll, wrapAsync(iteratee), callback);
 }
 var eachOf$1 = awaitify(eachOf, 3);
@@ -15504,7 +17506,7 @@ function filterGeneric(eachfn, coll, iteratee, callback) {
   });
 }
 function _filter(eachfn, coll, iteratee, callback) {
-  var filter2 = isArrayLike2(coll) ? filterArray : filterGeneric;
+  var filter2 = isArrayLike4(coll) ? filterArray : filterGeneric;
   return filter2(eachfn, coll, wrapAsync(iteratee), callback);
 }
 function filter(coll, iteratee, callback) {
@@ -15579,7 +17581,7 @@ if (hasNextTick) {
 }
 var nextTick = wrap(_defer);
 var _parallel = awaitify((eachfn, tasks, callback) => {
-  var results = isArrayLike2(tasks) ? [] : {};
+  var results = isArrayLike4(tasks) ? [] : {};
   eachfn(tasks, (task, key, taskCb) => {
     wrapAsync(task)((err, ...result) => {
       if (result.length < 2) {
@@ -15846,10 +17848,10 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
   }
 };
 var CachedSpanFetcher = (_class20 = class {
-  __init73() {this.spanCache = /* @__PURE__ */ new Map()}
-  __init74() {this.allFetched = false}
+  __init75() {this.spanCache = /* @__PURE__ */ new Map()}
+  __init76() {this.allFetched = false}
   
-  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class20.prototype.__init73.call(this);_class20.prototype.__init74.call(this);
+  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {;_class20.prototype.__init75.call(this);_class20.prototype.__init76.call(this);
     if (typeof objectTypeOrFetchFn === "function") {
       this.fetchFn = objectTypeOrFetchFn;
     } else {
@@ -15864,7 +17866,7 @@ var CachedSpanFetcher = (_class20 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _311 => _311.span_attributes, 'optionalAccess', _312 => _312.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _339 => _339.span_attributes, 'optionalAccess', _340 => _340.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -15898,7 +17900,7 @@ var CachedSpanFetcher = (_class20 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _313 => _313.span_attributes, 'optionalAccess', _314 => _314.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _341 => _341.span_attributes, 'optionalAccess', _342 => _342.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -15922,17 +17924,17 @@ var LocalTrace = (_class21 = class {
   
   
   
-  __init75() {this.spansFlushed = false}
-  __init76() {this.spansFlushPromise = null}
+  __init77() {this.spansFlushed = false}
+  __init78() {this.spansFlushPromise = null}
   
-  __init77() {this.threadCache = /* @__PURE__ */ new Map()}
+  __init79() {this.threadCache = /* @__PURE__ */ new Map()}
   constructor({
     objectType,
     objectId,
     rootSpanId,
     ensureSpansFlushed,
     state
-  }) {;_class21.prototype.__init75.call(this);_class21.prototype.__init76.call(this);_class21.prototype.__init77.call(this);
+  }) {;_class21.prototype.__init77.call(this);_class21.prototype.__init78.call(this);_class21.prototype.__init79.call(this);
     this.objectType = objectType;
     this.objectId = objectId;
     this.rootSpanId = rootSpanId;
@@ -15978,11 +17980,11 @@ var LocalTrace = (_class21 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _315 => _315.span_attributes, 'optionalAccess', _316 => _316.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _343 => _343.span_attributes, 'optionalAccess', _344 => _344.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _317 => _317.span_attributes, 'optionalAccess', _318 => _318.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _345 => _345.span_attributes, 'optionalAccess', _346 => _346.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -16001,7 +18003,7 @@ var LocalTrace = (_class21 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _319 => _319.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _347 => _347.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -16012,7 +18014,7 @@ var LocalTrace = (_class21 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _320 => _320.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _348 => _348.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -16188,10 +18190,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', _321 => _321.errors, 'optionalAccess', _322 => _322.map, 'call', _323 => _323((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _349 => _349.errors, 'optionalAccess', _350 => _350.map, 'call', _351 => _351((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _324 => _324.join, 'call', _325 => _325(", ")]);
+    }), 'access', _352 => _352.join, 'call', _353 => _353(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return rehydrateRemoteParameters(parameters, schema);
@@ -16281,7 +18283,7 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable4(value) {
+function isAsyncIterable6(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
@@ -16450,7 +18452,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', _326 => _326.spanCache, 'optionalAccess', _327 => _327.start, 'call', _328 => _328()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _354 => _354.spanCache, 'optionalAccess', _355 => _355.start, 'call', _356 => _356()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -16486,7 +18488,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     }
     const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
     const dataIterable = (() => {
-      if (isAsyncIterable4(resolvedDataResult)) {
+      if (isAsyncIterable6(resolvedDataResult)) {
         return resolvedDataResult;
       }
       if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
@@ -16505,7 +18507,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const experimentIdPromise = experiment ? (async () => {
       try {
         return await experiment.id;
-      } catch (e38) {
+      } catch (e40) {
         return void 0;
       }
     })() : void 0;
@@ -16561,7 +18563,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _329 => _329.data, 'access', async _330 => _330.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _357 => _357.data, 'access', async _358 => _358.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -16587,10 +18589,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _331 => _331({
+                    _optionalChain([stream, 'optionalCall', _359 => _359({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _332 => _332.event, 'optionalAccess', _333 => _333.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _360 => _360.event, 'optionalAccess', _361 => _361.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -16754,7 +18756,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _334 => _334.event, 'optionalAccess', _335 => _335.origin])
+              origin: _optionalChain([baseEvent, 'access', _362 => _362.event, 'optionalAccess', _363 => _363.origin])
             });
           }
         };
@@ -16789,7 +18791,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _336 => _336.setTotal, 'optionalCall', _337 => _337(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _364 => _364.setTotal, 'optionalCall', _365 => _365(evaluator.evalName, scheduledTrials)]);
           q.pushAsync({ datum, trialIndex }).catch((e) => {
             if (queueErrors.length < 5) {
               queueErrors.push(e);
@@ -16874,9 +18876,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _338 => _338.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _339 => _339.dispose, 'call', _340 => _340()]);
-      _optionalChain([spanCache, 'optionalAccess', _341 => _341.stop, 'call', _342 => _342()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _366 => _366.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _367 => _367.dispose, 'call', _368 => _368()]);
+      _optionalChain([spanCache, 'optionalAccess', _369 => _369.stop, 'call', _370 => _370()]);
     }
   }
 }
@@ -17113,7 +19115,7 @@ async function cachedLogin(options) {
 }
 function makeCheckAuthorized(allowedOrgName) {
   return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _343 => _343.ctx, 'optionalAccess', _344 => _344.token])) {
+    if (!_optionalChain([req, 'access', _371 => _371.ctx, 'optionalAccess', _372 => _372.token])) {
       return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
     try {
@@ -17126,7 +19128,7 @@ function makeCheckAuthorized(allowedOrgName) {
         return next(_httperrors2.default.call(void 0, 403, errorMessage));
       }
       const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _345 => _345.ctx, 'optionalAccess', _346 => _346.token]),
+        apiKey: _optionalChain([req, 'access', _373 => _373.ctx, 'optionalAccess', _374 => _374.token]),
         orgName
       });
       req.ctx.state = state;
@@ -17286,7 +19288,7 @@ var parametersContainerSchema = _v3.z.object({
 var staticParametersContainerSchema = _v3.z.object({
   type: _v3.z.literal("braintrust.staticParameters"),
   schema: staticParametersSchema,
-  source: _v3.z.null()
+  source: _v3.z.null().nullish()
 });
 var serializedParametersContainerSchema = _v3.z.union([
   parametersContainerSchema,
@@ -17323,10 +19325,10 @@ var Project2 = (_class22 = class {
   
   
   
-  __init78() {this._publishableCodeFunctions = []}
-  __init79() {this._publishablePrompts = []}
-  __init80() {this._publishableParameters = []}
-  constructor(args) {;_class22.prototype.__init78.call(this);_class22.prototype.__init79.call(this);_class22.prototype.__init80.call(this);
+  __init80() {this._publishableCodeFunctions = []}
+  __init81() {this._publishablePrompts = []}
+  __init82() {this._publishableParameters = []}
+  constructor(args) {;_class22.prototype.__init80.call(this);_class22.prototype.__init81.call(this);_class22.prototype.__init82.call(this);
     _initializeSpanContext();
     this.name = "name" in args ? args.name : void 0;
     this.id = "id" in args ? args.id : void 0;
@@ -17380,10 +19382,10 @@ var Project2 = (_class22 = class {
   }
 }, _class22);
 var ToolBuilder = (_class23 = class {
-  constructor(project) {;_class23.prototype.__init81.call(this);
+  constructor(project) {;_class23.prototype.__init83.call(this);
     this.project = project;
   }
-  __init81() {this.taskCounter = 0}
+  __init83() {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) {
@@ -17410,10 +19412,10 @@ var ToolBuilder = (_class23 = class {
   }
 }, _class23);
 var ScorerBuilder = (_class24 = class {
-  constructor(project) {;_class24.prototype.__init82.call(this);
+  constructor(project) {;_class24.prototype.__init84.call(this);
     this.project = project;
   }
-  __init82() {this.taskCounter = 0}
+  __init84() {this.taskCounter = 0}
   create(opts) {
     this.taskCounter++;
     let resolvedName = opts.name;
@@ -17769,9 +19771,9 @@ function serializeRemoteEvalParametersContainer(parameters) {
     source: null
   };
 }
-var ProjectNameIdMap = (_class25 = class {constructor() { _class25.prototype.__init83.call(this);_class25.prototype.__init84.call(this); }
-  __init83() {this.nameToId = {}}
-  __init84() {this.idToName = {}}
+var ProjectNameIdMap = (_class25 = class {constructor() { _class25.prototype.__init85.call(this);_class25.prototype.__init86.call(this); }
+  __init85() {this.nameToId = {}}
+  __init86() {this.idToName = {}}
   async getId(projectName) {
     if (!(projectName in this.nameToId)) {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
@@ -17876,7 +19878,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _347 => _347.ctx, 'optionalAccess', _348 => _348.state])) {
+      if (!_optionalChain([req, 'access', _375 => _375.ctx, 'optionalAccess', _376 => _376.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -17927,12 +19929,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: evaluator.scores.concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _349 => _349.map, 'call', _350 => _350(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _377 => _377.map, 'call', _378 => _378(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _351 => _351.ctx, 'optionalAccess', _352 => _352.projectId])
+                  _optionalChain([req, 'access', _379 => _379.ctx, 'optionalAccess', _380 => _380.projectId])
                 )
               )]), () => ( []))
             ),