braintrust 3.27.0 → 3.29.0

package/dev/dist/index.mjs

@@ -1,6 +1,6 @@
 // src/node/config.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import * as path from "node:path";
+import * as path2 from "node:path";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as fsSync from "node:fs";
@@ -664,8 +664,6 @@ function newGlobalTracingChannel(nameOrChannels) {
 var DefaultAsyncLocalStorage = class {
   constructor() {
   }
-  enterWith(_) {
-  }
   run(_, callback) {
     return callback();
   }
@@ -800,34 +798,93 @@ setGlobalHookErrorReporter((error) => {
   debugLogger.error("Global instrumentation hook error:", error);
 });
 
-// src/gitutil.ts
-import { simpleGit } from "simple-git";
-var COMMON_BASE_BRANCHES = ["main", "master", "develop"];
-async function currentRepo() {
-  try {
-    const git = simpleGit();
-    if (await git.checkIsRepo()) {
-      return git;
-    } else {
-      return null;
+// src/git-command.ts
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import * as path from "node:path";
+var GIT_EXECUTABLE_NAMES = process.platform === "win32" ? ["git.exe", "git"] : ["git"];
+var GIT_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+var gitExecutablePromise;
+function executableSearchPath() {
+  return Object.entries(process.env).find(
+    ([name]) => name.toUpperCase() === "PATH"
+  )?.[1];
+}
+async function findGitExecutable(searchPath = executableSearchPath()) {
+  if (!searchPath) {
+    return void 0;
+  }
+  for (const rawSearchDir of searchPath.split(path.delimiter)) {
+    const searchDir = rawSearchDir.trim().replace(/^"(.*)"$/, "$1");
+    if (!path.isAbsolute(searchDir)) {
+      continue;
     }
-  } catch {
-    return null;
+    for (const executableName of GIT_EXECUTABLE_NAMES) {
+      const candidate = path.join(searchDir, executableName);
+      try {
+        await access(
+          candidate,
+          process.platform === "win32" ? constants.F_OK : constants.X_OK
+        );
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+async function resolveGitExecutable() {
+  gitExecutablePromise ??= findGitExecutable();
+  return await gitExecutablePromise;
+}
+async function runGitCommand(args, options = {}) {
+  const executable = await resolveGitExecutable();
+  if (!executable) {
+    throw new Error("Could not find a git executable on PATH");
   }
+  return await new Promise((resolve, reject2) => {
+    execFile(
+      executable,
+      args,
+      {
+        cwd: options.cwd,
+        encoding: "utf8",
+        maxBuffer: GIT_MAX_BUFFER_BYTES
+      },
+      (error, stdout) => {
+        if (error) {
+          reject2(error);
+        } else {
+          resolve(stdout);
+        }
+      }
+    );
+  });
 }
+
+// src/gitutil.ts
+var COMMON_BASE_BRANCHES = ["main", "master", "develop"];
 var _baseBranch = null;
 async function getBaseBranch(remote = void 0) {
   if (_baseBranch === null) {
-    const git = await currentRepo();
-    if (git === null) {
+    const repoPath = await currentRepoPath();
+    if (!repoPath) {
       throw new Error("Not in a git repo");
     }
-    const remoteName = remote ?? (await git.getRemotes())[0]?.name;
+    const runGit = async (args) => await runGitCommand(args, { cwd: repoPath });
+    const remoteName = remote ?? (await runGit(["remote"])).trim().split(/\r?\n/)[0];
     if (!remoteName) {
       throw new Error("No remote found");
     }
     let branch = null;
-    const repoBranches = new Set((await git.branchLocal()).all);
+    const repoBranches = new Set(
+      (await runGit([
+        "for-each-ref",
+        "--format=%(refname:short)",
+        "refs/heads/"
+      ])).trim().split(/\r?\n/)
+    );
     const matchingBaseBranches = COMMON_BASE_BRANCHES.filter(
       (b) => repoBranches.has(b)
     );
@@ -835,7 +892,7 @@ async function getBaseBranch(remote = void 0) {
       branch = matchingBaseBranches[0];
     } else {
       try {
-        const remoteInfo = await git.remote(["show", remoteName]);
+        const remoteInfo = await runGit(["remote", "show", remoteName]);
         if (!remoteInfo) {
           throw new Error(`Could not find remote ${remoteName}`);
         }
@@ -853,27 +910,28 @@ async function getBaseBranch(remote = void 0) {
   return _baseBranch;
 }
 async function getBaseBranchAncestor(remote = void 0) {
-  const git = await currentRepo();
-  if (git === null) {
+  const repoPath = await currentRepoPath();
+  if (!repoPath) {
     throw new Error("Not in a git repo");
   }
   const { remote: remoteName, branch: baseBranch } = await getBaseBranch(remote);
-  const isDirty = (await git.diffSummary()).files.length > 0;
+  const isDirty = (await runGitCommand(["diff", "--name-only"], {
+    cwd: repoPath
+  })).trim().length > 0;
   const head = isDirty ? "HEAD" : "HEAD^";
   try {
-    const ancestor = await git.raw([
-      "merge-base",
-      head,
-      `${remoteName}/${baseBranch}`
-    ]);
+    const ancestor = await runGitCommand(
+      ["merge-base", head, `${remoteName}/${baseBranch}`],
+      { cwd: repoPath }
+    );
     return ancestor.trim();
   } catch {
     return void 0;
   }
 }
 async function getPastNAncestors(n = 1e3, remote = void 0) {
-  const git = await currentRepo();
-  if (git === null) {
+  const repoPath = await currentRepoPath();
+  if (!repoPath) {
     return [];
   }
   let ancestor = void 0;
@@ -888,8 +946,10 @@ async function getPastNAncestors(n = 1e3, remote = void 0) {
   if (!ancestor) {
     return [];
   }
-  const commits = await git.log({ from: ancestor, to: "HEAD", maxCount: n });
-  return commits.all.slice(0, n).map((c) => c.hash);
+  const commits = (await runGitCommand(["rev-list", `--max-count=${n}`, `${ancestor}..HEAD`], {
+    cwd: repoPath
+  })).trim();
+  return commits ? commits.split(/\r?\n/).slice(0, n) : [];
 }
 async function attempt(fn) {
   try {
@@ -920,9 +980,14 @@ async function getRepoInfo(settings) {
   });
   return sanitized;
 }
+async function currentRepoPath() {
+  return await attempt(
+    async () => (await runGitCommand(["rev-parse", "--show-toplevel"])).trim()
+  );
+}
 async function repoInfo() {
-  const git = await currentRepo();
-  if (git === null) {
+  const repoPath = await currentRepoPath();
+  if (!repoPath) {
     return void 0;
   }
   let commit = void 0;
@@ -933,29 +998,32 @@ async function repoInfo() {
   let tag = void 0;
   let branch = void 0;
   let git_diff = void 0;
-  const dirty = (await git.diffSummary()).files.length > 0;
-  commit = await attempt(async () => await git.revparse(["HEAD"]));
+  const runGit = async (args) => await runGitCommand(args, { cwd: repoPath });
+  const dirty = (await runGit(["diff", "--name-only"])).trim().length > 0;
+  commit = await attempt(
+    async () => (await runGit(["rev-parse", "HEAD"])).trim()
+  );
   commit_message = await attempt(
-    async () => (await git.raw(["log", "-1", "--pretty=%B"])).trim()
+    async () => (await runGit(["log", "-1", "--pretty=%B"])).trim()
   );
   commit_time = await attempt(
-    async () => (await git.raw(["log", "-1", "--pretty=%cI"])).trim()
+    async () => (await runGit(["log", "-1", "--pretty=%cI"])).trim()
   );
   author_name = await attempt(
-    async () => (await git.raw(["log", "-1", "--pretty=%aN"])).trim()
+    async () => (await runGit(["log", "-1", "--pretty=%aN"])).trim()
   );
   author_email = await attempt(
-    async () => (await git.raw(["log", "-1", "--pretty=%aE"])).trim()
+    async () => (await runGit(["log", "-1", "--pretty=%aE"])).trim()
   );
   tag = await attempt(
-    async () => (await git.raw(["describe", "--tags", "--exact-match", "--always"])).trim()
+    async () => (await runGit(["describe", "--tags", "--exact-match", "--always"])).trim()
   );
   branch = await attempt(
-    async () => (await git.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim()
+    async () => (await runGit(["rev-parse", "--abbrev-ref", "HEAD"])).trim()
   );
   if (dirty) {
     git_diff = await attempt(
-      async () => truncateToByteLimit(await git.raw(["--no-ext-diff", "diff", "HEAD"]))
+      async () => truncateToByteLimit(await runGit(["diff", "--no-ext-diff", "HEAD"]))
     );
   }
   return {
@@ -2036,15 +2104,15 @@ function mergeDictsWithPaths({
 function mergeDictsWithPathsHelper({
   mergeInto,
   mergeFrom,
-  path: path2,
+  path: path3,
   mergePaths
 }) {
   Object.entries(mergeFrom).forEach(([k, mergeFromV]) => {
     if (FORBIDDEN_MERGE_KEYS.has(k)) return;
-    const fullPath = path2.concat([k]);
+    const fullPath = path3.concat([k]);
     const fullPathSerialized = JSON.stringify(fullPath);
     const mergeIntoV = recordFind(mergeInto, k);
-    const isSetUnionField = path2.length === 0 && SET_UNION_FIELDS.has(k) && !mergePaths.has(fullPathSerialized);
+    const isSetUnionField = path3.length === 0 && SET_UNION_FIELDS.has(k) && !mergePaths.has(fullPathSerialized);
     if (isSetUnionField && isArray(mergeIntoV) && isArray(mergeFromV)) {
       const seen = /* @__PURE__ */ new Set();
       const combined = [];
@@ -2077,9 +2145,9 @@ function mergeDicts(mergeInto, mergeFrom) {
 function recordFind(m, k) {
   return m[k];
 }
-function getObjValueByPath(row, path2) {
+function getObjValueByPath(row, path3) {
   let curr = row;
-  for (const p of path2) {
+  for (const p of path3) {
     if (!isObjectOrArray(curr)) {
       return null;
     }
@@ -2706,7 +2774,10 @@ var AclObjectType = z6.union([
     "org_member",
     "project_log",
     "org_project",
-    "org_audit_logs"
+    "org_audit_logs",
+    "project_group",
+    "ai_secret",
+    "org_ai_secret"
   ]),
   z6.null()
 ]);
@@ -2835,7 +2906,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(),
@@ -2904,7 +2976,7 @@ var FunctionTypeEnum = z6.enum([
   "parameters",
   "sandbox"
 ]);
-var NullableSavedFunctionId = z6.union([
+var FacetPreprocessorId = z6.union([
   z6.object({
     type: z6.literal("function"),
     id: z6.string(),
@@ -2915,10 +2987,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(),
@@ -2930,6 +3015,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(),
@@ -2943,7 +3029,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(),
@@ -3204,18 +3290,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(),
@@ -3437,7 +3511,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(),
@@ -3536,7 +3610,7 @@ var PromptParserNullish = z6.union([
   }),
   z6.null()
 ]);
-var PreprocessorSavedFunctionId = z6.union([
+var PreprocessorId = z6.union([
   z6.object({
     type: z6.literal("function"),
     id: z6.string(),
@@ -3547,6 +3621,7 @@ var PreprocessorSavedFunctionId = z6.union([
     name: z6.string(),
     function_type: z6.literal("preprocessor").optional().default("preprocessor")
   }),
+  z6.object({ type: z6.literal("inline"), code: z6.string().min(1) }),
   z6.null()
 ]);
 var PromptDataNullish = z6.union([
@@ -3554,7 +3629,7 @@ var PromptDataNullish = z6.union([
     prompt: PromptBlockDataNullish,
     options: PromptOptionsNullish,
     parser: PromptParserNullish,
-    preprocessor: PreprocessorSavedFunctionId,
+    preprocessor: PreprocessorId,
     tool_functions: z6.union([z6.array(SavedFunctionId), z6.null()]),
     template_format: z6.union([
       z6.enum(["mustache", "nunjucks", "none"]),
@@ -3756,7 +3831,7 @@ var PromptData = z6.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
   parser: PromptParserNullish,
-  preprocessor: PreprocessorSavedFunctionId,
+  preprocessor: PreprocessorId,
   tool_functions: z6.union([z6.array(SavedFunctionId), z6.null()]),
   template_format: z6.union([
     z6.enum(["mustache", "nunjucks", "none"]),
@@ -3942,6 +4017,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",
@@ -3963,6 +4051,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(),
@@ -4043,6 +4132,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()
@@ -4084,7 +4239,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()
 });
@@ -4098,15 +4254,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()
         })
       ])
     }),
@@ -4157,21 +4319,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(),
@@ -4389,7 +4568,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(),
@@ -4594,7 +4774,10 @@ var View = z6.object({
     "for_review_datasets"
   ]),
   name: z6.string(),
+  description: z6.union([z6.string(), z6.null()]).optional(),
+  starred: z6.boolean().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(),
@@ -5121,10 +5304,10 @@ var DiskCache = class {
       return;
     }
     const stats = await Promise.all(
-      paths.map(async (path2) => {
-        const stat2 = await isomorph_default.stat(path2);
+      paths.map(async (path3) => {
+        const stat2 = await isomorph_default.stat(path3);
         return {
-          path: path2,
+          path: path3,
           mtime: stat2.mtime.getTime()
         };
       })
@@ -5296,44 +5479,72 @@ function createCacheLayers({
 }
 
 // src/prompt-cache/prompt-cache.ts
-function createCacheKey(key) {
+function createCacheKey(key, namespace) {
+  let cacheKey;
   if (key.id) {
-    return `id:${key.id}`;
-  }
-  const prefix = key.projectId ?? key.projectName;
-  if (!prefix) {
-    throw new Error("Either projectId or projectName must be provided");
-  }
-  if (!key.slug) {
-    throw new Error("Slug must be provided when not using ID");
+    cacheKey = `id:${key.id}`;
+  } else {
+    const prefix = key.projectId ?? key.projectName;
+    if (!prefix) {
+      throw new Error("Either projectId or projectName must be provided");
+    }
+    if (!key.slug) {
+      throw new Error("Slug must be provided when not using ID");
+    }
+    cacheKey = `${prefix}:${key.slug}:${key.version ?? "latest"}`;
   }
-  return `${prefix}:${key.slug}:${key.version ?? "latest"}`;
+  return namespace === void 0 ? cacheKey : `${namespace.length}:${namespace}:${cacheKey}`;
 }
-var PromptCache = class {
+var PromptCache = class _PromptCache {
   memoryCache;
   diskCache;
+  namespace;
+  expectedResolvedOrgIdentity;
   constructor(options) {
     this.memoryCache = options.memoryCache;
     this.diskCache = options.diskCache;
+    this.namespace = options.namespace;
+    this.expectedResolvedOrgIdentity = options.expectedResolvedOrgIdentity;
+  }
+  /**
+   * Returns a cache view that shares the same storage layers but isolates all
+   * entries under the provided namespace.
+   */
+  withNamespace(namespace, expectedResolvedOrgIdentity) {
+    return new _PromptCache({
+      memoryCache: this.memoryCache,
+      diskCache: this.diskCache,
+      namespace,
+      expectedResolvedOrgIdentity
+    });
   }
   /**
    * Retrieves a prompt from the cache.
    * First checks the in-memory LRU cache, then falls back to checking the disk cache if available.
    */
   async get(key) {
-    const cacheKey = createCacheKey(key);
+    const cacheKey = createCacheKey(key, this.namespace);
     if (this.memoryCache) {
-      const memoryPrompt = this.memoryCache.get(cacheKey);
-      if (memoryPrompt !== void 0) {
-        return memoryPrompt;
+      const memoryEntry = this.memoryCache.get(cacheKey);
+      if (memoryEntry !== void 0 && (this.expectedResolvedOrgIdentity === void 0 || memoryEntry.resolvedOrgIdentity === this.expectedResolvedOrgIdentity)) {
+        return memoryEntry.value;
       }
     }
     if (this.diskCache) {
-      const diskPrompt = await this.diskCache.get(cacheKey);
-      if (!diskPrompt) {
+      const diskEntry = await this.diskCache.get(cacheKey);
+      if (!diskEntry || this.expectedResolvedOrgIdentity !== void 0 && diskEntry.resolvedOrgIdentity !== this.expectedResolvedOrgIdentity) {
         return void 0;
       }
-      this.memoryCache?.set(cacheKey, diskPrompt);
+      const serializedPrompt = diskEntry.value;
+      const diskPrompt = new Prompt2(
+        serializedPrompt.metadata,
+        serializedPrompt.defaults,
+        serializedPrompt.noTrace
+      );
+      this.memoryCache?.set(cacheKey, {
+        value: diskPrompt,
+        resolvedOrgIdentity: diskEntry.resolvedOrgIdentity
+      });
       return diskPrompt;
     }
     return void 0;
@@ -5347,58 +5558,91 @@ var PromptCache = class {
    * @throws If there is an error writing to the disk cache.
    */
   async set(key, value) {
-    const cacheKey = createCacheKey(key);
-    this.memoryCache?.set(cacheKey, value);
+    const cacheKey = createCacheKey(key, this.namespace);
+    const memoryEntry = {
+      value,
+      resolvedOrgIdentity: this.expectedResolvedOrgIdentity
+    };
+    this.memoryCache?.set(cacheKey, memoryEntry);
     if (this.diskCache) {
-      await this.diskCache.set(cacheKey, value);
+      await this.diskCache.set(cacheKey, {
+        value: value._internalSerializeForCache(),
+        resolvedOrgIdentity: this.expectedResolvedOrgIdentity
+      });
     }
   }
 };
 
 // src/prompt-cache/parameters-cache.ts
-function createCacheKey2(key) {
+function createCacheKey2(key, namespace) {
+  let cacheKey;
   if (key.id) {
-    return `parameters:id:${key.id}`;
-  }
-  const prefix = key.projectId ?? key.projectName;
-  if (!prefix) {
-    throw new Error("Either projectId or projectName must be provided");
-  }
-  if (!key.slug) {
-    throw new Error("Slug must be provided when not using ID");
+    cacheKey = `parameters:id:${key.id}`;
+  } else {
+    const prefix = key.projectId ?? key.projectName;
+    if (!prefix) {
+      throw new Error("Either projectId or projectName must be provided");
+    }
+    if (!key.slug) {
+      throw new Error("Slug must be provided when not using ID");
+    }
+    cacheKey = `parameters:${prefix}:${key.slug}:${key.version ?? "latest"}`;
   }
-  return `parameters:${prefix}:${key.slug}:${key.version ?? "latest"}`;
+  return namespace === void 0 ? cacheKey : `${namespace.length}:${namespace}:${cacheKey}`;
 }
-var ParametersCache = class {
+var ParametersCache = class _ParametersCache {
   memoryCache;
   diskCache;
+  namespace;
+  expectedResolvedOrgIdentity;
   constructor(options) {
     this.memoryCache = options.memoryCache;
     this.diskCache = options.diskCache;
+    this.namespace = options.namespace;
+    this.expectedResolvedOrgIdentity = options.expectedResolvedOrgIdentity;
+  }
+  withNamespace(namespace, expectedResolvedOrgIdentity) {
+    return new _ParametersCache({
+      memoryCache: this.memoryCache,
+      diskCache: this.diskCache,
+      namespace,
+      expectedResolvedOrgIdentity
+    });
   }
   async get(key) {
-    const cacheKey = createCacheKey2(key);
+    const cacheKey = createCacheKey2(key, this.namespace);
     if (this.memoryCache) {
-      const memoryParams = this.memoryCache.get(cacheKey);
-      if (memoryParams !== void 0) {
-        return memoryParams;
+      const memoryEntry = this.memoryCache.get(cacheKey);
+      if (memoryEntry !== void 0 && (this.expectedResolvedOrgIdentity === void 0 || memoryEntry.resolvedOrgIdentity === this.expectedResolvedOrgIdentity)) {
+        return memoryEntry.value;
       }
     }
     if (this.diskCache) {
-      const diskParams = await this.diskCache.get(cacheKey);
-      if (!diskParams) {
+      const diskEntry = await this.diskCache.get(cacheKey);
+      if (!diskEntry || this.expectedResolvedOrgIdentity !== void 0 && diskEntry.resolvedOrgIdentity !== this.expectedResolvedOrgIdentity) {
         return void 0;
       }
-      this.memoryCache?.set(cacheKey, diskParams);
-      return diskParams;
+      const diskParameters = new RemoteEvalParameters(diskEntry.value.metadata);
+      this.memoryCache?.set(cacheKey, {
+        value: diskParameters,
+        resolvedOrgIdentity: diskEntry.resolvedOrgIdentity
+      });
+      return diskParameters;
     }
     return void 0;
   }
   async set(key, value) {
-    const cacheKey = createCacheKey2(key);
-    this.memoryCache?.set(cacheKey, value);
+    const cacheKey = createCacheKey2(key, this.namespace);
+    const memoryEntry = {
+      value,
+      resolvedOrgIdentity: this.expectedResolvedOrgIdentity
+    };
+    this.memoryCache?.set(cacheKey, memoryEntry);
     if (this.diskCache) {
-      await this.diskCache.set(cacheKey, value);
+      await this.diskCache.set(cacheKey, {
+        value: value._internalSerializeForCache(),
+        resolvedOrgIdentity: this.expectedResolvedOrgIdentity
+      });
     }
   }
 };
@@ -5702,6 +5946,7 @@ var INSTRUMENTATION_NAMES = {
   CLOUDFLARE_THINK: "cloudflare-think",
   COHERE: "cohere",
   CURSOR_SDK: "cursor-sdk",
+  DEEPSEEK_HARNESS: "deepseek-harness",
   EVE: "eve",
   FLUE: "flue",
   GENKIT: "genkit",
@@ -5721,12 +5966,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.29.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -5845,6 +6091,16 @@ var datasetSnapshotRegisterResponseSchema = z8.object({
   dataset_snapshot: DatasetSnapshot,
   found_existing: z8.boolean().optional()
 });
+var datasetObjectInfoSchema = z8.object({
+  object_id: z8.string(),
+  object_name: z8.string(),
+  parent_cols: z8.object({
+    project: z8.object({
+      id: z8.string(),
+      name: z8.string()
+    })
+  })
+});
 var datasetRestorePreviewResultSchema = z8.object({
   rows_to_restore: z8.number(),
   rows_to_delete: z8.number()
@@ -5921,6 +6177,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"
@@ -6055,12 +6314,53 @@ var loginSchema = z8.strictObject({
 });
 var stateNonce = 0;
 var V1_PROXY_SUFFIX = "/v1/proxy";
+var LOADER_LOGIN_CACHE_MAX = 16;
 function normalizeProxyConnUrl(proxyUrl) {
   return proxyUrl.endsWith(V1_PROXY_SUFFIX) ? proxyUrl.slice(0, proxyUrl.length - V1_PROXY_SUFFIX.length) : proxyUrl;
 }
 var BraintrustState = class _BraintrustState {
+  id;
+  currentExperiment;
+  // Note: the value of IsAsyncFlush doesn't really matter here, since we
+  // (safely) dynamically cast it whenever retrieving the logger.
+  currentLogger;
+  currentParent;
+  currentSpan;
+  // Any time we re-log in, we directly update the apiConn inside the logger.
+  // This is preferable to replacing the whole logger, which would create the
+  // possibility of multiple loggers floating around, which may not log in a
+  // deterministic order.
+  _bgLogger;
+  _overrideBgLogger = null;
+  appUrl = null;
+  appPublicUrl = null;
+  loginToken = null;
+  orgId = null;
+  orgName = null;
+  apiUrl = null;
+  proxyUrl = null;
+  loggedIn = false;
+  gitMetadataSettings;
+  debugLogLevel;
+  debugLogLevelConfigured = false;
+  fetch = globalThis.fetch;
+  _appConn = null;
+  _apiConn = null;
+  _proxyConn = null;
+  promptCache;
+  parametersCache;
+  spanCache;
+  _idGenerator = null;
+  _contextManager = null;
+  _otelFlushCallback = null;
+  spanOriginEnvironment;
+  traceContextSigningSecret;
+  loaderLoginCache = /* @__PURE__ */ new WeakMap();
+  loginParams;
+  activeLoginOrgNameSelector;
   constructor(loginParams) {
-    this.loginParams = loginParams;
+    this.loginParams = { ...loginParams };
+    this.activeLoginOrgNameSelector = loginParams.orgName ?? isomorph_default.getEnv("BRAINTRUST_ORG_NAME");
     this.id = `${(/* @__PURE__ */ new Date()).toLocaleString()}-${stateNonce++}`;
     this.currentExperiment = void 0;
     this.currentLogger = void 0;
@@ -6097,12 +6397,14 @@ var BraintrustState = class _BraintrustState {
     const {
       memoryCache: parametersMemoryCache,
       diskCache: parametersDiskCache
-    } = createCacheLayers({
-      memoryMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX",
-      diskCacheDirEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DIR",
-      diskMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DISK_MAX",
-      getDefaultDiskCacheDir: () => `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/parameters_cache`
-    });
+    } = createCacheLayers(
+      {
+        memoryMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_MEMORY_MAX",
+        diskCacheDirEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DIR",
+        diskMaxEnvVar: "BRAINTRUST_PARAMETERS_CACHE_DISK_MAX",
+        getDefaultDiskCacheDir: () => `${isomorph_default.getEnv("HOME") ?? isomorph_default.homedir()}/.braintrust/parameters_cache`
+      }
+    );
     this.parametersCache = new ParametersCache({
       memoryCache: parametersMemoryCache,
       diskCache: parametersDiskCache
@@ -6111,43 +6413,6 @@ var BraintrustState = class _BraintrustState {
     this.spanOriginEnvironment = detectSpanOriginEnvironment();
     this._internalSetTraceContextSigningSecret(loginParams.apiKey);
   }
-  loginParams;
-  id;
-  currentExperiment;
-  // Note: the value of IsAsyncFlush doesn't really matter here, since we
-  // (safely) dynamically cast it whenever retrieving the logger.
-  currentLogger;
-  currentParent;
-  currentSpan;
-  // Any time we re-log in, we directly update the apiConn inside the logger.
-  // This is preferable to replacing the whole logger, which would create the
-  // possibility of multiple loggers floating around, which may not log in a
-  // deterministic order.
-  _bgLogger;
-  _overrideBgLogger = null;
-  appUrl = null;
-  appPublicUrl = null;
-  loginToken = null;
-  orgId = null;
-  orgName = null;
-  apiUrl = null;
-  proxyUrl = null;
-  loggedIn = false;
-  gitMetadataSettings;
-  debugLogLevel;
-  debugLogLevelConfigured = false;
-  fetch = globalThis.fetch;
-  _appConn = null;
-  _apiConn = null;
-  _proxyConn = null;
-  promptCache;
-  parametersCache;
-  spanCache;
-  _idGenerator = null;
-  _contextManager = null;
-  _otelFlushCallback = null;
-  spanOriginEnvironment;
-  traceContextSigningSecret;
   /** @internal */
   _internalSetTraceContextSigningSecret(secret) {
     const normalizedSecret = secret?.trim();
@@ -6172,6 +6437,101 @@ var BraintrustState = class _BraintrustState {
     this._appConn = null;
     this._apiConn = null;
     this._proxyConn = null;
+    this.loaderLoginCache = /* @__PURE__ */ new WeakMap();
+  }
+  /** @internal */
+  async _internalResolveLoaderLoginOptions({
+    apiKey,
+    appUrl,
+    orgName,
+    fetch: fetch2,
+    forceLogin
+  }) {
+    const resolvedAppUrl = appUrl ?? (this.loggedIn ? this.appUrl ?? void 0 : void 0) ?? this.loginParams.appUrl ?? isomorph_default.getEnv("BRAINTRUST_APP_URL") ?? "https://www.braintrust.dev";
+    const resolvedApiKey = apiKey ?? (this.loggedIn ? this.loginToken ?? void 0 : void 0) ?? this.loginParams.apiKey ?? await isomorph_default.getBraintrustApiKey();
+    if (!resolvedApiKey) {
+      throw new Error(
+        "Please specify an api key (e.g. by setting BRAINTRUST_API_KEY)."
+      );
+    }
+    const normalizedApiKey = HTTPConnection.sanitize_token(resolvedApiKey);
+    const usesActiveCredential = this.loggedIn && normalizedApiKey === this.loginToken;
+    const requestedOrgName = orgName ?? (usesActiveCredential ? this.activeLoginOrgNameSelector : void 0) ?? this.loginParams.orgName ?? isomorph_default.getEnv("BRAINTRUST_ORG_NAME");
+    const resolvedOrgName = orgName ?? (usesActiveCredential ? this.orgName ?? void 0 : void 0) ?? requestedOrgName;
+    const resolvedFetch = fetch2 ?? (this.loggedIn ? this.fetch : void 0) ?? this.loginParams.fetch ?? globalThis.fetch;
+    const credentialCacheNamespace = JSON.stringify([
+      "loader-credential",
+      resolvedAppUrl,
+      requestedOrgName,
+      normalizedApiKey
+    ]);
+    return {
+      apiKey: normalizedApiKey,
+      appUrl: resolvedAppUrl,
+      orgName: resolvedOrgName,
+      fetch: resolvedFetch,
+      forceLogin,
+      credentialCacheNamespace,
+      existingState: !forceLogin && usesActiveCredential && resolvedAppUrl === this.appUrl && resolvedOrgName === this.orgName && resolvedFetch === this.fetch ? this : void 0
+    };
+  }
+  /** @internal */
+  _internalGetLoaderCacheViews(loginOptions, requestState) {
+    const expectedResolvedOrgIdentity = requestState?.orgId && requestState.appUrl ? JSON.stringify([
+      "loader-org",
+      requestState.appUrl,
+      requestState.orgId
+    ]) : void 0;
+    return {
+      promptCache: this.promptCache.withNamespace(
+        loginOptions.credentialCacheNamespace,
+        expectedResolvedOrgIdentity
+      ),
+      parametersCache: this.parametersCache.withNamespace(
+        loginOptions.credentialCacheNamespace,
+        expectedResolvedOrgIdentity
+      )
+    };
+  }
+  /** @internal */
+  async _internalGetLoaderState({
+    apiKey,
+    appUrl,
+    orgName,
+    fetch: fetch2,
+    forceLogin,
+    existingState
+  }) {
+    if (existingState) {
+      return existingState;
+    }
+    let cache = this.loaderLoginCache.get(fetch2);
+    if (!cache) {
+      cache = new LRUCache({ max: LOADER_LOGIN_CACHE_MAX });
+      this.loaderLoginCache.set(fetch2, cache);
+    }
+    const cacheKey = JSON.stringify([appUrl, orgName, apiKey]);
+    if (!forceLogin) {
+      const cachedState = cache.get(cacheKey);
+      if (cachedState) {
+        return cachedState;
+      }
+    }
+    const statePromise = loginToLoaderRequestState({
+      orgName,
+      apiKey,
+      appUrl,
+      fetch: fetch2
+    });
+    cache.set(cacheKey, statePromise);
+    try {
+      return await statePromise;
+    } catch (error) {
+      if (cache.get(cacheKey) === statePromise) {
+        cache.delete(cacheKey);
+      }
+      throw error;
+    }
   }
   resetIdGenState() {
     this._idGenerator = null;
@@ -6220,6 +6580,8 @@ var BraintrustState = class _BraintrustState {
     this.debugLogLevel = other.debugLogLevel;
     this.debugLogLevelConfigured = other.debugLogLevelConfigured;
     this.traceContextSigningSecret = other.traceContextSigningSecret;
+    this.fetch = other.fetch;
+    this.activeLoginOrgNameSelector = other.activeLoginOrgNameSelector;
     setGlobalDebugLogLevel(
       this.debugLogLevelConfigured ? this.debugLogLevel ?? false : void 0
     );
@@ -6427,36 +6789,76 @@ var FailedHTTPResponse = class extends Error {
   status;
   text;
   data;
-  constructor(status, text, data) {
+  cause;
+  constructor(status, text, data, cause) {
     super(`${status}: ${text} (${data})`);
     this.status = status;
     this.text = text;
     this.data = data;
+    this.cause = cause;
   }
 };
+var HTTPTransportError = class extends Error {
+  cause;
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : String(cause));
+    this.name = "HTTPTransportError";
+    this.cause = cause;
+  }
+};
+var httpTransportErrorCauses = /* @__PURE__ */ new WeakSet();
+function recordHTTPTransportError(error) {
+  if (typeof error === "object" && error !== null || typeof error === "function") {
+    httpTransportErrorCauses.add(error);
+  }
+}
+function rethrowHTTPTransportError(error, classifyTransportErrors) {
+  if (classifyTransportErrors) {
+    throw new HTTPTransportError(error);
+  }
+  recordHTTPTransportError(error);
+  throw error;
+}
+async function readJSONResponse(response, classifyTransportErrors = false) {
+  let data;
+  try {
+    data = await response.text();
+  } catch (error) {
+    rethrowHTTPTransportError(error, classifyTransportErrors);
+  }
+  return JSON.parse(data);
+}
 async function checkResponse(resp) {
   if (resp.ok) {
     return resp;
-  } else {
+  }
+  let data;
+  try {
+    data = await resp.text();
+  } catch (error) {
     throw new FailedHTTPResponse(
       resp.status,
       resp.statusText,
-      await resp.text()
+      "Unable to read response body",
+      error
     );
   }
+  throw new FailedHTTPResponse(resp.status, resp.statusText, data);
 }
 var HTTPConnection = class _HTTPConnection {
-  base_url;
-  token;
-  headers;
-  fetch;
-  constructor(base_url, fetch2) {
+  constructor(base_url, fetch2, classifyTransportErrors = false) {
+    this.classifyTransportErrors = classifyTransportErrors;
     this.base_url = base_url;
     this.token = null;
     this.headers = {};
     this._reset();
     this.fetch = fetch2;
   }
+  classifyTransportErrors;
+  base_url;
+  token;
+  headers;
+  fetch;
   setFetch(fetch2) {
     this.fetch = fetch2;
   }
@@ -6486,9 +6888,9 @@ var HTTPConnection = class _HTTPConnection {
       this.headers["Authorization"] = `Bearer ${this.token}`;
     }
   }
-  async get(path2, params = void 0, config) {
+  async get(path3, params = void 0, config) {
     const { headers, ...rest } = config || {};
-    const url = new URL(_urljoin(this.base_url, path2));
+    const url = new URL(_urljoin(this.base_url, path3));
     url.search = new URLSearchParams(
       params ? Object.entries(params).filter(([_, v]) => v !== void 0).flatMap(
         ([k, v]) => v !== void 0 ? typeof v === "string" ? [[k, v]] : v.map((x) => [k, x]) : []
@@ -6496,9 +6898,9 @@ var HTTPConnection = class _HTTPConnection {
     ).toString();
     const this_fetch = this.fetch;
     const this_headers = this.headers;
-    return await checkResponse(
-      // Using toString() here makes it work with isomorphic fetch
-      await this_fetch(url.toString(), {
+    let response;
+    try {
+      response = await this_fetch(url.toString(), {
         headers: {
           Accept: "application/json",
           ...this_headers,
@@ -6506,10 +6908,16 @@ var HTTPConnection = class _HTTPConnection {
         },
         keepalive: true,
         ...rest
-      })
-    );
+      });
+    } catch (error) {
+      if (config?.signal?.aborted) {
+        throw getAbortReason(config.signal);
+      }
+      rethrowHTTPTransportError(error, this.classifyTransportErrors);
+    }
+    return await checkResponse(response);
   }
-  async post(path2, params, config, retries = 0) {
+  async post(path3, params, config, retries = 0) {
     const { headers, ...rest } = config || {};
     const this_fetch = this.fetch;
     const this_base_url = this.base_url;
@@ -6517,8 +6925,9 @@ var HTTPConnection = class _HTTPConnection {
     const tries = retries + 1;
     for (let i = 0; i < tries; i++) {
       try {
-        return await checkResponse(
-          await this_fetch(_urljoin(this_base_url, path2), {
+        let response;
+        try {
+          response = await this_fetch(_urljoin(this_base_url, path3), {
             method: "POST",
             headers: {
               Accept: "application/json",
@@ -6529,8 +6938,14 @@ var HTTPConnection = class _HTTPConnection {
             body: typeof params === "string" ? params : params ? JSON.stringify(params) : void 0,
             keepalive: true,
             ...rest
-          })
-        );
+          });
+        } catch (error) {
+          if (config?.signal?.aborted) {
+            throw getAbortReason(config.signal);
+          }
+          rethrowHTTPTransportError(error, this.classifyTransportErrors);
+        }
+        return await checkResponse(response);
       } catch (error) {
         if (config?.signal?.aborted) {
           throw getAbortReason(config.signal);
@@ -6539,7 +6954,7 @@ var HTTPConnection = class _HTTPConnection {
           throw error;
         }
         debugLogger.debug(
-          `Retrying API request ${path2} after ${formatHTTPError(error)}`
+          `Retrying API request ${path3} after ${formatHTTPError(error)}`
         );
         const sleepTimeMs = HTTP_RETRY_BASE_SLEEP_TIME_S * 1e3 * 2 ** i + Math.random() * HTTP_RETRY_JITTER_MS;
         debugLogger.info(
@@ -6555,7 +6970,7 @@ var HTTPConnection = class _HTTPConnection {
     for (let i = 0; i < tries; i++) {
       try {
         const resp = await this.get(`${object_type}`, args);
-        return await resp.json();
+        return await readJSONResponse(resp, this.classifyTransportErrors);
       } catch (e) {
         if (i < tries - 1) {
           debugLogger.debug(
@@ -6578,7 +6993,7 @@ var HTTPConnection = class _HTTPConnection {
     const resp = await this.post(`${object_type}`, args, {
       headers: { "Content-Type": "application/json" }
     });
-    return await resp.json();
+    return await readJSONResponse(resp, this.classifyTransportErrors);
   }
   // Custom inspect for Node.js console.log
   [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
@@ -8398,6 +8813,7 @@ function initDataset(projectOrOptions, optionalOptions) {
   const {
     project,
     dataset,
+    datasetId,
     description,
     version,
     snapshotName,
@@ -8413,6 +8829,11 @@ function initDataset(projectOrOptions, optionalOptions) {
     state: stateArg,
     _internal_btql
   } = options;
+  if (datasetId !== void 0 && (description !== void 0 || metadata !== void 0)) {
+    throw new Error(
+      "Cannot specify description or metadata when datasetId is provided"
+    );
+  }
   const selection = normalizeDatasetSelection({
     version,
     environment,
@@ -8433,6 +8854,35 @@ function initDataset(projectOrOptions, optionalOptions) {
         fetch: fetch2,
         forceLogin
       });
+      if (datasetId !== void 0) {
+        const objectInfo = datasetObjectInfoSchema.array().parse(
+          await state.appConn().post_json("api/self/get_object_info", {
+            object_type: "dataset",
+            object_ids: [datasetId]
+          })
+        );
+        if (objectInfo.length === 0) {
+          throw new Error(`Dataset with ID ${datasetId} not found`);
+        }
+        if (objectInfo.length !== 1) {
+          throw new Error(
+            `Expected exactly one dataset with ID ${datasetId}, but found ${objectInfo.length}`
+          );
+        }
+        const datasetInfo = objectInfo[0];
+        return {
+          project: {
+            id: datasetInfo.parent_cols.project.id,
+            name: datasetInfo.parent_cols.project.name,
+            fullInfo: datasetInfo.parent_cols.project
+          },
+          dataset: {
+            id: datasetInfo.object_id,
+            name: datasetInfo.object_name,
+            fullInfo: datasetInfo
+          }
+        };
+      }
       const args = {
         org_id: state.orgId,
         project_name: project,
@@ -8607,6 +9057,52 @@ async function login(options = {}) {
   await state.login(options);
   return state;
 }
+async function loginToLoaderRequestState({
+  appUrl,
+  apiKey,
+  orgName,
+  fetch: fetch2
+}) {
+  let orgId;
+  let apiUrl;
+  if (apiKey === TEST_API_KEY) {
+    orgId = "test-org-id";
+    apiUrl = "https://braintrust.dev/fake-api-url";
+  } else {
+    let loginResponse;
+    try {
+      loginResponse = await fetch2(_urljoin(appUrl, `/api/apikey/login`), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+    } catch (error) {
+      throw new HTTPTransportError(error);
+    }
+    const info = await readJSONResponse(
+      await checkResponse(loginResponse),
+      true
+    );
+    const org = selectLoginOrg(info.org_info, orgName);
+    orgId = org.id;
+    apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
+    if (!apiUrl) {
+      throw new Error(
+        orgName ? `Unable to log into organization '${orgName}'. Are you sure this credential is scoped to the organization?` : "Unable to log into any organization with the provided credential."
+      );
+    }
+  }
+  const apiConnection = new HTTPConnection(apiUrl, fetch2, true);
+  apiConnection.set_token(apiKey);
+  apiConnection.make_long_lived();
+  return {
+    appUrl,
+    orgId,
+    apiConn: () => apiConnection
+  };
+}
 async function loginToState(options = {}) {
   const {
     appUrl = isomorph_default.getEnv("BRAINTRUST_APP_URL") || "https://www.braintrust.dev",
@@ -8638,16 +9134,18 @@ async function loginToState(options = {}) {
     _saveOrgInfo(state, testOrgInfo, testOrgInfo[0].name);
     return state;
   } else {
-    const resp = await checkResponse(
-      await fetch2(_urljoin(state.appUrl, `/api/apikey/login`), {
+    const loginResponse = await fetch2(
+      _urljoin(state.appUrl, `/api/apikey/login`),
+      {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${apiKey}`
         }
-      })
+      }
     );
-    const info = await resp.json();
+    const resp = await checkResponse(loginResponse);
+    const info = await readJSONResponse(resp);
     _saveOrgInfo(state, info.org_info, orgName);
     if (!state.apiUrl) {
       if (orgName) {
@@ -9049,27 +9547,28 @@ function withCurrent(span, callback, state = void 0) {
 function withParent(parent, callback, state = void 0) {
   return (state ?? _globalState).currentParent.run(parent, () => callback());
 }
-function _saveOrgInfo(state, org_info, org_name) {
-  if (org_info.length === 0) {
+function _saveOrgInfo(state, orgInfo, orgName) {
+  const org = selectLoginOrg(orgInfo, orgName);
+  state.orgId = org.id;
+  state.orgName = org.name;
+  state.apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
+  state.proxyUrl = isomorph_default.getEnv("BRAINTRUST_PROXY_URL") ?? org.proxy_url;
+  state.gitMetadataSettings = org.git_metadata || void 0;
+}
+function selectLoginOrg(orgInfo, orgName) {
+  if (orgInfo.length === 0) {
     throw new LoginInvalidOrgError(
       "This user is not part of any organizations."
     );
   }
-  for (const org of org_info) {
-    if (org_name === void 0 || org.name === org_name) {
-      state.orgId = org.id;
-      state.orgName = org.name;
-      state.apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
-      state.proxyUrl = isomorph_default.getEnv("BRAINTRUST_PROXY_URL") ?? org.proxy_url;
-      state.gitMetadataSettings = org.git_metadata || void 0;
-      break;
+  for (const org of orgInfo) {
+    if (orgName === void 0 || org.name === orgName) {
+      return org;
     }
   }
-  if (state.orgId === void 0) {
-    throw new LoginInvalidOrgError(
-      `Organization ${org_name} not found. Must be one of ${org_info.map((x) => x.name).join(", ")}`
-    );
-  }
+  throw new LoginInvalidOrgError(
+    `Organization ${orgName} not found. Must be one of ${orgInfo.map((org) => org.name).join(", ")}`
+  );
 }
 function validateTags(tags) {
   const seen = /* @__PURE__ */ new Set();
@@ -9304,7 +9803,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"
@@ -9313,6 +9812,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`,
         {
@@ -9352,7 +9855,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;
@@ -9872,7 +10382,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() {
@@ -10959,6 +11471,14 @@ var Prompt2 = class _Prompt {
   static isPrompt(data) {
     return typeof data === "object" && data !== null && "__braintrust_prompt_marker" in data;
   }
+  /** @internal */
+  _internalSerializeForCache() {
+    return {
+      metadata: this.metadata,
+      defaults: this.defaults,
+      noTrace: this.noTrace
+    };
+  }
   static fromPromptData(name, promptData) {
     return new _Prompt(
       {
@@ -10999,6 +11519,10 @@ var RemoteEvalParameters = class {
   get data() {
     return this.metadata.function_data.data ?? {};
   }
+  /** @internal */
+  _internalSerializeForCache() {
+    return { metadata: this.metadata };
+  }
   validate(data) {
     if (typeof data !== "object" || data === null) {
       return false;
@@ -11690,56 +12214,14 @@ function suppressionStore() {
   autoInstrumentationSuppressionStore ??= isomorph_default.newAsyncLocalStorage();
   return autoInstrumentationSuppressionStore;
 }
-function currentFrames() {
-  return suppressionStore().getStore()?.frames ?? [];
-}
 function isAutoInstrumentationSuppressed() {
-  const frames = currentFrames();
-  return frames[frames.length - 1]?.mode === "suppress";
+  return suppressionStore().getStore() === true;
 }
 function runWithAutoInstrumentationSuppressed(callback) {
-  const frame = {
-    id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-suppress"),
-    mode: "suppress"
-  };
-  return suppressionStore().run(
-    { frames: [...currentFrames(), frame] },
-    callback
-  );
-}
-function bindAutoInstrumentationSuppressionToStart(tracingChannel) {
-  const startChannel = tracingChannel.start;
-  if (!startChannel) {
-    return void 0;
-  }
-  const store = suppressionStore();
-  startChannel.bindStore(store, () => ({
-    frames: [
-      ...currentFrames(),
-      {
-        id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-suppress"),
-        mode: "suppress"
-      }
-    ]
-  }));
-  return () => {
-    startChannel.unbindStore(store);
-  };
+  return suppressionStore().run(true, callback);
 }
-function enterAutoInstrumentationAllowed() {
-  const frame = {
-    id: /* @__PURE__ */ Symbol("braintrust.auto-instrumentation-allow"),
-    mode: "allow"
-  };
-  suppressionStore().enterWith({
-    frames: [...currentFrames(), frame]
-  });
-  return () => {
-    const frames = currentFrames().filter(
-      (candidate) => candidate.id !== frame.id
-    );
-    suppressionStore().enterWith(frames.length > 0 ? { frames } : void 0);
-  };
+function runWithAutoInstrumentationAllowed(callback) {
+  return suppressionStore().run(void 0, callback);
 }
 
 // src/instrumentation/core/channel-tracing.ts
@@ -12430,6 +12912,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,
@@ -13012,13 +13510,33 @@ function aggregateChatLogprobs(existing, incoming) {
   }
   return aggregated;
 }
+function createAggregatedChatChoice(index) {
+  return {
+    index,
+    role: void 0,
+    content: void 0,
+    refusal: void 0,
+    toolCallsByIndex: /* @__PURE__ */ new Map(),
+    logprobs: void 0,
+    finish_reason: void 0
+  };
+}
+function toChatChoice(choice) {
+  const toolCalls = Array.from(choice.toolCallsByIndex.entries()).sort(([left], [right]) => left - right).map(([, toolCall]) => toolCall);
+  return {
+    index: choice.index,
+    message: {
+      role: choice.role,
+      content: choice.content,
+      ...choice.refusal !== void 0 ? { refusal: choice.refusal } : {},
+      tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+    },
+    logprobs: choice.logprobs ?? null,
+    finish_reason: choice.finish_reason
+  };
+}
 function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
-  let role = void 0;
-  let content = void 0;
-  let refusal = void 0;
-  let tool_calls = void 0;
-  let logprobs = void 0;
-  let finish_reason = void 0;
+  const choicesByIndex = /* @__PURE__ */ new Map();
   let metrics = {};
   for (const chunk of chunks) {
     if (chunk.usage) {
@@ -13027,62 +13545,75 @@ function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
         ...parseMetricsFromUsage(chunk.usage)
       };
     }
-    const choice = chunk.choices?.[0];
-    if (!choice) {
-      continue;
-    }
-    if (choice.finish_reason) {
-      finish_reason = choice.finish_reason;
-    }
-    logprobs = aggregateChatLogprobs(logprobs, choice.logprobs);
-    const delta = choice.delta;
-    if (!delta) {
+    const choices = chunk.choices;
+    if (!choices?.length) {
       continue;
     }
-    if (delta.finish_reason) {
-      finish_reason = delta.finish_reason;
-    }
-    if (!role && delta.role) {
-      role = delta.role;
-    }
-    if (delta.content) {
-      content = (content || "") + delta.content;
-    }
-    if (delta.refusal) {
-      refusal = (refusal || "") + delta.refusal;
-    }
-    if (delta.tool_calls) {
-      const toolDelta = delta.tool_calls[0];
-      if (!tool_calls || toolDelta.id && tool_calls[tool_calls.length - 1].id !== toolDelta.id) {
-        tool_calls = [
-          ...tool_calls || [],
-          {
-            id: toolDelta.id,
-            type: toolDelta.type,
-            function: toolDelta.function
+    for (const choice of choices) {
+      const choiceIndex = choice.index;
+      let aggregatedChoice = choicesByIndex.get(choiceIndex);
+      if (!aggregatedChoice) {
+        aggregatedChoice = createAggregatedChatChoice(choiceIndex);
+        choicesByIndex.set(choiceIndex, aggregatedChoice);
+      }
+      if (choice.finish_reason) {
+        aggregatedChoice.finish_reason = choice.finish_reason;
+      }
+      aggregatedChoice.logprobs = aggregateChatLogprobs(
+        aggregatedChoice.logprobs,
+        choice.logprobs
+      );
+      const delta = choice.delta;
+      if (!delta) {
+        continue;
+      }
+      if (delta.finish_reason) {
+        aggregatedChoice.finish_reason = delta.finish_reason;
+      }
+      if (!aggregatedChoice.role && delta.role) {
+        aggregatedChoice.role = delta.role;
+      }
+      if (delta.content) {
+        aggregatedChoice.content = (aggregatedChoice.content || "") + delta.content;
+      }
+      if (delta.refusal) {
+        aggregatedChoice.refusal = (aggregatedChoice.refusal || "") + delta.refusal;
+      }
+      if (delta.tool_calls) {
+        for (const toolDelta of delta.tool_calls) {
+          let aggregatedToolCall = aggregatedChoice.toolCallsByIndex.get(
+            toolDelta.index
+          );
+          if (!aggregatedToolCall) {
+            aggregatedToolCall = {
+              function: { arguments: "" }
+            };
+            aggregatedChoice.toolCallsByIndex.set(
+              toolDelta.index,
+              aggregatedToolCall
+            );
           }
-        ];
-      } else {
-        tool_calls[tool_calls.length - 1].function.arguments += toolDelta.function.arguments;
+          if (toolDelta.id !== void 0) {
+            aggregatedToolCall.id = toolDelta.id;
+          }
+          if (toolDelta.type !== void 0) {
+            aggregatedToolCall.type = toolDelta.type;
+          }
+          if (toolDelta.function?.name !== void 0) {
+            aggregatedToolCall.function.name = toolDelta.function.name;
+          }
+          if (toolDelta.function?.arguments !== void 0) {
+            aggregatedToolCall.function.arguments += toolDelta.function.arguments;
+          }
+        }
       }
     }
   }
   metrics = withCachedMetric(metrics, streamResult, endEvent);
+  const output = Array.from(choicesByIndex.values()).sort((left, right) => left.index - right.index).map(toChatChoice);
   return {
     metrics,
-    output: [
-      {
-        index: 0,
-        message: {
-          role,
-          content,
-          ...refusal !== void 0 ? { refusal } : {},
-          tool_calls
-        },
-        logprobs: logprobs ?? null,
-        finish_reason
-      }
-    ]
+    output: output.length > 0 ? output : [toChatChoice(createAggregatedChatChoice(0))]
   };
 }
 function aggregateResponseStreamEvents(chunks, _streamResult, endEvent) {
@@ -13777,12 +14308,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 = {};
@@ -14375,6 +14924,24 @@ 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.output_tokens_details)) {
+    const thinkingTokens = usage.output_tokens_details.thinking_tokens;
+    if (typeof thinkingTokens === "number") {
+      metrics.completion_reasoning_tokens = thinkingTokens;
+    }
+  }
   if (isObject(usage.server_tool_use)) {
     for (const [name, value] of Object.entries(usage.server_tool_use)) {
       if (typeof value === "number") {
@@ -15331,7 +15898,6 @@ function endHarnessTurn(parent) {
 function braintrustAISDKTelemetry() {
   const operations = /* @__PURE__ */ new Map();
   const operationKeysByCallId = /* @__PURE__ */ new Map();
-  const workflowOperationKeyStore = isomorph_default.newAsyncLocalStorage();
   const modelSpans = /* @__PURE__ */ new Map();
   const objectSpans = /* @__PURE__ */ new Map();
   const embedSpans = /* @__PURE__ */ new Map();
@@ -15374,9 +15940,6 @@ function braintrustAISDKTelemetry() {
       return;
     }
     operations.delete(operationKey);
-    if (workflowOperationKeyStore.getStore() === operationKey) {
-      workflowOperationKeyStore.enterWith(void 0);
-    }
     const keys = operationKeysByCallId.get(state.callId);
     if (!keys) {
       return;
@@ -15424,14 +15987,7 @@ function braintrustAISDKTelemetry() {
         return key;
       }
     }
-    const workflowOperationKey = workflowOperationKeyStore.getStore();
-    if (workflowOperationKey && keys.includes(workflowOperationKey)) {
-      return workflowOperationKey;
-    }
-    if (callId === "workflow-agent") {
-      return void 0;
-    }
-    return mode === "finish" ? keys[0] : keys[keys.length - 1];
+    return callId === "workflow-agent" || mode === "active" ? keys[keys.length - 1] : keys[0];
   };
   const operationKeyFromEvent = (event, mode = "active") => {
     const explicit = explicitOperationKey(event);
@@ -15445,17 +16001,13 @@ function braintrustAISDKTelemetry() {
         if (operationKey) {
           return operationKey;
         }
-        const workflowOperationKey2 = workflowOperationKeyStore.getStore();
-        if (workflowOperationKey2 && operations.has(workflowOperationKey2)) {
-          return workflowOperationKey2;
+        const workflowAgentKeys2 = operationKeysByCallId.get("workflow-agent");
+        if (workflowAgentKeys2?.length) {
+          return workflowAgentKeys2[workflowAgentKeys2.length - 1];
         }
         return callId === "workflow-agent" ? void 0 : callId;
       }
     }
-    const workflowOperationKey = workflowOperationKeyStore.getStore();
-    if (workflowOperationKey && operations.has(workflowOperationKey)) {
-      return workflowOperationKey;
-    }
     const wrapperSpan = currentWorkflowAgentWrapperSpan();
     if (wrapperSpan?.spanId) {
       for (const [operationKey, state] of operations) {
@@ -15465,8 +16017,8 @@ function braintrustAISDKTelemetry() {
       }
     }
     const workflowAgentKeys = operationKeysByCallId.get("workflow-agent");
-    if (workflowAgentKeys?.length === 1) {
-      return workflowAgentKeys[0];
+    if (workflowAgentKeys?.length) {
+      return workflowAgentKeys[workflowAgentKeys.length - 1];
     }
     if (operations.size === 1) {
       return operations.keys().next().value;
@@ -15669,9 +16221,6 @@ function braintrustAISDKTelemetry() {
         if (!ownsSpan) {
           return;
         }
-        if (workflowAgent) {
-          workflowOperationKeyStore.enterWith(operationKey);
-        }
         let metadata = metadataFromEvent(event);
         const logPayload = { metadata };
         const workflowAgentCallInput = workflowAgent ? operationInput(event, operationName) : void 0;
@@ -16143,6 +16692,10 @@ var aiSDKChannels = defineChannels(
       channelName: "generateText",
       kind: "async"
     }),
+    generateImage: channel({
+      channelName: "generateImage",
+      kind: "async"
+    }),
     streamText: channel({
       channelName: "streamText",
       kind: "async"
@@ -16330,7 +16883,7 @@ var AISDKPlugin = class extends BasePlugin {
   }
   subscribeToAISDK() {
     const denyOutputPaths = this.config.denyOutputPaths || DEFAULT_DENY_OUTPUT_PATHS;
-    this.unsubscribers.push(subscribeToAISDKV7TelemetryDispatcher());
+    this.unsubscribers.push(interceptAISDKV7TelemetryDispatcher());
     this.unsubscribers.push(subscribeToHarnessAgentCreateSession());
     this.unsubscribers.push(
       subscribeToHarnessContinuation(
@@ -16358,6 +16911,18 @@ var AISDKPlugin = class extends BasePlugin {
         aggregateChunks: aggregateAISDKChunks
       })
     );
+    this.unsubscribers.push(
+      traceAsyncChannel(aiSDKChannels.generateImage, {
+        name: "generateImage",
+        type: "llm" /* LLM */,
+        extractInput: ([params], event) => prepareAISDKGenerateImageInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKGenerateImageOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result) => extractTokenMetrics(result)
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.streamText, {
         name: "streamText",
@@ -16847,26 +17412,29 @@ function subscribeToHarnessContinuation(continuationChannel, defaultDenyOutputPa
     channel2.unsubscribe(handlers);
   };
 }
-function subscribeToAISDKV7TelemetryDispatcher() {
-  const channel2 = aiSDKChannels.v7CreateTelemetryDispatcher.tracingChannel();
+function interceptAISDKV7TelemetryDispatcher() {
   const telemetry = braintrustAISDKTelemetry();
-  const handlers = {
-    end: (event) => {
-      const telemetryOptions = event.arguments?.[0]?.telemetry;
-      if (telemetryOptions?.isEnabled === false) {
-        return;
+  return aiSDKChannels.v7CreateTelemetryDispatcher.intercept(
+    (target, thisArg, args) => {
+      const dispatcher = Reflect.apply(target, thisArg, args);
+      const telemetryOptions = args[0]?.telemetry;
+      if (telemetryOptions?.isEnabled !== false) {
+        try {
+          patchAISDKV7TelemetryDispatcher(
+            dispatcher,
+            telemetry,
+            telemetryOptions
+          );
+        } catch (error) {
+          debugLogger.error(
+            "Error instrumenting AI SDK v7 telemetry dispatcher:",
+            error
+          );
+        }
       }
-      patchAISDKV7TelemetryDispatcher(
-        event.result,
-        telemetry,
-        telemetryOptions
-      );
+      return dispatcher;
     }
-  };
-  channel2.subscribe(handlers);
-  return () => {
-    channel2.unsubscribe(handlers);
-  };
+  );
 }
 function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry, telemetryOptions) {
   if (!isObject(dispatcher)) {
@@ -16966,7 +17534,7 @@ function resolveDenyOutputPaths(event, defaultDenyOutputPaths) {
     return defaultDenyOutputPaths;
   }
   const runtimeDenyOutputPaths = firstArgument2[RUNTIME_DENY_OUTPUT_PATHS];
-  if (Array.isArray(runtimeDenyOutputPaths) && runtimeDenyOutputPaths.every((path2) => typeof path2 === "string")) {
+  if (Array.isArray(runtimeDenyOutputPaths) && runtimeDenyOutputPaths.every((path3) => typeof path3 === "string")) {
     return runtimeDenyOutputPaths;
   }
   return defaultDenyOutputPaths;
@@ -17191,16 +17759,10 @@ var convertImageToAttachment = (image, explicitMimeType) => {
       }
     }
     if (explicitMimeType) {
-      if (image instanceof Uint8Array) {
-        return new Attachment({
-          data: new Blob([image], { type: explicitMimeType }),
-          filename: `image.${getExtensionFromMediaType(explicitMimeType)}`,
-          contentType: explicitMimeType
-        });
-      }
-      if (typeof Buffer !== "undefined" && Buffer.isBuffer(image)) {
+      const blob = convertDataToBlob(image, explicitMimeType);
+      if (blob) {
         return new Attachment({
-          data: new Blob([image], { type: explicitMimeType }),
+          data: blob,
           filename: `image.${getExtensionFromMediaType(explicitMimeType)}`,
           contentType: explicitMimeType
         });
@@ -17254,6 +17816,25 @@ var convertDataToAttachment = (data, mimeType, filename) => {
 function processAISDKCallInput(params) {
   return processInputAttachmentsSync(params);
 }
+function processAISDKGenerateImageInput(params) {
+  const prompt = params.prompt;
+  if (!isObject(prompt) || Array.isArray(prompt)) {
+    return processAISDKCallInput(params);
+  }
+  const processedPrompt = { ...prompt };
+  if (Array.isArray(prompt.images)) {
+    processedPrompt.images = prompt.images.map(
+      (image) => convertImageToAttachment(image, "image/png") ?? image
+    );
+  }
+  if (prompt.mask !== void 0) {
+    processedPrompt.mask = convertImageToAttachment(prompt.mask, "image/png") ?? prompt.mask;
+  }
+  return processAISDKCallInput({
+    ...params,
+    prompt: processedPrompt
+  });
+}
 function processAISDKWorkflowAgentCallInput(params) {
   const processed = processAISDKCallInput(params);
   return {
@@ -17392,6 +17973,12 @@ function prepareAISDKEmbedInput(params, self) {
     metadata: extractMetadataFromEmbedParams(params, self)
   };
 }
+function prepareAISDKGenerateImageInput(params, self) {
+  return {
+    input: processAISDKGenerateImageInput(params).input,
+    metadata: extractMetadataFromCallParams(params, self)
+  };
+}
 function prepareAISDKRerankInput(params, self) {
   const { documents, query } = params;
   return {
@@ -18728,11 +19315,11 @@ function processAISDKOutput(output, denyOutputPaths) {
   if (!output) return output;
   const merged = extractSerializableOutputFields(output);
   const deleteOutputPaths = denyOutputPaths.filter(
-    (path2) => path2.toLowerCase().endsWith("headers")
+    (path3) => path3.toLowerCase().endsWith("headers")
   );
   const sanitized = omit(merged, denyOutputPaths, deleteOutputPaths);
-  for (const path2 of TRANSPORT_PAYLOAD_ROOT_PATHS) {
-    const stack = [{ obj: sanitized, keys: parsePath(path2) }];
+  for (const path3 of TRANSPORT_PAYLOAD_ROOT_PATHS) {
+    const stack = [{ obj: sanitized, keys: parsePath(path3) }];
     while (stack.length > 0) {
       const entry = stack.pop();
       if (!entry || entry.keys.length === 0) {
@@ -18767,6 +19354,57 @@ function processAISDKOutput(output, denyOutputPaths) {
   }
   return normalizeAISDKLoggedOutput(sanitized);
 }
+function processAISDKGenerateImageOutput(output, denyOutputPaths) {
+  if (!output || typeof output !== "object") {
+    return output;
+  }
+  const summarized = {};
+  for (const field of [
+    "usage",
+    "warnings",
+    "providerMetadata",
+    "experimental_providerMetadata",
+    "responses"
+  ]) {
+    const value = safeSerializableFieldRead(output, field);
+    if (value !== void 0 && isSerializableOutputValue(value)) {
+      summarized[field] = value;
+    }
+  }
+  const images = safeSerializableFieldRead(output, "images");
+  const image = safeSerializableFieldRead(output, "image");
+  const generatedFiles = Array.isArray(images) && images.length > 0 ? images : image !== void 0 ? [image] : [];
+  const loggedOutput = normalizeAISDKLoggedOutput(
+    omit(summarized, denyOutputPaths)
+  );
+  if (generatedFiles.length > 0) {
+    loggedOutput.images = generatedFiles.map(
+      (file, index) => convertAISDKGeneratedFileToAttachment(file, index)
+    );
+  }
+  return loggedOutput;
+}
+function convertAISDKGeneratedFileToAttachment(file, index) {
+  if (!file || typeof file !== "object") {
+    return file;
+  }
+  const generatedFile = file;
+  const generatedMediaType = safeSerializableFieldRead(
+    generatedFile,
+    "mediaType"
+  );
+  const mediaType = typeof generatedMediaType === "string" ? generatedMediaType : "application/octet-stream";
+  const data = safeSerializableFieldRead(generatedFile, "base64") ?? safeSerializableFieldRead(generatedFile, "uint8Array");
+  const blob = convertDataToBlob(data, mediaType);
+  if (blob) {
+    return new Attachment({
+      data: blob,
+      filename: `generated_image_${index}.${getExtensionFromMediaType(mediaType)}`,
+      contentType: mediaType
+    });
+  }
+  return file;
+}
 function processAISDKEmbeddingOutput(output, denyOutputPaths) {
   if (!output || typeof output !== "object") {
     return output;
@@ -19171,11 +19809,11 @@ function firstNumber2(...values) {
 function deepCopy(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
-function parsePath(path2) {
+function parsePath(path3) {
   const keys = [];
   let current = "";
-  for (let i = 0; i < path2.length; i++) {
-    const char = path2[i];
+  for (let i = 0; i < path3.length; i++) {
+    const char = path3[i];
     if (char === ".") {
       if (current) {
         keys.push(current);
@@ -19188,8 +19826,8 @@ function parsePath(path2) {
       }
       let bracketContent = "";
       i++;
-      while (i < path2.length && path2[i] !== "]") {
-        bracketContent += path2[i];
+      while (i < path3.length && path3[i] !== "]") {
+        bracketContent += path3[i];
         i++;
       }
       if (bracketContent === "") {
@@ -19244,9 +19882,9 @@ function omitAtPath(obj, keys, deleteLeaf = false) {
 function omit(obj, paths, deletePaths = []) {
   const result = deepCopy(obj);
   const deletePathSet = new Set(deletePaths);
-  for (const path2 of paths) {
-    const keys = parsePath(path2);
-    omitAtPath(result, keys, deletePathSet.has(path2));
+  for (const path3 of paths) {
+    const keys = parsePath(path3);
+    omitAtPath(result, keys, deletePathSet.has(path3));
   }
   return result;
 }
@@ -19267,118 +19905,22 @@ var claudeAgentSDKChannels = defineChannels(
 var CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION = "__braintrust_skip_local_tool_hooks";
 
 // src/instrumentation/plugins/claude-agent-sdk-local-tool-context.ts
-var LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED = /* @__PURE__ */ Symbol.for(
-  "braintrust.claude_agent_sdk.local_tool_context_async_iterator_patched"
-);
-function createLocalToolContextStore() {
-  const maybeIsoWithAsyncLocalStorage = isomorph_default;
-  if (typeof maybeIsoWithAsyncLocalStorage.newAsyncLocalStorage === "function") {
-    return maybeIsoWithAsyncLocalStorage.newAsyncLocalStorage();
-  }
-  let currentStore;
-  return {
-    enterWith(store) {
-      currentStore = store;
-    },
-    getStore() {
-      return currentStore;
-    },
-    run(store, callback) {
-      const previousStore = currentStore;
-      currentStore = store;
-      try {
-        return callback();
-      } finally {
-        currentStore = previousStore;
-      }
-    }
-  };
-}
-var localToolContextStore = createLocalToolContextStore();
-var fallbackLocalToolParentResolver;
-function createClaudeLocalToolContext() {
-  return {};
-}
-function runWithClaudeLocalToolContext(callback, context) {
-  return localToolContextStore.run(
-    context ?? createClaudeLocalToolContext(),
-    callback
-  );
+var localToolContextStore = isomorph_default.newAsyncLocalStorage();
+var localToolParentResolversByToolUseId = /* @__PURE__ */ new Map();
+function runWithClaudeLocalToolContext(callback, resolver) {
+  return localToolContextStore.run(resolver, callback);
 }
-function ensureClaudeLocalToolContext() {
-  const existing = localToolContextStore.getStore();
-  if (existing) {
-    return existing;
-  }
-  const created = {};
-  localToolContextStore.enterWith(created);
-  return created;
+function registerClaudeLocalToolParentResolver(toolUseId, resolver) {
+  localToolParentResolversByToolUseId.set(toolUseId, resolver);
 }
-function setClaudeLocalToolParentResolver(resolver) {
-  fallbackLocalToolParentResolver = resolver;
-  const context = ensureClaudeLocalToolContext();
-  if (!context) {
-    return;
+function getClaudeLocalToolParentResolver(toolUseId) {
+  const currentResolver = localToolContextStore.getStore();
+  if (!toolUseId) {
+    return currentResolver;
   }
-  context.resolveLocalToolParent = resolver;
-}
-function getClaudeLocalToolParentResolver() {
-  return localToolContextStore.getStore()?.resolveLocalToolParent ?? fallbackLocalToolParentResolver;
-}
-function isAsyncIterable3(value) {
-  return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
-}
-function bindClaudeLocalToolContextToAsyncIterable(result, localToolContext) {
-  if (!isAsyncIterable3(result) || Object.isFrozen(result) || Object.isSealed(result)) {
-    return result;
-  }
-  const stream = result;
-  const originalAsyncIterator = stream[Symbol.asyncIterator];
-  if (originalAsyncIterator[LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED]) {
-    return result;
-  }
-  const patchedAsyncIterator = function() {
-    return runWithClaudeLocalToolContext(() => {
-      const iterator = Reflect.apply(originalAsyncIterator, this, []);
-      if (!iterator || typeof iterator !== "object") {
-        return iterator;
-      }
-      const patchMethod = (methodName) => {
-        const originalMethod = Reflect.get(iterator, methodName);
-        if (typeof originalMethod !== "function") {
-          return;
-        }
-        Reflect.set(
-          iterator,
-          methodName,
-          (...args) => runWithClaudeLocalToolContext(
-            () => Reflect.apply(
-              originalMethod,
-              iterator,
-              args
-            ),
-            localToolContext
-          )
-        );
-      };
-      patchMethod("next");
-      patchMethod("return");
-      patchMethod("throw");
-      return iterator;
-    }, localToolContext);
-  };
-  Object.defineProperty(
-    patchedAsyncIterator,
-    LOCAL_TOOL_CONTEXT_ASYNC_ITERATOR_PATCHED,
-    {
-      configurable: false,
-      enumerable: false,
-      value: true,
-      writable: false
-    }
-  );
-  Reflect.set(stream, Symbol.asyncIterator, patchedAsyncIterator);
-  return result;
+  const registeredResolver = localToolParentResolversByToolUseId.get(toolUseId);
+  localToolParentResolversByToolUseId.delete(toolUseId);
+  return currentResolver ?? registeredResolver;
 }
 
 // src/instrumentation/plugins/claude-agent-sdk-local-tool-spans.ts
@@ -19404,7 +19946,7 @@ function wrapLocalClaudeToolHandler(handler, getMetadata) {
     const metadata = getMetadata();
     const rawToolName = metadata.serverName ? `mcp__${metadata.serverName}__${metadata.toolName}` : metadata.toolName;
     const toolUseId = getToolUseIdFromExtra(handlerArgs[1]);
-    const localToolParentResolver = getClaudeLocalToolParentResolver();
+    const localToolParentResolver = getClaudeLocalToolParentResolver(toolUseId);
     const spanName = metadata.serverName ? `tool: ${metadata.serverName}/${metadata.toolName}` : `tool: ${metadata.toolName}`;
     const runWithResolvedParent = async () => {
       const parent = toolUseId && localToolParentResolver ? await localToolParentResolver(toolUseId).catch(() => void 0) : void 0;
@@ -19673,37 +20215,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];
@@ -19737,16 +20339,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
@@ -19768,8 +20370,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();
@@ -19859,12 +20461,19 @@ 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))) {
+      registerClaudeLocalToolParentResolver(toolUseID, resolveParentSpan);
       return {};
     }
     const parsed = parseToolName(input.tool_name);
@@ -20059,9 +20668,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 {
@@ -20083,7 +20689,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,
@@ -20092,6 +20698,8 @@ function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localTo
     subagentStop
   } = createToolTracingHooks(
     resolveParentSpan,
+    taskIdToToolUseId,
+    toolUseToParent,
     activeToolSpans,
     options.mcpServers,
     localToolHookNames,
@@ -20173,6 +20781,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,
@@ -20180,6 +20795,8 @@ async function finalizeCurrentMessageGroup(state) {
     state.options,
     state.currentMessageStartTime,
     parentSpan,
+    usage,
+    hasFinalOutputUsage,
     existingLlmSpan
   );
   if (llmSpanResult) {
@@ -20197,9 +20814,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;
 }
@@ -20290,6 +20915,10 @@ async function ensureActiveLlmSpanForParentToolUse(rootSpan, activeLlmSpansByPar
     );
     llmParentSpan = await subAgentSpan.export();
   }
+  const racedLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
+  if (racedLlmSpan) {
+    return racedLlmSpan;
+  }
   const llmSpan = startSpan(
     withSpanInstrumentationName(
       {
@@ -20409,7 +21038,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;
@@ -20456,36 +21127,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;
@@ -20493,8 +21137,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) {
@@ -20518,6 +21166,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();
     }
@@ -20533,7 +21184,7 @@ async function finalizeQuerySpan(state) {
 }
 var ClaudeAgentSDKPlugin = class extends BasePlugin {
   onEnable() {
-    this.subscribeToQuery();
+    this.interceptQuery();
   }
   onDisable() {
     for (const unsubscribe of this.unsubscribers) {
@@ -20541,207 +21192,218 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
     }
     this.unsubscribers = [];
   }
-  subscribeToQuery() {
-    const channel2 = claudeAgentSDKChannels.query.tracingChannel();
-    const spans = /* @__PURE__ */ new WeakMap();
-    const handlers = {
-      start: (event) => {
-        const params = event.arguments[0] ?? {};
-        const originalPrompt = params.prompt;
-        const options = params.options ?? {};
-        const promptIsAsyncIterable = isAsyncIterable(originalPrompt);
-        let promptStarted = false;
-        let capturedPromptMessages;
-        let resolvePromptDone;
-        const promptDone = new Promise((resolve) => {
-          resolvePromptDone = resolve;
-        });
-        if (promptIsAsyncIterable) {
-          capturedPromptMessages = [];
-          const promptStream = originalPrompt;
-          params.prompt = (async function* () {
-            promptStarted = true;
-            try {
-              for await (const message of promptStream) {
-                capturedPromptMessages.push(message);
-                yield message;
-              }
-            } finally {
-              resolvePromptDone?.();
+  interceptQuery() {
+    const startQuery = (params) => {
+      const originalPrompt = params.prompt;
+      const options = params.options ?? {};
+      const promptIsAsyncIterable = isAsyncIterable(originalPrompt);
+      let promptStarted = false;
+      let capturedPromptMessages;
+      let resolvePromptDone;
+      const promptDone = new Promise((resolve) => {
+        resolvePromptDone = resolve;
+      });
+      if (promptIsAsyncIterable) {
+        capturedPromptMessages = [];
+        const promptStream = originalPrompt;
+        params.prompt = (async function* () {
+          promptStarted = true;
+          try {
+            for await (const message of promptStream) {
+              capturedPromptMessages.push(message);
+              yield message;
             }
-          })();
-        }
-        const span = startSpan(
-          withSpanInstrumentationName(
-            {
-              name: "Claude Agent",
-              spanAttributes: {
-                type: "task" /* TASK */
-              }
-            },
-            INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
-          )
-        );
-        const startTime = getCurrentUnixTimestamp();
-        try {
-          span.log({
-            input: typeof originalPrompt === "string" ? originalPrompt : promptIsAsyncIterable ? void 0 : originalPrompt !== void 0 ? String(originalPrompt) : void 0,
-            metadata: filterSerializableOptions(options)
-          });
-        } catch (error) {
-          console.error("Error extracting input for Claude Agent SDK:", error);
-        }
-        const activeToolSpans = /* @__PURE__ */ new Map();
-        const activeLlmSpansByParentToolUse = /* @__PURE__ */ new Map();
-        const conversationHistoryByParentKey = /* @__PURE__ */ new Map();
-        const subAgentSpans = /* @__PURE__ */ new Map();
-        const endedSubAgentSpans = /* @__PURE__ */ new Set();
-        const toolUseToParent = /* @__PURE__ */ new Map();
-        const latestLlmParentBySubAgentToolUse = /* @__PURE__ */ new Map();
-        const latestRootLlmParentRef = {
-          value: void 0
-        };
-        const subAgentDetailsByToolUseId = /* @__PURE__ */ new Map();
-        const taskIdToToolUseId = /* @__PURE__ */ new Map();
-        const promptMessagesByParentKey = /* @__PURE__ */ new Map();
-        const promptSourcePriorityByParentKey = /* @__PURE__ */ new Map();
-        const localToolContext = createClaudeLocalToolContext();
-        const { hasLocalToolHandlers, localToolHookNames } = prepareLocalToolHandlersInMcpServers(options.mcpServers);
-        const skipLocalToolHooks = options[CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION] === true || hasLocalToolHandlers;
-        const resolveToolUseParentSpan = async (toolUseID, context) => {
-          const trackedParentToolUseId = toolUseToParent.get(toolUseID);
-          const parentToolUseId = trackedParentToolUseId ?? (context?.agentId ? taskIdToToolUseId.get(context.agentId) ?? null : null);
-          const parentKey = llmParentKey(parentToolUseId);
-          const activeLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
-          const latestLlmParent = parentToolUseId ? latestLlmParentBySubAgentToolUse.get(parentToolUseId) : latestRootLlmParentRef.value;
-          if (!activeLlmSpan && !latestLlmParent) {
-            await ensureActiveLlmSpanForParentToolUse(
-              span,
-              activeLlmSpansByParentToolUse,
-              subAgentDetailsByToolUseId,
-              activeToolSpans,
-              subAgentSpans,
-              parentToolUseId,
-              getCurrentUnixTimestamp()
-            );
-          }
-          if (parentToolUseId) {
-            const subAgentSpan = await ensureSubAgentSpan(
-              subAgentDetailsByToolUseId,
-              span,
-              activeToolSpans,
-              subAgentSpans,
-              parentToolUseId
-            );
-            return subAgentSpan.export();
+          } finally {
+            resolvePromptDone?.();
           }
-          return span.export();
-        };
-        localToolContext.resolveLocalToolParent = resolveToolUseParentSpan;
-        setClaudeLocalToolParentResolver(resolveToolUseParentSpan);
-        const optionsWithHooks = injectTracingHooks(
-          options,
-          resolveToolUseParentSpan,
-          activeToolSpans,
-          localToolHookNames,
-          skipLocalToolHooks,
-          subAgentDetailsByToolUseId,
-          subAgentSpans,
-          endedSubAgentSpans
-        );
-        params.options = optionsWithHooks;
-        event.arguments[0] = params;
-        spans.set(event, {
-          accumulatedOutputTokens: 0,
-          activeLlmSpansByParentToolUse,
-          activeToolSpans,
-          conversationHistoryByParentKey,
-          capturedPromptMessages,
-          currentMessageId: void 0,
-          currentMessageStartTime: startTime,
-          currentMessages: [],
-          endedSubAgentSpans,
-          finalResults: [],
-          options: optionsWithHooks,
-          originalPrompt,
-          processing: Promise.resolve(),
-          promptDone,
-          promptMessagesByParentKey,
-          promptStarted: () => promptStarted,
-          promptSourcePriorityByParentKey,
-          span,
-          subAgentDetailsByToolUseId,
-          subAgentSpans,
-          taskIdToToolUseId,
-          latestLlmParentBySubAgentToolUse,
-          latestRootLlmParentRef,
-          toolUseToParent,
-          localToolContext
+        })();
+      }
+      const span = startSpan(
+        withSpanInstrumentationName(
+          {
+            name: "Claude Agent",
+            spanAttributes: {
+              type: "task" /* TASK */
+            }
+          },
+          INSTRUMENTATION_NAMES.CLAUDE_AGENT_SDK
+        )
+      );
+      const startTime = getCurrentUnixTimestamp();
+      try {
+        span.log({
+          input: typeof originalPrompt === "string" ? originalPrompt : promptIsAsyncIterable ? void 0 : originalPrompt !== void 0 ? String(originalPrompt) : void 0,
+          metadata: filterSerializableOptions(options)
         });
-      },
-      end: (event) => {
-        const state = spans.get(event);
-        if (!state) {
-          return;
-        }
-        const eventResult = bindClaudeLocalToolContextToAsyncIterable(
-          event.result,
-          state.localToolContext
-        );
-        if (eventResult === void 0) {
-          state.span.end();
-          spans.delete(event);
-          return;
-        }
-        if (isAsyncIterable(eventResult)) {
-          patchStreamIfNeeded(eventResult, {
-            onChunk: (message) => {
-              maybeTrackToolUseContext(state, message);
-              state.processing = state.processing.then(() => handleStreamMessage(state, message)).catch((error) => {
-                console.error(
-                  "Error processing Claude Agent SDK stream chunk:",
-                  error
-                );
-              });
-            },
-            onComplete: () => state.processing.then(() => finalizeQuerySpan(state)).finally(() => {
-              spans.delete(event);
-            }),
-            onError: (error) => state.processing.then(() => {
-              state.span.log({
-                error: error.message
-              });
-            }).then(() => finalizeQuerySpan(state)).finally(() => {
-              spans.delete(event);
-            })
-          });
-          return;
-        }
-        try {
-          state.span.log({ output: eventResult });
-        } catch (error) {
-          console.error("Error extracting output for Claude Agent SDK:", error);
-        } finally {
-          state.span.end();
-          spans.delete(event);
+      } catch (error) {
+        console.error("Error extracting input for Claude Agent SDK:", error);
+      }
+      const activeToolSpans = /* @__PURE__ */ new Map();
+      const activeLlmSpansByParentToolUse = /* @__PURE__ */ new Map();
+      const conversationHistoryByParentKey = /* @__PURE__ */ new Map();
+      const subAgentSpans = /* @__PURE__ */ new Map();
+      const endedSubAgentSpans = /* @__PURE__ */ new Set();
+      const toolUseToParent = /* @__PURE__ */ new Map();
+      const latestLlmParentBySubAgentToolUse = /* @__PURE__ */ new Map();
+      const latestRootLlmParentRef = {
+        value: void 0
+      };
+      const subAgentDetailsByToolUseId = /* @__PURE__ */ new Map();
+      const taskIdToToolUseId = /* @__PURE__ */ new Map();
+      const promptMessagesByParentKey = /* @__PURE__ */ new Map();
+      const promptSourcePriorityByParentKey = /* @__PURE__ */ new Map();
+      const { hasLocalToolHandlers, localToolHookNames } = prepareLocalToolHandlersInMcpServers(options.mcpServers);
+      const skipLocalToolHooks = options[CLAUDE_AGENT_SDK_SKIP_LOCAL_TOOL_HOOKS_OPTION] === true || hasLocalToolHandlers;
+      const resolveToolUseParentSpan = async (toolUseID, context) => {
+        const trackedParentToolUseId = toolUseToParent.get(toolUseID);
+        const parentToolUseId = trackedParentToolUseId ?? (context?.agentId ? taskIdToToolUseId.get(context.agentId) ?? null : null);
+        const parentKey = llmParentKey(parentToolUseId);
+        const activeLlmSpan = activeLlmSpansByParentToolUse.get(parentKey);
+        const latestLlmParent = parentToolUseId ? latestLlmParentBySubAgentToolUse.get(parentToolUseId) : latestRootLlmParentRef.value;
+        if (!activeLlmSpan && !latestLlmParent) {
+          await ensureActiveLlmSpanForParentToolUse(
+            span,
+            activeLlmSpansByParentToolUse,
+            subAgentDetailsByToolUseId,
+            activeToolSpans,
+            subAgentSpans,
+            parentToolUseId,
+            getCurrentUnixTimestamp()
+          );
         }
-      },
-      error: (event) => {
-        const state = spans.get(event);
-        if (!state || !event.error) {
-          return;
+        if (parentToolUseId) {
+          const subAgentSpan = await ensureSubAgentSpan(
+            subAgentDetailsByToolUseId,
+            span,
+            activeToolSpans,
+            subAgentSpans,
+            parentToolUseId
+          );
+          return subAgentSpan.export();
         }
-        state.span.log({
-          error: event.error.message
+        return span.export();
+      };
+      const optionsWithHooks = injectTracingHooks(
+        options,
+        resolveToolUseParentSpan,
+        taskIdToToolUseId,
+        toolUseToParent,
+        activeToolSpans,
+        localToolHookNames,
+        skipLocalToolHooks,
+        subAgentDetailsByToolUseId,
+        subAgentSpans,
+        endedSubAgentSpans
+      );
+      params.options = optionsWithHooks;
+      return {
+        activeLlmSpansByParentToolUse,
+        activePartialMessageIdByParentKey: /* @__PURE__ */ new Map(),
+        activeToolSpans,
+        conversationHistoryByParentKey,
+        capturedPromptMessages,
+        currentMessageId: void 0,
+        currentMessageStartTime: startTime,
+        currentMessages: [],
+        endedSubAgentSpans,
+        finalOutputUsageMessageIds: /* @__PURE__ */ new Set(),
+        finalResults: [],
+        options: optionsWithHooks,
+        originalPrompt,
+        processing: Promise.resolve(),
+        promptDone,
+        promptMessagesByParentKey,
+        promptStarted: () => promptStarted,
+        promptSourcePriorityByParentKey,
+        span,
+        subAgentDetailsByToolUseId,
+        subAgentSpans,
+        taskIdToToolUseId,
+        latestLlmParentBySubAgentToolUse,
+        latestRootLlmParentRef,
+        toolUseToParent,
+        usageByMessageId: /* @__PURE__ */ new Map(),
+        localToolParentResolver: resolveToolUseParentSpan
+      };
+    };
+    const finishQuery = (state, result) => {
+      if (isAsyncIterable(result)) {
+        patchStreamIfNeeded(result, {
+          aroundNext: (callback) => runWithClaudeLocalToolContext(
+            callback,
+            state.localToolParentResolver
+          ),
+          onChunk: (message) => {
+            maybeTrackToolUseContext(state, message);
+            state.processing = state.processing.then(() => handleStreamMessage(state, message)).catch((error) => {
+              console.error(
+                "Error processing Claude Agent SDK stream chunk:",
+                error
+              );
+            });
+          },
+          onComplete: () => state.processing.then(() => finalizeQuerySpan(state)),
+          onError: (error) => state.processing.then(() => {
+            state.span.log({ error: error.message });
+          }).then(() => finalizeQuerySpan(state))
         });
+        return;
+      }
+      try {
+        state.span.log({ output: result });
+      } catch (error) {
+        console.error("Error extracting output for Claude Agent SDK:", error);
+      } finally {
         state.span.end();
-        spans.delete(event);
       }
     };
-    channel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      channel2.unsubscribe(handlers);
-    });
+    this.unsubscribers.push(
+      claudeAgentSDKChannels.query.intercept((target, thisArg, args) => {
+        let state;
+        try {
+          args[0] ??= {};
+          state = startQuery(args[0]);
+        } catch (error) {
+          debugLogger.error(
+            "Error starting Claude Agent SDK instrumentation:",
+            error
+          );
+        }
+        const invokeTarget = () => Reflect.apply(target, thisArg, args);
+        try {
+          const result = state ? runWithClaudeLocalToolContext(
+            invokeTarget,
+            state.localToolParentResolver
+          ) : invokeTarget();
+          if (state) {
+            try {
+              finishQuery(state, result);
+            } catch (error) {
+              debugLogger.error(
+                "Error finalizing Claude Agent SDK instrumentation:",
+                error
+              );
+            }
+          }
+          return result;
+        } catch (error) {
+          if (state) {
+            try {
+              state.span.log({
+                error: error instanceof Error ? error.message : String(error)
+              });
+              state.span.end();
+            } catch (instrumentationError) {
+              debugLogger.error(
+                "Error handling Claude Agent SDK instrumentation failure:",
+                instrumentationError
+              );
+            }
+          }
+          throw error;
+        }
+      })
+    );
   }
 };
 
@@ -23150,9 +23812,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;
     }
   }
@@ -24855,7 +25517,7 @@ function patchOpenRouterCallModelResult(args) {
         span,
         () => originalMethod.apply(resultLike, args2)
       );
-      if (!isAsyncIterable4(stream)) {
+      if (!isAsyncIterable3(stream)) {
         return stream;
       }
       return wrapAsyncIterableWithSpan({
@@ -25050,7 +25712,7 @@ function wrapAsyncIterableWithSpan(args) {
     }
   };
 }
-function isAsyncIterable4(value) {
+function isAsyncIterable3(value) {
   return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function normalizeError(error) {
@@ -25928,7 +26590,7 @@ function patchOpenRouterCallModelResult2(args) {
         span,
         () => originalMethod.apply(resultLike, args2)
       );
-      if (!isAsyncIterable5(stream)) {
+      if (!isAsyncIterable4(stream)) {
         return stream;
       }
       return wrapAsyncIterableWithSpan2({
@@ -26123,7 +26785,7 @@ function wrapAsyncIterableWithSpan2(args) {
     }
   };
 }
-function isAsyncIterable5(value) {
+function isAsyncIterable4(value) {
   return !!value && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 function normalizeError2(error) {
@@ -30047,7 +30709,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(
@@ -30056,10 +30718,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
   };
@@ -30998,17 +31660,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) {
@@ -31023,6 +31688,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) } : {},
@@ -31039,6 +31709,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);
@@ -31051,8 +31723,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, {
@@ -31060,11 +31731,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) {
@@ -31311,16 +31985,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) {
@@ -31499,6 +32177,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;
 }
@@ -31656,6 +32399,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;
@@ -32019,12 +32777,14 @@ function getMetricsFromResponse(response) {
       continue;
     }
     const inputTokenDetails = usageMetadata.input_token_details;
+    const outputTokenDetails = usageMetadata.output_token_details;
     return normalizeTokenMetrics({
       total_tokens: usageMetadata.total_tokens,
       prompt_tokens: usageMetadata.input_tokens,
       completion_tokens: usageMetadata.output_tokens,
       prompt_cache_creation_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_creation : void 0,
-      prompt_cached_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_read : void 0
+      prompt_cached_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_read : void 0,
+      completion_reasoning_tokens: isRecord(outputTokenDetails) ? outputTokenDetails.reasoning : void 0
     });
   }
   const llmOutput = response.llmOutput || {};
@@ -32611,6 +33371,9 @@ var piCodingAgentChannels = defineChannels(
 // src/instrumentation/plugins/pi-coding-agent-plugin.ts
 var piAgentPatchStates = /* @__PURE__ */ new WeakMap();
 var piAgentEventSubscriptions = /* @__PURE__ */ new WeakSet();
+var PI_TOOL_EXECUTE_WRAPPED = /* @__PURE__ */ Symbol.for(
+  "braintrust.pi_coding_agent.tool_execute_wrapped"
+);
 var piPromptContextStore;
 var PiCodingAgentPlugin = class extends BasePlugin {
   activePromptStates = /* @__PURE__ */ new Set();
@@ -32691,6 +33454,7 @@ function startPiPromptRun(event, onFinalize) {
     return void 0;
   }
   installPiAgentInstrumentation(agent);
+  wrapPiToolExecutors(agent.state?.tools);
   const metadata = {
     ...extractSessionMetadata(session),
     ...extractPromptOptionsMetadata(event.arguments[1]),
@@ -32787,6 +33551,7 @@ function makeInstrumentedStreamFn(agent, originalStreamFn) {
     if (!state || state.agent !== agent || state.finalized) {
       return invokeOriginal();
     }
+    wrapPiToolExecutors(context.tools);
     const llmState = await startPiLlmSpan(state, model, context, options);
     try {
       const stream = await runWithAutoInstrumentationSuppressed(invokeOriginal);
@@ -32797,6 +33562,33 @@ function makeInstrumentedStreamFn(agent, originalStreamFn) {
     }
   };
 }
+function wrapPiToolExecutors(tools) {
+  if (!tools) {
+    return;
+  }
+  for (const tool of tools) {
+    try {
+      const execute = tool.execute;
+      if (typeof execute !== "function" || execute[PI_TOOL_EXECUTE_WRAPPED]) {
+        continue;
+      }
+      const wrappedExecute = function(...args) {
+        return runWithAutoInstrumentationAllowed(
+          () => Reflect.apply(execute, this, args)
+        );
+      };
+      Object.defineProperty(wrappedExecute, PI_TOOL_EXECUTE_WRAPPED, {
+        configurable: false,
+        enumerable: false,
+        value: true,
+        writable: false
+      });
+      tool.execute = wrappedExecute;
+    } catch (error) {
+      logInstrumentationError4("Pi Coding Agent tool wrapping", error);
+    }
+  }
+}
 async function startPiLlmSpan(state, model, context, options) {
   const metadata = {
     ...extractModelMetadata2(model),
@@ -32968,35 +33760,26 @@ async function startPiToolSpan(state, event) {
   if (!event.toolCallId || state.activeToolSpans.has(event.toolCallId)) {
     return;
   }
-  const restoreAutoInstrumentation = enterAutoInstrumentationAllowed();
   const metadata = {
     "gen_ai.tool.call.id": event.toolCallId,
     "gen_ai.tool.name": event.toolName,
     "pi_coding_agent.tool.name": event.toolName
   };
-  try {
-    const span = startSpan(
-      withSpanInstrumentationName(
-        {
-          event: {
-            input: event.args,
-            metadata
-          },
-          name: event.toolName || "tool",
-          parent: await state.span.export(),
-          spanAttributes: { type: "tool" /* TOOL */ }
+  const span = startSpan(
+    withSpanInstrumentationName(
+      {
+        event: {
+          input: event.args,
+          metadata
         },
-        INSTRUMENTATION_NAMES.PI_CODING_AGENT
-      )
-    );
-    state.activeToolSpans.set(event.toolCallId, {
-      restoreAutoInstrumentation,
-      span
-    });
-  } catch (error) {
-    restoreAutoInstrumentation();
-    throw error;
-  }
+        name: event.toolName || "tool",
+        parent: await state.span.export(),
+        spanAttributes: { type: "tool" /* TOOL */ }
+      },
+      INSTRUMENTATION_NAMES.PI_CODING_AGENT
+    )
+  );
+  state.activeToolSpans.set(event.toolCallId, { span });
 }
 function finishPiToolSpan(state, event) {
   const toolState = state.activeToolSpans.get(event.toolCallId);
@@ -33017,11 +33800,7 @@ function finishPiToolSpan(state, event) {
       output: event.result
     });
   } finally {
-    try {
-      toolState.span.end();
-    } finally {
-      toolState.restoreAutoInstrumentation?.();
-    }
+    toolState.span.end();
   }
 }
 function finishPiPromptRun(state, error) {
@@ -33092,14 +33871,10 @@ function finishPiLlmSpan(promptState, llmState, message, error) {
 }
 function finishOpenToolSpans(state, error) {
   for (const [, toolState] of state.activeToolSpans) {
-    try {
-      safeLog4(toolState.span, {
-        error: error ? toLoggedError(error) : "Pi tool did not complete"
-      });
-      toolState.span.end();
-    } finally {
-      toolState.restoreAutoInstrumentation?.();
-    }
+    safeLog4(toolState.span, {
+      error: error ? toLoggedError(error) : "Pi tool did not complete"
+    });
+    toolState.span.end();
   }
   state.activeToolSpans.clear();
 }
@@ -33418,12 +34193,12 @@ var MAX_STRANDS_STRING_ATTACHMENT_CACHE_ENTRIES = 32;
 var StrandsAgentSDKPlugin = class extends BasePlugin {
   activeChildParents = /* @__PURE__ */ new WeakMap();
   onEnable() {
-    this.subscribeToAgentStream();
-    this.subscribeToMultiAgentStream(
+    this.interceptAgentStream();
+    this.interceptMultiAgentStream(
       strandsAgentSDKChannels.graphStream,
       "Graph.stream"
     );
-    this.subscribeToMultiAgentStream(
+    this.interceptMultiAgentStream(
       strandsAgentSDKChannels.swarmStream,
       "Swarm.stream"
     );
@@ -33434,143 +34209,109 @@ var StrandsAgentSDKPlugin = class extends BasePlugin {
     }
     this.unsubscribers = [];
   }
-  subscribeToAgentStream() {
-    const channel2 = strandsAgentSDKChannels.agentStream.tracingChannel();
-    const states = /* @__PURE__ */ new WeakMap();
-    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(channel2);
-    const handlers = {
-      start: (event) => {
-        const state = startAgentStream(event, this.activeChildParents);
-        if (state) {
-          states.set(event, state);
-        }
-      },
-      end: (event) => {
-        const state = states.get(event);
-        if (!state) {
-          return;
-        }
-        const result = event.result;
-        if (isAsyncIterable(result)) {
-          patchStreamIfNeeded(result, {
-            aroundNext: (callback) => runWithAutoInstrumentationSuppressed(callback),
-            onChunk: (chunk) => handleAgentStreamEvent(state, chunk),
-            onComplete: () => {
-              finalizeAgentStream(state);
-              states.delete(event);
-            },
-            onError: (error) => {
-              finalizeAgentStream(state, error);
-              states.delete(event);
-            }
-          });
-          return;
-        }
-        finalizeAgentStream(state, void 0, result);
-        states.delete(event);
-      },
-      error: (event) => {
-        const state = states.get(event);
-        if (!state || !event.error) {
-          return;
-        }
-        finalizeAgentStream(state, event.error);
-        states.delete(event);
-      }
-    };
-    channel2.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      unbindAutoInstrumentationSuppression?.();
-      channel2.unsubscribe(handlers);
-    });
+  interceptAgentStream() {
+    this.unsubscribers.push(
+      strandsAgentSDKChannels.agentStream.intercept(
+        (target, thisArg, args, additional) => instrumentStrandsStreamInvocation({
+          finalize: finalizeAgentStream,
+          handleChunk: handleAgentStreamEvent,
+          invoke: () => Reflect.apply(target, thisArg, args),
+          name: "Strands Agent SDK",
+          start: () => startAgentStream(
+            args[0],
+            extractAgent(additional.agent, thisArg),
+            this.activeChildParents
+          )
+        })
+      )
+    );
   }
-  subscribeToMultiAgentStream(channel2, operation) {
-    const tracingChannel = channel2.tracingChannel();
-    const states = /* @__PURE__ */ new WeakMap();
-    const unbindAutoInstrumentationSuppression = bindAutoInstrumentationSuppressionToStart(tracingChannel);
-    const handlers = {
-      start: (event) => {
-        const state = startMultiAgentStream(
-          event,
-          operation,
-          this.activeChildParents
-        );
-        if (state) {
-          states.set(event, state);
-        }
-      },
-      end: (event) => {
-        const state = states.get(event);
-        if (!state) {
-          return;
-        }
-        const result = event.result;
-        if (isAsyncIterable(result)) {
-          patchStreamIfNeeded(result, {
-            aroundNext: (callback) => runWithAutoInstrumentationSuppressed(callback),
-            onChunk: (chunk) => handleMultiAgentStreamEvent(
-              state,
-              chunk,
-              this.activeChildParents
-            ),
-            onComplete: () => {
-              finalizeMultiAgentStream(state, this.activeChildParents);
-              states.delete(event);
-            },
-            onError: (error) => {
-              finalizeMultiAgentStream(state, this.activeChildParents, error);
-              states.delete(event);
-            }
-          });
-          return;
-        }
-        finalizeMultiAgentStream(
-          state,
-          this.activeChildParents,
-          void 0,
-          result
+  interceptMultiAgentStream(channel2, operation) {
+    this.unsubscribers.push(
+      channel2.intercept(
+        (target, thisArg, args, additional) => instrumentStrandsStreamInvocation({
+          finalize: (state, error, output) => finalizeMultiAgentStream(
+            state,
+            this.activeChildParents,
+            error,
+            output
+          ),
+          handleChunk: (state, chunk) => handleMultiAgentStreamEvent(state, chunk, this.activeChildParents),
+          invoke: () => Reflect.apply(target, thisArg, args),
+          name: "Strands multi-agent",
+          start: () => startMultiAgentStream(
+            args[0],
+            extractOrchestrator(additional.orchestrator, thisArg),
+            operation,
+            this.activeChildParents
+          )
+        })
+      )
+    );
+  }
+};
+function instrumentStrandsStreamInvocation(options) {
+  let state;
+  try {
+    state = options.start();
+  } catch (error) {
+    debugLogger.error(`Error starting ${options.name} instrumentation:`, error);
+  }
+  let result;
+  try {
+    result = runWithAutoInstrumentationSuppressed(options.invoke);
+  } catch (error) {
+    if (state) {
+      try {
+        options.finalize(state, error);
+      } catch (instrumentationError) {
+        debugLogger.error(
+          `Error handling ${options.name} instrumentation failure:`,
+          instrumentationError
         );
-        states.delete(event);
-      },
-      error: (event) => {
-        const state = states.get(event);
-        if (!state || !event.error) {
-          return;
-        }
-        finalizeMultiAgentStream(state, this.activeChildParents, event.error);
-        states.delete(event);
       }
-    };
-    tracingChannel.subscribe(handlers);
-    this.unsubscribers.push(() => {
-      unbindAutoInstrumentationSuppression?.();
-      tracingChannel.unsubscribe(handlers);
-    });
+    }
+    throw error;
   }
-};
-function startAgentStream(event, activeChildParents) {
-  const agent = extractAgent(event);
+  if (state) {
+    try {
+      if (isAsyncIterable(result)) {
+        patchStreamIfNeeded(result, {
+          aroundNext: (callback) => runWithAutoInstrumentationSuppressed(callback),
+          onChunk: (chunk) => options.handleChunk(state, chunk),
+          onComplete: () => options.finalize(state),
+          onError: (error) => options.finalize(state, error)
+        });
+      } else {
+        options.finalize(state, void 0, result);
+      }
+    } catch (error) {
+      debugLogger.error(
+        `Error finalizing ${options.name} instrumentation:`,
+        error
+      );
+    }
+  }
+  return result;
+}
+function startAgentStream(input, agent, activeChildParents) {
   const model = agent?.model;
   const metadata = {
     ...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();
-  const input = processStrandsInputAttachments(
-    event.arguments[0],
-    attachmentCache
-  );
+  const processedInput = processStrandsInputAttachments(input, attachmentCache);
   const span = parentSpan ? withCurrent(
     parentSpan,
     () => startSpan(
       withSpanInstrumentationName(
         {
           event: {
-            input,
+            input: processedInput,
             metadata
           },
           name: formatAgentSpanName(agent),
@@ -33583,7 +34324,7 @@ function startAgentStream(event, activeChildParents) {
     withSpanInstrumentationName(
       {
         event: {
-          input,
+          input: processedInput,
           metadata
         },
         name: formatAgentSpanName(agent),
@@ -33601,23 +34342,21 @@ function startAgentStream(event, activeChildParents) {
     startTime: getCurrentUnixTimestamp()
   };
 }
-function startMultiAgentStream(event, operation, activeChildParents) {
-  const orchestrator = extractOrchestrator(event);
+function startMultiAgentStream(input, orchestrator, 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]);
+  const processedInput = processStrandsInputAttachments(input);
   const span = parentSpan ? withCurrent(
     parentSpan,
     () => startSpan(
       withSpanInstrumentationName(
         {
           event: {
-            input,
+            input: processedInput,
             metadata
           },
           name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
@@ -33630,7 +34369,7 @@ function startMultiAgentStream(event, operation, activeChildParents) {
     withSpanInstrumentationName(
       {
         event: {
-          input,
+          input: processedInput,
           metadata
         },
         name: operation === "Graph.stream" ? "Strands Graph" : "Strands Swarm",
@@ -34001,12 +34740,12 @@ function finalizeMultiAgentStream(state, activeChildParents, error, output) {
   });
   state.span.end();
 }
-function extractAgent(event) {
-  const candidate = event.agent ?? event.self;
+function extractAgent(agent, self) {
+  const candidate = agent ?? self;
   return isObject(candidate) && typeof candidate.stream === "function" ? candidate : void 0;
 }
-function extractOrchestrator(event) {
-  const candidate = event.orchestrator ?? event.self;
+function extractOrchestrator(orchestrator, self) {
+  const candidate = orchestrator ?? self;
   return isObject(candidate) && typeof candidate.stream === "function" ? candidate : void 0;
 }
 function extractAgentMetadata2(agent) {
@@ -34393,6 +35132,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, extractInput2, 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 } = extractInput2(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, log2) {
+  try {
+    log2();
+  } 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",
@@ -34948,6 +36001,7 @@ var BraintrustPlugin = class extends BasePlugin {
   langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
+  voyageAIPlugin = null;
   cloudflareAIChatPlugin = null;
   cloudflareAgentsPlugin = null;
   constructor(config = {}) {
@@ -35022,6 +36076,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();
@@ -35138,6 +36196,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;
@@ -35257,7 +36319,10 @@ var envIntegrationAliases = {
   "langchain-js": "langchain",
   "@langchain": "langchain",
   langgraph: "langgraph",
-  langsmith: "langsmith"
+  langsmith: "langsmith",
+  voyage: "voyageai",
+  "voyage-ai": "voyageai",
+  voyageai: "voyageai"
 };
 function getDefaultInstrumentationIntegrations() {
   return {
@@ -35292,6 +36357,7 @@ function getDefaultInstrumentationIntegrations() {
     langchain: true,
     langgraph: true,
     langsmith: true,
+    voyageai: true,
     piCodingAgent: true,
     strandsAgentSDK: true,
     cloudflareAgents: true
@@ -35712,9 +36778,9 @@ function configureNode() {
       return value;
     }
     const envPaths = [];
-    for (let dir2 = process.cwd(), depth = 0; depth <= BRAINTRUST_ENV_SEARCH_PARENT_LIMIT; dir2 = path.dirname(dir2), depth++) {
-      envPaths.push(path.join(dir2, ".env.braintrust"));
-      if (path.dirname(dir2) === dir2) {
+    for (let dir2 = process.cwd(), depth = 0; depth <= BRAINTRUST_ENV_SEARCH_PARENT_LIMIT; dir2 = path2.dirname(dir2), depth++) {
+      envPaths.push(path2.join(dir2, ".env.braintrust"));
+      if (path2.dirname(dir2) === dir2) {
         break;
       }
     }
@@ -35756,10 +36822,10 @@ function configureNode() {
   isomorph_default.processOn = (event, handler) => {
     process.on(event, handler);
   };
-  isomorph_default.basename = path.basename;
+  isomorph_default.basename = path2.basename;
   isomorph_default.writeln = (text) => process.stdout.write(text + "\n");
-  isomorph_default.pathJoin = path.join;
-  isomorph_default.pathDirname = path.dirname;
+  isomorph_default.pathJoin = path2.join;
+  isomorph_default.pathDirname = path2.dirname;
   isomorph_default.mkdir = fs.mkdir;
   isomorph_default.writeFile = fs.writeFile;
   isomorph_default.readFile = fs.readFile;
@@ -35794,8 +36860,8 @@ function configureNode() {
   registry.enable();
 }
 function getNearestBraintrustEnvValue(name) {
-  for (let dir2 = process.cwd(), depth = 0; depth <= BRAINTRUST_ENV_SEARCH_PARENT_LIMIT; dir2 = path.dirname(dir2), depth++) {
-    const envPath = path.join(dir2, ".env.braintrust");
+  for (let dir2 = process.cwd(), depth = 0; depth <= BRAINTRUST_ENV_SEARCH_PARENT_LIMIT; dir2 = path2.dirname(dir2), depth++) {
+    const envPath = path2.join(dir2, ".env.braintrust");
     try {
       const parsed = dotenv.parse(fsSync.readFileSync(envPath, "utf8"));
       const value = parsed[name];
@@ -35805,7 +36871,7 @@ function getNearestBraintrustEnvValue(name) {
         return void 0;
       }
     }
-    if (path.dirname(dir2) === dir2) {
+    if (path2.dirname(dir2) === dir2) {
       break;
     }
   }
@@ -35887,7 +36953,7 @@ function isAsync(fn) {
 function isAsyncGenerator2(fn) {
   return fn[Symbol.toStringTag] === "AsyncGenerator";
 }
-function isAsyncIterable6(obj) {
+function isAsyncIterable5(obj) {
   return typeof obj[Symbol.asyncIterator] === "function";
 }
 function wrapAsync(asyncFn) {
@@ -36059,7 +37125,7 @@ var eachOfLimit$2 = (limit) => {
     if (isAsyncGenerator2(obj)) {
       return asyncEachOfLimit(obj, limit, iteratee, callback);
     }
-    if (isAsyncIterable6(obj)) {
+    if (isAsyncIterable5(obj)) {
       return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
     }
     var nextElem = createIterator(obj);
@@ -37371,8 +38437,8 @@ function validateParametersWithJsonSchema(parameters, schema) {
   const validate = ajv.compile(schema);
   if (!validate(parameters)) {
     const errorMessages = validate.errors?.map((err) => {
-      const path2 = err.instancePath || "root";
-      return `${path2}: ${err.message}`;
+      const path3 = err.instancePath || "root";
+      return `${path3}: ${err.message}`;
     }).join(", ");
     throw Error(`Invalid parameters: ${errorMessages}`);
   }
@@ -37401,6 +38467,9 @@ function rehydrateRemoteParameters(parameters, schema) {
 }
 
 // src/framework.ts
+function BaseExperiment(options = {}) {
+  return { _type: "BaseExperiment", ...options };
+}
 var EvalResultWithSummary = class {
   constructor(summary, results) {
     this.summary = summary;
@@ -37461,6 +38530,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 initExperiment(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;
@@ -37472,12 +38561,54 @@ function callEvaluatorData(data) {
     baseExperiment
   };
 }
-function isAsyncIterable7(value) {
+function isAsyncIterable6(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 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 = initExperiment(evaluator.state, {
+      ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: evaluator.projectName },
+      experiment: name,
+      open: true
+    }).asDataset();
+  }
+  const resolvedDataResult = dataResult instanceof Promise ? await dataResult : dataResult;
+  if (isAsyncIterable6(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: [],
@@ -37524,25 +38655,13 @@ async function Eval(name, evaluator, reporterOrOpts) {
   }
   const resolvedReporter = options.reporter || defaultReporter;
   try {
-    const { data, baseExperiment: defaultBaseExperiment } = callEvaluatorData(
-      evaluator.data
+    const { data } = callEvaluatorData(evaluator.data);
+    const experiment = await _internalInitEvaluatorExperiment(
+      name,
+      evaluator,
+      data,
+      { disabled: Boolean(options.parent || options.noSendLogs) }
     );
-    const parameters = await getExperimentParametersRef(evaluator.parameters);
-    const experiment = options.parent || options.noSendLogs ? null : initExperiment(evaluator.state, {
-      ...evaluator.projectId ? { projectId: evaluator.projectId } : { project: name },
-      experiment: evaluator.experimentName,
-      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
-    });
     if (experiment && typeof process !== "undefined" && globalThis.BRAINTRUST_CONTEXT_MANAGER !== void 0) {
       await experiment._waitForId();
     }
@@ -37611,8 +38730,8 @@ function serializeJSONWithPlainString(v) {
   }
 }
 function evaluateFilter(object, filter2) {
-  const { path: path2, pattern } = filter2;
-  const key = path2.reduce(
+  const { path: path3, pattern } = filter2;
+  const key = path3.reduce(
     (acc, p) => typeof acc === "object" && acc !== null ? (
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       acc[p]
@@ -37630,19 +38749,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, {
@@ -37687,6 +38861,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(
@@ -37725,54 +38920,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 = initExperiment(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 {
@@ -37841,57 +38996,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 {
@@ -37901,20 +39044,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(
@@ -37928,35 +39069,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;
                     }
                   )
                 )
@@ -37973,24 +39096,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;
                     }
                   )
                 )
@@ -38219,7 +39334,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);
   }
@@ -39381,39 +40496,19 @@ async function getDataset(state, data) {
       _internal_btql: data._internal_btql ?? void 0
     });
   } else if ("dataset_id" in data) {
-    const datasetInfo = await getDatasetById({
-      state,
-      datasetId: data.dataset_id
-    });
     return initDataset({
       state,
-      projectId: datasetInfo.projectId,
-      dataset: datasetInfo.dataset,
+      datasetId: data.dataset_id,
       version: data.dataset_version ?? void 0,
       environment: data.dataset_environment ?? void 0,
       _internal_btql: data._internal_btql ?? void 0
     });
+  } else if ("experiment_name" in data) {
+    return BaseExperiment({ name: data.experiment_name });
   } else {
     return data.data;
   }
 }
-var datasetFetchSchema = z14.object({
-  project_id: z14.string(),
-  name: z14.string()
-});
-async function getDatasetById({
-  state,
-  datasetId
-}) {
-  const dataset = await state.appConn().post_json("api/dataset/get", {
-    id: datasetId
-  });
-  const parsed = z14.array(datasetFetchSchema).parse(dataset);
-  if (parsed.length === 0) {
-    throw new Error(`Dataset '${datasetId}' not found`);
-  }
-  return { projectId: parsed[0].project_id, dataset: parsed[0].name };
-}
 function makeScorer(state, name, score, projectId) {
   const ret = async (input) => {
     const request = {