braintrust 3.5.0 → 3.7.0

package/dist/cli.js

@@ -1232,7 +1232,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "3.5.0",
+      version: "3.7.0",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
@@ -1319,6 +1319,10 @@ var require_package = __commonJS({
           module: "./dist/auto-instrumentations/bundler/webpack.mjs",
           require: "./dist/auto-instrumentations/bundler/webpack.js"
         },
+        "./webpack-loader": {
+          types: "./dist/auto-instrumentations/bundler/webpack-loader.d.ts",
+          require: "./dist/auto-instrumentations/bundler/webpack-loader.cjs"
+        },
         "./esbuild": {
           types: "./dist/auto-instrumentations/bundler/esbuild.d.ts",
           import: "./dist/auto-instrumentations/bundler/esbuild.mjs",
@@ -5775,6 +5779,9 @@ var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
 var LOGS3_OVERFLOW_REFERENCE_TYPE = "logs3_overflow";
 var BRAINTRUST_PARAMS = Object.keys(BraintrustModelParams.shape);
+var RESET_CONTEXT_MANAGER_STATE = Symbol.for(
+  "braintrust.resetContextManagerState"
+);
 var DEFAULT_MAX_REQUEST_SIZE = 6 * 1024 * 1024;
 var parametersRowSchema = import_v38.z.object({
   id: import_v38.z.string().uuid(),
@@ -5837,13 +5844,18 @@ function applyMaskingToField(maskingFunction, data, fieldName) {
     return `ERROR: Failed to mask field '${fieldName}' - ${errorType}`;
   }
 }
+var BRAINTRUST_CURRENT_SPAN_STORE = Symbol.for(
+  "braintrust.currentSpanStore"
+);
 var ContextManager = class {
 };
 var BraintrustContextManager = class extends ContextManager {
   _currentSpan;
+  [BRAINTRUST_CURRENT_SPAN_STORE];
   constructor() {
     super();
     this._currentSpan = isomorph_default.newAsyncLocalStorage();
+    this[BRAINTRUST_CURRENT_SPAN_STORE] = this._currentSpan;
   }
   getParentSpanIds() {
     const currentSpan2 = this._currentSpan.getStore();
@@ -6050,6 +6062,9 @@ var BraintrustState = class _BraintrustState {
   resetIdGenState() {
     this._idGenerator = null;
   }
+  [RESET_CONTEXT_MANAGER_STATE]() {
+    this._contextManager = null;
+  }
   get idGenerator() {
     if (this._idGenerator === null) {
       this._idGenerator = getIdGenerator();
@@ -12596,6 +12611,90 @@ var fancyReporter = {
 var import_node_async_hooks = require("node:async_hooks");
 var diagnostics_channel = __toESM(require("node:diagnostics_channel"));
 var path = __toESM(require("node:path"));
+
+// src/auto-instrumentations/patch-tracing-channel.ts
+function patchTracingChannel(tracingChannelFn) {
+  const dummyChannel = tracingChannelFn("__braintrust_probe__");
+  const TracingChannel = dummyChannel?.constructor;
+  if (!TracingChannel?.prototype) {
+    return;
+  }
+  if (!Object.getOwnPropertyDescriptor(TracingChannel.prototype, "hasSubscribers")) {
+    Object.defineProperty(TracingChannel.prototype, "hasSubscribers", {
+      configurable: true,
+      enumerable: false,
+      get() {
+        return Boolean(
+          this.start?.hasSubscribers || this.end?.hasSubscribers || this.asyncStart?.hasSubscribers || this.asyncEnd?.hasSubscribers || this.error?.hasSubscribers
+        );
+      }
+    });
+  }
+  if (TracingChannel.prototype.tracePromise) {
+    TracingChannel.prototype.tracePromise = function(fn, context2 = {}, thisArg, ...args) {
+      const { start, end, asyncStart, asyncEnd, error: error2 } = this;
+      function publishRejected(err) {
+        context2.error = err;
+        error2?.publish(context2);
+        asyncStart?.publish(context2);
+        asyncEnd?.publish(context2);
+      }
+      function publishResolved(result) {
+        context2.result = result;
+        asyncStart?.publish(context2);
+        asyncEnd?.publish(context2);
+      }
+      return start.runStores(context2, () => {
+        try {
+          const result = Reflect.apply(fn, thisArg, args);
+          end?.publish(context2);
+          if (result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function") {
+            if (result.constructor === Promise) {
+              return result.then(
+                (res) => {
+                  publishResolved(res);
+                  return res;
+                },
+                (err) => {
+                  publishRejected(err);
+                  return Promise.reject(err);
+                }
+              );
+            }
+            void result.then(
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              (resolved) => {
+                try {
+                  publishResolved(resolved);
+                } catch {
+                }
+              },
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              (err) => {
+                try {
+                  publishRejected(err);
+                } catch {
+                }
+              }
+            );
+            return result;
+          }
+          context2.result = result;
+          asyncStart?.publish(context2);
+          asyncEnd?.publish(context2);
+          return result;
+        } catch (err) {
+          context2.error = err;
+          error2?.publish(context2);
+          end?.publish(context2);
+          throw err;
+        }
+      });
+    };
+  }
+}
+
+// src/node/config.ts
 var fs = __toESM(require("node:fs/promises"));
 var os = __toESM(require("node:os"));
 var fsSync = __toESM(require("node:fs"));
@@ -13352,6 +13451,36 @@ function startSpanForEvent(config3, event, channelName) {
   }
   return { span, startTime };
 }
+function ensureSpanStateForEvent(states, config3, event, channelName) {
+  const key = event;
+  const existing = states.get(key);
+  if (existing) {
+    return existing;
+  }
+  const created = startSpanForEvent(config3, event, channelName);
+  states.set(key, created);
+  return created;
+}
+function bindCurrentSpanStoreToStart(tracingChannel2, states, config3, channelName) {
+  const state = _internalGetGlobalState();
+  const startChannel = tracingChannel2.start;
+  const currentSpanStore = state?.contextManager ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (!currentSpanStore || !startChannel) {
+    return void 0;
+  }
+  startChannel.bindStore(
+    currentSpanStore,
+    (event) => ensureSpanStateForEvent(
+      states,
+      config3,
+      event,
+      channelName
+    ).span
+  );
+  return () => {
+    startChannel.unbindStore(currentSpanStore);
+  };
+}
 function logErrorAndEnd(states, event) {
   const spanData = states.get(event);
   if (!spanData) {
@@ -13367,15 +13496,19 @@ function traceAsyncChannel(channel2, config3) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config3,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config3,
         event,
-        startSpanForEvent(
-          config3,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     asyncEnd: (event) => {
@@ -13417,6 +13550,7 @@ function traceAsyncChannel(channel2, config3) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -13424,15 +13558,19 @@ function traceStreamingChannel(channel2, config3) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config3,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config3,
         event,
-        startSpanForEvent(
-          config3,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     asyncEnd: (event) => {
@@ -13548,6 +13686,7 @@ function traceStreamingChannel(channel2, config3) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -13555,15 +13694,19 @@ function traceSyncStreamChannel(channel2, config3) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel2,
+    states,
+    config3,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config3,
         event,
-        startSpanForEvent(
-          config3,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     end: (event) => {
@@ -13652,6 +13795,7 @@ function traceSyncStreamChannel(channel2, config3) {
   };
   tracingChannel2.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel2.unsubscribe(handlers);
   };
 }
@@ -14423,7 +14567,7 @@ var AnthropicPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(anthropicChannels.betaMessagesCreate, {
         ...anthropicConfig,
-        name: "anthropic.beta.messages.create"
+        name: "anthropic.messages.create"
       })
     );
   }
@@ -14446,9 +14590,12 @@ function parseMetricsFromUsage2(usage) {
   return metrics;
 }
 function aggregateAnthropicStreamChunks(chunks) {
-  const deltas = [];
+  const fallbackTextDeltas = [];
+  const contentBlocks = {};
+  const contentBlockDeltas = {};
   let metrics = {};
   let metadata = {};
+  let role;
   for (const event of chunks) {
     switch (event?.type) {
       case "message_start":
@@ -14456,15 +14603,43 @@ function aggregateAnthropicStreamChunks(chunks) {
           const initialMetrics = parseMetricsFromUsage2(event.message.usage);
           metrics = { ...metrics, ...initialMetrics };
         }
+        if (typeof event.message?.role === "string") {
+          role = event.message.role;
+        }
+        break;
+      case "content_block_start":
+        if (event.content_block) {
+          contentBlocks[event.index] = event.content_block;
+          contentBlockDeltas[event.index] = [];
+        }
         break;
       case "content_block_delta":
         if (event.delta?.type === "text_delta") {
           const text = event.delta.text;
           if (text) {
-            deltas.push(text);
+            if (contentBlocks[event.index] !== void 0 || contentBlockDeltas[event.index] !== void 0) {
+              contentBlockDeltas[event.index] ??= [];
+              contentBlockDeltas[event.index].push(text);
+            } else {
+              fallbackTextDeltas.push(text);
+            }
+          }
+        } else if (event.delta?.type === "input_json_delta") {
+          const partialJson = event.delta.partial_json;
+          if (partialJson) {
+            contentBlockDeltas[event.index] ??= [];
+            contentBlockDeltas[event.index].push(partialJson);
           }
         }
         break;
+      case "content_block_stop":
+        finalizeContentBlock(
+          event.index,
+          contentBlocks,
+          contentBlockDeltas,
+          fallbackTextDeltas
+        );
+        break;
       case "message_delta":
         if (event.usage) {
           const finalMetrics = parseMetricsFromUsage2(event.usage);
@@ -14476,7 +14651,21 @@ function aggregateAnthropicStreamChunks(chunks) {
         break;
     }
   }
-  const output = deltas.join("");
+  const orderedContent = Object.entries(contentBlocks).map(([index, block]) => ({
+    block,
+    index: Number(index)
+  })).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)) {
+      output = orderedContent.map((block) => block.text).join("");
+    } else {
+      output = {
+        ...role ? { role } : {},
+        content: orderedContent
+      };
+    }
+  }
   const finalized = finalizeAnthropicTokens(metrics);
   const filteredMetrics = Object.fromEntries(
     Object.entries(finalized).filter(
@@ -14489,6 +14678,49 @@ function aggregateAnthropicStreamChunks(chunks) {
     metadata
   };
 }
+function finalizeContentBlock(index, contentBlocks, contentBlockDeltas, fallbackTextDeltas) {
+  const contentBlock = contentBlocks[index];
+  if (!contentBlock) {
+    return;
+  }
+  const text = contentBlockDeltas[index]?.join("") ?? "";
+  if (isToolUseContentBlock(contentBlock)) {
+    if (!text) {
+      return;
+    }
+    try {
+      contentBlocks[index] = {
+        ...contentBlock,
+        input: JSON.parse(text)
+      };
+    } catch {
+      fallbackTextDeltas.push(text);
+      delete contentBlocks[index];
+    }
+    return;
+  }
+  if (isTextContentBlock(contentBlock)) {
+    if (!text) {
+      delete contentBlocks[index];
+      return;
+    }
+    contentBlocks[index] = {
+      ...contentBlock,
+      text
+    };
+    return;
+  }
+  if (text) {
+    fallbackTextDeltas.push(text);
+  }
+  delete contentBlocks[index];
+}
+function isTextContentBlock(contentBlock) {
+  return contentBlock.type === "text";
+}
+function isToolUseContentBlock(contentBlock) {
+  return contentBlock.type === "tool_use";
+}
 function isAnthropicBase64ContentBlock(input) {
   return (input.type === "image" || input.type === "document") && isObject(input.source) && input.source.type === "base64";
 }
@@ -15611,12 +15843,15 @@ var claudeAgentSDKChannels = defineChannels(
   {
     query: channel({
       channelName: "query",
-      kind: "async"
+      kind: "sync-stream"
     })
   }
 );
 
 // src/instrumentation/plugins/claude-agent-sdk-plugin.ts
+function isSubAgentToolName(toolName) {
+  return toolName === "Agent" || toolName === "Task";
+}
 function filterSerializableOptions(options) {
   const allowedKeys = [
     "model",
@@ -15670,34 +15905,50 @@ function extractUsageFromMessage(message) {
   const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
   const cacheCreationTokens = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
   if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
-    const cacheTokens = extractAnthropicCacheTokens(
-      cacheReadTokens,
-      cacheCreationTokens
+    Object.assign(
+      metrics,
+      extractAnthropicCacheTokens(cacheReadTokens, cacheCreationTokens)
     );
-    Object.assign(metrics, cacheTokens);
   }
   if (Object.keys(metrics).length > 0) {
     Object.assign(metrics, finalizeAnthropicTokens(metrics));
   }
   return metrics;
 }
-function buildLLMInput(prompt, conversationHistory) {
-  const promptMessage = typeof prompt === "string" ? { content: prompt, role: "user" } : void 0;
-  const inputParts = [
-    ...promptMessage ? [promptMessage] : [],
-    ...conversationHistory
-  ];
+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 = msg.message?.role;
+      const content = msg.message?.content;
+      if (role && content !== void 0) {
+        promptMessages.push({ content, role });
+      }
+    }
+  }
+  const inputParts = [...promptMessages, ...conversationHistory];
   return inputParts.length > 0 ? inputParts : void 0;
 }
-async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
-  if (messages.length === 0) return void 0;
+function formatCapturedMessages(messages) {
+  return messages.length > 0 ? messages : [];
+}
+async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, capturedPromptMessages, parentSpan) {
+  if (messages.length === 0) {
+    return void 0;
+  }
   const lastMessage = messages[messages.length - 1];
   if (lastMessage.type !== "assistant" || !lastMessage.message?.usage) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
   const usage = extractUsageFromMessage(lastMessage);
-  const input = buildLLMInput(prompt, conversationHistory);
+  const input = buildLLMInput(
+    prompt,
+    conversationHistory,
+    capturedPromptMessages
+  );
   const outputs = messages.map(
     (m) => m.message?.content && m.message?.role ? { content: m.message.content, role: m.message.role } : void 0
   ).filter(
@@ -15705,21 +15956,359 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
   );
   const span = startSpan({
     name: "anthropic.messages.create",
+    parent: parentSpan,
     spanAttributes: {
       type: "llm" /* LLM */
     },
-    startTime,
-    parent: parentSpan
+    startTime
   });
   span.log({
     input,
-    output: outputs,
     metadata: model ? { model } : void 0,
-    metrics: usage
+    metrics: usage,
+    output: outputs
   });
   await span.end();
   return lastMessage.message?.content && lastMessage.message?.role ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
+function getMcpServerMetadata(serverName, mcpServers) {
+  if (!serverName || !mcpServers) {
+    return {};
+  }
+  const serverConfig = mcpServers[serverName];
+  if (!serverConfig) {
+    return {};
+  }
+  const metadata = {};
+  if (serverConfig.type) {
+    metadata["mcp.type"] = serverConfig.type;
+  } else if (typeof serverConfig === "object" && "transport" in serverConfig) {
+    metadata["mcp.type"] = "sdk";
+  }
+  if (serverConfig.url) {
+    metadata["mcp.url"] = serverConfig.url;
+  }
+  if (serverConfig.command) {
+    metadata["mcp.command"] = serverConfig.command;
+    if (serverConfig.args) {
+      metadata["mcp.args"] = serverConfig.args.join(" ");
+    }
+  }
+  return metadata;
+}
+function parseToolName(rawToolName) {
+  const mcpMatch = rawToolName.match(/^mcp__([^_]+)__(.+)$/);
+  if (mcpMatch) {
+    const [, mcpServer, toolName] = mcpMatch;
+    return {
+      displayName: `tool: ${mcpServer}/${toolName}`,
+      mcpServer,
+      rawToolName,
+      toolName
+    };
+  }
+  return {
+    displayName: `tool: ${rawToolName}`,
+    rawToolName,
+    toolName: rawToolName
+  };
+}
+function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, subAgentSpans, endedSubAgentSpans) {
+  const preToolUse = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PreToolUse" || !toolUseID) {
+      return {};
+    }
+    if (isSubAgentToolName(input.tool_name)) {
+      return {};
+    }
+    const parsed = parseToolName(input.tool_name);
+    const toolSpan = startSpan({
+      event: {
+        input: input.tool_input,
+        metadata: {
+          "claude_agent_sdk.cwd": input.cwd,
+          "claude_agent_sdk.raw_tool_name": parsed.rawToolName,
+          "claude_agent_sdk.session_id": input.session_id,
+          "gen_ai.tool.call.id": toolUseID,
+          "gen_ai.tool.name": parsed.toolName,
+          ...parsed.mcpServer && { "mcp.server": parsed.mcpServer },
+          ...getMcpServerMetadata(parsed.mcpServer, mcpServers)
+        }
+      },
+      name: parsed.displayName,
+      parent: await resolveParentSpan(toolUseID),
+      spanAttributes: { type: "tool" /* TOOL */ }
+    });
+    activeToolSpans.set(toolUseID, toolSpan);
+    return {};
+  };
+  const postToolUse = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PostToolUse" || !toolUseID) {
+      return {};
+    }
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan) {
+      try {
+        const response = input.tool_response;
+        const metadata = {};
+        if (response?.status) {
+          metadata["claude_agent_sdk.status"] = response.status;
+        }
+        if (response?.totalDurationMs) {
+          metadata["claude_agent_sdk.duration_ms"] = response.totalDurationMs;
+        }
+        if (response?.totalToolUseCount !== void 0) {
+          metadata["claude_agent_sdk.tool_use_count"] = response.totalToolUseCount;
+        }
+        subAgentSpan.log({
+          metadata,
+          output: response?.content
+        });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
+    const toolSpan = activeToolSpans.get(toolUseID);
+    if (!toolSpan) {
+      return {};
+    }
+    try {
+      toolSpan.log({ output: input.tool_response });
+    } finally {
+      toolSpan.end();
+      activeToolSpans.delete(toolUseID);
+    }
+    return {};
+  };
+  const postToolUseFailure = async (input, toolUseID) => {
+    if (input.hook_event_name !== "PostToolUseFailure" || !toolUseID) {
+      return {};
+    }
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan) {
+      try {
+        subAgentSpan.log({ error: input.error });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
+    const toolSpan = activeToolSpans.get(toolUseID);
+    if (!toolSpan) {
+      return {};
+    }
+    const parsed = parseToolName(input.tool_name);
+    try {
+      toolSpan.log({
+        error: input.error,
+        metadata: {
+          "claude_agent_sdk.is_interrupt": input.is_interrupt,
+          "claude_agent_sdk.session_id": input.session_id,
+          "gen_ai.tool.call.id": toolUseID,
+          "gen_ai.tool.name": parsed.toolName,
+          ...parsed.mcpServer && { "mcp.server": parsed.mcpServer }
+        }
+      });
+    } finally {
+      toolSpan.end();
+      activeToolSpans.delete(toolUseID);
+    }
+    return {};
+  };
+  return { postToolUse, postToolUseFailure, preToolUse };
+}
+function injectTracingHooks(options, resolveParentSpan, activeToolSpans, subAgentSpans, endedSubAgentSpans) {
+  const { preToolUse, postToolUse, postToolUseFailure } = createToolTracingHooks(
+    resolveParentSpan,
+    activeToolSpans,
+    options.mcpServers,
+    subAgentSpans,
+    endedSubAgentSpans
+  );
+  const existingHooks = options.hooks ?? {};
+  return {
+    ...options,
+    hooks: {
+      ...existingHooks,
+      PostToolUse: [
+        ...existingHooks.PostToolUse ?? [],
+        { hooks: [postToolUse] }
+      ],
+      PostToolUseFailure: [
+        ...existingHooks.PostToolUseFailure ?? [],
+        {
+          hooks: [postToolUseFailure]
+        }
+      ],
+      PreToolUse: [
+        ...existingHooks.PreToolUse ?? [],
+        { hooks: [preToolUse] }
+      ]
+    }
+  };
+}
+async function finalizeCurrentMessageGroup(state) {
+  if (state.currentMessages.length === 0) {
+    return;
+  }
+  const parentToolUseId = state.currentMessages[0]?.parent_tool_use_id ?? null;
+  let parentSpan = await state.span.export();
+  if (parentToolUseId) {
+    const subAgentSpan = state.subAgentSpans.get(parentToolUseId);
+    if (subAgentSpan) {
+      parentSpan = await subAgentSpan.export();
+    }
+  }
+  const finalMessage = await createLLMSpanForMessages(
+    state.currentMessages,
+    state.originalPrompt,
+    state.finalResults,
+    state.options,
+    state.currentMessageStartTime,
+    state.capturedPromptMessages,
+    parentSpan
+  );
+  if (finalMessage) {
+    state.finalResults.push(finalMessage);
+  }
+  const lastMessage = state.currentMessages[state.currentMessages.length - 1];
+  if (lastMessage?.message?.usage) {
+    state.accumulatedOutputTokens += getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
+  }
+  state.currentMessages.length = 0;
+}
+function maybeTrackToolUseContext(state, message) {
+  if (message.type !== "assistant" || !Array.isArray(message.message?.content)) {
+    return;
+  }
+  const parentToolUseId = message.parent_tool_use_id ?? null;
+  for (const block of message.message.content) {
+    if (typeof block !== "object" || block === null || !("type" in block) || block.type !== "tool_use" || !("id" in block) || typeof block.id !== "string") {
+      continue;
+    }
+    state.toolUseToParent.set(block.id, parentToolUseId);
+    if (block.name === "Task" && typeof block.input === "object" && block.input !== null && "subagent_type" in block.input && typeof block.input.subagent_type === "string") {
+      state.pendingSubAgentNames.set(block.id, block.input.subagent_type);
+    }
+  }
+}
+async function maybeStartSubAgentSpan(state, message) {
+  if (!("parent_tool_use_id" in message)) {
+    return;
+  }
+  const parentToolUseId = message.parent_tool_use_id;
+  if (!parentToolUseId) {
+    return;
+  }
+  await ensureSubAgentSpan(
+    state.pendingSubAgentNames,
+    state.span,
+    state.subAgentSpans,
+    parentToolUseId
+  );
+}
+async function ensureSubAgentSpan(pendingSubAgentNames, rootSpan, subAgentSpans, parentToolUseId) {
+  const existingSpan = subAgentSpans.get(parentToolUseId);
+  if (existingSpan) {
+    return existingSpan;
+  }
+  const agentName = pendingSubAgentNames.get(parentToolUseId);
+  const spanName = agentName ? `Agent: ${agentName}` : "Agent: sub-agent";
+  const subAgentSpan = startSpan({
+    event: {
+      metadata: {
+        ...agentName && { "claude_agent_sdk.agent_type": agentName }
+      }
+    },
+    name: spanName,
+    parent: await rootSpan.export(),
+    spanAttributes: { type: "task" /* TASK */ }
+  });
+  subAgentSpans.set(parentToolUseId, subAgentSpan);
+  return subAgentSpan;
+}
+async function handleStreamMessage(state, message) {
+  maybeTrackToolUseContext(state, message);
+  await maybeStartSubAgentSpan(state, message);
+  const messageId = message.message?.id;
+  if (messageId && messageId !== state.currentMessageId) {
+    await finalizeCurrentMessageGroup(state);
+    state.currentMessageId = messageId;
+    state.currentMessageStartTime = getCurrentUnixTimestamp();
+  }
+  if (message.type === "assistant" && message.message?.usage) {
+    state.currentMessages.push(message);
+  }
+  if (message.type !== "result" || !message.usage) {
+    return;
+  }
+  const finalUsageMetrics = extractUsageFromMessage(message);
+  if (state.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
+    const lastMessage = state.currentMessages[state.currentMessages.length - 1];
+    if (lastMessage?.message?.usage) {
+      const adjustedTokens = finalUsageMetrics.completion_tokens - state.accumulatedOutputTokens;
+      if (adjustedTokens >= 0) {
+        lastMessage.message.usage.output_tokens = adjustedTokens;
+      }
+      const resultUsage = message.usage;
+      if (resultUsage && typeof resultUsage === "object") {
+        const cacheReadTokens = getNumberProperty(
+          resultUsage,
+          "cache_read_input_tokens"
+        );
+        if (cacheReadTokens !== void 0) {
+          lastMessage.message.usage.cache_read_input_tokens = cacheReadTokens;
+        }
+        const cacheCreationTokens = getNumberProperty(
+          resultUsage,
+          "cache_creation_input_tokens"
+        );
+        if (cacheCreationTokens !== void 0) {
+          lastMessage.message.usage.cache_creation_input_tokens = cacheCreationTokens;
+        }
+      }
+    }
+  }
+  const metadata = {};
+  if (message.num_turns !== void 0) {
+    metadata.num_turns = message.num_turns;
+  }
+  if (message.session_id !== void 0) {
+    metadata.session_id = message.session_id;
+  }
+  if (Object.keys(metadata).length > 0) {
+    state.span.log({ metadata });
+  }
+}
+async function finalizeQuerySpan(state) {
+  try {
+    await finalizeCurrentMessageGroup(state);
+    state.span.log({
+      output: state.finalResults.length > 0 ? state.finalResults[state.finalResults.length - 1] : void 0
+    });
+    if (state.capturedPromptMessages) {
+      if (state.promptStarted()) {
+        await state.promptDone;
+      }
+      if (state.capturedPromptMessages.length > 0) {
+        state.span.log({
+          input: formatCapturedMessages(state.capturedPromptMessages)
+        });
+      }
+    }
+  } finally {
+    for (const [id, subAgentSpan] of state.subAgentSpans) {
+      if (!state.endedSubAgentSpans.has(id)) {
+        subAgentSpan.end();
+      }
+    }
+    state.subAgentSpans.clear();
+    state.span.end();
+  }
+}
 var ClaudeAgentSDKPlugin = class extends BasePlugin {
   onEnable() {
     this.subscribeToQuery();
@@ -15730,19 +16319,36 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
     }
     this.unsubscribers = [];
   }
-  /**
-   * Subscribe to the query channel for agent interactions.
-   * Handles streaming responses and traces both the top-level agent task
-   * and individual LLM calls.
-   */
   subscribeToQuery() {
     const channel2 = claudeAgentSDKChannels.query.tracingChannel();
     const spans = /* @__PURE__ */ new WeakMap();
     const handlers = {
       start: (event) => {
-        const params = event.arguments[0];
-        const prompt = params?.prompt;
-        const options = params?.options ?? {};
+        const params = event.arguments[0] ?? {};
+        const originalPrompt = params.prompt;
+        const options = params.options ?? {};
+        const promptIsAsyncIterable = isAsyncIterable3(originalPrompt);
+        let promptStarted = false;
+        let capturedPromptMessages;
+        let resolvePromptDone;
+        const promptDone = new Promise((resolve2) => {
+          resolvePromptDone = resolve2;
+        });
+        if (promptIsAsyncIterable) {
+          capturedPromptMessages = [];
+          const promptStream = originalPrompt;
+          params.prompt = (async function* () {
+            promptStarted = true;
+            try {
+              for await (const message of promptStream) {
+                capturedPromptMessages.push(message);
+                yield message;
+              }
+            } finally {
+              resolvePromptDone?.();
+            }
+          })();
+        }
         const span = startSpan({
           name: "Claude Agent",
           spanAttributes: {
@@ -15752,163 +16358,115 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         const startTime = getCurrentUnixTimestamp();
         try {
           span.log({
-            input: typeof prompt === "string" ? prompt : {
-              type: "streaming",
-              description: "AsyncIterable<ClaudeAgentSDKMessage>"
-            },
+            input: typeof originalPrompt === "string" ? originalPrompt : promptIsAsyncIterable ? void 0 : originalPrompt !== void 0 ? String(originalPrompt) : void 0,
             metadata: filterSerializableOptions(options)
           });
         } catch (error2) {
           console.error("Error extracting input for Claude Agent SDK:", error2);
         }
+        const activeToolSpans = /* @__PURE__ */ new Map();
+        const subAgentSpans = /* @__PURE__ */ new Map();
+        const endedSubAgentSpans = /* @__PURE__ */ new Set();
+        const toolUseToParent = /* @__PURE__ */ new Map();
+        const pendingSubAgentNames = /* @__PURE__ */ new Map();
+        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();
+          },
+          activeToolSpans,
+          subAgentSpans,
+          endedSubAgentSpans
+        );
+        params.options = optionsWithHooks;
+        event.arguments[0] = params;
         spans.set(event, {
-          span,
-          startTime,
-          conversationHistory: [],
-          currentMessages: [],
+          accumulatedOutputTokens: 0,
+          activeToolSpans,
+          capturedPromptMessages,
           currentMessageId: void 0,
           currentMessageStartTime: startTime,
-          accumulatedOutputTokens: 0
+          currentMessages: [],
+          endedSubAgentSpans,
+          finalResults: [],
+          options: optionsWithHooks,
+          originalPrompt,
+          pendingSubAgentNames,
+          processing: Promise.resolve(),
+          promptDone,
+          promptStarted: () => promptStarted,
+          span,
+          subAgentSpans,
+          toolUseToParent
         });
       },
-      asyncEnd: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData) {
+      end: (event) => {
+        const state = spans.get(event);
+        if (!state) {
           return;
         }
         const eventResult = event.result;
         if (eventResult === void 0) {
-          spanData.span.end();
+          state.span.end();
           spans.delete(event);
           return;
         }
         if (isAsyncIterable3(eventResult)) {
           patchStreamIfNeeded(eventResult, {
-            onChunk: async (message) => {
-              const currentTime = getCurrentUnixTimestamp();
-              const params = event.arguments[0];
-              const prompt = params?.prompt;
-              const options = params?.options ?? {};
-              const messageId = message.message?.id;
-              if (messageId && messageId !== spanData.currentMessageId) {
-                if (spanData.currentMessages.length > 0) {
-                  const finalMessage = await createLLMSpanForMessages(
-                    spanData.currentMessages,
-                    prompt,
-                    spanData.conversationHistory,
-                    options,
-                    spanData.currentMessageStartTime,
-                    await spanData.span.export()
-                  );
-                  if (finalMessage) {
-                    spanData.conversationHistory.push(finalMessage);
-                  }
-                  const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (lastMessage?.message?.usage) {
-                    const outputTokens = getNumberProperty(
-                      lastMessage.message.usage,
-                      "output_tokens"
-                    ) || 0;
-                    spanData.accumulatedOutputTokens += outputTokens;
-                  }
-                  spanData.currentMessages = [];
-                }
-                spanData.currentMessageId = messageId;
-                spanData.currentMessageStartTime = currentTime;
-              }
-              if (message.type === "assistant" && message.message?.usage) {
-                spanData.currentMessages.push(message);
-              }
-              if (message.type === "result" && message.usage) {
-                const finalUsageMetrics = extractUsageFromMessage(message);
-                if (spanData.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
-                  const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (lastMessage?.message?.usage) {
-                    const adjustedTokens = finalUsageMetrics.completion_tokens - spanData.accumulatedOutputTokens;
-                    if (adjustedTokens >= 0) {
-                      lastMessage.message.usage.output_tokens = adjustedTokens;
-                    }
-                  }
-                }
-                const result_metadata = {};
-                if (message.num_turns !== void 0) {
-                  result_metadata.num_turns = message.num_turns;
-                }
-                if (message.session_id !== void 0) {
-                  result_metadata.session_id = message.session_id;
-                }
-                if (Object.keys(result_metadata).length > 0) {
-                  spanData.span.log({
-                    metadata: result_metadata
-                  });
-                }
-              }
-            },
-            onComplete: async () => {
-              try {
-                const params = event.arguments[0];
-                const prompt = params?.prompt;
-                const options = params?.options ?? {};
-                if (spanData.currentMessages.length > 0) {
-                  const finalMessage = await createLLMSpanForMessages(
-                    spanData.currentMessages,
-                    prompt,
-                    spanData.conversationHistory,
-                    options,
-                    spanData.currentMessageStartTime,
-                    await spanData.span.export()
-                  );
-                  if (finalMessage) {
-                    spanData.conversationHistory.push(finalMessage);
-                  }
-                }
-                spanData.span.log({
-                  output: spanData.conversationHistory.length > 0 ? spanData.conversationHistory[spanData.conversationHistory.length - 1] : void 0
-                });
-              } catch (error2) {
+            onChunk: (message) => {
+              maybeTrackToolUseContext(state, message);
+              state.processing = state.processing.then(() => handleStreamMessage(state, message)).catch((error2) => {
                 console.error(
-                  "Error extracting output for Claude Agent SDK:",
+                  "Error processing Claude Agent SDK stream chunk:",
                   error2
                 );
-              } finally {
-                spanData.span.end();
-                spans.delete(event);
-              }
+              });
+            },
+            onComplete: () => {
+              void state.processing.then(() => finalizeQuerySpan(state)).finally(() => {
+                spans.delete(event);
+              });
             },
             onError: (error2) => {
-              spanData.span.log({
-                error: error2.message
+              void state.processing.then(() => {
+                state.span.log({
+                  error: error2.message
+                });
+              }).then(() => finalizeQuerySpan(state)).finally(() => {
+                spans.delete(event);
               });
-              spanData.span.end();
-              spans.delete(event);
             }
           });
-        } else {
-          try {
-            spanData.span.log({
-              output: eventResult
-            });
-          } catch (error2) {
-            console.error(
-              "Error extracting output for Claude Agent SDK:",
-              error2
-            );
-          } finally {
-            spanData.span.end();
-            spans.delete(event);
-          }
+          return;
+        }
+        try {
+          state.span.log({ output: eventResult });
+        } catch (error2) {
+          console.error("Error extracting output for Claude Agent SDK:", error2);
+        } finally {
+          state.span.end();
+          spans.delete(event);
         }
       },
       error: (event) => {
-        const spanData = spans.get(event);
-        if (!spanData || !event.error) {
+        const state = spans.get(event);
+        if (!state || !event.error) {
           return;
         }
-        const { span } = spanData;
-        span.log({
+        state.span.log({
           error: event.error.message
         });
-        span.end();
+        state.span.end();
         spans.delete(event);
       }
     };
@@ -15932,6 +16490,18 @@ var googleGenAIChannels = defineChannels("@google/genai", {
 });
 
 // src/instrumentation/plugins/google-genai-plugin.ts
+var GOOGLE_GENAI_INTERNAL_CONTEXT = {
+  caller_filename: "<node-internal>",
+  caller_functionname: "<node-internal>",
+  caller_lineno: 0
+};
+function createWrapperParityEvent(args) {
+  return {
+    context: GOOGLE_GENAI_INTERNAL_CONTEXT,
+    input: args.input,
+    metadata: args.metadata
+  };
+}
 var GoogleGenAIPlugin = class extends BasePlugin {
   onEnable() {
     this.subscribeToGoogleGenAIChannels();
@@ -15940,51 +16510,282 @@ var GoogleGenAIPlugin = class extends BasePlugin {
     this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
   subscribeToGoogleGenAIChannels() {
-    this.unsubscribers.push(
-      traceAsyncChannel(googleGenAIChannels.generateContent, {
-        name: "google-genai.generateContent",
-        type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          const input = serializeInput(params);
-          const metadata = extractMetadata(params);
-          return {
-            input,
-            metadata: { ...metadata, provider: "google-genai" }
-          };
-        },
-        extractOutput: (result) => {
-          return result;
-        },
-        extractMetrics: (result, startTime) => {
-          return extractGenerateContentMetrics(result, startTime);
-        }
-      })
+    this.subscribeToGenerateContentChannel();
+    this.subscribeToGenerateContentStreamChannel();
+  }
+  subscribeToGenerateContentChannel() {
+    const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
+      tracingChannel2,
+      states,
+      (event) => {
+        const params = event.arguments[0];
+        const input = serializeInput(params);
+        const metadata = extractMetadata(params);
+        const span = startSpan({
+          name: "generate_content",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: createWrapperParityEvent({ input, metadata })
+        });
+        return {
+          span,
+          startTime: getCurrentUnixTimestamp()
+        };
+      }
     );
-    this.unsubscribers.push(
-      traceStreamingChannel(googleGenAIChannels.generateContentStream, {
-        name: "google-genai.generateContentStream",
-        type: "llm" /* LLM */,
-        extractInput: ([params]) => {
+    const handlers = {
+      start: (event) => {
+        ensureSpanState(states, event, () => {
+          const params = event.arguments[0];
           const input = serializeInput(params);
           const metadata = extractMetadata(params);
+          const span = startSpan({
+            name: "generate_content",
+            spanAttributes: {
+              type: "llm" /* LLM */
+            },
+            event: createWrapperParityEvent({ input, metadata })
+          });
           return {
-            input,
-            metadata: { ...metadata, provider: "google-genai" }
+            span,
+            startTime: getCurrentUnixTimestamp()
           };
-        },
-        extractOutput: (result) => {
-          return result;
-        },
-        extractMetrics: () => {
-          return {};
-        },
-        aggregateChunks: (chunks, _result, _endEvent, startTime) => {
-          return aggregateGenerateContentChunks(chunks, startTime);
+        });
+      },
+      asyncEnd: (event) => {
+        const spanState = states.get(event);
+        if (!spanState) {
+          return;
         }
-      })
-    );
+        try {
+          spanState.span.log({
+            metrics: cleanMetrics(
+              extractGenerateContentMetrics(
+                event.result,
+                spanState.startTime
+              )
+            ),
+            output: event.result
+          });
+        } finally {
+          spanState.span.end();
+          states.delete(event);
+        }
+      },
+      error: (event) => {
+        logErrorAndEndSpan(states, event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToGenerateContentStreamChannel() {
+    const tracingChannel2 = googleGenAIChannels.generateContentStream.tracingChannel();
+    const handlers = {
+      start: (event) => {
+        const streamEvent = event;
+        const params = event.arguments[0];
+        streamEvent.googleGenAIInput = serializeInput(params);
+        streamEvent.googleGenAIMetadata = extractMetadata(params);
+      },
+      asyncEnd: (event) => {
+        const streamEvent = event;
+        patchGoogleGenAIStreamingResult({
+          input: streamEvent.googleGenAIInput,
+          metadata: streamEvent.googleGenAIMetadata,
+          result: streamEvent.result
+        });
+      },
+      error: () => {
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      tracingChannel2.unsubscribe(handlers);
+    });
   }
 };
+function ensureSpanState(states, event, create) {
+  const existing = states.get(event);
+  if (existing) {
+    return existing;
+  }
+  const created = create();
+  states.set(event, created);
+  return created;
+}
+function bindCurrentSpanStoreToStart2(tracingChannel2, states, create) {
+  const state = _internalGetGlobalState();
+  const startChannel = tracingChannel2.start;
+  const currentSpanStore = state?.contextManager ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (!startChannel?.bindStore || !currentSpanStore) {
+    return void 0;
+  }
+  startChannel.bindStore(
+    currentSpanStore,
+    (event) => ensureSpanState(
+      states,
+      event,
+      () => create(event)
+    ).span
+  );
+  return () => {
+    startChannel.unbindStore?.(currentSpanStore);
+  };
+}
+function logErrorAndEndSpan(states, event) {
+  const spanState = states.get(event);
+  if (!spanState) {
+    return;
+  }
+  spanState.span.log({
+    error: event.error.message
+  });
+  spanState.span.end();
+  states.delete(event);
+}
+function patchGoogleGenAIStreamingResult(args) {
+  const { input, metadata, result } = args;
+  if (!input || !metadata || !result || typeof result !== "object" || typeof result.next !== "function") {
+    return false;
+  }
+  const chunks = [];
+  let firstTokenTime = null;
+  let finalized = false;
+  let span = null;
+  let startTime = null;
+  const ensureSpan = () => {
+    if (!span) {
+      span = startSpan({
+        name: "generate_content_stream",
+        spanAttributes: {
+          type: "llm" /* LLM */
+        },
+        event: {
+          input,
+          metadata
+        }
+      });
+      startTime = getCurrentUnixTimestamp();
+    }
+    return span;
+  };
+  const finalize = (options) => {
+    if (finalized || !span) {
+      return;
+    }
+    finalized = true;
+    if (options.result) {
+      const { end, ...metricsWithoutEnd } = options.result.metrics;
+      span.log({
+        metrics: cleanMetrics(metricsWithoutEnd),
+        output: options.result.aggregated
+      });
+      span.end(typeof end === "number" ? { endTime: end } : void 0);
+      return;
+    }
+    if (options.error !== void 0) {
+      span.log({
+        error: options.error instanceof Error ? options.error.message : String(options.error)
+      });
+    }
+    span.end();
+  };
+  const patchIterator = (iterator) => {
+    if (typeof iterator !== "object" || iterator === null || "__braintrustGoogleGenAIPatched" in iterator) {
+      return iterator;
+    }
+    const iteratorRecord = iterator;
+    const originalNext = typeof iteratorRecord.next === "function" ? iteratorRecord.next.bind(iterator) : void 0;
+    const originalReturn = typeof iteratorRecord.return === "function" ? iteratorRecord.return.bind(iterator) : void 0;
+    const originalThrow = typeof iteratorRecord.throw === "function" ? iteratorRecord.throw.bind(iterator) : void 0;
+    const asyncIteratorMethod = iteratorRecord[Symbol.asyncIterator];
+    const originalAsyncIterator = typeof asyncIteratorMethod === "function" ? asyncIteratorMethod.bind(iterator) : void 0;
+    Object.defineProperty(iteratorRecord, "__braintrustGoogleGenAIPatched", {
+      configurable: true,
+      enumerable: false,
+      value: true,
+      writable: false
+    });
+    if (originalNext) {
+      iteratorRecord.next = async (...nextArgs) => {
+        ensureSpan();
+        try {
+          const nextResult = await originalNext(
+            ...nextArgs
+          );
+          if (!nextResult.done && nextResult.value) {
+            if (firstTokenTime === null) {
+              firstTokenTime = getCurrentUnixTimestamp();
+            }
+            chunks.push(nextResult.value);
+          }
+          if (nextResult.done && startTime !== null) {
+            finalize({
+              result: aggregateGenerateContentChunks(
+                chunks,
+                startTime,
+                firstTokenTime
+              )
+            });
+          }
+          return nextResult;
+        } catch (error2) {
+          finalize({ error: error2 });
+          throw error2;
+        }
+      };
+    }
+    if (originalReturn) {
+      iteratorRecord.return = async (...returnArgs) => {
+        ensureSpan();
+        try {
+          return await originalReturn(
+            ...returnArgs
+          );
+        } finally {
+          if (startTime !== null) {
+            finalize({
+              result: chunks.length > 0 ? aggregateGenerateContentChunks(
+                chunks,
+                startTime,
+                firstTokenTime
+              ) : void 0
+            });
+          } else {
+            finalize({});
+          }
+        }
+      };
+    }
+    if (originalThrow) {
+      iteratorRecord.throw = async (...throwArgs) => {
+        ensureSpan();
+        try {
+          return await originalThrow(
+            ...throwArgs
+          );
+        } catch (error2) {
+          finalize({ error: error2 });
+          throw error2;
+        }
+      };
+    }
+    iteratorRecord[Symbol.asyncIterator] = () => {
+      const asyncIterator = originalAsyncIterator ? originalAsyncIterator() : iterator;
+      return patchIterator(asyncIterator);
+    };
+    return iterator;
+  };
+  patchIterator(result);
+  return true;
+}
 function serializeInput(params) {
   const input = {
     model: params.model,
@@ -15993,11 +16794,13 @@ function serializeInput(params) {
   if (params.config) {
     const config3 = tryToDict(params.config);
     if (config3) {
-      const tools = serializeTools(params);
-      if (tools) {
-        config3.tools = tools;
-      }
-      input.config = config3;
+      const filteredConfig = {};
+      Object.keys(config3).forEach((key) => {
+        if (key !== "tools") {
+          filteredConfig[key] = config3[key];
+        }
+      });
+      input.config = filteredConfig;
     }
   }
   return input;
@@ -16084,12 +16887,18 @@ function extractMetadata(params) {
       });
     }
   }
+  const tools = serializeTools(params);
+  if (tools) {
+    metadata.tools = tools;
+  }
   return metadata;
 }
 function extractGenerateContentMetrics(response, startTime) {
   const metrics = {};
-  if (startTime) {
+  if (startTime !== void 0) {
     const end = getCurrentUnixTimestamp();
+    metrics.start = startTime;
+    metrics.end = end;
     metrics.duration = end - startTime;
   }
   if (response?.usageMetadata) {
@@ -16114,19 +16923,18 @@ function populateUsageMetrics(metrics, usage) {
     metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
   }
 }
-function aggregateGenerateContentChunks(chunks, startTime) {
-  const metrics = {};
-  if (startTime !== void 0) {
-    const end = getCurrentUnixTimestamp();
-    metrics.duration = end - startTime;
-  }
-  let firstTokenTime = null;
-  if (chunks.length > 0 && firstTokenTime === null && startTime !== void 0) {
-    firstTokenTime = getCurrentUnixTimestamp();
+function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
+  const end = getCurrentUnixTimestamp();
+  const metrics = {
+    start: startTime,
+    end,
+    duration: end - startTime
+  };
+  if (firstTokenTime !== null) {
     metrics.time_to_first_token = firstTokenTime - startTime;
   }
   if (chunks.length === 0) {
-    return { output: {}, metrics };
+    return { aggregated: {}, metrics };
   }
   let text = "";
   let thoughtText = "";
@@ -16162,7 +16970,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
       }
     }
   }
-  const output = {};
+  const aggregated = {};
   const parts = [];
   if (thoughtText) {
     parts.push({ text: thoughtText, thought: true });
@@ -16188,16 +16996,25 @@ function aggregateGenerateContentChunks(chunks, startTime) {
       }
       candidates.push(candidateDict);
     }
-    output.candidates = candidates;
+    aggregated.candidates = candidates;
   }
   if (usageMetadata) {
-    output.usageMetadata = usageMetadata;
+    aggregated.usageMetadata = usageMetadata;
     populateUsageMetrics(metrics, usageMetadata);
   }
   if (text) {
-    output.text = text;
+    aggregated.text = text;
   }
-  return { output, metrics };
+  return { aggregated, metrics };
+}
+function cleanMetrics(metrics) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(metrics)) {
+    if (value !== null && value !== void 0) {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
 }
 function tryToDict(obj) {
   if (obj === null || obj === void 0) {
@@ -16213,54 +17030,1076 @@ function tryToDict(obj) {
   return null;
 }
 
-// src/instrumentation/braintrust-plugin.ts
-var BraintrustPlugin = class extends BasePlugin {
-  config;
-  openaiPlugin = null;
-  anthropicPlugin = null;
-  aiSDKPlugin = null;
-  claudeAgentSDKPlugin = null;
-  googleGenAIPlugin = null;
-  constructor(config3 = {}) {
-    super();
-    this.config = config3;
+// 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"
+  }),
+  toolExecute: channel({
+    channelName: "tool.execute",
+    kind: "async"
+  })
+});
+
+// src/openrouter-utils.ts
+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 {};
   }
-  onEnable() {
-    const integrations = this.config.integrations || {};
-    if (integrations.openai !== false) {
-      this.openaiPlugin = new OpenAIPlugin();
-      this.openaiPlugin.enable();
-    }
-    if (integrations.anthropic !== false) {
-      this.anthropicPlugin = new AnthropicPlugin();
-      this.anthropicPlugin.enable();
+  const metrics = {};
+  for (const [name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      metrics[TOKEN_NAME_MAP2[name] || camelToSnake(name)] = value;
+      continue;
     }
-    if (integrations.aisdk !== false && integrations.vercel !== false) {
-      this.aiSDKPlugin = new AISDKPlugin();
-      this.aiSDKPlugin.enable();
+    if (!isObject(value)) {
+      continue;
     }
-    if (integrations.claudeAgentSDK !== false) {
-      this.claudeAgentSDKPlugin = new ClaudeAgentSDKPlugin();
-      this.claudeAgentSDKPlugin.enable();
+    const prefix = TOKEN_DETAIL_PREFIX_MAP[name];
+    if (!prefix) {
+      continue;
     }
-    if (integrations.googleGenAI !== false && integrations.google !== false) {
-      this.googleGenAIPlugin = new GoogleGenAIPlugin();
-      this.googleGenAIPlugin.enable();
+    for (const [nestedName, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${camelToSnake(nestedName)}`] = nestedValue;
     }
   }
-  onDisable() {
-    if (this.openaiPlugin) {
-      this.openaiPlugin.disable();
-      this.openaiPlugin = null;
-    }
-    if (this.anthropicPlugin) {
-      this.anthropicPlugin.disable();
-      this.anthropicPlugin = null;
-    }
-    if (this.aiSDKPlugin) {
-      this.aiSDKPlugin.disable();
-      this.aiSDKPlugin = null;
-    }
+  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;
+}
+
+// src/openrouter-logging.ts
+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 isZodSchema2(value) {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function serializeZodSchema2(schema) {
+  try {
+    return zodToJsonSchema(schema);
+  } catch {
+    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 (isZodSchema2(value)) {
+    return serializeZodSchema2(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, 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 } : {},
+    ...xTitle !== void 0 ? { xTitle } : {},
+    provider: normalizedModel.provider || "openrouter"
+  };
+}
+function buildOpenRouterEmbeddingMetadata(metadata, httpReferer, xTitle) {
+  const normalized = buildOpenRouterMetadata(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 extractOpenRouterCallModelMetadata(request) {
+  if (!isObject(request)) {
+    return { provider: "openrouter" };
+  }
+  const { input: _input, ...metadata } = request;
+  return buildOpenRouterMetadata(metadata, 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;
+}
+
+// src/openrouter-tool-wrapping.ts
+var OPENROUTER_WRAPPED_TOOL = Symbol("braintrust.openrouter.wrappedTool");
+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 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 patchOpenRouterCallModelResult(span, result, request) {
+  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 = (error2) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    span.log({
+      error: normalizeError(error2).message
+    });
+    span.end();
+  };
+  const finalizeFromResponse = async (fallbackOutput) => {
+    if (!originalGetResponse) {
+      await endSpanWithResult(void 0, fallbackOutput);
+      return;
+    }
+    try {
+      await endSpanWithResult(await originalGetResponse(), fallbackOutput);
+    } catch {
+      await endSpanWithResult(void 0, fallbackOutput);
+    }
+  };
+  if (originalGetResponse) {
+    resultLike.getResponse = async (...args) => {
+      return await withCurrent(span, async () => {
+        try {
+          const response = await originalGetResponse(...args);
+          await endSpanWithResult(response);
+          return response;
+        } catch (error2) {
+          endSpanWithError(error2);
+          throw error2;
+        }
+      });
+    };
+  }
+  if (typeof resultLike.getText === "function") {
+    const originalGetText = resultLike.getText.bind(resultLike);
+    resultLike.getText = async (...args) => {
+      return await withCurrent(span, async () => {
+        try {
+          const text = await originalGetText(...args);
+          await finalizeFromResponse(text);
+          return text;
+        } catch (error2) {
+          endSpanWithError(error2);
+          throw error2;
+        }
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_CONTEXT_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
+      continue;
+    }
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = async (...args) => {
+      return await withCurrent(span, async () => {
+        return await originalMethod.apply(resultLike, args);
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_STREAM_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
+      continue;
+    }
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = (...args) => {
+      const stream = withCurrent(
+        span,
+        () => originalMethod.apply(resultLike, args)
+      );
+      if (!isAsyncIterable4(stream)) {
+        return stream;
+      }
+      return wrapAsyncIterableWithSpan({
+        finalize: finalizeFromResponse,
+        iteratorFactory: () => stream[Symbol.asyncIterator](),
+        onError: endSpanWithError,
+        span
+      });
+    };
+  }
+  if (originalGetInitialResponse) {
+    let initialTurnTraced = false;
+    resultLike.getInitialResponse = async (...args) => {
+      if (initialTurnTraced) {
+        return await withCurrent(span, async () => {
+          return await originalGetInitialResponse(...args);
+        });
+      }
+      initialTurnTraced = true;
+      const resolvedRequest = getOpenRouterResolvedRequest(resultLike, request);
+      const childSpan = startOpenRouterCallModelTurnSpan({
+        request: resolvedRequest,
+        step: tracedTurnCount + 1,
+        stepType: tracedTurnCount === 0 ? "initial" : "continue"
+      });
+      return await withCurrent(childSpan, async () => {
+        try {
+          const response = await originalGetInitialResponse(...args);
+          tracedTurnCount++;
+          finishOpenRouterCallModelTurnSpan({
+            response,
+            step: tracedTurnCount,
+            stepType: tracedTurnCount === 1 ? "initial" : "continue",
+            span: childSpan
+          });
+          return response;
+        } catch (error2) {
+          childSpan.log({
+            error: normalizeError(error2).message
+          });
+          childSpan.end();
+          throw error2;
+        }
+      });
+    };
+  }
+  if (originalMakeFollowupRequest) {
+    resultLike.makeFollowupRequest = async (...args) => {
+      const currentResponse = args[0];
+      const toolResults = Array.isArray(args[1]) ? args[1] : [];
+      const resolvedRequest = getOpenRouterResolvedRequest(resultLike, request);
+      const followupRequest = buildOpenRouterFollowupRequest(
+        resolvedRequest,
+        currentResponse,
+        toolResults
+      );
+      const childSpan = startOpenRouterCallModelTurnSpan({
+        request: followupRequest,
+        step: tracedTurnCount + 1,
+        stepType: "continue"
+      });
+      return await withCurrent(childSpan, async () => {
+        try {
+          const response = await originalMakeFollowupRequest(...args);
+          tracedTurnCount++;
+          finishOpenRouterCallModelTurnSpan({
+            response,
+            step: tracedTurnCount,
+            stepType: "continue",
+            span: childSpan
+          });
+          return response;
+        } catch (error2) {
+          childSpan.log({
+            error: normalizeError(error2).message
+          });
+          childSpan.end();
+          throw error2;
+        }
+      });
+    };
+  }
+  return true;
+}
+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 isWrappedCallModelResult(value) {
+  return Boolean(
+    isObject(value) && value[OPENROUTER_WRAPPED_CALL_MODEL_RESULT]
+  );
+}
+function traceToolExecution(args) {
+  const tracingChannel2 = openRouterChannels.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 (error2) {
+    event.error = normalizeError(error2);
+    tracingChannel2.error.publish(event);
+    throw error2;
+  }
+}
+function publishToolResult(tracingChannel2, event, result) {
+  if (isPromiseLike(result)) {
+    return result.then(
+      (resolved) => {
+        event.result = resolved;
+        tracingChannel2.asyncEnd.publish(event);
+        return resolved;
+      },
+      (error2) => {
+        event.error = normalizeError(error2);
+        tracingChannel2.error.publish(event);
+        throw error2;
+      }
+    );
+  }
+  event.result = result;
+  tracingChannel2.asyncEnd.publish(event);
+  return result;
+}
+function getToolCallId(context2) {
+  const toolContext = context2;
+  return typeof toolContext?.toolCall?.id === "string" ? toolContext.toolCall.id : void 0;
+}
+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 startOpenRouterCallModelTurnSpan(args) {
+  const requestRecord = isObject(args.request) ? args.request : void 0;
+  const metadata = requestRecord ? extractOpenRouterCallModelMetadata(requestRecord) : { provider: "openrouter" };
+  if (isObject(metadata) && "tools" in metadata) {
+    delete metadata.tools;
+  }
+  return startSpan({
+    name: "openrouter.beta.responses.send",
+    spanAttributes: {
+      type: "llm" /* LLM */
+    },
+    event: {
+      input: requestRecord ? extractOpenRouterCallModelInput(requestRecord) : void 0,
+      metadata: {
+        ...metadata,
+        step: args.step,
+        step_type: args.stepType
+      }
+    }
+  });
+}
+function finishOpenRouterCallModelTurnSpan(args) {
+  if (!isObject(args.response)) {
+    args.span.end();
+    return;
+  }
+  args.span.log({
+    output: extractOpenRouterResponseOutput(args.response),
+    ...extractOpenRouterResponseMetadata(args.response) ? {
+      metadata: {
+        ...extractOpenRouterResponseMetadata(args.response),
+        ...args.step !== void 0 ? { step: args.step } : {},
+        ...args.stepType ? { step_type: args.stepType } : {}
+      }
+    } : {},
+    metrics: parseOpenRouterMetricsFromUsage(args.response.usage)
+  });
+  args.span.end();
+}
+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;
+            },
+            (error2) => {
+              args.onError(error2);
+              throw error2;
+            }
+          );
+        },
+        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;
+            },
+            (error2) => {
+              args.onError(error2);
+              throw error2;
+            }
+          );
+        },
+        throw(error2) {
+          args.onError(error2);
+          if (typeof iterator.throw !== "function") {
+            return Promise.reject(error2);
+          }
+          return withCurrent(args.span, () => iterator.throw(error2));
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    }
+  };
+}
+function isAsyncIterable4(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function isPromiseLike(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+function normalizeError(error2) {
+  return error2 instanceof Error ? error2 : new Error(String(error2));
+}
+
+// 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(request?.chatGenerationParams) ? request.chatGenerationParams : {};
+          const httpReferer = request?.httpReferer;
+          const xTitle = request?.xTitle;
+          const { messages, ...metadata } = chatGenerationParams;
+          return {
+            input: messages,
+            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+          };
+        },
+        extractOutput: (result) => {
+          return isObject(result) ? result.choices : void 0;
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = parseOpenRouterMetricsFromUsage(result?.usage);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateOpenRouterChatChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(openRouterChannels.embeddingsGenerate, {
+        name: "openrouter.embeddings.generate",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const requestBody = isObject(request?.requestBody) ? request.requestBody : {};
+          const httpReferer = request?.httpReferer;
+          const xTitle = request?.xTitle;
+          const { input, ...metadata } = requestBody;
+          return {
+            input,
+            metadata: buildOpenRouterEmbeddingMetadata(
+              metadata,
+              httpReferer,
+              xTitle
+            )
+          };
+        },
+        extractOutput: (result) => {
+          if (!isObject(result)) {
+            return void 0;
+          }
+          const embedding = result.data?.[0]?.embedding;
+          return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
+        },
+        extractMetadata: (result) => {
+          if (!isObject(result)) {
+            return void 0;
+          }
+          return extractOpenRouterResponseMetadata(result);
+        },
+        extractMetrics: (result) => {
+          return isObject(result) ? parseOpenRouterMetricsFromUsage(result.usage) : {};
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.betaResponsesSend, {
+        name: "openrouter.beta.responses.send",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const openResponsesRequest = isObject(request?.openResponsesRequest) ? request.openResponsesRequest : {};
+          const httpReferer = request?.httpReferer;
+          const xTitle = request?.xTitle;
+          const { input, ...metadata } = openResponsesRequest;
+          return {
+            input,
+            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+          };
+        },
+        extractOutput: (result) => extractOpenRouterResponseOutput(result),
+        extractMetadata: (result) => extractOpenRouterResponseMetadata(result),
+        extractMetrics: (result, startTime) => {
+          const metrics = parseOpenRouterMetricsFromUsage(result?.usage);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateOpenRouterResponseStreamEvents
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(openRouterChannels.callModel, {
+        name: "openrouter.callModel",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterCallModelRequestArg(args);
+          return {
+            input: request ? extractOpenRouterCallModelInput(request) : void 0,
+            metadata: request ? extractOpenRouterCallModelMetadata(request) : { provider: "openrouter" }
+          };
+        },
+        patchResult: ({ endEvent, result, span }) => {
+          return patchOpenRouterCallModelResult(
+            span,
+            result,
+            getOpenRouterCallModelRequestArg(endEvent.arguments)
+          );
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.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 = openRouterChannels.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 (isArrayLike2(args)) {
+    return Array.from(args);
+  }
+  return [args];
+}
+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 keyedCandidate = normalizedArgs.find(
+    (arg) => isObject(arg) && ("chatGenerationParams" in arg || "requestBody" in arg || "openResponsesRequest" in arg)
+  );
+  if (isObject(keyedCandidate)) {
+    return keyedCandidate;
+  }
+  const firstObjectArg = normalizedArgs.find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function getOpenRouterCallModelRequestArg(args) {
+  const firstObjectArg = normalizeArgs(args).find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function aggregateOpenRouterChatChunks(chunks) {
+  let role;
+  let content = "";
+  let toolCalls;
+  let finishReason;
+  let metrics = {};
+  for (const chunk of chunks) {
+    metrics = {
+      ...metrics,
+      ...parseOpenRouterMetricsFromUsage(chunk?.usage)
+    };
+    const choice = chunk?.choices?.[0];
+    const delta = choice?.delta;
+    if (!delta) {
+      if (choice?.finish_reason !== void 0) {
+        finishReason = choice.finish_reason;
+      }
+      continue;
+    }
+    if (!role && delta.role) {
+      role = delta.role;
+    }
+    if (typeof delta.content === "string") {
+      content += delta.content;
+    }
+    const choiceFinishReason = choice?.finishReason ?? choice?.finish_reason ?? void 0;
+    const deltaFinishReason = delta.finishReason ?? delta.finish_reason ?? void 0;
+    if (choiceFinishReason !== void 0) {
+      finishReason = choiceFinishReason;
+    } else if (deltaFinishReason !== void 0) {
+      finishReason = deltaFinishReason;
+    }
+    const toolCallDeltas = Array.isArray(delta.toolCalls) ? delta.toolCalls : Array.isArray(delta.tool_calls) ? delta.tool_calls : void 0;
+    if (!toolCallDeltas) {
+      continue;
+    }
+    for (const toolDelta of toolCallDeltas) {
+      if (!toolDelta?.function) {
+        continue;
+      }
+      const toolIndex = toolDelta.index ?? 0;
+      const existingToolCall = toolCalls?.[toolIndex];
+      if (!existingToolCall || toolDelta.id && existingToolCall.id !== void 0 && existingToolCall.id !== toolDelta.id) {
+        const nextToolCalls = [...toolCalls || []];
+        nextToolCalls[toolIndex] = {
+          index: toolIndex,
+          id: toolDelta.id,
+          type: toolDelta.type,
+          function: {
+            name: toolDelta.function.name,
+            arguments: toolDelta.function.arguments || ""
+          }
+        };
+        toolCalls = nextToolCalls;
+        continue;
+      }
+      const current = existingToolCall;
+      if (toolDelta.id && !current.id) {
+        current.id = toolDelta.id;
+      }
+      if (toolDelta.type && !current.type) {
+        current.type = toolDelta.type;
+      }
+      if (toolDelta.function.name && !current.function.name) {
+        current.function.name = toolDelta.function.name;
+      }
+      current.function.arguments += toolDelta.function.arguments || "";
+    }
+  }
+  return {
+    output: [
+      {
+        index: 0,
+        message: {
+          role,
+          content: content || void 0,
+          ...toolCalls ? { tool_calls: toolCalls } : {}
+        },
+        logprobs: null,
+        finish_reason: finishReason
+      }
+    ],
+    metrics
+  };
+}
+function aggregateOpenRouterResponseStreamEvents(chunks) {
+  let finalResponse;
+  for (const chunk of chunks) {
+    const response = chunk?.response;
+    if (!response) {
+      continue;
+    }
+    if (chunk.type === "response.completed" || chunk.type === "response.incomplete" || chunk.type === "response.failed") {
+      finalResponse = response;
+    }
+  }
+  if (!finalResponse) {
+    return {
+      output: void 0,
+      metrics: {}
+    };
+  }
+  return {
+    output: extractOpenRouterResponseOutput(finalResponse),
+    metrics: parseOpenRouterMetricsFromUsage(finalResponse.usage),
+    ...extractOpenRouterResponseMetadata(finalResponse) ? { metadata: extractOpenRouterResponseMetadata(finalResponse) } : {}
+  };
+}
+
+// src/instrumentation/braintrust-plugin.ts
+var BraintrustPlugin = class extends BasePlugin {
+  config;
+  openaiPlugin = null;
+  anthropicPlugin = null;
+  aiSDKPlugin = null;
+  claudeAgentSDKPlugin = null;
+  googleGenAIPlugin = null;
+  openRouterPlugin = null;
+  constructor(config3 = {}) {
+    super();
+    this.config = config3;
+  }
+  onEnable() {
+    const integrations = this.config.integrations || {};
+    if (integrations.openai !== false) {
+      this.openaiPlugin = new OpenAIPlugin();
+      this.openaiPlugin.enable();
+    }
+    if (integrations.anthropic !== false) {
+      this.anthropicPlugin = new AnthropicPlugin();
+      this.anthropicPlugin.enable();
+    }
+    if (integrations.aisdk !== false && integrations.vercel !== false) {
+      this.aiSDKPlugin = new AISDKPlugin();
+      this.aiSDKPlugin.enable();
+    }
+    if (integrations.claudeAgentSDK !== false) {
+      this.claudeAgentSDKPlugin = new ClaudeAgentSDKPlugin();
+      this.claudeAgentSDKPlugin.enable();
+    }
+    if (integrations.googleGenAI !== false && integrations.google !== false) {
+      this.googleGenAIPlugin = new GoogleGenAIPlugin();
+      this.googleGenAIPlugin.enable();
+    }
+    if (integrations.openrouter !== false) {
+      this.openRouterPlugin = new OpenRouterPlugin();
+      this.openRouterPlugin.enable();
+    }
+  }
+  onDisable() {
+    if (this.openaiPlugin) {
+      this.openaiPlugin.disable();
+      this.openaiPlugin = null;
+    }
+    if (this.anthropicPlugin) {
+      this.anthropicPlugin.disable();
+      this.anthropicPlugin = null;
+    }
+    if (this.aiSDKPlugin) {
+      this.aiSDKPlugin.disable();
+      this.aiSDKPlugin = null;
+    }
     if (this.claudeAgentSDKPlugin) {
       this.claudeAgentSDKPlugin.disable();
       this.claudeAgentSDKPlugin = null;
@@ -16269,6 +18108,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.googleGenAIPlugin.disable();
       this.googleGenAIPlugin = null;
     }
+    if (this.openRouterPlugin) {
+      this.openRouterPlugin.disable();
+      this.openRouterPlugin = null;
+    }
   }
 };
 
@@ -16340,7 +18183,8 @@ var PluginRegistry = class {
       vercel: true,
       aisdk: true,
       google: true,
-      claudeAgentSDK: true
+      claudeAgentSDK: true,
+      openrouter: true
     };
   }
   /**
@@ -16370,6 +18214,7 @@ function configureNode() {
   isomorph_default.getCallerLocation = getCallerLocation;
   isomorph_default.newAsyncLocalStorage = () => new import_node_async_hooks.AsyncLocalStorage();
   isomorph_default.newTracingChannel = (nameOrChannels) => diagnostics_channel.tracingChannel(nameOrChannels);
+  patchTracingChannel(diagnostics_channel.tracingChannel);
   isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };