braintrust 3.4.0 → 3.6.0

package/dist/instrumentation/index.js

@@ -52,8 +52,54 @@ var DefaultAsyncLocalStorage = class {
     return void 0;
   }
 };
-var DefaultTracingChannel = class {
+var DefaultChannel = class {
+  constructor(name) {
+    this.name = name;
+  }
   hasSubscribers = false;
+  subscribe(_subscription) {
+  }
+  unsubscribe(_subscription) {
+    return false;
+  }
+  bindStore(_store, _transform) {
+  }
+  unbindStore(_store) {
+    return false;
+  }
+  publish(_message) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runStores(_message, fn, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+};
+var DefaultTracingChannel = class {
+  start;
+  end;
+  asyncStart;
+  asyncEnd;
+  error;
+  constructor(nameOrChannels) {
+    if (typeof nameOrChannels === "string") {
+      this.start = new DefaultChannel(`tracing:${nameOrChannels}:start`);
+      this.end = new DefaultChannel(`tracing:${nameOrChannels}:end`);
+      this.asyncStart = new DefaultChannel(
+        `tracing:${nameOrChannels}:asyncStart`
+      );
+      this.asyncEnd = new DefaultChannel(`tracing:${nameOrChannels}:asyncEnd`);
+      this.error = new DefaultChannel(`tracing:${nameOrChannels}:error`);
+      return;
+    }
+    this.start = nameOrChannels.start ?? new DefaultChannel("tracing:start");
+    this.end = nameOrChannels.end ?? new DefaultChannel("tracing:end");
+    this.asyncStart = nameOrChannels.asyncStart ?? new DefaultChannel("tracing:asyncStart");
+    this.asyncEnd = nameOrChannels.asyncEnd ?? new DefaultChannel("tracing:asyncEnd");
+    this.error = nameOrChannels.error ?? new DefaultChannel("tracing:error");
+  }
+  get hasSubscribers() {
+    return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
+  }
   subscribe(_handlers) {
   }
   unsubscribe(_handlers) {
@@ -81,7 +127,7 @@ var iso = {
   getCallerLocation: () => void 0,
   newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  newTracingChannel: (_nameOrChannels) => new DefaultTracingChannel(),
+  newTracingChannel: (nameOrChannels) => new DefaultTracingChannel(nameOrChannels),
   processOn: (_0, _1) => {
   },
   basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
@@ -2115,6 +2161,8 @@ var Experiment = import_v36.z.object({
   deleted_at: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   dataset_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   dataset_version: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  parameters_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  parameters_version: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   public: import_v36.z.boolean(),
   user_id: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   metadata: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
@@ -2137,7 +2185,11 @@ var SpanType = import_v36.z.union([
   import_v36.z.null()
 ]);
 var SpanAttributes = import_v36.z.union([
-  import_v36.z.object({ name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]), type: SpanType }).partial().passthrough(),
+  import_v36.z.object({
+    name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
+    type: SpanType,
+    purpose: import_v36.z.union([import_v36.z.literal("scorer"), import_v36.z.null()])
+  }).partial().passthrough(),
   import_v36.z.null()
 ]);
 var ExperimentEvent = import_v36.z.object({
@@ -2577,6 +2629,7 @@ var FunctionId = import_v36.z.union([
       version: import_v36.z.string()
     }),
     code: import_v36.z.string(),
+    function_type: FunctionTypeEnum.and(import_v36.z.unknown()).optional(),
     name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
   }),
   import_v36.z.object({
@@ -2806,7 +2859,12 @@ var TopicAutomationConfig = import_v36.z.object({
   topic_map_functions: import_v36.z.array(TopicMapFunctionAutomation),
   scope: import_v36.z.union([SpanScope, TraceScope, GroupScope, import_v36.z.null()]).optional(),
   data_scope: TopicAutomationDataScope.optional(),
-  btql_filter: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
+  btql_filter: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  backfill_time_range: import_v36.z.union([
+    import_v36.z.string(),
+    import_v36.z.object({ from: import_v36.z.string(), to: import_v36.z.string() }),
+    import_v36.z.null()
+  ]).optional()
 });
 var ProjectAutomation = import_v36.z.object({
   id: import_v36.z.string().uuid(),
@@ -4199,6 +4257,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(),
@@ -4215,6 +4276,12 @@ var parametersRowSchema = import_v38.z.object({
   }),
   metadata: import_v38.z.union([import_v38.z.object({}).partial().passthrough(), import_v38.z.null()]).optional()
 });
+var InlineAttachmentReferenceSchema = import_v38.z.object({
+  type: import_v38.z.literal("inline_attachment"),
+  src: import_v38.z.string().min(1),
+  content_type: import_v38.z.string().optional(),
+  filename: import_v38.z.string().optional()
+});
 var LoginInvalidOrgError = class extends Error {
   constructor(message) {
     super(message);
@@ -4255,13 +4322,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();
@@ -4468,6 +4540,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();
@@ -8017,7 +8092,11 @@ function startSpanForEvent(config, event, channelName) {
   });
   const startTime = getCurrentUnixTimestamp();
   try {
-    const { input, metadata } = config.extractInput(event.arguments);
+    const { input, metadata } = config.extractInput(
+      event.arguments,
+      event,
+      span
+    );
     span.log({
       input,
       metadata: mergeInputMetadata(metadata, spanInfoMetadata)
@@ -8027,6 +8106,36 @@ function startSpanForEvent(config, event, channelName) {
   }
   return { span, startTime };
 }
+function ensureSpanStateForEvent(states, config, event, channelName) {
+  const key = event;
+  const existing = states.get(key);
+  if (existing) {
+    return existing;
+  }
+  const created = startSpanForEvent(config, event, channelName);
+  states.set(key, created);
+  return created;
+}
+function bindCurrentSpanStoreToStart(tracingChannel, states, config, channelName) {
+  const state = _internalGetGlobalState();
+  const startChannel = tracingChannel.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,
+      config,
+      event,
+      channelName
+    ).span
+  );
+  return () => {
+    startChannel.unbindStore(currentSpanStore);
+  };
+}
 function logErrorAndEnd(states, event) {
   const spanData = states.get(event);
   if (!spanData) {
@@ -8042,15 +8151,19 @@ function traceAsyncChannel(channel2, config) {
   const tracingChannel = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     asyncEnd: (event) => {
@@ -8092,6 +8205,7 @@ function traceAsyncChannel(channel2, config) {
   };
   tracingChannel.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel.unsubscribe(handlers);
   };
 }
@@ -8099,15 +8213,19 @@ function traceStreamingChannel(channel2, config) {
   const tracingChannel = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     asyncEnd: (event) => {
@@ -8181,6 +8299,16 @@ function traceStreamingChannel(channel2, config) {
         });
         return;
       }
+      if (config.patchResult?.({
+        channelName,
+        endEvent: asyncEndEvent,
+        result: asyncEndEvent.result,
+        span,
+        startTime
+      })) {
+        states.delete(event);
+        return;
+      }
       try {
         const output = config.extractOutput(
           asyncEndEvent.result,
@@ -8213,6 +8341,7 @@ function traceStreamingChannel(channel2, config) {
   };
   tracingChannel.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel.unsubscribe(handlers);
   };
 }
@@ -8220,15 +8349,19 @@ function traceSyncStreamChannel(channel2, config) {
   const tracingChannel = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
   const channelName = channel2.channelName;
+  const unbindCurrentSpanStore = bindCurrentSpanStoreToStart(
+    tracingChannel,
+    states,
+    config,
+    channelName
+  );
   const handlers = {
     start: (event) => {
-      states.set(
+      ensureSpanStateForEvent(
+        states,
+        config,
         event,
-        startSpanForEvent(
-          config,
-          event,
-          channelName
-        )
+        channelName
       );
     },
     end: (event) => {
@@ -8237,8 +8370,17 @@ function traceSyncStreamChannel(channel2, config) {
         return;
       }
       const { span, startTime } = spanData;
-      const resultEvent = event;
-      const stream = resultEvent.result;
+      const endEvent = event;
+      if (config.patchResult?.({
+        channelName,
+        endEvent,
+        result: endEvent.result,
+        span,
+        startTime
+      })) {
+        return;
+      }
+      const stream = endEvent.result;
       if (!isSyncStreamLike(stream)) {
         span.end();
         states.delete(event);
@@ -8308,6 +8450,7 @@ function traceSyncStreamChannel(channel2, config) {
   };
   tracingChannel.subscribe(handlers);
   return () => {
+    unbindCurrentSpanStore?.();
     tracingChannel.unsubscribe(handlers);
   };
 }
@@ -9209,6 +9352,108 @@ function filterFrom(obj, fieldsToRemove) {
   return result;
 }
 
+// src/wrappers/ai-sdk/normalize-logged-output.ts
+var REMOVE_NORMALIZED_VALUE = Symbol("braintrust.ai-sdk.remove-normalized");
+function normalizeAISDKLoggedOutput(value) {
+  const normalized = normalizeAISDKLoggedValue(value);
+  return normalized === REMOVE_NORMALIZED_VALUE ? {} : normalized;
+}
+function normalizeAISDKLoggedValue(value, context = {}) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeAISDKLoggedValue(entry, context)).filter((entry) => entry !== REMOVE_NORMALIZED_VALUE);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const nextInProviderMetadata = context.inProviderMetadata || context.parentKey === "providerMetadata" || context.parentKey === "experimental_providerMetadata";
+  const normalizedEntries = [];
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "cachedPromptTokens" && entry === 0) {
+      continue;
+    }
+    if (context.parentKey === "request" && key === "body" && entry === "<omitted>") {
+      continue;
+    }
+    const normalizedEntry = normalizeAISDKLoggedValue(entry, {
+      inProviderMetadata: nextInProviderMetadata,
+      parentKey: key
+    });
+    if (normalizedEntry === REMOVE_NORMALIZED_VALUE) {
+      continue;
+    }
+    normalizedEntries.push([key, normalizedEntry]);
+  }
+  if (normalizedEntries.length === 0) {
+    if (context.parentKey === "request" || nextInProviderMetadata) {
+      return REMOVE_NORMALIZED_VALUE;
+    }
+    return {};
+  }
+  return Object.fromEntries(normalizedEntries);
+}
+
+// src/zod/utils.ts
+var import_zod_to_json_schema = require("zod-to-json-schema");
+var z42 = __toESM(require("zod/v4"));
+function isZodV4(zodObject) {
+  return typeof zodObject === "object" && zodObject !== null && "_zod" in zodObject && zodObject._zod !== void 0;
+}
+function zodToJsonSchema(schema) {
+  if (isZodV4(schema)) {
+    return z42.toJSONSchema(schema, {
+      target: "draft-7"
+    });
+  }
+  return (0, import_zod_to_json_schema.zodToJsonSchema)(schema);
+}
+
+// src/wrappers/ai-sdk/tool-serialization.ts
+function isZodSchema(value) {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function serializeZodSchema(schema) {
+  try {
+    return zodToJsonSchema(schema);
+  } catch {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
+  }
+}
+function serializeTool(tool) {
+  if (!tool || typeof tool !== "object") {
+    return tool;
+  }
+  const serialized = { ...tool };
+  if (isZodSchema(serialized.inputSchema)) {
+    serialized.inputSchema = serializeZodSchema(serialized.inputSchema);
+  }
+  if (isZodSchema(serialized.parameters)) {
+    serialized.parameters = serializeZodSchema(serialized.parameters);
+  }
+  if ("execute" in serialized) {
+    delete serialized.execute;
+  }
+  if ("render" in serialized) {
+    delete serialized.render;
+  }
+  return serialized;
+}
+function serializeAISDKToolsForLogging(tools) {
+  if (!tools || typeof tools !== "object") {
+    return tools;
+  }
+  if (Array.isArray(tools)) {
+    return tools.map(serializeTool);
+  }
+  const serialized = {};
+  for (const [key, tool] of Object.entries(tools)) {
+    serialized[key] = serializeTool(tool);
+  }
+  return serialized;
+}
+
 // src/instrumentation/plugins/ai-sdk-channels.ts
 var aiSDKChannels = defineChannels("ai", {
   generateText: channel({
@@ -9219,6 +9464,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "streamText",
     kind: "async"
   }),
+  streamTextSync: channel({
+    channelName: "streamText.sync",
+    kind: "sync-stream"
+  }),
   generateObject: channel({
     channelName: "generateObject",
     kind: "async"
@@ -9227,6 +9476,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "streamObject",
     kind: "async"
   }),
+  streamObjectSync: channel({
+    channelName: "streamObject.sync",
+    kind: "sync-stream"
+  }),
   agentGenerate: channel({
     channelName: "Agent.generate",
     kind: "async"
@@ -9234,6 +9487,14 @@ var aiSDKChannels = defineChannels("ai", {
   agentStream: channel({
     channelName: "Agent.stream",
     kind: "async"
+  }),
+  toolLoopAgentGenerate: channel({
+    channelName: "ToolLoopAgent.generate",
+    kind: "async"
+  }),
+  toolLoopAgentStream: channel({
+    channelName: "ToolLoopAgent.stream",
+    kind: "async"
   })
 });
 
@@ -9252,6 +9513,8 @@ var DEFAULT_DENY_OUTPUT_PATHS = [
   "steps[].response.body",
   "steps[].response.headers"
 ];
+var AUTO_PATCHED_MODEL = Symbol.for("braintrust.ai-sdk.auto-patched-model");
+var AUTO_PATCHED_TOOL = Symbol.for("braintrust.ai-sdk.auto-patched-tool");
 var AISDKPlugin = class extends BasePlugin {
   config;
   constructor(config = {}) {
@@ -9270,22 +9533,12 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.generateText, {
         name: "generateText",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(result, denyOutputPaths);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
       })
     );
@@ -9293,45 +9546,43 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.streamText, {
         name: "streamText",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
-          return processAISDKOutput(result, denyOutputPaths);
-        },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
-        aggregateChunks: aggregateAISDKChunks
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.streamTextSync, {
+        name: "streamText",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
       })
     );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.generateObject, {
         name: "generateObject",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(result, denyOutputPaths);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
       })
     );
@@ -9339,45 +9590,43 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.streamObject, {
         name: "streamObject",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
-          return processAISDKOutput(result, denyOutputPaths);
-        },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
-        aggregateChunks: aggregateAISDKChunks
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.streamObjectSync, {
+        name: "streamObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
       })
     );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.agentGenerate, {
         name: "Agent.generate",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(result, denyOutputPaths);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
       })
     );
@@ -9385,88 +9634,506 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.agentStream, {
         name: "Agent.stream",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          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),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(result, denyOutputPaths);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
       })
     );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.toolLoopAgentStream, {
+        name: "ToolLoopAgent.stream",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
   }
 };
 function processAISDKInput(params) {
   if (!params) return params;
-  return processInputAttachments(params);
+  const input = processInputAttachments(params);
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return input;
+  }
+  const { tools: _tools, ...rest } = input;
+  return rest;
+}
+function prepareAISDKInput(params, event, span, denyOutputPaths) {
+  const input = processAISDKInput(params);
+  const metadata = extractMetadataFromParams(params, event.self);
+  const childTracing = prepareAISDKChildTracing(
+    params,
+    event.self,
+    span,
+    denyOutputPaths
+  );
+  event.__braintrust_ai_sdk_model_wrapped = childTracing.modelWrapped;
+  if (childTracing.cleanup) {
+    event.__braintrust_ai_sdk_cleanup = childTracing.cleanup;
+  }
+  return {
+    input,
+    metadata
+  };
+}
+function extractTopLevelAISDKMetrics(result, event, startTime) {
+  const metrics = hasModelChildTracing(event) ? {} : extractTokenMetrics(result);
+  if (startTime) {
+    metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+  }
+  return metrics;
+}
+function hasModelChildTracing(event) {
+  return event?.__braintrust_ai_sdk_model_wrapped === true;
 }
-function extractMetadataFromParams(params) {
+function extractMetadataFromParams(params, self) {
   const metadata = {
     braintrust: {
       integration_name: "ai-sdk",
       sdk_language: "typescript"
     }
   };
-  const { model, provider } = serializeModelWithProvider(params.model);
+  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && self.settings?.model ? self.settings?.model : void 0;
+  const { model, provider } = serializeModelWithProvider(
+    params.model ?? agentModel
+  );
   if (model) {
     metadata.model = model;
   }
   if (provider) {
     metadata.provider = provider;
   }
+  const tools = serializeAISDKToolsForLogging(params.tools);
+  if (tools) {
+    metadata.tools = tools;
+  }
   return metadata;
 }
-function processAISDKOutput(output, denyOutputPaths) {
-  if (!output) return output;
-  const getterValues = extractGetterValues(output);
-  const merged = { ...output, ...getterValues };
-  return omit(merged, denyOutputPaths);
-}
-function extractTokenMetrics(result) {
-  const metrics = {};
-  let usage = result?.totalUsage || result?.usage;
-  if (!usage && result) {
-    try {
-      if ("totalUsage" in result && typeof result.totalUsage !== "function") {
-        usage = result.totalUsage;
-      } else if ("usage" in result && typeof result.usage !== "function") {
-        usage = result.usage;
-      }
-    } catch {
+function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
+  const cleanup = [];
+  const patchedModels = /* @__PURE__ */ new WeakSet();
+  const patchedTools = /* @__PURE__ */ new WeakSet();
+  let modelWrapped = false;
+  const patchModel = (model) => {
+    const resolvedModel = resolveAISDKModel(model);
+    if (!resolvedModel || typeof resolvedModel !== "object" || typeof resolvedModel.doGenerate !== "function" || patchedModels.has(resolvedModel) || resolvedModel[AUTO_PATCHED_MODEL]) {
+      return;
     }
-  }
-  if (!usage) {
-    return metrics;
-  }
-  const promptTokens = firstNumber(
-    usage.inputTokens?.total,
-    usage.inputTokens,
-    usage.promptTokens,
-    usage.prompt_tokens
-  );
-  if (promptTokens !== void 0) {
-    metrics.prompt_tokens = promptTokens;
-  }
-  const completionTokens = firstNumber(
-    usage.outputTokens?.total,
-    usage.outputTokens,
-    usage.completionTokens,
-    usage.completion_tokens
-  );
-  if (completionTokens !== void 0) {
-    metrics.completion_tokens = completionTokens;
-  }
-  const totalTokens = firstNumber(
+    patchedModels.add(resolvedModel);
+    resolvedModel[AUTO_PATCHED_MODEL] = true;
+    modelWrapped = true;
+    const originalDoGenerate = resolvedModel.doGenerate;
+    const originalDoStream = resolvedModel.doStream;
+    const baseMetadata = buildAISDKChildMetadata(resolvedModel);
+    resolvedModel.doGenerate = async function doGeneratePatched(options) {
+      return parentSpan.traced(
+        async (span) => {
+          const result = await Reflect.apply(
+            originalDoGenerate,
+            resolvedModel,
+            [options]
+          );
+          span.log({
+            output: processAISDKOutput(result, denyOutputPaths),
+            metrics: extractTokenMetrics(result),
+            ...buildResolvedMetadataPayload(result)
+          });
+          return result;
+        },
+        {
+          name: "doGenerate",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: {
+            input: processAISDKInput(options),
+            metadata: baseMetadata
+          }
+        }
+      );
+    };
+    if (originalDoStream) {
+      resolvedModel.doStream = async function doStreamPatched(options) {
+        const span = parentSpan.startSpan({
+          name: "doStream",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: {
+            input: processAISDKInput(options),
+            metadata: baseMetadata
+          }
+        });
+        const result = await withCurrent(
+          span,
+          () => Reflect.apply(originalDoStream, resolvedModel, [options])
+        );
+        const output = {};
+        let text = "";
+        let reasoning = "";
+        const toolCalls = [];
+        let object = void 0;
+        const transformStream = new TransformStream({
+          transform(chunk, controller) {
+            switch (chunk.type) {
+              case "text-delta":
+                text += extractTextDelta(chunk);
+                break;
+              case "reasoning-delta":
+                if (chunk.delta) {
+                  reasoning += chunk.delta;
+                } else if (chunk.text) {
+                  reasoning += chunk.text;
+                }
+                break;
+              case "tool-call":
+                toolCalls.push(chunk);
+                break;
+              case "object":
+                object = chunk.object;
+                break;
+              case "raw":
+                if (chunk.rawValue) {
+                  const rawVal = chunk.rawValue;
+                  if (rawVal.delta?.content) {
+                    text += rawVal.delta.content;
+                  } else if (rawVal.choices?.[0]?.delta?.content) {
+                    text += rawVal.choices[0].delta.content;
+                  } else if (typeof rawVal.text === "string") {
+                    text += rawVal.text;
+                  } else if (typeof rawVal.content === "string") {
+                    text += rawVal.content;
+                  }
+                }
+                break;
+              case "finish":
+                output.text = text;
+                output.reasoning = reasoning;
+                output.toolCalls = toolCalls;
+                output.finishReason = chunk.finishReason;
+                output.usage = chunk.usage;
+                if (object !== void 0) {
+                  output.object = object;
+                }
+                span.log({
+                  output: processAISDKOutput(
+                    output,
+                    denyOutputPaths
+                  ),
+                  metrics: extractTokenMetrics(output),
+                  ...buildResolvedMetadataPayload(output)
+                });
+                span.end();
+                break;
+            }
+            controller.enqueue(chunk);
+          }
+        });
+        return {
+          ...result,
+          stream: result.stream.pipeThrough(transformStream)
+        };
+      };
+    }
+    cleanup.push(() => {
+      resolvedModel.doGenerate = originalDoGenerate;
+      if (originalDoStream) {
+        resolvedModel.doStream = originalDoStream;
+      }
+      delete resolvedModel[AUTO_PATCHED_MODEL];
+    });
+  };
+  const patchTool = (tool, name) => {
+    if (tool == null || typeof tool !== "object" || !("execute" in tool) || typeof tool.execute !== "function" || patchedTools.has(tool) || tool[AUTO_PATCHED_TOOL]) {
+      return;
+    }
+    patchedTools.add(tool);
+    tool[AUTO_PATCHED_TOOL] = true;
+    const originalExecute = tool.execute;
+    tool.execute = function executePatched(...args) {
+      const result = Reflect.apply(originalExecute, this, args);
+      if (isAsyncGenerator(result)) {
+        return (async function* () {
+          const span = parentSpan.startSpan({
+            name,
+            spanAttributes: {
+              type: "tool" /* TOOL */
+            }
+          });
+          span.log({ input: args.length === 1 ? args[0] : args });
+          try {
+            let lastValue;
+            for await (const value of result) {
+              lastValue = value;
+              yield value;
+            }
+            span.log({ output: lastValue });
+          } catch (error) {
+            span.log({
+              error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          } finally {
+            span.end();
+          }
+        })();
+      }
+      return parentSpan.traced(
+        async (span) => {
+          span.log({ input: args.length === 1 ? args[0] : args });
+          const awaitedResult = await result;
+          span.log({ output: awaitedResult });
+          return awaitedResult;
+        },
+        {
+          name,
+          spanAttributes: {
+            type: "tool" /* TOOL */
+          }
+        }
+      );
+    };
+    cleanup.push(() => {
+      tool.execute = originalExecute;
+      delete tool[AUTO_PATCHED_TOOL];
+    });
+  };
+  const patchTools = (tools) => {
+    if (!tools) {
+      return;
+    }
+    const inferName = (tool, fallback) => tool && (tool.name || tool.toolName || tool.id) || fallback;
+    if (Array.isArray(tools)) {
+      tools.forEach(
+        (tool, index) => patchTool(tool, inferName(tool, `tool[${index}]`))
+      );
+      return;
+    }
+    for (const [key, tool] of Object.entries(tools)) {
+      patchTool(tool, key);
+    }
+  };
+  if (params && typeof params === "object") {
+    patchModel(params.model);
+    patchTools(params.tools);
+  }
+  if (self && typeof self === "object") {
+    const selfRecord = self;
+    if (selfRecord.model !== void 0) {
+      patchModel(selfRecord.model);
+    }
+    if (selfRecord.settings && typeof selfRecord.settings === "object") {
+      if (selfRecord.settings.model !== void 0) {
+        patchModel(selfRecord.settings.model);
+      }
+      if (selfRecord.settings.tools !== void 0) {
+        patchTools(selfRecord.settings.tools);
+      }
+    }
+  }
+  return {
+    cleanup: cleanup.length > 0 ? () => {
+      while (cleanup.length > 0) {
+        cleanup.pop()?.();
+      }
+    } : void 0,
+    modelWrapped
+  };
+}
+function finalizeAISDKChildTracing(event) {
+  const cleanup = event?.__braintrust_ai_sdk_cleanup;
+  if (event && typeof cleanup === "function") {
+    cleanup();
+    delete event.__braintrust_ai_sdk_cleanup;
+  }
+}
+function patchAISDKStreamingResult(args) {
+  const { denyOutputPaths, endEvent, result, span, startTime } = args;
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  const resultRecord = result;
+  if (!isReadableStreamLike(resultRecord.baseStream)) {
+    return false;
+  }
+  let firstChunkTime;
+  const wrappedBaseStream = resultRecord.baseStream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        if (firstChunkTime === void 0) {
+          firstChunkTime = getCurrentUnixTimestamp();
+        }
+        controller.enqueue(chunk);
+      },
+      async flush() {
+        const metrics = extractTopLevelAISDKMetrics(result, endEvent);
+        if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
+          metrics.time_to_first_token = firstChunkTime - startTime;
+        }
+        const output = await processAISDKStreamingOutput(
+          result,
+          denyOutputPaths
+        );
+        const metadata = buildResolvedMetadataPayload(result).metadata;
+        span.log({
+          output,
+          ...metadata ? { metadata } : {},
+          metrics
+        });
+        finalizeAISDKChildTracing(endEvent);
+        span.end();
+      }
+    })
+  );
+  Object.defineProperty(resultRecord, "baseStream", {
+    configurable: true,
+    enumerable: true,
+    value: wrappedBaseStream,
+    writable: true
+  });
+  return true;
+}
+function isReadableStreamLike(value) {
+  return value != null && typeof value === "object" && typeof value.pipeThrough === "function";
+}
+async function processAISDKStreamingOutput(result, denyOutputPaths) {
+  const output = processAISDKOutput(result, denyOutputPaths);
+  if (!output || typeof output !== "object") {
+    return output;
+  }
+  const outputRecord = output;
+  try {
+    if ("text" in result && typeof result.text === "string") {
+      outputRecord.text = result.text;
+    }
+  } catch {
+  }
+  try {
+    if ("object" in result) {
+      const resolvedObject = await Promise.resolve(result.object);
+      if (resolvedObject !== void 0) {
+        outputRecord.object = resolvedObject;
+      }
+    }
+  } catch {
+  }
+  return outputRecord;
+}
+function buildAISDKChildMetadata(model) {
+  const { model: modelId, provider } = serializeModelWithProvider(model);
+  return {
+    ...modelId ? { model: modelId } : {},
+    ...provider ? { provider } : {},
+    braintrust: {
+      integration_name: "ai-sdk",
+      sdk_language: "typescript"
+    }
+  };
+}
+function buildResolvedMetadataPayload(result) {
+  const gatewayInfo = extractGatewayRoutingInfo(result);
+  const metadata = {};
+  if (gatewayInfo?.provider) {
+    metadata.provider = gatewayInfo.provider;
+  }
+  if (gatewayInfo?.model) {
+    metadata.model = gatewayInfo.model;
+  }
+  if (result.finishReason !== void 0) {
+    metadata.finish_reason = result.finishReason;
+  }
+  return Object.keys(metadata).length > 0 ? { metadata } : {};
+}
+function resolveAISDKModel(model) {
+  if (typeof model !== "string") {
+    return model;
+  }
+  const provider = globalThis.AI_SDK_DEFAULT_PROVIDER ?? null;
+  if (provider && typeof provider.languageModel === "function") {
+    return provider.languageModel(model);
+  }
+  return model;
+}
+function extractTextDelta(chunk) {
+  if (typeof chunk.textDelta === "string") return chunk.textDelta;
+  if (typeof chunk.delta === "string") return chunk.delta;
+  if (typeof chunk.text === "string") return chunk.text;
+  if (typeof chunk.content === "string") return chunk.content;
+  return "";
+}
+function isAsyncGenerator(value) {
+  return value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function" && typeof value.next === "function" && typeof value.return === "function" && typeof value.throw === "function";
+}
+function processAISDKOutput(output, denyOutputPaths) {
+  if (!output) return output;
+  const merged = extractSerializableOutputFields(output);
+  return normalizeAISDKLoggedOutput(omit(merged, denyOutputPaths));
+}
+function extractTokenMetrics(result) {
+  const metrics = {};
+  let usage = result?.totalUsage || result?.usage;
+  if (!usage && result) {
+    try {
+      if ("totalUsage" in result && typeof result.totalUsage !== "function") {
+        usage = result.totalUsage;
+      } else if ("usage" in result && typeof result.usage !== "function") {
+        usage = result.usage;
+      }
+    } catch {
+    }
+  }
+  if (!usage) {
+    return metrics;
+  }
+  const promptTokens = firstNumber(
+    usage.inputTokens?.total,
+    usage.inputTokens,
+    usage.promptTokens,
+    usage.prompt_tokens
+  );
+  if (promptTokens !== void 0) {
+    metrics.prompt_tokens = promptTokens;
+  }
+  const completionTokens = firstNumber(
+    usage.outputTokens?.total,
+    usage.outputTokens,
+    usage.completionTokens,
+    usage.completion_tokens
+  );
+  if (completionTokens !== void 0) {
+    metrics.completion_tokens = completionTokens;
+  }
+  const totalTokens = firstNumber(
     usage.totalTokens,
     usage.tokens,
     usage.total_tokens
@@ -9480,12 +10147,14 @@ function extractTokenMetrics(result) {
   }
   return metrics;
 }
-function aggregateAISDKChunks(chunks) {
+function aggregateAISDKChunks(chunks, _result, endEvent) {
   const lastChunk = chunks[chunks.length - 1];
   const output = {};
   let metrics = {};
+  let metadata;
   if (lastChunk) {
-    metrics = extractTokenMetrics(lastChunk);
+    metrics = hasModelChildTracing(endEvent) ? {} : extractTokenMetrics(lastChunk);
+    metadata = buildResolvedMetadataPayload(lastChunk).metadata;
     if (lastChunk.text !== void 0) {
       output.text = lastChunk.text;
     }
@@ -9499,7 +10168,8 @@ function aggregateAISDKChunks(chunks) {
       output.toolCalls = lastChunk.toolCalls;
     }
   }
-  return { output, metrics };
+  finalizeAISDKChildTracing(endEvent);
+  return { output, metrics, metadata };
 }
 function extractGetterValues(obj) {
   const getterValues = {};
@@ -9519,7 +10189,7 @@ function extractGetterValues(obj) {
   ];
   for (const name of getterNames) {
     try {
-      if (obj && name in obj && typeof obj[name] !== "function") {
+      if (obj && name in obj && isSerializableOutputValue(obj[name])) {
         getterValues[name] = obj[name];
       }
     } catch {
@@ -9527,6 +10197,47 @@ function extractGetterValues(obj) {
   }
   return getterValues;
 }
+function extractSerializableOutputFields(output) {
+  const serialized = {};
+  const directFieldNames = [
+    "steps",
+    "request",
+    "responseMessages",
+    "warnings",
+    "rawResponse",
+    "response",
+    "providerMetadata",
+    "experimental_providerMetadata"
+  ];
+  for (const name of directFieldNames) {
+    try {
+      const value = output?.[name];
+      if (isSerializableOutputValue(value)) {
+        serialized[name] = value;
+      }
+    } catch {
+    }
+  }
+  return {
+    ...serialized,
+    ...extractGetterValues(output)
+  };
+}
+function isSerializableOutputValue(value) {
+  if (typeof value === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value.then === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value.getReader === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function") {
+    return false;
+  }
+  return true;
+}
 function serializeModelWithProvider(model) {
   const modelId = typeof model === "string" ? model : model?.modelId;
   const explicitProvider = typeof model === "object" ? model?.provider : void 0;
@@ -9552,6 +10263,25 @@ function parseGatewayModelString(modelString) {
   }
   return { model: modelString };
 }
+function extractGatewayRoutingInfo(result) {
+  if (result?.steps && Array.isArray(result.steps) && result.steps.length > 0) {
+    const routing2 = result.steps[0]?.providerMetadata?.gateway?.routing;
+    if (routing2) {
+      return {
+        provider: routing2.resolvedProvider || routing2.finalProvider,
+        model: routing2.resolvedProviderApiModelId
+      };
+    }
+  }
+  const routing = result?.providerMetadata?.gateway?.routing;
+  if (routing) {
+    return {
+      provider: routing.resolvedProvider || routing.finalProvider,
+      model: routing.resolvedProviderApiModelId
+    };
+  }
+  return null;
+}
 function extractCostFromResult(result) {
   if (result?.steps && Array.isArray(result.steps) && result.steps.length > 0) {
     let totalCost = 0;
@@ -10282,47 +11012,1069 @@ 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(config = {}) {
-    super();
-    this.config = config;
+// 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) {
+  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 = (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 {
+      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 (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
+    };
+  }
+  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 (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 (...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 (!isAsyncIterable2(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 (error) {
+          childSpan.log({
+            error: normalizeError(error).message
+          });
+          childSpan.end();
+          throw error;
+        }
+      });
+    };
+  }
+  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 (error) {
+          childSpan.log({
+            error: normalizeError(error).message
+          });
+          childSpan.end();
+          throw error;
+        }
+      });
+    };
+  }
+  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 tracingChannel = 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
+  };
+  tracingChannel.start.publish(event);
+  try {
+    const result = args.execute();
+    return publishToolResult(tracingChannel, event, result);
+  } catch (error) {
+    event.error = normalizeError(error);
+    tracingChannel.error.publish(event);
+    throw error;
+  }
+}
+function publishToolResult(tracingChannel, event, result) {
+  if (isPromiseLike(result)) {
+    return result.then(
+      (resolved) => {
+        event.result = resolved;
+        tracingChannel.asyncEnd.publish(event);
+        return resolved;
+      },
+      (error) => {
+        event.error = normalizeError(error);
+        tracingChannel.error.publish(event);
+        throw error;
+      }
+    );
+  }
+  event.result = result;
+  tracingChannel.asyncEnd.publish(event);
+  return result;
+}
+function getToolCallId(context) {
+  const toolContext = context;
+  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;
+            },
+            (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 isAsyncIterable2(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(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// 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 (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 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(config = {}) {
+    super();
+    this.config = config;
+  }
+  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;
     }
@@ -10338,6 +12090,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.googleGenAIPlugin.disable();
       this.googleGenAIPlugin = null;
     }
+    if (this.openRouterPlugin) {
+      this.openRouterPlugin.disable();
+      this.openRouterPlugin = null;
+    }
   }
 };
 
@@ -10409,7 +12165,8 @@ var PluginRegistry = class {
       vercel: true,
       aisdk: true,
       google: true,
-      claudeAgentSDK: true
+      claudeAgentSDK: true,
+      openrouter: true
     };
   }
   /**