braintrust 3.27.0 → 3.28.0

package/dist/workerd.mjs

@@ -1567,12 +1567,12 @@ function base64ToUint8Array(base64) {
   return uint8Array;
 }
 function uint8ArrayToString(uint8Array) {
-  const decoder = new TextDecoder("utf-8");
-  return decoder.decode(uint8Array);
+  const decoder2 = new TextDecoder("utf-8");
+  return decoder2.decode(uint8Array);
 }
 function stringToUint8Array(str) {
-  const encoder = new TextEncoder();
-  return encoder.encode(str);
+  const encoder2 = new TextEncoder();
+  return encoder2.encode(str);
 }
 
 // util/span_identifier_v3.ts
@@ -2476,7 +2476,8 @@ var AclObjectType = z6.union([
     "org_member",
     "project_log",
     "org_project",
-    "org_audit_logs"
+    "org_audit_logs",
+    "project_group"
   ]),
   z6.null()
 ]);
@@ -2605,7 +2606,8 @@ var AsyncScoringState = z6.union([
     token: z6.string(),
     function_ids: z6.array(z6.unknown()),
     skip_logging: z6.union([z6.boolean(), z6.null()]).optional(),
-    triggered_functions: z6.union([z6.record(TriggeredFunctionState), z6.null()]).optional()
+    triggered_functions: z6.union([z6.record(TriggeredFunctionState), z6.null()]).optional(),
+    last_triggered_xact_id: z6.union([z6.string(), z6.number(), z6.null()]).optional()
   }),
   z6.object({ status: z6.literal("disabled") }),
   z6.null(),
@@ -2674,7 +2676,7 @@ var FunctionTypeEnum = z6.enum([
   "parameters",
   "sandbox"
 ]);
