braintrust 3.4.0 → 3.5.0

package/dev/dist/index.js

@@ -22,8 +22,54 @@ var DefaultAsyncLocalStorage = class {
     return void 0;
   }
 };
-var DefaultTracingChannel = (_class = class {constructor() { _class.prototype.__init.call(this); }
+var DefaultChannel = (_class = class {
+  constructor(name) {;_class.prototype.__init.call(this);
+    this.name = name;
+  }
   __init() {this.hasSubscribers = false}
+  subscribe(_subscription) {
+  }
+  unsubscribe(_subscription) {
+    return false;
+  }
+  bindStore(_store, _transform) {
+  }
+  unbindStore(_store) {
+    return false;
+  }
+  publish(_message) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runStores(_message, fn, thisArg, ...args) {
+    return fn.apply(thisArg, args);
+  }
+}, _class);
+var DefaultTracingChannel = class {
+  
+  
+  
+  
+  
+  constructor(nameOrChannels) {
+    if (typeof nameOrChannels === "string") {
+      this.start = new DefaultChannel(`tracing:${nameOrChannels}:start`);
+      this.end = new DefaultChannel(`tracing:${nameOrChannels}:end`);
+      this.asyncStart = new DefaultChannel(
+        `tracing:${nameOrChannels}:asyncStart`
+      );
+      this.asyncEnd = new DefaultChannel(`tracing:${nameOrChannels}:asyncEnd`);
+      this.error = new DefaultChannel(`tracing:${nameOrChannels}:error`);
+      return;
+    }
+    this.start = _nullishCoalesce(nameOrChannels.start, () => ( new DefaultChannel("tracing:start")));
+    this.end = _nullishCoalesce(nameOrChannels.end, () => ( new DefaultChannel("tracing:end")));
+    this.asyncStart = _nullishCoalesce(nameOrChannels.asyncStart, () => ( new DefaultChannel("tracing:asyncStart")));
+    this.asyncEnd = _nullishCoalesce(nameOrChannels.asyncEnd, () => ( new DefaultChannel("tracing:asyncEnd")));
+    this.error = _nullishCoalesce(nameOrChannels.error, () => ( new DefaultChannel("tracing:error")));
+  }
+  get hasSubscribers() {
+    return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers || this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
+  }
   subscribe(_handlers) {
   }
   unsubscribe(_handlers) {
@@ -41,7 +87,7 @@ var DefaultTracingChannel = (_class = class {constructor() { _class.prototype.__
   traceCallback(fn, _position, _message, thisArg, ...args) {
     return fn.apply(thisArg, args);
   }
-}, _class);
+};
 var iso = {
   buildType: "unknown",
   // Will be set by configureBrowser() or configureNode()
@@ -51,7 +97,7 @@ var iso = {
   getCallerLocation: () => void 0,
   newAsyncLocalStorage: () => new DefaultAsyncLocalStorage(),
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  newTracingChannel: (_nameOrChannels) => new DefaultTracingChannel(),
+  newTracingChannel: (nameOrChannels) => new DefaultTracingChannel(nameOrChannels),
   processOn: (_0, _1) => {
   },
   basename: (filepath) => filepath.split(/[\\/]/).pop() || filepath,
@@ -2334,6 +2380,8 @@ var Experiment = _v3.z.object({
   deleted_at: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   dataset_id: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   dataset_version: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  parameters_id: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  parameters_version: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   public: _v3.z.boolean(),
   user_id: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
   metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional(),
@@ -2356,7 +2404,11 @@ var SpanType = _v3.z.union([
   _v3.z.null()
 ]);
 var SpanAttributes = _v3.z.union([
-  _v3.z.object({ name: _v3.z.union([_v3.z.string(), _v3.z.null()]), type: SpanType }).partial().passthrough(),
+  _v3.z.object({
+    name: _v3.z.union([_v3.z.string(), _v3.z.null()]),
+    type: SpanType,
+    purpose: _v3.z.union([_v3.z.literal("scorer"), _v3.z.null()])
+  }).partial().passthrough(),
   _v3.z.null()
 ]);
 var ExperimentEvent = _v3.z.object({
@@ -2796,6 +2848,7 @@ var FunctionId = _v3.z.union([
       version: _v3.z.string()
     }),
     code: _v3.z.string(),
+    function_type: FunctionTypeEnum.and(_v3.z.unknown()).optional(),
     name: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional()
   }),
   _v3.z.object({
@@ -3025,7 +3078,12 @@ var TopicAutomationConfig = _v3.z.object({
   topic_map_functions: _v3.z.array(TopicMapFunctionAutomation),
   scope: _v3.z.union([SpanScope, TraceScope, GroupScope, _v3.z.null()]).optional(),
   data_scope: TopicAutomationDataScope.optional(),
-  btql_filter: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional()
+  btql_filter: _v3.z.union([_v3.z.string(), _v3.z.null()]).optional(),
+  backfill_time_range: _v3.z.union([
+    _v3.z.string(),
+    _v3.z.object({ from: _v3.z.string(), to: _v3.z.string() }),
+    _v3.z.null()
+  ]).optional()
 });
 var ProjectAutomation = _v3.z.object({
   id: _v3.z.string().uuid(),
@@ -4464,6 +4522,12 @@ var parametersRowSchema = _v3.z.object({
   }),
   metadata: _v3.z.union([_v3.z.object({}).partial().passthrough(), _v3.z.null()]).optional()
 });
+var InlineAttachmentReferenceSchema = _v3.z.object({
+  type: _v3.z.literal("inline_attachment"),
+  src: _v3.z.string().min(1),
+  content_type: _v3.z.string().optional(),
+  filename: _v3.z.string().optional()
+});
 var LoginInvalidOrgError = class extends Error {
   constructor(message) {
     super(message);
@@ -6453,6 +6517,7 @@ function init(projectOrOptions, optionalOptions) {
     experiment,
     description,
     dataset,
+    parameters,
     baseExperiment,
     isPublic,
     open: open2,
@@ -6570,6 +6635,17 @@ function init(projectOrOptions, optionalOptions) {
           args["dataset_version"] = await dataset.version();
         }
       }
+      if (parameters !== void 0) {
+        if (RemoteEvalParameters.isParameters(parameters)) {
+          args["parameters_id"] = parameters.id;
+          args["parameters_version"] = parameters.version;
+        } else {
+          args["parameters_id"] = parameters.id;
+          if (parameters.version !== void 0) {
+            args["parameters_version"] = parameters.version;
+          }
+        }
+      }
       if (isPublic !== void 0) {
         args["public"] = isPublic;
       }
@@ -8221,40 +8297,82 @@ var Dataset2 = (_class14 = class extends ObjectFetcher {
     return typeof data === "object" && data !== null && "__braintrust_dataset_marker" in data;
   }
 }, _class14);
-function renderMessage(render, message) {
+function isAttachmentObject(value) {
+  return BraintrustAttachmentReference.safeParse(value).success || InlineAttachmentReferenceSchema.safeParse(value).success || ExternalAttachmentReference.safeParse(value).success;
+}
+function isURL(url) {
+  try {
+    const parsedUrl = new URL(url.trim());
+    return parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+  } catch (e18) {
+    return false;
+  }
+}
+function expandAttachmentArrayPreTemplate(content, variables) {
+  if (typeof content !== "string") return null;
+  const match = content.match(/^\{\{\s*([\w.]+)\s*\}\}$/);
+  if (!match) return null;
+  const varPath = match[1];
+  const value = varPath.includes(".") ? getObjValueByPath(variables, varPath.split(".")) : variables[varPath];
+  if (!Array.isArray(value)) return null;
+  const allValid = value.every(
+    (v) => isAttachmentObject(v) || typeof v === "string" && isURL(v)
+  );
+  if (!allValid) return null;
+  return value.map((item) => ({
+    type: "image_url",
+    image_url: { url: item }
+  }));
+}
+function renderMessageImpl(render, message, variables) {
   return {
     ...message,
     ..."content" in message ? {
-      content: isEmpty2(message.content) ? void 0 : typeof message.content === "string" ? render(message.content) : message.content.map((c) => {
+      content: isEmpty2(message.content) ? void 0 : typeof message.content === "string" ? render(message.content) : message.content.flatMap((c) => {
         switch (c.type) {
           case "text":
-            return { ...c, text: render(c.text) };
+            return [{ ...c, text: render(c.text) }];
           case "image_url":
             if (isObject(c.image_url.url)) {
               throw new Error(
                 "Attachments must be replaced with URLs before calling `build()`"
               );
             }
-            return {
-              ...c,
-              image_url: {
-                ...c.image_url,
-                url: render(c.image_url.url)
+            if (variables) {
+              const expanded = expandAttachmentArrayPreTemplate(
+                c.image_url.url,
+                variables
+              );
+              if (expanded) {
+                return expanded;
               }
-            };
+            }
+            return [
+              {
+                ...c,
+                image_url: {
+                  ...c.image_url,
+                  url: render(c.image_url.url)
+                }
+              }
+            ];
           case "file":
-            return {
-              ...c,
-              file: {
-                file_data: render(c.file.file_data || ""),
-                ...c.file.file_id && {
-                  file_id: render(c.file.file_id)
-                },
-                ...c.file.filename && {
-                  filename: render(c.file.filename)
+            return [
+              {
+                ...c,
+                file: {
+                  ...c.file.file_data && {
+                    file_data: render(c.file.file_data)
+                  },
+                  ...c.file.file_id && {
+                    file_id: render(c.file.file_id)
+                  },
+                  ...c.file.filename && {
+                    filename: render(c.file.filename)
+                  }
                 }
               }
-            };
+            ];
           default:
             const _exhaustiveCheck = c;
             return _exhaustiveCheck;
@@ -8411,17 +8529,19 @@ var Prompt2 = (_class15 = class _Prompt {
   }
   runBuild(buildArgs, options) {
     const { flavor } = options;
-    const params = {
-      ...this.defaults,
-      ...Object.fromEntries(
-        Object.entries(this.options.params || {}).filter(
-          ([k, _v]) => !BRAINTRUST_PARAMS.includes(k)
-        )
-      ),
-      ...!isEmpty2(this.options.model) ? {
-        model: this.options.model
-      } : {}
-    };
+    const params = Object.fromEntries(
+      Object.entries({
+        ...this.defaults,
+        ...Object.fromEntries(
+          Object.entries(this.options.params || {}).filter(
+            ([k, _v]) => !BRAINTRUST_PARAMS.includes(k)
+          )
+        ),
+        ...!isEmpty2(this.options.model) ? {
+          model: this.options.model
+        } : {}
+      }).filter(([key, value]) => key !== "response_format" || value !== null)
+    );
     if (!("model" in params) || isEmpty2(params.model)) {
       throw new Error(
         "No model specified. Either specify it in the prompt or as a default"
@@ -8521,7 +8641,7 @@ var Prompt2 = (_class15 = class _Prompt {
         templateFormat
       });
       const baseMessages = (prompt.messages || []).map(
-        (m) => renderMessage(render, m)
+        (m) => renderMessageImpl(render, m, variables)
       );
       const hasSystemPrompt = baseMessages.some((m) => m.role === "system");
       const messages = [
@@ -9149,7 +9269,11 @@ function startSpanForEvent(config, event, channelName) {
   });
   const startTime = getCurrentUnixTimestamp();
   try {
-    const { input, metadata } = config.extractInput(event.arguments);
+    const { input, metadata } = config.extractInput(
+      event.arguments,
+      event,
+      span
+    );
     span.log({
       input,
       metadata: mergeInputMetadata(metadata, spanInfoMetadata)
@@ -9313,6 +9437,16 @@ function traceStreamingChannel(channel2, config) {
         });
         return;
       }
+      if (_optionalChain([config, 'access', _115 => _115.patchResult, 'optionalCall', _116 => _116({
+        channelName,
+        endEvent: asyncEndEvent,
+        result: asyncEndEvent.result,
+        span,
+        startTime
+      })])) {
+        states.delete(event);
+        return;
+      }
       try {
         const output = config.extractOutput(
           asyncEndEvent.result,
@@ -9323,7 +9457,7 @@ function traceStreamingChannel(channel2, config) {
           startTime,
           asyncEndEvent
         );
-        const metadata = _optionalChain([config, 'access', _115 => _115.extractMetadata, 'optionalCall', _116 => _116(
+        const metadata = _optionalChain([config, 'access', _117 => _117.extractMetadata, 'optionalCall', _118 => _118(
           asyncEndEvent.result,
           asyncEndEvent
         )]);
@@ -9369,8 +9503,17 @@ function traceSyncStreamChannel(channel2, config) {
         return;
       }
       const { span, startTime } = spanData;
-      const resultEvent = event;
-      const stream = resultEvent.result;
+      const endEvent = event;
+      if (_optionalChain([config, 'access', _119 => _119.patchResult, 'optionalCall', _120 => _120({
+        channelName,
+        endEvent,
+        result: endEvent.result,
+        span,
+        startTime
+      })])) {
+        return;
+      }
+      const stream = endEvent.result;
       if (!isSyncStreamLike(stream)) {
         span.end();
         states.delete(event);
@@ -9502,7 +9645,7 @@ function convertDataToBlob(data, mediaType) {
     } else if (typeof Buffer !== "undefined" && data instanceof Buffer) {
       return new Blob([data], { type: mediaType });
     }
-  } catch (e18) {
+  } catch (e19) {
     return null;
   }
   return null;
@@ -9514,7 +9657,7 @@ function processInputAttachments(input) {
   let attachmentIndex = 0;
   const inferMediaTypeFromDataUrl = (value, fallback2) => {
     const mediaTypeMatch = value.match(/^data:([^;]+);/);
-    return _optionalChain([mediaTypeMatch, 'optionalAccess', _117 => _117[1]]) || fallback2;
+    return _optionalChain([mediaTypeMatch, 'optionalAccess', _121 => _121[1]]) || fallback2;
   };
   const toAttachment = (value, mediaType, filename) => {
     const blob = convertDataToBlob(value, mediaType);
@@ -9764,11 +9907,11 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _118 => _118.choices]);
+          return _optionalChain([result, 'optionalAccess', _122 => _122.choices]);
         },
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _119 => _119.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _123 => _123.usage])),
             result,
             endEvent
           );
@@ -9792,12 +9935,12 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          const embedding = _optionalChain([result, 'optionalAccess', _120 => _120.data, 'optionalAccess', _121 => _121[0], 'optionalAccess', _122 => _122.embedding]);
+          const embedding = _optionalChain([result, 'optionalAccess', _124 => _124.data, 'optionalAccess', _125 => _125[0], 'optionalAccess', _126 => _126.embedding]);
           return Array.isArray(embedding) ? { embedding_length: embedding.length } : void 0;
         },
         extractMetrics: (result, _startTime, endEvent) => {
           return withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _123 => _123.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _127 => _127.usage])),
             result,
             endEvent
           );
@@ -9816,11 +9959,11 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _124 => _124.choices]);
+          return _optionalChain([result, 'optionalAccess', _128 => _128.choices]);
         },
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _125 => _125.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _129 => _129.usage])),
             result,
             endEvent
           );
@@ -9857,11 +10000,11 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return _optionalChain([result, 'optionalAccess', _126 => _126.results]);
+          return _optionalChain([result, 'optionalAccess', _130 => _130.results]);
         },
         extractMetrics: (result, _startTime, endEvent) => {
           return withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _127 => _127.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _131 => _131.usage])),
             result,
             endEvent
           );
@@ -9880,7 +10023,7 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _128 => _128.output]));
+          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _132 => _132.output]));
         },
         extractMetadata: (result) => {
           if (!result) {
@@ -9891,7 +10034,7 @@ var OpenAIPlugin = class extends BasePlugin {
         },
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _129 => _129.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _133 => _133.usage])),
             result,
             endEvent
           );
@@ -9944,7 +10087,7 @@ var OpenAIPlugin = class extends BasePlugin {
           };
         },
         extractOutput: (result) => {
-          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _130 => _130.output]));
+          return processImagesInOutput(_optionalChain([result, 'optionalAccess', _134 => _134.output]));
         },
         extractMetadata: (result) => {
           if (!result) {
@@ -9955,7 +10098,7 @@ var OpenAIPlugin = class extends BasePlugin {
         },
         extractMetrics: (result, startTime, endEvent) => {
           const metrics = withCachedMetric(
-            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _131 => _131.usage])),
+            parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _135 => _135.usage])),
             result,
             endEvent
           );
