braintrust 2.2.1-rc.0 → 2.2.1

package/dist/index.js

@@ -2150,7 +2150,8 @@ var SpanType = _v3.z.union([
     "automation",
     "facet",
     "preprocessor",
-    "classifier"
+    "classifier",
+    "review"
   ]),
   _v3.z.null()
 ]);
@@ -12922,14 +12923,17 @@ function parseToolName(rawToolName) {
     rawToolName
   };
 }
-function createToolTracingHooks(parentSpanExportPromise, activeToolSpans, mcpServers) {
+function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, subAgentSpans, endedSubAgentSpans) {
   const preToolUse = async (input, toolUseID) => {
     if (input.hook_event_name !== "PreToolUse" || !toolUseID) {
       return {};
     }
+    if (input.tool_name === "Task") {
+      return {};
+    }
     const parsed = parseToolName(input.tool_name);
     const mcpMetadata = getMcpServerMetadata(parsed.mcpServer, mcpServers);
-    const parentExport = await parentSpanExportPromise;
+    const parentExport = await resolveParentSpan(toolUseID);
     const toolSpan = startSpan({
       name: parsed.displayName,
       spanAttributes: { type: "tool" /* TOOL */ },
@@ -12957,6 +12961,30 @@ function createToolTracingHooks(parentSpanExportPromise, activeToolSpans, mcpSer
     if (input.hook_event_name !== "PostToolUse" || !toolUseID) {
       return {};
     }
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan) {
+      try {
+        const response = input.tool_response;
+        const metadata = {};
+        if (_optionalChain([response, 'optionalAccess', _276 => _276.status])) {
+          metadata["claude_agent_sdk.status"] = response.status;
+        }
+        if (_optionalChain([response, 'optionalAccess', _277 => _277.totalDurationMs])) {
+          metadata["claude_agent_sdk.duration_ms"] = response.totalDurationMs;
+        }
+        if (_optionalChain([response, 'optionalAccess', _278 => _278.totalToolUseCount]) !== void 0) {
+          metadata["claude_agent_sdk.tool_use_count"] = response.totalToolUseCount;
+        }
+        subAgentSpan.log({
+          output: _optionalChain([response, 'optionalAccess', _279 => _279.content]),
+          metadata
+        });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
     const toolSpan = activeToolSpans.get(toolUseID);
     if (!toolSpan) {
       return {};
@@ -12973,6 +13001,16 @@ function createToolTracingHooks(parentSpanExportPromise, activeToolSpans, mcpSer
     if (input.hook_event_name !== "PostToolUseFailure" || !toolUseID) {
       return {};
     }
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan) {
+      try {
+        subAgentSpan.log({ error: input.error });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
     const toolSpan = activeToolSpans.get(toolUseID);
     if (!toolSpan) {
       return {};
@@ -12997,12 +13035,14 @@ function createToolTracingHooks(parentSpanExportPromise, activeToolSpans, mcpSer
   };
   return { preToolUse, postToolUse, postToolUseFailure };
 }
-function injectTracingHooks(options, parentSpanExportPromise, activeToolSpans) {
+function injectTracingHooks(options, resolveParentSpan, activeToolSpans, subAgentSpans, endedSubAgentSpans) {
   const mcpServers = options.mcpServers;
   const { preToolUse, postToolUse, postToolUseFailure } = createToolTracingHooks(
-    parentSpanExportPromise,
+    resolveParentSpan,
     activeToolSpans,
-    mcpServers
+    mcpServers,
+    subAgentSpans,
+    endedSubAgentSpans
   );
   const existingHooks = _nullishCoalesce(options.hooks, () => ( {}));
   return {
@@ -13048,18 +13088,45 @@ function filterSerializableOptions(options) {
   }
   return filtered;
 }
+function isAsyncIterable(value) {
+  return value !== null && value !== void 0 && typeof value[Symbol.asyncIterator] === "function";
+}
 function wrapClaudeAgentQuery(queryFn, defaultThis) {
   const proxy = new Proxy(queryFn, {
     apply(target, thisArg, argArray) {
       const params = _nullishCoalesce(argArray[0], () => ( {}));
       const { prompt, options = {} } = params;
+      const promptIsAsyncIterable = isAsyncIterable(prompt);
+      let capturedPromptMessages;
+      let promptForQuery = prompt;
+      let promptStarted = false;
+      let resolvePromptDone;
+      const promptDone = new Promise((resolve) => {
+        resolvePromptDone = resolve;
+      });
+      if (promptIsAsyncIterable) {
+        capturedPromptMessages = [];
+        const originalPrompt = prompt;
+        const capturingPrompt = (async function* () {
+          promptStarted = true;
+          try {
+            for await (const msg of originalPrompt) {
+              capturedPromptMessages.push(msg);
+              yield msg;
+            }
+          } finally {
+            _optionalChain([resolvePromptDone, 'optionalCall', _280 => _280()]);
+          }
+        })();
+        promptForQuery = capturingPrompt;
+      }
       const span = startSpan({
         name: "Claude Agent",
         spanAttributes: {
           type: "task" /* TASK */
         },
         event: {
-          input: typeof prompt === "string" ? prompt : { type: "streaming", description: "AsyncIterable<SDKMessage>" },
+          input: typeof prompt === "string" ? prompt : promptIsAsyncIterable ? void 0 : prompt !== void 0 ? String(prompt) : void 0,
           metadata: filterSerializableOptions(options)
         }
       });
@@ -13070,19 +13137,28 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
       let currentMessageStartTime = getCurrentUnixTimestamp();
       const currentMessages = [];
       const createLLMSpan = async () => {
+        const parentToolUseId = _nullishCoalesce(_optionalChain([currentMessages, 'access', _281 => _281[0], 'optionalAccess', _282 => _282.parent_tool_use_id]), () => ( null));
+        let parentSpanExport;
+        if (parentToolUseId) {
+          const subAgentSpan = subAgentSpans.get(parentToolUseId);
+          parentSpanExport = subAgentSpan ? await subAgentSpan.export() : await span.export();
+        } else {
+          parentSpanExport = await span.export();
+        }
         const finalMessageContent = await _createLLMSpanForMessages(
           currentMessages,
           prompt,
           finalResults,
           options,
           currentMessageStartTime,
-          await span.export()
+          capturedPromptMessages,
+          parentSpanExport
         );
         if (finalMessageContent) {
           finalResults.push(finalMessageContent);
         }
         const lastMessage = currentMessages[currentMessages.length - 1];
-        if (_optionalChain([lastMessage, 'optionalAccess', _276 => _276.message, 'optionalAccess', _277 => _277.usage])) {
+        if (_optionalChain([lastMessage, 'optionalAccess', _283 => _283.message, 'optionalAccess', _284 => _284.usage])) {
           const outputTokens = getNumberProperty2(lastMessage.message.usage, "output_tokens") || 0;
           accumulatedOutputTokens += outputTokens;
         }
@@ -13090,12 +13166,34 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
       };
       const invocationTarget = thisArg === proxy || thisArg === void 0 ? _nullishCoalesce(defaultThis, () => ( thisArg)) : thisArg;
       const activeToolSpans = /* @__PURE__ */ new Map();
+      const subAgentSpans = /* @__PURE__ */ new Map();
+      const endedSubAgentSpans = /* @__PURE__ */ new Set();
+      const toolUseToParent = /* @__PURE__ */ new Map();
+      const pendingSubAgentNames = /* @__PURE__ */ new Map();
+      const resolveParentSpan = async (toolUseID) => {
+        const parentToolUseId = toolUseToParent.get(toolUseID);
+        if (parentToolUseId) {
+          const subAgentSpan = subAgentSpans.get(parentToolUseId);
+          if (subAgentSpan) {
+            return subAgentSpan.export();
+          }
+        }
+        return span.export();
+      };
       const optionsWithHooks = injectTracingHooks(
         options,
-        span.export(),
-        activeToolSpans
+        resolveParentSpan,
+        activeToolSpans,
+        subAgentSpans,
+        endedSubAgentSpans
       );
-      const modifiedArgArray = [{ ...params, options: optionsWithHooks }];
+      const modifiedArgArray = [
+        {
+          ...params,
+          ...promptForQuery !== void 0 ? { prompt: promptForQuery } : {},
+          options: optionsWithHooks
+        }
+      ];
       const originalGenerator = withCurrent(
         span,
         () => Reflect.apply(target, invocationTarget, modifiedArgArray)
@@ -13104,20 +13202,55 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
         try {
           for await (const message of originalGenerator) {
             const currentTime = getCurrentUnixTimestamp();
-            const messageId = _optionalChain([message, 'access', _278 => _278.message, 'optionalAccess', _279 => _279.id]);
+            if (message.type === "assistant" && Array.isArray(_optionalChain([message, 'access', _285 => _285.message, 'optionalAccess', _286 => _286.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', _287 => _287.input, 'optionalAccess', _288 => _288.subagent_type])) {
+                    pendingSubAgentNames.set(
+                      block.id,
+                      block.input.subagent_type
+                    );
+                  }
+                }
+              }
+            }
+            if ("parent_tool_use_id" in message) {
+              const parentToolUseId = message.parent_tool_use_id;
+              if (parentToolUseId && !subAgentSpans.has(parentToolUseId)) {
+                const agentName = pendingSubAgentNames.get(parentToolUseId);
+                const spanName = agentName ? `Agent: ${agentName}` : "Agent: sub-agent";
+                const parentExport = await span.export();
+                const subAgentSpan = startSpan({
+                  name: spanName,
+                  spanAttributes: { type: "task" /* TASK */ },
+                  event: {
+                    metadata: {
+                      ...agentName && {
+                        "claude_agent_sdk.agent_type": agentName
+                      }
+                    }
+                  },
+                  parent: parentExport
+                });
+                subAgentSpans.set(parentToolUseId, subAgentSpan);
+              }
+            }
+            const messageId = _optionalChain([message, 'access', _289 => _289.message, 'optionalAccess', _290 => _290.id]);
             if (messageId && messageId !== currentMessageId) {
               await createLLMSpan();
               currentMessageId = messageId;
               currentMessageStartTime = currentTime;
             }
-            if (message.type === "assistant" && _optionalChain([message, 'access', _280 => _280.message, 'optionalAccess', _281 => _281.usage])) {
+            if (message.type === "assistant" && _optionalChain([message, 'access', _291 => _291.message, 'optionalAccess', _292 => _292.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', _282 => _282.message, 'optionalAccess', _283 => _283.usage])) {
+                if (_optionalChain([lastMessage, 'optionalAccess', _293 => _293.message, 'optionalAccess', _294 => _294.usage])) {
                   const adjustedTokens = finalUsageMetrics.completion_tokens - accumulatedOutputTokens;
                   if (adjustedTokens >= 0) {
                     lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -13149,6 +13282,22 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
           });
           throw error;
         } finally {
+          for (const [id, subSpan] of subAgentSpans) {
+            if (!endedSubAgentSpans.has(id)) {
+              subSpan.end();
+            }
+          }
+          subAgentSpans.clear();
+          if (capturedPromptMessages) {
+            if (promptStarted) {
+              await promptDone;
+            }
+            if (capturedPromptMessages.length > 0) {
+              span.log({
+                input: _formatCapturedMessages(capturedPromptMessages)
+              });
+            }
+          }
           span.end();
         }
       })();
@@ -13176,19 +13325,30 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
   });
   return proxy;
 }
-function _buildLLMInput(prompt, conversationHistory) {
-  const promptMessage = typeof prompt === "string" ? { content: prompt, role: "user" } : void 0;
-  const inputParts = [
-    ...promptMessage ? [promptMessage] : [],
-    ...conversationHistory
-  ];
+function _buildLLMInput(prompt, conversationHistory, capturedPromptMessages) {
+  const promptMessages = [];
+  if (typeof prompt === "string") {
+    promptMessages.push({ content: prompt, role: "user" });
+  } else if (capturedPromptMessages && capturedPromptMessages.length > 0) {
+    for (const msg of capturedPromptMessages) {
+      const role = _optionalChain([msg, 'access', _295 => _295.message, 'optionalAccess', _296 => _296.role]);
+      const content = _optionalChain([msg, 'access', _297 => _297.message, 'optionalAccess', _298 => _298.content]);
+      if (role && content !== void 0) {
+        promptMessages.push({ content, role });
+      }
+    }
+  }
+  const inputParts = [...promptMessages, ...conversationHistory];
   return inputParts.length > 0 ? inputParts : void 0;
 }
+function _formatCapturedMessages(messages) {
+  return messages.length > 0 ? messages : [];
+}
 function _extractUsageFromMessage(message) {
   const metrics = {};
   let usage;
   if (message.type === "assistant") {
-    usage = _optionalChain([message, 'access', _284 => _284.message, 'optionalAccess', _285 => _285.usage]);
+    usage = _optionalChain([message, 'access', _299 => _299.message, 'optionalAccess', _300 => _300.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -13217,17 +13377,21 @@ function _extractUsageFromMessage(message) {
   }
   return metrics;
 }
-async function _createLLMSpanForMessages(messages, prompt, conversationHistory, options, startTime, parentSpan) {
+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', _286 => _286.message, 'optionalAccess', _287 => _287.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _301 => _301.message, 'optionalAccess', _302 => _302.usage])) {
     return void 0;
   }
   const model = lastMessage.message.model || options.model;
   const usage = _extractUsageFromMessage(lastMessage);
-  const input = _buildLLMInput(prompt, conversationHistory);
+  const input = _buildLLMInput(
+    prompt,
+    conversationHistory,
+    capturedPromptMessages
+  );
   const outputs = messages.map(
-    (m) => _optionalChain([m, 'access', _288 => _288.message, 'optionalAccess', _289 => _289.content]) && _optionalChain([m, 'access', _290 => _290.message, 'optionalAccess', _291 => _291.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _303 => _303.message, 'optionalAccess', _304 => _304.content]) && _optionalChain([m, 'access', _305 => _305.message, 'optionalAccess', _306 => _306.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter((c) => c !== void 0);
   await traced(
     (llmSpan) => {
@@ -13247,7 +13411,7 @@ async function _createLLMSpanForMessages(messages, prompt, conversationHistory,
       parent: parentSpan
     }
   );
-  return _optionalChain([lastMessage, 'access', _292 => _292.message, 'optionalAccess', _293 => _293.content]) && _optionalChain([lastMessage, 'access', _294 => _294.message, 'optionalAccess', _295 => _295.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _307 => _307.message, 'optionalAccess', _308 => _308.content]) && _optionalChain([lastMessage, 'access', _309 => _309.message, 'optionalAccess', _310 => _310.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 function wrapClaudeAgentSDK(sdk) {
   const cache = /* @__PURE__ */ new Map();
@@ -13521,7 +13685,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _296 => _296.config, 'optionalAccess', _297 => _297.tools])) {
+  if (!_optionalChain([params, 'access', _311 => _311.config, 'optionalAccess', _312 => _312.tools])) {
     return null;
   }
   try {
@@ -13604,7 +13768,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _298 => _298.content, 'optionalAccess', _299 => _299.parts])) {
+        if (_optionalChain([candidate, 'access', _313 => _313.content, 'optionalAccess', _314 => _314.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -13635,7 +13799,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _300 => _300.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _315 => _315.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -13982,7 +14146,7 @@ function unescapePath(path2) {
 }
 var graph_framework_default = { createGraph };
 
-// ../node_modules/.pnpm/async@3.2.5/node_modules/async/dist/async.mjs
+// ../node_modules/async/dist/async.mjs
 function initialParams(fn) {
   return function(...args) {
     var callback = args.pop();
@@ -14053,7 +14217,7 @@ function isAsync(fn) {
 function isAsyncGenerator2(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable(obj) {
+function isAsyncIterable2(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -14107,7 +14271,6 @@ 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;
@@ -14199,7 +14362,7 @@ function asyncEachOfLimit(generator, limit, iteratee, callback) {
       canceled = true;
       return;
     }
-    if (result === breakLoop$1 || done && running <= 0) {
+    if (result === breakLoop || done && running <= 0) {
       done = true;
       return callback(null);
     }
@@ -14225,7 +14388,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator2(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable(obj)) {
+    if (isAsyncIterable2(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -14242,7 +14405,7 @@ var eachOfLimit$2 = (limit) => {
       } else if (err === false) {
         done = true;
         canceled = true;
-      } else if (value === breakLoop$1 || done && running <= 0) {
+      } else if (value === breakLoop || done && running <= 0) {
         done = true;
         return callback(null);
       } else if (!looping) {
@@ -14285,7 +14448,7 @@ function eachOfArrayLike(coll, iteratee, callback) {
     if (canceled === true) return;
     if (err) {
       callback(err);
-    } else if (++completed === length || value === breakLoop$1) {
+    } else if (++completed === length || value === breakLoop) {
       callback(null);
     }
   }
@@ -14681,7 +14844,7 @@ function _createTester(check, getResult) {
         if (check(result) && !testResult) {
           testPassed = true;
           testResult = getResult(true, value);
-          return callback(null, breakLoop$1);
+          return callback(null, breakLoop);
         }
         callback();
       });
@@ -15093,7 +15256,7 @@ var CachedSpanFetcher = (_class18 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _301 => _301.span_attributes, 'optionalAccess', _302 => _302.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _316 => _316.span_attributes, 'optionalAccess', _317 => _317.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -15127,7 +15290,7 @@ var CachedSpanFetcher = (_class18 = class {
   async fetchSpans(spanType) {
     const spans = await this.fetchFn(spanType);
     for (const span of spans) {
-      const type = _nullishCoalesce(_optionalChain([span, 'access', _303 => _303.span_attributes, 'optionalAccess', _304 => _304.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _318 => _318.span_attributes, 'optionalAccess', _319 => _319.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -15207,11 +15370,11 @@ var LocalTrace = (_class19 = class {
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
       let spans = cachedSpans.filter(
-        (span) => _optionalChain([span, 'access', _305 => _305.span_attributes, 'optionalAccess', _306 => _306.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _320 => _320.span_attributes, 'optionalAccess', _321 => _321.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _307 => _307.span_attributes, 'optionalAccess', _308 => _308.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _322 => _322.span_attributes, 'optionalAccess', _323 => _323.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -15230,7 +15393,7 @@ var LocalTrace = (_class19 = class {
    * Calls the API with the project_default preprocessor (which falls back to "thread").
    */
   async getThread(options) {
-    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _309 => _309.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _324 => _324.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -15241,7 +15404,7 @@ var LocalTrace = (_class19 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _310 => _310.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _325 => _325.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -15400,10 +15563,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', _311 => _311.errors, 'optionalAccess', _312 => _312.map, 'call', _313 => _313((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _326 => _326.errors, 'optionalAccess', _327 => _327.map, 'call', _328 => _328((err) => {
       const path2 = err.instancePath || "root";
       return `${path2}: ${err.message}`;
-    }), 'access', _314 => _314.join, 'call', _315 => _315(", ")]);
+    }), 'access', _329 => _329.join, 'call', _330 => _330(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return parameters;
@@ -15459,7 +15622,7 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable2(value) {
+function isAsyncIterable3(value) {
   return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
 }
 function isIterable(value) {
@@ -15644,7 +15807,7 @@ var defaultErrorScoreHandler = ({
 };
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _316 => _316.spanCache, 'optionalAccess', _317 => _317.start, 'call', _318 => _318()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _331 => _331.spanCache, 'optionalAccess', _332 => _332.start, 'call', _333 => _333()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -15680,7 +15843,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     }
     const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
     const dataIterable = (() => {
-      if (isAsyncIterable2(resolvedDataResult)) {
+      if (isAsyncIterable3(resolvedDataResult)) {
         return resolvedDataResult;
       }
       if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
@@ -15755,7 +15918,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _319 => _319.data, 'access', async _320 => _320.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _334 => _334.data, 'access', async _335 => _335.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -15781,10 +15944,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _321 => _321({
+                    _optionalChain([stream, 'optionalCall', _336 => _336({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _322 => _322.event, 'optionalAccess', _323 => _323.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _337 => _337.event, 'optionalAccess', _338 => _338.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -15948,7 +16111,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _324 => _324.event, 'optionalAccess', _325 => _325.origin])
+              origin: _optionalChain([baseEvent, 'access', _339 => _339.event, 'optionalAccess', _340 => _340.origin])
             });
           }
         };
@@ -15981,7 +16144,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _326 => _326.setTotal, 'optionalCall', _327 => _327(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _341 => _341.setTotal, 'optionalCall', _342 => _342(evaluator.evalName, scheduledTrials)]);
           q.push({ datum, trialIndex });
         }
       }
@@ -16056,9 +16219,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _328 => _328.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _329 => _329.dispose, 'call', _330 => _330()]);
-      _optionalChain([spanCache, 'optionalAccess', _331 => _331.stop, 'call', _332 => _332()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _343 => _343.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _344 => _344.dispose, 'call', _345 => _345()]);
+      _optionalChain([spanCache, 'optionalAccess', _346 => _346.stop, 'call', _347 => _347()]);
     }
   }
 }