braintrust 2.2.1-rc.0 → 2.2.1

package/dist/browser.js

@@ -1928,7 +1928,8 @@ var SpanType = _v3.z.union([
     "automation",
     "facet",
     "preprocessor",
-    "classifier"
+    "classifier",
+    "review"
   ]),
   _v3.z.null()
 ]);
@@ -12695,14 +12696,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 */ },
@@ -12730,6 +12734,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', _267 => _267.status])) {
+          metadata["claude_agent_sdk.status"] = response.status;
+        }
+        if (_optionalChain([response, 'optionalAccess', _268 => _268.totalDurationMs])) {
+          metadata["claude_agent_sdk.duration_ms"] = response.totalDurationMs;
+        }
+        if (_optionalChain([response, 'optionalAccess', _269 => _269.totalToolUseCount]) !== void 0) {
+          metadata["claude_agent_sdk.tool_use_count"] = response.totalToolUseCount;
+        }
+        subAgentSpan.log({
+          output: _optionalChain([response, 'optionalAccess', _270 => _270.content]),
+          metadata
+        });
+      } finally {
+        subAgentSpan.end();
+        endedSubAgentSpans.add(toolUseID);
+      }
+      return {};
+    }
     const toolSpan = activeToolSpans.get(toolUseID);
     if (!toolSpan) {
       return {};
@@ -12746,6 +12774,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 {};
@@ -12770,12 +12808,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 {
@@ -12821,18 +12861,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', _271 => _271()]);
+          }
+        })();
+        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)
         }
       });