@@ -10051,7 +10194,7 @@ function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
         ...parseMetricsFromUsage(chunk.usage)
       };
     }
-    const delta = _optionalChain([chunk, 'access', _132 => _132.choices, 'optionalAccess', _133 => _133[0], 'optionalAccess', _134 => _134.delta]);
+    const delta = _optionalChain([chunk, 'access', _136 => _136.choices, 'optionalAccess', _137 => _137[0], 'optionalAccess', _138 => _138.delta]);
     if (!delta) {
       continue;
     }
@@ -10109,14 +10252,14 @@ function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
       continue;
     }
     const response = chunk.response;
-    if (_optionalChain([response, 'optionalAccess', _135 => _135.output]) !== void 0) {
+    if (_optionalChain([response, 'optionalAccess', _139 => _139.output]) !== void 0) {
       output = processImagesInOutput(response.output);
     }
     const { usage: _usage, output: _output, ...rest } = response || {};
     if (Object.keys(rest).length > 0) {
       metadata = rest;
     }
-    metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _136 => _136.usage]));
+    metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _140 => _140.usage]));
   }
   return {
     output,
@@ -10182,7 +10325,7 @@ var AnthropicPlugin = class extends BasePlugin {
         return message ? { role: message.role, content: message.content } : null;
       },
       extractMetrics: (message, startTime) => {
-        const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _137 => _137.usage]));
+        const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _141 => _141.usage]));
         if (startTime) {
           metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
         }