-var NullableSavedFunctionId = z6.union([
+var FacetPreprocessorId = z6.union([
   z6.object({
     type: z6.literal("function"),
     id: z6.string(),
@@ -2685,10 +2687,23 @@ var NullableSavedFunctionId = z6.union([
     name: z6.string(),
     function_type: FunctionTypeEnum.optional().default("scorer")
   }),
+  z6.object({ type: z6.literal("inline"), code: z6.string().min(1) }),
   z6.null()
 ]);
+var SavedFunctionId = z6.union([
+  z6.object({
+    type: z6.literal("function"),
+    id: z6.string(),
+    version: z6.string().optional()
+  }),
+  z6.object({
+    type: z6.literal("global"),
+    name: z6.string(),
+    function_type: FunctionTypeEnum.optional().default("scorer")
+  })
+]);
 var TopicMapGenerationSettings = z6.object({
-  algorithm: z6.enum(["hdbscan", "kmeans"]),
+  algorithm: z6.enum(["hdbscan", "kmeans", "community"]),
   dimension_reduction: z6.enum(["umap", "pca", "none"]),
   sample_size: z6.number().int().gt(0).optional(),
   n_clusters: z6.number().int().gt(0).optional(),
@@ -2700,6 +2715,7 @@ var TopicMapGenerationSettings = z6.object({
 var TopicMapData = z6.object({
   type: z6.literal("topic_map"),
   source_facet: z6.string(),
+  source_facet_function: SavedFunctionId.and(z6.unknown()).optional(),
   embedding_model: z6.string(),
   bundle_key: z6.string().optional(),
   report_key: z6.string().optional(),
@@ -2713,7 +2729,7 @@ var TopicMapData = z6.object({
 });
 var BatchedFacetData = z6.object({
   type: z6.literal("batched_facet"),
-  preprocessor: NullableSavedFunctionId.and(z6.unknown()).optional(),
+  preprocessor: FacetPreprocessorId.optional(),
   facets: z6.array(
     z6.object({
       name: z6.string(),
@@ -2974,18 +2990,6 @@ var ObjectReferenceNullish = z6.union([
   }),
   z6.null()
 ]);
-var SavedFunctionId = z6.union([
-  z6.object({
-    type: z6.literal("function"),
-    id: z6.string(),
-    version: z6.string().optional()
-  }),
-  z6.object({
-    type: z6.literal("global"),
-    name: z6.string(),
-    function_type: FunctionTypeEnum.optional().default("scorer")
-  })
-]);
 var DatasetEvent = z6.object({
   id: z6.string(),
   _xact_id: z6.string(),
@@ -3207,7 +3211,7 @@ var ExtendedSavedFunctionId = z6.union([
 ]);
 var FacetData = z6.object({
   type: z6.literal("facet"),
-  preprocessor: NullableSavedFunctionId.and(z6.unknown()).optional(),
+  preprocessor: FacetPreprocessorId.optional(),
   prompt: z6.string(),
   model: z6.string().optional(),
   embedding_model: z6.string().optional(),
@@ -3712,6 +3716,19 @@ var MessageRole = z6.enum([
   "model",
   "developer"
 ]);
+var NullableSavedFunctionId = z6.union([
+  z6.object({
+    type: z6.literal("function"),
+    id: z6.string(),
+    version: z6.string().optional()
+  }),
+  z6.object({
+    type: z6.literal("global"),
+    name: z6.string(),
+    function_type: FunctionTypeEnum.optional().default("scorer")
+  }),
+  z6.null()
+]);
 var ObjectReference = z6.object({
   object_type: z6.enum([
     "project_logs",
@@ -3733,6 +3750,7 @@ var TraceScope = z6.object({
 });
 var OnlineScoreConfig = z6.union([
   z6.object({
+    status: AutomationStatus.optional(),
     sampling_rate: z6.number().gte(0).lte(1),
     scorers: z6.array(SavedFunctionId),
     btql_filter: z6.union([z6.string(), z6.null()]).optional(),
@@ -3813,6 +3831,72 @@ var Project = z6.object({
   user_id: z6.union([z6.string(), z6.null()]).optional(),
   settings: ProjectSettings.optional()
 });
+var WindowedAutomationConfig = z6.object({
+  event_type: z6.literal("windowed"),
+  product_origin: z6.union([z6.literal("patterns"), z6.null()]).optional(),
+  status: AutomationStatus.optional(),
+  threshold: z6.object({
+    calculation: z6.object({
+      type: z6.literal("btql"),
+      btql_query: z6.string().min(1),
+      output: z6.object({
+        type: z6.literal("scalar"),
+        value_column: z6.string().min(1)
+      })
+    }),
+    policy: z6.object({
+      condition: z6.object({
+        type: z6.literal("threshold"),
+        operator: z6.enum(["lt", "lte", "gt", "gte", "eq", "neq"]),
+        threshold: z6.number()
+      }),
+      pending_seconds: z6.number().int().gte(0).lte(2592e3),
+      no_data_behavior: z6.enum(["keep_last", "resolve", "alert"]),
+      renotify_interval_seconds: z6.union([z6.number(), z6.null()]).optional(),
+      notify_on_recovery: z6.boolean().optional().default(true)
+    })
+  }).optional(),
+  window: z6.object({
+    window_seconds: z6.number().int().gte(1).lte(2592e3),
+    schedule: z6.union([
+      z6.object({
+        type: z6.literal("interval"),
+        evaluation_interval_seconds: z6.number().int().gte(1).lte(2592e3)
+      }),
+      z6.object({
+        type: z6.literal("cron"),
+        cron_expression: z6.string().min(1),
+        timezone: z6.union([z6.string(), z6.null()]).optional()
+      })
+    ]),
+    evaluation_delay_seconds: z6.number().int().gte(0).lte(2592e3)
+  }),
+  loop: z6.object({
+    prompt: z6.string().min(1).max(1e4),
+    include_trigger_input: z6.boolean().optional().default(false),
+    agent_slug: z6.string().min(1),
+    auto_approve_tools: z6.array(z6.string().min(1)).optional().default([]),
+    harness: z6.enum(["native", "codex", "claude-code"]).optional(),
+    model: z6.string().min(1).optional(),
+    reasoning_effort: z6.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional()
+  }).optional(),
+  actions: z6.array(
+    z6.union([
+      z6.object({
+        type: z6.literal("webhook"),
+        url: z6.string(),
+        formatting_prompt: z6.string().min(1).max(1e4).optional()
+      }),
+      z6.object({
+        type: z6.literal("slack"),
+        workspace_id: z6.string(),
+        channel: z6.string(),
+        message_template: z6.string().optional(),
+        formatting_prompt: z6.string().min(1).max(1e4).optional()
+      })
+    ])
+  ).max(20).optional().default([])
+});
 var TopicAutomationFacetModel = z6.union([
   z6.enum(["brain-facet-latest", "brain-facet-1", "brain-facet-2"]),
   z6.null()
@@ -3854,7 +3938,8 @@ var TopicDigestAutomationConfig = z6.object({
     type: z6.literal("slack"),
     workspace_id: z6.string(),
     channel: z6.string(),
-    message_template: z6.string().optional()
+    message_template: z6.string().optional(),
+    formatting_prompt: z6.string().min(1).max(1e4).optional()
   }),
   topic_map_function_ids: z6.array(z6.string()).max(10).optional()
 });
@@ -3868,15 +3953,21 @@ var ProjectAutomation = z6.object({
   config: z6.union([
     z6.object({
       event_type: z6.literal("logs"),
+      status: AutomationStatus.optional(),
       btql_filter: z6.string(),
       interval_seconds: z6.number().gte(1).lte(2592e3),
       action: z6.union([
-        z6.object({ type: z6.literal("webhook"), url: z6.string() }),
+        z6.object({
+          type: z6.literal("webhook"),
+          url: z6.string(),
+          formatting_prompt: z6.string().min(1).max(1e4).optional()
+        }),
         z6.object({
           type: z6.literal("slack"),
           workspace_id: z6.string(),
           channel: z6.string(),
-          message_template: z6.string().optional()
+          message_template: z6.string().optional(),
+          formatting_prompt: z6.string().min(1).max(1e4).optional()
         })
       ])
     }),
@@ -3927,21 +4018,38 @@ var ProjectAutomation = z6.object({
     }),
     z6.object({
       event_type: z6.literal("environment_update"),
+      status: AutomationStatus.optional(),
       environment_filter: z6.array(z6.string()).optional(),
       action: z6.union([
-        z6.object({ type: z6.literal("webhook"), url: z6.string() }),
+        z6.object({
+          type: z6.literal("webhook"),
+          url: z6.string(),
+          formatting_prompt: z6.string().min(1).max(1e4).optional()
+        }),
         z6.object({
           type: z6.literal("slack"),
           workspace_id: z6.string(),
           channel: z6.string(),
-          message_template: z6.string().optional()
+          message_template: z6.string().optional(),
+          formatting_prompt: z6.string().min(1).max(1e4).optional()
         })
       ])
     }),
+    WindowedAutomationConfig,
     TopicAutomationConfig,
     TopicDigestAutomationConfig
   ])
 });
+var ProjectGroup = z6.object({
+  id: z6.string().uuid(),
+  org_id: z6.string().uuid(),
+  user_id: z6.union([z6.string(), z6.null()]).optional(),
+  created: z6.union([z6.string(), z6.null()]).optional(),
+  name: z6.string(),
+  description: z6.union([z6.string(), z6.null()]).optional(),
+  deleted_at: z6.union([z6.string(), z6.null()]).optional(),
+  member_projects: z6.array(z6.string().uuid()).max(1e4)
+});
 var ProjectLogsEvent = z6.object({
   id: z6.string(),
   _xact_id: z6.string(),
@@ -4159,7 +4267,8 @@ var RunEval = z6.object({
       dataset_environment: z6.union([z6.string(), z6.null()]).optional(),
       _internal_btql: z6.union([z6.object({}).partial().passthrough(), z6.null()]).optional()
     }),
-    z6.object({ data: z6.array(z6.unknown()) })
+    z6.object({ data: z6.array(z6.unknown()) }),
+    z6.object({ experiment_name: z6.string() })
   ]),
   name: z6.string().optional(),
   parameters: z6.object({}).partial().passthrough().optional(),
@@ -4364,7 +4473,9 @@ var View = z6.object({
     "for_review_datasets"
   ]),
   name: z6.string(),
+  description: z6.union([z6.string(), z6.null()]).optional(),
   created: z6.union([z6.string(), z6.null()]).optional(),
+  updated_at: z6.union([z6.string(), z6.null()]).optional(),
   view_data: ViewData.optional(),
   options: ViewOptions.optional(),
   user_id: z6.union([z6.string(), z6.null()]).optional(),
@@ -4700,7 +4811,7 @@ var BraintrustStream = class _BraintrustStream {
   }
 };
 function btStreamParser() {
-  const decoder = new TextDecoder();
+  const decoder2 = new TextDecoder();
   let parser;
   return new TransformStream({
     async start(controller) {
@@ -4717,7 +4828,7 @@ function btStreamParser() {
     },
     async transform(chunk, controller) {
       if (chunk instanceof Uint8Array) {
-        parser.feed(decoder.decode(chunk, { stream: true }));
+        parser.feed(decoder2.decode(chunk, { stream: true }));
       } else if (typeof chunk === "string") {
         parser.feed(chunk);
       } else {
@@ -4725,7 +4836,7 @@ function btStreamParser() {
       }
     },
     async flush(controller) {
-      const tail = decoder.decode();
+      const tail = decoder2.decode();
       if (tail) {
         parser.feed(tail);
       }
@@ -4734,7 +4845,7 @@ function btStreamParser() {
   });
 }
 function createFinalValuePassThroughStream(onFinal, onError) {
-  const decoder = new TextDecoder();
+  const decoder2 = new TextDecoder();
   const textChunks = [];
   const jsonChunks = [];
   const reasoningChunks = [];
@@ -4747,10 +4858,10 @@ function createFinalValuePassThroughStream(onFinal, onError) {
           data: chunk
         });
       } else if (chunk instanceof Uint8Array) {
-        textChunks.push(decoder.decode(chunk));
+        textChunks.push(decoder2.decode(chunk));
         controller.enqueue({
           type: "text_delta",
-          data: decoder.decode(chunk)
+          data: decoder2.decode(chunk)
         });
       } else if (braintrustStreamChunkSchema.safeParse(chunk).success) {
         const chunkType = chunk.type;
@@ -5491,12 +5602,13 @@ var INSTRUMENTATION_NAMES = {
   OPENROUTER: "openrouter",
   OPENROUTER_AGENT: "openrouter-agent",
   PI_CODING_AGENT: "pi-coding-agent",
-  STRANDS_AGENT_SDK: "strands-agent-sdk"
+  STRANDS_AGENT_SDK: "strands-agent-sdk",
+  VOYAGEAI: "voyageai"
 };
 var INTERNAL_SPAN_INSTRUMENTATION_NAME = /* @__PURE__ */ Symbol.for(
   "braintrust.spanInstrumentationName"
 );
-var SDK_VERSION = true ? "3.27.0" : "0.0.0";
+var SDK_VERSION = true ? "3.28.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -5691,6 +5803,9 @@ function applyMaskingToField(maskingFunction, data, fieldName) {
 var INITIAL_SPAN_WRITE_AS_MERGE = /* @__PURE__ */ Symbol(
   "braintrust.initial-span-write-as-merge"
 );
+var RESUME_SPAN_WITHOUT_INITIAL_WRITE = /* @__PURE__ */ Symbol(
+  "braintrust.resume-span-without-initial-write"
+);
 var INTERNAL_SPAN_CONTEXT = /* @__PURE__ */ Symbol("braintrust.internal-span-context");
 var BRAINTRUST_CURRENT_SPAN_STORE = /* @__PURE__ */ Symbol.for(
   "braintrust.currentSpanStore"
@@ -6914,6 +7029,30 @@ function updateSpan({
     event
   });
 }
+function _internalResumeSpan({
+  exported,
+  state
+}) {
+  const resolvedState = state ?? _globalState;
+  const components = SpanComponentsV4.fromStr(exported);
+  const { row_id, root_span_id, span_id } = components.data;
+  if (!row_id || !root_span_id || !span_id) {
+    throw new Error("Only exported root spans can be resumed");
+  }
+  return new SpanImpl({
+    state: resolvedState,
+    parentObjectType: components.data.object_type,
+    parentObjectId: new LazyValue(
+      spanComponentsToObjectIdLambda(resolvedState, components)
+    ),
+    parentComputeObjectMetadataArgs: void 0,
+    parentSpanIds: { parentSpanIds: [], rootSpanId: root_span_id },
+    spanId: span_id,
+    event: { id: row_id },
+    propagatedEvent: components.data.propagated_event ?? void 0,
+    [RESUME_SPAN_WITHOUT_INITIAL_WRITE]: true
+  });
+}
 function spanComponentsToObjectIdLambda(state, components) {
   if (components.data.object_id) {
     const ret = components.data.object_id;
@@ -9794,7 +9933,7 @@ var ObjectFetcher = class {
     const objectId = await this.id;
     const batchLimit = batchSize ?? DEFAULT_FETCH_BATCH_SIZE;
     const internalLimit = getInternalBtqlLimit(this._internal_btql);
-    const limit = batchSize !== void 0 ? batchSize : internalLimit ?? batchLimit;
+    let remainingLimit = internalLimit;
     const internalBtqlWithoutReservedQueryKeys = Object.fromEntries(
       Object.entries(this._internal_btql ?? {}).filter(
         ([key]) => key !== "cursor" && key !== "limit" && key !== "select" && key !== "from"
@@ -9803,6 +9942,10 @@ var ObjectFetcher = class {
     let cursor = void 0;
     let iterations = 0;
     while (true) {
+      if (remainingLimit !== void 0 && remainingLimit <= 0) {
+        return;
+      }
+      const limit = remainingLimit === void 0 ? batchLimit : Math.min(batchLimit, remainingLimit);
       const resp = await state.apiConn().post(
         `btql`,
         {
@@ -9842,7 +9985,14 @@ var ObjectFetcher = class {
       const respJson = await resp.json();
       const mutate = this.mutateRecord;
       for (const record of respJson.data ?? []) {
-        yield mutate ? mutate(record) : record;
+        if (remainingLimit !== void 0 && remainingLimit <= 0) {
+          return;
+        }
+        const mutatedRecord = mutate ? mutate(record) : record;
+        if (remainingLimit !== void 0) {
+          remainingLimit--;
+        }
+        yield mutatedRecord;
       }
       if (!respJson.cursor) {
         break;
@@ -10362,7 +10512,9 @@ var SpanImpl = class _SpanImpl {
     this._rootSpanId = resolvedIds.rootSpanId;
     this._spanParents = resolvedIds.spanParents;
     this.isMerge = args[INITIAL_SPAN_WRITE_AS_MERGE] === true;
-    this.logInternal({ event, internalData });
+    if (!args[RESUME_SPAN_WITHOUT_INITIAL_WRITE]) {
+      this.logInternal({ event, internalData });
+    }
     this.isMerge = true;
   }
   getParentInfo() {
@@ -13052,6 +13204,22 @@ function processInputAttachments(input) {
         };
       }
     }
+    const voyageBase64Key = node.type === "image_base64" ? Object.hasOwn(node, "imageBase64") ? "imageBase64" : "image_base64" : node.type === "video_base64" ? Object.hasOwn(node, "videoBase64") ? "videoBase64" : "video_base64" : void 0;
+    const voyageBase64Value = voyageBase64Key ? node[voyageBase64Key] : void 0;
+    if (voyageBase64Key && typeof voyageBase64Value === "string" && voyageBase64Value.startsWith("data:")) {
+      const mediaType = inferMediaTypeFromDataUrl(
+        voyageBase64Value,
+        node.type === "video_base64" ? "video/mp4" : "image/png"
+      );
+      const filename = `${node.type === "video_base64" ? "video" : "image"}.${getExtensionFromMediaType(mediaType)}`;
+      const attachment = toAttachment(voyageBase64Value, mediaType, filename);
+      if (attachment) {
+        return {
+          ...node,
+          [voyageBase64Key]: attachment
+        };
+      }
+    }
     if (node.type === "file" && node.file && typeof node.file === "object" && typeof node.file.file_data === "string" && node.file.file_data.startsWith("data:")) {
       const mediaType = inferMediaTypeFromDataUrl(
         node.file.file_data,
@@ -14399,12 +14567,30 @@ function logInstrumentationError(context, error) {
 
 // src/wrappers/anthropic-tokens-util.ts
 function finalizeAnthropicTokens(metrics) {
-  const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + (metrics.prompt_cache_creation_tokens || 0);
-  return {
+  const hasSplitCacheCreationTokens = metrics.prompt_cache_creation_5m_tokens !== void 0 || metrics.prompt_cache_creation_1h_tokens !== void 0;
+  const splitCacheCreationTokens = (metrics.prompt_cache_creation_5m_tokens || 0) + (metrics.prompt_cache_creation_1h_tokens || 0);
+  const aggregateCacheCreationTokens = metrics.prompt_cache_creation_tokens || 0;
+  const effectiveCacheCreationTokens = Math.max(
+    aggregateCacheCreationTokens,
+    splitCacheCreationTokens
+  );
+  const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + effectiveCacheCreationTokens;
+  const finalized = {
     ...metrics,
     prompt_tokens,
     tokens: prompt_tokens + (metrics.completion_tokens || 0)
   };
+  if (hasSplitCacheCreationTokens && splitCacheCreationTokens >= aggregateCacheCreationTokens) {
+    delete finalized.prompt_cache_creation_tokens;
+  }
+  return finalized;
+}
+function toNumericMetrics(metrics) {
+  return Object.fromEntries(
+    Object.entries(metrics).filter(
+      (entry) => entry[1] !== void 0
+    )
+  );
 }
 function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens = 0) {
   const cacheTokens = {};
@@ -15010,6 +15196,18 @@ function parseMetricsFromUsage2(usage) {
   saveIfExistsTo("output_tokens", "completion_tokens");
   saveIfExistsTo("cache_read_input_tokens", "prompt_cached_tokens");
   saveIfExistsTo("cache_creation_input_tokens", "prompt_cache_creation_tokens");
+  if (isObject(usage.cache_creation)) {
+    const cacheCreation = usage.cache_creation;
+    for (const [source, target] of [
+      ["ephemeral_5m_input_tokens", "prompt_cache_creation_5m_tokens"],
+      ["ephemeral_1h_input_tokens", "prompt_cache_creation_1h_tokens"]
+    ]) {
+      const value = cacheCreation[source];
+      if (typeof value === "number") {
+        metrics[target] = value;
+      }
+    }
+  }
   if (isObject(usage.server_tool_use)) {
     for (const [name, value] of Object.entries(usage.server_tool_use)) {
       if (typeof value === "number") {
@@ -20308,37 +20506,97 @@ function seedTaskToolUseIdMapping(taskIdToToolUseId, message) {
     taskIdToToolUseId.set(message.task_id, message.tool_use_id);
   }
 }
-function extractUsageFromMessage(message) {
-  const metrics = {};
-  let usage;
-  if (message.type === "assistant") {
-    usage = message.message?.usage;
-  } else if (message.type === "result") {
-    usage = message.usage;
-  }
+function tokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function copyUsage(usage) {
   if (!usage || typeof usage !== "object") {
-    return metrics;
+    return void 0;
+  }
+  const copy = {};
+  for (const key of [
+    "input_tokens",
+    "output_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens"
+  ]) {
+    const value = tokenCount(Reflect.get(usage, key));
+    if (value !== void 0) {
+      copy[key] = value;
+    }
+  }
+  const cacheCreation = Reflect.get(usage, "cache_creation");
+  if (cacheCreation && typeof cacheCreation === "object") {
+    const cacheCreationCopy = {};
+    for (const key of [
+      "ephemeral_5m_input_tokens",
+      "ephemeral_1h_input_tokens"
+    ]) {
+      const value = tokenCount(Reflect.get(cacheCreation, key));
+      if (value !== void 0) {
+        cacheCreationCopy[key] = value;
+      }
+    }
+    if (Object.keys(cacheCreationCopy).length > 0) {
+      copy.cache_creation = cacheCreationCopy;
+    }
+  }
+  return Object.keys(copy).length > 0 ? copy : void 0;
+}
+function mergeUsage(base, override) {
+  if (!base || !override) {
+    return override ?? base;
+  }
+  const cacheCreation = base.cache_creation || override.cache_creation ? { ...base.cache_creation, ...override.cache_creation } : void 0;
+  return {
+    ...base,
+    ...override,
+    ...cacheCreation && { cache_creation: cacheCreation }
+  };
+}
+function extractUsage(usage, includeOutput) {
+  const metrics = {};
+  if (!usage) {
+    return {};
   }
   const inputTokens = getNumberProperty(usage, "input_tokens");
   if (inputTokens !== void 0) {
     metrics.prompt_tokens = inputTokens;
   }
-  const outputTokens = getNumberProperty(usage, "output_tokens");
-  if (outputTokens !== void 0) {
-    metrics.completion_tokens = outputTokens;
+  if (includeOutput) {
+    const outputTokens = getNumberProperty(usage, "output_tokens");
+    if (outputTokens !== void 0) {
+      metrics.completion_tokens = outputTokens;
+    }
   }
   const cacheReadTokens = getNumberProperty(usage, "cache_read_input_tokens") || 0;
   const cacheCreationTokens = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
-  if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
-    Object.assign(
-      metrics,
-      extractAnthropicCacheTokens(cacheReadTokens, cacheCreationTokens)
-    );
+  Object.assign(
+    metrics,
+    extractAnthropicCacheTokens(cacheReadTokens, cacheCreationTokens)
+  );
+  const cacheCreation5mTokens = getNumberProperty(
+    usage.cache_creation,
+    "ephemeral_5m_input_tokens"
+  );
+  const cacheCreation1hTokens = getNumberProperty(
+    usage.cache_creation,
+    "ephemeral_1h_input_tokens"
+  );
+  if (cacheCreation5mTokens !== void 0) {
+    metrics.prompt_cache_creation_5m_tokens = cacheCreation5mTokens;
   }
-  if (Object.keys(metrics).length > 0) {
-    Object.assign(metrics, finalizeAnthropicTokens(metrics));
+  if (cacheCreation1hTokens !== void 0) {
+    metrics.prompt_cache_creation_1h_tokens = cacheCreation1hTokens;
   }
-  return metrics;
+  if (Object.keys(metrics).length === 0) {
+    return {};
+  }
+  const finalized = finalizeAnthropicTokens(metrics);
+  if (metrics.completion_tokens === void 0) {
+    delete finalized.tokens;
+  }
+  return toNumericMetrics(finalized);
 }
 function buildLLMInput(promptMessages, conversationHistory) {
   const inputParts = [...promptMessages, ...conversationHistory];
@@ -20372,16 +20630,16 @@ function buildRootPromptMessages(prompt, capturedPromptMessages) {
 function formatCapturedMessages(messages) {
   return messages.length > 0 ? messages : [];
 }
-async function createLLMSpanForMessages(messages, promptMessages, conversationHistory, options, startTime, parentSpan, existingSpan) {
+async function createLLMSpanForMessages(messages, promptMessages, conversationHistory, options, startTime, parentSpan, usage, hasFinalOutputUsage, existingSpan) {
   if (messages.length === 0) {
     return void 0;
   }
   const lastMessage = messages[messages.length - 1];
-  if (lastMessage.type !== "assistant" || !lastMessage.message?.usage) {
+  if (lastMessage.type !== "assistant") {
     return void 0;
   }
-  const model = lastMessage.message.model || options.model;
-  const usage = extractUsageFromMessage(lastMessage);
+  const model = lastMessage.message?.model || options.model;
+  const metrics = options.includePartialMessages ? extractUsage(usage, hasFinalOutputUsage) : {};
   const input = buildLLMInput(promptMessages, conversationHistory);
   const outputs = messages.map(
     (m) => m.message?.content && m.message?.role ? { content: m.message.content, role: m.message.role } : void 0
@@ -20403,8 +20661,8 @@ async function createLLMSpanForMessages(messages, promptMessages, conversationHi
   );
   span.log({
     input,
-    metadata: model ? { model } : void 0,
-    metrics: usage,
+    metadata: { ...model && { model }, provider: "anthropic" },
+    ...Object.keys(metrics).length > 0 ? { metrics } : {},
     output: outputs
   });
   const spanExport = await span.export();
@@ -20494,11 +20752,17 @@ function prepareLocalToolHandlersInMcpServers(mcpServers) {
   }
   return { hasLocalToolHandlers, localToolHookNames };
 }
-function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
+function createToolTracingHooks(resolveParentSpan, taskIdToToolUseId, toolUseToParent, activeToolSpans, mcpServers, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
   const preToolUse = async (input, toolUseID) => {
     if (input.hook_event_name !== "PreToolUse" || !toolUseID) {
       return {};
     }
+    if (!toolUseToParent.has(toolUseID) && input.agent_id) {
+      const parentToolUseId = taskIdToToolUseId.get(input.agent_id);
+      if (parentToolUseId) {
+        toolUseToParent.set(toolUseID, parentToolUseId);
+      }
+    }
     if (skipLocalToolHooks && (isLocalToolUse(input.tool_name, mcpServers) || localToolHookNames.has(input.tool_name))) {
       return {};
     }
@@ -20694,9 +20958,6 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
     }
     const metadata = {
       ...subAgentDetailsToMetadata(details),
-      ...input.agent_transcript_path && {
-        "claude_agent_sdk.agent_transcript_path": input.agent_transcript_path
-      },
       "claude_agent_sdk.stop_hook_active": input.stop_hook_active
     };
     try {
@@ -20718,7 +20979,7 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
     subagentStop
   };
 }
-function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
+function injectTracingHooks(options, resolveParentSpan, taskIdToToolUseId, toolUseToParent, activeToolSpans, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
   const {
     preToolUse,
     postToolUse,
@@ -20727,6 +20988,8 @@ function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localTo
     subagentStop
   } = createToolTracingHooks(
     resolveParentSpan,
+    taskIdToToolUseId,
+    toolUseToParent,
     activeToolSpans,
     options.mcpServers,
     localToolHookNames,
@@ -20808,6 +21071,13 @@ async function finalizeCurrentMessageGroup(state) {
     }
   }
   const existingLlmSpan = state.activeLlmSpansByParentToolUse.get(parentKey);
+  const lastMessage = state.currentMessages[state.currentMessages.length - 1];
+  const messageId = lastMessage?.message?.id;
+  const usage = state.options.includePartialMessages ? mergeUsage(
+    copyUsage(lastMessage?.message?.usage),
+    messageId ? state.usageByMessageId.get(messageId) : void 0
+  ) : void 0;
+  const hasFinalOutputUsage = messageId !== void 0 && state.finalOutputUsageMessageIds.has(messageId);
   const llmSpanResult = await createLLMSpanForMessages(
     state.currentMessages,
     promptMessages,
@@ -20815,6 +21085,8 @@ async function finalizeCurrentMessageGroup(state) {
     state.options,
     state.currentMessageStartTime,
     parentSpan,
+    usage,
+    hasFinalOutputUsage,
     existingLlmSpan
   );
   if (llmSpanResult) {
@@ -20832,9 +21104,17 @@ async function finalizeCurrentMessageGroup(state) {
     }
   }
   state.activeLlmSpansByParentToolUse.delete(parentKey);
-  const lastMessage = state.currentMessages[state.currentMessages.length - 1];
-  if (lastMessage?.message?.usage) {
-    state.accumulatedOutputTokens += getNumberProperty(lastMessage.message.usage, "output_tokens") || 0;
+  if (messageId) {
+    state.usageByMessageId.delete(messageId);
+    state.finalOutputUsageMessageIds.delete(messageId);
+    for (const [
+      parent,
+      activeMessageId
+    ] of state.activePartialMessageIdByParentKey) {
+      if (activeMessageId === messageId) {
+        state.activePartialMessageIdByParentKey.delete(parent);
+      }
+    }
   }
   state.currentMessages.length = 0;
 }
@@ -20925,6 +21205,10 @@ async function ensureActiveLlmSpanForParentToolUse(rootSpan, activeLlmSpansByPar
     );
     llmParentSpan = await subAgentSpan.export();
   }
+  const racedLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
+  if (racedLlmSpan) {
+    return racedLlmSpan;
+  }
   const llmSpan = startSpan(
     withSpanInstrumentationName(
       {
@@ -21044,7 +21328,49 @@ async function maybeHandleTaskLifecycleMessage(state, message) {
   }
   return true;
 }
+function handlePartialUsageMessage(state, message) {
+  if (message.type !== "stream_event") {
+    return false;
+  }
+  const event = message.event;
+  if (!event || typeof event !== "object") {
+    return true;
+  }
+  const parentKey = llmParentKey(message.parent_tool_use_id ?? null);
+  if (event.type === "message_start") {
+    const messageId2 = event.message?.id;
+    const usage = copyUsage(event.message?.usage);
+    if (messageId2) {
+      state.activePartialMessageIdByParentKey.set(parentKey, messageId2);
+      if (usage) {
+        state.usageByMessageId.set(messageId2, usage);
+      }
+    }
+    return true;
+  }
+  const messageId = state.activePartialMessageIdByParentKey.get(parentKey);
+  if (!messageId) {
+    return true;
+  }
+  if (event.type === "message_delta") {
+    const update = copyUsage(event.usage);
+    if (update) {
+      const usage = state.usageByMessageId.get(messageId) ?? {};
+      Object.assign(usage, update);
+      state.usageByMessageId.set(messageId, usage);
+      if (update.output_tokens !== void 0) {
+        state.finalOutputUsageMessageIds.add(messageId);
+      }
+    }
+  } else if (event.type === "message_stop") {
+    state.activePartialMessageIdByParentKey.delete(parentKey);
+  }
+  return true;
+}
 async function handleStreamMessage(state, message) {
+  if (handlePartialUsageMessage(state, message)) {
+    return;
+  }
   maybeTrackToolUseContext(state, message);
   if (await maybeHandleTaskLifecycleMessage(state, message)) {
     return;
@@ -21091,36 +21417,9 @@ async function handleStreamMessage(state, message) {
     );
     state.currentMessages.push(message);
   }
-  if (message.type !== "result" || !message.usage) {
+  if (message.type !== "result") {
     return;
   }
-  const finalUsageMetrics = extractUsageFromMessage(message);
-  if (state.currentMessages.length > 0 && finalUsageMetrics.completion_tokens !== void 0) {
-    const lastMessage = state.currentMessages[state.currentMessages.length - 1];
-    if (lastMessage?.message?.usage) {
-      const adjustedTokens = finalUsageMetrics.completion_tokens - state.accumulatedOutputTokens;
-      if (adjustedTokens >= 0) {
-        lastMessage.message.usage.output_tokens = adjustedTokens;
-      }
-      const resultUsage = message.usage;
-      if (resultUsage && typeof resultUsage === "object") {
-        const cacheReadTokens = getNumberProperty(
-          resultUsage,
-          "cache_read_input_tokens"
-        );
-        if (cacheReadTokens !== void 0) {
-          lastMessage.message.usage.cache_read_input_tokens = cacheReadTokens;
-        }
-        const cacheCreationTokens = getNumberProperty(
-          resultUsage,
-          "cache_creation_input_tokens"
-        );
-        if (cacheCreationTokens !== void 0) {
-          lastMessage.message.usage.cache_creation_input_tokens = cacheCreationTokens;
-        }
-      }
-    }
-  }
   const metadata = {};
   if (message.num_turns !== void 0) {
     metadata.num_turns = message.num_turns;
@@ -21128,8 +21427,12 @@ async function handleStreamMessage(state, message) {
   if (message.session_id !== void 0) {
     metadata.session_id = message.session_id;
   }
-  if (Object.keys(metadata).length > 0) {
-    state.span.log({ metadata });
+  const metrics = state.options.includePartialMessages ? {} : extractUsage(copyUsage(message.usage), true);
+  if (Object.keys(metadata).length > 0 || Object.keys(metrics).length > 0) {
+    state.span.log({
+      ...Object.keys(metadata).length > 0 ? { metadata } : {},
+      ...Object.keys(metrics).length > 0 ? { metrics } : {}
+    });
   }
 }
 async function finalizeQuerySpan(state) {
@@ -21153,6 +21456,9 @@ async function finalizeQuerySpan(state) {
       llmSpan.end();
     }
     state.activeLlmSpansByParentToolUse.clear();
+    state.activePartialMessageIdByParentKey.clear();
+    state.finalOutputUsageMessageIds.clear();
+    state.usageByMessageId.clear();
     for (const toolSpan of state.activeToolSpans.values()) {
       toolSpan.end();
     }
@@ -21277,6 +21583,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         const optionsWithHooks = injectTracingHooks(
           options,
           resolveToolUseParentSpan,
+          taskIdToToolUseId,
+          toolUseToParent,
           activeToolSpans,
           localToolHookNames,
           skipLocalToolHooks,
@@ -21287,8 +21595,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         params.options = optionsWithHooks;
         event.arguments[0] = params;
         spans.set(event, {
-          accumulatedOutputTokens: 0,
           activeLlmSpansByParentToolUse,
+          activePartialMessageIdByParentKey: /* @__PURE__ */ new Map(),
           activeToolSpans,
           conversationHistoryByParentKey,
           capturedPromptMessages,
@@ -21296,6 +21604,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           currentMessageStartTime: startTime,
           currentMessages: [],
           endedSubAgentSpans,
+          finalOutputUsageMessageIds: /* @__PURE__ */ new Set(),
           finalResults: [],
           options: optionsWithHooks,
           originalPrompt,
@@ -21311,6 +21620,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           latestLlmParentBySubAgentToolUse,
           latestRootLlmParentRef,
           toolUseToParent,
+          usageByMessageId: /* @__PURE__ */ new Map(),
           localToolContext
         });
       },
@@ -23785,9 +24095,9 @@ function extractEmbedPromptTokenCount(response) {
   let sawAny = false;
   for (const embedding of embeddings) {
     const embeddingStats = tryToDict(tryToDict(embedding)?.statistics);
-    const tokenCount = embeddingStats?.tokenCount;
-    if (typeof tokenCount === "number" && Number.isFinite(tokenCount)) {
-      total += tokenCount;
+    const tokenCount2 = embeddingStats?.tokenCount;
+    if (typeof tokenCount2 === "number" && Number.isFinite(tokenCount2)) {
+      total += tokenCount2;
       sawAny = true;
     }
   }
@@ -30682,7 +30992,7 @@ function getStringProperty2(obj, key) {
   return typeof value === "string" ? value : void 0;
 }
 function extractMetricsFromUsage(usage) {
-  const metrics = {
+  const rawMetrics = {
     prompt_tokens: usage.inputTokens,
     completion_tokens: usage.outputTokens,
     ...extractAnthropicCacheTokens(
@@ -30691,10 +31001,10 @@ function extractMetricsFromUsage(usage) {
     )
   };
   if (usage.reasoningTokens !== void 0) {
-    metrics.completion_reasoning_tokens = usage.reasoningTokens;
-    metrics.reasoning_tokens = usage.reasoningTokens;
+    rawMetrics.completion_reasoning_tokens = usage.reasoningTokens;
+    rawMetrics.reasoning_tokens = usage.reasoningTokens;
   }
-  Object.assign(metrics, finalizeAnthropicTokens(metrics));
+  const metrics = finalizeAnthropicTokens(rawMetrics);
   const metadata = {
     model: usage.model
   };
@@ -31633,17 +31943,20 @@ var FlueObserveBridge = class {
       return;
     }
     const metadata = {
+      ...event.runId ? this.runsById.get(event.runId)?.metadata : {},
       ...extractEventMetadata(event),
       "flue.operation": event.operationKind,
       provider: "flue"
     };
     const parent = this.parentSpanForEvent(event);
-    const span = startFlueSpan(parent, {
+    const args = {
       name: `flue.${event.operationKind}`,
       spanAttributes: { type: "task" /* TASK */ },
       startTime: eventTime(event.timestamp),
       event: { metadata }
-    });
+    };
+    const runSpan = event.runId ? this.runsById.get(event.runId)?.span : void 0;
+    const span = event.operationKind === "prompt" && (!parent || parent === runSpan) ? startFlueRootSpan(args) : startFlueSpan(parent, args);
     this.operationsById.set(event.operationId, { metadata, span });
   }
   handleOperation(event) {
@@ -31658,6 +31971,11 @@ var FlueObserveBridge = class {
       ...event.isError !== void 0 ? { "flue.is_error": event.isError } : {},
       ...event.usage ? { "flue.usage": event.usage } : {}
     };
+    const input = flueOperationInput(event);
+    if (!state.loggedInput && input !== void 0) {
+      safeLog3(state.span, { input });
+      state.loggedInput = true;
+    }
     this.finishPendingChildrenForOperation(event, output);
     safeLog3(state.span, {
       ...event.isError ? { error: toLoggedError(event.errorInfo ?? event.error) } : {},
@@ -31674,6 +31992,8 @@ var FlueObserveBridge = class {
       return;
     }
     const input = flueTurnRequestInput(event);
+    const operation = event.operationId ? this.operationsById.get(event.operationId) : void 0;
+    const turnInput = prepareFlueTurnInput(event, input, operation);
     const model = flueTurnRequestModel(event);
     const provider = flueTurnRequestProvider(event);
     const api = flueTurnRequestApi(event);
@@ -31686,8 +32006,7 @@ var FlueObserveBridge = class {
       ...provider ? { "flue.provider": provider } : {},
       ...event.purpose ? { "flue.turn_purpose": event.purpose } : {},
       ...reasoning ? { reasoning } : {},
-      ...input?.systemPrompt ? { "flue.system_prompt": input.systemPrompt } : {},
-      ...input?.tools ? { tools: input.tools } : {}
+      ...turnInput.metadata
     };
     const parent = this.parentSpanForTurn(event);
     const span = startFlueSpan(parent, {
@@ -31695,11 +32014,14 @@ var FlueObserveBridge = class {
       spanAttributes: { type: "llm" /* LLM */ },
       startTime: eventTime(event.timestamp),
       event: {
-        input: input?.messages,
+        input: turnInput.messages,
         metadata
       }
     });
-    this.logOperationInput(event.operationId, input?.messages ?? input);
+    this.logOperationInput(
+      event.operationId,
+      latestUserMessageInput(input?.messages)
+    );
     this.turnsByKey.set(key, { metadata, span });
   }
   handleTurn(event) {
@@ -31946,16 +32268,20 @@ var FlueObserveBridge = class {
   }
   startSyntheticOperation(event) {
     const metadata = {
+      ...event.runId ? this.runsById.get(event.runId)?.metadata : {},
       ...extractEventMetadata(event),
       "flue.operation": event.operationKind,
       provider: "flue"
     };
-    const span = startFlueSpan(this.parentSpanForEvent(event), {
+    const args = {
       name: `flue.${event.operationKind}`,
       spanAttributes: { type: "task" /* TASK */ },
       startTime: eventTime(event.timestamp),
       event: { metadata }
-    });
+    };
+    const parent = this.parentSpanForEvent(event);
+    const runSpan = event.runId ? this.runsById.get(event.runId)?.span : void 0;
+    const span = event.operationKind === "prompt" && (!parent || parent === runSpan) ? startFlueRootSpan(args) : startFlueSpan(parent, args);
     return { metadata, span };
   }
   startSyntheticTurn(event) {
@@ -32134,6 +32460,71 @@ function flueRunInput(event) {
 function flueTurnRequestInput(event) {
   return event.request?.input ?? event.input;
 }
+function prepareFlueTurnInput(event, input, operation) {
+  const messages = input?.messages;
+  const tracksUserTurn = event.purpose === "agent" && operation?.metadata["flue.operation"] === "prompt" && Array.isArray(messages);
+  if (!tracksUserTurn) {
+    return {
+      messages,
+      metadata: {
+        ...input?.systemPrompt ? { "flue.system_prompt": input.systemPrompt } : {},
+        ...input?.tools ? { tools: input.tools } : {}
+      }
+    };
+  }
+  const previous = operation.turnInputState;
+  const previousMessageCount = previous?.messageCount ?? 0;
+  const boundaryFingerprint = messages.length > 0 ? fingerprintJsonValue(messages[messages.length - 1]) : void 0;
+  const continuesPreviousInput = previous !== void 0 && messages.length >= previousMessageCount && (previousMessageCount === 0 || previous.boundaryFingerprint !== void 0 && previous.boundaryFingerprint === fingerprintJsonValue(messages[previousMessageCount - 1]));
+  const inputMode = previous === void 0 ? "full" : continuesPreviousInput ? "delta" : "reset";
+  const systemPromptFingerprint = fingerprintJsonValue(input?.systemPrompt);
+  const toolsFingerprint = fingerprintJsonValue(input?.tools);
+  operation.turnInputState = {
+    ...boundaryFingerprint !== void 0 ? { boundaryFingerprint } : {},
+    messageCount: messages.length,
+    ...systemPromptFingerprint !== void 0 ? { systemPromptFingerprint } : {},
+    ...toolsFingerprint !== void 0 ? { toolsFingerprint } : {}
+  };
+  return {
+    messages: continuesPreviousInput ? messages.slice(previousMessageCount) : messages,
+    metadata: {
+      "flue.input_mode": inputMode,
+      ...continuesPreviousInput ? { "flue.input_message_offset": previousMessageCount } : {},
+      ...input?.systemPrompt && (!continuesPreviousInput || systemPromptFingerprint !== previous?.systemPromptFingerprint) ? { "flue.system_prompt": input.systemPrompt } : {},
+      ...input?.tools && (!continuesPreviousInput || toolsFingerprint !== previous?.toolsFingerprint) ? { tools: input.tools } : {}
+    }
+  };
+}
+function fingerprintJsonValue(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) {
+      return void 0;
+    }
+    let hash = 2166136261;
+    for (let i = 0; i < serialized.length; i++) {
+      hash = Math.imul(hash ^ serialized.charCodeAt(i), 16777619);
+    }
+    return `${serialized.length}:${hash >>> 0}`;
+  } catch {
+    return void 0;
+  }
+}
+function latestUserMessageInput(messages) {
+  if (!messages) {
+    return void 0;
+  }
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (isObjectLike(message) && Reflect.get(message, "role") === "user") {
+      return [message];
+    }
+  }
+  return void 0;
+}
+function flueOperationInput(event) {
+  return typeof event.agentInput?.text === "string" ? [{ content: event.agentInput.text, role: "user" }] : void 0;
+}
 function flueTurnRequestModel(event) {
   return event.request?.requestedModel ?? event.request?.model ?? event.model;
 }
@@ -32291,6 +32682,21 @@ function startFlueSpan(parent, args) {
     withSpanInstrumentationName(args, INSTRUMENTATION_NAMES.FLUE)
   );
 }
+function startFlueRootSpan(args) {
+  const state = _internalGetGlobalState();
+  const spanId = state.idGenerator.getSpanId();
+  const rootSpanId = state.idGenerator.shareRootSpanId() ? spanId : state.idGenerator.getTraceId();
+  return withCurrent(
+    NOOP_SPAN,
+    () => startSpan({
+      ...withSpanInstrumentationName(args, INSTRUMENTATION_NAMES.FLUE),
+      parentSpanIds: { parentSpanIds: [], rootSpanId },
+      spanId,
+      state
+    }),
+    state
+  );
+}
 function runWithCurrentSpanStore(span, next) {
   const state = _internalGetGlobalState();
   const contextManager = state?.contextManager;
@@ -34190,8 +34596,7 @@ function startAgentStream(event, activeChildParents) {
     ...extractAgentMetadata2(agent),
     ...extractModelMetadata3(model),
     "strands.operation": "Agent.stream",
-    provider: extractProvider(model),
-    ...event.moduleVersion ? { "strands_agent_sdk.version": event.moduleVersion } : {}
+    provider: extractProvider(model)
   };
   const parentSpan = agent ? getOnlyChildParent(activeChildParents, agent) : void 0;
   const attachmentCache = createStrandsAttachmentCache();
@@ -34241,8 +34646,7 @@ function startMultiAgentStream(event, operation, activeChildParents) {
   const metadata = {
     "strands.operation": operation,
     provider: "strands",
-    ...orchestrator?.id ? { "strands.orchestrator.id": orchestrator.id } : {},
-    ...event.moduleVersion ? { "strands_agent_sdk.version": event.moduleVersion } : {}
+    ...orchestrator?.id ? { "strands.orchestrator.id": orchestrator.id } : {}
   };
   const parentSpan = orchestrator ? getOnlyChildParent(activeChildParents, orchestrator) : void 0;
   const input = processStrandsInputAttachments(event.arguments[0]);
@@ -35028,6 +35432,320 @@ function logInstrumentationError5(context, error) {
   debugLogger.debug(`${context}:`, error);
 }
 
+// src/instrumentation/plugins/voyageai-channels.ts
+var voyageAIChannels = defineChannels(
+  "voyageai",
+  {
+    embed: channel({
+      channelName: "embed",
+      kind: "async"
+    }),
+    multimodalEmbed: channel({
+      channelName: "multimodalEmbed",
+      kind: "async"
+    }),
+    rerank: channel({
+      channelName: "rerank",
+      kind: "async"
+    }),
+    contextualizedEmbed: channel({
+      channelName: "contextualizedEmbed",
+      kind: "async"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.VOYAGEAI }
+);
+
+// src/instrumentation/plugins/voyageai-plugin.ts
+var RERANK_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "model",
+  "returnDocuments",
+  "topK",
+  "truncation"
+]);
+var VoyageAIPlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(
+      interceptVoyageAICall(
+        voyageAIChannels.embed,
+        "voyageai.embed",
+        extractTextEmbeddingInput,
+        summarizeEmbeddingOutput,
+        extractEmbeddingUsageMetrics
+      ),
+      interceptVoyageAICall(
+        voyageAIChannels.multimodalEmbed,
+        "voyageai.multimodalEmbed",
+        extractMultimodalEmbeddingInput,
+        summarizeEmbeddingOutput,
+        extractEmbeddingUsageMetrics
+      ),
+      interceptVoyageAICall(
+        voyageAIChannels.rerank,
+        "voyageai.rerank",
+        extractRerankInput,
+        summarizeRerankOutput
+      ),
+      interceptVoyageAICall(
+        voyageAIChannels.contextualizedEmbed,
+        "voyageai.contextualizedEmbed",
+        extractContextualizedEmbeddingInput,
+        summarizeContextualizedEmbeddingOutput,
+        extractEmbeddingUsageMetrics
+      )
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function interceptVoyageAICall(channel2, name, extractInput3, extractOutput2, extractMetrics2 = extractUsageMetrics3) {
+  return channel2.intercept((target, thisArg, args) => {
+    const invokeTarget = () => Reflect.apply(target, thisArg, args);
+    if (isAutoInstrumentationSuppressed()) {
+      return invokeTarget();
+    }
+    let span;
+    try {
+      const { input, metadata } = extractInput3(args);
+      span = startSpan(
+        withSpanInstrumentationName(
+          {
+            event: { input, metadata },
+            name,
+            spanAttributes: { type: "llm" /* LLM */ }
+          },
+          INSTRUMENTATION_NAMES.VOYAGEAI
+        )
+      );
+    } catch (error) {
+      debugLogger.error(`Error starting span for ${name}:`, error);
+      return invokeTarget();
+    }
+    let result;
+    try {
+      result = withCurrent(
+        span,
+        () => runWithAutoInstrumentationSuppressed(invokeTarget)
+      );
+    } catch (error) {
+      finishVoyageAISpan(span, name, () => span.log({ error }));
+      throw error;
+    }
+    void Promise.resolve(result).then(
+      (value) => finishVoyageAISpan(span, name, () => {
+        const metadata = extractResponseMetadata3(value);
+        span.log({
+          output: extractOutput2(value),
+          ...metadata ? { metadata } : {},
+          metrics: extractMetrics2(value)
+        });
+      }),
+      (error) => finishVoyageAISpan(span, name, () => span.log({ error }))
+    );
+    return result;
+  });
+}
+function finishVoyageAISpan(span, name, log3) {
+  try {
+    log3();
+  } catch (error) {
+    debugLogger.error(`Error logging span for ${name}:`, error);
+  }
+  try {
+    span.end();
+  } catch (error) {
+    debugLogger.error(`Error ending span for ${name}:`, error);
+  }
+}
+function getRequestArg2(args) {
+  if (Array.isArray(args)) {
+    return isObject(args[0]) ? args[0] : void 0;
+  }
+  if (!isObject(args)) {
+    return void 0;
+  }
+  const firstArg = Reflect.get(args, "0");
+  return isObject(firstArg) ? firstArg : void 0;
+}
+function pickMetadata(request, allowlist) {
+  const metadata = {};
+  if (request) {
+    for (const key of allowlist) {
+      if (!Object.hasOwn(request, key)) {
+        continue;
+      }
+      const value = request[key];
+      if (value !== void 0) {
+        metadata[key] = value;
+      }
+    }
+  }
+  return {
+    ...metadata,
+    provider: "voyage"
+  };
+}
+function buildEmbeddingInput(inputs, request) {
+  const outputDimensions = request?.outputDimension;
+  return {
+    inputs,
+    ...typeof outputDimensions === "number" && Number.isFinite(outputDimensions) ? { output_dimensions: outputDimensions } : {}
+  };
+}
+function embeddingMetadata(request) {
+  return {
+    ...typeof request?.model === "string" ? { model: request.model } : {},
+    provider: "voyage"
+  };
+}
+function extractTextEmbeddingInput(args) {
+  const request = getRequestArg2(args);
+  const rawInput = request?.input;
+  const values = Array.isArray(rawInput) ? rawInput : [rawInput];
+  return {
+    input: buildEmbeddingInput(
+      values.flatMap(
+        (value) => typeof value === "string" ? [{ content: value }] : []
+      ),
+      request
+    ),
+    metadata: embeddingMetadata(request)
+  };
+}
+function extractContextualizedEmbeddingInput(args) {
+  const request = getRequestArg2(args);
+  const rawInputs = request?.inputs;
+  const values = Array.isArray(rawInputs) ? rawInputs.flatMap((value) => Array.isArray(value) ? value : [value]) : [];
+  return {
+    input: buildEmbeddingInput(
+      values.flatMap(
+        (value) => typeof value === "string" ? [{ content: value }] : []
+      ),
+      request
+    ),
+    metadata: embeddingMetadata(request)
+  };
+}
+function extractMultimodalEmbeddingInput(args) {
+  const request = getRequestArg2(args);
+  const rawInputs = request?.inputs;
+  const inputs = Array.isArray(rawInputs) ? rawInputs.map((rawInput) => {
+    const rawContent = isObject(rawInput) ? rawInput.content : void 0;
+    return {
+      content: Array.isArray(rawContent) ? rawContent.flatMap(normalizeMultimodalContentPart) : []
+    };
+  }) : [];
+  const input = buildEmbeddingInput(inputs, request);
+  const processedInput = processInputAttachments(input);
+  return {
+    input: hasInlineEmbeddingMedia(processedInput) ? input : processedInput,
+    metadata: embeddingMetadata(request)
+  };
+}
+function normalizeMultimodalContentPart(part) {
+  if (!isObject(part) || typeof part.type !== "string") {
+    return [];
+  }
+  if (part.type === "text") {
+    return typeof part.text === "string" ? [{ type: "text", text: part.text }] : [];
+  }
+  const camelCaseField = {
+    image_base64: "imageBase64",
+    image_url: "imageUrl",
+    video_base64: "videoBase64",
+    video_url: "videoUrl"
+  };
+  const field = camelCaseField[part.type];
+  if (!field) {
+    return [];
+  }
+  const data = typeof part[field] === "string" ? part[field] : part[part.type];
+  if (typeof data !== "string") {
+    return [];
+  }
+  return part.type.startsWith("image_") ? [{ type: "image_url", image_url: { url: data } }] : [{ type: "file", file: { file_data: data } }];
+}
+function hasInlineEmbeddingMedia(input) {
+  return input.inputs.some(
+    ({ content }) => Array.isArray(content) ? content.some((part) => {
+      const value = part.type === "image_url" ? part.image_url.url : part.type === "file" ? part.file.file_data : void 0;
+      return typeof value === "string" && value.startsWith("data:");
+    }) : false
+  );
+}
+function extractRerankInput(args) {
+  const request = getRequestArg2(args);
+  const documents = request?.documents;
+  return {
+    input: {
+      documents,
+      query: request?.query
+    },
+    metadata: {
+      ...pickMetadata(request, RERANK_METADATA_ALLOWLIST),
+      ...Array.isArray(documents) ? { document_count: documents.length } : {}
+    }
+  };
+}
+function extractResponseMetadata3(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const rawResponse = isObject(result.rawResponse) ? result.rawResponse : void 0;
+  const model = typeof result.model === "string" ? result.model : typeof rawResponse?.model === "string" ? rawResponse.model : void 0;
+  return model ? { model } : void 0;
+}
+function summarizeEmbeddingOutput(result) {
+  return {
+    count: isObject(result) && Array.isArray(result.data) ? result.data.length : 0
+  };
+}
+function summarizeRerankOutput(result) {
+  if (!isObject(result) || !Array.isArray(result.data)) {
+    return void 0;
+  }
+  return result.data.slice(0, 100).map((item) => ({
+    index: isObject(item) ? item.index : void 0,
+    relevance_score: isObject(item) ? (typeof item.relevanceScore === "number" ? item.relevanceScore : item.relevance_score) ?? null : null
+  }));
+}
+function summarizeContextualizedEmbeddingOutput(result) {
+  if (!isObject(result)) {
+    return { count: 0 };
+  }
+  if (Array.isArray(result.results)) {
+    return {
+      count: result.results.reduce(
+        (count, item) => count + (isObject(item) && Array.isArray(item.embeddings) ? item.embeddings.length : 0),
+        0
+      )
+    };
+  }
+  if (!Array.isArray(result.data)) {
+    return { count: 0 };
+  }
+  return {
+    count: result.data.reduce(
+      (count, item) => count + (isObject(item) && Array.isArray(item.data) ? item.data.length : 0),
+      0
+    )
+  };
+}
+function extractEmbeddingUsageMetrics(result) {
+  const metrics = extractUsageMetrics3(result);
+  return typeof metrics.tokens === "number" ? { prompt_tokens: metrics.tokens, tokens: metrics.tokens } : {};
+}
+function extractUsageMetrics3(result) {
+  if (!isObject(result)) {
+    return {};
+  }
+  const rawResponse = isObject(result.rawResponse) ? result.rawResponse : void 0;
+  const usage = isObject(result.usage) ? result.usage : isObject(rawResponse?.usage) ? rawResponse.usage : void 0;
+  const tokens = typeof result.totalTokens === "number" ? result.totalTokens : usage?.totalTokens ?? usage?.total_tokens;
+  return typeof tokens === "number" && Number.isFinite(tokens) && tokens >= 0 ? { tokens } : {};
+}
+
 // src/instrumentation/plugins/cloudflare-ai-chat-channels.ts
 var cloudflareAIChatChannels = defineChannels(
   "@cloudflare/ai-chat",
@@ -35606,6 +36324,7 @@ var BraintrustPlugin = class extends BasePlugin {
   langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
+  voyageAIPlugin = null;
   cloudflareAIChatPlugin = null;
   cloudflareAgentsPlugin = null;
   constructor(config = {}) {
@@ -35680,6 +36399,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.coherePlugin = new CoherePlugin();
       this.coherePlugin.enable();
     }
+    if (integrations.voyageai !== false) {
+      this.voyageAIPlugin = new VoyageAIPlugin();
+      this.voyageAIPlugin.enable();
+    }
     if (integrations.groq !== false) {
       this.groqPlugin = new GroqPlugin();
       this.groqPlugin.enable();
@@ -35796,6 +36519,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.coherePlugin.disable();
       this.coherePlugin = null;
     }
+    if (this.voyageAIPlugin) {
+      this.voyageAIPlugin.disable();
+      this.voyageAIPlugin = null;
+    }
     if (this.groqPlugin) {
       this.groqPlugin.disable();
       this.groqPlugin = null;
@@ -35915,7 +36642,10 @@ var envIntegrationAliases = {
   "langchain-js": "langchain",
   "@langchain": "langchain",
   langgraph: "langgraph",
-  langsmith: "langsmith"
+  langsmith: "langsmith",
+  voyage: "voyageai",
+  "voyage-ai": "voyageai",
+  voyageai: "voyageai"
 };
 function getDefaultInstrumentationIntegrations() {
   return {
@@ -35950,6 +36680,7 @@ function getDefaultInstrumentationIntegrations() {
     langchain: true,
     langgraph: true,
     langsmith: true,
+    voyageai: true,
     piCodingAgent: true,
     strandsAgentSDK: true,
     cloudflareAgents: true
@@ -36113,6 +36844,8 @@ __export(exports_exports, {
   BRAINTRUST_PARENT_KEY: () => BRAINTRUST_PARENT_KEY,
   BaseAttachment: () => BaseAttachment,
   BaseExperiment: () => BaseExperiment,
+  BatchScorer: () => BatchScorer,
+  BatchTask: () => BatchTask,
   BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
   BraintrustObservabilityExporter: () => BraintrustObservabilityExporter,
@@ -36126,6 +36859,8 @@ __export(exports_exports, {
   DEFAULT_MAX_REQUEST_SIZE: () => DEFAULT_MAX_REQUEST_SIZE,
   Dataset: () => Dataset2,
   DatasetPipeline: () => DatasetPipeline,
+  DurableEvalMemoryStore: () => DurableEvalMemoryStore,
+  DurableEvalRedisStore: () => DurableEvalRedisStore,
   ERR_PERMALINK: () => ERR_PERMALINK,
   Eval: () => Eval,
   EvalResultWithSummary: () => EvalResultWithSummary,
@@ -36183,6 +36918,7 @@ __export(exports_exports, {
   currentSpan: () => currentSpan,
   deepCopyEvent: () => deepCopyEvent,
   defaultErrorScoreHandler: () => defaultErrorScoreHandler,
+  defineDurableEval: () => defineDurableEval,
   deserializePlainStringAsJSON: () => deserializePlainStringAsJSON,
   devNullWritableStream: () => devNullWritableStream,
   evaluatorDefinitionSchema: () => evaluatorDefinitionSchema,
@@ -36278,7 +37014,8 @@ __export(exports_exports, {
   wrapPiCodingAgentSDK: () => wrapPiCodingAgentSDK,
   wrapStrandsAgentSDK: () => wrapStrandsAgentSDK,
   wrapTraced: () => wrapTraced,
-  wrapVitest: () => wrapVitest
+  wrapVitest: () => wrapVitest,
+  wrapVoyageAI: () => wrapVoyageAI
 });
 
 // src/sandbox.ts
@@ -37539,7 +38276,7 @@ function normalizeUsageMetrics(usage, provider, providerMetadata) {
         cacheCreationTokens
       );
       Object.assign(metrics, cacheTokens);
-      Object.assign(metrics, finalizeAnthropicTokens(metrics));
+      return toNumericMetrics(finalizeAnthropicTokens(metrics));
     }
   }
   return metrics;
@@ -41872,6 +42609,84 @@ function wrapRerank3(rerank) {
   });
 }
 
+// src/wrappers/voyageai.ts
+function wrapVoyageAI(client) {
+  if (!isSupportedVoyageAIClient(client)) {
+    console.warn("Unsupported Voyage AI library. Not wrapping.");
+    return client;
+  }
+  return voyageAIProxy(client);
+}
+var voyageAIProxyCache = /* @__PURE__ */ new WeakMap();
+function isObject3(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasFunction5(value, name) {
+  return typeof Reflect.get(value, name) === "function";
+}
+function isSupportedVoyageAIClient(value) {
+  if (!isObject3(value)) {
+    return false;
+  }
+  return hasFunction5(value, "embed") || hasFunction5(value, "multimodalEmbed") || hasFunction5(value, "rerank") || hasFunction5(value, "contextualizedEmbed");
+}
+function voyageAIProxy(client) {
+  const cached = voyageAIProxyCache.get(client);
+  if (cached) {
+    return cached;
+  }
+  const proxy = new Proxy(client, {
+    get(target, prop, receiver) {
+      switch (prop) {
+        case "embed":
+          if (typeof target.embed !== "function") {
+            return target.embed;
+          }
+          return (request, options) => voyageAIChannels.embed.invoke(
+            target.embed,
+            target,
+            [request, options],
+            {}
+          );
+        case "multimodalEmbed":
+          if (typeof target.multimodalEmbed !== "function") {
+            return target.multimodalEmbed;
+          }
+          return (request, options) => voyageAIChannels.multimodalEmbed.invoke(
+            target.multimodalEmbed,
+            target,
+            [request, options],
+            {}
+          );
+        case "rerank":
+          if (typeof target.rerank !== "function") {
+            return target.rerank;
+          }
+          return (request, options) => voyageAIChannels.rerank.invoke(
+            target.rerank,
+            target,
+            [request, options],
+            {}
+          );
+        case "contextualizedEmbed":
+          if (typeof target.contextualizedEmbed !== "function") {
+            return target.contextualizedEmbed;
+          }
+          return (request, options) => voyageAIChannels.contextualizedEmbed.invoke(
+            target.contextualizedEmbed,
+            target,
+            [request, options],
+            {}
+          );
+        default:
+          return Reflect.get(target, prop, receiver);
+      }
+    }
+  });
+  voyageAIProxyCache.set(client, proxy);
+  return proxy;
+}
+
 // src/wrappers/groq.ts
 function wrapGroq(groq) {
   if (isSupportedGroqClient(groq)) {
@@ -41883,14 +42698,14 @@ function wrapGroq(groq) {
 function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
-function hasFunction5(value, methodName) {
+function hasFunction6(value, methodName) {
   return isRecord6(value) && methodName in value && typeof value[methodName] === "function";
 }
 function hasChat2(value) {
-  return isRecord6(value) && isRecord6(value.completions) && hasFunction5(value.completions, "create");
+  return isRecord6(value) && isRecord6(value.completions) && hasFunction6(value.completions, "create");
 }
 function hasEmbeddings2(value) {
-  return hasFunction5(value, "create");
+  return hasFunction6(value, "create");
 }
 function isSupportedGroqClient(value) {
   return isRecord6(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
@@ -42473,7 +43288,7 @@ async function flushExperimentWithSync(context, config) {
 // src/wrappers/shared/scorers.ts
 async function runScorers(args) {
   const { scorers, output, expected, input, metadata, span } = args;
-  const scorerArgs = {
+  const scorerArgs2 = {
     output,
     expected,
     input,
@@ -42482,7 +43297,7 @@ async function runScorers(args) {
   await Promise.all(
     scorers.map(async (scorer) => {
       try {
-        const result = await scorer(scorerArgs);
+        const result = await scorer(scorerArgs2);
         const scores = normalizeScores(result);
         if (scores.length > 0) {
           const accScores = {};
@@ -44841,6 +45656,26 @@ async function getExperimentParametersRef(parameters) {
     version: resolvedParameters.version
   };
 }
+async function _internalInitEvaluatorExperiment(projectName, evaluator, data, options = {}) {
+  if (options.disabled) return null;
+  const { baseExperiment } = callEvaluatorData(data);
+  const parameters = await getExperimentParametersRef(evaluator.parameters);
+  return initExperiment2(evaluator.state, {
+    ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: projectName },
+    experiment: options.experimentName ?? evaluator.experimentName,
+    description: evaluator.description,
+    metadata: evaluator.metadata,
+    tags: evaluator.tags,
+    isPublic: evaluator.isPublic,
+    update: options.update ?? evaluator.update,
+    baseExperiment: evaluator.baseExperimentName ?? baseExperiment,
+    baseExperimentId: evaluator.baseExperimentId,
+    gitMetadataSettings: evaluator.gitMetadataSettings,
+    repoInfo: evaluator.repoInfo,
+    dataset: Dataset2.isDataset(data) ? data : void 0,
+    parameters
+  });
+}
 function callEvaluatorData(data) {
   const dataResult = typeof data === "function" ? data() : data;
   let baseExperiment = void 0;
@@ -44858,6 +45693,48 @@ function isAsyncIterable7(value) {
 function isIterable(value) {
   return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
 }
+async function _internalResolveEvaluatorData(evaluator, experiment) {
+  if (typeof evaluator.data === "string") {
+    throw new Error("Unimplemented: string data paths");
+  }
+  let dataResult = typeof evaluator.data === "function" ? evaluator.data() : evaluator.data;
+  if ("_type" in dataResult) {
+    if (dataResult._type !== "BaseExperiment") {
+      throw new Error("Invalid _type");
+    }
+    if (!experiment) {
+      throw new Error(
+        "Cannot use BaseExperiment() without connecting to Braintrust (you most likely set --no-send-logs)"
+      );
+    }
+    let name = dataResult.name;
+    if (isEmpty2(name)) {
+      const baseExperiment = await experiment.fetchBaseExperiment();
+      if (!baseExperiment) {
+        throw new Error("BaseExperiment() failed to fetch base experiment");
+      }
+      name = baseExperiment.name;
+    }
+    dataResult = initExperiment2(evaluator.state, {
+      ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: evaluator.projectName },
+      experiment: name,
+      open: true
+    }).asDataset();
+  }
+  const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
+  if (isAsyncIterable7(resolvedDataResult)) {
+    return resolvedDataResult;
+  }
+  if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
+    const iterable = resolvedDataResult;
+    return (async function* () {
+      for (const datum of iterable) yield datum;
+    })();
+  }
+  throw new Error(
+    "Evaluator data must be an array, iterable, or async iterable"
+  );
+}
 globalThis._evals = {
   functions: [],
   prompts: [],
@@ -44904,25 +45781,13 @@ async function Eval(name, evaluator, reporterOrOpts) {
   }
   const resolvedReporter = options.reporter || defaultReporter;
   try {
-    const { data, baseExperiment: defaultBaseExperiment } = callEvaluatorData(
-      evaluator.data
-    );
-    const parameters = await getExperimentParametersRef(evaluator.parameters);
-    const experiment = options.parent || options.noSendLogs ? null : initExperiment2(evaluator.state, {
-      ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: name },
-      experiment: evaluator.experimentName,
-      description: evaluator.description,
-      metadata: evaluator.metadata,
-      tags: evaluator.tags,
-      isPublic: evaluator.isPublic,
-      update: evaluator.update,
-      baseExperiment: evaluator.baseExperimentName ?? defaultBaseExperiment,
-      baseExperimentId: evaluator.baseExperimentId,
-      gitMetadataSettings: evaluator.gitMetadataSettings,
-      repoInfo: evaluator.repoInfo,
-      dataset: Dataset2.isDataset(data) ? data : void 0,
-      parameters
-    });
+    const { data } = callEvaluatorData(evaluator.data);
+    const experiment = await _internalInitEvaluatorExperiment(
+      name,
+      evaluator,
+      data,
+      { disabled: Boolean(options.parent || options.noSendLogs) }
+    );
     if (experiment && typeof process !== "undefined" && globalThis.BRAINTRUST_CONTEXT_MANAGER !== void 0) {
       await experiment._waitForId();
     }
@@ -45020,19 +45885,74 @@ function scorerName(scorer, scorer_idx) {
 function classifierName(classifier, classifier_idx) {
   return classifier.name || `classifier_${classifier_idx}`;
 }
+async function _internalRunEvaluatorTask(task, datum, trialIndex, parameters, span, reportProgress = () => void 0) {
+  const metadata = {
+    ..."metadata" in datum ? datum.metadata : {}
+  };
+  const hooks = {
+    meta(value) {
+      Object.assign(metadata, value);
+    },
+    metadata,
+    expected: "expected" in datum ? datum.expected : void 0,
+    span,
+    parameters,
+    reportProgress,
+    trialIndex,
+    tags: [...datum.tags ?? []]
+  };
+  const output = await task(datum.input, hooks);
+  span.log({ output });
+  return {
+    output,
+    metadata: hooks.metadata,
+    tags: hooks.tags ?? []
+  };
+}
 function buildSpanMetadata(results) {
-  return results.length === 1 ? results[0].metadata : results.reduce(
-    (prev, s) => mergeDicts(prev, { [s.name]: s.metadata }),
-    {}
+  return results.length === 1 ? results[0].metadata : Object.fromEntries(
+    results.map((result) => [result.name, result.metadata])
   );
 }
 function buildSpanScores(results) {
-  const scoresRecord = results.reduce(
-    (prev, s) => mergeDicts(prev, { [s.name]: s.score }),
-    {}
+  const scoresRecord = Object.fromEntries(
+    results.map((result) => [result.name, result.score])
   );
   return { resultMetadata: buildSpanMetadata(results), scoresRecord };
 }
+function _internalPrepareEvaluatorScore(scoreValue, name) {
+  if (scoreValue === null) return { results: null };
+  if (Array.isArray(scoreValue)) {
+    for (const score of scoreValue) {
+      if (!(typeof score === "object" && !isEmpty2(score))) {
+        throw new Error(
+          `When returning an array of scores, each score must be a non-empty object. Got: ${JSON.stringify(score)}`
+        );
+      }
+    }
+  }
+  let results;
+  if (Array.isArray(scoreValue)) {
+    results = scoreValue;
+  } else if (typeof scoreValue === "object" && !isEmpty2(scoreValue)) {
+    results = [scoreValue];
+  } else {
+    results = [{ name, score: scoreValue }];
+  }
+  const { resultMetadata, scoresRecord } = buildSpanScores(results);
+  const fields = (score) => {
+    const { metadata: _metadata, name: _name, ...rest } = score;
+    return rest;
+  };
+  return {
+    results,
+    output: results.length === 1 ? fields(results[0]) : Object.fromEntries(
+      results.map((score) => [score.name ?? name, fields(score)])
+    ),
+    metadata: resultMetadata,
+    scores: scoresRecord
+  };
+}
 async function runInScorerSpan(rootSpan, spanName, spanType, propagatedEvent, eventInput, fn) {
   try {
     const value = await rootSpan.traced(fn, {
@@ -45077,6 +45997,27 @@ function toClassificationItem(c) {
     ...c.metadata !== void 0 ? { metadata: c.metadata } : {}
   };
 }
+function _internalPrepareEvaluatorClassification(value, name) {
+  if (value === null) return { results: null };
+  const results = (Array.isArray(value) ? value : [value]).map(
+    (result) => validateClassificationResult(result, name)
+  );
+  const classifications = /* @__PURE__ */ Object.create(null);
+  for (const result of results) {
+    (classifications[result.name] ??= []).push(toClassificationItem(result));
+  }
+  return {
+    results,
+    output: results.length === 1 ? toClassificationItem(results[0]) : Object.fromEntries(
+      results.map((result) => [
+        result.name,
+        toClassificationItem(result)
+      ])
+    ),
+    metadata: buildSpanMetadata(results),
+    classifications
+  };
+}
 function logScoringFailures(kind, failures, metadata, rootSpan, state) {
   if (!failures.length) return [];
   const errorMap = Object.fromEntries(
@@ -45124,54 +46065,14 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
     (evaluator.state ?? _internalGetGlobalState())?.spanCache?.start();
   }
   try {
-    if (typeof evaluator.data === "string") {
-      throw new Error("Unimplemented: string data paths");
-    }
-    let dataResult = typeof evaluator.data === "function" ? evaluator.data() : evaluator.data;
     parameters = await validateParameters(
       parameters ?? {},
       evaluator.parameters
     );
-    if ("_type" in dataResult) {
-      if (dataResult._type !== "BaseExperiment") {
-        throw new Error("Invalid _type");
-      }
-      if (!experiment) {
-        throw new Error(
-          "Cannot use BaseExperiment() without connecting to Braintrust (you most likely set --no-send-logs)"
-        );
-      }
-      let name = dataResult.name;
-      if (isEmpty2(name)) {
-        const baseExperiment = await experiment.fetchBaseExperiment();
-        if (!baseExperiment) {
-          throw new Error("BaseExperiment() failed to fetch base experiment");
-        }
-        name = baseExperiment.name;
-      }
-      dataResult = initExperiment2(evaluator.state, {
-        ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: evaluator.projectName },
-        experiment: name,
-        open: true
-      }).asDataset();
-    }
-    const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
-    const dataIterable = (() => {
-      if (isAsyncIterable7(resolvedDataResult)) {
-        return resolvedDataResult;
-      }
-      if (Array.isArray(resolvedDataResult) || isIterable(resolvedDataResult)) {
-        const iterable = resolvedDataResult;
-        return (async function* () {
-          for (const datum of iterable) {
-            yield datum;
-          }
-        })();
-      }
-      throw new Error(
-        "Evaluator data must be an array, iterable, or async iterable"
-      );
-    })();
+    const dataIterable = await _internalResolveEvaluatorData(
+      evaluator,
+      experiment
+    );
     progressReporter.start(evaluator.evalName, 0);
     const experimentIdPromise = experiment ? (async () => {
       try {
@@ -45240,57 +46141,45 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             ensureSpansFlushed,
             state
           }) : void 0;
-          let metadata = {
-            ..."metadata" in datum ? datum.metadata : {}
-          };
+          let metadata = {};
           const expected = "expected" in datum ? datum.expected : void 0;
           let output = void 0;
           let error = void 0;
-          let tags = [...datum.tags ?? []];
-          const scores = {};
-          const classifications = {};
+          let tags = [];
+          const scores = /* @__PURE__ */ Object.create(null);
+          const classifications = /* @__PURE__ */ Object.create(null);
           const scorerNames = (evaluator.scores ?? []).map(scorerName);
           const classifierNames = (evaluator.classifiers ?? []).map(
             classifierName
           );
           let unhandledScores = scorerNames;
           try {
-            const meta = (o) => metadata = { ...metadata, ...o };
-            await rootSpan.traced(
-              async (span) => {
-                const hooksForTask = {
-                  meta,
-                  metadata,
-                  expected,
-                  span,
-                  parameters: parameters ?? {},
-                  reportProgress: (event) => {
-                    stream?.({
-                      ...event,
-                      id: rootSpan.id,
-                      origin: baseEvent.event?.origin,
-                      name: evaluator.evalName,
-                      object_type: "task"
-                    });
-                  },
-                  trialIndex,
-                  tags
-                };
-                const outputResult = evaluator.task(datum.input, hooksForTask);
-                if (outputResult instanceof Promise) {
-                  output = await outputResult;
-                } else {
-                  output = outputResult;
+            const taskResult = await rootSpan.traced(
+              (span) => _internalRunEvaluatorTask(
+                evaluator.task,
+                datum,
+                trialIndex,
+                parameters ?? {},
+                span,
+                (event) => {
+                  stream?.({
+                    ...event,
+                    id: rootSpan.id,
+                    origin: baseEvent.event?.origin,
+                    name: evaluator.evalName,
+                    object_type: "task"
+                  });
                 }
-                tags = hooksForTask.tags ?? [];
-                span.log({ output });
-              },
+              ),
               {
                 name: "task",
                 spanAttributes: { type: "task" /* TASK */ },
                 event: { input: datum.input }
               }
             );
+            output = taskResult.output;
+            metadata = taskResult.metadata;
+            tags = taskResult.tags;
             if (tags.length) {
               rootSpan.log({ output, metadata, expected, tags });
             } else {
@@ -45300,20 +46189,18 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               await rootSpan.flush();
             }
             const scoringArgs = {
+              id: datum.id,
               input: datum.input,
               expected: "expected" in datum ? datum.expected : void 0,
               metadata,
               output,
+              tags,
               trace
             };
             const { trace: _trace, ...scoringArgsForLogging } = scoringArgs;
             const propagatedEvent = makeScorerPropagatedEvent(
               await rootSpan.export()
             );
-            const getOtherFields = (s) => {
-              const { metadata: _metadata, name: _name, ...rest } = s;
-              return rest;
-            };
             const [scoreResults, classificationResults] = await Promise.all([
               Promise.all(
                 (evaluator.scores ?? []).map(
@@ -45327,35 +46214,17 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                       const scoreValue = await Promise.resolve(
                         score(scoringArgs)
                       );
-                      if (scoreValue === null) return null;
-                      if (Array.isArray(scoreValue)) {
-                        for (const s of scoreValue) {
-                          if (!(typeof s === "object" && !isEmpty2(s))) {
-                            throw new Error(
-                              `When returning an array of scores, each score must be a non-empty object. Got: ${JSON.stringify(s)}`
-                            );
-                          }
-                        }
-                      }
-                      const results = Array.isArray(scoreValue) ? scoreValue : typeof scoreValue === "object" && !isEmpty2(scoreValue) ? [scoreValue] : [
-                        {
-                          name: scorerNames[score_idx],
-                          score: scoreValue
-                        }
-                      ];
-                      const { resultMetadata, scoresRecord } = buildSpanScores(results);
-                      const resultOutput = results.length === 1 ? getOtherFields(results[0]) : results.reduce(
-                        (prev, s) => mergeDicts(prev, {
-                          [s.name]: getOtherFields(s)
-                        }),
-                        {}
+                      const prepared = _internalPrepareEvaluatorScore(
+                        scoreValue,
+                        scorerNames[score_idx]
                       );
+                      if (prepared.results === null) return null;
                       span.log({
-                        output: resultOutput,
-                        metadata: resultMetadata,
-                        scores: scoresRecord
+                        output: prepared.output,
+                        metadata: prepared.metadata,
+                        scores: prepared.scores
                       });
-                      return results;
+                      return prepared.results;
                     }
                   )
                 )
@@ -45372,24 +46241,16 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                       const classifierValue = await Promise.resolve(
                         classifier(scoringArgs)
                       );
-                      if (classifierValue === null) return null;
-                      const rawResults = (Array.isArray(classifierValue) ? classifierValue : [classifierValue]).map(
-                        (result) => validateClassificationResult(
-                          result,
-                          classifierNames[idx]
-                        )
-                      );
-                      const resultOutput = rawResults.length === 1 ? toClassificationItem(rawResults[0]) : rawResults.reduce(
-                        (prev, r) => mergeDicts(prev, {
-                          [r.name]: toClassificationItem(r)
-                        }),
-                        {}
+                      const prepared = _internalPrepareEvaluatorClassification(
+                        classifierValue,
+                        classifierNames[idx]
                       );
+                      if (prepared.results === null) return null;
                       span.log({
-                        output: resultOutput,
-                        metadata: buildSpanMetadata(rawResults)
+                        output: prepared.output,
+                        metadata: prepared.metadata
                       });
-                      return rawResults;
+                      return prepared.results;
                     }
                   )
                 )
@@ -45618,7 +46479,7 @@ function accumulateScores(accumulator, scores) {
   }
 }
 function ensureScoreAccumulator(results) {
-  const accumulator = {};
+  const accumulator = /* @__PURE__ */ Object.create(null);
   for (const result of results) {
     accumulateScores(accumulator, result.scores);
   }
@@ -45761,6 +46622,1156 @@ var defaultReporter = {
   }
 };
 
+// src/durable-eval.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var BATCH_TASK_KIND = "braintrust.durable.batch-task";
+var BATCH_SCORER_KIND = "braintrust.durable.batch-scorer";
+var DEFAULT_BATCH_SIZE = 1e3;
+var DurableEvalMemoryStore = class {
+  values = /* @__PURE__ */ new Map();
+  async read(key) {
+    return this.values.get(key)?.slice();
+  }
+  async write(key, value) {
+    this.values.set(key, value.slice());
+  }
+  async getOrSet(key, value) {
+    const existing = this.values.get(key);
+    if (existing) return { value: existing.slice(), created: false };
+    this.values.set(key, value.slice());
+    return { value: value.slice(), created: true };
+  }
+};
+var DurableEvalRedisStore = class {
+  client;
+  keyPrefix;
+  ttlMs;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix ?? "braintrust-eval:";
+    this.ttlMs = options.ttlMs ?? 1e3 * 60 * 60 * 24 * 7;
+    if (!Number.isInteger(this.ttlMs) || this.ttlMs < 1) {
+      throw new Error("DurableEvalRedisStore ttlMs must be a positive integer");
+    }
+  }
+  async read(key) {
+    const value = await this.client.get(`${this.keyPrefix}${key}`);
+    if (value == null) return void 0;
+    if (typeof value !== "string") {
+      throw new Error("DurableEvalRedisStore expected GET to return a string");
+    }
+    return base64ToUint8Array(value);
+  }
+  async write(key, value) {
+    const client = this.client;
+    const set = client.set;
+    const redisKey = `${this.keyPrefix}${key}`;
+    const encoded = uint8ArrayToBase64(value);
+    if (typeof client.defineCommand === "function") {
+      await set.call(client, redisKey, encoded, "PX", this.ttlMs);
+    } else if (typeof client.sendCommand === "function") {
+      await set.call(client, redisKey, encoded, { PX: this.ttlMs });
+    } else if (typeof client.createScript === "function") {
+      await set.call(client, redisKey, encoded, { px: this.ttlMs });
+    } else {
+      throw new Error(
+        "DurableEvalRedisStore requires a node-redis, ioredis, or @upstash/redis client"
+      );
+    }
+  }
+  async getOrSet(key, value) {
+    const redisKey = `${this.keyPrefix}${key}`;
+    const encoded = uint8ArrayToBase64(value);
+    const client = this.client;
+    const set = client.set;
+    let setOptions;
+    if (typeof client.defineCommand === "function") {
+      setOptions = ["PX", this.ttlMs, "NX", "GET"];
+    } else if (typeof client.sendCommand === "function") {
+      setOptions = [{ PX: this.ttlMs, NX: true, GET: true }];
+    } else if (typeof client.createScript === "function") {
+      setOptions = [{ px: this.ttlMs, nx: true, get: true }];
+    } else {
+      throw new Error(
+        "DurableEvalRedisStore getOrSet requires a node-redis, ioredis, or @upstash/redis client"
+      );
+    }
+    const existing = await set.call(client, redisKey, encoded, ...setOptions);
+    if (existing === null) return { value: value.slice(), created: true };
+    if (typeof existing !== "string") {
+      throw new Error(
+        "DurableEvalRedisStore expected atomic SET to return a string or null"
+      );
+    }
+    return { value: base64ToUint8Array(existing), created: false };
+  }
+};
+var BatchTask = class {
+  constructor(processor) {
+    this.processor = processor;
+  }
+  processor;
+  kind = BATCH_TASK_KIND;
+};
+var BatchScorer = class {
+  constructor(processor) {
+    this.processor = processor;
+    this.name = processor.name;
+  }
+  processor;
+  kind = BATCH_SCORER_KIND;
+  name;
+};
+function defineDurableEval(projectName, evaluator) {
+  const definition = {
+    projectName,
+    evalName: evaluator.experimentName ?? projectName,
+    evaluator
+  };
+  return {
+    start: (options = {}) => startDurableEval(definition, options),
+    status: (options) => getDurableEvalStatus(definition, options),
+    poll: (options) => pollDurableEval(definition, options),
+    processBatchResult: (result) => processDurableBatchResult(definition, result)
+  };
+}
+async function startDurableEval(definition, options) {
+  const store = definition.evaluator.store;
+  const runId = newId();
+  const key = runKey(definition.projectName, definition.evalName, runId);
+  const { data } = callEvaluatorData(definition.evaluator.data);
+  const parameters = await validateParameters(
+    options.parameters ?? {},
+    definition.evaluator.parameters
+  );
+  const experimentName = definition.evaluator.experimentName ?? `${definition.evalName}-${runId}`;
+  const experiment = await _internalInitEvaluatorExperiment(
+    definition.projectName,
+    { ...definition.evaluator, data },
+    data,
+    {
+      disabled: options.noSendLogs ?? false,
+      experimentName,
+      update: true
+    }
+  );
+  if (!isBatchTask(definition.evaluator.task) && !(definition.evaluator.scores ?? []).some(isBatchScorer)) {
+    const result = await runEvaluator(
+      experiment,
+      {
+        ...definition.evaluator,
+        projectName: definition.projectName,
+        evalName: definition.evalName,
+        data
+      },
+      {
+        start: () => void 0,
+        stop: () => void 0,
+        increment: () => void 0
+      },
+      [],
+      void 0,
+      parameters,
+      true,
+      true
+    );
+    const state2 = {
+      runId,
+      experimentName,
+      noSendLogs: options.noSendLogs ?? false,
+      parameters: assertJsonValue(parameters, "eval parameters"),
+      status: "completed",
+      summary: result.summary,
+      cases: [],
+      batches: []
+    };
+    await experiment?.flush();
+    await writeRunRecord(store, key, state2);
+    return currentStatus(definition, state2);
+  }
+  const state = {
+    runId,
+    experimentName,
+    noSendLogs: options.noSendLogs ?? false,
+    parameters: assertJsonValue(parameters, "eval parameters"),
+    status: "running",
+    cases: await materializeCases(definition, data, experiment),
+    batches: []
+  };
+  await writeCaseBaseRecords(store, key, state.cases);
+  await writeRunRecord(store, key, state);
+  return advanceDurableEval(definition, state, store, key, experiment);
+}
+async function getDurableEvalStatus(definition, options) {
+  const store = definition.evaluator.store;
+  const state = await readRunState(
+    definition,
+    store,
+    runKey(definition.projectName, definition.evalName, options.runId)
+  );
+  if (!state) throw new Error(`Durable eval run ${options.runId} is missing`);
+  return currentStatus(definition, state);
+}
+async function processDurableBatchResult(definition, result) {
+  if (!result.batchId && !result.externalId) {
+    throw new Error("Batch results require batchId or externalId");
+  }
+  const store = definition.evaluator.store;
+  const key = runKey(definition.projectName, definition.evalName, result.runId);
+  const state = await readRunState(definition, store, key);
+  if (!state) throw new Error(`Durable eval run ${result.runId} is missing`);
+  const byBatch = result.batchId ? state.batches.find((candidate) => candidate.id === result.batchId) : void 0;
+  const byExternal = result.externalId ? state.batches.find(
+    (candidate) => candidate.externalId === result.externalId
+  ) : void 0;
+  if (byBatch && byExternal && byBatch.id !== byExternal.id) {
+    throw new Error("batchId and externalId identify different batches");
+  }
+  const batch = byBatch ?? byExternal;
+  if (!batch) throw new Error("No submitted batch matches this result");
+  if (batch.status !== "complete") {
+    const records = await collectBatch(definition, state, batch);
+    batch.status = "complete";
+    await writeCaseRecords(store, key, records);
+    await writeBatchRecords(store, key, [batch]);
+  }
+  return advanceDurableEval(
+    definition,
+    await readRunState(definition, store, key),
+    store,
+    key
+  );
+}
+async function pollDurableEval(definition, options) {
+  const store = definition.evaluator.store;
+  const key = runKey(
+    definition.projectName,
+    definition.evalName,
+    options.runId
+  );
+  const state = await readRunState(definition, store, key);
+  if (!state) throw new Error(`Durable eval run ${options.runId} is missing`);
+  const batches = state.batches.filter((batch) => {
+    if (batch.status === "complete") return false;
+    return processorForStage(definition, batch.kind, batch.scorerName).completion.mode === "poll";
+  });
+  const results = await Promise.all(
+    batches.map(async (batch) => ({
+      batch,
+      result: await processorForStage(definition, batch.kind, batch.scorerName).completion.poll(batch.submissionData, {
+        runId: state.runId,
+        batchId: batch.id
+      })
+    }))
+  );
+  const changedCases = /* @__PURE__ */ new Map();
+  const changedBatches = [];
+  for (const { batch, result } of results) {
+    if (result.status === "failed") throw asError(result.error);
+    if (result.status !== "complete") continue;
+    for (const record of await collectBatch(definition, state, batch)) {
+      changedCases.set(record.id, record);
+    }
+    batch.status = "complete";
+    changedBatches.push(batch);
+  }
+  if (changedBatches.length > 0) {
+    await writeCaseRecords(store, key, [...changedCases.values()]);
+    await writeBatchRecords(store, key, changedBatches);
+  }
+  const currentState = changedBatches.length > 0 ? await readRunState(definition, store, key) : state;
+  return advanceDurableEval(definition, currentState, store, key);
+}
+async function openDurableExperiment(definition, state) {
+  const data = [];
+  return await _internalInitEvaluatorExperiment(
+    definition.projectName,
+    { ...definition.evaluator, data },
+    data,
+    {
+      disabled: state.noSendLogs,
+      experimentName: state.experimentName,
+      update: true
+    }
+  );
+}
+async function advanceDurableEval(definition, state, store, key, existingExperiment) {
+  if (state.status === "completed") return currentStatus(definition, state);
+  const experiment = existingExperiment === void 0 ? await openDurableExperiment(definition, state) : existingExperiment;
+  await runTaskStage(definition, state, store, key, experiment);
+  await logCompletedTasks(definition, state, store, key, experiment);
+  state = await readRunState(definition, store, key) ?? state;
+  if (state.cases.some((record) => !record.taskComplete || !record.taskLogged)) {
+    return currentStatus(definition, state);
+  }
+  await runScoreStages(definition, state, store, key, experiment);
+  state = await readRunState(definition, store, key) ?? state;
+  const scorerNames = resolveScorers(definition.evaluator.scores ?? []).map(
+    ({ name }) => name
+  );
+  const classifierNames = (definition.evaluator.classifiers ?? []).map(
+    classifierName
+  );
+  if (state.cases.some(
+    (record) => scorerNames.some(
+      (name) => !Object.hasOwn(record.scores, name) || !Object.hasOwn(record.loggedScores, name)
+    ) || classifierNames.some(
+      (name) => !Object.hasOwn(record.loggedClassifications, name)
+    )
+  )) {
+    return currentStatus(definition, state);
+  }
+  if (!await claimAction(store, key, "finish")) {
+    const latest = await readRunState(definition, store, key);
+    return currentStatus(definition, latest ?? state);
+  }
+  state.summary = await finishExperiment(definition, state, experiment);
+  state.status = "completed";
+  await writeRunRecord(store, key, state);
+  return currentStatus(definition, state);
+}
+function currentStatus(definition, state) {
+  if (state.status === "completed") {
+    if (!state.summary) {
+      throw new Error(`Durable eval run ${state.runId} has no saved summary`);
+    }
+    return {
+      status: "completed",
+      runId: state.runId,
+      pending: { poll: 0, webhook: 0 },
+      summary: state.summary
+    };
+  }
+  const pending = { poll: 0, webhook: 0 };
+  for (const batch of state.batches) {
+    if (batch.status === "complete") continue;
+    pending[processorForStage(definition, batch.kind, batch.scorerName).completion.mode]++;
+  }
+  return { status: "waiting", runId: state.runId, pending };
+}
+async function startCaseRoot(definition, state, record, experiment) {
+  if (!experiment) return NOOP_SPAN;
+  const datum = record.datum;
+  return _internalStartSpanWithInitialMerge({
+    ...definition.evaluator.state ? { state: definition.evaluator.state } : {},
+    parent: await experiment.export(),
+    name: "eval",
+    spanId: deterministicId(`${state.runId}:${record.id}:span`),
+    spanAttributes: { type: "eval" /* EVAL */ },
+    event: {
+      id: deterministicId(`${state.runId}:${record.id}:row`),
+      input: datum.input,
+      expected: "expected" in datum ? datum.expected : void 0,
+      tags: datum.tags,
+      origin: datum.origin
+    }
+  });
+}
+async function logTaskResult(definition, state, record, experiment, task) {
+  const datum = record.datum;
+  const root = await startCaseRoot(definition, state, record, experiment);
+  try {
+    if (task) {
+      const result = await root.traced(
+        (span) => _internalRunEvaluatorTask(
+          task,
+          datum,
+          record.trialIndex,
+          state.parameters,
+          span
+        ),
+        {
+          name: "task",
+          spanId: deterministicId(`${state.runId}:${record.id}:task`),
+          spanAttributes: { type: "task" /* TASK */ },
+          event: { input: datum.input }
+        }
+      );
+      record.output = assertJsonValue(
+        result.output,
+        `task output for ${record.caseId}`
+      );
+      record.metadata = assertJsonValue(result.metadata, "task metadata");
+      record.tags = result.tags;
+      record.taskComplete = true;
+    } else {
+      await root.traced((span) => span.log({ output: record.output }), {
+        name: "task",
+        spanId: deterministicId(`${state.runId}:${record.id}:task`),
+        spanAttributes: { type: "task" /* TASK */ },
+        event: { input: datum.input }
+      });
+    }
+    root.log({
+      output: record.output,
+      expected: "expected" in datum ? datum.expected : void 0,
+      metadata: {
+        ...record.metadata,
+        durable_eval: {
+          run_id: state.runId,
+          case_id: record.caseId,
+          trial_index: record.trialIndex
+        }
+      },
+      tags: record.tags
+    });
+    record.rootSpan = await root.export();
+    record.taskLogged = true;
+  } catch (error) {
+    logError(root, error);
+    throw error;
+  } finally {
+    root.end();
+  }
+}
+async function logCompletedTasks(definition, state, store, key, experiment) {
+  const changed = [];
+  for (const record of state.cases) {
+    if (!record.taskComplete || record.taskLogged) continue;
+    if (!await claimAction(store, key, "task-log", record.id)) continue;
+    await logTaskResult(definition, state, record, experiment);
+    changed.push(record);
+  }
+  if (changed.length > 0) {
+    await experiment?.flush();
+    await writeCaseRecords(store, key, changed);
+  }
+}
+async function runTaskStage(definition, state, store, key, experiment) {
+  if (isBatchTask(definition.evaluator.task)) {
+    await ensureBatches(definition, state, store, key, "task");
+    return;
+  }
+  const task = definition.evaluator.task;
+  const changed = [];
+  for (const record of state.cases) {
+    if (record.taskComplete) continue;
+    if (!await claimAction(store, key, "task", record.id)) continue;
+    await logTaskResult(definition, state, record, experiment, task);
+    changed.push(record);
+  }
+  if (changed.length > 0) {
+    await experiment?.flush();
+    await writeCaseRecords(store, key, changed);
+  }
+}
+async function runScoreStages(definition, state, store, key, experiment) {
+  const scorers = resolveScorers(definition.evaluator.scores ?? []);
+  const changed = /* @__PURE__ */ new Map();
+  const persistChangedCases = async () => {
+    if (changed.size === 0) return;
+    await experiment?.flush();
+    await writeCaseRecords(store, key, [...changed.values()]);
+    changed.clear();
+  };
+  for (const { name, scorer } of scorers) {
+    if (isBatchScorer(scorer)) {
+      for (const record of state.cases) {
+        if (Object.hasOwn(record.scores, name) && !Object.hasOwn(record.loggedScores, name)) {
+          if (!await claimAction(store, key, "score-log", record.id, name)) {
+            continue;
+          }
+          await evaluateAndLogScore(
+            definition,
+            state,
+            record,
+            name,
+            experiment
+          );
+          changed.set(record.id, record);
+        }
+      }
+      await persistChangedCases();
+      await ensureBatches(definition, state, store, key, "score", name);
+      continue;
+    }
+    for (const record of state.cases) {
+      if (Object.hasOwn(record.loggedScores, name)) continue;
+      if (!await claimAction(store, key, "score", record.id, name)) continue;
+      await evaluateAndLogScore(
+        definition,
+        state,
+        record,
+        name,
+        experiment,
+        scorer
+      );
+      changed.set(record.id, record);
+    }
+  }
+  for (const [index, classifier] of (definition.evaluator.classifiers ?? []).entries()) {
+    const name = classifierName(classifier, index);
+    for (const record of state.cases) {
+      if (Object.hasOwn(record.loggedClassifications, name)) continue;
+      if (!await claimAction(store, key, "classification", record.id, name)) {
+        continue;
+      }
+      await evaluateAndLogClassification(
+        definition,
+        state,
+        record,
+        name,
+        classifier,
+        experiment
+      );
+      changed.set(record.id, record);
+    }
+  }
+  await persistChangedCases();
+}
+function scorerArgs(record) {
+  const datum = record.datum;
+  return {
+    ...datum,
+    metadata: record.metadata,
+    output: record.output
+  };
+}
+function resumeCaseRoot(definition, record, experiment) {
+  if (!experiment) return NOOP_SPAN;
+  if (!record.rootSpan) {
+    throw new Error(`Durable eval case ${record.caseId} has no root span`);
+  }
+  return _internalResumeSpan({
+    exported: record.rootSpan,
+    state: definition.evaluator.state
+  });
+}
+async function evaluateAndLogScore(definition, state, record, name, experiment, scorer) {
+  const root = resumeCaseRoot(definition, record, experiment);
+  try {
+    const rootExport = await root.export();
+    const prepared = await root.traced(
+      async (span) => {
+        const value = scorer ? await scorer(scorerArgs(record)) : record.scores[name];
+        if (scorer) {
+          record.scores[name] = assertJsonValue(value, `scorer ${name} output`);
+        }
+        const result = _internalPrepareEvaluatorScore(value, name);
+        if (result.results !== null) {
+          span.log({
+            output: result.output,
+            metadata: result.metadata,
+            scores: result.scores
+          });
+        }
+        return result;
+      },
+      {
+        name,
+        spanId: deterministicId(`${state.runId}:${record.id}:score:${name}`),
+        spanAttributes: {
+          type: "score" /* SCORE */,
+          purpose: "scorer"
+        },
+        propagatedEvent: makeScorerPropagatedEvent(rootExport || void 0),
+        event: { input: scorerArgs(record) }
+      }
+    );
+    if (prepared.scores) root.log({ scores: prepared.scores });
+    record.loggedScores[name] = true;
+  } catch (error) {
+    logError(root, error);
+    throw error;
+  } finally {
+    root.end();
+  }
+}
+async function evaluateAndLogClassification(definition, state, record, name, classifier, experiment) {
+  const root = resumeCaseRoot(definition, record, experiment);
+  try {
+    const rootExport = await root.export();
+    const prepared = await root.traced(
+      async (span) => {
+        const value = await classifier(scorerArgs(record));
+        record.classifications[name] = assertJsonValue(
+          value,
+          `classifier ${name} output`
+        );
+        const result = _internalPrepareEvaluatorClassification(value, name);
+        if (result.results !== null) {
+          span.log({ output: result.output, metadata: result.metadata });
+        }
+        return result;
+      },
+      {
+        name,
+        spanId: deterministicId(
+          `${state.runId}:${record.id}:classification:${name}`
+        ),
+        spanAttributes: {
+          type: "classifier" /* CLASSIFIER */,
+          purpose: "scorer"
+        },
+        propagatedEvent: makeScorerPropagatedEvent(rootExport || void 0),
+        event: { input: scorerArgs(record) }
+      }
+    );
+    if (prepared.classifications) {
+      root.log({ classifications: prepared.classifications });
+    }
+    record.loggedClassifications[name] = true;
+  } catch (error) {
+    logError(root, error);
+    throw error;
+  } finally {
+    root.end();
+  }
+}
+async function ensureBatches(definition, state, store, key, kind, scorerName2) {
+  const processor = processorForStage(definition, kind, scorerName2);
+  const plans = plannedBatches(
+    definition,
+    state.runId,
+    state.cases.map(({ id }) => id)
+  );
+  const casesById = new Map(state.cases.map((record) => [record.id, record]));
+  for (const plan of plans) {
+    if (plan.kind !== kind || plan.scorerName !== scorerName2) continue;
+    if (state.batches.some(({ id }) => id === plan.id)) continue;
+    const records = plan.itemIds.map((id) => casesById.get(id));
+    const ready = records.every(
+      (record) => kind === "task" ? !record.taskComplete : !Object.hasOwn(record.scores, scorerName2)
+    );
+    if (!ready) continue;
+    const batchId = plan.id;
+    const claim = await store.getOrSet(
+      claimRecordKey(key, "batch", batchId),
+      encoder.encode(batchId)
+    );
+    if (!claim.created) continue;
+    const context = { runId: state.runId, batchId };
+    const items = records.map(
+      (record) => kind === "task" ? taskBatchItem(record, state.parameters) : scorerBatchItem(record)
+    );
+    const submissionData = assertJsonValue(
+      await processor.submit(items, context),
+      `submission data for batch ${batchId}`
+    );
+    const externalId = processor.completion.mode === "webhook" ? processor.completion.getExternalId(submissionData, context) : void 0;
+    if (externalId !== void 0 && !externalId.trim()) {
+      throw new Error(`Batch ${batchId} produced an empty externalId`);
+    }
+    const batch = {
+      id: batchId,
+      kind,
+      scorerName: scorerName2,
+      itemIds: records.map((record) => record.id),
+      submissionData,
+      externalId,
+      status: "submitted"
+    };
+    state.batches.push(batch);
+    await writeBatchRecords(store, key, [batch]);
+  }
+}
+async function collectBatch(definition, state, batch) {
+  const processor = processorForStage(definition, batch.kind, batch.scorerName);
+  const context = { runId: state.runId, batchId: batch.id };
+  const results = await processor.collect(batch.submissionData, context);
+  if (!Array.isArray(results)) {
+    throw new Error(`collect for batch ${batch.id} must return an array`);
+  }
+  const expectedIds = new Set(batch.itemIds);
+  const seen = /* @__PURE__ */ new Set();
+  const records = [];
+  for (const result of results) {
+    const id = resultItemId(result);
+    if (!expectedIds.has(id)) {
+      throw new Error(`Batch ${batch.id} returned unknown item ${id}`);
+    }
+    if (seen.has(id)) {
+      throw new Error(`Batch ${batch.id} returned item ${id} more than once`);
+    }
+    seen.add(id);
+    const record = state.cases.find((candidate) => candidate.id === id);
+    records.push(record);
+    if (batch.kind === "task") {
+      record.output = assertJsonValue(
+        result.output,
+        `task output for item ${id}`
+      );
+      if ("metadata" in result && result.metadata !== void 0) {
+        record.metadata = assertJsonValue(
+          {
+            ...record.metadata,
+            ...result.metadata
+          },
+          `metadata for ${id}`
+        );
+      }
+      if ("tags" in result && result.tags !== void 0)
+        record.tags = result.tags;
+      record.taskComplete = true;
+    } else {
+      record.scores[batch.scorerName] = assertJsonValue(
+        result.score,
+        `score output for item ${id}`
+      );
+    }
+  }
+  const missing = batch.itemIds.filter((id) => !seen.has(id));
+  if (missing.length > 0) {
+    throw new Error(
+      `Batch ${batch.id} did not return results for: ${missing.join(", ")}`
+    );
+  }
+  return records;
+}
+function processorForStage(definition, kind, scorerName2) {
+  if (kind === "task") {
+    if (!isBatchTask(definition.evaluator.task)) {
+      throw new Error("Definition no longer contains the batch task");
+    }
+    return definition.evaluator.task.processor;
+  }
+  const scorer = resolveScorers(definition.evaluator.scores ?? []).find(
+    ({ name }) => name === scorerName2
+  )?.scorer;
+  if (!isBatchScorer(scorer)) {
+    throw new Error(`Definition no longer contains scorer ${scorerName2}`);
+  }
+  return scorer.processor;
+}
+async function materializeCases(definition, data, experiment) {
+  const evaluator = definition.evaluator;
+  const iterable = await _internalResolveEvaluatorData(
+    {
+      data,
+      projectName: definition.projectName,
+      projectId: evaluator.projectId,
+      state: evaluator.state
+    },
+    experiment
+  );
+  const records = [];
+  const seen = /* @__PURE__ */ new Set();
+  for await (const datum of iterable) {
+    const caseId = datum.id ?? datum.upsert_id ?? (evaluator.caseId ? await evaluator.caseId(datum) : void 0);
+    if (!caseId) {
+      throw new Error(
+        "Every durable eval case requires id, upsert_id, or caseId"
+      );
+    }
+    if (seen.has(caseId))
+      throw new Error(`Duplicate durable eval case id: ${caseId}`);
+    seen.add(caseId);
+    const trialCount = datum.trialCount ?? evaluator.trialCount ?? 1;
+    if (!Number.isInteger(trialCount) || trialCount < 1) {
+      throw new Error(`Invalid trialCount for durable eval case ${caseId}`);
+    }
+    for (let trialIndex = 0; trialIndex < trialCount; trialIndex++) {
+      records.push({
+        id: `${caseId}:trial:${trialIndex}`,
+        caseId,
+        trialIndex,
+        datum: assertJsonValue(datum, `case ${caseId}`),
+        metadata: assertJsonValue(
+          "metadata" in datum ? datum.metadata : {},
+          `metadata for ${caseId}`
+        ),
+        tags: datum.tags,
+        taskComplete: false,
+        taskLogged: false,
+        scores: /* @__PURE__ */ Object.create(null),
+        loggedScores: /* @__PURE__ */ Object.create(null),
+        classifications: /* @__PURE__ */ Object.create(null),
+        loggedClassifications: /* @__PURE__ */ Object.create(null)
+      });
+    }
+  }
+  return records;
+}
+function taskBatchItem(record, parameters) {
+  const datum = record.datum;
+  return {
+    id: record.id,
+    input: datum.input,
+    expected: "expected" in datum ? datum.expected : void 0,
+    metadata: record.metadata,
+    tags: record.tags,
+    parameters,
+    trialIndex: record.trialIndex
+  };
+}
+function scorerBatchItem(record) {
+  const datum = record.datum;
+  return {
+    id: record.id,
+    input: datum.input,
+    output: record.output,
+    expected: "expected" in datum ? datum.expected : void 0,
+    metadata: record.metadata,
+    tags: record.tags,
+    trialIndex: record.trialIndex
+  };
+}
+async function finishExperiment(definition, state, experiment) {
+  const scorerNames = resolveScorers(definition.evaluator.scores ?? []).map(
+    ({ name }) => name
+  );
+  const results = state.cases.map((record) => {
+    const datum = record.datum;
+    const scores = Object.fromEntries(
+      scorerNames.flatMap(
+        (name) => Object.entries(
+          _internalPrepareEvaluatorScore(
+            record.scores[name],
+            name
+          ).scores ?? {}
+        )
+      )
+    );
+    const classifications = Object.fromEntries(
+      Object.entries(record.classifications).flatMap(
+        ([name, value]) => Object.entries(
+          _internalPrepareEvaluatorClassification(value, name).classifications ?? {}
+        )
+      )
+    );
+    return {
+      ...datum,
+      output: record.output,
+      metadata: record.metadata,
+      tags: record.tags,
+      scores,
+      error: void 0,
+      ...Object.keys(classifications).length > 0 ? { classifications } : {}
+    };
+  });
+  if (!experiment) {
+    return buildLocalSummary(
+      {
+        ...definition.evaluator,
+        projectName: definition.projectName,
+        evalName: state.experimentName
+      },
+      results
+    );
+  }
+  await experiment.flush();
+  let comparisonExperimentId = definition.evaluator.baseExperimentId;
+  if (!comparisonExperimentId) {
+    try {
+      comparisonExperimentId = await experiment._getBaseExperimentId();
+    } catch {
+      comparisonExperimentId = void 0;
+    }
+  }
+  return await experiment.summarize({
+    summarizeScores: definition.evaluator.summarizeScores,
+    ...comparisonExperimentId ? { comparisonExperimentId } : {}
+  });
+}
+function resolveScorers(scorers) {
+  return scorers.map((scorer, index) => ({
+    name: isBatchScorer(scorer) ? scorer.name : scorer.name || `scorer_${index}`,
+    scorer
+  }));
+}
+function runKey(projectName, evalName, runId) {
+  return `durable-eval/v1/runs/${contentVersion(encoder.encode(`${projectName}\0${evalName}\0${runId}`))}`;
+}
+function encodedKeyPart(value) {
+  return uint8ArrayToBase64(encoder.encode(value)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function caseRecordKey(key, caseId, kind, ...names) {
+  const suffix = names.map(encodedKeyPart).join("/");
+  return `${key}/cases/${encodedKeyPart(caseId)}/${kind}${suffix ? `/${suffix}` : ""}`;
+}
+function batchRecordKey(key, batchId) {
+  return `${key}/batches/${encodedKeyPart(batchId)}`;
+}
+function claimRecordKey(key, kind, ...parts) {
+  const identity = stableStringify([kind, parts]);
+  return `${key}/claims/${contentVersion(encoder.encode(identity))}`;
+}
+async function claimAction(store, key, kind, ...parts) {
+  return (await store.getOrSet(
+    claimRecordKey(key, kind, ...parts),
+    encoder.encode("claimed")
+  )).created;
+}
+function plannedBatches(definition, runId, caseIds) {
+  const stages = [];
+  if (isBatchTask(definition.evaluator.task)) stages.push({ kind: "task" });
+  for (const { name, scorer } of resolveScorers(
+    definition.evaluator.scores ?? []
+  )) {
+    if (isBatchScorer(scorer)) {
+      stages.push({ kind: "score", scorerName: name });
+    }
+  }
+  const plans = [];
+  for (const { kind, scorerName: scorerName2 } of stages) {
+    const batchSize = processorForStage(definition, kind, scorerName2).batchSize ?? DEFAULT_BATCH_SIZE;
+    if (!Number.isInteger(batchSize) || batchSize < 1) {
+      throw new Error(
+        `Invalid batchSize for ${scorerName2 ?? "task"}: ${batchSize}`
+      );
+    }
+    for (let offset = 0; offset < caseIds.length; offset += batchSize) {
+      const itemIds = caseIds.slice(offset, offset + batchSize);
+      plans.push({
+        id: deterministicId(
+          stableStringify([runId, kind, scorerName2, itemIds])
+        ),
+        kind,
+        scorerName: scorerName2,
+        itemIds
+      });
+    }
+  }
+  return plans;
+}
+async function readCaseRecord(definition, store, key, id) {
+  const scorers = resolveScorers(definition.evaluator.scores ?? []);
+  const classifiers = (definition.evaluator.classifiers ?? []).map(
+    classifierName
+  );
+  const [
+    base,
+    task,
+    taskLog,
+    scoreValues,
+    scoreLogValues,
+    classificationValues,
+    classificationLogValues
+  ] = await Promise.all([
+    readJson(store, caseRecordKey(key, id, "base")),
+    readJson(store, caseRecordKey(key, id, "task")),
+    readJson(store, caseRecordKey(key, id, "task-log")),
+    Promise.all(
+      scorers.map(async ({ name }) => ({
+        name,
+        value: await readJson(
+          store,
+          caseRecordKey(key, id, "score", name)
+        )
+      }))
+    ),
+    Promise.all(
+      scorers.map(async ({ name }) => ({
+        name,
+        value: await readJson(
+          store,
+          caseRecordKey(key, id, "score-log", name)
+        )
+      }))
+    ),
+    Promise.all(
+      classifiers.map(async (name) => ({
+        name,
+        value: await readJson(
+          store,
+          caseRecordKey(key, id, "classification", name)
+        )
+      }))
+    ),
+    Promise.all(
+      classifiers.map(async (name) => ({
+        name,
+        value: await readJson(
+          store,
+          caseRecordKey(key, id, "classification-log", name)
+        )
+      }))
+    )
+  ]);
+  if (!base) throw new Error(`Durable eval case ${id} is missing`);
+  const scores = /* @__PURE__ */ Object.create(null);
+  for (const { name, value } of scoreValues) {
+    if (value !== void 0) scores[name] = value;
+  }
+  const loggedScores = /* @__PURE__ */ Object.create(null);
+  for (const { name, value } of scoreLogValues) {
+    if (value) loggedScores[name] = true;
+  }
+  const classifications = /* @__PURE__ */ Object.create(null);
+  for (const { name, value } of classificationValues) {
+    if (value !== void 0) classifications[name] = value;
+  }
+  const loggedClassifications = /* @__PURE__ */ Object.create(null);
+  for (const { name, value } of classificationLogValues) {
+    if (value) loggedClassifications[name] = true;
+  }
+  return {
+    ...base,
+    metadata: task?.metadata ?? base.metadata,
+    tags: task ? task.tags : base.tags,
+    taskComplete: task !== void 0,
+    taskLogged: taskLog !== void 0,
+    output: task?.output,
+    rootSpan: taskLog?.rootSpan,
+    scores,
+    loggedScores,
+    classifications,
+    loggedClassifications
+  };
+}
+async function readRunState(definition, store, key) {
+  const record = await readJson(store, key);
+  if (!record) return void 0;
+  const plans = plannedBatches(definition, record.runId, record.caseIds);
+  const [cases, batchRecords] = await Promise.all([
+    Promise.all(
+      record.caseIds.map((id) => readCaseRecord(definition, store, key, id))
+    ),
+    Promise.all(
+      plans.map(async ({ id }) => {
+        return readJson(store, batchRecordKey(key, id));
+      })
+    )
+  ]);
+  const batches = batchRecords.filter(
+    (value) => value !== void 0
+  );
+  const { caseIds: _caseIds, ...state } = record;
+  return { ...state, cases, batches };
+}
+async function writeRunRecord(store, key, state) {
+  const { cases, batches: _batches, ...record } = state;
+  await writeJson(store, key, {
+    ...record,
+    caseIds: cases.map(({ id }) => id)
+  });
+}
+async function writeCaseBaseRecords(store, key, records) {
+  await Promise.all(
+    records.map(
+      ({ id, caseId, trialIndex, datum, metadata, tags }) => writeJson(store, caseRecordKey(key, id, "base"), {
+        id,
+        caseId,
+        trialIndex,
+        datum,
+        metadata,
+        tags
+      })
+    )
+  );
+}
+async function writeCaseRecords(store, key, records) {
+  const writes = [];
+  for (const record of records) {
+    if (record.taskComplete) {
+      writes.push(
+        writeJson(store, caseRecordKey(key, record.id, "task"), {
+          output: record.output,
+          metadata: record.metadata,
+          tags: record.tags,
+          taskComplete: true
+        })
+      );
+    }
+    if (record.taskLogged) {
+      writes.push(
+        writeJson(store, caseRecordKey(key, record.id, "task-log"), {
+          rootSpan: record.rootSpan,
+          taskLogged: true
+        })
+      );
+    }
+    for (const [name, value] of Object.entries(record.scores)) {
+      writes.push(
+        writeJson(store, caseRecordKey(key, record.id, "score", name), value)
+      );
+    }
+    for (const name of Object.keys(record.loggedScores)) {
+      writes.push(
+        writeJson(
+          store,
+          caseRecordKey(key, record.id, "score-log", name),
+          true
+        )
+      );
+    }
+    for (const [name, value] of Object.entries(record.classifications)) {
+      writes.push(
+        writeJson(
+          store,
+          caseRecordKey(key, record.id, "classification", name),
+          value
+        )
+      );
+    }
+    for (const name of Object.keys(record.loggedClassifications)) {
+      writes.push(
+        writeJson(
+          store,
+          caseRecordKey(key, record.id, "classification-log", name),
+          true
+        )
+      );
+    }
+  }
+  await Promise.all(writes);
+}
+async function writeBatchRecords(store, key, records) {
+  await Promise.all(
+    records.map(
+      (record) => writeJson(store, batchRecordKey(key, record.id), record)
+    )
+  );
+}
+function deterministicId(value) {
+  const hex = contentVersion(encoder.encode(value)).padEnd(32, "0").slice(0, 32);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-5${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+function contentVersion(value) {
+  if (isomorph_default.hash) return isomorph_default.hash(decoder.decode(value));
+  let hash = 2166136261;
+  for (const byte of value) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+async function readJson(store, key) {
+  const value = await store.read(key);
+  return value ? JSON.parse(decoder.decode(value)) : void 0;
+}
+async function writeJson(store, key, value) {
+  await store.write(key, encoder.encode(stableStringify(value)));
+}
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, nested) => {
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+      return Object.fromEntries(
+        Object.entries(nested).sort(
+          ([left], [right]) => left.localeCompare(right)
+        )
+      );
+    }
+    return nested;
+  });
+}
+function assertJsonValue(value, label) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0)
+      throw new Error("value serializes to undefined");
+    return JSON.parse(serialized);
+  } catch (error) {
+    throw new Error(`${label} must be JSON serializable`, { cause: error });
+  }
+}
+function resultItemId(value) {
+  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string") {
+    throw new Error("Batch results must contain a string id");
+  }
+  return value.id;
+}
+function isBatchTask(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === BATCH_TASK_KIND;
+}
+function isBatchScorer(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === BATCH_SCORER_KIND;
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
 // src/agent-assertions.ts
 function agentAssertionScorer(callback, options = {}) {
   return async (args) => {
@@ -46693,6 +48704,8 @@ export {
   BRAINTRUST_PARENT_KEY,
   BaseAttachment,
   BaseExperiment,
+  BatchScorer,
+  BatchTask,
   BraintrustLangChainCallbackHandler,
   BraintrustMiddleware,
   BraintrustObservabilityExporter,
@@ -46706,6 +48719,8 @@ export {
   DEFAULT_MAX_REQUEST_SIZE,
   Dataset2 as Dataset,
   DatasetPipeline,
+  DurableEvalMemoryStore,
+  DurableEvalRedisStore,
   ERR_PERMALINK,
   Eval,
   EvalResultWithSummary,
@@ -46764,6 +48779,7 @@ export {
   deepCopyEvent,
   exports_exports as default,
   defaultErrorScoreHandler,
+  defineDurableEval,
   deserializePlainStringAsJSON,
   devNullWritableStream,
   evaluatorDefinitionSchema,
@@ -46859,5 +48875,6 @@ export {
   wrapPiCodingAgentSDK,
   wrapStrandsAgentSDK,
   wrapTraced,
-  wrapVitest
+  wrapVitest,
+  wrapVoyageAI
 };