braintrust 3.7.0 → 3.7.1

package/dev/dist/index.js

@@ -165,7 +165,7 @@ var DefaultTracingChannel = class {
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   tracePromise(fn, _message, thisArg, ...args) {
-    return Promise.resolve(fn.apply(thisArg, args));
+    return fn.apply(thisArg, args);
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   traceCallback(fn, _position, _message, thisArg, ...args) {
@@ -185,6 +185,7 @@ var iso = {
   processOn: (_0, _1) => {
   },
   basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
+  // eslint-disable-next-line no-restricted-properties -- preserving intentional console usage.
   writeln: (text) => console.log(text)
 };
 var isomorph_default = iso;
@@ -1881,6 +1882,15 @@ var InternalAbortError = class extends Error {
     this.name = "InternalAbortError";
   }
 };
+function filterFrom(record, keys) {
+  const out = {};
+  for (const k of Object.keys(record)) {
+    if (!keys.includes(k)) {
+      out[k] = record[k];
+    }
+  }
+  return out;
+}
 
 // src/generated_types.ts
 
@@ -8874,7 +8884,7 @@ function patchStreamIfNeeded(stream, options) {
             if (!completed) {
               completed = true;
               try {
-                options.onComplete(chunks);
+                await options.onComplete(chunks);
               } catch (error) {
                 console.error("Error in stream onComplete handler:", error);
               }
@@ -8886,7 +8896,7 @@ function patchStreamIfNeeded(stream, options) {
               chunks.push(chunk);
               if (options.onChunk) {
                 try {
-                  options.onChunk(chunk);
+                  await options.onChunk(chunk);
                 } catch (error) {
                   console.error("Error in stream onChunk handler:", error);
                 }
@@ -8899,7 +8909,7 @@ function patchStreamIfNeeded(stream, options) {
             completed = true;
             if (options.onError) {
               try {
-                options.onError(
+                await options.onError(
                   error instanceof Error ? error : new Error(String(error)),
                   chunks
                 );
@@ -8917,7 +8927,7 @@ function patchStreamIfNeeded(stream, options) {
           if (!completed) {
             completed = true;
             try {
-              options.onComplete(chunks);
+              await options.onComplete(chunks);
             } catch (error) {
               console.error("Error in stream onComplete handler:", error);
             }
@@ -8934,7 +8944,7 @@ function patchStreamIfNeeded(stream, options) {
             const error = rawError instanceof Error ? rawError : new Error(String(rawError));
             if (options.onError) {
               try {
-                options.onError(error, chunks);
+                await options.onError(error, chunks);
               } catch (handlerError) {
                 console.error("Error in stream onError handler:", handlerError);
               }
@@ -9643,51 +9653,28 @@ function traceSyncStreamChannel(channel2, config) {
       }
       const { span, startTime } = spanData;
       const endEvent = event;
-      if (_optionalChain([config, 'access', _154 => _154.patchResult, 'optionalCall', _155 => _155({
-        channelName,
-        endEvent,
-        result: endEvent.result,
-        span,
-        startTime
-      })])) {
-        return;
-      }
-      const stream = endEvent.result;
-      if (!isSyncStreamLike(stream)) {
-        span.end();
-        states.delete(event);
-        return;
-      }
-      let first = true;
-      stream.on("chunk", () => {
-        if (first) {
-          span.log({
-            metrics: {
-              time_to_first_token: getCurrentUnixTimestamp() - startTime
-            }
-          });
-          first = false;
-        }
-      });
-      stream.on("chatCompletion", (completion) => {
-        try {
-          if (hasChoices(completion)) {
-            span.log({
-              output: completion.choices
-            });
-          }
-        } catch (error) {
-          console.error(
-            `Error extracting chatCompletion for ${channelName}:`,
-            error
-          );
+      const handleResolvedResult = (result) => {
+        const resolvedEndEvent = {
+          ...endEvent,
+          result
+        };
+        if (_optionalChain([config, 'access', _154 => _154.patchResult, 'optionalCall', _155 => _155({
+          channelName,
+          endEvent: resolvedEndEvent,
+          result,
+          span,
+          startTime
+        })])) {
+          return;
         }
-      });
-      stream.on("event", (streamEvent) => {
-        if (!config.extractFromEvent) {
+        const stream = result;
+        if (!isSyncStreamLike(stream)) {
+          span.end();
+          states.delete(event);
           return;
         }
-        try {
+        let first = true;
+        stream.on("chunk", () => {
           if (first) {
             span.log({
               metrics: {
@@ -9696,25 +9683,55 @@ function traceSyncStreamChannel(channel2, config) {
             });
             first = false;
           }
-          const extracted = config.extractFromEvent(streamEvent);
-          if (extracted && Object.keys(extracted).length > 0) {
-            span.log(extracted);
+        });
+        stream.on("chatCompletion", (completion) => {
+          try {
+            if (hasChoices(completion)) {
+              span.log({
+                output: completion.choices
+              });
+            }
+          } catch (error) {
+            console.error(
+              `Error extracting chatCompletion for ${channelName}:`,
+              error
+            );
           }
-        } catch (error) {
-          console.error(`Error extracting event for ${channelName}:`, error);
-        }
-      });
-      stream.on("end", () => {
-        span.end();
-        states.delete(event);
-      });
-      stream.on("error", (error) => {
-        span.log({
-          error: error.message
         });
-        span.end();
-        states.delete(event);
-      });
+        stream.on("event", (streamEvent) => {
+          if (!config.extractFromEvent) {
+            return;
+          }
+          try {
+            if (first) {
+              span.log({
+                metrics: {
+                  time_to_first_token: getCurrentUnixTimestamp() - startTime
+                }
+              });
+              first = false;
+            }
+            const extracted = config.extractFromEvent(streamEvent);
+            if (extracted && Object.keys(extracted).length > 0) {
+              span.log(extracted);
+            }
+          } catch (error) {
+            console.error(`Error extracting event for ${channelName}:`, error);
+          }
+        });
+        stream.on("end", () => {
+          span.end();
+          states.delete(event);
+        });
+        stream.on("error", (error) => {
+          span.log({
+            error: error.message
+          });
+          span.end();
+          states.delete(event);
+        });
+      };
+      handleResolvedResult(endEvent.result);
     },
     error: (event) => {
       logErrorAndEnd(states, event);
@@ -10537,28 +10554,40 @@ function aggregateAnthropicStreamChunks(chunks) {
       case "content_block_start":
         if (event.content_block) {
           contentBlocks[event.index] = event.content_block;
-          contentBlockDeltas[event.index] = [];
+          contentBlockDeltas[event.index] = { textDeltas: [], citations: [] };
         }
         break;
-      case "content_block_delta":
-        if (_optionalChain([event, 'access', _184 => _184.delta, 'optionalAccess', _185 => _185.type]) === "text_delta") {
-          const text = event.delta.text;
+      case "content_block_delta": {
+        const acc = contentBlockDeltas[event.index];
+        const delta = event.delta;
+        if (!delta) break;
+        if (delta.type === "text_delta" && "text" in delta) {
+          const text = delta.text;
           if (text) {
-            if (contentBlocks[event.index] !== void 0 || contentBlockDeltas[event.index] !== void 0) {
-              contentBlockDeltas[event.index] ??= [];
-              contentBlockDeltas[event.index].push(text);
+            if (acc !== void 0) {
+              acc.textDeltas.push(text);
             } else {
               fallbackTextDeltas.push(text);
             }
           }
-        } else if (_optionalChain([event, 'access', _186 => _186.delta, 'optionalAccess', _187 => _187.type]) === "input_json_delta") {
-          const partialJson = event.delta.partial_json;
-          if (partialJson) {
-            contentBlockDeltas[event.index] ??= [];
-            contentBlockDeltas[event.index].push(partialJson);
+        } else if (delta.type === "input_json_delta" && "partial_json" in delta) {
+          const partialJson = delta.partial_json;
+          if (partialJson && acc !== void 0) {
+            acc.textDeltas.push(partialJson);
+          }
+        } else if (delta.type === "thinking_delta" && "thinking" in delta) {
+          const thinking = delta.thinking;
+          if (thinking && acc !== void 0) {
+            acc.textDeltas.push(thinking);
+          }
+        } else if (delta.type === "citations_delta" && "citation" in delta) {
+          const citation = delta.citation;
+          if (citation && acc !== void 0) {
+            acc.citations.push(citation);
           }
         }
         break;
+      }
       case "content_block_stop":
         finalizeContentBlock(
           event.index,
@@ -10584,7 +10613,7 @@ function aggregateAnthropicStreamChunks(chunks) {
   })).filter(({ block }) => block !== void 0).sort((left, right) => left.index - right.index).map(({ block }) => block);
   let output = fallbackTextDeltas.join("");
   if (orderedContent.length > 0) {
-    if (orderedContent.every(isTextContentBlock)) {
+    if (orderedContent.every(isTextContentBlock) && orderedContent.every((block) => !_optionalChain([block, 'access', _184 => _184.citations, 'optionalAccess', _185 => _185.length]))) {
       output = orderedContent.map((block) => block.text).join("");
     } else {
       output = {
@@ -10610,7 +10639,8 @@ function finalizeContentBlock(index, contentBlocks, contentBlockDeltas, fallback
   if (!contentBlock) {
     return;
   }
-  const text = _nullishCoalesce(_optionalChain([contentBlockDeltas, 'access', _188 => _188[index], 'optionalAccess', _189 => _189.join, 'call', _190 => _190("")]), () => ( ""));
+  const acc = contentBlockDeltas[index];
+  const text = _nullishCoalesce(_optionalChain([acc, 'optionalAccess', _186 => _186.textDeltas, 'access', _187 => _187.join, 'call', _188 => _188("")]), () => ( ""));
   if (isToolUseContentBlock(contentBlock)) {
     if (!text) {
       return;
@@ -10627,20 +10657,28 @@ function finalizeContentBlock(index, contentBlocks, contentBlockDeltas, fallback
     return;
   }
   if (isTextContentBlock(contentBlock)) {
+    if (!text) {
+      delete contentBlocks[index];
+      return;
+    }
+    const updated = { ...contentBlock, text };
+    if (_optionalChain([acc, 'optionalAccess', _189 => _189.citations, 'access', _190 => _190.length])) {
+      updated.citations = acc.citations;
+    }
+    contentBlocks[index] = updated;
+    return;
+  }
+  if (isThinkingContentBlock(contentBlock)) {
     if (!text) {
       delete contentBlocks[index];
       return;
     }
     contentBlocks[index] = {
       ...contentBlock,
-      text
+      thinking: text
     };
     return;
   }
-  if (text) {
-    fallbackTextDeltas.push(text);
-  }
-  delete contentBlocks[index];
 }
 function isTextContentBlock(contentBlock) {
   return contentBlock.type === "text";
@@ -10648,6 +10686,9 @@ function isTextContentBlock(contentBlock) {
 function isToolUseContentBlock(contentBlock) {
   return contentBlock.type === "tool_use";
 }
+function isThinkingContentBlock(contentBlock) {
+  return contentBlock.type === "thinking";
+}
 function isAnthropicBase64ContentBlock(input) {
   return (input.type === "image" || input.type === "document") && isObject(input.source) && input.source.type === "base64";
 }
@@ -10702,15 +10743,6 @@ function coalesceInput(messages, system) {
   }
   return input;
 }
-function filterFrom(obj, fieldsToRemove) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (!fieldsToRemove.includes(key)) {
-      result[key] = value;
-    }
-  }
-  return result;
-}
 
 // src/wrappers/ai-sdk/normalize-logged-output.ts
 var REMOVE_NORMALIZED_VALUE = Symbol("braintrust.ai-sdk.remove-normalized");
@@ -10824,10 +10856,6 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "streamText",
     kind: "async"
   }),
-  streamTextSync: channel({
-    channelName: "streamText.sync",
-    kind: "sync-stream"
-  }),
   generateObject: channel({
     channelName: "generateObject",
     kind: "async"
@@ -10836,10 +10864,6 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "streamObject",
     kind: "async"
   }),
-  streamObjectSync: channel({
-    channelName: "streamObject.sync",
-    kind: "sync-stream"
-  }),
   agentGenerate: channel({
     channelName: "Agent.generate",
     kind: "async"
@@ -10875,6 +10899,9 @@ var DEFAULT_DENY_OUTPUT_PATHS = [
 ];
 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 RUNTIME_DENY_OUTPUT_PATHS = Symbol.for(
+  "braintrust.ai-sdk.deny-output-paths"
+);
 var AISDKPlugin = class extends BasePlugin {
   
   constructor(config = {}) {
@@ -10896,7 +10923,10 @@ var AISDKPlugin = class extends BasePlugin {
         extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
-          return processAISDKOutput(result, denyOutputPaths);
+          return processAISDKOutput(
+            result,
+            resolveDenyOutputPaths(endEvent, denyOutputPaths)
+          );
         },
         extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
@@ -10907,25 +10937,14 @@ var AISDKPlugin = class extends BasePlugin {
         name: "streamText",
         type: "llm" /* LLM */,
         extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
-        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, 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,
+          defaultDenyOutputPaths: denyOutputPaths,
           endEvent,
           result,
           span,
@@ -10940,7 +10959,10 @@ var AISDKPlugin = class extends BasePlugin {
         extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
-          return processAISDKOutput(result, denyOutputPaths);
+          return processAISDKOutput(
+            result,
+            resolveDenyOutputPaths(endEvent, denyOutputPaths)
+          );
         },
         extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
@@ -10951,25 +10973,14 @@ var AISDKPlugin = class extends BasePlugin {
         name: "streamObject",
         type: "llm" /* LLM */,
         extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
-        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, 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,
+          defaultDenyOutputPaths: denyOutputPaths,
           endEvent,
           result,
           span,
@@ -10984,7 +10995,10 @@ var AISDKPlugin = class extends BasePlugin {
         extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
-          return processAISDKOutput(result, denyOutputPaths);
+          return processAISDKOutput(
+            result,
+            resolveDenyOutputPaths(endEvent, denyOutputPaths)
+          );
         },
         extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
@@ -10995,11 +11009,14 @@ var AISDKPlugin = class extends BasePlugin {
         name: "Agent.stream",
         type: "llm" /* LLM */,
         extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
-        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
         extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
         aggregateChunks: aggregateAISDKChunks,
         patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
-          denyOutputPaths,
+          defaultDenyOutputPaths: denyOutputPaths,
           endEvent,
           result,
           span,
@@ -11014,7 +11031,10 @@ var AISDKPlugin = class extends BasePlugin {
         extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
-          return processAISDKOutput(result, denyOutputPaths);
+          return processAISDKOutput(
+            result,
+            resolveDenyOutputPaths(endEvent, denyOutputPaths)
+          );
         },
         extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
@@ -11025,11 +11045,14 @@ var AISDKPlugin = class extends BasePlugin {
         name: "ToolLoopAgent.stream",
         type: "llm" /* LLM */,
         extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
-        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractOutput: (result, endEvent) => processAISDKOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
         extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
         aggregateChunks: aggregateAISDKChunks,
         patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
-          denyOutputPaths,
+          defaultDenyOutputPaths: denyOutputPaths,
           endEvent,
           result,
           span,
@@ -11039,125 +11062,425 @@ var AISDKPlugin = class extends BasePlugin {
     );
   }
 };
-function processAISDKInput(params) {
-  if (!params) return params;
-  const input = processInputAttachments(params);
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    return input;
+function resolveDenyOutputPaths(event, defaultDenyOutputPaths) {
+  if (Array.isArray(_optionalChain([event, 'optionalAccess', _191 => _191.denyOutputPaths]))) {
+    return event.denyOutputPaths;
   }
-  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;
+  const firstArgument = _optionalChain([event, 'optionalAccess', _192 => _192.arguments]) && event.arguments.length > 0 ? event.arguments[0] : void 0;
+  if (!firstArgument || typeof firstArgument !== "object") {
+    return defaultDenyOutputPaths;
   }
-  return {
-    input,
-    metadata
-  };
-}
-function extractTopLevelAISDKMetrics(result, event, startTime) {
-  const metrics = hasModelChildTracing(event) ? {} : extractTokenMetrics(result);
-  if (startTime) {
-    metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+  const runtimeDenyOutputPaths = firstArgument[RUNTIME_DENY_OUTPUT_PATHS];
+  if (Array.isArray(runtimeDenyOutputPaths) && runtimeDenyOutputPaths.every((path2) => typeof path2 === "string")) {
+    return runtimeDenyOutputPaths;
   }
-  return metrics;
-}
-function hasModelChildTracing(event) {
-  return _optionalChain([event, 'optionalAccess', _191 => _191.__braintrust_ai_sdk_model_wrapped]) === true;
+  return defaultDenyOutputPaths;
 }
-function extractMetadataFromParams(params, self) {
-  const metadata = {
-    braintrust: {
-      integration_name: "ai-sdk",
-      sdk_language: "typescript"
-    }
-  };
-  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _192 => _192.settings, 'optionalAccess', _193 => _193.model]) ? _optionalChain([self, 'access', _194 => _194.settings, 'optionalAccess', _195 => _195.model]) : void 0;
-  const { model, provider } = serializeModelWithProvider(
-    _nullishCoalesce(params.model, () => ( agentModel))
-  );
-  if (model) {
-    metadata.model = model;
+var isZodSchema2 = (value) => {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+};
+var serializeZodSchema2 = (schema) => {
+  try {
+    return zodToJsonSchema(schema);
+  } catch (e24) {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
   }
-  if (provider) {
-    metadata.provider = provider;
+};
+var isOutputObject = (value) => {
+  if (value == null || typeof value !== "object") {
+    return false;
   }
-  const tools = serializeAISDKToolsForLogging(params.tools);
-  if (tools) {
-    metadata.tools = tools;
+  const output = value;
+  if (!("responseFormat" in output)) {
+    return false;
   }
-  return metadata;
-}
-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;
-    }
-    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 (output.type === "object" || output.type === "text") {
+    return true;
+  }
+  if (typeof output.responseFormat === "function" || typeof output.responseFormat === "object") {
+    return true;
+  }
+  return false;
+};
+var serializeOutputObject = (output, model) => {
+  try {
+    const result = {
+      response_format: null
     };
-    if (originalDoStream) {
-      resolvedModel.doStream = async function doStreamPatched(options) {
-        const span = parentSpan.startSpan({
-          name: "doStream",
-          spanAttributes: {
-            type: "llm" /* LLM */
-          },
-          event: {
-            input: processAISDKInput(options),
-            metadata: baseMetadata
+    if (output.type) {
+      result.type = output.type;
+    }
+    let responseFormat;
+    if (typeof output.responseFormat === "function") {
+      const mockModelForSchema = {
+        supportsStructuredOutputs: true,
+        ...model && typeof model === "object" ? model : {}
+      };
+      responseFormat = output.responseFormat({ model: mockModelForSchema });
+    } else if (output.responseFormat != null && typeof output.responseFormat === "object") {
+      responseFormat = output.responseFormat;
+    }
+    if (responseFormat) {
+      if (typeof responseFormat.then === "function") {
+        result.response_format = Promise.resolve(responseFormat).then(
+          (resolved) => {
+            if (resolved.schema && isZodSchema2(resolved.schema)) {
+              return {
+                ...resolved,
+                schema: serializeZodSchema2(resolved.schema)
+              };
+            }
+            return resolved;
           }
-        });
-        const result = await withCurrent(
-          span,
-          () => Reflect.apply(originalDoStream, resolvedModel, [options])
         );
+      } else {
+        const syncResponseFormat = responseFormat;
+        if (syncResponseFormat.schema && isZodSchema2(syncResponseFormat.schema)) {
+          responseFormat = {
+            ...syncResponseFormat,
+            schema: serializeZodSchema2(syncResponseFormat.schema)
+          };
+        }
+        result.response_format = responseFormat;
+      }
+    }
+    return result;
+  } catch (e25) {
+    return {
+      response_format: null
+    };
+  }
+};
+var processInputAttachmentsSync = (input) => {
+  if (!input) return { input };
+  const processed = { ...input };
+  if (input.messages && Array.isArray(input.messages)) {
+    processed.messages = input.messages.map(processMessage);
+  }
+  if (input.prompt && typeof input.prompt === "object") {
+    if (Array.isArray(input.prompt)) {
+      processed.prompt = input.prompt.map(processMessage);
+    } else {
+      processed.prompt = processPromptContent(input.prompt);
+    }
+  }
+  if (input.schema && isZodSchema2(input.schema)) {
+    processed.schema = serializeZodSchema2(input.schema);
+  }
+  if (input.callOptionsSchema && isZodSchema2(input.callOptionsSchema)) {
+    processed.callOptionsSchema = serializeZodSchema2(input.callOptionsSchema);
+  }
+  if (input.tools) {
+    processed.tools = serializeAISDKToolsForLogging(input.tools);
+  }
+  let outputPromise;
+  if (input.output && isOutputObject(input.output)) {
+    const serialized = serializeOutputObject(input.output, input.model);
+    if (serialized.response_format && typeof serialized.response_format.then === "function") {
+      processed.output = { ...serialized, response_format: {} };
+      outputPromise = serialized.response_format.then(
+        (resolvedFormat) => ({
+          output: { ...serialized, response_format: resolvedFormat }
+        })
+      );
+    } else {
+      processed.output = serialized;
+    }
+  }
+  if ("prepareCall" in processed && typeof processed.prepareCall === "function") {
+    processed.prepareCall = "[Function]";
+  }
+  return { input: processed, outputPromise };
+};
+var processMessage = (message) => {
+  if (!message || typeof message !== "object") return message;
+  if (Array.isArray(message.content)) {
+    return {
+      ...message,
+      content: message.content.map(processContentPart)
+    };
+  }
+  if (typeof message.content === "object" && message.content !== null) {
+    return {
+      ...message,
+      content: processContentPart(message.content)
+    };
+  }
+  return message;
+};
+var processPromptContent = (prompt) => {
+  if (Array.isArray(prompt)) {
+    return prompt.map(processContentPart);
+  }
+  if (prompt.content) {
+    if (Array.isArray(prompt.content)) {
+      return {
+        ...prompt,
+        content: prompt.content.map(processContentPart)
+      };
+    } else if (typeof prompt.content === "object") {
+      return {
+        ...prompt,
+        content: processContentPart(prompt.content)
+      };
+    }
+  }
+  return prompt;
+};
+var processContentPart = (part) => {
+  if (!part || typeof part !== "object") return part;
+  try {
+    if (part.type === "image" && part.image) {
+      const imageAttachment = convertImageToAttachment(
+        part.image,
+        part.mimeType || part.mediaType
+      );
+      if (imageAttachment) {
+        return {
+          ...part,
+          image: imageAttachment
+        };
+      }
+    }
+    if (part.type === "file" && part.data && (part.mimeType || part.mediaType)) {
+      const fileAttachment = convertDataToAttachment(
+        part.data,
+        part.mimeType || part.mediaType,
+        part.name || part.filename
+      );
+      if (fileAttachment) {
+        return {
+          ...part,
+          data: fileAttachment
+        };
+      }
+    }
+    if (part.type === "image_url" && part.image_url) {
+      if (typeof part.image_url === "object" && part.image_url.url) {
+        const imageAttachment = convertImageToAttachment(part.image_url.url);
+        if (imageAttachment) {
+          return {
+            ...part,
+            image_url: {
+              ...part.image_url,
+              url: imageAttachment
+            }
+          };
+        }
+      }
+    }
+  } catch (error) {
+    console.warn("Error processing content part:", error);
+  }
+  return part;
+};
+var convertImageToAttachment = (image, explicitMimeType) => {
+  try {
+    if (typeof image === "string" && image.startsWith("data:")) {
+      const [mimeTypeSection, base64Data] = image.split(",");
+      const mimeType = _optionalChain([mimeTypeSection, 'access', _193 => _193.match, 'call', _194 => _194(/data:(.*?);/), 'optionalAccess', _195 => _195[1]]);
+      if (mimeType && base64Data) {
+        const blob = convertDataToBlob(base64Data, mimeType);
+        if (blob) {
+          return new Attachment({
+            data: blob,
+            filename: `image.${getExtensionFromMediaType(mimeType)}`,
+            contentType: mimeType
+          });
+        }
+      }
+    }
+    if (explicitMimeType) {
+      if (image instanceof Uint8Array) {
+        return new Attachment({
+          data: new Blob([image], { type: explicitMimeType }),
+          filename: `image.${getExtensionFromMediaType(explicitMimeType)}`,
+          contentType: explicitMimeType
+        });
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(image)) {
+        return new Attachment({
+          data: new Blob([image], { type: explicitMimeType }),
+          filename: `image.${getExtensionFromMediaType(explicitMimeType)}`,
+          contentType: explicitMimeType
+        });
+      }
+    }
+    if (image instanceof Blob && image.type) {
+      return new Attachment({
+        data: image,
+        filename: `image.${getExtensionFromMediaType(image.type)}`,
+        contentType: image.type
+      });
+    }
+    if (image instanceof Attachment) {
+      return image;
+    }
+  } catch (error) {
+    console.warn("Error converting image to attachment:", error);
+  }
+  return null;
+};
+var convertDataToAttachment = (data, mimeType, filename) => {
+  if (!mimeType) return null;
+  try {
+    let blob = null;
+    if (typeof data === "string" && data.startsWith("data:")) {
+      const [, base64Data] = data.split(",");
+      if (base64Data) {
+        blob = convertDataToBlob(base64Data, mimeType);
+      }
+    } else if (typeof data === "string" && data.length > 0) {
+      blob = convertDataToBlob(data, mimeType);
+    } else if (data instanceof Uint8Array) {
+      blob = new Blob([data], { type: mimeType });
+    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+      blob = new Blob([data], { type: mimeType });
+    } else if (data instanceof Blob) {
+      blob = data;
+    }
+    if (blob) {
+      return new Attachment({
+        data: blob,
+        filename: filename || `file.${getExtensionFromMediaType(mimeType)}`,
+        contentType: mimeType
+      });
+    }
+  } catch (error) {
+    console.warn("Error converting data to attachment:", error);
+  }
+  return null;
+};
+function processAISDKInput(params) {
+  return processInputAttachmentsSync(params);
+}
+function prepareAISDKInput(params, event, span, defaultDenyOutputPaths) {
+  const { input, outputPromise } = processAISDKInput(params);
+  if (outputPromise && input && typeof input === "object") {
+    outputPromise.then((resolvedData) => {
+      span.log({
+        input: {
+          ...input,
+          ...resolvedData
+        }
+      });
+    }).catch(() => {
+    });
+  }
+  const metadata = extractMetadataFromParams(params, event.self);
+  const childTracing = prepareAISDKChildTracing(
+    params,
+    event.self,
+    span,
+    defaultDenyOutputPaths,
+    event.aiSDK
+  );
+  event.modelWrapped = 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 _optionalChain([event, 'optionalAccess', _196 => _196.modelWrapped]) === true || _optionalChain([event, 'optionalAccess', _197 => _197.__braintrust_ai_sdk_model_wrapped]) === true;
+}
+function extractMetadataFromParams(params, self) {
+  const metadata = {
+    braintrust: {
+      integration_name: "ai-sdk",
+      sdk_language: "typescript"
+    }
+  };
+  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _198 => _198.settings, 'optionalAccess', _199 => _199.model]) ? _optionalChain([self, 'access', _200 => _200.settings, 'optionalAccess', _201 => _201.model]) : void 0;
+  const { model, provider } = serializeModelWithProvider(
+    _nullishCoalesce(params.model, () => ( agentModel))
+  );
+  if (model) {
+    metadata.model = model;
+  }
+  if (provider) {
+    metadata.provider = provider;
+  }
+  const tools = serializeAISDKToolsForLogging(params.tools);
+  if (tools) {
+    metadata.tools = tools;
+  }
+  return metadata;
+}
+function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiSDK) {
+  const cleanup = [];
+  const patchedModels = /* @__PURE__ */ new WeakSet();
+  const patchedTools = /* @__PURE__ */ new WeakSet();
+  let modelWrapped = false;
+  const patchModel = (model) => {
+    const resolvedModel = resolveAISDKModel(model, aiSDK);
+    if (!resolvedModel || typeof resolvedModel !== "object" || typeof resolvedModel.doGenerate !== "function" || patchedModels.has(resolvedModel) || resolvedModel[AUTO_PATCHED_MODEL]) {
+      return resolvedModel;
+    }
+    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).input,
+            metadata: baseMetadata
+          }
+        }
+      );
+    };
+    if (originalDoStream) {
+      resolvedModel.doStream = async function doStreamPatched(options) {
+        const span = parentSpan.startSpan({
+          name: "doStream",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: {
+            input: processAISDKInput(options).input,
+            metadata: baseMetadata
+          }
+        });
+        const result = await withCurrent(
+          span,
+          () => Reflect.apply(originalDoStream, resolvedModel, [options])
+        );
+        const streamStartTime = getCurrentUnixTimestamp();
+        let firstChunkTime;
         const output = {};
         let text = "";
         let reasoning = "";
@@ -11165,6 +11488,9 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
         let object = void 0;
         const transformStream = new TransformStream({
           transform(chunk, controller) {
+            if (firstChunkTime === void 0) {
+              firstChunkTime = getCurrentUnixTimestamp();
+            }
             switch (chunk.type) {
               case "text-delta":
                 text += extractTextDelta(chunk);
@@ -11185,9 +11511,9 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
               case "raw":
                 if (chunk.rawValue) {
                   const rawVal = chunk.rawValue;
-                  if (_optionalChain([rawVal, 'access', _196 => _196.delta, 'optionalAccess', _197 => _197.content])) {
+                  if (_optionalChain([rawVal, 'access', _202 => _202.delta, 'optionalAccess', _203 => _203.content])) {
                     text += rawVal.delta.content;
-                  } else if (_optionalChain([rawVal, 'access', _198 => _198.choices, 'optionalAccess', _199 => _199[0], 'optionalAccess', _200 => _200.delta, 'optionalAccess', _201 => _201.content])) {
+                  } else if (_optionalChain([rawVal, 'access', _204 => _204.choices, 'optionalAccess', _205 => _205[0], 'optionalAccess', _206 => _206.delta, 'optionalAccess', _207 => _207.content])) {
                     text += rawVal.choices[0].delta.content;
                   } else if (typeof rawVal.text === "string") {
                     text += rawVal.text;
@@ -11205,12 +11531,19 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
                 if (object !== void 0) {
                   output.object = object;
                 }
+                const metrics = extractTokenMetrics(output);
+                if (firstChunkTime !== void 0) {
+                  metrics.time_to_first_token = Math.max(
+                    firstChunkTime - streamStartTime,
+                    1e-6
+                  );
+                }
                 span.log({
                   output: processAISDKOutput(
                     output,
                     denyOutputPaths
                   ),
-                  metrics: extractTokenMetrics(output),
+                  metrics,
                   ...buildResolvedMetadataPayload(output)
                 });
                 span.end();
@@ -11232,6 +11565,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
       }
       delete resolvedModel[AUTO_PATCHED_MODEL];
     });
+    return resolvedModel;
   };
   const patchTool = (tool, name) => {
     if (tool == null || typeof tool !== "object" || !("execute" in tool) || typeof tool.execute !== "function" || patchedTools.has(tool) || tool[AUTO_PATCHED_TOOL]) {
@@ -11304,17 +11638,26 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
     }
   };
   if (params && typeof params === "object") {
-    patchModel(params.model);
+    const patchedParamModel = patchModel(params.model);
+    if (typeof params.model === "string" && patchedParamModel && typeof patchedParamModel === "object") {
+      params.model = patchedParamModel;
+    }
     patchTools(params.tools);
   }
   if (self && typeof self === "object") {
     const selfRecord = self;
     if (selfRecord.model !== void 0) {
-      patchModel(selfRecord.model);
+      const patchedSelfModel = patchModel(selfRecord.model);
+      if (typeof selfRecord.model === "string" && patchedSelfModel && typeof patchedSelfModel === "object") {
+        selfRecord.model = patchedSelfModel;
+      }
     }
     if (selfRecord.settings && typeof selfRecord.settings === "object") {
       if (selfRecord.settings.model !== void 0) {
-        patchModel(selfRecord.settings.model);
+        const patchedSettingsModel = patchModel(selfRecord.settings.model);
+        if (typeof selfRecord.settings.model === "string" && patchedSettingsModel && typeof patchedSettingsModel === "object") {
+          selfRecord.settings.model = patchedSettingsModel;
+        }
       }
       if (selfRecord.settings.tools !== void 0) {
         patchTools(selfRecord.settings.tools);
@@ -11324,79 +11667,189 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths) {
   return {
     cleanup: cleanup.length > 0 ? () => {
       while (cleanup.length > 0) {
-        _optionalChain([cleanup, 'access', _202 => _202.pop, 'call', _203 => _203(), 'optionalCall', _204 => _204()]);
+        _optionalChain([cleanup, 'access', _208 => _208.pop, 'call', _209 => _209(), 'optionalCall', _210 => _210()]);
       }
     } : void 0,
     modelWrapped
   };
 }
 function finalizeAISDKChildTracing(event) {
-  const cleanup = _optionalChain([event, 'optionalAccess', _205 => _205.__braintrust_ai_sdk_cleanup]);
+  const cleanup = _optionalChain([event, 'optionalAccess', _211 => _211.__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;
+  const { defaultDenyOutputPaths, endEvent, result, span, startTime } = args;
   if (!result || typeof result !== "object") {
     return false;
   }
   const resultRecord = result;
-  if (!isReadableStreamLike(resultRecord.baseStream)) {
+  attachKnownResultPromiseHandlers(resultRecord);
+  if (isReadableStreamLike(resultRecord.baseStream)) {
+    let firstChunkTime2;
+    const wrappedBaseStream = resultRecord.baseStream.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          if (firstChunkTime2 === void 0) {
+            firstChunkTime2 = getCurrentUnixTimestamp();
+          }
+          controller.enqueue(chunk);
+        },
+        async flush() {
+          const metrics = extractTopLevelAISDKMetrics(result, endEvent);
+          if (metrics.time_to_first_token === void 0 && firstChunkTime2 !== void 0) {
+            metrics.time_to_first_token = firstChunkTime2 - startTime;
+          }
+          const output = await processAISDKStreamingOutput(
+            result,
+            resolveDenyOutputPaths(endEvent, defaultDenyOutputPaths)
+          );
+          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;
+  }
+  const streamField = findAsyncIterableField(resultRecord, [
+    "partialObjectStream",
+    "textStream",
+    "fullStream",
+    "stream"
+  ]);
+  if (!streamField) {
     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();
+  const wrappedStream = createPatchedAsyncIterable(streamField.stream, {
+    onChunk: () => {
+      if (firstChunkTime === void 0) {
+        firstChunkTime = getCurrentUnixTimestamp();
       }
-    })
-  );
-  Object.defineProperty(resultRecord, "baseStream", {
+    },
+    onComplete: async () => {
+      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,
+        resolveDenyOutputPaths(endEvent, defaultDenyOutputPaths)
+      );
+      const metadata = buildResolvedMetadataPayload(result).metadata;
+      span.log({
+        output,
+        ...metadata ? { metadata } : {},
+        metrics
+      });
+      finalizeAISDKChildTracing(endEvent);
+      span.end();
+    },
+    onError: (error) => {
+      span.log({
+        error: error.message
+      });
+      finalizeAISDKChildTracing(endEvent);
+      span.end();
+    }
+  });
+  Object.defineProperty(resultRecord, streamField.field, {
     configurable: true,
     enumerable: true,
-    value: wrappedBaseStream,
+    value: wrappedStream,
     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 (e24) {
+function attachKnownResultPromiseHandlers(result) {
+  const promiseLikeFields = [
+    "content",
+    "text",
+    "object",
+    "finishReason",
+    "usage",
+    "totalUsage",
+    "steps"
+  ];
+  for (const field of promiseLikeFields) {
+    try {
+      if (!(field in result)) {
+        continue;
+      }
+      const value = result[field];
+      if (isPromiseLike(value)) {
+        void Promise.resolve(value).catch(() => {
+        });
+      }
+    } catch (e26) {
+    }
+  }
+}
+function isReadableStreamLike(value) {
+  return value != null && typeof value === "object" && typeof value.pipeThrough === "function";
+}
+function isAsyncIterableLike(value) {
+  return value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+}
+function findAsyncIterableField(result, candidateFields) {
+  for (const field of candidateFields) {
+    try {
+      const stream = result[field];
+      if (isAsyncIterableLike(stream)) {
+        return { field, stream };
+      }
+    } catch (e27) {
+    }
+  }
+  return null;
+}
+function createPatchedAsyncIterable(stream, hooks) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      try {
+        for await (const chunk of stream) {
+          hooks.onChunk(chunk);
+          yield chunk;
+        }
+        await hooks.onComplete();
+      } catch (error) {
+        hooks.onError(
+          error instanceof Error ? error : new Error(String(error))
+        );
+        throw error;
+      }
+    }
+  };
+}
+async function processAISDKStreamingOutput(result, denyOutputPaths) {
+  const output = processAISDKOutput(result, denyOutputPaths);
+  if (!output || typeof output !== "object") {
+    return output;
+  }
+  const outputRecord = output;
+  const isObjectStreamingResult = result != null && typeof result === "object" && "partialObjectStream" in result;
+  try {
+    if (!isObjectStreamingResult && "text" in result) {
+      const resolvedText = await Promise.resolve(result.text);
+      if (typeof resolvedText === "string") {
+        outputRecord.text = resolvedText;
+      }
+    }
+  } catch (e28) {
   }
   try {
     if ("object" in result) {
@@ -11405,7 +11858,16 @@ async function processAISDKStreamingOutput(result, denyOutputPaths) {
         outputRecord.object = resolvedObject;
       }
     }
-  } catch (e25) {
+  } catch (e29) {
+  }
+  try {
+    if ("finishReason" in result) {
+      const resolvedFinishReason = await Promise.resolve(result.finishReason);
+      if (resolvedFinishReason !== void 0) {
+        outputRecord.finishReason = resolvedFinishReason;
+      }
+    }
+  } catch (e30) {
   }
   return outputRecord;
 }
@@ -11423,22 +11885,31 @@ function buildAISDKChildMetadata(model) {
 function buildResolvedMetadataPayload(result) {
   const gatewayInfo = extractGatewayRoutingInfo(result);
   const metadata = {};
-  if (_optionalChain([gatewayInfo, 'optionalAccess', _206 => _206.provider])) {
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _212 => _212.provider])) {
     metadata.provider = gatewayInfo.provider;
   }
-  if (_optionalChain([gatewayInfo, 'optionalAccess', _207 => _207.model])) {
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _213 => _213.model])) {
     metadata.model = gatewayInfo.model;
   }
-  if (result.finishReason !== void 0) {
-    metadata.finish_reason = result.finishReason;
+  let finishReason;
+  try {
+    finishReason = result.finishReason;
+  } catch (e31) {
+    finishReason = void 0;
+  }
+  if (isPromiseLike(finishReason)) {
+    void Promise.resolve(finishReason).catch(() => {
+    });
+  } else if (finishReason !== void 0) {
+    metadata.finish_reason = finishReason;
   }
   return Object.keys(metadata).length > 0 ? { metadata } : {};
 }
-function resolveAISDKModel(model) {
+function resolveAISDKModel(model, aiSDK) {
   if (typeof model !== "string") {
     return model;
   }
-  const provider = _nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( null));
+  const provider = _nullishCoalesce(_nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( _optionalChain([aiSDK, 'optionalAccess', _214 => _214.gateway]))), () => ( null));
   if (provider && typeof provider.languageModel === "function") {
     return provider.languageModel(model);
   }
@@ -11461,22 +11932,22 @@ function processAISDKOutput(output, denyOutputPaths) {
 }
 function extractTokenMetrics(result) {
   const metrics = {};
-  let usage = _optionalChain([result, 'optionalAccess', _208 => _208.totalUsage]) || _optionalChain([result, 'optionalAccess', _209 => _209.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 (e26) {
+  let usage;
+  const totalUsageValue = safeResultFieldRead(result, "totalUsage");
+  if (totalUsageValue !== void 0 && !isPromiseLike(totalUsageValue)) {
+    usage = totalUsageValue;
+  }
+  if (!usage) {
+    const usageValue = safeResultFieldRead(result, "usage");
+    if (usageValue !== void 0 && !isPromiseLike(usageValue)) {
+      usage = usageValue;
     }
   }
   if (!usage) {
     return metrics;
   }
   const promptTokens = firstNumber(
-    _optionalChain([usage, 'access', _210 => _210.inputTokens, 'optionalAccess', _211 => _211.total]),
+    _optionalChain([usage, 'access', _215 => _215.inputTokens, 'optionalAccess', _216 => _216.total]),
     usage.inputTokens,
     usage.promptTokens,
     usage.prompt_tokens
@@ -11485,7 +11956,7 @@ function extractTokenMetrics(result) {
     metrics.prompt_tokens = promptTokens;
   }
   const completionTokens = firstNumber(
-    _optionalChain([usage, 'access', _212 => _212.outputTokens, 'optionalAccess', _213 => _213.total]),
+    _optionalChain([usage, 'access', _217 => _217.outputTokens, 'optionalAccess', _218 => _218.total]),
     usage.outputTokens,
     usage.completionTokens,
     usage.completion_tokens
@@ -11507,6 +11978,22 @@ function extractTokenMetrics(result) {
   }
   return metrics;
 }
+function safeResultFieldRead(result, field) {
+  return safeSerializableFieldRead(result, field);
+}
+function safeSerializableFieldRead(obj, field) {
+  try {
+    const value = _optionalChain([obj, 'optionalAccess', _219 => _219[field]]);
+    if (isPromiseLike(value)) {
+      void Promise.resolve(value).catch(() => {
+      });
+      return void 0;
+    }
+    return value;
+  } catch (e32) {
+    return void 0;
+  }
+}
 function aggregateAISDKChunks(chunks, _result, endEvent) {
   const lastChunk = chunks[chunks.length - 1];
   const output = {};
@@ -11515,17 +12002,21 @@ function aggregateAISDKChunks(chunks, _result, endEvent) {
   if (lastChunk) {
     metrics = hasModelChildTracing(endEvent) ? {} : extractTokenMetrics(lastChunk);
     metadata = buildResolvedMetadataPayload(lastChunk).metadata;
-    if (lastChunk.text !== void 0) {
-      output.text = lastChunk.text;
+    const text = safeSerializableFieldRead(lastChunk, "text");
+    if (text !== void 0) {
+      output.text = text;
     }
-    if (lastChunk.object !== void 0) {
-      output.object = lastChunk.object;
+    const objectValue = safeSerializableFieldRead(lastChunk, "object");
+    if (objectValue !== void 0) {
+      output.object = objectValue;
     }
-    if (lastChunk.finishReason !== void 0) {
-      output.finishReason = lastChunk.finishReason;
+    const finishReason = safeSerializableFieldRead(lastChunk, "finishReason");
+    if (finishReason !== void 0) {
+      output.finishReason = finishReason;
     }
-    if (lastChunk.toolCalls !== void 0) {
-      output.toolCalls = lastChunk.toolCalls;
+    const toolCalls = safeSerializableFieldRead(lastChunk, "toolCalls");
+    if (toolCalls !== void 0) {
+      output.toolCalls = toolCalls;
     }
   }
   finalizeAISDKChildTracing(endEvent);
@@ -11534,6 +12025,7 @@ function aggregateAISDKChunks(chunks, _result, endEvent) {
 function extractGetterValues(obj) {
   const getterValues = {};
   const getterNames = [
+    "content",
     "text",
     "object",
     "finishReason",
@@ -11549,10 +12041,19 @@ function extractGetterValues(obj) {
   ];
   for (const name of getterNames) {
     try {
-      if (obj && name in obj && isSerializableOutputValue(obj[name])) {
-        getterValues[name] = obj[name];
+      if (!obj || !(name in obj)) {
+        continue;
       }
-    } catch (e27) {
+      const value = obj[name];
+      if (isPromiseLike(value)) {
+        void Promise.resolve(value).catch(() => {
+        });
+        continue;
+      }
+      if (isSerializableOutputValue(value)) {
+        getterValues[name] = value;
+      }
+    } catch (e33) {
     }
   }
   return getterValues;
@@ -11571,11 +12072,16 @@ function extractSerializableOutputFields(output) {
   ];
   for (const name of directFieldNames) {
     try {
-      const value = _optionalChain([output, 'optionalAccess', _214 => _214[name]]);
+      const value = _optionalChain([output, 'optionalAccess', _220 => _220[name]]);
+      if (isPromiseLike(value)) {
+        void Promise.resolve(value).catch(() => {
+        });
+        continue;
+      }
       if (isSerializableOutputValue(value)) {
         serialized[name] = value;
       }
-    } catch (e28) {
+    } catch (e34) {
     }
   }
   return {
@@ -11583,6 +12089,9 @@ function extractSerializableOutputFields(output) {
     ...extractGetterValues(output)
   };
 }
+function isPromiseLike(value) {
+  return value != null && typeof value === "object" && typeof value.then === "function";
+}
 function isSerializableOutputValue(value) {
   if (typeof value === "function") {
     return false;
@@ -11599,8 +12108,8 @@ function isSerializableOutputValue(value) {
   return true;
 }
 function serializeModelWithProvider(model) {
-  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _215 => _215.modelId]);
-  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _216 => _216.provider]) : void 0;
+  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _221 => _221.modelId]);
+  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _222 => _222.provider]) : void 0;
   if (!modelId) {
     return { model: modelId, provider: explicitProvider };
   }
@@ -11624,8 +12133,9 @@ function parseGatewayModelString(modelString) {
   return { model: modelString };
 }
 function extractGatewayRoutingInfo(result) {
-  if (_optionalChain([result, 'optionalAccess', _217 => _217.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
-    const routing2 = _optionalChain([result, 'access', _218 => _218.steps, 'access', _219 => _219[0], 'optionalAccess', _220 => _220.providerMetadata, 'optionalAccess', _221 => _221.gateway, 'optionalAccess', _222 => _222.routing]);
+  const steps = safeSerializableFieldRead(result, "steps");
+  if (Array.isArray(steps) && steps.length > 0) {
+    const routing2 = _optionalChain([steps, 'access', _223 => _223[0], 'optionalAccess', _224 => _224.providerMetadata, 'optionalAccess', _225 => _225.gateway, 'optionalAccess', _226 => _226.routing]);
     if (routing2) {
       return {
         provider: routing2.resolvedProvider || routing2.finalProvider,
@@ -11633,7 +12143,11 @@ function extractGatewayRoutingInfo(result) {
       };
     }
   }
-  const routing = _optionalChain([result, 'optionalAccess', _223 => _223.providerMetadata, 'optionalAccess', _224 => _224.gateway, 'optionalAccess', _225 => _225.routing]);
+  const providerMetadata = safeSerializableFieldRead(
+    result,
+    "providerMetadata"
+  );
+  const routing = _optionalChain([providerMetadata, 'optionalAccess', _227 => _227.gateway, 'optionalAccess', _228 => _228.routing]);
   if (routing) {
     return {
       provider: routing.resolvedProvider || routing.finalProvider,
@@ -11643,12 +12157,13 @@ function extractGatewayRoutingInfo(result) {
   return null;
 }
 function extractCostFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _226 => _226.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+  const steps = safeSerializableFieldRead(result, "steps");
+  if (Array.isArray(steps) && steps.length > 0) {
     let totalCost = 0;
     let foundCost = false;
-    for (const step of result.steps) {
-      const gateway2 = _optionalChain([step, 'optionalAccess', _227 => _227.providerMetadata, 'optionalAccess', _228 => _228.gateway]);
-      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _229 => _229.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _230 => _230.marketCost]));
+    for (const step of steps) {
+      const gateway2 = _optionalChain([step, 'optionalAccess', _229 => _229.providerMetadata, 'optionalAccess', _230 => _230.gateway]);
+      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _231 => _231.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _232 => _232.marketCost]));
       if (stepCost !== void 0 && stepCost > 0) {
         totalCost += stepCost;
         foundCost = true;
@@ -11658,8 +12173,12 @@ function extractCostFromResult(result) {
       return totalCost;
     }
   }
-  const gateway = _optionalChain([result, 'optionalAccess', _231 => _231.providerMetadata, 'optionalAccess', _232 => _232.gateway]);
-  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _233 => _233.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _234 => _234.marketCost]));
+  const providerMetadata = safeSerializableFieldRead(
+    result,
+    "providerMetadata"
+  );
+  const gateway = _optionalChain([providerMetadata, 'optionalAccess', _233 => _233.gateway]);
+  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _234 => _234.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _235 => _235.marketCost]));
   if (directCost !== void 0 && directCost > 0) {
     return directCost;
   }
@@ -11814,7 +12333,7 @@ function extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _235 => _235.message, 'optionalAccess', _236 => _236.usage]);
+    usage = _optionalChain([message, 'access', _236 => _236.message, 'optionalAccess', _237 => _237.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -11848,8 +12367,8 @@ function buildLLMInput(prompt, conversationHistory, capturedPromptMessages) {
     promptMessages.push({ content: prompt, role: "user" });
   } else if (capturedPromptMessages && capturedPromptMessages.length > 0) {
     for (const msg of capturedPromptMessages) {
-      const role = _optionalChain([msg, 'access', _237 => _237.message, 'optionalAccess', _238 => _238.role]);
-      const content = _optionalChain([msg, 'access', _239 => _239.message, 'optionalAccess', _240 => _240.content]);
+      const role = _optionalChain([msg, 'access', _238 => _238.message, 'optionalAccess', _239 => _239.role]);
+      const content = _optionalChain([msg, 'access', _240 => _240.message, 'optionalAccess', _241 => _241.content]);
       if (role && content !== void 0) {
         promptMessages.push({ content, role });
       }
@@ -11866,7 +12385,7 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
     return void 0;
   }
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _241 => _241.message, 'optionalAccess', _242 => _242.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _242 => _242.message, 'optionalAccess', _243 => _243.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
@@ -11877,7 +12396,7 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
     capturedPromptMessages
   );
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _243 => _243.message, 'optionalAccess', _244 => _244.content]) && _optionalChain([m, 'access', _245 => _245.message, 'optionalAccess', _246 => _246.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _244 => _244.message, 'optionalAccess', _245 => _245.content]) && _optionalChain([m, 'access', _246 => _246.message, 'optionalAccess', _247 => _247.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter(
     (c) => c !== void 0
   );
@@ -11896,7 +12415,7 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
     output: outputs
   });
   await span.end();
-  return _optionalChain([lastMessage, 'access', _247 => _247.message, 'optionalAccess', _248 => _248.content]) && _optionalChain([lastMessage, 'access', _249 => _249.message, 'optionalAccess', _250 => _250.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _248 => _248.message, 'optionalAccess', _249 => _249.content]) && _optionalChain([lastMessage, 'access', _250 => _250.message, 'optionalAccess', _251 => _251.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 function getMcpServerMetadata(serverName, mcpServers) {
   if (!serverName || !mcpServers) {
@@ -11978,18 +12497,18 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
       try {
         const response = input.tool_response;
         const metadata = {};
-        if (_optionalChain([response, 'optionalAccess', _251 => _251.status])) {
+        if (_optionalChain([response, 'optionalAccess', _252 => _252.status])) {
           metadata["claude_agent_sdk.status"] = response.status;
         }
-        if (_optionalChain([response, 'optionalAccess', _252 => _252.totalDurationMs])) {
+        if (_optionalChain([response, 'optionalAccess', _253 => _253.totalDurationMs])) {
           metadata["claude_agent_sdk.duration_ms"] = response.totalDurationMs;
         }
-        if (_optionalChain([response, 'optionalAccess', _253 => _253.totalToolUseCount]) !== void 0) {
+        if (_optionalChain([response, 'optionalAccess', _254 => _254.totalToolUseCount]) !== void 0) {
           metadata["claude_agent_sdk.tool_use_count"] = response.totalToolUseCount;
         }
         subAgentSpan.log({
           metadata,
-          output: _optionalChain([response, 'optionalAccess', _254 => _254.content])
+          output: _optionalChain([response, 'optionalAccess', _255 => _255.content])
         });
       } finally {
         subAgentSpan.end();
@@ -12081,7 +12600,7 @@ async function finalizeCurrentMessageGroup(state) {
   if (state.currentMessages.length === 0) {
     return;
   }
-  const parentToolUseId = _nullishCoalesce(_optionalChain([state, 'access', _255 => _255.currentMessages, 'access', _256 => _256[0], 'optionalAccess', _257 => _257.parent_tool_use_id]), () => ( null));
+  const parentToolUseId = _nullishCoalesce(_optionalChain([state, 'access', _256 => _256.currentMessages, 'access', _257 => _257[0], 'optionalAccess', _258 => _258.parent_tool_use_id]), () => ( null));
   let parentSpan = await state.span.export();
   if (parentToolUseId) {
     const subAgentSpan = state.subAgentSpans.get(parentToolUseId);
@@ -12102,13 +12621,13 @@ async function finalizeCurrentMessageGroup(state) {
     state.finalResults.push(finalMessage);
   }
   const lastMessage = state.currentMessages[state.currentMessages.length - 1];
-  if (_optionalChain([lastMessage, 'optionalAccess', _258 => _258.message, 'optionalAccess', _259 => _259.usage])) {
+  if (_optionalChain([lastMessage, 'optionalAccess', _259 => _259.message, 'optionalAccess', _260 => _260.usage])) {
     state.accumulatedOutputTokens += getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
   }
   state.currentMessages.length = 0;
 }
 function maybeTrackToolUseContext(state, message) {
-  if (message.type !== "assistant" || !Array.isArray(_optionalChain([message, 'access', _260 => _260.message, 'optionalAccess', _261 => _261.content]))) {
+  if (message.type !== "assistant" || !Array.isArray(_optionalChain([message, 'access', _261 => _261.message, 'optionalAccess', _262 => _262.content]))) {
     return;
   }
   const parentToolUseId = _nullishCoalesce(message.parent_tool_use_id, () => ( null));
@@ -12160,13 +12679,13 @@ async function ensureSubAgentSpan(pendingSubAgentNames, rootSpan, subAgentSpans,
 async function handleStreamMessage(state, message) {
   maybeTrackToolUseContext(state, message);
   await maybeStartSubAgentSpan(state, message);
-  const messageId = _optionalChain([message, 'access', _262 => _262.message, 'optionalAccess', _263 => _263.id]);
+  const messageId = _optionalChain([message, 'access', _263 => _263.message, 'optionalAccess', _264 => _264.id]);
   if (messageId && messageId !== state.currentMessageId) {
     await finalizeCurrentMessageGroup(state);
     state.currentMessageId = messageId;
     state.currentMessageStartTime = getCurrentUnixTimestamp();
   }
-  if (message.type === "assistant" && _optionalChain([message, 'access', _264 => _264.message, 'optionalAccess', _265 => _265.usage])) {
+  if (message.type === "assistant" && _optionalChain([message, 'access', _265 => _265.message, 'optionalAccess', _266 => _266.usage])) {
     state.currentMessages.push(message);
   }
   if (message.type !== "result" || !message.usage) {
@@ -12175,7 +12694,7 @@ async function handleStreamMessage(state, message) {
   const finalUsageMetrics = extractUsageFromMessage(message);
   if (state.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
     const lastMessage = state.currentMessages[state.currentMessages.length - 1];
-    if (_optionalChain([lastMessage, 'optionalAccess', _266 => _266.message, 'optionalAccess', _267 => _267.usage])) {
+    if (_optionalChain([lastMessage, 'optionalAccess', _267 => _267.message, 'optionalAccess', _268 => _268.usage])) {
       const adjustedTokens = finalUsageMetrics.completion_tokens - state.accumulatedOutputTokens;
       if (adjustedTokens >= 0) {
         lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -12272,7 +12791,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
                 yield message;
               }
             } finally {
-              _optionalChain([resolvePromptDone, 'optionalCall', _268 => _268()]);
+              _optionalChain([resolvePromptDone, 'optionalCall', _269 => _269()]);
             }
           })();
         }
@@ -12359,20 +12878,16 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
                 );
               });
             },
-            onComplete: () => {
-              void state.processing.then(() => finalizeQuerySpan(state)).finally(() => {
-                spans.delete(event);
-              });
-            },
-            onError: (error) => {
-              void state.processing.then(() => {
-                state.span.log({
-                  error: error.message
-                });
-              }).then(() => finalizeQuerySpan(state)).finally(() => {
-                spans.delete(event);
+            onComplete: () => state.processing.then(() => finalizeQuerySpan(state)).finally(() => {
+              spans.delete(event);
+            }),
+            onError: (error) => state.processing.then(() => {
+              state.span.log({
+                error: error.message
               });
-            }
+            }).then(() => finalizeQuerySpan(state)).finally(() => {
+              spans.delete(event);
+            })
           });
           return;
         }
@@ -12508,7 +13023,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
     };
     tracingChannel2.subscribe(handlers);
     this.unsubscribers.push(() => {
-      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _269 => _269()]);
+      _optionalChain([unbindCurrentSpanStore, 'optionalCall', _270 => _270()]);
       tracingChannel2.unsubscribe(handlers);
     });
   }
@@ -12520,12 +13035,14 @@ var GoogleGenAIPlugin = class extends BasePlugin {
         const params = event.arguments[0];
         streamEvent.googleGenAIInput = serializeInput(params);
         streamEvent.googleGenAIMetadata = extractMetadata(params);
+        streamEvent.googleGenAIStartTime = getCurrentUnixTimestamp();
       },
       asyncEnd: (event) => {
         const streamEvent = event;
         patchGoogleGenAIStreamingResult({
           input: streamEvent.googleGenAIInput,
           metadata: streamEvent.googleGenAIMetadata,
+          startTime: streamEvent.googleGenAIStartTime,
           result: streamEvent.result
         });
       },
@@ -12550,8 +13067,8 @@ function ensureSpanState(states, event, create) {
 function bindCurrentSpanStoreToStart2(tracingChannel2, states, create) {
   const state = _internalGetGlobalState();
   const startChannel = tracingChannel2.start;
-  const currentSpanStore = _optionalChain([state, 'optionalAccess', _270 => _270.contextManager]) ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
-  if (!_optionalChain([startChannel, 'optionalAccess', _271 => _271.bindStore]) || !currentSpanStore) {
+  const currentSpanStore = _optionalChain([state, 'optionalAccess', _271 => _271.contextManager]) ? state.contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (!_optionalChain([startChannel, 'optionalAccess', _272 => _272.bindStore]) || !currentSpanStore) {
     return void 0;
   }
   startChannel.bindStore(
@@ -12563,7 +13080,7 @@ function bindCurrentSpanStoreToStart2(tracingChannel2, states, create) {
     ).span
   );
   return () => {
-    _optionalChain([startChannel, 'access', _272 => _272.unbindStore, 'optionalCall', _273 => _273(currentSpanStore)]);
+    _optionalChain([startChannel, 'access', _273 => _273.unbindStore, 'optionalCall', _274 => _274(currentSpanStore)]);
   };
 }
 function logErrorAndEndSpan(states, event) {
@@ -12578,7 +13095,7 @@ function logErrorAndEndSpan(states, event) {
   states.delete(event);
 }
 function patchGoogleGenAIStreamingResult(args) {
-  const { input, metadata, result } = args;
+  const { input, metadata, result, startTime } = args;
   if (!input || !metadata || !result || typeof result !== "object" || typeof result.next !== "function") {
     return false;
   }
@@ -12586,7 +13103,7 @@ function patchGoogleGenAIStreamingResult(args) {
   let firstTokenTime = null;
   let finalized = false;
   let span = null;
-  let startTime = null;
+  const requestStartTime = _nullishCoalesce(startTime, () => ( getCurrentUnixTimestamp()));
   const ensureSpan = () => {
     if (!span) {
       span = startSpan({
@@ -12599,7 +13116,6 @@ function patchGoogleGenAIStreamingResult(args) {
           metadata
         }
       });
-      startTime = getCurrentUnixTimestamp();
     }
     return span;
   };
@@ -12653,11 +13169,11 @@ function patchGoogleGenAIStreamingResult(args) {
             }
             chunks.push(nextResult.value);
           }
-          if (nextResult.done && startTime !== null) {
+          if (nextResult.done) {
             finalize({
               result: aggregateGenerateContentChunks(
                 chunks,
-                startTime,
+                requestStartTime,
                 firstTokenTime
               )
             });
@@ -12677,13 +13193,13 @@ function patchGoogleGenAIStreamingResult(args) {
             ...returnArgs
           );
         } finally {
-          if (startTime !== null) {
+          if (chunks.length > 0) {
             finalize({
-              result: chunks.length > 0 ? aggregateGenerateContentChunks(
+              result: aggregateGenerateContentChunks(
                 chunks,
-                startTime,
+                requestStartTime,
                 firstTokenTime
-              ) : void 0
+              )
             });
           } else {
             finalize({});
@@ -12785,7 +13301,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _274 => _274.config, 'optionalAccess', _275 => _275.tools])) {
+  if (!_optionalChain([params, 'access', _275 => _275.config, 'optionalAccess', _276 => _276.tools])) {
     return null;
   }
   try {
@@ -12795,7 +13311,7 @@ function serializeTools(params) {
       }
       return tool;
     });
-  } catch (e29) {
+  } catch (e35) {
     return null;
   }
 }
@@ -12828,7 +13344,7 @@ function extractGenerateContentMetrics(response, startTime) {
     metrics.end = end;
     metrics.duration = end - startTime;
   }
-  if (_optionalChain([response, 'optionalAccess', _276 => _276.usageMetadata])) {
+  if (_optionalChain([response, 'optionalAccess', _277 => _277.usageMetadata])) {
     populateUsageMetrics(metrics, response.usageMetadata);
   }
   return metrics;
@@ -12875,7 +13391,7 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _277 => _277.content, 'optionalAccess', _278 => _278.parts])) {
+        if (_optionalChain([candidate, 'access', _278 => _278.content, 'optionalAccess', _279 => _279.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -12906,7 +13422,7 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _279 => _279.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _280 => _280.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -12975,895 +13491,535 @@ var openRouterChannels = defineChannels("@openrouter/sdk", {
     channelName: "callModel",
     kind: "sync-stream"
   }),
+  callModelTurn: channel({
+    channelName: "callModel.turn",
+    kind: "async"
+  }),
   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 {};
-  }
-  const metrics = {};
-  for (const [name, value] of Object.entries(usage)) {
-    if (typeof value === "number") {
-      metrics[TOKEN_NAME_MAP2[name] || camelToSnake(name)] = value;
-      continue;
-    }
-    if (!isObject(value)) {
-      continue;
-    }
-    const prefix = TOKEN_DETAIL_PREFIX_MAP[name];
-    if (!prefix) {
-      continue;
-    }
-    for (const [nestedName, nestedValue] of Object.entries(value)) {
-      if (typeof nestedValue !== "number") {
-        continue;
-      }
-      metrics[`${prefix}_${camelToSnake(nestedName)}`] = nestedValue;
-    }
-  }
-  return metrics;
-}
-function extractOpenRouterUsageMetadata(usage) {
-  if (!isObject(usage)) {
-    return void 0;
-  }
-  const metadata = {};
-  if (typeof usage.isByok === "boolean") {
-    metadata.is_byok = usage.isByok;
-  } else if (typeof usage.is_byok === "boolean") {
-    metadata.is_byok = usage.is_byok;
-  }
-  return Object.keys(metadata).length > 0 ? metadata : void 0;
-}
-
-// 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 (e30) {
-    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;
+// src/instrumentation/plugins/openrouter-plugin.ts
+var OpenRouterPlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToOpenRouterChannels();
   }
-  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);
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
-  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
+  subscribeToOpenRouterChannels() {
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.chatSend, {
+        name: "openrouter.chat.send",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _281 => _281.chatGenerationParams])) ? request.chatGenerationParams : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _282 => _282.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _283 => _283.xTitle]);
+          const { messages, ...metadata } = chatGenerationParams;
+          return {
+            input: messages,
+            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+          };
+        },
+        extractOutput: (result) => {
+          return isObject(result) ? result.choices : void 0;
+        },
+        extractMetrics: (result, startTime) => {
+          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _284 => _284.usage]));
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        },
+        aggregateChunks: aggregateOpenRouterChatChunks
+      })
     );
-    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 (e31) {
-      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;
+    this.unsubscribers.push(
+      traceAsyncChannel(openRouterChannels.embeddingsGenerate, {
+        name: "openrouter.embeddings.generate",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const requestBody = isObject(_optionalChain([request, 'optionalAccess', _285 => _285.requestBody])) ? request.requestBody : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _286 => _286.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _287 => _287.xTitle]);
+          const { input, ...metadata } = requestBody;
+          return {
+            input,
+            metadata: buildOpenRouterEmbeddingMetadata(
+              metadata,
+              httpReferer,
+              xTitle
+            )
+          };
+        },
+        extractOutput: (result) => {
+          if (!isObject(result)) {
+            return void 0;
+          }
+          const embedding = _optionalChain([result, 'access', _288 => _288.data, 'optionalAccess', _289 => _289[0], 'optionalAccess', _290 => _290.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) : {};
         }
-      });
-    };
-  }
-  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
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(openRouterChannels.betaResponsesSend, {
+        name: "openrouter.beta.responses.send",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const openResponsesRequest = isObject(_optionalChain([request, 'optionalAccess', _291 => _291.openResponsesRequest])) ? request.openResponsesRequest : {};
+          const httpReferer = _optionalChain([request, 'optionalAccess', _292 => _292.httpReferer]);
+          const xTitle = _optionalChain([request, 'optionalAccess', _293 => _293.xTitle]);
+          const { input, ...metadata } = openResponsesRequest;
+          return {
+            input,
+            metadata: buildOpenRouterMetadata(metadata, httpReferer, xTitle)
+          };
+        },
+        extractOutput: (result) => extractOpenRouterResponseOutput(result),
+        extractMetadata: (result) => extractOpenRouterResponseMetadata(result),
+        extractMetrics: (result, startTime) => {
+          const metrics = parseOpenRouterMetricsFromUsage(_optionalChain([result, 'optionalAccess', _294 => _294.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({
+            request: getOpenRouterCallModelRequestArg(endEvent.arguments),
+            result,
+            span
           });
-          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;
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(openRouterChannels.callModelTurn, {
+        name: "openrouter.beta.responses.send",
+        type: "llm" /* LLM */,
+        extractInput: (args, event) => {
+          const request = getOpenRouterCallModelRequestArg(args);
+          const metadata = request ? extractOpenRouterCallModelMetadata(request) : { provider: "openrouter" };
+          if (isObject(metadata) && "tools" in metadata) {
+            delete metadata.tools;
+          }
+          return {
+            input: request ? extractOpenRouterCallModelInput(request) : void 0,
+            metadata: {
+              ...metadata,
+              step: event.step,
+              step_type: event.stepType
+            }
+          };
+        },
+        extractOutput: (result) => extractOpenRouterResponseOutput(result),
+        extractMetadata: (result, event) => {
+          if (!isObject(result)) {
+            return {
+              step: _optionalChain([event, 'optionalAccess', _295 => _295.step]),
+              step_type: _optionalChain([event, 'optionalAccess', _296 => _296.stepType])
+            };
+          }
+          return {
+            ...extractOpenRouterResponseMetadata(result) || {},
+            ..._optionalChain([event, 'optionalAccess', _297 => _297.step]) !== void 0 ? { step: event.step } : {},
+            ..._optionalChain([event, 'optionalAccess', _298 => _298.stepType]) ? { step_type: event.stepType } : {}
+          };
+        },
+        extractMetrics: (result) => isObject(result) ? parseOpenRouterMetricsFromUsage(result.usage) : {}
+      })
+    );
+    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;
         }
-      });
-    };
-  }
-  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
-        });
+        patchOpenRouterCallModelRequestTools(request);
       }
-    }
-  };
-  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 (error) {
-    event.error = normalizeError(error);
-    tracingChannel2.error.publish(event);
-    throw error;
+    };
+    callModelChannel.subscribe(callModelHandlers);
+    this.unsubscribers.push(() => {
+      callModelChannel.unsubscribe(callModelHandlers);
+    });
   }
-}
-function publishToolResult(tracingChannel2, event, result) {
-  if (isPromiseLike(result)) {
-    return result.then(
-      (resolved) => {
-        event.result = resolved;
-        tracingChannel2.asyncEnd.publish(event);
-        return resolved;
-      },
-      (error) => {
-        event.error = normalizeError(error);
-        tracingChannel2.error.publish(event);
-        throw error;
-      }
-    );
+};
+function normalizeArgs(args) {
+  if (Array.isArray(args)) {
+    return args;
   }
-  event.result = result;
-  tracingChannel2.asyncEnd.publish(event);
-  return result;
-}
-function getToolCallId(context) {
-  const toolContext = context;
-  return typeof _optionalChain([toolContext, 'optionalAccess', _280 => _280.toolCall, 'optionalAccess', _281 => _281.id]) === "string" ? toolContext.toolCall.id : void 0;
+  if (isArrayLike(args)) {
+    return Array.from(args);
+  }
+  return [args];
 }
-function extractOpenRouterCallModelResultMetadata(response, turnCount) {
-  const combined = {
-    ...extractOpenRouterResponseMetadata(response) || {},
-    ...turnCount !== void 0 ? { turn_count: turnCount } : {}
-  };
-  return Object.keys(combined).length > 0 ? combined : void 0;
+function isArrayLike(value) {
+  return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
 }
-function getFinalOpenRouterCallModelResponse(result, response) {
-  if (isObject(response)) {
-    return response;
+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;
   }
-  return isObject(result.finalResponse) ? result.finalResponse : void 0;
+  const firstObjectArg = normalizedArgs.find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : 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 getOpenRouterCallModelRequestArg(args) {
+  const firstObjectArg = normalizeArgs(args).find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
 }
-function aggregateOpenRouterCallModelMetrics(rounds, finalResponse) {
+var TOKEN_NAME_MAP2 = {
+  promptTokens: "prompt_tokens",
+  inputTokens: "prompt_tokens",
+  completionTokens: "completion_tokens",
+  outputTokens: "completion_tokens",
+  totalTokens: "tokens",
+  prompt_tokens: "prompt_tokens",
+  input_tokens: "prompt_tokens",
+  completion_tokens: "completion_tokens",
+  output_tokens: "completion_tokens",
+  total_tokens: "tokens"
+};
+var TOKEN_DETAIL_PREFIX_MAP = {
+  promptTokensDetails: "prompt",
+  inputTokensDetails: "prompt",
+  completionTokensDetails: "completion",
+  outputTokensDetails: "completion",
+  costDetails: "cost",
+  prompt_tokens_details: "prompt",
+  input_tokens_details: "prompt",
+  completion_tokens_details: "completion",
+  output_tokens_details: "completion",
+  cost_details: "cost"
+};
+function camelToSnake(value) {
+  return value.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+}
+function parseOpenRouterMetricsFromUsage(usage) {
+  if (!isObject(usage)) {
+    return {};
+  }
   const metrics = {};
-  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;
+  for (const [name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      metrics[TOKEN_NAME_MAP2[name] || camelToSnake(name)] = value;
+      continue;
+    }
+    if (!isObject(value)) {
+      continue;
+    }
+    const prefix = TOKEN_DETAIL_PREFIX_MAP[name];
+    if (!prefix) {
+      continue;
+    }
+    for (const [nestedName, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${camelToSnake(nestedName)}`] = nestedValue;
     }
   }
   return metrics;
 }
-function 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 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;
 }
-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;
+var OMITTED_OPENROUTER_KEYS = /* @__PURE__ */ new Set([
+  "execute",
+  "render",
+  "nextTurnParams",
+  "requireApproval"
+]);
+function parseOpenRouterModelString(model) {
+  if (typeof model !== "string") {
+    return { model };
   }
-  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
-      }
-    }
-  });
+  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 finishOpenRouterCallModelTurnSpan(args) {
-  if (!isObject(args.response)) {
-    args.span.end();
-    return;
+function isZodSchema3(value) {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function serializeZodSchema3(schema) {
+  try {
+    return zodToJsonSchema(schema);
+  } catch (e36) {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
   }
-  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;
+function serializeOpenRouterTool(tool) {
+  if (!isObject(tool)) {
+    return tool;
   }
-  return request;
+  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 buildOpenRouterFollowupRequest(request, currentResponse, toolResults) {
-  if (!request) {
+function serializeOpenRouterToolsForLogging(tools) {
+  if (!Array.isArray(tools)) {
     return void 0;
   }
-  return {
-    ...request,
-    input: buildNextOpenRouterCallModelInput(
-      extractOpenRouterCallModelInput(request),
-      isObject(currentResponse) ? currentResponse : {},
-      toolResults
-    ),
-    stream: false
-  };
+  return tools.map((tool) => serializeOpenRouterTool(tool));
 }
-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 sanitizeOpenRouterLoggedValue(value) {
+  if (isZodSchema3(value)) {
+    return serializeZodSchema3(value);
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeOpenRouterLoggedValue(entry));
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (OMITTED_OPENROUTER_KEYS.has(key)) {
+      continue;
+    }
+    if (key === "tools" && Array.isArray(entry)) {
+      sanitized.tools = serializeOpenRouterToolsForLogging(entry);
+      continue;
     }
+    sanitized[key] = sanitizeOpenRouterLoggedValue(entry);
+  }
+  return sanitized;
+}
+function buildOpenRouterMetadata(metadata, httpReferer, 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 isAsyncIterable2(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+function buildOpenRouterEmbeddingMetadata(metadata, httpReferer, xTitle) {
+  const normalized = buildOpenRouterMetadata(metadata, httpReferer, xTitle);
+  return typeof normalized.model === "string" ? {
+    ...normalized,
+    embedding_model: normalized.model
+  } : normalized;
 }
-function isPromiseLike(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+function extractOpenRouterCallModelInput(request) {
+  return isObject(request) && "input" in request ? sanitizeOpenRouterLoggedValue(request.input) : void 0;
 }
-function normalizeError(error) {
-  return error instanceof Error ? error : new Error(String(error));
+function extractOpenRouterCallModelMetadata(request) {
+  if (!isObject(request)) {
+    return { provider: "openrouter" };
+  }
+  const { input: _input, ...metadata } = request;
+  return buildOpenRouterMetadata(metadata, void 0, void 0);
 }
-
-// src/instrumentation/plugins/openrouter-plugin.ts
-var OpenRouterPlugin = class extends BasePlugin {
-  onEnable() {
-    this.subscribeToOpenRouterChannels();
+function extractOpenRouterResponseMetadata(result) {
+  if (!isObject(result)) {
+    return void 0;
   }
-  onDisable() {
-    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  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);
   }
-  subscribeToOpenRouterChannels() {
-    this.unsubscribers.push(
-      traceStreamingChannel(openRouterChannels.chatSend, {
-        name: "openrouter.chat.send",
-        type: "llm" /* LLM */,
-        extractInput: (args) => {
-          const request = getOpenRouterRequestArg(args);
-          const chatGenerationParams = isObject(_optionalChain([request, 'optionalAccess', _282 => _282.chatGenerationParams])) ? request.chatGenerationParams : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _283 => _283.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _284 => _284.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(_optionalChain([result, 'optionalAccess', _285 => _285.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(_optionalChain([request, 'optionalAccess', _286 => _286.requestBody])) ? request.requestBody : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _287 => _287.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _288 => _288.xTitle]);
-          const { input, ...metadata } = requestBody;
-          return {
-            input,
-            metadata: buildOpenRouterEmbeddingMetadata(
-              metadata,
-              httpReferer,
-              xTitle
-            )
-          };
-        },
-        extractOutput: (result) => {
-          if (!isObject(result)) {
-            return void 0;
-          }
-          const embedding = _optionalChain([result, 'access', _289 => _289.data, 'optionalAccess', _290 => _290[0], 'optionalAccess', _291 => _291.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(_optionalChain([request, 'optionalAccess', _292 => _292.openResponsesRequest])) ? request.openResponsesRequest : {};
-          const httpReferer = _optionalChain([request, 'optionalAccess', _293 => _293.httpReferer]);
-          const xTitle = _optionalChain([request, 'optionalAccess', _294 => _294.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(_optionalChain([result, 'optionalAccess', _295 => _295.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);
-    });
+  if (fallbackOutput !== void 0) {
+    return sanitizeOpenRouterLoggedValue(fallbackOutput);
   }
-};
-function normalizeArgs(args) {
-  if (Array.isArray(args)) {
-    return args;
+  return void 0;
+}
+var OPENROUTER_WRAPPED_TOOL = Symbol("braintrust.openrouter.wrappedTool");
+function patchOpenRouterCallModelRequestTools(request) {
+  if (!Array.isArray(request.tools) || request.tools.length === 0) {
+    return void 0;
   }
-  if (isArrayLike(args)) {
-    return Array.from(args);
+  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;
   }
-  return [args];
+  request.tools = wrappedTools;
+  return () => {
+    request.tools = originalTools;
+  };
+}
+function wrapOpenRouterTool(tool) {
+  if (isWrappedTool(tool) || !tool.function || typeof tool.function !== "object" || typeof tool.function.execute !== "function") {
+    return tool;
+  }
+  const toolName = tool.function.name || "tool";
+  const originalExecute = tool.function.execute;
+  const wrappedTool = {
+    ...tool,
+    function: {
+      ...tool.function,
+      execute(...args) {
+        return traceToolExecution({
+          args,
+          execute: () => Reflect.apply(originalExecute, this, args),
+          toolCallId: getToolCallId(args[1]),
+          toolName
+        });
+      }
+    }
+  };
+  Object.defineProperty(wrappedTool, OPENROUTER_WRAPPED_TOOL, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  return wrappedTool;
+}
+function isWrappedTool(tool) {
+  return Boolean(tool[OPENROUTER_WRAPPED_TOOL]);
 }
-function isArrayLike(value) {
-  return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
+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 (error) {
+    event.error = normalizeError(error);
+    tracingChannel2.error.publish(event);
+    throw error;
+  }
 }
-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;
+function publishToolResult(tracingChannel2, event, result) {
+  if (isPromiseLike2(result)) {
+    return result.then(
+      (resolved) => {
+        event.result = resolved;
+        tracingChannel2.asyncEnd.publish(event);
+        return resolved;
+      },
+      (error) => {
+        event.error = normalizeError(error);
+        tracingChannel2.error.publish(event);
+        throw error;
+      }
+    );
   }
-  const firstObjectArg = normalizedArgs.find((arg) => isObject(arg));
-  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+  event.result = result;
+  tracingChannel2.asyncEnd.publish(event);
+  return result;
 }
-function getOpenRouterCallModelRequestArg(args) {
-  const firstObjectArg = normalizeArgs(args).find((arg) => isObject(arg));
-  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+function getToolCallId(context) {
+  const toolContext = context;
+  return typeof _optionalChain([toolContext, 'optionalAccess', _299 => _299.toolCall, 'optionalAccess', _300 => _300.id]) === "string" ? toolContext.toolCall.id : void 0;
+}
+function isPromiseLike2(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
 }
 function aggregateOpenRouterChatChunks(chunks) {
   let role;
@@ -13874,105 +14030,448 @@ function aggregateOpenRouterChatChunks(chunks) {
   for (const chunk of chunks) {
     metrics = {
       ...metrics,
-      ...parseOpenRouterMetricsFromUsage(_optionalChain([chunk, 'optionalAccess', _296 => _296.usage]))
+      ...parseOpenRouterMetricsFromUsage(_optionalChain([chunk, 'optionalAccess', _301 => _301.usage]))
+    };
+    const choice = _optionalChain([chunk, 'optionalAccess', _302 => _302.choices, 'optionalAccess', _303 => _303[0]]);
+    const delta = _optionalChain([choice, 'optionalAccess', _304 => _304.delta]);
+    if (!delta) {
+      if (_optionalChain([choice, 'optionalAccess', _305 => _305.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 = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _306 => _306.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _307 => _307.finish_reason]))), () => ( void 0));
+    const deltaFinishReason = _nullishCoalesce(_nullishCoalesce(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 (!_optionalChain([toolDelta, 'optionalAccess', _308 => _308.function])) {
+        continue;
+      }
+      const toolIndex = _nullishCoalesce(toolDelta.index, () => ( 0));
+      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _309 => _309[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 = _optionalChain([chunk, 'optionalAccess', _310 => _310.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) } : {}
+  };
+}
+var OPENROUTER_WRAPPED_CALL_MODEL_RESULT = Symbol(
+  "braintrust.openrouter.wrappedCallModelResult"
+);
+var OPENROUTER_CALL_MODEL_STREAM_METHODS = [
+  "getFullResponsesStream",
+  "getItemsStream",
+  "getNewMessagesStream",
+  "getReasoningStream",
+  "getTextStream",
+  "getToolCallsStream",
+  "getToolStream"
+];
+var OPENROUTER_CALL_MODEL_CONTEXT_METHODS = [
+  "cancel",
+  "getPendingToolCalls",
+  "getState",
+  "getToolCalls",
+  "requiresApproval"
+];
+function patchOpenRouterCallModelResult(args) {
+  const { request, result, span } = args;
+  if (!isObject(result) || isWrappedCallModelResult(result)) {
+    return false;
+  }
+  const resultLike = result;
+  const hasInstrumentableMethod = typeof resultLike.getResponse === "function" || typeof resultLike.getText === "function" || OPENROUTER_CALL_MODEL_STREAM_METHODS.some(
+    (methodName) => typeof resultLike[methodName] === "function"
+  );
+  if (!hasInstrumentableMethod) {
+    return false;
+  }
+  Object.defineProperty(resultLike, OPENROUTER_WRAPPED_CALL_MODEL_RESULT, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  const originalGetResponse = typeof resultLike.getResponse === "function" ? resultLike.getResponse.bind(resultLike) : void 0;
+  const originalGetInitialResponse = typeof resultLike.getInitialResponse === "function" ? resultLike.getInitialResponse.bind(resultLike) : void 0;
+  const originalMakeFollowupRequest = typeof resultLike.makeFollowupRequest === "function" ? resultLike.makeFollowupRequest.bind(resultLike) : void 0;
+  let ended = false;
+  let tracedTurnCount = 0;
+  const endSpanWithResult = async (response, fallbackOutput) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    const finalResponse = getFinalOpenRouterCallModelResponse(
+      resultLike,
+      response
+    );
+    if (finalResponse) {
+      const rounds = getOpenRouterCallModelRounds(resultLike);
+      const metadata = extractOpenRouterCallModelResultMetadata(
+        finalResponse,
+        rounds.length + 1
+      );
+      span.log({
+        output: extractOpenRouterResponseOutput(finalResponse, fallbackOutput),
+        ...metadata ? { metadata } : {},
+        metrics: aggregateOpenRouterCallModelMetrics(rounds, finalResponse)
+      });
+      span.end();
+      return;
+    }
+    if (fallbackOutput !== void 0) {
+      span.log({
+        output: fallbackOutput
+      });
+    }
+    span.end();
+  };
+  const endSpanWithError = (error) => {
+    if (ended) {
+      return;
+    }
+    ended = true;
+    span.log({
+      error: normalizeError(error).message
+    });
+    span.end();
+  };
+  const finalizeFromResponse = async (fallbackOutput) => {
+    if (!originalGetResponse) {
+      await endSpanWithResult(void 0, fallbackOutput);
+      return;
+    }
+    try {
+      await endSpanWithResult(await originalGetResponse(), fallbackOutput);
+    } catch (e37) {
+      await endSpanWithResult(void 0, fallbackOutput);
+    }
+  };
+  if (originalGetResponse) {
+    resultLike.getResponse = async (...args2) => {
+      return await withCurrent(span, async () => {
+        try {
+          const response = await originalGetResponse(...args2);
+          await endSpanWithResult(response);
+          return response;
+        } catch (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
+    };
+  }
+  if (typeof resultLike.getText === "function") {
+    const originalGetText = resultLike.getText.bind(resultLike);
+    resultLike.getText = async (...args2) => {
+      return await withCurrent(span, async () => {
+        try {
+          const text = await originalGetText(...args2);
+          await finalizeFromResponse(text);
+          return text;
+        } catch (error) {
+          endSpanWithError(error);
+          throw error;
+        }
+      });
     };
-    const choice = _optionalChain([chunk, 'optionalAccess', _297 => _297.choices, 'optionalAccess', _298 => _298[0]]);
-    const delta = _optionalChain([choice, 'optionalAccess', _299 => _299.delta]);
-    if (!delta) {
-      if (_optionalChain([choice, 'optionalAccess', _300 => _300.finish_reason]) !== void 0) {
-        finishReason = choice.finish_reason;
-      }
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_CONTEXT_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
       continue;
     }
-    if (!role && delta.role) {
-      role = delta.role;
-    }
-    if (typeof delta.content === "string") {
-      content += delta.content;
-    }
-    const choiceFinishReason = _nullishCoalesce(_nullishCoalesce(_optionalChain([choice, 'optionalAccess', _301 => _301.finishReason]), () => ( _optionalChain([choice, 'optionalAccess', _302 => _302.finish_reason]))), () => ( void 0));
-    const deltaFinishReason = _nullishCoalesce(_nullishCoalesce(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) {
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = async (...args2) => {
+      return await withCurrent(span, async () => {
+        return await originalMethod.apply(resultLike, args2);
+      });
+    };
+  }
+  for (const methodName of OPENROUTER_CALL_MODEL_STREAM_METHODS) {
+    if (typeof resultLike[methodName] !== "function") {
       continue;
     }
-    for (const toolDelta of toolCallDeltas) {
-      if (!_optionalChain([toolDelta, 'optionalAccess', _303 => _303.function])) {
-        continue;
-      }
-      const toolIndex = _nullishCoalesce(toolDelta.index, () => ( 0));
-      const existingToolCall = _optionalChain([toolCalls, 'optionalAccess', _304 => _304[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;
+    const originalMethod = resultLike[methodName];
+    resultLike[methodName] = (...args2) => {
+      const stream = withCurrent(
+        span,
+        () => originalMethod.apply(resultLike, args2)
+      );
+      if (!isAsyncIterable2(stream)) {
+        return stream;
       }
-      if (toolDelta.function.name && !current.function.name) {
-        current.function.name = toolDelta.function.name;
+      return wrapAsyncIterableWithSpan({
+        finalize: finalizeFromResponse,
+        iteratorFactory: () => stream[Symbol.asyncIterator](),
+        onError: endSpanWithError,
+        span
+      });
+    };
+  }
+  if (originalGetInitialResponse) {
+    let initialTurnTraced = false;
+    resultLike.getInitialResponse = async (...args2) => {
+      if (initialTurnTraced) {
+        return await withCurrent(span, async () => {
+          return await originalGetInitialResponse(...args2);
+        });
       }
-      current.function.arguments += toolDelta.function.arguments || "";
-    }
+      initialTurnTraced = true;
+      const step = tracedTurnCount + 1;
+      const stepType = tracedTurnCount === 0 ? "initial" : "continue";
+      const response = await traceOpenRouterCallModelTurn({
+        fn: async () => {
+          const nextResponse = await originalGetInitialResponse(...args2);
+          tracedTurnCount++;
+          return nextResponse;
+        },
+        parentSpan: span,
+        request: getOpenRouterResolvedRequest(resultLike, request),
+        step,
+        stepType
+      });
+      return response;
+    };
   }
-  return {
-    output: [
-      {
-        index: 0,
-        message: {
-          role,
-          content: content || void 0,
-          ...toolCalls ? { tool_calls: toolCalls } : {}
+  if (originalMakeFollowupRequest) {
+    resultLike.makeFollowupRequest = async (...args2) => {
+      const currentResponse = args2[0];
+      const toolResults = Array.isArray(args2[1]) ? args2[1] : [];
+      const step = tracedTurnCount + 1;
+      const response = await traceOpenRouterCallModelTurn({
+        fn: async () => {
+          const nextResponse = await originalMakeFollowupRequest(...args2);
+          tracedTurnCount++;
+          return nextResponse;
         },
-        logprobs: null,
-        finish_reason: finishReason
-      }
-    ],
-    metrics
+        parentSpan: span,
+        request: buildOpenRouterFollowupRequest(
+          getOpenRouterResolvedRequest(resultLike, request),
+          currentResponse,
+          toolResults
+        ),
+        step,
+        stepType: "continue"
+      });
+      return response;
+    };
+  }
+  return true;
+}
+async function traceOpenRouterCallModelTurn(args) {
+  const context = {
+    arguments: [args.request],
+    step: args.step,
+    stepType: args.stepType
   };
+  return await withCurrent(
+    args.parentSpan,
+    () => openRouterChannels.callModelTurn.tracePromise(args.fn, context)
+  );
 }
-function aggregateOpenRouterResponseStreamEvents(chunks) {
-  let finalResponse;
-  for (const chunk of chunks) {
-    const response = _optionalChain([chunk, 'optionalAccess', _305 => _305.response]);
-    if (!response) {
-      continue;
-    }
-    if (chunk.type === "response.completed" || chunk.type === "response.incomplete" || chunk.type === "response.failed") {
-      finalResponse = response;
+function isWrappedCallModelResult(value) {
+  return Boolean(
+    isObject(value) && value[OPENROUTER_WRAPPED_CALL_MODEL_RESULT]
+  );
+}
+function extractOpenRouterCallModelResultMetadata(response, turnCount) {
+  const combined = {
+    ...extractOpenRouterResponseMetadata(response) || {},
+    ...turnCount !== void 0 ? { turn_count: turnCount } : {}
+  };
+  return Object.keys(combined).length > 0 ? combined : void 0;
+}
+function getFinalOpenRouterCallModelResponse(result, response) {
+  if (isObject(response)) {
+    return response;
+  }
+  return isObject(result.finalResponse) ? result.finalResponse : void 0;
+}
+function getOpenRouterCallModelRounds(result) {
+  if (!Array.isArray(result.allToolExecutionRounds)) {
+    return [];
+  }
+  return result.allToolExecutionRounds.filter((round) => isObject(round)).map((round) => ({
+    response: isObject(round.response) ? round.response : void 0,
+    round: typeof round.round === "number" ? round.round : void 0,
+    toolResults: Array.isArray(round.toolResults) ? round.toolResults : []
+  })).filter((round) => round.response !== void 0);
+}
+function aggregateOpenRouterCallModelMetrics(rounds, finalResponse) {
+  const metrics = {};
+  const responses = [
+    ...rounds.map((round) => round.response).filter(isObject),
+    finalResponse
+  ];
+  for (const response of responses) {
+    const responseMetrics = parseOpenRouterMetricsFromUsage(response.usage);
+    for (const [name, value] of Object.entries(responseMetrics)) {
+      metrics[name] = (metrics[name] || 0) + value;
     }
   }
-  if (!finalResponse) {
-    return {
-      output: void 0,
-      metrics: {}
-    };
+  return metrics;
+}
+function buildNextOpenRouterCallModelInput(currentInput, response, toolResults) {
+  const normalizedInput = Array.isArray(currentInput) ? [...currentInput] : currentInput === void 0 ? [] : [currentInput];
+  const responseOutput = Array.isArray(response.output) ? response.output : response.output === void 0 ? [] : [response.output];
+  return [...normalizedInput, ...responseOutput, ...toolResults].map(
+    (entry) => sanitizeOpenRouterLoggedValue(entry)
+  );
+}
+function getOpenRouterResolvedRequest(result, request) {
+  if (isObject(result.resolvedRequest)) {
+    return result.resolvedRequest;
+  }
+  return request;
+}
+function buildOpenRouterFollowupRequest(request, currentResponse, toolResults) {
+  if (!request) {
+    return void 0;
   }
   return {
-    output: extractOpenRouterResponseOutput(finalResponse),
-    metrics: parseOpenRouterMetricsFromUsage(finalResponse.usage),
-    ...extractOpenRouterResponseMetadata(finalResponse) ? { metadata: extractOpenRouterResponseMetadata(finalResponse) } : {}
+    ...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 normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
 
 // src/instrumentation/braintrust-plugin.ts
 var BraintrustPlugin = (_class18 = class extends BasePlugin {
@@ -15365,7 +15864,7 @@ var CachedSpanFetcher = (_class20 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _306 => _306.span_attributes, 'optionalAccess', _307 => _307.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _311 => _311.span_attributes, 'optionalAccess', _312 => _312.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -15399,7 +15898,7 @@ var CachedSpanFetcher = (_class20 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _308 => _308.span_attributes, 'optionalAccess', _309 => _309.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _313 => _313.span_attributes, 'optionalAccess', _314 => _314.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -15479,11 +15978,11 @@ var LocalTrace = (_class21 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _310 => _310.span_attributes, 'optionalAccess', _311 => _311.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _315 => _315.span_attributes, 'optionalAccess', _316 => _316.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _312 => _312.span_attributes, 'optionalAccess', _313 => _313.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _317 => _317.span_attributes, 'optionalAccess', _318 => _318.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -15502,7 +16001,7 @@ var LocalTrace = (_class21 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _314 => _314.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _319 => _319.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -15513,7 +16012,7 @@ var LocalTrace = (_class21 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _315 => _315.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _320 => _320.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -15689,13 +16188,34 @@ function validateParametersWithJsonSchema(parameters, schema) {
   const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
   const validate = ajv.compile(schema);
   if (!validate(parameters)) {
-    const errorMessages = _optionalChain([validate, 'access', _316 => _316.errors, 'optionalAccess', _317 => _317.map, 'call', _318 => _318((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _321 => _321.errors, 'optionalAccess', _322 => _322.map, 'call', _323 => _323((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _319 => _319.join, 'call', _320 => _320(", ")]);
+    }), 'access', _324 => _324.join, 'call', _325 => _325(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
-  return parameters;
+  return rehydrateRemoteParameters(parameters, schema);
+}
+function rehydrateRemoteParameters(parameters, schema) {
+  const schemaProperties = schema.properties;
+  if (typeof schemaProperties !== "object" || schemaProperties === null) {
+    return parameters;
+  }
+  return Object.fromEntries(
+    Object.entries(parameters).map(([name, value]) => {
+      const propertySchema = Reflect.get(schemaProperties, name);
+      if (typeof propertySchema !== "object" || propertySchema === null) {
+        return [name, value];
+      }
+      if (Reflect.get(propertySchema, "x-bt-type") === "prompt") {
+        return [
+          name,
+          Prompt2.fromPromptData(name, PromptData.parse(value))
+        ];
+      }
+      return [name, value];
+    })
+  );
 }
 
 // src/framework.ts
@@ -15930,7 +16450,7 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters, st
 }
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _321 => _321.spanCache, 'optionalAccess', _322 => _322.start, 'call', _323 => _323()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _326 => _326.spanCache, 'optionalAccess', _327 => _327.start, 'call', _328 => _328()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -15985,7 +16505,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const experimentIdPromise = experiment ? (async () => {
       try {
         return await experiment.id;
-      } catch (e32) {
+      } catch (e38) {
         return void 0;
       }
     })() : void 0;
@@ -16041,7 +16561,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _324 => _324.data, 'access', async _325 => _325.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _329 => _329.data, 'access', async _330 => _330.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -16067,10 +16587,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _326 => _326({
+                    _optionalChain([stream, 'optionalCall', _331 => _331({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _327 => _327.event, 'optionalAccess', _328 => _328.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _332 => _332.event, 'optionalAccess', _333 => _333.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -16234,7 +16754,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _329 => _329.event, 'optionalAccess', _330 => _330.origin])
+              origin: _optionalChain([baseEvent, 'access', _334 => _334.event, 'optionalAccess', _335 => _335.origin])
             });
           }
         };
@@ -16269,7 +16789,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _331 => _331.setTotal, 'optionalCall', _332 => _332(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _336 => _336.setTotal, 'optionalCall', _337 => _337(evaluator.evalName, scheduledTrials)]);
           q.pushAsync({ datum, trialIndex }).catch((e) => {
             if (queueErrors.length < 5) {
               queueErrors.push(e);
@@ -16354,9 +16874,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _333 => _333.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _334 => _334.dispose, 'call', _335 => _335()]);
-      _optionalChain([spanCache, 'optionalAccess', _336 => _336.stop, 'call', _337 => _337()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _338 => _338.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _339 => _339.dispose, 'call', _340 => _340()]);
+      _optionalChain([spanCache, 'optionalAccess', _341 => _341.stop, 'call', _342 => _342()]);
     }
   }
 }
@@ -16593,7 +17113,7 @@ async function cachedLogin(options) {
 }
 function makeCheckAuthorized(allowedOrgName) {
   return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _338 => _338.ctx, 'optionalAccess', _339 => _339.token])) {
+    if (!_optionalChain([req, 'access', _343 => _343.ctx, 'optionalAccess', _344 => _344.token])) {
       return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
     try {
@@ -16606,7 +17126,7 @@ function makeCheckAuthorized(allowedOrgName) {
         return next(_httperrors2.default.call(void 0, 403, errorMessage));
       }
       const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _340 => _340.ctx, 'optionalAccess', _341 => _341.token]),
+        apiKey: _optionalChain([req, 'access', _345 => _345.ctx, 'optionalAccess', _346 => _346.token]),
         orgName
       });
       req.ctx.state = state;
@@ -16930,7 +17450,8 @@ var ScorerBuilder = (_class24 = class {
           type: "llm_classifier",
           use_cot: opts.useCot,
           choice_scores: opts.choiceScores
-        }
+        },
+        ...opts.templateFormat ? { template_format: opts.templateFormat } : {}
       };
       const codePrompt = new CodePrompt(
         this.project,
@@ -17355,7 +17876,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _342 => _342.ctx, 'optionalAccess', _343 => _343.state])) {
+      if (!_optionalChain([req, 'access', _347 => _347.ctx, 'optionalAccess', _348 => _348.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -17406,12 +17927,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: evaluator.scores.concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _344 => _344.map, 'call', _345 => _345(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _349 => _349.map, 'call', _350 => _350(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _346 => _346.ctx, 'optionalAccess', _347 => _347.projectId])
+                  _optionalChain([req, 'access', _351 => _351.ctx, 'optionalAccess', _352 => _352.projectId])
                 )
               )]), () => ( []))
             ),