@@ -10197,7 +10340,7 @@ var AnthropicPlugin = class extends BasePlugin {
         const metadata = {};
         const metas = ["stop_reason", "stop_sequence"];
         for (const m of metas) {
-          if (_optionalChain([message, 'optionalAccess', _138 => _138[m]]) !== void 0) {
+          if (_optionalChain([message, 'optionalAccess', _142 => _142[m]]) !== void 0) {
             metadata[m] = message[m];
           }
         }
@@ -10238,15 +10381,15 @@ function aggregateAnthropicStreamChunks(chunks) {
   let metrics = {};
   let metadata = {};
   for (const event of chunks) {
-    switch (_optionalChain([event, 'optionalAccess', _139 => _139.type])) {
+    switch (_optionalChain([event, 'optionalAccess', _143 => _143.type])) {
       case "message_start":
-        if (_optionalChain([event, 'access', _140 => _140.message, 'optionalAccess', _141 => _141.usage])) {
+        if (_optionalChain([event, 'access', _144 => _144.message, 'optionalAccess', _145 => _145.usage])) {
           const initialMetrics = parseMetricsFromUsage2(event.message.usage);
           metrics = { ...metrics, ...initialMetrics };
         }
         break;
       case "content_block_delta":
-        if (_optionalChain([event, 'access', _142 => _142.delta, 'optionalAccess', _143 => _143.type]) === "text_delta") {
+        if (_optionalChain([event, 'access', _146 => _146.delta, 'optionalAccess', _147 => _147.type]) === "text_delta") {
           const text = event.delta.text;
           if (text) {
             deltas.push(text);
@@ -10341,6 +10484,108 @@ function filterFrom(obj, fieldsToRemove) {
   return result;
 }
 
+// src/wrappers/ai-sdk/normalize-logged-output.ts
+var REMOVE_NORMALIZED_VALUE = Symbol("braintrust.ai-sdk.remove-normalized");
+function normalizeAISDKLoggedOutput(value) {
+  const normalized = normalizeAISDKLoggedValue(value);
+  return normalized === REMOVE_NORMALIZED_VALUE ? {} : normalized;
+}
+function normalizeAISDKLoggedValue(value, context = {}) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeAISDKLoggedValue(entry, context)).filter((entry) => entry !== REMOVE_NORMALIZED_VALUE);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const nextInProviderMetadata = context.inProviderMetadata || context.parentKey === "providerMetadata" || context.parentKey === "experimental_providerMetadata";
+  const normalizedEntries = [];
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "cachedPromptTokens" && entry === 0) {
+      continue;
+    }
+    if (context.parentKey === "request" && key === "body" && entry === "<omitted>") {
+      continue;
+    }
+    const normalizedEntry = normalizeAISDKLoggedValue(entry, {
+      inProviderMetadata: nextInProviderMetadata,
+      parentKey: key
+    });
+    if (normalizedEntry === REMOVE_NORMALIZED_VALUE) {
+      continue;
+    }
+    normalizedEntries.push([key, normalizedEntry]);
+  }
+  if (normalizedEntries.length === 0) {
+    if (context.parentKey === "request" || nextInProviderMetadata) {
+      return REMOVE_NORMALIZED_VALUE;
+    }
+    return {};
+  }
+  return Object.fromEntries(normalizedEntries);
+}
+
+// src/zod/utils.ts
+var _zodtojsonschema = require('zod-to-json-schema');
+var _v4 = require('zod/v4'); var z42 = _interopRequireWildcard(_v4);
+function isZodV4(zodObject) {
+  return typeof zodObject === "object" && zodObject !== null && "_zod" in zodObject && zodObject._zod !== void 0;
+}
+function zodToJsonSchema(schema) {
+  if (isZodV4(schema)) {
+    return z42.toJSONSchema(schema, {
+      target: "draft-7"
+    });
+  }
+  return _zodtojsonschema.zodToJsonSchema.call(void 0, schema);
+}
+
+// src/wrappers/ai-sdk/tool-serialization.ts
+function isZodSchema(value) {
+  return value != null && typeof value === "object" && "_def" in value && typeof value._def === "object";
+}
+function serializeZodSchema(schema) {
+  try {
+    return zodToJsonSchema(schema);
+  } catch (e20) {
+    return {
+      type: "object",
+      description: "Zod schema (conversion failed)"
+    };
+  }
+}
+function serializeTool(tool) {
+  if (!tool || typeof tool !== "object") {
+    return tool;
+  }
+  const serialized = { ...tool };
+  if (isZodSchema(serialized.inputSchema)) {
+    serialized.inputSchema = serializeZodSchema(serialized.inputSchema);
+  }
+  if (isZodSchema(serialized.parameters)) {
+    serialized.parameters = serializeZodSchema(serialized.parameters);
+  }
+  if ("execute" in serialized) {
+    delete serialized.execute;
+  }
+  if ("render" in serialized) {
+    delete serialized.render;
+  }
+  return serialized;
+}
+function serializeAISDKToolsForLogging(tools) {
+  if (!tools || typeof tools !== "object") {
+    return tools;
+  }
+  if (Array.isArray(tools)) {
+    return tools.map(serializeTool);
+  }
+  const serialized = {};
+  for (const [key, tool] of Object.entries(tools)) {
+    serialized[key] = serializeTool(tool);
+  }
+  return serialized;
+}
+
 // src/instrumentation/plugins/ai-sdk-channels.ts
 var aiSDKChannels = defineChannels("ai", {
   generateText: channel({
@@ -10351,6 +10596,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "streamText",
     kind: "async"
   }),
+  streamTextSync: channel({
+    channelName: "streamText.sync",
+    kind: "sync-stream"
+  }),
   generateObject: channel({
     channelName: "generateObject",
     kind: "async"
@@ -10359,6 +10608,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "streamObject",
     kind: "async"
   }),
+  streamObjectSync: channel({
+    channelName: "streamObject.sync",
+    kind: "sync-stream"
+  }),
   agentGenerate: channel({
     channelName: "Agent.generate",
     kind: "async"
@@ -10366,6 +10619,14 @@ var aiSDKChannels = defineChannels("ai", {
   agentStream: channel({
     channelName: "Agent.stream",
     kind: "async"
+  }),
+  toolLoopAgentGenerate: channel({
+    channelName: "ToolLoopAgent.generate",
+    kind: "async"
+  }),
+  toolLoopAgentStream: channel({
+    channelName: "ToolLoopAgent.stream",
+    kind: "async"
   })
 });
 
@@ -10384,6 +10645,8 @@ var DEFAULT_DENY_OUTPUT_PATHS = [
   "steps[].response.body",
   "steps[].response.headers"
 ];
+var AUTO_PATCHED_MODEL = Symbol.for("braintrust.ai-sdk.auto-patched-model");
+var AUTO_PATCHED_TOOL = Symbol.for("braintrust.ai-sdk.auto-patched-tool");
 var AISDKPlugin = class extends BasePlugin {
   
   constructor(config = {}) {
@@ -10402,22 +10665,12 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.generateText, {
         name: "generateText",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(result, denyOutputPaths);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
       })
     );
@@ -10425,45 +10678,43 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.streamText, {
         name: "streamText",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
-          return processAISDKOutput(result, denyOutputPaths);
-        },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
-        aggregateChunks: aggregateAISDKChunks
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.streamTextSync, {
+        name: "streamText",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
       })
     );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.generateObject, {
         name: "generateObject",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(result, denyOutputPaths);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
       })
     );
@@ -10471,45 +10722,43 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.streamObject, {
         name: "streamObject",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
-          return processAISDKOutput(result, denyOutputPaths);
-        },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
-        aggregateChunks: aggregateAISDKChunks
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceSyncStreamChannel(aiSDKChannels.streamObjectSync, {
+        name: "streamObject",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
       })
     );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.agentGenerate, {
         name: "Agent.generate",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(result, denyOutputPaths);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
       })
     );
@@ -10517,56 +10766,474 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.agentStream, {
         name: "Agent.stream",
         type: "llm" /* LLM */,
-        extractInput: ([params]) => {
-          return {
-            input: processAISDKInput(params),
-            metadata: extractMetadataFromParams(params)
-          };
-        },
-        extractOutput: (result) => {
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.toolLoopAgentGenerate, {
+        name: "ToolLoopAgent.generate",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(result, denyOutputPaths);
         },
-        extractMetrics: (result, startTime) => {
-          const metrics = extractTokenMetrics(result);
-          if (startTime) {
-            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
-          }
-          return metrics;
-        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
         aggregateChunks: aggregateAISDKChunks
       })
     );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.toolLoopAgentStream, {
+        name: "ToolLoopAgent.stream",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event, span) => prepareAISDKInput(params, event, span, denyOutputPaths),
+        extractOutput: (result) => processAISDKOutput(result, denyOutputPaths),
+        extractMetrics: (result, startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent, startTime),
+        aggregateChunks: aggregateAISDKChunks,
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          denyOutputPaths,
+          endEvent,
+          result,
+          span,
+          startTime
+        })
+      })
+    );
   }
 };
 function processAISDKInput(params) {
   if (!params) return params;
-  return processInputAttachments(params);
+  const input = processInputAttachments(params);
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return input;
+  }
+  const { tools: _tools, ...rest } = input;
+  return rest;
+}
+function prepareAISDKInput(params, event, span, denyOutputPaths) {
+  const input = processAISDKInput(params);
+  const metadata = extractMetadataFromParams(params, event.self);
+  const childTracing = prepareAISDKChildTracing(
+    params,
+    event.self,
+    span,
+    denyOutputPaths
+  );
+  event.__braintrust_ai_sdk_model_wrapped = childTracing.modelWrapped;
+  if (childTracing.cleanup) {
+    event.__braintrust_ai_sdk_cleanup = childTracing.cleanup;
+  }
+  return {
+    input,
+    metadata
+  };
+}
+function extractTopLevelAISDKMetrics(result, event, startTime) {
+  const metrics = hasModelChildTracing(event) ? {} : extractTokenMetrics(result);
+  if (startTime) {
+    metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+  }
+  return metrics;
 }
