braintrust 3.0.0 → 3.1.0

package/dist/index.js

@@ -6497,6 +6497,7 @@ function init(projectOrOptions, optionalOptions) {
     forceLogin,
     fetch: fetch2,
     metadata,
+    tags,
     gitMetadataSettings,
     projectId,
     baseExperimentId,
@@ -6609,6 +6610,10 @@ function init(projectOrOptions, optionalOptions) {
       if (metadata) {
         args["metadata"] = metadata;
       }
+      if (tags) {
+        validateTags(tags);
+        args["tags"] = tags;
+      }
       let response = null;
       while (true) {
         try {
@@ -7555,6 +7560,7 @@ function validateTags(tags) {
     if (seen.has(tag)) {
       throw new Error(`duplicate tag: ${tag}`);
     }
+    seen.add(tag);
   }
 }
 function validateAndSanitizeExperimentLogPartialArgs(event) {
@@ -9279,6 +9285,7 @@ var _exportsForTestingOnly = {
   isGeneratorFunction,
   isAsyncGeneratorFunction,
   resetIdGenStateForTests,
+  validateTags,
   isomorph: isomorph_default
   // Expose isomorph for build type detection
 };
@@ -10630,9 +10637,13 @@ var makeGenerateTextWrapper = (name, options, generateText, aiSDK) => {
     const processedInput = await processInputAttachments2(params);
     return traced(
       async (span) => {
+        const { wrappedModel, getMetrics } = wrapModelAndGetMetrics(
+          params.model,
+          aiSDK
+        );
         const result = await generateText({
           ...params,
-          model: wrapModel(params.model, aiSDK),
+          model: wrappedModel,
           tools: wrapTools(params.tools)
         });
         const gatewayInfo = extractGatewayRoutingInfo(result);
@@ -10645,7 +10656,7 @@ var makeGenerateTextWrapper = (name, options, generateText, aiSDK) => {
         }
         span.log({
           output: await processOutput(result, options.denyOutputPaths),
-          metrics: extractTokenMetrics(result),
+          metrics: getMetrics(result),
           ...Object.keys(resolvedMetadata).length > 0 ? { metadata: resolvedMetadata } : {}
         });
         return result;
@@ -10866,6 +10877,14 @@ var wrapModel = (model, ai) => {
 var wrapGenerateText = (generateText, options = {}, aiSDK) => {
   return makeGenerateTextWrapper("generateText", options, generateText, aiSDK);
 };
+var wrapModelAndGetMetrics = (model, aiSDK) => {
+  const wrappedModel = wrapModel(model, aiSDK);
+  const modelIsWrapped = _optionalChain([wrappedModel, 'optionalAccess', _162 => _162._braintrustWrapped]) === true;
+  return {
+    wrappedModel,
+    getMetrics: (result) => modelIsWrapped ? void 0 : extractTokenMetrics(result)
+  };
+};
 var wrapGenerateObject = (generateObject, options = {}, aiSDK) => {
   return async function generateObjectWrapper(allParams) {
     const { span_info, ...params } = allParams;
@@ -10878,23 +10897,27 @@ var wrapGenerateObject = (generateObject, options = {}, aiSDK) => {
     const processedInput = await processInputAttachments2(params);
     return traced(
       async (span) => {
+        const { wrappedModel, getMetrics } = wrapModelAndGetMetrics(
+          params.model,
+          aiSDK
+        );
         const result = await generateObject({
           ...params,
-          model: wrapModel(params.model, aiSDK),
+          model: wrappedModel,
           tools: wrapTools(params.tools)
         });
         const output = await processOutput(result, options.denyOutputPaths);
         const gatewayInfo = extractGatewayRoutingInfo(result);
         const resolvedMetadata = {};
-        if (_optionalChain([gatewayInfo, 'optionalAccess', _162 => _162.provider])) {
+        if (_optionalChain([gatewayInfo, 'optionalAccess', _163 => _163.provider])) {
           resolvedMetadata.provider = gatewayInfo.provider;
         }
-        if (_optionalChain([gatewayInfo, 'optionalAccess', _163 => _163.model])) {
+        if (_optionalChain([gatewayInfo, 'optionalAccess', _164 => _164.model])) {
           resolvedMetadata.model = gatewayInfo.model;
         }
         span.log({
           output,
-          metrics: extractTokenMetrics(result),
+          metrics: getMetrics(result),
           ...Object.keys(resolvedMetadata).length > 0 ? { metadata: resolvedMetadata } : {}
         });
         return result;
@@ -10959,11 +10982,15 @@ var makeStreamTextWrapper = (name, options, streamText, aiSDK) => {
     try {
       const startTime = Date.now();
       let receivedFirst = false;
+      const { wrappedModel, getMetrics } = wrapModelAndGetMetrics(
+        params.model,
+        aiSDK
+      );
       const result = withCurrent(
         span,
         () => streamText({
           ...params,
-          model: wrapModel(params.model, aiSDK),
+          model: wrappedModel,
           tools: wrapTools(params.tools),
           onChunk: (chunk) => {
             if (!receivedFirst) {
@@ -10974,27 +11001,27 @@ var makeStreamTextWrapper = (name, options, streamText, aiSDK) => {
                 }
               });
             }
-            _optionalChain([params, 'access', _164 => _164.onChunk, 'optionalCall', _165 => _165(chunk)]);
+            _optionalChain([params, 'access', _165 => _165.onChunk, 'optionalCall', _166 => _166(chunk)]);
           },
           onFinish: async (event) => {
-            _optionalChain([params, 'access', _166 => _166.onFinish, 'optionalCall', _167 => _167(event)]);
+            _optionalChain([params, 'access', _167 => _167.onFinish, 'optionalCall', _168 => _168(event)]);
             const gatewayInfo = extractGatewayRoutingInfo(event);
             const resolvedMetadata = {};
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _168 => _168.provider])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _169 => _169.provider])) {
               resolvedMetadata.provider = gatewayInfo.provider;
             }
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _169 => _169.model])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _170 => _170.model])) {
               resolvedMetadata.model = gatewayInfo.model;
             }
             span.log({
               output: await processOutput(event, options.denyOutputPaths),
-              metrics: extractTokenMetrics(event),
+              metrics: getMetrics(event),
               ...Object.keys(resolvedMetadata).length > 0 ? { metadata: resolvedMetadata } : {}
             });
             span.end();
           },
           onError: async (err) => {
-            _optionalChain([params, 'access', _170 => _170.onError, 'optionalCall', _171 => _171(err)]);
+            _optionalChain([params, 'access', _171 => _171.onError, 'optionalCall', _172 => _172(err)]);
             span.log({
               error: serializeError(err)
             });
@@ -11083,11 +11110,15 @@ var wrapStreamObject = (streamObject, options = {}, aiSDK) => {
     try {
       const startTime = Date.now();
       let receivedFirst = false;
+      const { wrappedModel, getMetrics } = wrapModelAndGetMetrics(
+        params.model,
+        aiSDK
+      );
       const result = withCurrent(
         span,
         () => streamObject({
           ...params,
-          model: wrapModel(params.model, aiSDK),
+          model: wrappedModel,
           tools: wrapTools(params.tools),
           onChunk: (chunk) => {
             if (!receivedFirst) {
@@ -11098,27 +11129,27 @@ var wrapStreamObject = (streamObject, options = {}, aiSDK) => {
                 }
               });
             }
-            _optionalChain([params, 'access', _172 => _172.onChunk, 'optionalCall', _173 => _173(chunk)]);
+            _optionalChain([params, 'access', _173 => _173.onChunk, 'optionalCall', _174 => _174(chunk)]);
           },
           onFinish: async (event) => {
-            _optionalChain([params, 'access', _174 => _174.onFinish, 'optionalCall', _175 => _175(event)]);
+            _optionalChain([params, 'access', _175 => _175.onFinish, 'optionalCall', _176 => _176(event)]);
             const gatewayInfo = extractGatewayRoutingInfo(event);
             const resolvedMetadata = {};
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _176 => _176.provider])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _177 => _177.provider])) {
               resolvedMetadata.provider = gatewayInfo.provider;
             }
-            if (_optionalChain([gatewayInfo, 'optionalAccess', _177 => _177.model])) {
+            if (_optionalChain([gatewayInfo, 'optionalAccess', _178 => _178.model])) {
               resolvedMetadata.model = gatewayInfo.model;
             }
             span.log({
               output: await processOutput(event, options.denyOutputPaths),
-              metrics: extractTokenMetrics(event),
+              metrics: getMetrics(event),
               ...Object.keys(resolvedMetadata).length > 0 ? { metadata: resolvedMetadata } : {}
             });
             span.end();
           },
           onError: async (err) => {
-            _optionalChain([params, 'access', _178 => _178.onError, 'optionalCall', _179 => _179(err)]);
+            _optionalChain([params, 'access', _179 => _179.onError, 'optionalCall', _180 => _180(err)]);
             span.log({
               error: serializeError(err)
             });
@@ -11299,8 +11330,8 @@ function parseGatewayModelString(modelString) {
   return { model: modelString };
 }
 function serializeModelWithProvider(model) {
-  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _180 => _180.modelId]);
-  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _181 => _181.provider]) : void 0;
+  const modelId = typeof model === "string" ? model : _optionalChain([model, 'optionalAccess', _181 => _181.modelId]);
+  const explicitProvider = typeof model === "object" ? _optionalChain([model, 'optionalAccess', _182 => _182.provider]) : void 0;
   if (!modelId) {
     return { model: modelId, provider: explicitProvider };
   }
@@ -11311,8 +11342,8 @@ function serializeModelWithProvider(model) {
   };
 }
 function extractGatewayRoutingInfo(result) {
-  if (_optionalChain([result, 'optionalAccess', _182 => _182.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
-    const routing2 = _optionalChain([result, 'access', _183 => _183.steps, 'access', _184 => _184[0], 'optionalAccess', _185 => _185.providerMetadata, 'optionalAccess', _186 => _186.gateway, 'optionalAccess', _187 => _187.routing]);
+  if (_optionalChain([result, 'optionalAccess', _183 => _183.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+    const routing2 = _optionalChain([result, 'access', _184 => _184.steps, 'access', _185 => _185[0], 'optionalAccess', _186 => _186.providerMetadata, 'optionalAccess', _187 => _187.gateway, 'optionalAccess', _188 => _188.routing]);
     if (routing2) {
       return {
         provider: routing2.resolvedProvider || routing2.finalProvider,
@@ -11320,7 +11351,7 @@ function extractGatewayRoutingInfo(result) {
       };
     }
   }
-  const routing = _optionalChain([result, 'optionalAccess', _188 => _188.providerMetadata, 'optionalAccess', _189 => _189.gateway, 'optionalAccess', _190 => _190.routing]);
+  const routing = _optionalChain([result, 'optionalAccess', _189 => _189.providerMetadata, 'optionalAccess', _190 => _190.gateway, 'optionalAccess', _191 => _191.routing]);
   if (routing) {
     return {
       provider: routing.resolvedProvider || routing.finalProvider,
@@ -11592,7 +11623,7 @@ var convertImageToAttachment = (image, explicitMimeType) => {
   try {
     if (typeof image === "string" && image.startsWith("data:")) {
       const [mimeTypeSection, base64Data] = image.split(",");
-      const mimeType = _optionalChain([mimeTypeSection, 'access', _191 => _191.match, 'call', _192 => _192(/data:(.*?);/), 'optionalAccess', _193 => _193[1]]);
+      const mimeType = _optionalChain([mimeTypeSection, 'access', _192 => _192.match, 'call', _193 => _193(/data:(.*?);/), 'optionalAccess', _194 => _194[1]]);
       if (mimeType && base64Data) {
         const blob = convertDataToBlob(base64Data, mimeType);
         if (blob) {
@@ -11759,7 +11790,7 @@ function firstNumber(...values) {
 }
 function extractTokenMetrics(result) {
   const metrics = {};
-  let usage = _optionalChain([result, 'optionalAccess', _194 => _194.totalUsage]) || _optionalChain([result, 'optionalAccess', _195 => _195.usage]);
+  let usage = _optionalChain([result, 'optionalAccess', _195 => _195.totalUsage]) || _optionalChain([result, 'optionalAccess', _196 => _196.usage]);
   if (!usage && result) {
     try {
       if ("totalUsage" in result && typeof result.totalUsage !== "function") {
@@ -11774,7 +11805,7 @@ function extractTokenMetrics(result) {
     return metrics;
   }
   const promptTokens = firstNumber(
-    _optionalChain([usage, 'access', _196 => _196.inputTokens, 'optionalAccess', _197 => _197.total]),
+    _optionalChain([usage, 'access', _197 => _197.inputTokens, 'optionalAccess', _198 => _198.total]),
     usage.inputTokens,
     usage.promptTokens,
     usage.prompt_tokens
@@ -11783,7 +11814,7 @@ function extractTokenMetrics(result) {
     metrics.prompt_tokens = promptTokens;
   }
   const completionTokens = firstNumber(
-    _optionalChain([usage, 'access', _198 => _198.outputTokens, 'optionalAccess', _199 => _199.total]),
+    _optionalChain([usage, 'access', _199 => _199.outputTokens, 'optionalAccess', _200 => _200.total]),
     usage.outputTokens,
     usage.completionTokens,
     usage.completion_tokens
@@ -11800,7 +11831,7 @@ function extractTokenMetrics(result) {
     metrics.tokens = totalTokens;
   }
   const promptCachedTokens = firstNumber(
-    _optionalChain([usage, 'access', _200 => _200.inputTokens, 'optionalAccess', _201 => _201.cacheRead]),
+    _optionalChain([usage, 'access', _201 => _201.inputTokens, 'optionalAccess', _202 => _202.cacheRead]),
     usage.cachedInputTokens,
     usage.promptCachedTokens,
     usage.prompt_cached_tokens
@@ -11830,7 +11861,7 @@ function extractTokenMetrics(result) {
     metrics.completion_cached_tokens = completionCachedTokens;
   }
   const reasoningTokenCount = firstNumber(
-    _optionalChain([usage, 'access', _202 => _202.outputTokens, 'optionalAccess', _203 => _203.reasoning]),
+    _optionalChain([usage, 'access', _203 => _203.outputTokens, 'optionalAccess', _204 => _204.reasoning]),
     usage.reasoningTokens,
     usage.completionReasoningTokens,
     usage.completion_reasoning_tokens,
@@ -11856,12 +11887,12 @@ function extractTokenMetrics(result) {
   return metrics;
 }
 function extractCostFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _204 => _204.steps]) && Array.isArray(result.steps) && result.steps.length > 0) {
+  if (_optionalChain([result, 'optionalAccess', _205 => _205.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', _205 => _205.providerMetadata, 'optionalAccess', _206 => _206.gateway]);
-      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _207 => _207.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _208 => _208.marketCost]));
+      const gateway2 = _optionalChain([step, 'optionalAccess', _206 => _206.providerMetadata, 'optionalAccess', _207 => _207.gateway]);
+      const stepCost = parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _208 => _208.cost])) || parseGatewayCost(_optionalChain([gateway2, 'optionalAccess', _209 => _209.marketCost]));
       if (stepCost !== void 0 && stepCost > 0) {
         totalCost += stepCost;
         foundCost = true;
@@ -11871,8 +11902,8 @@ function extractCostFromResult(result) {
       return totalCost;
     }
   }
-  const gateway = _optionalChain([result, 'optionalAccess', _209 => _209.providerMetadata, 'optionalAccess', _210 => _210.gateway]);
-  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _211 => _211.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _212 => _212.marketCost]));
+  const gateway = _optionalChain([result, 'optionalAccess', _210 => _210.providerMetadata, 'optionalAccess', _211 => _211.gateway]);
+  const directCost = parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _212 => _212.cost])) || parseGatewayCost(_optionalChain([gateway, 'optionalAccess', _213 => _213.marketCost]));
   if (directCost !== void 0 && directCost > 0) {
     return directCost;
   }
@@ -11966,7 +11997,7 @@ var omit = (obj, paths) => {
 // src/wrappers/ai-sdk/deprecated/wrapAISDKModel.ts
 function wrapAISDKModel(model) {
   const m = model;
-  if (_optionalChain([m, 'optionalAccess', _213 => _213.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _214 => _214.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _215 => _215.modelId]) === "string") {
+  if (_optionalChain([m, 'optionalAccess', _214 => _214.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _215 => _215.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _216 => _216.modelId]) === "string") {
     return new BraintrustLanguageModelWrapper(m);
   } else {
     console.warn("Unsupported AI SDK model. Not wrapping.");
@@ -12023,10 +12054,10 @@ var BraintrustLanguageModelWrapper = class {
         metrics: {
           time_to_first_token: getCurrentUnixTimestamp() - startTime,
           tokens: !isEmpty2(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
-          prompt_tokens: _optionalChain([ret, 'access', _216 => _216.usage, 'optionalAccess', _217 => _217.promptTokens]),
-          completion_tokens: _optionalChain([ret, 'access', _218 => _218.usage, 'optionalAccess', _219 => _219.completionTokens]),
+          prompt_tokens: _optionalChain([ret, 'access', _217 => _217.usage, 'optionalAccess', _218 => _218.promptTokens]),
+          completion_tokens: _optionalChain([ret, 'access', _219 => _219.usage, 'optionalAccess', _220 => _220.completionTokens]),
           cached: parseCachedHeader(
-            _nullishCoalesce(_optionalChain([ret, 'access', _220 => _220.rawResponse, 'optionalAccess', _221 => _221.headers, 'optionalAccess', _222 => _222[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _223 => _223.rawResponse, 'optionalAccess', _224 => _224.headers, 'optionalAccess', _225 => _225[LEGACY_CACHED_HEADER]])))
+            _nullishCoalesce(_optionalChain([ret, 'access', _221 => _221.rawResponse, 'optionalAccess', _222 => _222.headers, 'optionalAccess', _223 => _223[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _224 => _224.rawResponse, 'optionalAccess', _225 => _225.headers, 'optionalAccess', _226 => _226[LEGACY_CACHED_HEADER]])))
           )
         }
       });
@@ -12118,10 +12149,10 @@ var BraintrustLanguageModelWrapper = class {
                 metrics: {
                   time_to_first_token,
                   tokens: !isEmpty2(usage) ? usage.promptTokens + usage.completionTokens : void 0,
-                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _226 => _226.promptTokens]),
-                  completion_tokens: _optionalChain([usage, 'optionalAccess', _227 => _227.completionTokens]),
+                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _227 => _227.promptTokens]),
+                  completion_tokens: _optionalChain([usage, 'optionalAccess', _228 => _228.completionTokens]),
                   cached: parseCachedHeader(
-                    _nullishCoalesce(_optionalChain([ret, 'access', _228 => _228.rawResponse, 'optionalAccess', _229 => _229.headers, 'optionalAccess', _230 => _230[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _231 => _231.rawResponse, 'optionalAccess', _232 => _232.headers, 'optionalAccess', _233 => _233[LEGACY_CACHED_HEADER]])))
+                    _nullishCoalesce(_optionalChain([ret, 'access', _229 => _229.rawResponse, 'optionalAccess', _230 => _230.headers, 'optionalAccess', _231 => _231[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _232 => _232.rawResponse, 'optionalAccess', _233 => _233.headers, 'optionalAccess', _234 => _234[LEGACY_CACHED_HEADER]])))
                   )
                 }
               });
@@ -12165,7 +12196,7 @@ function postProcessPrompt(prompt) {
         return [
           {
             role: "assistant",
-            content: _optionalChain([textPart, 'optionalAccess', _234 => _234.text]),
+            content: _optionalChain([textPart, 'optionalAccess', _235 => _235.text]),
             ...toolCallParts.length > 0 ? {
               tool_calls: toolCallParts.map((part) => ({
                 id: part.toolCallId,
@@ -12258,23 +12289,23 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
 
 // src/wrappers/ai-sdk/deprecated/BraintrustMiddleware.ts
 function detectProviderFromResult(result) {
-  if (!_optionalChain([result, 'optionalAccess', _235 => _235.providerMetadata])) {
+  if (!_optionalChain([result, 'optionalAccess', _236 => _236.providerMetadata])) {
     return void 0;
   }
   const keys = Object.keys(result.providerMetadata);
-  return _optionalChain([keys, 'optionalAccess', _236 => _236.at, 'call', _237 => _237(0)]);
+  return _optionalChain([keys, 'optionalAccess', _237 => _237.at, 'call', _238 => _238(0)]);
 }
 function extractModelFromResult(result) {
-  if (_optionalChain([result, 'optionalAccess', _238 => _238.response, 'optionalAccess', _239 => _239.modelId])) {
+  if (_optionalChain([result, 'optionalAccess', _239 => _239.response, 'optionalAccess', _240 => _240.modelId])) {
     return result.response.modelId;
   }
-  if (_optionalChain([result, 'optionalAccess', _240 => _240.request, 'optionalAccess', _241 => _241.body, 'optionalAccess', _242 => _242.model])) {
+  if (_optionalChain([result, 'optionalAccess', _241 => _241.request, 'optionalAccess', _242 => _242.body, 'optionalAccess', _243 => _243.model])) {
     return result.request.body.model;
   }
   return void 0;
 }
 function extractModelFromWrapGenerateCallback(model) {
-  return _optionalChain([model, 'optionalAccess', _243 => _243.modelId]);
+  return _optionalChain([model, 'optionalAccess', _244 => _244.modelId]);
 }
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
@@ -12319,7 +12350,7 @@ function normalizeUsageMetrics(usage, provider, providerMetadata) {
     metrics.prompt_cached_tokens = cachedInputTokens;
   }
   if (provider === "anthropic") {
-    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _244 => _244.anthropic]);
+    const anthropicMetadata = _optionalChain([providerMetadata, 'optionalAccess', _245 => _245.anthropic]);
     if (anthropicMetadata) {
       const cacheReadTokens = getNumberProperty(anthropicMetadata.usage, "cache_read_input_tokens") || 0;
       const cacheCreationTokens = getNumberProperty(
@@ -12345,7 +12376,7 @@ function buildAssistantOutputWithToolCalls(result, toolCalls) {
     {
       index: 0,
       logprobs: null,
-      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _245 => _245.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
+      finish_reason: _nullishCoalesce(normalizeFinishReason(_optionalChain([result, 'optionalAccess', _246 => _246.finishReason])), () => ( (toolCalls.length ? "tool_calls" : void 0))),
       message: {
         role: "assistant",
         tool_calls: toolCalls.length > 0 ? toolCalls : void 0
@@ -12358,7 +12389,7 @@ function extractToolCallsFromSteps(steps) {
   if (!Array.isArray(steps)) return toolCalls;
   let idx = 0;
   for (const step of steps) {
-    const blocks = _optionalChain([step, 'optionalAccess', _246 => _246.content]);
+    const blocks = _optionalChain([step, 'optionalAccess', _247 => _247.content]);
     if (!Array.isArray(blocks)) continue;
     for (const block of blocks) {
       if (block && typeof block === "object" && block.type === "tool-call") {
@@ -12381,7 +12412,7 @@ function extractToolCallsFromBlocks(blocks) {
   return extractToolCallsFromSteps([{ content: blocks }]);
 }
 function extractInput(params) {
-  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _247 => _247.prompt]), () => ( _optionalChain([params, 'optionalAccess', _248 => _248.messages]))), () => ( _optionalChain([params, 'optionalAccess', _249 => _249.system])));
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _248 => _248.prompt]), () => ( _optionalChain([params, 'optionalAccess', _249 => _249.messages]))), () => ( _optionalChain([params, 'optionalAccess', _250 => _250.system])));
 }
 var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
   "prompt",
@@ -12405,16 +12436,16 @@ function BraintrustMiddleware(config = {}) {
       const rawInput = extractInput(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
-        name: _optionalChain([config, 'access', _250 => _250.spanInfo, 'optionalAccess', _251 => _251.name]) || "ai-sdk.doGenerate",
+        name: _optionalChain([config, 'access', _251 => _251.spanInfo, 'optionalAccess', _252 => _252.name]) || "ai-sdk.doGenerate",
         spanAttributes: {
           type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _252 => _252.spanInfo, 'optionalAccess', _253 => _253.spanAttributes]) || {}
+          ..._optionalChain([config, 'access', _253 => _253.spanInfo, 'optionalAccess', _254 => _254.spanAttributes]) || {}
         },
         event: {
           input: processedInput,
           metadata: {
             ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _254 => _254.spanInfo, 'optionalAccess', _255 => _255.metadata]) || {}
+            ..._optionalChain([config, 'access', _255 => _255.spanInfo, 'optionalAccess', _256 => _256.metadata]) || {}
           }
         }
       };
@@ -12440,12 +12471,12 @@ function BraintrustMiddleware(config = {}) {
             metadata.model = modelId;
           }
         }
-        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _256 => _256.steps]));
+        let toolCalls = extractToolCallsFromSteps(_optionalChain([result, 'optionalAccess', _257 => _257.steps]));
         if (!toolCalls || toolCalls.length === 0) {
-          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _257 => _257.content]));
+          toolCalls = extractToolCallsFromBlocks(_optionalChain([result, 'optionalAccess', _258 => _258.content]));
         }
         span.log({
-          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _258 => _258.content]),
+          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : _optionalChain([result, 'optionalAccess', _259 => _259.content]),
           metadata,
           metrics: normalizeUsageMetrics(
             result.usage,
@@ -12467,16 +12498,16 @@ function BraintrustMiddleware(config = {}) {
       const rawInput = extractInput(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
-        name: _optionalChain([config, 'access', _259 => _259.spanInfo, 'optionalAccess', _260 => _260.name]) || "ai-sdk.doStream",
+        name: _optionalChain([config, 'access', _260 => _260.spanInfo, 'optionalAccess', _261 => _261.name]) || "ai-sdk.doStream",
         spanAttributes: {
           type: "llm" /* LLM */,
-          ..._optionalChain([config, 'access', _261 => _261.spanInfo, 'optionalAccess', _262 => _262.spanAttributes]) || {}
+          ..._optionalChain([config, 'access', _262 => _262.spanInfo, 'optionalAccess', _263 => _263.spanAttributes]) || {}
         },
         event: {
           input: processedInput,
           metadata: {
             ...extractModelParameters(params, V2_EXCLUDE_KEYS),
-            ..._optionalChain([config, 'access', _263 => _263.spanInfo, 'optionalAccess', _264 => _264.metadata]) || {}
+            ..._optionalChain([config, 'access', _264 => _264.spanInfo, 'optionalAccess', _265 => _265.metadata]) || {}
           }
         }
       };
@@ -12747,9 +12778,9 @@ function streamNextProxy(stream, sspan) {
     }
     const item = result.value;
     const blockIndex = item.index;
-    switch (_optionalChain([item, 'optionalAccess', _265 => _265.type])) {
+    switch (_optionalChain([item, 'optionalAccess', _266 => _266.type])) {
       case "message_start":
-        const msg = _optionalChain([item, 'optionalAccess', _266 => _266.message]);
+        const msg = _optionalChain([item, 'optionalAccess', _267 => _267.message]);
         if (msg) {
           const event = parseEventFromMessage(msg);
           totals = { ...totals, ...event.metrics };
@@ -12766,23 +12797,23 @@ function streamNextProxy(stream, sspan) {
         if (!contentBlockDeltas[blockIndex]) {
           contentBlockDeltas[blockIndex] = [];
         }
-        if (_optionalChain([item, 'optionalAccess', _267 => _267.delta, 'optionalAccess', _268 => _268.type]) === "text_delta") {
-          const text2 = _optionalChain([item, 'optionalAccess', _269 => _269.delta, 'optionalAccess', _270 => _270.text]);
+        if (_optionalChain([item, 'optionalAccess', _268 => _268.delta, 'optionalAccess', _269 => _269.type]) === "text_delta") {
+          const text2 = _optionalChain([item, 'optionalAccess', _270 => _270.delta, 'optionalAccess', _271 => _271.text]);
           if (text2) {
             contentBlockDeltas[blockIndex].push(text2);
           }
-        } else if (_optionalChain([item, 'optionalAccess', _271 => _271.delta, 'optionalAccess', _272 => _272.type]) === "input_json_delta") {
-          const partialJson = _optionalChain([item, 'optionalAccess', _273 => _273.delta, 'optionalAccess', _274 => _274.partial_json]);
+        } else if (_optionalChain([item, 'optionalAccess', _272 => _272.delta, 'optionalAccess', _273 => _273.type]) === "input_json_delta") {
+          const partialJson = _optionalChain([item, 'optionalAccess', _274 => _274.delta, 'optionalAccess', _275 => _275.partial_json]);
           if (partialJson) {
             contentBlockDeltas[blockIndex].push(partialJson);
           }
         }
         break;
       case "content_block_stop":
-        const text = _optionalChain([contentBlockDeltas, 'access', _275 => _275[blockIndex], 'optionalAccess', _276 => _276.join, 'call', _277 => _277("")]);
+        const text = _optionalChain([contentBlockDeltas, 'access', _276 => _276[blockIndex], 'optionalAccess', _277 => _277.join, 'call', _278 => _278("")]);
         if (!text) break;
         const block = contentBlocks[blockIndex];
-        if (_optionalChain([block, 'optionalAccess', _278 => _278.type]) === "tool_use") {
+        if (_optionalChain([block, 'optionalAccess', _279 => _279.type]) === "tool_use") {
           try {
             span.log({
               output: {
@@ -12798,12 +12829,12 @@ function streamNextProxy(stream, sspan) {
         }
         break;
       case "message_delta":
-        const usage = _optionalChain([item, 'optionalAccess', _279 => _279.usage]);
+        const usage = _optionalChain([item, 'optionalAccess', _280 => _280.usage]);
         if (usage) {
           const metrics = parseMetricsFromUsage2(usage);
           totals = { ...totals, ...metrics };
         }
-        const delta = _optionalChain([item, 'optionalAccess', _280 => _280.delta]);
+        const delta = _optionalChain([item, 'optionalAccess', _281 => _281.delta]);
         if (delta) {
           metadata = { ...metadata, ...delta };
         }
@@ -12816,7 +12847,7 @@ function streamNextProxy(stream, sspan) {
 }
 function parseEventFromMessage(message) {
   const output = message ? { role: message.role, content: message.content } : null;
-  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _281 => _281.usage]));
+  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _282 => _282.usage]));
   const metas = ["stop_reason", "stop_sequence"];
   const metadata = {};
   for (const m of metas) {
@@ -12990,17 +13021,17 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
       try {
         const response = input.tool_response;
         const metadata = {};
-        if (_optionalChain([response, 'optionalAccess', _282 => _282.status])) {
+        if (_optionalChain([response, 'optionalAccess', _283 => _283.status])) {
           metadata["claude_agent_sdk.status"] = response.status;
         }
-        if (_optionalChain([response, 'optionalAccess', _283 => _283.totalDurationMs])) {
+        if (_optionalChain([response, 'optionalAccess', _284 => _284.totalDurationMs])) {
           metadata["claude_agent_sdk.duration_ms"] = response.totalDurationMs;
         }
-        if (_optionalChain([response, 'optionalAccess', _284 => _284.totalToolUseCount]) !== void 0) {
+        if (_optionalChain([response, 'optionalAccess', _285 => _285.totalToolUseCount]) !== void 0) {
           metadata["claude_agent_sdk.tool_use_count"] = response.totalToolUseCount;
         }
         subAgentSpan.log({
-          output: _optionalChain([response, 'optionalAccess', _285 => _285.content]),
+          output: _optionalChain([response, 'optionalAccess', _286 => _286.content]),
           metadata
         });
       } finally {
@@ -13139,7 +13170,7 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
               yield msg;
             }
           } finally {
-            _optionalChain([resolvePromptDone, 'optionalCall', _286 => _286()]);
+            _optionalChain([resolvePromptDone, 'optionalCall', _287 => _287()]);
           }
         })();
         promptForQuery = capturingPrompt;
@@ -13161,7 +13192,7 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
       let currentMessageStartTime = getCurrentUnixTimestamp();
       const currentMessages = [];
       const createLLMSpan = async () => {
-        const parentToolUseId = _nullishCoalesce(_optionalChain([currentMessages, 'access', _287 => _287[0], 'optionalAccess', _288 => _288.parent_tool_use_id]), () => ( null));
+        const parentToolUseId = _nullishCoalesce(_optionalChain([currentMessages, 'access', _288 => _288[0], 'optionalAccess', _289 => _289.parent_tool_use_id]), () => ( null));
         let parentSpanExport;
         if (parentToolUseId) {
           const subAgentSpan = subAgentSpans.get(parentToolUseId);
@@ -13182,7 +13213,7 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
           finalResults.push(finalMessageContent);
         }
         const lastMessage = currentMessages[currentMessages.length - 1];
-        if (_optionalChain([lastMessage, 'optionalAccess', _289 => _289.message, 'optionalAccess', _290 => _290.usage])) {
+        if (_optionalChain([lastMessage, 'optionalAccess', _290 => _290.message, 'optionalAccess', _291 => _291.usage])) {
           const outputTokens = getNumberProperty2(lastMessage.message.usage, "output_tokens") || 0;
           accumulatedOutputTokens += outputTokens;
         }
@@ -13226,12 +13257,12 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
         try {
           for await (const message of originalGenerator) {
             const currentTime = getCurrentUnixTimestamp();
-            if (message.type === "assistant" && Array.isArray(_optionalChain([message, 'access', _291 => _291.message, 'optionalAccess', _292 => _292.content]))) {
+            if (message.type === "assistant" && Array.isArray(_optionalChain([message, 'access', _292 => _292.message, 'optionalAccess', _293 => _293.content]))) {
               const parentToolUseId = _nullishCoalesce(message.parent_tool_use_id, () => ( null));
               for (const block of message.message.content) {
                 if (block.type === "tool_use" && block.id) {
                   toolUseToParent.set(block.id, parentToolUseId);
-                  if (block.name === "Task" && _optionalChain([block, 'access', _293 => _293.input, 'optionalAccess', _294 => _294.subagent_type])) {
+                  if (block.name === "Task" && _optionalChain([block, 'access', _294 => _294.input, 'optionalAccess', _295 => _295.subagent_type])) {
                     pendingSubAgentNames.set(
                       block.id,
                       block.input.subagent_type
@@ -13261,20 +13292,20 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
                 subAgentSpans.set(parentToolUseId, subAgentSpan);
               }
             }
-            const messageId = _optionalChain([message, 'access', _295 => _295.message, 'optionalAccess', _296 => _296.id]);
+            const messageId = _optionalChain([message, 'access', _296 => _296.message, 'optionalAccess', _297 => _297.id]);
             if (messageId && messageId !== currentMessageId) {
               await createLLMSpan();
               currentMessageId = messageId;
               currentMessageStartTime = currentTime;
             }
-            if (message.type === "assistant" && _optionalChain([message, 'access', _297 => _297.message, 'optionalAccess', _298 => _298.usage])) {
+            if (message.type === "assistant" && _optionalChain([message, 'access', _298 => _298.message, 'optionalAccess', _299 => _299.usage])) {
               currentMessages.push(message);
             }
             if (message.type === "result" && message.usage) {
               finalUsageMetrics = _extractUsageFromMessage(message);
               if (currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
                 const lastMessage = currentMessages[currentMessages.length - 1];
-                if (_optionalChain([lastMessage, 'optionalAccess', _299 => _299.message, 'optionalAccess', _300 => _300.usage])) {
+                if (_optionalChain([lastMessage, 'optionalAccess', _300 => _300.message, 'optionalAccess', _301 => _301.usage])) {
                   const adjustedTokens = finalUsageMetrics.completion_tokens - accumulatedOutputTokens;
                   if (adjustedTokens >= 0) {
                     lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -13355,8 +13386,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', _301 => _301.message, 'optionalAccess', _302 => _302.role]);
-      const content = _optionalChain([msg, 'access', _303 => _303.message, 'optionalAccess', _304 => _304.content]);
+      const role = _optionalChain([msg, 'access', _302 => _302.message, 'optionalAccess', _303 => _303.role]);
+      const content = _optionalChain([msg, 'access', _304 => _304.message, 'optionalAccess', _305 => _305.content]);
       if (role && content !== void 0) {
         promptMessages.push({ content, role });
       }
@@ -13372,7 +13403,7 @@ function _extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _305 => _305.message, 'optionalAccess', _306 => _306.usage]);
+    usage = _optionalChain([message, 'access', _306 => _306.message, 'optionalAccess', _307 => _307.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -13404,7 +13435,7 @@ function _extractUsageFromMessage(message) {
 async function _createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, capturedPromptMessages, parentSpan) {
   if (messages.length === 0) return void 0;
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _307 => _307.message, 'optionalAccess', _308 => _308.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _308 => _308.message, 'optionalAccess', _309 => _309.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
@@ -13415,7 +13446,7 @@ async function _createLLMSpanForMessages(messages, prompt, conversationHistory,
     capturedPromptMessages
   );
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _309 => _309.message, 'optionalAccess', _310 => _310.content]) && _optionalChain([m, 'access', _311 => _311.message, 'optionalAccess', _312 => _312.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _310 => _310.message, 'optionalAccess', _311 => _311.content]) && _optionalChain([m, 'access', _312 => _312.message, 'optionalAccess', _313 => _313.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter((c) => c !== void 0);
   await traced(
     (llmSpan) => {
@@ -13435,7 +13466,7 @@ async function _createLLMSpanForMessages(messages, prompt, conversationHistory,
       parent: parentSpan
     }
   );
-  return _optionalChain([lastMessage, 'access', _313 => _313.message, 'optionalAccess', _314 => _314.content]) && _optionalChain([lastMessage, 'access', _315 => _315.message, 'optionalAccess', _316 => _316.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _314 => _314.message, 'optionalAccess', _315 => _315.content]) && _optionalChain([lastMessage, 'access', _316 => _316.message, 'optionalAccess', _317 => _317.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 function wrapClaudeAgentSDK(sdk) {
   const cache = /* @__PURE__ */ new Map();
@@ -13709,7 +13740,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _317 => _317.config, 'optionalAccess', _318 => _318.tools])) {
+  if (!_optionalChain([params, 'access', _318 => _318.config, 'optionalAccess', _319 => _319.tools])) {
     return null;
   }
   try {
@@ -13792,7 +13823,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _319 => _319.content, 'optionalAccess', _320 => _320.parts])) {
+        if (_optionalChain([candidate, 'access', _320 => _320.content, 'optionalAccess', _321 => _321.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -13823,7 +13854,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _321 => _321.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _322 => _322.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -15280,7 +15311,7 @@ var CachedSpanFetcher = (_class19 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _322 => _322.span_attributes, 'optionalAccess', _323 => _323.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _323 => _323.span_attributes, 'optionalAccess', _324 => _324.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -15314,7 +15345,7 @@ var CachedSpanFetcher = (_class19 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _324 => _324.span_attributes, 'optionalAccess', _325 => _325.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _325 => _325.span_attributes, 'optionalAccess', _326 => _326.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -15394,11 +15425,11 @@ var LocalTrace = (_class20 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _326 => _326.span_attributes, 'optionalAccess', _327 => _327.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _327 => _327.span_attributes, 'optionalAccess', _328 => _328.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _328 => _328.span_attributes, 'optionalAccess', _329 => _329.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _329 => _329.span_attributes, 'optionalAccess', _330 => _330.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -15417,7 +15448,7 @@ var LocalTrace = (_class20 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _330 => _330.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _331 => _331.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -15428,7 +15459,7 @@ var LocalTrace = (_class20 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _331 => _331.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _332 => _332.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -15587,10 +15618,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', _332 => _332.errors, 'optionalAccess', _333 => _333.map, 'call', _334 => _334((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _333 => _333.errors, 'optionalAccess', _334 => _334.map, 'call', _335 => _335((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _335 => _335.join, 'call', _336 => _336(", ")]);
+    }), 'access', _336 => _336.join, 'call', _337 => _337(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return parameters;
@@ -15706,6 +15737,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
       experiment: evaluator.experimentName,
       description: evaluator.description,
       metadata: evaluator.metadata,
+      tags: evaluator.tags,
       isPublic: evaluator.isPublic,
       update: evaluator.update,
       baseExperiment: _nullishCoalesce(evaluator.baseExperimentName, () => ( defaultBaseExperiment)),
@@ -15831,7 +15863,7 @@ var defaultErrorScoreHandler = ({
 };
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _337 => _337.spanCache, 'optionalAccess', _338 => _338.start, 'call', _339 => _339()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _338 => _338.spanCache, 'optionalAccess', _339 => _339.start, 'call', _340 => _340()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -15942,7 +15974,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _340 => _340.data, 'access', async _341 => _341.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _341 => _341.data, 'access', async _342 => _342.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -15968,10 +16000,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _342 => _342({
+                    _optionalChain([stream, 'optionalCall', _343 => _343({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _343 => _343.event, 'optionalAccess', _344 => _344.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _344 => _344.event, 'optionalAccess', _345 => _345.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -16135,7 +16167,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _345 => _345.event, 'optionalAccess', _346 => _346.origin])
+              origin: _optionalChain([baseEvent, 'access', _346 => _346.event, 'optionalAccess', _347 => _347.origin])
             });
           }
         };
@@ -16168,7 +16200,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _347 => _347.setTotal, 'optionalCall', _348 => _348(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _348 => _348.setTotal, 'optionalCall', _349 => _349(evaluator.evalName, scheduledTrials)]);
           q.push({ datum, trialIndex });
         }
       }
@@ -16243,9 +16275,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _349 => _349.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _350 => _350.dispose, 'call', _351 => _351()]);
-      _optionalChain([spanCache, 'optionalAccess', _352 => _352.stop, 'call', _353 => _353()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _350 => _350.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _351 => _351.dispose, 'call', _352 => _352()]);
+      _optionalChain([spanCache, 'optionalAccess', _353 => _353.stop, 'call', _354 => _354()]);
     }
   }
 }