@@ -12843,19 +12910,28 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
       let currentMessageStartTime = getCurrentUnixTimestamp();
       const currentMessages = [];
       const createLLMSpan = async () => {
+        const parentToolUseId = _nullishCoalesce(_optionalChain([currentMessages, 'access', _272 => _272[0], 'optionalAccess', _273 => _273.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', _267 => _267.message, 'optionalAccess', _268 => _268.usage])) {
+        if (_optionalChain([lastMessage, 'optionalAccess', _274 => _274.message, 'optionalAccess', _275 => _275.usage])) {
           const outputTokens = getNumberProperty2(lastMessage.message.usage, "output_tokens") || 0;
           accumulatedOutputTokens += outputTokens;
         }
@@ -12863,12 +12939,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)
@@ -12877,20 +12975,55 @@ function wrapClaudeAgentQuery(queryFn, defaultThis) {
         try {
           for await (const message of originalGenerator) {
             const currentTime = getCurrentUnixTimestamp();
-            const messageId = _optionalChain([message, 'access', _269 => _269.message, 'optionalAccess', _270 => _270.id]);
+            if (message.type === "assistant" && Array.isArray(_optionalChain([message, 'access', _276 => _276.message, 'optionalAccess', _277 => _277.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', _278 => _278.input, 'optionalAccess', _279 => _279.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', _280 => _280.message, 'optionalAccess', _281 => _281.id]);
             if (messageId && messageId !== currentMessageId) {
               await createLLMSpan();
               currentMessageId = messageId;
               currentMessageStartTime = currentTime;
             }
-            if (message.type === "assistant" && _optionalChain([message, 'access', _271 => _271.message, 'optionalAccess', _272 => _272.usage])) {
+            if (message.type === "assistant" && _optionalChain([message, 'access', _282 => _282.message, 'optionalAccess', _283 => _283.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', _273 => _273.message, 'optionalAccess', _274 => _274.usage])) {
+                if (_optionalChain([lastMessage, 'optionalAccess', _284 => _284.message, 'optionalAccess', _285 => _285.usage])) {
                   const adjustedTokens = finalUsageMetrics.completion_tokens - accumulatedOutputTokens;
                   if (adjustedTokens >= 0) {
                     lastMessage.message.usage.output_tokens = adjustedTokens;
@@ -12922,6 +13055,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();
         }
       })();
@@ -12949,19 +13098,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', _286 => _286.message, 'optionalAccess', _287 => _287.role]);
+      const content = _optionalChain([msg, 'access', _288 => _288.message, 'optionalAccess', _289 => _289.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', _275 => _275.message, 'optionalAccess', _276 => _276.usage]);
+    usage = _optionalChain([message, 'access', _290 => _290.message, 'optionalAccess', _291 => _291.usage]);
   } else if (message.type === "result") {
     usage = message.usage;
   }
@@ -12990,17 +13150,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', _277 => _277.message, 'optionalAccess', _278 => _278.usage])) {
+  if (lastMessage.type !== "assistant" || !_optionalChain([lastMessage, 'access', _292 => _292.message, 'optionalAccess', _293 => _293.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', _279 => _279.message, 'optionalAccess', _280 => _280.content]) && _optionalChain([m, 'access', _281 => _281.message, 'optionalAccess', _282 => _282.role]) ? { content: m.message.content, role: m.message.role } : void 0
+    (m) => _optionalChain([m, 'access', _294 => _294.message, 'optionalAccess', _295 => _295.content]) && _optionalChain([m, 'access', _296 => _296.message, 'optionalAccess', _297 => _297.role]) ? { content: m.message.content, role: m.message.role } : void 0
   ).filter((c) => c !== void 0);
   await traced(
     (llmSpan) => {
@@ -13020,7 +13184,7 @@ async function _createLLMSpanForMessages(messages, prompt, conversationHistory,
       parent: parentSpan
     }
   );
-  return _optionalChain([lastMessage, 'access', _283 => _283.message, 'optionalAccess', _284 => _284.content]) && _optionalChain([lastMessage, 'access', _285 => _285.message, 'optionalAccess', _286 => _286.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
+  return _optionalChain([lastMessage, 'access', _298 => _298.message, 'optionalAccess', _299 => _299.content]) && _optionalChain([lastMessage, 'access', _300 => _300.message, 'optionalAccess', _301 => _301.role]) ? { content: lastMessage.message.content, role: lastMessage.message.role } : void 0;
 }
 function wrapClaudeAgentSDK(sdk) {
   const cache = /* @__PURE__ */ new Map();
@@ -13294,7 +13458,7 @@ function serializePart(part) {
   return part;
 }
 function serializeTools(params) {
-  if (!_optionalChain([params, 'access', _287 => _287.config, 'optionalAccess', _288 => _288.tools])) {
+  if (!_optionalChain([params, 'access', _302 => _302.config, 'optionalAccess', _303 => _303.tools])) {
     return null;
   }
   try {
@@ -13377,7 +13541,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
-        if (_optionalChain([candidate, 'access', _289 => _289.content, 'optionalAccess', _290 => _290.parts])) {
+        if (_optionalChain([candidate, 'access', _304 => _304.content, 'optionalAccess', _305 => _305.parts])) {
           for (const part of candidate.content.parts) {
             if (part.text !== void 0) {
               if (part.thought) {
@@ -13408,7 +13572,7 @@ function aggregateGenerateContentChunks(chunks, start, firstTokenTime) {
     parts.push({ text });
   }
   parts.push(...otherParts);
-  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _291 => _291.candidates])) {
+  if (parts.length > 0 && _optionalChain([lastResponse, 'optionalAccess', _306 => _306.candidates])) {
     const candidates = [];
     for (const candidate of lastResponse.candidates) {
       const candidateDict = {
@@ -13755,7 +13919,7 @@ function unescapePath(path) {
 }
 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();
@@ -13826,7 +13990,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) {
@@ -13880,7 +14044,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;
@@ -13972,7 +14135,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);
     }
@@ -13998,7 +14161,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);
@@ -14015,7 +14178,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) {
@@ -14058,7 +14221,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);
     }
   }
@@ -14454,7 +14617,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();
       });
@@ -14866,7 +15029,7 @@ var CachedSpanFetcher = (_class18 = class {
           spanType
         );
         const rows = await fetcher.fetchedData();
-        return rows.filter((row) => _optionalChain([row, 'access', _292 => _292.span_attributes, 'optionalAccess', _293 => _293.purpose]) !== "scorer").map((row) => ({
+        return rows.filter((row) => _optionalChain([row, 'access', _307 => _307.span_attributes, 'optionalAccess', _308 => _308.purpose]) !== "scorer").map((row) => ({
           input: row.input,
           output: row.output,
           metadata: row.metadata,
@@ -14900,7 +15063,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', _294 => _294.span_attributes, 'optionalAccess', _295 => _295.type]), () => ( ""));
+      const type = _nullishCoalesce(_optionalChain([span, 'access', _309 => _309.span_attributes, 'optionalAccess', _310 => _310.type]), () => ( ""));
       const existing = _nullishCoalesce(this.spanCache.get(type), () => ( []));
       existing.push(span);
       this.spanCache.set(type, existing);
@@ -14980,11 +15143,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', _296 => _296.span_attributes, 'optionalAccess', _297 => _297.purpose]) !== "scorer"
+        (span) => _optionalChain([span, 'access', _311 => _311.span_attributes, 'optionalAccess', _312 => _312.purpose]) !== "scorer"
       );
       if (spanType && spanType.length > 0) {
         spans = spans.filter(
-          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _298 => _298.span_attributes, 'optionalAccess', _299 => _299.type]), () => ( "")))
+          (span) => spanType.includes(_nullishCoalesce(_optionalChain([span, 'access', _313 => _313.span_attributes, 'optionalAccess', _314 => _314.type]), () => ( "")))
         );
       }
       return spans.map((span) => ({
@@ -15003,7 +15166,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', _300 => _300.preprocessor]), () => ( "project_default"));
+    const cacheKey = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _315 => _315.preprocessor]), () => ( "project_default"));
     if (!this.threadCache.has(cacheKey)) {
       const promise = this.fetchThread(options);
       this.threadCache.set(cacheKey, promise);
@@ -15014,7 +15177,7 @@ var LocalTrace = (_class19 = class {
     await this.ensureSpansReady();
     await this.state.login({});
     const result = await invoke({
-      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _301 => _301.preprocessor]), () => ( "project_default")),
+      globalFunction: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _316 => _316.preprocessor]), () => ( "project_default")),
       functionType: "preprocessor",
       input: {
         trace_ref: {
@@ -15173,10 +15336,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', _302 => _302.errors, 'optionalAccess', _303 => _303.map, 'call', _304 => _304((err) => {
+    const errorMessages = _optionalChain([validate, 'access', _317 => _317.errors, 'optionalAccess', _318 => _318.map, 'call', _319 => _319((err) => {
       const path = err.instancePath || "root";
       return `${path}: ${err.message}`;
-    }), 'access', _305 => _305.join, 'call', _306 => _306(", ")]);
+    }), 'access', _320 => _320.join, 'call', _321 => _321(", ")]);
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
   return parameters;
@@ -15232,7 +15395,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) {
@@ -15417,7 +15580,7 @@ var defaultErrorScoreHandler = ({
 };
 async function runEvaluatorInternal(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults, enableCache) {
   if (enableCache) {
-    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _307 => _307.spanCache, 'optionalAccess', _308 => _308.start, 'call', _309 => _309()]);
+    _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _322 => _322.spanCache, 'optionalAccess', _323 => _323.start, 'call', _324 => _324()]);
   }
   try {
     if (typeof evaluator.data === "string") {
@@ -15453,7 +15616,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)) {
@@ -15528,7 +15691,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
             ) : "experiment",
-            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _310 => _310.data, 'access', async _311 => _311.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
+            objectId: await _asyncNullishCoalesce(await _asyncOptionalChain([parentComponents, 'optionalAccess', async _325 => _325.data, 'access', async _326 => _326.object_id]), async () => ( (experimentIdPromise ? await _asyncNullishCoalesce(await experimentIdPromise, async () => ( "")) : ""))),
             rootSpanId: rootSpan.rootSpanId,
             ensureSpansFlushed,
             state
@@ -15554,10 +15717,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   span,
                   parameters: _nullishCoalesce(parameters, () => ( {})),
                   reportProgress: (event) => {
-                    _optionalChain([stream, 'optionalCall', _312 => _312({
+                    _optionalChain([stream, 'optionalCall', _327 => _327({
                       ...event,
                       id: rootSpan.id,
-                      origin: _optionalChain([baseEvent, 'access', _313 => _313.event, 'optionalAccess', _314 => _314.origin]),
+                      origin: _optionalChain([baseEvent, 'access', _328 => _328.event, 'optionalAccess', _329 => _329.origin]),
                       name: evaluator.evalName,
                       object_type: "task"
                     })]);
@@ -15721,7 +15884,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               metadata,
               scores: mergedScores,
               error,
-              origin: _optionalChain([baseEvent, 'access', _315 => _315.event, 'optionalAccess', _316 => _316.origin])
+              origin: _optionalChain([baseEvent, 'access', _330 => _330.event, 'optionalAccess', _331 => _331.origin])
             });
           }
         };
@@ -15754,7 +15917,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             break;
           }
           scheduledTrials++;
-          _optionalChain([progressReporter, 'access', _317 => _317.setTotal, 'optionalCall', _318 => _318(evaluator.evalName, scheduledTrials)]);
+          _optionalChain([progressReporter, 'access', _332 => _332.setTotal, 'optionalCall', _333 => _333(evaluator.evalName, scheduledTrials)]);
           q.push({ datum, trialIndex });
         }
       }
@@ -15829,9 +15992,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     );
   } finally {
     if (enableCache) {
-      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _319 => _319.spanCache]);
-      _optionalChain([spanCache, 'optionalAccess', _320 => _320.dispose, 'call', _321 => _321()]);
-      _optionalChain([spanCache, 'optionalAccess', _322 => _322.stop, 'call', _323 => _323()]);
+      const spanCache = _optionalChain([(_nullishCoalesce(evaluator.state, () => ( _internalGetGlobalState()))), 'optionalAccess', _334 => _334.spanCache]);
+      _optionalChain([spanCache, 'optionalAccess', _335 => _335.dispose, 'call', _336 => _336()]);
+      _optionalChain([spanCache, 'optionalAccess', _337 => _337.stop, 'call', _338 => _338()]);
     }
   }
 }