-function extractMetadataFromParams(params) {
+function hasModelChildTracing(event) {
+  return _optionalChain([event, 'optionalAccess', _148 => _148.__braintrust_ai_sdk_model_wrapped]) === true;
+}
+function extractMetadataFromParams(params, self) {
   const metadata = {
     braintrust: {
       integration_name: "ai-sdk",
       sdk_language: "typescript"
     }
   };
-  const { model, provider } = serializeModelWithProvider(params.model);
+  const agentModel = self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && _optionalChain([self, 'access', _149 => _149.settings, 'optionalAccess', _150 => _150.model]) ? _optionalChain([self, 'access', _151 => _151.settings, 'optionalAccess', _152 => _152.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) {
+  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 (originalDoStream) {
+      resolvedModel.doStream = async function doStreamPatched(options) {
+        const span = parentSpan.startSpan({
+          name: "doStream",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: {
+            input: processAISDKInput(options),
+            metadata: baseMetadata
+          }
+        });
+        const result = await withCurrent(
+          span,
+          () => Reflect.apply(originalDoStream, resolvedModel, [options])
+        );
+        const output = {};
+        let text = "";
+        let reasoning = "";
+        const toolCalls = [];
+        let object = void 0;
+        const transformStream = new TransformStream({
+          transform(chunk, controller) {
+            switch (chunk.type) {
+              case "text-delta":
+                text += extractTextDelta(chunk);
+                break;
+              case "reasoning-delta":
+                if (chunk.delta) {
+                  reasoning += chunk.delta;
+                } else if (chunk.text) {
+                  reasoning += chunk.text;
+                }
+                break;
+              case "tool-call":
+                toolCalls.push(chunk);
+                break;
+              case "object":
+                object = chunk.object;
+                break;
+              case "raw":
+                if (chunk.rawValue) {
+                  const rawVal = chunk.rawValue;
+                  if (_optionalChain([rawVal, 'access', _153 => _153.delta, 'optionalAccess', _154 => _154.content])) {
+                    text += rawVal.delta.content;
+                  } else if (_optionalChain([rawVal, 'access', _155 => _155.choices, 'optionalAccess', _156 => _156[0], 'optionalAccess', _157 => _157.delta, 'optionalAccess', _158 => _158.content])) {
+                    text += rawVal.choices[0].delta.content;
+                  } else if (typeof rawVal.text === "string") {
+                    text += rawVal.text;
+                  } else if (typeof rawVal.content === "string") {
+                    text += rawVal.content;
+                  }
+                }
+                break;
+              case "finish":
+                output.text = text;
+                output.reasoning = reasoning;
+                output.toolCalls = toolCalls;
+                output.finishReason = chunk.finishReason;
+                output.usage = chunk.usage;
+                if (object !== void 0) {
+                  output.object = object;
+                }
+                span.log({
+                  output: processAISDKOutput(
+                    output,
+                    denyOutputPaths
+                  ),
+                  metrics: extractTokenMetrics(output),
+                  ...buildResolvedMetadataPayload(output)
+                });
+                span.end();
+                break;
+            }
+            controller.enqueue(chunk);
+          }
+        });
+        return {
+          ...result,
+          stream: result.stream.pipeThrough(transformStream)
+        };
+      };
+    }
+    cleanup.push(() => {
+      resolvedModel.doGenerate = originalDoGenerate;
+      if (originalDoStream) {
+        resolvedModel.doStream = originalDoStream;
+      }
+      delete resolvedModel[AUTO_PATCHED_MODEL];
+    });
+  };
+  const patchTool = (tool, name) => {
+    if (tool == null || typeof tool !== "object" || !("execute" in tool) || typeof tool.execute !== "function" || patchedTools.has(tool) || tool[AUTO_PATCHED_TOOL]) {
+      return;
+    }
+    patchedTools.add(tool);
+    tool[AUTO_PATCHED_TOOL] = true;
+    const originalExecute = tool.execute;
+    tool.execute = function executePatched(...args) {
+      const result = Reflect.apply(originalExecute, this, args);
+      if (isAsyncGenerator(result)) {
+        return (async function* () {
+          const span = parentSpan.startSpan({
+            name,
+            spanAttributes: {
+              type: "tool" /* TOOL */
+            }
+          });
+          span.log({ input: args.length === 1 ? args[0] : args });
+          try {
+            let lastValue;
+            for await (const value of result) {
+              lastValue = value;
+              yield value;
+            }
+            span.log({ output: lastValue });
+          } catch (error) {
+            span.log({
+              error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          } finally {
+            span.end();
+          }
+        })();
+      }
+      return parentSpan.traced(
+        async (span) => {
+          span.log({ input: args.length === 1 ? args[0] : args });
+          const awaitedResult = await result;
+          span.log({ output: awaitedResult });
+          return awaitedResult;
+        },
+        {
+          name,
+          spanAttributes: {
+            type: "tool" /* TOOL */
+          }
+        }
+      );
+    };
+    cleanup.push(() => {
+      tool.execute = originalExecute;
+      delete tool[AUTO_PATCHED_TOOL];
+    });
+  };
+  const patchTools = (tools) => {
+    if (!tools) {
+      return;
+    }
+    const inferName = (tool, fallback2) => tool && (tool.name || tool.toolName || tool.id) || fallback2;
+    if (Array.isArray(tools)) {
+      tools.forEach(
+        (tool, index) => patchTool(tool, inferName(tool, `tool[${index}]`))
+      );
+      return;
+    }
+    for (const [key, tool] of Object.entries(tools)) {
+      patchTool(tool, key);
+    }
+  };
+  if (params && typeof params === "object") {
+    patchModel(params.model);
+    patchTools(params.tools);
+  }
+  if (self && typeof self === "object") {
+    const selfRecord = self;
+    if (selfRecord.model !== void 0) {
+      patchModel(selfRecord.model);
+    }
+    if (selfRecord.settings && typeof selfRecord.settings === "object") {
+      if (selfRecord.settings.model !== void 0) {
+        patchModel(selfRecord.settings.model);
+      }
+      if (selfRecord.settings.tools !== void 0) {
+        patchTools(selfRecord.settings.tools);
+      }
+    }
+  }
+  return {
+    cleanup: cleanup.length > 0 ? () => {
+      while (cleanup.length > 0) {
+        _optionalChain([cleanup, 'access', _159 => _159.pop, 'call', _160 => _160(), 'optionalCall', _161 => _161()]);
+      }
+    } : void 0,
+    modelWrapped
+  };
+}
+function finalizeAISDKChildTracing(event) {
+  const cleanup = _optionalChain([event, 'optionalAccess', _162 => _162.__braintrust_ai_sdk_cleanup]);
+  if (event && typeof cleanup === "function") {
+    cleanup();
+    delete event.__braintrust_ai_sdk_cleanup;
+  }
+}
+function patchAISDKStreamingResult(args) {
+  const { denyOutputPaths, endEvent, result, span, startTime } = args;
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  const resultRecord = result;
+  if (!isReadableStreamLike(resultRecord.baseStream)) {
+    return false;
+  }
+  let firstChunkTime;
+  const wrappedBaseStream = resultRecord.baseStream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        if (firstChunkTime === void 0) {
+          firstChunkTime = getCurrentUnixTimestamp();
+        }
+        controller.enqueue(chunk);
+      },
+      async flush() {
+        const metrics = extractTopLevelAISDKMetrics(result, endEvent);
+        if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
+          metrics.time_to_first_token = firstChunkTime - startTime;
+        }
+        const output = await processAISDKStreamingOutput(
+          result,
+          denyOutputPaths
+        );
+        const metadata = buildResolvedMetadataPayload(result).metadata;
+        span.log({
+          output,
+          ...metadata ? { metadata } : {},
+          metrics
+        });
+        finalizeAISDKChildTracing(endEvent);
+        span.end();
+      }
+    })
+  );
+  Object.defineProperty(resultRecord, "baseStream", {
+    configurable: true,
+    enumerable: true,
+    value: wrappedBaseStream,
+    writable: true
+  });
+  return true;
+}
+function isReadableStreamLike(value) {
+  return value != null && typeof value === "object" && typeof value.pipeThrough === "function";
+}
+async function processAISDKStreamingOutput(result, denyOutputPaths) {
+  const output = processAISDKOutput(result, denyOutputPaths);
+  if (!output || typeof output !== "object") {
+    return output;
+  }
+  const outputRecord = output;
+  try {
+    if ("text" in result && typeof result.text === "string") {
+      outputRecord.text = result.text;
+    }
+  } catch (e21) {
+  }
+  try {
+    if ("object" in result) {
+      const resolvedObject = await Promise.resolve(result.object);
+      if (resolvedObject !== void 0) {
+        outputRecord.object = resolvedObject;
+      }
+    }
+  } catch (e22) {
+  }
+  return outputRecord;
+}
+function buildAISDKChildMetadata(model) {
+  const { model: modelId, provider } = serializeModelWithProvider(model);
+  return {
+    ...modelId ? { model: modelId } : {},
+    ...provider ? { provider } : {},
+    braintrust: {
+      integration_name: "ai-sdk",
+      sdk_language: "typescript"
+    }
+  };
+}
+function buildResolvedMetadataPayload(result) {
+  const gatewayInfo = extractGatewayRoutingInfo(result);
+  const metadata = {};
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _163 => _163.provider])) {
+    metadata.provider = gatewayInfo.provider;
+  }
+  if (_optionalChain([gatewayInfo, 'optionalAccess', _164 => _164.model])) {
+    metadata.model = gatewayInfo.model;
+  }
+  if (result.finishReason !== void 0) {
+    metadata.finish_reason = result.finishReason;
+  }
+  return Object.keys(metadata).length > 0 ? { metadata } : {};
+}
+function resolveAISDKModel(model) {
+  if (typeof model !== "string") {
+    return model;
+  }
+  const provider = _nullishCoalesce(globalThis.AI_SDK_DEFAULT_PROVIDER, () => ( null));
+  if (provider && typeof provider.languageModel === "function") {
+    return provider.languageModel(model);
+  }
+  return model;
+}
+function extractTextDelta(chunk) {
+  if (typeof chunk.textDelta === "string") return chunk.textDelta;
+  if (typeof chunk.delta === "string") return chunk.delta;
+  if (typeof chunk.text === "string") return chunk.text;
+  if (typeof chunk.content === "string") return chunk.content;
+  return "";
+}
+function isAsyncGenerator(value) {
+  return value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function" && typeof value.next === "function" && typeof value.return === "function" && typeof value.throw === "function";
+}
 function processAISDKOutput(output, denyOutputPaths) {
   if (!output) return output;
-  const getterValues = extractGetterValues(output);
-  const merged = { ...output, ...getterValues };
-  return omit(merged, denyOutputPaths);
+  const merged = extractSerializableOutputFields(output);
+  return normalizeAISDKLoggedOutput(omit(merged, denyOutputPaths));
 }
 function extractTokenMetrics(result) {
   const metrics = {};
-  let usage = _optionalChain([result, 'optionalAccess', _144 => _144.totalUsage]) || _optionalChain([result, 'optionalAccess', _145 => _145.usage]);
+  let usage = _optionalChain([result, 'optionalAccess', _165 => _165.totalUsage]) || _optionalChain([result, 'optionalAccess', _166 => _166.usage]);
   if (!usage && result) {
     try {
       if ("totalUsage" in result && typeof result.totalUsage !== "function") {
@@ -10574,14 +11241,14 @@ function extractTokenMetrics(result) {
       } else if ("usage" in result && typeof result.usage !== "function") {
         usage = result.usage;
       }
-    } catch (e19) {
+    } catch (e23) {
     }
   }
   if (!usage) {
     return metrics;
   }
   const promptTokens = firstNumber(
-    _optionalChain([usage, 'access', _146 => _146.inputTokens, 'optionalAccess', _147 => _147.total]),
+    _optionalChain([usage, 'access', _167 => _167.inputTokens, 'optionalAccess', _168 => _168.total]),
     usage.inputTokens,
     usage.promptTokens,
     usage.prompt_tokens
@@ -10590,7 +11257,7 @@ function extractTokenMetrics(result) {
     metrics.prompt_tokens = promptTokens;
   }
   const completionTokens = firstNumber(
-    _optionalChain([usage, 'access', _148 => _148.outputTokens, 'optionalAccess', _149 => _149.total]),
+    _optionalChain([usage, 'access', _169 => _169.outputTokens, 'optionalAccess', _170 => _170.total]),
     usage.outputTokens,
     usage.completionTokens,
     usage.completion_tokens
@@ -10612,12 +11279,14 @@ function extractTokenMetrics(result) {
   }
   return metrics;
 }
-function aggregateAISDKChunks(chunks) {
+function aggregateAISDKChunks(chunks, _result, endEvent) {
   const lastChunk = chunks[chunks.length - 1];
   const output = {};
   let metrics = {};
+  let metadata;
   if (lastChunk) {
-    metrics = extractTokenMetrics(lastChunk);
+    metrics = hasModelChildTracing(endEvent) ? {} : extractTokenMetrics(lastChunk);
+    metadata = buildResolvedMetadataPayload(lastChunk).metadata;
     if (lastChunk.text !== void 0) {
       output.text = lastChunk.text;
     }
@@ -10631,7 +11300,8 @@ function aggregateAISDKChunks(chunks) {
       output.toolCalls = lastChunk.toolCalls;
     }
   }
-  return { output, metrics };
+  finalizeAISDKChildTracing(endEvent);
+  return { output, metrics, metadata };
 }
 function extractGetterValues(obj) {
   const getterValues = {};
@@ -10651,17 +11321,58 @@ function extractGetterValues(obj) {
   ];
   for (const name of getterNames) {
     try {
-      if (obj && name in obj && typeof obj[name] !== "function") {
+      if (obj && name in obj && isSerializableOutputValue(obj[name])) {
         getterValues[name] = obj[name];
       }
-    } catch (e20) {
+    } catch (e24) {
     }
   }
   return getterValues;
 }
+function extractSerializableOutputFields(output) {
+  const serialized = {};
+  const directFieldNames = [
+    "steps",
+    "request",
+    "responseMessages",
+    "warnings",
+    "rawResponse",
+    "response",
+    "providerMetadata",
+    "experimental_providerMetadata"
+  ];
+  for (const name of directFieldNames) {
+    try {
+      const value = _optionalChain([output, 'optionalAccess', _171 => _171[name]]);
+      if (isSerializableOutputValue(value)) {
+        serialized[name] = value;
+      }
+    } catch (e25) {
+    }
+  }
+  return {
+    ...serialized,
+    ...extractGetterValues(output)
+  };
+}
+function isSerializableOutputValue(value) {
+  if (typeof value === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value.then === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value.getReader === "function") {
+    return false;
+  }
+  if (value && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function") {
+    return false;
+  }
+  return true;
+}
 function serializeModelWithProvider(model) {
-  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _150 => _150.modelId]);
-  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _151 => _151.provider]) : void 0;
+  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _172 => _172.modelId]);
+  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _173 => _173.provider]) : void 0;
   if (!modelId) {
     return { model: modelId, provider: explicitProvider };
   }
@@ -10684,13 +11395,32 @@ function parseGatewayModelString(modelString) {
   }
   return { model: modelString };
 }
+function extractGatewayRoutingInfo(result) {
+  if (_optionalChain([result, 'optionalAccess', _174 => _174.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+    const routing2 = _optionalChain([result, 'access', _175 => _175.steps, 'access', _176 => _176[0], 'optionalAccess', _177 => _177.providerMetadata, 'optionalAccess', _178 => _178.gateway, 'optionalAccess', _179 => _179.routing]);
+    if (routing2) {
+      return {
+        provider: routing2.resolvedProvider || routing2.finalProvider,
+        model: routing2.resolvedProviderApiModelId
+      };
+    }
+  }
+  const routing = _optionalChain([result, 'optionalAccess', _180 => _180.providerMetadata, 'optionalAccess', _181 => _181.gateway, 'optionalAccess', _182 => _182.routing]);
+  if (routing) {
+    return {
+      provider: routing.resolvedProvider || routing.finalProvider,
+      model: routing.resolvedProviderApiModelId
+    };
+  }
+  return null;
+}
 function extractCostFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _152 => _152.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+  if (_optionalChain([result, 'optionalAccess', _183 => _183.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
     let totalCost = 0;
     let foundCost = false;
     for (const step of result.steps) {
-      const gateway2 = _optionalChain([step, 'optionalAccess', _153 => _153.providerMetadata, 'optionalAccess', _154 => _154.gateway]);
-      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _155 => _155.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _156 => _156.marketCost]));
+      const gateway2 = _optionalChain([step, 'optionalAccess', _184 => _184.providerMetadata, 'optionalAccess', _185 => _185.gateway]);
+      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _186 => _186.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _187 => _187.marketCost]));
       if (stepCost !== void 0 && stepCost > 0) {
         totalCost += stepCost;
         foundCost = true;
@@ -10700,8 +11430,8 @@ function extractCostFromResult(result) {
       return totalCost;
     }
   }
-  const gateway = _optionalChain([result, 'optionalAccess', _157 => _157.providerMetadata, 'optionalAccess', _158 => _158.gateway]);
-  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _159 => _159.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _160 => _160.marketCost]));
+  const gateway = _optionalChain([result, 'optionalAccess', _188 => _188.providerMetadata, 'optionalAccess', _189 => _189.gateway]);
+  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _190 => _190.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _191 => _191.marketCost]));
   if (directCost !== void 0 && directCost > 0) {
     return directCost;
   }
@@ -10853,7 +11583,7 @@ function extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _161 => _161.message, 'optionalAccess', _162 => _162.usage]);
+    usage = _optionalChain([message, 'access', _192 => _192.message, 'optionalAccess', _193 => _193.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -10893,14 +11623,14 @@ function buildLLMInput(prompt, conversationHistory) {
 async function createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
   if (messages.length === 0) return void 0;
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _163 => _163.message, 'optionalAccess', _164 => _164.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _194 => _194.message, 'optionalAccess', _195 => _195.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
   const usage = extractUsageFromMessage(lastMessage);
   const input = buildLLMInput(prompt, conversationHistory);
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _165 => _165.message, 'optionalAccess', _166 => _166.content]) && _optionalChain([m, 'access', _167 => _167.message, 'optionalAccess', _168 => _168.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _196 => _196.message, 'optionalAccess', _197 => _197.content]) && _optionalChain([m, 'access', _198 => _198.message, 'optionalAccess', _199 => _199.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter(
     (c) => c !== void 0
   );
@@ -10919,7 +11649,7 @@ async function createLLMSpanForMessages(messages, prompt, conversationHistory, o
     metrics: usage
   });
   await span.end();
-  return _optionalChain([lastMessage, 'access', _169 => _169.message, 'optionalAccess', _170 => _170.content]) && _optionalChain([lastMessage, 'access', _171 => _171.message, 'optionalAccess', _172 => _172.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _200 => _200.message, 'optionalAccess', _201 => _201.content]) && _optionalChain([lastMessage, 'access', _202 => _202.message, 'optionalAccess', _203 => _203.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 var ClaudeAgentSDKPlugin = class extends BasePlugin {
   onEnable() {
@@ -10942,8 +11672,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
     const handlers = {
       start: (event) => {
         const params = event.arguments[0];
-        const prompt = _optionalChain([params, 'optionalAccess', _173 => _173.prompt]);
-        const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _174 => _174.options]), () => ( {}));
+        const prompt = _optionalChain([params, 'optionalAccess', _204 => _204.prompt]);
+        const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _205 => _205.options]), () => ( {}));
         const span = startSpan({
           name: "Claude Agent",
           spanAttributes: {
@@ -10988,9 +11718,9 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
             onChunk: async (message) => {
               const currentTime = getCurrentUnixTimestamp();
               const params = event.arguments[0];
-              const prompt = _optionalChain([params, 'optionalAccess', _175 => _175.prompt]);
-              const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _176 => _176.options]), () => ( {}));
-              const messageId = _optionalChain([message, 'access', _177 => _177.message, 'optionalAccess', _178 => _178.id]);
+              const prompt = _optionalChain([params, 'optionalAccess', _206 => _206.prompt]);
+              const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _207 => _207.options]), () => ( {}));
+              const messageId = _optionalChain([message, 'access', _208 => _208.message, 'optionalAccess', _209 => _209.id]);
               if (messageId && messageId !== spanData.currentMessageId) {
                 if (spanData.currentMessages.length > 0) {
                   const finalMessage = await createLLMSpanForMessages(
@@ -11005,7 +11735,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
                     spanData.conversationHistory.push(finalMessage);
                   }
                   const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (_optionalChain([lastMessage, 'optionalAccess', _179 => _179.message, 'optionalAccess', _180 => _180.usage])) {
+                  if (_optionalChain([lastMessage, 'optionalAccess', _210 => _210.message, 'optionalAccess', _211 => _211.usage])) {
                     const outputTokens = getNumberProperty(
                       lastMessage.message.usage,
                       "output_tokens"
@@ -11017,14 +11747,14 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
                 spanData.currentMessageId = messageId;
                 spanData.currentMessageStartTime = currentTime;
               }
-              if (message.type === "assistant" && _optionalChain([message, 'access', _181 => _181.message, 'optionalAccess', _182 => _182.usage])) {
+              if (message.type === "assistant" && _optionalChain([message, 'access', _212 => _212.message, 'optionalAccess', _213 => _213.usage])) {
                 spanData.currentMessages.push(message);
               }
               if (message.type === "result" && message.usage) {
                 const finalUsageMetrics = extractUsageFromMessage(message);
                 if (spanData.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
                   const lastMessage = spanData.currentMessages[spanData.currentMessages.length - 1];
-                  if (_optionalChain([lastMessage, 'optionalAccess', _183 => _183.message, 'optionalAccess', _184 => _184.usage])) {
+                  if (_optionalChain([lastMessage, 'optionalAccess', _214 => _214.message, 'optionalAccess', _215 => _215.usage])) {
                     const adjustedTokens = finalUsageMetrics.completion_tokens - spanData.accumulatedOutputTokens;
                     if (adjustedTokens >= 0) {
                       lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -11048,8 +11778,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
             onComplete: async () => {
               try {
                 const params = event.arguments[0];
-                const prompt = _optionalChain([params, 'optionalAccess', _185 => _185.prompt]);
-                const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _186 => _186.options]), () => ( {}));
+                const prompt = _optionalChain([params, 'optionalAccess', _216 => _216.prompt]);
+                const options = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _217 => _217.options]), () => ( {}));
                 if (spanData.currentMessages.length > 0) {
                   const finalMessage = await createLLMSpanForMessages(
                     spanData.currentMessages,
@@ -11256,7 +11986,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _187 => _187.config, 'optionalAccess', _188 => _188.tools])) {
+  if (!_optionalChain([params, 'access', _218 => _218.config, 'optionalAccess', _219 => _219.tools])) {
     return null;
   }
   try {
@@ -11266,7 +11996,7 @@ function serializeTools(params) {
       }
       return tool;
     });
-  } catch (e21) {
+  } catch (e26) {
     return null;
   }
 }
@@ -11293,7 +12023,7 @@ function extractGenerateContentMetrics(response, startTime) {
     const end = getCurrentUnixTimestamp();
     metrics.duration = end - startTime;
   }
-  if (_optionalChain([response, 'optionalAccess', _189 => _189.usageMetadata])) {
+  if (_optionalChain([response, 'optionalAccess', _220 => _220.usageMetadata])) {
     populateUsageMetrics(metrics, response.usageMetadata);
   }
   return metrics;
@@ -11341,7 +12071,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _190 => _190.content, 'optionalAccess', _191 => _191.parts])) {
+        if (_optionalChain([candidate, 'access', _221 => _221.content, 'optionalAccess', _222 => _222.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -11372,7 +12102,7 @@ function aggregateGenerateContentChunks(chunks, startTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _192 => _192.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _223 => _223.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -11604,7 +12334,7 @@ function configureNode() {
 var _express = require('express'); var _express2 = _interopRequireDefault(_express);
 var _cors = require('cors'); var _cors2 = _interopRequireDefault(_cors);
 
-// ../node_modules/async/dist/async.mjs
+// ../node_modules/.pnpm/async@3.2.5/node_modules/async/dist/async.mjs
 function initialParams(fn) {
   return function(...args) {
     var callback = args.pop();
@@ -11672,7 +12402,7 @@ function invokeCallback(callback, error, value) {
 function isAsync(fn) {
   return fn[Symbol.toStringTag] === "AsyncFunction";
 }
-function isAsyncGenerator(fn) {
+function isAsyncGenerator2(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
 function isAsyncIterable2(obj) {
@@ -11729,6 +12459,7 @@ function isArrayLike(value) {
   return value && typeof value.length === "number" && value.length >= 0 && value.length % 1 === 0;
 }
 var breakLoop = {};
+var breakLoop$1 = breakLoop;
 function once(fn) {
   function wrapper(...args) {
     if (fn === null) return;
@@ -11820,7 +12551,7 @@ function asyncEachOfLimit(generator, limit, iteratee, callback) {
       canceled = true;
       return;
     }
-    if (result === breakLoop || done && running <= 0) {
+    if (result === breakLoop$1 || done && running <= 0) {
       done = true;
       return callback(null);
     }
@@ -11843,7 +12574,7 @@ var eachOfLimit$2 = (limit) => {
     if (!obj) {
       return callback(null);
     }
-    if (isAsyncGenerator(obj)) {
+    if (isAsyncGenerator2(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
     if (isAsyncIterable2(obj)) {
@@ -11863,7 +12594,7 @@ var eachOfLimit$2 = (limit) => {
       } else if (err === false) {
         done = true;
         canceled = true;
-      } else if (value === breakLoop || done && running <= 0) {
+      } else if (value === breakLoop$1 || done && running <= 0) {
         done = true;
         return callback(null);
       } else if (!looping) {
@@ -11906,7 +12637,7 @@ function eachOfArrayLike(coll, iteratee, callback) {
     if (canceled === true) return;
     if (err) {
       callback(err);
-    } else if (++completed === length || value === breakLoop) {
+    } else if (++completed === length || value === breakLoop$1) {
       callback(null);
     }
   }
@@ -12302,7 +13033,7 @@ function _createTester(check, getResult) {
         if (check(result) && !testResult) {
           testPassed = true;
           testResult = getResult(true, value);
-          return callback(null, breakLoop);
+          return callback(null, breakLoop$1);
         }
         callback();
       });
@@ -12793,7 +13524,7 @@ var CachedSpanFetcher = (_class20 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _193 => _193.span_attributes, 'optionalAccess', _194 => _194.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _224 => _224.span_attributes, 'optionalAccess', _225 => _225.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -12827,7 +13558,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', _195 => _195.span_attributes, 'optionalAccess', _196 => _196.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _226 => _226.span_attributes, 'optionalAccess', _227 => _227.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -12907,11 +13638,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', _197 => _197.span_attributes, 'optionalAccess', _198 => _198.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _228 => _228.span_attributes, 'optionalAccess', _229 => _229.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _199 => _199.span_attributes, 'optionalAccess', _200 => _200.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _230 => _230.span_attributes, 'optionalAccess', _231 => _231.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -12930,7 +13661,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', _201 => _201.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _232 => _232.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -12941,7 +13672,7 @@ var LocalTrace = (_class21 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _202 => _202.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _233 => _233.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -13005,7 +13736,8 @@ var promptDefinitionSchema = promptContentsSchema.and(
   _v3.z.object({
     model: _v3.z.string(),
     params: ModelParams.optional(),
-    templateFormat: _v3.z.enum(["mustache", "nunjucks", "none"]).optional()
+    templateFormat: _v3.z.enum(["mustache", "nunjucks", "none"]).optional(),
+    environments: _v3.z.array(_v3.z.string()).optional()
   })
 );
 var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
@@ -13116,10 +13848,10 @@ function validateParametersWithJsonSchema(parameters, schema) {
   const ajv = new (0, _ajv2.default)({ coerceTypes: true, useDefaults: true, strict: false });
   const validate = ajv.compile(schema);
   if (!validate(parameters)) {
-    const errorMessages = _optionalChain([validate, 'access', _203 => _203.errors, 'optionalAccess', _204 => _204.map, 'call', _205 => _205((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _234 => _234.errors, 'optionalAccess', _235 => _235.map, 'call', _236 => _236((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _206 => _206.join, 'call', _207 => _207(", ")]);
+    }), 'access', _237 => _237.join, 'call', _238 => _238(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return parameters;
@@ -13161,6 +13893,22 @@ function initExperiment(state, options = {}) {
     setCurrent: false
   });
 }
+async function getExperimentParametersRef(parameters) {
+  if (!parameters) {
+    return void 0;
+  }
+  const resolvedParameters = parameters instanceof Promise ? await parameters : parameters;
+  if (!RemoteEvalParameters.isParameters(resolvedParameters)) {
+    return void 0;
+  }
+  if (resolvedParameters.id === void 0) {
+    return void 0;
+  }
+  return {
+    id: resolvedParameters.id,
+    version: resolvedParameters.version
+  };
+}
 function callEvaluatorData(data) {
   const dataResult = typeof data === "function" ? data() : data;
   let baseExperiment = void 0;
@@ -13227,6 +13975,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
     const { data, baseExperiment: defaultBaseExperiment } = callEvaluatorData(
       evaluator.data
     );
+    const parameters = await getExperimentParametersRef(evaluator.parameters);
     const experiment = options.parent || options.noSendLogs ? null : initExperiment(evaluator.state, {
       ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: name },
       experiment: evaluator.experimentName,
@@ -13239,7 +13988,8 @@ async function Eval(name, evaluator, reporterOrOpts) {
       baseExperimentId: evaluator.baseExperimentId,
       gitMetadataSettings: evaluator.gitMetadataSettings,
       repoInfo: evaluator.repoInfo,
-      dataset: Dataset2.isDataset(data) ? data : void 0
+      dataset: Dataset2.isDataset(data) ? data : void 0,
+      parameters
     });
     if (experiment && typeof process !== "undefined" && globalThis.BRAINTRUST_CONTEXT_MANAGER !== void 0) {
       await experiment._waitForId();
@@ -13294,7 +14044,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
       if (experiment) {
         await experiment.flush().catch(console.error);
       } else if (options.parent) {
-        await flush().catch(console.error);
+        await flush({ state: evaluator.state }).catch(console.error);
       }
     }
   } finally {
@@ -13339,7 +14089,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', _208 => _208.spanCache, 'optionalAccess', _209 => _209.start, 'call', _210 => _210()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _239 => _239.spanCache, 'optionalAccess', _240 => _240.start, 'call', _241 => _241()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -13394,7 +14144,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     const experimentIdPromise = experiment ? (async () => {
       try {
         return await experiment.id;
-      } catch (e22) {
+      } catch (e27) {
         return void 0;
       }
     })() : void 0;
@@ -13450,7 +14200,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _211 => _211.data, 'access', async _212 => _212.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _242 => _242.data, 'access', async _243 => _243.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -13476,10 +14226,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _213 => _213({
+                    _optionalChain([stream, 'optionalCall', _244 => _244({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _214 => _214.event, 'optionalAccess', _215 => _215.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _245 => _245.event, 'optionalAccess', _246 => _246.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -13643,7 +14393,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _216 => _216.event, 'optionalAccess', _217 => _217.origin])
+              origin: _optionalChain([baseEvent, 'access', _247 => _247.event, 'optionalAccess', _248 => _248.origin])
             });
           }
         };
@@ -13663,6 +14413,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       },
       Math.max(_nullishCoalesce(evaluator.maxConcurrency, () => ( Number.MAX_SAFE_INTEGER)), 1)
     );
+    const queueErrors = [];
     const enqueuePromise = (async () => {
       for await (const datum of dataIterable) {
         if (cancelled) {
@@ -13677,8 +14428,12 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _218 => _218.setTotal, 'optionalCall', _219 => _219(evaluator.evalName, scheduledTrials)]);
-          q.push({ datum, trialIndex });
+          _optionalChain([progressReporter, 'access', _249 => _249.setTotal, 'optionalCall', _250 => _250(evaluator.evalName, scheduledTrials)]);
+          q.pushAsync({ datum, trialIndex }).catch((e) => {
+            if (queueErrors.length < 5) {
+              queueErrors.push(e);
+            }
+          });
         }
       }
     })();
@@ -13726,6 +14481,12 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     })();
     try {
       await Promise.race([waitForQueue, cancel()]);
+      if (queueErrors.length > 0) {
+        throw new AggregateError(
+          queueErrors,
+          `Encountered ${queueErrors.length} unhandled task errors`
+        );
+      }
     } catch (e) {
       q.kill();
       if (e instanceof InternalAbortError) {
@@ -13752,9 +14513,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _220 => _220.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _221 => _221.dispose, 'call', _222 => _222()]);
-      _optionalChain([spanCache, 'optionalAccess', _223 => _223.stop, 'call', _224 => _224()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _251 => _251.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _252 => _252.dispose, 'call', _253 => _253()]);
+      _optionalChain([spanCache, 'optionalAccess', _254 => _254.stop, 'call', _255 => _255()]);
     }
   }
 }
@@ -13991,7 +14752,7 @@ async function cachedLogin(options) {
 }
 function makeCheckAuthorized(allowedOrgName) {
   return async (req, _res, next) => {
-    if (!_optionalChain([req, 'access', _225 => _225.ctx, 'optionalAccess', _226 => _226.token])) {
+    if (!_optionalChain([req, 'access', _256 => _256.ctx, 'optionalAccess', _257 => _257.token])) {
       return next(_httperrors2.default.call(void 0, 401, "Unauthorized"));
     }
     try {
@@ -14004,7 +14765,7 @@ function makeCheckAuthorized(allowedOrgName) {
         return next(_httperrors2.default.call(void 0, 403, errorMessage));
       }
       const state = await cachedLogin({
-        apiKey: _optionalChain([req, 'access', _227 => _227.ctx, 'optionalAccess', _228 => _228.token]),
+        apiKey: _optionalChain([req, 'access', _258 => _258.ctx, 'optionalAccess', _259 => _259.token]),
         orgName
       });
       req.ctx.state = state;
@@ -14187,23 +14948,6 @@ var evaluatorDefinitionsSchema = _v3.z.record(
 
 // src/framework2.ts
 
-
-// src/zod/utils.ts
-var _zodtojsonschema = require('zod-to-json-schema');
-var _v4 = require('zod/v4'); var z42 = _interopRequireWildcard(_v4);
-function isZodV4(zodObject) {
-  return typeof zodObject === "object" && zodObject !== null && "_zod" in zodObject && zodObject._zod !== void 0;
-}
-function zodToJsonSchema(schema) {
-  if (isZodV4(schema)) {
-    return z42.toJSONSchema(schema, {
-      target: "draft-7"
-    });
-  }
-  return _zodtojsonschema.zodToJsonSchema.call(void 0, schema);
-}
-
-// src/framework2.ts
 var currentFilename = typeof __filename !== "undefined" ? __filename : "unknown";
 var ProjectBuilder = class {
   create(opts) {
@@ -14409,6 +15153,7 @@ var CodePrompt = class {
   
   
   
+  
   constructor(project, prompt, toolFunctions, opts, functionType) {
     this.project = project;
     this.name = opts.name;
@@ -14421,6 +15166,7 @@ var CodePrompt = class {
     this.functionType = functionType;
     this.tags = opts.tags;
     this.metadata = opts.metadata;
+    this.environmentSlugs = opts.environments;
   }
   async toFunctionDefinition(projectNameToId) {
     const prompt_data = {
@@ -14455,7 +15201,8 @@ var CodePrompt = class {
       prompt_data,
       if_exists: this.ifExists,
       tags: this.tags,
-      metadata: this.metadata
+      metadata: this.metadata,
+      environments: this.environmentSlugs && this.environmentSlugs.length > 0 ? this.environmentSlugs.map((slug) => ({ slug })) : void 0
     };
   }
 };
@@ -14767,7 +15514,7 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      if (!_optionalChain([req, 'access', _229 => _229.ctx, 'optionalAccess', _230 => _230.state])) {
+      if (!_optionalChain([req, 'access', _260 => _260.ctx, 'optionalAccess', _261 => _261.state])) {
         res.status(500).json({ error: "Braintrust state not initialized in request" });
         return;
       }
@@ -14818,12 +15565,12 @@ function runDevServer(evaluators, opts) {
             ...evaluator,
             data: evalData.data,
             scores: evaluator.scores.concat(
-              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _231 => _231.map, 'call', _232 => _232(
+              _nullishCoalesce(_optionalChain([scores, 'optionalAccess', _262 => _262.map, 'call', _263 => _263(
                 (score) => makeScorer(
                   state,
                   score.name,
                   score.function_id,
-                  _optionalChain([req, 'access', _233 => _233.ctx, 'optionalAccess', _234 => _234.projectId])
+                  _optionalChain([req, 'access', _264 => _264.ctx, 'optionalAccess', _265 => _265.projectId])
                 )
               )]), () => ( []))
             ),