braintrust 3.8.0 → 3.9.0

package/dist/cli.js

@@ -1232,12 +1232,12 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "3.8.0",
+      version: "3.9.0",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
         url: "git+https://github.com/braintrustdata/braintrust-sdk-javascript.git",
-        directory: "blob/main/js"
+        directory: "js"
       },
       homepage: "https://www.braintrust.dev/docs",
       main: "./dist/index.js",
@@ -1375,7 +1375,6 @@ var require_package = __commonJS({
         "test:vitest": "pnpm --filter @braintrust/vitest-wrapper-tests test",
         "test:output": "tsx scripts/test-output.ts --with-comparison --with-metrics --with-progress",
         bench: "tsx src/queue.bench.ts",
-        "publish:validate": "./scripts/validate-release.sh && pnpm install --frozen-lockfile && pnpm run build && pnpm publish",
         lint: "eslint .",
         "fix:lint": "eslint --fix .",
         playground: "tsx playground.ts",
@@ -1388,6 +1387,7 @@ var require_package = __commonJS({
       devDependencies: {
         "@ai-sdk/anthropic": "2.0.37",
         "@anthropic-ai/sdk": "^0.60.0",
+        "@google/adk": "^0.6.1",
         "@google/genai": "^1.25.0",
         "@jest/globals": "^29.7.0",
         "@nodelib/fs.walk": "^1.2.8",
@@ -1423,7 +1423,7 @@ var require_package = __commonJS({
         typedoc: "^0.25.13",
         "typedoc-plugin-markdown": "^3.17.1",
         typescript: "5.4.4",
-        vite: "^6.4.1",
+        vite: "^6.4.2",
         "vite-tsconfig-paths": "^4.3.2",
         vitest: "^4.1.2",
         webpack: "^5.97.1",
@@ -1431,7 +1431,7 @@ var require_package = __commonJS({
       },
       dependencies: {
         "@ai-sdk/provider": "^1.1.3",
-        "@apm-js-collab/code-transformer": "^0.9.0",
+        "@apm-js-collab/code-transformer": "^0.12.0",
         "@next/env": "^14.2.3",
         "@vercel/functions": "^1.0.2",
         ajv: "^8.17.1",
@@ -1441,7 +1441,7 @@ var require_package = __commonJS({
         "cli-progress": "^3.12.0",
         "cli-table3": "^0.6.5",
         cors: "^2.8.5",
-        "dc-browser": "^1.0.3",
+        "dc-browser": "^1.0.4",
         dotenv: "^16.4.5",
         esbuild: "^0.27.0",
         "eventsource-parser": "^1.1.2",
@@ -1461,6 +1461,11 @@ var require_package = __commonJS({
       },
       peerDependencies: {
         zod: "^3.25.34 || ^4.0"
+      },
+      publishConfig: {
+        access: "public",
+        registry: "https://registry.npmjs.org/",
+        provenance: true
       }
     };
   }
@@ -2400,6 +2405,9 @@ function isObjectOrArray(value) {
 function isEmpty(a) {
   return a === void 0 || a === null;
 }
+function isPromiseLike(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
 
 // util/object_util.ts
 var SET_UNION_FIELDS = /* @__PURE__ */ new Set(["tags"]);
@@ -3508,7 +3516,11 @@ var CodeBundle = import_v36.z.object({
       eval_name: import_v36.z.string(),
       position: import_v36.z.union([
         import_v36.z.object({ type: import_v36.z.literal("task") }),
-        import_v36.z.object({ type: import_v36.z.literal("scorer"), index: import_v36.z.number().int().gte(0) })
+        import_v36.z.object({ type: import_v36.z.literal("scorer"), index: import_v36.z.number().int().gte(0) }),
+        import_v36.z.object({
+          type: import_v36.z.literal("classifier"),
+          index: import_v36.z.number().int().gte(0)
+        })
       ])
     }),
     import_v36.z.object({ type: import_v36.z.literal("function"), index: import_v36.z.number().int().gte(0) }),
@@ -4630,11 +4642,15 @@ var RunEval = import_v36.z.object({
   data: import_v36.z.union([
     import_v36.z.object({
       dataset_id: import_v36.z.string(),
+      dataset_version: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+      dataset_environment: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
       _internal_btql: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional()
     }),
     import_v36.z.object({
       project_name: import_v36.z.string(),
       dataset_name: import_v36.z.string(),
+      dataset_version: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+      dataset_environment: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
       _internal_btql: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional()
     }),
     import_v36.z.object({ data: import_v36.z.array(import_v36.z.unknown()) })
@@ -4762,6 +4778,7 @@ var ViewOptions = import_v36.z.union([
     rowHeight: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
     tallGroupRows: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
     layout: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
+    topicMapReportKey: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
     chartHeight: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]),
     excludedMeasures: import_v36.z.union([
       import_v36.z.array(
@@ -4804,6 +4821,7 @@ var ViewOptions = import_v36.z.union([
       import_v36.z.null()
     ]),
     queryShape: import_v36.z.union([import_v36.z.enum(["traces", "spans"]), import_v36.z.null()]),
+    cluster: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
     freezeColumns: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()])
   }).partial(),
   import_v36.z.null()
@@ -8441,8 +8459,9 @@ function validateAndSanitizeExperimentLogPartialArgs(event) {
 }
 function deepCopyEvent(event) {
   const attachments = [];
-  const IDENTIFIER = "_bt_internal_saved_attachment";
-  const savedAttachmentSchema = import_v38.z.strictObject({ [IDENTIFIER]: import_v38.z.number() });
+  const ATTACHMENT_INDEX_KEY = "_bt_internal_saved_attachment_idx";
+  const ATTACHMENT_MARKER_KEY = "_bt_internal_saved_attachment_marker";
+  const attachmentMarker = ++deepCopyEventMarkerCounter;
   const serialized = JSON.stringify(event, (_k, v) => {
     if (v instanceof SpanImpl || v instanceof NoopSpan) {
       return `<span>`;
@@ -8454,21 +8473,39 @@ function deepCopyEvent(event) {
       return `<logger>`;
     } else if (v instanceof BaseAttachment) {
       const idx = attachments.push(v);
-      return { [IDENTIFIER]: idx - 1 };
+      return {
+        [ATTACHMENT_INDEX_KEY]: idx - 1,
+        [ATTACHMENT_MARKER_KEY]: attachmentMarker
+      };
     } else if (v instanceof ReadonlyAttachment) {
       return v.reference;
     }
     return v;
   });
   const x = JSON.parse(serialized, (_k, v) => {
-    const parsedAttachment = savedAttachmentSchema.safeParse(v);
-    if (parsedAttachment.success) {
-      return attachments[parsedAttachment.data[IDENTIFIER]];
+    if (isDeepCopyAttachmentPlaceholder(v, attachmentMarker)) {
+      return attachments[v[ATTACHMENT_INDEX_KEY]];
     }
     return v;
   });
   return x;
 }
+var deepCopyEventMarkerCounter = 0;
+function isDeepCopyAttachmentPlaceholder(value, attachmentMarker) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if (!Object.hasOwn(record, "_bt_internal_saved_attachment_idx") || !Object.hasOwn(record, "_bt_internal_saved_attachment_marker")) {
+    return false;
+  }
+  if (Object.keys(record).length !== 2) {
+    return false;
+  }
+  const attachmentIndex = record._bt_internal_saved_attachment_idx;
+  const marker = record._bt_internal_saved_attachment_marker;
+  return Number.isInteger(attachmentIndex) && attachmentIndex >= 0 && marker === attachmentMarker;
+}
 function extractAttachments(event, attachments) {
   for (const [key, value] of Object.entries(event)) {
     if (!value) {
@@ -11909,7 +11946,88 @@ function evaluateFilter(object, filter2) {
 function scorerName(scorer, scorer_idx) {
   return scorer.name || `scorer_${scorer_idx}`;
 }
+function classifierName(classifier, classifier_idx) {
+  return classifier.name || `classifier_${classifier_idx}`;
+}
+function buildSpanMetadata(results) {
+  return results.length === 1 ? results[0].metadata : results.reduce(
+    (prev, s) => mergeDicts(prev, { [s.name]: s.metadata }),
+    {}
+  );
+}
+function buildSpanScores(results) {
+  const scoresRecord = results.reduce(
+    (prev, s) => mergeDicts(prev, { [s.name]: s.score }),
+    {}
+  );
+  return { resultMetadata: buildSpanMetadata(results), scoresRecord };
+}
+async function runInScorerSpan(rootSpan, spanName, spanType, propagatedEvent, eventInput, fn) {
+  try {
+    const value = await rootSpan.traced(fn, {
+      name: spanName,
+      spanAttributes: { type: spanType, purpose: "scorer" },
+      propagatedEvent,
+      event: { input: eventInput }
+    });
+    return { kind: "score", value };
+  } catch (e) {
+    return { kind: "error", value: e };
+  }
+}
+function collectScoringResults(runResults, names, onResult) {
+  const failing = [];
+  runResults.forEach((r, i) => {
+    if (r.kind === "score") {
+      (r.value ?? []).forEach(onResult);
+    } else {
+      failing.push({ name: names[i], error: r.value });
+    }
+  });
+  return failing;
+}
+function validateClassificationResult(value, scorerName2) {
+  if (!(typeof value === "object" && value !== null && !isEmpty2(value))) {
+    throw new Error(
+      `When returning structured classifier results, each classification must be a non-empty object. Got: ${JSON.stringify(value)}`
+    );
+  }
+  if (!("name" in value) || typeof value.name !== "string" || !value.name) {
+    const classification = value;
+    classification.name = scorerName2;
+    return classification;
+  }
+  return value;
+}
+function toClassificationItem(c) {
+  return {
+    id: c.id,
+    label: c.label ?? c.id,
+    ...c.metadata !== void 0 ? { metadata: c.metadata } : {}
+  };
+}
+function logScoringFailures(kind, failures, metadata, rootSpan, state) {
+  if (!failures.length) return [];
+  const errorMap = Object.fromEntries(
+    failures.map(({ name, error: error2 }) => [
+      name,
+      error2 instanceof Error ? error2.stack : `${error2}`
+    ])
+  );
+  metadata[`${kind}_errors`] = errorMap;
+  rootSpan.log({ metadata: { [`${kind}_errors`]: errorMap } });
+  debugLogger.forState(state).warn(
+    `Found exceptions for the following ${kind}s: ${Object.keys(errorMap).join(", ")}`,
+    failures.map((f) => f.error)
+  );
+  return Object.keys(errorMap);
+}
 async function runEvaluator(experiment, evaluator, progressReporter, filters, stream, parameters, collectResults = true, enableCache = true) {
+  if (!evaluator.scores && !evaluator.classifiers) {
+    throw new Error(
+      "Evaluator must include at least one of `scores` or `classifiers`"
+    );
+  }
   return await runEvaluatorInternal(
     experiment,
     evaluator,
@@ -12047,7 +12165,11 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
           let error2 = void 0;
           let tags = [...datum.tags ?? []];
           const scores = {};
-          const scorerNames = evaluator.scores.map(scorerName);
+          const classifications = {};
+          const scorerNames = (evaluator.scores ?? []).map(scorerName);
+          const classifierNames = (evaluator.classifiers ?? []).map(
+            classifierName
+          );
           let unhandledScores = scorerNames;
           try {
             const meta = (o) => metadata = { ...metadata, ...o };
@@ -12101,106 +12223,131 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
               output,
               trace
             };
-            const scoreResults = await Promise.all(
-              evaluator.scores.map(async (score, score_idx) => {
-                try {
-                  const runScorer = async (span) => {
-                    const scoreResult = score(scoringArgs);
-                    const scoreValue = scoreResult instanceof Promise ? await scoreResult : scoreResult;
-                    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 { 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(
+                  (score, score_idx) => runInScorerSpan(
+                    rootSpan,
+                    scorerNames[score_idx],
+                    "score" /* SCORE */,
+                    propagatedEvent,
+                    scoringArgsForLogging,
+                    async (span) => {
+                      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)
+                        }),
+                        {}
+                      );
+                      span.log({
+                        output: resultOutput,
+                        metadata: resultMetadata,
+                        scores: scoresRecord
+                      });
+                      return results;
                     }
-                    const results2 = Array.isArray(scoreValue) ? scoreValue : typeof scoreValue === "object" && !isEmpty2(scoreValue) ? [scoreValue] : [
-                      {
-                        name: scorerNames[score_idx],
-                        score: scoreValue
-                      }
-                    ];
-                    const getOtherFields = (s) => {
-                      const { metadata: _metadata, name: _name, ...rest } = s;
-                      return rest;
-                    };
-                    const resultMetadata = results2.length === 1 ? results2[0].metadata : results2.reduce(
-                      (prev, s) => mergeDicts(prev, {
-                        [s.name]: s.metadata
-                      }),
-                      {}
-                    );
-                    const resultOutput = results2.length === 1 ? getOtherFields(results2[0]) : results2.reduce(
-                      (prev, s) => mergeDicts(prev, { [s.name]: getOtherFields(s) }),
-                      {}
-                    );
-                    const scores2 = results2.reduce(
-                      (prev, s) => mergeDicts(prev, { [s.name]: s.score }),
-                      {}
-                    );
-                    span.log({
-                      output: resultOutput,
-                      metadata: resultMetadata,
-                      scores: scores2
-                    });
-                    return results2;
-                  };
-                  const { trace: _trace, ...scoringArgsForLogging } = scoringArgs;
-                  const results = await rootSpan.traced(runScorer, {
-                    name: scorerNames[score_idx],
-                    spanAttributes: {
-                      type: "score" /* SCORE */,
-                      purpose: "scorer"
-                    },
-                    propagatedEvent: makeScorerPropagatedEvent(
-                      await rootSpan.export()
-                    ),
-                    event: { input: scoringArgsForLogging }
-                  });
-                  return { kind: "score", value: results };
-                } catch (e) {
-                  return { kind: "error", value: e };
-                }
-              })
+                  )
+                )
+              ),
+              Promise.all(
+                (evaluator.classifiers ?? []).map(
+                  (classifier, idx) => runInScorerSpan(
+                    rootSpan,
+                    classifierNames[idx],
+                    "classifier" /* CLASSIFIER */,
+                    propagatedEvent,
+                    scoringArgsForLogging,
+                    async (span) => {
+                      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)
+                        }),
+                        {}
+                      );
+                      span.log({
+                        output: resultOutput,
+                        metadata: buildSpanMetadata(rawResults)
+                      });
+                      return rawResults;
+                    }
+                  )
+                )
+              )
+            ]);
+            const failingScorers = collectScoringResults(
+              scoreResults,
+              scorerNames,
+              (result) => {
+                scores[result.name] = result.score;
+              }
             );
-            const failingScorersAndResults = [];
-            scoreResults.forEach((results, i) => {
-              const name = scorerNames[i];
-              if (results.kind === "score") {
-                (results.value || []).forEach((result) => {
-                  scores[result.name] = result.score;
-                });
-              } else {
-                failingScorersAndResults.push({ name, error: results.value });
+            const failingClassifiers = collectScoringResults(
+              classificationResults,
+              classifierNames,
+              (result) => {
+                const item = toClassificationItem(result);
+                if (!classifications[result.name]) {
+                  classifications[result.name] = [];
+                }
+                classifications[result.name].push(item);
               }
-            });
-            unhandledScores = null;
-            if (failingScorersAndResults.length) {
-              const scorerErrors = Object.fromEntries(
-                failingScorersAndResults.map(({ name, error: error3 }) => [
-                  name,
-                  error3 instanceof Error ? error3.stack : `${error3}`
-                ])
-              );
-              metadata["scorer_errors"] = scorerErrors;
-              rootSpan.log({
-                metadata: { scorer_errors: scorerErrors }
-              });
-              const names = Object.keys(scorerErrors).join(", ");
-              const errors = failingScorersAndResults.map((item) => item.error);
-              unhandledScores = Object.keys(scorerErrors);
-              debugLogger.forState(evaluator.state).warn(
-                `Found exceptions for the following scorers: ${names}`,
-                errors
-              );
+            );
+            if (Object.keys(classifications).length > 0) {
+              rootSpan.log({ classifications });
             }
+            const failedScorerNames = logScoringFailures(
+              "scorer",
+              failingScorers,
+              metadata,
+              rootSpan,
+              evaluator.state
+            );
+            unhandledScores = failedScorerNames.length ? failedScorerNames : null;
+            logScoringFailures(
+              "classifier",
+              failingClassifiers,
+              metadata,
+              rootSpan,
+              evaluator.state
+            );
           } catch (e) {
             logError(rootSpan, e);
             error2 = e;
@@ -12219,15 +12366,19 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             accumulateScores(localScoreAccumulator, mergedScores);
           }
           if (collectResults) {
-            collectedResults.push({
+            const baseResult = {
               input: datum.input,
               ..."expected" in datum ? { expected: datum.expected } : {},
               output,
               tags: tags.length ? tags : void 0,
               metadata,
-              scores: mergedScores,
               error: error2,
               origin: baseEvent.event?.origin
+            };
+            collectedResults.push({
+              ...baseResult,
+              scores: mergedScores,
+              ...Object.keys(classifications).length > 0 ? { classifications } : {}
             });
           }
         };
@@ -12256,7 +12407,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         if (!filters.every((f) => evaluateFilter(datum, f))) {
           continue;
         }
-        const trialCount = evaluator.trialCount ?? 1;
+        const trialCount = datum.trialCount ?? evaluator.trialCount ?? 1;
         for (let trialIndex = 0; trialIndex < trialCount; trialIndex++) {
           if (cancelled) {
             break;
@@ -12363,6 +12514,9 @@ function logError2(e, verbose) {
   }
 }
 function accumulateScores(accumulator, scores) {
+  if (!scores) {
+    return;
+  }
   for (const [name, score] of Object.entries(scores)) {
     if (score === null || score === void 0) {
       continue;
@@ -12983,6 +13137,16 @@ function getCallerLocation() {
 function isAsyncIterable3(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
+function hasAsyncIteratorMethods(value) {
+  return value !== null && typeof value === "object" && "next" in value && typeof value.next === "function";
+}
+function isSelfAsyncIterator(value) {
+  try {
+    return value[Symbol.asyncIterator]() === value;
+  } catch {
+    return false;
+  }
+}
 function patchStreamIfNeeded(stream, options) {
   if (!isAsyncIterable3(stream)) {
     return stream;
@@ -12993,6 +13157,98 @@ function patchStreamIfNeeded(stream, options) {
     );
     return stream;
   }
+  if (hasAsyncIteratorMethods(stream) && isSelfAsyncIterator(stream)) {
+    if ("__braintrust_patched_iterator_methods" in stream) {
+      return stream;
+    }
+    try {
+      const originalNext = stream.next.bind(stream);
+      const originalReturn = typeof stream.return === "function" ? stream.return.bind(stream) : null;
+      const originalThrow = typeof stream.throw === "function" ? stream.throw.bind(stream) : null;
+      const chunks = [];
+      let completed = false;
+      stream.next = async (...args) => {
+        try {
+          const result = await originalNext(...args);
+          if (result.done) {
+            if (!completed) {
+              completed = true;
+              try {
+                await options.onComplete(chunks);
+              } catch (error2) {
+                console.error("Error in stream onComplete handler:", error2);
+              }
+            }
+          } else {
+            const chunk = result.value;
+            const shouldCollect = options.shouldCollect ? options.shouldCollect(chunk) : true;
+            if (shouldCollect) {
+              chunks.push(chunk);
+              if (options.onChunk) {
+                try {
+                  await options.onChunk(chunk);
+                } catch (error2) {
+                  console.error("Error in stream onChunk handler:", error2);
+                }
+              }
+            }
+          }
+          return result;
+        } catch (error2) {
+          if (!completed) {
+            completed = true;
+            if (options.onError) {
+              try {
+                await options.onError(
+                  error2 instanceof Error ? error2 : new Error(String(error2)),
+                  chunks
+                );
+              } catch (handlerError) {
+                console.error("Error in stream onError handler:", handlerError);
+              }
+            }
+          }
+          throw error2;
+        }
+      };
+      if (originalReturn) {
+        stream.return = async (...args) => {
+          if (!completed) {
+            completed = true;
+            try {
+              await options.onComplete(chunks);
+            } catch (error2) {
+              console.error("Error in stream onComplete handler:", error2);
+            }
+          }
+          return originalReturn(...args);
+        };
+      }
+      if (originalThrow) {
+        stream.throw = async (...args) => {
+          if (!completed) {
+            completed = true;
+            const rawError = args[0];
+            const error2 = rawError instanceof Error ? rawError : new Error(String(rawError));
+            if (options.onError) {
+              try {
+                await options.onError(error2, chunks);
+              } catch (handlerError) {
+                console.error("Error in stream onError handler:", handlerError);
+              }
+            }
+          }
+          return originalThrow(...args);
+        };
+      }
+      Object.defineProperty(stream, "__braintrust_patched_iterator_methods", {
+        value: true
+      });
+      return stream;
+    } catch (error2) {
+      console.warn("Failed to patch stream iterator methods:", error2);
+    }
+  }
   const originalIteratorFn = stream[Symbol.asyncIterator];
   if ("__braintrust_patched" in originalIteratorFn && originalIteratorFn["__braintrust_patched"]) {
     return stream;
@@ -14549,10 +14805,42 @@ function processImagesInOutput(output) {
   }
   return output;
 }
+function mergeLogprobTokens(existing, incoming) {
+  if (incoming === void 0) {
+    return existing;
+  }
+  if (incoming === null) {
+    return existing ?? null;
+  }
+  if (Array.isArray(existing)) {
+    return [...existing, ...incoming];
+  }
+  return [...incoming];
+}
+function aggregateChatLogprobs(existing, incoming) {
+  if (incoming === void 0) {
+    return existing;
+  }
+  if (incoming === null) {
+    return existing ?? null;
+  }
+  const aggregated = existing && existing !== null ? { ...existing, ...incoming } : { ...incoming };
+  const content = mergeLogprobTokens(existing?.content, incoming.content);
+  if (content !== void 0) {
+    aggregated.content = content;
+  }
+  const refusal = mergeLogprobTokens(existing?.refusal, incoming.refusal);
+  if (refusal !== void 0) {
+    aggregated.refusal = refusal;
+  }
+  return aggregated;
+}
 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;
   let metrics = {};
   for (const chunk of chunks) {
@@ -14562,19 +14850,30 @@ function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
         ...parseMetricsFromUsage(chunk.usage)
       };
     }
-    const delta = chunk.choices?.[0]?.delta;
-    if (!delta) {
+    const choice = chunk.choices?.[0];
+    if (!choice) {
       continue;
     }
-    if (!role && delta.role) {
-      role = delta.role;
+    if (choice.finish_reason) {
+      finish_reason = choice.finish_reason;
+    }
+    logprobs = aggregateChatLogprobs(logprobs, choice.logprobs);
+    const delta = choice.delta;
+    if (!delta) {
+      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) {
@@ -14600,9 +14899,10 @@ function aggregateChatCompletionChunks(chunks, streamResult, endEvent) {
         message: {
           role,
           content,
+          ...refusal !== void 0 ? { refusal } : {},
           tool_calls
         },
-        logprobs: null,
+        logprobs: logprobs ?? null,
         finish_reason
       }
     ]
@@ -14665,13 +14965,21 @@ var anthropicChannels = defineChannels("@anthropic-ai/sdk", {
   betaMessagesCreate: channel({
     channelName: "beta.messages.create",
     kind: "async"
+  }),
+  betaMessagesToolRunner: channel({
+    channelName: "beta.messages.toolRunner",
+    kind: "sync-stream"
   })
 });
 
 // src/instrumentation/plugins/anthropic-plugin.ts
+var ANTHROPIC_TOOL_RUNNER_TOOL_WRAPPED = Symbol.for(
+  "braintrust.anthropic_tool_runner_tool_wrapped"
+);
 var AnthropicPlugin = class extends BasePlugin {
   onEnable() {
     this.subscribeToAnthropicChannels();
+    this.subscribeToAnthropicToolRunner();
   }
   onDisable() {
     this.unsubscribers = unsubscribeAll(this.unsubscribers);
@@ -14726,6 +15034,61 @@ var AnthropicPlugin = class extends BasePlugin {
       })
     );
   }
+  subscribeToAnthropicToolRunner() {
+    const tracingChannel2 = anthropicChannels.betaMessagesToolRunner.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const params = event.arguments[0] ?? {};
+        const span = startSpan({
+          name: "anthropic.beta.messages.toolRunner",
+          spanAttributes: {
+            type: "task" /* TASK */
+          }
+        });
+        span.log({
+          input: processAttachmentsInInput(
+            coalesceInput(params.messages ?? [], params.system)
+          ),
+          metadata: {
+            ...extractAnthropicToolRunnerMetadata(params),
+            provider: "anthropic"
+          }
+        });
+        const state = {
+          aggregatedMetrics: {},
+          finalized: false,
+          iterationCount: 0,
+          seenMessages: /* @__PURE__ */ new WeakSet(),
+          span,
+          startTime: getCurrentUnixTimestamp()
+        };
+        states.set(event, state);
+      },
+      end: (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        patchAnthropicToolRunner({
+          runner: event.result,
+          state
+        });
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (!state || !event.error) {
+          return;
+        }
+        finalizeAnthropicToolRunnerError(state, event.error);
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
 };
 function parseMetricsFromUsage2(usage) {
   if (!usage) {
@@ -14742,39 +15105,378 @@ 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.server_tool_use)) {
+    for (const [name, value] of Object.entries(usage.server_tool_use)) {
+      if (typeof value === "number") {
+        metrics[`server_tool_use_${name}`] = value;
+      }
+    }
+  }
   return metrics;
 }
-function aggregateAnthropicStreamChunks(chunks) {
-  const fallbackTextDeltas = [];
-  const contentBlocks = {};
-  const contentBlockDeltas = {};
-  let metrics = {};
-  let metadata = {};
-  let role;
-  for (const event of chunks) {
-    switch (event?.type) {
-      case "message_start":
-        if (event.message?.usage) {
-          const initialMetrics = parseMetricsFromUsage2(event.message.usage);
-          metrics = { ...metrics, ...initialMetrics };
-        }
-        if (typeof event.message?.role === "string") {
-          role = event.message.role;
-        }
-        break;
-      case "content_block_start":
-        if (event.content_block) {
-          contentBlocks[event.index] = event.content_block;
-          contentBlockDeltas[event.index] = { textDeltas: [], citations: [] };
-        }
-        break;
-      case "content_block_delta": {
-        const acc = contentBlockDeltas[event.index];
-        const delta = event.delta;
-        if (!delta) break;
-        if (delta.type === "text_delta" && "text" in delta) {
-          const text = delta.text;
-          if (text) {
+function extractAnthropicToolRunnerMetadata(params) {
+  const metadata = filterFrom(params, ["messages", "system", "tools"]);
+  const toolNames = extractAnthropicToolNames(params.tools);
+  return {
+    ...metadata,
+    operation: "toolRunner",
+    ...toolNames.length > 0 ? { tool_names: toolNames } : {}
+  };
+}
+function extractAnthropicToolNames(tools) {
+  const toolNames = [];
+  for (const tool of tools) {
+    if (!tool || typeof tool !== "object") {
+      continue;
+    }
+    const toolRecord = tool;
+    if (typeof toolRecord.name === "string") {
+      toolNames.push(toolRecord.name);
+      continue;
+    }
+    if (typeof toolRecord.mcp_server_name === "string") {
+      toolNames.push(toolRecord.mcp_server_name);
+    }
+  }
+  return toolNames;
+}
+function toErrorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function getAnthropicToolRunnerInput(args) {
+  return args.length > 0 ? args[0] : void 0;
+}
+function wrapAnthropicToolRunnerTools(params, state) {
+  if (!Array.isArray(params.tools)) {
+    return;
+  }
+  params.tools = params.tools.map(
+    (tool, index) => wrapAnthropicToolRunnerTool(tool, index, state)
+  );
+}
+function wrapAnthropicToolRunnerTool(tool, index, state) {
+  if (!tool || typeof tool !== "object" || typeof tool.run !== "function" || tool[ANTHROPIC_TOOL_RUNNER_TOOL_WRAPPED]) {
+    return tool;
+  }
+  const toolName = typeof tool.name === "string" ? tool.name : `tool[${index}]`;
+  const originalRun = tool.run;
+  const runDescriptor = Object.getOwnPropertyDescriptor(tool, "run");
+  const wrappedTool = Object.create(
+    Object.getPrototypeOf(tool),
+    Object.getOwnPropertyDescriptors(tool)
+  );
+  Object.defineProperty(wrappedTool, "run", {
+    configurable: runDescriptor?.configurable ?? true,
+    enumerable: runDescriptor?.enumerable ?? true,
+    value: function braintrustAnthropicToolRunnerRun(...args) {
+      return state.span.traced(
+        (span) => {
+          const finalizeSuccess = (result) => {
+            span.log({ output: result });
+            return result;
+          };
+          const finalizeError = (error2) => {
+            span.log({ error: toErrorMessage(error2) });
+            throw error2;
+          };
+          try {
+            const result = Reflect.apply(originalRun, this, args);
+            if (isPromiseLike(result)) {
+              return result.then(finalizeSuccess, finalizeError);
+            }
+            return finalizeSuccess(result);
+          } catch (error2) {
+            return finalizeError(error2);
+          }
+        },
+        {
+          event: {
+            input: getAnthropicToolRunnerInput(args),
+            metadata: {
+              "gen_ai.tool.name": toolName,
+              provider: "anthropic"
+            }
+          },
+          name: `tool: ${toolName}`,
+          spanAttributes: {
+            type: "tool" /* TOOL */
+          }
+        }
+      );
+    },
+    writable: runDescriptor?.writable ?? true
+  });
+  Object.defineProperty(wrappedTool, ANTHROPIC_TOOL_RUNNER_TOOL_WRAPPED, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false
+  });
+  return wrappedTool;
+}
+function getAnthropicToolRunnerParams(runnerRecord) {
+  const params = Reflect.get(runnerRecord, "params");
+  return params && typeof params === "object" ? params : void 0;
+}
+function ensureAnthropicToolRunnerToolsWrapped(runnerRecord, state) {
+  const params = getAnthropicToolRunnerParams(runnerRecord);
+  if (params) {
+    wrapAnthropicToolRunnerTools(params, state);
+  }
+}
+function wrapAnthropicToolRunnerSetMessagesParams(runnerRecord, state) {
+  const setMessagesParams = Reflect.get(runnerRecord, "setMessagesParams");
+  if (typeof setMessagesParams !== "function") {
+    return;
+  }
+  Reflect.set(
+    runnerRecord,
+    "setMessagesParams",
+    function patchedSetMessagesParams(...args) {
+      const result = Reflect.apply(setMessagesParams, this, args);
+      const nextParams = getAnthropicToolRunnerParams(runnerRecord);
+      if (nextParams) {
+        wrapAnthropicToolRunnerTools(nextParams, state);
+      }
+      return result;
+    }
+  );
+}
+function isAnthropicMessage(value) {
+  return !!value && typeof value === "object" && typeof value.role === "string" && Array.isArray(value.content);
+}
+function isAnthropicMessageStream(value) {
+  return !!value && typeof value === "object" && isAsyncIterable3(value) && "finalMessage" in value && typeof value.finalMessage === "function";
+}
+function recordAnthropicToolRunnerMessage(state, message) {
+  if (typeof message !== "object" || message === null) {
+    return;
+  }
+  if (state.seenMessages.has(message)) {
+    state.lastMessage = message;
+    return;
+  }
+  state.seenMessages.add(message);
+  state.lastMessage = message;
+  const parsedMetrics = parseMetricsFromUsage2(message.usage);
+  for (const [key, value] of Object.entries(parsedMetrics)) {
+    if (typeof value === "number") {
+      state.aggregatedMetrics[key] = (state.aggregatedMetrics[key] ?? 0) + value;
+    }
+  }
+}
+function instrumentAnthropicMessageStream(stream, state) {
+  if ("__braintrust_tool_runner_stream_patched" in stream) {
+    return;
+  }
+  if (!Object.isFrozen(stream) && !Object.isSealed(stream)) {
+    patchStreamIfNeeded(stream, {
+      onChunk: () => {
+        if (state.firstTokenTime === void 0) {
+          state.firstTokenTime = getCurrentUnixTimestamp();
+        }
+      },
+      onComplete: () => void 0
+    });
+  }
+  if (typeof stream.finalMessage === "function") {
+    const originalFinalMessage = stream.finalMessage.bind(stream);
+    stream.finalMessage = async () => {
+      const message = await originalFinalMessage();
+      recordAnthropicToolRunnerMessage(state, message);
+      return message;
+    };
+  }
+  Object.defineProperty(stream, "__braintrust_tool_runner_stream_patched", {
+    value: true
+  });
+}
+async function finalizeAnthropicToolRunner(state, finalMessage) {
+  if (state.finalized) {
+    return;
+  }
+  state.finalized = true;
+  const message = finalMessage ?? state.lastMessage;
+  if (message) {
+    recordAnthropicToolRunnerMessage(state, message);
+  }
+  const metrics = finalizeAnthropicTokens({
+    ...state.aggregatedMetrics
+  });
+  if (state.firstTokenTime !== void 0) {
+    metrics.time_to_first_token = state.firstTokenTime - state.startTime;
+  }
+  const metadata = {
+    anthropic_tool_runner_iterations: state.iterationCount
+  };
+  if (message?.stop_reason !== void 0) {
+    metadata.stop_reason = message.stop_reason;
+  }
+  if (message?.stop_sequence !== void 0) {
+    metadata.stop_sequence = message.stop_sequence;
+  }
+  state.span.log({
+    ...message ? { output: { role: message.role, content: message.content } } : {},
+    metadata,
+    metrics: Object.fromEntries(
+      Object.entries(metrics).filter(
+        (entry) => entry[1] !== void 0
+      )
+    )
+  });
+  state.span.end();
+}
+function finalizeAnthropicToolRunnerError(state, error2) {
+  if (state.finalized) {
+    return;
+  }
+  state.finalized = true;
+  state.span.log({
+    error: error2 instanceof Error ? error2.message : String(error2)
+  });
+  state.span.end();
+}
+async function resolveAnthropicToolRunnerFinalMessage(runner) {
+  if (typeof runner.done === "function") {
+    return await runner.done();
+  }
+  if (typeof runner.runUntilDone === "function") {
+    return await runner.runUntilDone();
+  }
+  return void 0;
+}
+function wrapAnthropicToolRunnerPromiseMethod(runnerRecord, methodName, state) {
+  const method = runnerRecord[methodName];
+  if (typeof method !== "function") {
+    return;
+  }
+  runnerRecord[methodName] = async (...args) => {
+    ensureAnthropicToolRunnerToolsWrapped(runnerRecord, state);
+    return await withCurrent(state.span, async () => {
+      try {
+        const message = await method.apply(runnerRecord, args);
+        recordAnthropicToolRunnerMessage(state, message);
+        await finalizeAnthropicToolRunner(state, message);
+        return message;
+      } catch (error2) {
+        finalizeAnthropicToolRunnerError(state, error2);
+        throw error2;
+      }
+    });
+  };
+}
+function patchAnthropicToolRunner(args) {
+  const { runner, state } = args;
+  if (!runner || typeof runner !== "object") {
+    void finalizeAnthropicToolRunner(state);
+    return;
+  }
+  const runnerRecord = runner;
+  if ("__braintrust_tool_runner_patched" in runnerRecord) {
+    return;
+  }
+  ensureAnthropicToolRunnerToolsWrapped(runnerRecord, state);
+  wrapAnthropicToolRunnerSetMessagesParams(runnerRecord, state);
+  wrapAnthropicToolRunnerPromiseMethod(runnerRecord, "done", state);
+  wrapAnthropicToolRunnerPromiseMethod(runnerRecord, "runUntilDone", state);
+  if (!isAsyncIterable3(runnerRecord)) {
+    Object.defineProperty(runnerRecord, "__braintrust_tool_runner_patched", {
+      value: true
+    });
+    return;
+  }
+  const originalIterator = runnerRecord[Symbol.asyncIterator].bind(runnerRecord);
+  runnerRecord[Symbol.asyncIterator] = function() {
+    const iterator = originalIterator();
+    return {
+      async next(value) {
+        try {
+          ensureAnthropicToolRunnerToolsWrapped(runnerRecord, state);
+          const result = await withCurrent(
+            state.span,
+            () => value === void 0 ? iterator.next() : iterator.next(value)
+          );
+          if (result.done) {
+            const finalMessage = await resolveAnthropicToolRunnerFinalMessage(runner);
+            await finalizeAnthropicToolRunner(state, finalMessage);
+            return result;
+          }
+          state.iterationCount += 1;
+          if (isAnthropicMessage(result.value)) {
+            if (state.firstTokenTime === void 0) {
+              state.firstTokenTime = getCurrentUnixTimestamp();
+            }
+            recordAnthropicToolRunnerMessage(state, result.value);
+          } else if (isAnthropicMessageStream(result.value)) {
+            instrumentAnthropicMessageStream(result.value, state);
+          }
+          return result;
+        } catch (error2) {
+          finalizeAnthropicToolRunnerError(state, error2);
+          throw error2;
+        }
+      },
+      async return(value) {
+        try {
+          ensureAnthropicToolRunnerToolsWrapped(runnerRecord, state);
+          const result = typeof iterator.return === "function" ? await withCurrent(state.span, () => iterator.return(value)) : { done: true, value };
+          const finalMessage = await resolveAnthropicToolRunnerFinalMessage(
+            runner
+          ).catch(() => void 0);
+          await finalizeAnthropicToolRunner(state, finalMessage);
+          return result;
+        } catch (error2) {
+          finalizeAnthropicToolRunnerError(state, error2);
+          throw error2;
+        }
+      },
+      async throw(error2) {
+        finalizeAnthropicToolRunnerError(state, error2);
+        if (typeof iterator.throw === "function") {
+          return await withCurrent(state.span, () => iterator.throw(error2));
+        }
+        throw error2;
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  };
+  Object.defineProperty(runnerRecord, "__braintrust_tool_runner_patched", {
+    value: true
+  });
+}
+function aggregateAnthropicStreamChunks(chunks) {
+  const fallbackTextDeltas = [];
+  const contentBlocks = {};
+  const contentBlockDeltas = {};
+  let metrics = {};
+  let metadata = {};
+  let role;
+  for (const event of chunks) {
+    switch (event?.type) {
+      case "message_start":
+        if (event.message?.usage) {
+          const initialMetrics = parseMetricsFromUsage2(event.message.usage);
+          metrics = { ...metrics, ...initialMetrics };
+        }
+        if (typeof event.message?.role === "string") {
+          role = event.message.role;
+        }
+        break;
+      case "content_block_start":
+        if (event.content_block) {
+          contentBlocks[event.index] = event.content_block;
+          contentBlockDeltas[event.index] = { textDeltas: [], citations: [] };
+        }
+        break;
+      case "content_block_delta": {
+        const acc = contentBlockDeltas[event.index];
+        const delta = event.delta;
+        if (!delta) break;
+        if (delta.type === "text_delta" && "text" in delta) {
+          const text = delta.text;
+          if (text) {
             if (acc !== void 0) {
               acc.textDeltas.push(text);
             } else {
@@ -14852,15 +15554,24 @@ function finalizeContentBlock(index, contentBlocks, contentBlockDeltas, fallback
   }
   const acc = contentBlockDeltas[index];
   const text = acc?.textDeltas.join("") ?? "";
-  if (isToolUseContentBlock(contentBlock)) {
+  if (isToolUseLikeContentBlock(contentBlock)) {
     if (!text) {
       return;
     }
     try {
-      contentBlocks[index] = {
-        ...contentBlock,
-        input: JSON.parse(text)
+      const parsedInput = JSON.parse(text);
+      if (!isObject(parsedInput)) {
+        fallbackTextDeltas.push(text);
+        delete contentBlocks[index];
+        return;
+      }
+      const parsedToolUseBlock = {
+        type: contentBlock.type,
+        id: contentBlock.id,
+        name: contentBlock.name,
+        input: parsedInput
       };
+      contentBlocks[index] = parsedToolUseBlock;
     } catch {
       fallbackTextDeltas.push(text);
       delete contentBlocks[index];
@@ -14894,8 +15605,8 @@ function finalizeContentBlock(index, contentBlocks, contentBlockDeltas, fallback
 function isTextContentBlock(contentBlock) {
   return contentBlock.type === "text";
 }
-function isToolUseContentBlock(contentBlock) {
-  return contentBlock.type === "tool_use";
+function isToolUseLikeContentBlock(contentBlock) {
+  return (contentBlock.type === "tool_use" || contentBlock.type === "server_tool_use") && typeof contentBlock.id === "string" && typeof contentBlock.name === "string" && isObject(contentBlock.input);
 }
 function isThinkingContentBlock(contentBlock) {
   return contentBlock.type === "thinking";
@@ -15093,6 +15804,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "embedMany",
     kind: "async"
   }),
+  rerank: channel({
+    channelName: "rerank",
+    kind: "async"
+  }),
   agentGenerate: channel({
     channelName: "Agent.generate",
     kind: "async"
@@ -15152,7 +15867,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.generateText, {
         name: "generateText",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
@@ -15168,7 +15883,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.streamText, {
         name: "streamText",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
@@ -15188,7 +15903,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceSyncStreamChannel(aiSDKChannels.streamTextSync, {
         name: "streamText",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
           defaultDenyOutputPaths: denyOutputPaths,
@@ -15202,7 +15917,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.generateObject, {
         name: "generateObject",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
@@ -15218,7 +15933,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.streamObject, {
         name: "streamObject",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
@@ -15238,7 +15953,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceSyncStreamChannel(aiSDKChannels.streamObjectSync, {
         name: "streamObject",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
           defaultDenyOutputPaths: denyOutputPaths,
@@ -15252,7 +15967,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceAsyncChannel(aiSDKChannels.embed, {
         name: "embed",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event) => prepareAISDKEmbedInput(params, event.self),
         extractOutput: (result, endEvent) => processAISDKEmbeddingOutput(
           result,
@@ -15264,7 +15979,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceAsyncChannel(aiSDKChannels.embedMany, {
         name: "embedMany",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event) => prepareAISDKEmbedInput(params, event.self),
         extractOutput: (result, endEvent) => processAISDKEmbeddingOutput(
           result,
@@ -15273,10 +15988,22 @@ var AISDKPlugin = class extends BasePlugin {
         extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent)
       })
     );
+    this.unsubscribers.push(
+      traceAsyncChannel(aiSDKChannels.rerank, {
+        name: "rerank",
+        type: "function" /* FUNCTION */,
+        extractInput: ([params], event) => prepareAISDKRerankInput(params, event.self),
+        extractOutput: (result, endEvent) => processAISDKRerankOutput(
+          result,
+          resolveDenyOutputPaths(endEvent, denyOutputPaths)
+        ),
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent)
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.agentGenerate, {
         name: "Agent.generate",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
@@ -15292,7 +16019,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.agentStream, {
         name: "Agent.stream",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
@@ -15312,7 +16039,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceSyncStreamChannel(aiSDKChannels.agentStreamSync, {
         name: "Agent.stream",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
           defaultDenyOutputPaths: denyOutputPaths,
@@ -15326,7 +16053,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.toolLoopAgentGenerate, {
         name: "ToolLoopAgent.generate",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
@@ -15342,7 +16069,7 @@ var AISDKPlugin = class extends BasePlugin {
     this.unsubscribers.push(
       traceStreamingChannel(aiSDKChannels.toolLoopAgentStream, {
         name: "ToolLoopAgent.stream",
-        type: "llm" /* LLM */,
+        type: "function" /* FUNCTION */,
         extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
@@ -15692,6 +16419,16 @@ function prepareAISDKEmbedInput(params, self) {
     metadata: extractMetadataFromEmbedParams(params, self)
   };
 }
+function prepareAISDKRerankInput(params, self) {
+  const { documents, query } = params;
+  return {
+    input: {
+      documents,
+      query
+    },
+    metadata: extractMetadataFromRerankParams(params, self)
+  };
+}
 function extractTopLevelAISDKMetrics(result, event, startTime) {
   const metrics = hasModelChildTracing(event) ? {} : extractTokenMetrics(result);
   if (startTime) {
@@ -15737,6 +16474,16 @@ function extractMetadataFromCallParams(params, self) {
 function extractMetadataFromEmbedParams(params, self) {
   return extractBaseMetadata(params.model, self);
 }
+function extractMetadataFromRerankParams(params, self) {
+  const metadata = extractBaseMetadata(params.model, self);
+  if (typeof params.topN === "number") {
+    metadata.topN = params.topN;
+  }
+  if (Array.isArray(params.documents)) {
+    metadata.document_count = params.documents.length;
+  }
+  return metadata;
+}
 function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiSDK) {
   const cleanup = [];
   const patchedModels = /* @__PURE__ */ new WeakSet();
@@ -16284,6 +17031,22 @@ function processAISDKEmbeddingOutput(output, denyOutputPaths) {
   }
   return normalizeAISDKLoggedOutput(omit(summarized, denyOutputPaths));
 }
+function processAISDKRerankOutput(output, _denyOutputPaths) {
+  if (!output || typeof output !== "object") {
+    return output;
+  }
+  const ranking = safeSerializableFieldRead(output, "ranking");
+  if (Array.isArray(ranking)) {
+    return ranking.slice(0, 100).map((item) => {
+      const entry = item && typeof item === "object" ? item : void 0;
+      return {
+        index: typeof entry?.originalIndex === "number" ? entry.originalIndex : void 0,
+        relevance_score: typeof entry?.score === "number" ? entry.score : void 0
+      };
+    });
+  }
+  return void 0;
+}
 function extractTokenMetrics(result) {
   const metrics = {};
   let usage;
@@ -16326,12 +17089,80 @@ function extractTokenMetrics(result) {
   if (totalTokens !== void 0) {
     metrics.tokens = totalTokens;
   }
+  const promptCachedTokens = firstNumber(
+    usage.inputTokens?.cacheRead,
+    usage.inputTokenDetails?.cacheReadTokens,
+    usage.cachedInputTokens,
+    usage.promptCachedTokens,
+    usage.prompt_cached_tokens
+  );
+  if (promptCachedTokens !== void 0) {
+    metrics.prompt_cached_tokens = promptCachedTokens;
+  }
+  const promptCacheCreationTokens = firstNumber(
+    usage.inputTokens?.cacheWrite,
+    usage.inputTokenDetails?.cacheWriteTokens,
+    usage.promptCacheCreationTokens,
+    usage.prompt_cache_creation_tokens,
+    extractAnthropicCacheCreationTokens(result)
+  );
+  if (promptCacheCreationTokens !== void 0) {
+    metrics.prompt_cache_creation_tokens = promptCacheCreationTokens;
+  }
+  const promptReasoningTokens = firstNumber(
+    usage.promptReasoningTokens,
+    usage.prompt_reasoning_tokens
+  );
+  if (promptReasoningTokens !== void 0) {
+    metrics.prompt_reasoning_tokens = promptReasoningTokens;
+  }
+  const completionCachedTokens = firstNumber(
+    usage.completionCachedTokens,
+    usage.completion_cached_tokens
+  );
+  if (completionCachedTokens !== void 0) {
+    metrics.completion_cached_tokens = completionCachedTokens;
+  }
+  const reasoningTokenCount = firstNumber(
+    usage.outputTokens?.reasoning,
+    usage.reasoningTokens,
+    usage.completionReasoningTokens,
+    usage.completion_reasoning_tokens,
+    usage.reasoning_tokens,
+    usage.thinkingTokens,
+    usage.thinking_tokens
+  );
+  if (reasoningTokenCount !== void 0) {
+    metrics.completion_reasoning_tokens = reasoningTokenCount;
+    metrics.reasoning_tokens = reasoningTokenCount;
+  }
+  const completionAudioTokens = firstNumber(
+    usage.completionAudioTokens,
+    usage.completion_audio_tokens
+  );
+  if (completionAudioTokens !== void 0) {
+    metrics.completion_audio_tokens = completionAudioTokens;
+  }
   const cost = extractCostFromResult(result);
   if (cost !== void 0) {
     metrics.estimated_cost = cost;
   }
   return metrics;
 }
+function extractAnthropicCacheCreationTokens(result) {
+  const providerMetadata = safeSerializableFieldRead(
+    result,
+    "providerMetadata"
+  );
+  const anthropicMetadata = providerMetadata?.anthropic;
+  if (!anthropicMetadata) {
+    return void 0;
+  }
+  return firstNumber(
+    anthropicMetadata.cacheCreationInputTokens,
+    anthropicMetadata.usage?.cache_creation_input_tokens
+  );
+}
 function safeResultFieldRead(result, field) {
   return safeSerializableFieldRead(result, field);
 }
@@ -16448,14 +17279,11 @@ function extractSerializableOutputFields(output) {
     ...extractGetterValues(output)
   };
 }
-function isPromiseLike(value) {
-  return value != null && typeof value === "object" && typeof value.then === "function";
-}
 function isSerializableOutputValue(value) {
   if (typeof value === "function") {
     return false;
   }
-  if (value && typeof value === "object" && typeof value.then === "function") {
+  if (isPromiseLike(value)) {
     return false;
   }
   if (value && typeof value === "object" && typeof value.getReader === "function") {
@@ -16775,12 +17603,9 @@ function bindClaudeLocalToolContextToAsyncIterable(result, localToolContext) {
 var LOCAL_TOOL_HANDLER_WRAPPED = Symbol.for(
   "braintrust.claude_agent_sdk.local_tool_handler_wrapped"
 );
-function toErrorMessage(error2) {
+function toErrorMessage2(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
-function isPromiseLike2(value) {
-  return value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
-}
 function getToolUseIdFromExtra(extra) {
   if (!extra || typeof extra !== "object" || !("_meta" in extra)) {
     return void 0;
@@ -16827,14 +17652,14 @@ function wrapLocalClaudeToolHandler(handler, getMetadata) {
         return result;
       };
       const finalizeError = (error2) => {
-        span.log({ error: toErrorMessage(error2) });
+        span.log({ error: toErrorMessage2(error2) });
         span.end();
         throw error2;
       };
       return withCurrent(span, () => {
         try {
           const result = runHandler();
-          if (isPromiseLike2(result)) {
+          if (isPromiseLike(result)) {
             return result.then(finalizeSuccess, finalizeError);
           }
           return finalizeSuccess(result);
@@ -16954,7 +17779,7 @@ var ROOT_LLM_PARENT_KEY = "__root__";
 function llmParentKey(parentToolUseId) {
   return parentToolUseId ?? ROOT_LLM_PARENT_KEY;
 }
-function isSubAgentToolName(toolName) {
+function isSubAgentDelegationToolName(toolName) {
   return toolName === "Agent" || toolName === "Task";
 }
 function filterSerializableOptions(options) {
@@ -16988,19 +17813,87 @@ function getNumberProperty(obj, key) {
   const value = Reflect.get(obj, key);
   return typeof value === "number" ? value : void 0;
 }
-function extractUsageFromMessage(message) {
-  const metrics = {};
-  let usage;
-  if (message.type === "assistant") {
-    usage = message.message?.usage;
-  } else if (message.type === "result") {
-    usage = message.usage;
-  }
-  if (!usage || typeof usage !== "object") {
-    return metrics;
+function getStringProperty(obj, key) {
+  if (!obj || typeof obj !== "object" || !(key in obj)) {
+    return void 0;
   }
-  const inputTokens = getNumberProperty(usage, "input_tokens");
-  if (inputTokens !== void 0) {
+  const value = Reflect.get(obj, key);
+  return typeof value === "string" ? value : void 0;
+}
+function upsertSubAgentDetails(detailsByToolUseId, toolUseId, update) {
+  const existing = detailsByToolUseId.get(toolUseId) ?? {};
+  const merged = {
+    ...existing,
+    ...Object.fromEntries(
+      Object.entries(update).filter(([, value]) => value !== void 0)
+    )
+  };
+  detailsByToolUseId.set(toolUseId, merged);
+  return merged;
+}
+function formatSubAgentSpanName(details) {
+  if (details?.description) {
+    return `Agent: ${details.description}`;
+  }
+  if (details?.agentType) {
+    return `Agent: ${details.agentType}`;
+  }
+  return "Agent: sub-agent";
+}
+function subAgentDetailsToMetadata(details) {
+  if (!details) {
+    return {};
+  }
+  const metadata = {};
+  if (details.agentId) {
+    metadata["claude_agent_sdk.agent_id"] = details.agentId;
+  }
+  if (details.agentType) {
+    metadata["claude_agent_sdk.agent_type"] = details.agentType;
+  }
+  if (details.description) {
+    metadata["claude_agent_sdk.description"] = details.description;
+  }
+  if (details.taskId) {
+    metadata["claude_agent_sdk.task_id"] = details.taskId;
+  }
+  if (details.taskType) {
+    metadata["claude_agent_sdk.task_type"] = details.taskType;
+  }
+  if (details.toolUseId) {
+    metadata["claude_agent_sdk.tool_use_id"] = details.toolUseId;
+  }
+  if (details.workflowName) {
+    metadata["claude_agent_sdk.workflow_name"] = details.workflowName;
+  }
+  return metadata;
+}
+function resolveTaskToolUseId(taskIdToToolUseId, message) {
+  const messageToolUseId = typeof message.tool_use_id === "string" ? message.tool_use_id : void 0;
+  if (messageToolUseId && typeof message.task_id === "string") {
+    taskIdToToolUseId.set(message.task_id, messageToolUseId);
+  }
+  if (messageToolUseId) {
+    return messageToolUseId;
+  }
+  if (typeof message.task_id === "string") {
+    return taskIdToToolUseId.get(message.task_id);
+  }
+  return void 0;
+}
+function extractUsageFromMessage(message) {
+  const metrics = {};
+  let usage;
+  if (message.type === "assistant") {
+    usage = message.message?.usage;
+  } else if (message.type === "result") {
+    usage = message.usage;
+  }
+  if (!usage || typeof usage !== "object") {
+    return metrics;
+  }
+  const inputTokens = getNumberProperty(usage, "input_tokens");
+  if (inputTokens !== void 0) {
     metrics.prompt_tokens = inputTokens;
   }
   const outputTokens = getNumberProperty(usage, "output_tokens");
@@ -17160,7 +18053,7 @@ function prepareLocalToolHandlersInMcpServers(mcpServers) {
   }
   return { hasLocalToolHandlers, localToolHookNames };
 }
-function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, localToolHookNames, skipLocalToolHooks, subAgentSpans, endedSubAgentSpans) {
+function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
   const preToolUse = async (input, toolUseID) => {
     if (input.hook_event_name !== "PreToolUse" || !toolUseID) {
       return {};
@@ -17168,9 +18061,6 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
     if (skipLocalToolHooks && (isLocalToolUse(input.tool_name, mcpServers) || localToolHookNames.has(input.tool_name))) {
       return {};
     }
-    if (isSubAgentToolName(input.tool_name)) {
-      return {};
-    }
     const parsed = parseToolName(input.tool_name);
     const toolSpan = startSpan({
       event: {
@@ -17200,10 +18090,18 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
       return {};
     }
     const subAgentSpan = subAgentSpans.get(toolUseID);
+    const toolSpan = activeToolSpans.get(toolUseID);
     if (subAgentSpan) {
+      if (endedSubAgentSpans.has(toolUseID)) {
+        return {};
+      }
       try {
         const response = input.tool_response;
-        const metadata = {};
+        const metadata = {
+          ...subAgentDetailsToMetadata(
+            subAgentDetailsByToolUseId.get(toolUseID)
+          )
+        };
         if (response?.status) {
           metadata["claude_agent_sdk.status"] = response.status;
         }
@@ -17221,9 +18119,16 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
         subAgentSpan.end();
         endedSubAgentSpans.add(toolUseID);
       }
+      if (toolSpan) {
+        try {
+          toolSpan.log({ output: input.tool_response });
+        } finally {
+          toolSpan.end();
+          activeToolSpans.delete(toolUseID);
+        }
+      }
       return {};
     }
-    const toolSpan = activeToolSpans.get(toolUseID);
     if (!toolSpan) {
       return {};
     }
@@ -17243,16 +18148,43 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
       return {};
     }
     const subAgentSpan = subAgentSpans.get(toolUseID);
+    const toolSpan = activeToolSpans.get(toolUseID);
     if (subAgentSpan) {
+      if (endedSubAgentSpans.has(toolUseID)) {
+        return {};
+      }
       try {
-        subAgentSpan.log({ error: input.error });
+        subAgentSpan.log({
+          error: input.error,
+          metadata: subAgentDetailsToMetadata(
+            subAgentDetailsByToolUseId.get(toolUseID)
+          )
+        });
       } finally {
         subAgentSpan.end();
         endedSubAgentSpans.add(toolUseID);
       }
+      if (toolSpan) {
+        const parsed2 = parseToolName(input.tool_name);
+        try {
+          toolSpan.log({
+            error: input.error,
+            metadata: {
+              "claude_agent_sdk.is_interrupt": input.is_interrupt,
+              "claude_agent_sdk.session_id": input.session_id,
+              "claude_agent_sdk.raw_tool_name": parsed2.rawToolName,
+              "gen_ai.tool.call.id": toolUseID,
+              "gen_ai.tool.name": parsed2.toolName,
+              ...parsed2.mcpServer && { "mcp.server": parsed2.mcpServer }
+            }
+          });
+        } finally {
+          toolSpan.end();
+          activeToolSpans.delete(toolUseID);
+        }
+      }
       return {};
     }
-    const toolSpan = activeToolSpans.get(toolUseID);
     if (!toolSpan) {
       return {};
     }
@@ -17274,15 +18206,84 @@ function createToolTracingHooks(resolveParentSpan, activeToolSpans, mcpServers,
     }
     return {};
   };
-  return { postToolUse, postToolUseFailure, preToolUse };
+  const subagentStart = async (input, toolUseID) => {
+    if (input.hook_event_name !== "SubagentStart" || !toolUseID) {
+      return {};
+    }
+    const details = upsertSubAgentDetails(
+      subAgentDetailsByToolUseId,
+      toolUseID,
+      {
+        agentId: input.agent_id,
+        agentType: input.agent_type,
+        toolUseId: toolUseID
+      }
+    );
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (subAgentSpan && !endedSubAgentSpans.has(toolUseID)) {
+      subAgentSpan.log({
+        metadata: subAgentDetailsToMetadata(details)
+      });
+    }
+    return {};
+  };
+  const subagentStop = async (input, toolUseID) => {
+    if (input.hook_event_name !== "SubagentStop" || !toolUseID) {
+      return {};
+    }
+    const details = upsertSubAgentDetails(
+      subAgentDetailsByToolUseId,
+      toolUseID,
+      {
+        agentId: input.agent_id,
+        agentType: input.agent_type,
+        toolUseId: toolUseID
+      }
+    );
+    const subAgentSpan = subAgentSpans.get(toolUseID);
+    if (!subAgentSpan || endedSubAgentSpans.has(toolUseID)) {
+      return {};
+    }
+    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 {
+      subAgentSpan.log({
+        metadata,
+        output: input.last_assistant_message
+      });
+    } finally {
+      subAgentSpan.end();
+      endedSubAgentSpans.add(toolUseID);
+    }
+    return {};
+  };
+  return {
+    postToolUse,
+    postToolUseFailure,
+    preToolUse,
+    subagentStart,
+    subagentStop
+  };
 }
-function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localToolHookNames, skipLocalToolHooks, subAgentSpans, endedSubAgentSpans) {
-  const { preToolUse, postToolUse, postToolUseFailure } = createToolTracingHooks(
+function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localToolHookNames, skipLocalToolHooks, subAgentDetailsByToolUseId, subAgentSpans, endedSubAgentSpans) {
+  const {
+    preToolUse,
+    postToolUse,
+    postToolUseFailure,
+    subagentStart,
+    subagentStop
+  } = createToolTracingHooks(
     resolveParentSpan,
     activeToolSpans,
     options.mcpServers,
     localToolHookNames,
     skipLocalToolHooks,
+    subAgentDetailsByToolUseId,
     subAgentSpans,
     endedSubAgentSpans
   );
@@ -17304,6 +18305,18 @@ function injectTracingHooks(options, resolveParentSpan, activeToolSpans, localTo
       PreToolUse: [
         ...existingHooks.PreToolUse ?? [],
         { hooks: [preToolUse] }
+      ],
+      SubagentStart: [
+        ...existingHooks.SubagentStart ?? [],
+        {
+          hooks: [subagentStart]
+        }
+      ],
+      SubagentStop: [
+        ...existingHooks.SubagentStop ?? [],
+        {
+          hooks: [subagentStop]
+        }
       ]
     }
   };
@@ -17332,7 +18345,6 @@ async function finalizeCurrentMessageGroup(state) {
     parentSpan,
     existingLlmSpan
   );
-  state.activeLlmSpansByParentToolUse.delete(parentKey);
   if (llmSpanResult) {
     if (parentToolUseId) {
       state.latestLlmParentBySubAgentToolUse.set(
@@ -17346,6 +18358,7 @@ async function finalizeCurrentMessageGroup(state) {
       state.finalResults.push(llmSpanResult.finalMessage);
     }
   }
+  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;
@@ -17362,8 +18375,12 @@ function maybeTrackToolUseContext(state, message) {
       continue;
     }
     state.toolUseToParent.set(block.id, parentToolUseId);
-    if (block.name === "Task" && typeof block.input === "object" && block.input !== null && "subagent_type" in block.input && typeof block.input.subagent_type === "string") {
-      state.pendingSubAgentNames.set(block.id, block.input.subagent_type);
+    if (typeof block.name === "string" && isSubAgentDelegationToolName(block.name) && typeof block.input === "object" && block.input !== null) {
+      upsertSubAgentDetails(state.subAgentDetailsByToolUseId, block.id, {
+        agentType: getStringProperty(block.input, "subagent_type"),
+        description: getStringProperty(block.input, "description"),
+        toolUseId: block.id
+      });
     }
   }
 }
@@ -17376,34 +18393,133 @@ async function maybeStartSubAgentSpan(state, message) {
     return;
   }
   await ensureSubAgentSpan(
-    state.pendingSubAgentNames,
+    state.subAgentDetailsByToolUseId,
     state.span,
+    state.activeToolSpans,
     state.subAgentSpans,
     parentToolUseId
   );
 }
-async function ensureSubAgentSpan(pendingSubAgentNames, rootSpan, subAgentSpans, parentToolUseId) {
+async function ensureSubAgentSpan(subAgentDetailsByToolUseId, rootSpan, activeToolSpans, subAgentSpans, parentToolUseId) {
   const existingSpan = subAgentSpans.get(parentToolUseId);
   if (existingSpan) {
     return existingSpan;
   }
-  const agentName = pendingSubAgentNames.get(parentToolUseId);
-  const spanName = agentName ? `Agent: ${agentName}` : "Agent: sub-agent";
+  const details = subAgentDetailsByToolUseId.get(parentToolUseId);
+  const spanName = formatSubAgentSpanName(details);
+  const parentToolSpan = activeToolSpans.get(parentToolUseId);
+  const parentSpan = parentToolSpan ? await parentToolSpan.export() : await rootSpan.export();
   const subAgentSpan = startSpan({
     event: {
-      metadata: {
-        ...agentName && { "claude_agent_sdk.agent_type": agentName }
-      }
+      metadata: subAgentDetailsToMetadata(details)
     },
     name: spanName,
-    parent: await rootSpan.export(),
+    parent: parentSpan,
     spanAttributes: { type: "task" /* TASK */ }
   });
   subAgentSpans.set(parentToolUseId, subAgentSpan);
   return subAgentSpan;
 }
+async function maybeHandleTaskLifecycleMessage(state, message) {
+  if (message.type !== "system") {
+    return false;
+  }
+  if (message.subtype !== "task_started" && message.subtype !== "task_progress" && message.subtype !== "task_notification") {
+    return false;
+  }
+  const toolUseId = resolveTaskToolUseId(state.taskIdToToolUseId, message);
+  if (!toolUseId) {
+    return true;
+  }
+  const details = upsertSubAgentDetails(
+    state.subAgentDetailsByToolUseId,
+    toolUseId,
+    {
+      description: getStringProperty(message, "description"),
+      taskId: getStringProperty(message, "task_id"),
+      taskType: getStringProperty(message, "task_type"),
+      toolUseId,
+      workflowName: getStringProperty(message, "workflow_name")
+    }
+  );
+  const subAgentSpan = await ensureSubAgentSpan(
+    state.subAgentDetailsByToolUseId,
+    state.span,
+    state.activeToolSpans,
+    state.subAgentSpans,
+    toolUseId
+  );
+  if (state.endedSubAgentSpans.has(toolUseId)) {
+    return true;
+  }
+  const usage = message.usage;
+  const usageTotalTokens = getNumberProperty(usage, "total_tokens");
+  const usageToolUses = getNumberProperty(usage, "tool_uses");
+  const usageDurationMs = getNumberProperty(usage, "duration_ms");
+  const metadata = {
+    ...subAgentDetailsToMetadata(details),
+    "claude_agent_sdk.tool_use_id": toolUseId,
+    ...usageTotalTokens !== void 0 && {
+      "claude_agent_sdk.total_tokens": usageTotalTokens
+    },
+    ...usageToolUses !== void 0 && {
+      "claude_agent_sdk.tool_use_count": usageToolUses
+    },
+    ...usageDurationMs !== void 0 && {
+      "claude_agent_sdk.duration_ms": usageDurationMs
+    }
+  };
+  if (message.subtype === "task_started") {
+    const prompt = getStringProperty(message, "prompt");
+    subAgentSpan.log({
+      input: prompt,
+      metadata
+    });
+    return true;
+  }
+  const summary = getStringProperty(message, "summary");
+  if (summary) {
+    metadata["claude_agent_sdk.summary"] = summary;
+  }
+  if (message.subtype === "task_progress") {
+    const lastToolName = getStringProperty(message, "last_tool_name");
+    if (lastToolName) {
+      metadata["claude_agent_sdk.last_tool_name"] = lastToolName;
+    }
+    subAgentSpan.log({
+      metadata,
+      output: summary
+    });
+    return true;
+  }
+  const status = getStringProperty(message, "status");
+  const outputFile = getStringProperty(message, "output_file");
+  if (status) {
+    metadata["claude_agent_sdk.task_status"] = status;
+  }
+  if (outputFile) {
+    metadata["claude_agent_sdk.output_file"] = outputFile;
+  }
+  const output = summary || outputFile ? {
+    ...summary && { summary },
+    ...outputFile && { output_file: outputFile }
+  } : void 0;
+  try {
+    subAgentSpan.log({
+      metadata,
+      output
+    });
+  } finally {
+    subAgentSpan.end();
+    state.endedSubAgentSpans.add(toolUseId);
+  }
+  return true;
+}
 async function handleStreamMessage(state, message) {
   maybeTrackToolUseContext(state, message);
+  if (await maybeHandleTaskLifecycleMessage(state, message)) {
+    return;
+  }
   await maybeStartSubAgentSpan(state, message);
   const messageId = message.message?.id;
   if (messageId && messageId !== state.currentMessageId) {
@@ -17418,8 +18534,9 @@ async function handleStreamMessage(state, message) {
       let llmParentSpan = await state.span.export();
       if (parentToolUseId) {
         const subAgentSpan = await ensureSubAgentSpan(
-          state.pendingSubAgentNames,
+          state.subAgentDetailsByToolUseId,
           state.span,
+          state.activeToolSpans,
           state.subAgentSpans,
           parentToolUseId
         );
@@ -17499,6 +18616,10 @@ async function finalizeQuerySpan(state) {
       llmSpan.end();
     }
     state.activeLlmSpansByParentToolUse.clear();
+    for (const toolSpan of state.activeToolSpans.values()) {
+      toolSpan.end();
+    }
+    state.activeToolSpans.clear();
     for (const [id, subAgentSpan] of state.subAgentSpans) {
       if (!state.endedSubAgentSpans.has(id)) {
         subAgentSpan.end();
@@ -17572,7 +18693,8 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
         const latestRootLlmParentRef = {
           value: void 0
         };
-        const pendingSubAgentNames = /* @__PURE__ */ new Map();
+        const subAgentDetailsByToolUseId = /* @__PURE__ */ new Map();
+        const taskIdToToolUseId = /* @__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;
@@ -17589,8 +18711,9 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
               return parentLlm;
             }
             const subAgentSpan = await ensureSubAgentSpan(
-              pendingSubAgentNames,
+              subAgentDetailsByToolUseId,
               span,
+              activeToolSpans,
               subAgentSpans,
               parentToolUseId
             );
@@ -17609,6 +18732,7 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           activeToolSpans,
           localToolHookNames,
           skipLocalToolHooks,
+          subAgentDetailsByToolUseId,
           subAgentSpans,
           endedSubAgentSpans
         );
@@ -17626,12 +18750,13 @@ var ClaudeAgentSDKPlugin = class extends BasePlugin {
           finalResults: [],
           options: optionsWithHooks,
           originalPrompt,
-          pendingSubAgentNames,
           processing: Promise.resolve(),
           promptDone,
           promptStarted: () => promptStarted,
           span,
+          subAgentDetailsByToolUseId,
           subAgentSpans,
+          taskIdToToolUseId,
           latestLlmParentBySubAgentToolUse,
           latestRootLlmParentRef,
           toolUseToParent,
@@ -17713,6 +18838,10 @@ var googleGenAIChannels = defineChannels("@google/genai", {
   generateContentStream: channel({
     channelName: "models.generateContentStream",
     kind: "async"
+  }),
+  embedContent: channel({
+    channelName: "models.embedContent",
+    kind: "async"
   })
 });
 
@@ -17739,6 +18868,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
   subscribeToGoogleGenAIChannels() {
     this.subscribeToGenerateContentChannel();
     this.subscribeToGenerateContentStreamChannel();
+    this.subscribeToEmbedContentChannel();
   }
   subscribeToGenerateContentChannel() {
     const tracingChannel2 = googleGenAIChannels.generateContent.tracingChannel();
@@ -17748,8 +18878,8 @@ var GoogleGenAIPlugin = class extends BasePlugin {
       states,
       (event) => {
         const params = event.arguments[0];
-        const input = serializeInput(params);
-        const metadata = extractMetadata(params);
+        const input = serializeGenerateContentInput(params);
+        const metadata = extractGenerateContentMetadata(params);
         const span = startSpan({
           name: "generate_content",
           spanAttributes: {
@@ -17767,8 +18897,8 @@ var GoogleGenAIPlugin = class extends BasePlugin {
       start: (event) => {
         ensureSpanState(states, event, () => {
           const params = event.arguments[0];
-          const input = serializeInput(params);
-          const metadata = extractMetadata(params);
+          const input = serializeGenerateContentInput(params);
+          const metadata = extractGenerateContentMetadata(params);
           const span = startSpan({
             name: "generate_content",
             spanAttributes: {
@@ -17788,7 +18918,9 @@ var GoogleGenAIPlugin = class extends BasePlugin {
           return;
         }
         try {
+          const responseMetadata = extractResponseMetadata(event.result);
           spanState.span.log({
+            ...responseMetadata ? { metadata: responseMetadata } : {},
             metrics: cleanMetrics(
               extractGenerateContentMetrics(
                 event.result,
@@ -17818,8 +18950,8 @@ var GoogleGenAIPlugin = class extends BasePlugin {
       start: (event) => {
         const streamEvent = event;
         const params = event.arguments[0];
-        streamEvent.googleGenAIInput = serializeInput(params);
-        streamEvent.googleGenAIMetadata = extractMetadata(params);
+        streamEvent.googleGenAIInput = serializeGenerateContentInput(params);
+        streamEvent.googleGenAIMetadata = extractGenerateContentMetadata(params);
         streamEvent.googleGenAIStartTime = getCurrentUnixTimestamp();
       },
       asyncEnd: (event) => {
@@ -17839,6 +18971,76 @@ var GoogleGenAIPlugin = class extends BasePlugin {
       tracingChannel2.unsubscribe(handlers);
     });
   }
+  subscribeToEmbedContentChannel() {
+    const tracingChannel2 = googleGenAIChannels.embedContent.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
+      tracingChannel2,
+      states,
+      (event) => {
+        const params = event.arguments[0];
+        const input = serializeEmbedContentInput(params);
+        const metadata = extractEmbedContentMetadata(params);
+        const span = startSpan({
+          name: "embed_content",
+          spanAttributes: {
+            type: "llm" /* LLM */
+          },
+          event: createWrapperParityEvent({ input, metadata })
+        });
+        return {
+          span,
+          startTime: getCurrentUnixTimestamp()
+        };
+      }
+    );
+    const handlers = {
+      start: (event) => {
+        ensureSpanState(states, event, () => {
+          const params = event.arguments[0];
+          const input = serializeEmbedContentInput(params);
+          const metadata = extractEmbedContentMetadata(params);
+          const span = startSpan({
+            name: "embed_content",
+            spanAttributes: {
+              type: "llm" /* LLM */
+            },
+            event: createWrapperParityEvent({ input, metadata })
+          });
+          return {
+            span,
+            startTime: getCurrentUnixTimestamp()
+          };
+        });
+      },
+      asyncEnd: (event) => {
+        const spanState = states.get(event);
+        if (!spanState) {
+          return;
+        }
+        try {
+          const output = summarizeEmbedContentOutput(event.result);
+          spanState.span.log({
+            ...output ? { output } : {},
+            metrics: cleanMetrics(
+              extractEmbedContentMetrics(event.result, spanState.startTime)
+            )
+          });
+        } finally {
+          spanState.span.end();
+          states.delete(event);
+        }
+      },
+      error: (event) => {
+        logErrorAndEndSpan(states, event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
 };
 function ensureSpanState(states, event, create) {
   const existing = states.get(event);
@@ -17912,7 +19114,11 @@ function patchGoogleGenAIStreamingResult(args) {
     finalized = true;
     if (options.result) {
       const { end, ...metricsWithoutEnd } = options.result.metrics;
+      const responseMetadata = extractResponseMetadata(
+        options.result.aggregated
+      );
       span.log({
+        ...responseMetadata ? { metadata: responseMetadata } : {},
         metrics: cleanMetrics(metricsWithoutEnd),
         output: options.result.aggregated
       });
@@ -18015,26 +19221,35 @@ function patchGoogleGenAIStreamingResult(args) {
   patchIterator(result);
   return true;
 }
-function serializeInput(params) {
+function serializeGenerateContentInput(params) {
   const input = {
     model: params.model,
-    contents: serializeContents(params.contents)
+    contents: serializeContentCollection(params.contents)
   };
-  if (params.config) {
-    const config3 = tryToDict(params.config);
-    if (config3) {
-      const filteredConfig = {};
-      Object.keys(config3).forEach((key) => {
-        if (key !== "tools") {
-          filteredConfig[key] = config3[key];
-        }
-      });
-      input.config = filteredConfig;
-    }
+  const config3 = params.config ? tryToDict(params.config) : null;
+  if (config3) {
+    const filteredConfig = {};
+    Object.keys(config3).forEach((key) => {
+      if (key !== "tools") {
+        filteredConfig[key] = config3[key];
+      }
+    });
+    input.config = filteredConfig;
+  }
+  return input;
+}
+function serializeEmbedContentInput(params) {
+  const input = {
+    model: params.model,
+    contents: serializeContentCollection(params.contents)
+  };
+  const config3 = params.config ? tryToDict(params.config) : null;
+  if (config3) {
+    input.config = config3;
   }
   return input;
 }
-function serializeContents(contents) {
+function serializeContentCollection(contents) {
   if (contents === null || contents === void 0) {
     return null;
   }
@@ -18086,22 +19301,26 @@ function serializePart(part) {
   }
   return part;
 }
-function serializeTools(params) {
-  if (!params.config?.tools) {
+function serializeGenerateContentTools(params) {
+  const config3 = params.config ? tryToDict(params.config) : null;
+  const tools = config3?.tools;
+  if (!Array.isArray(tools)) {
     return null;
   }
   try {
-    return params.config.tools.map((tool) => {
-      if (typeof tool === "object" && tool.functionDeclarations) {
-        return tool;
+    const serializedTools = [];
+    for (const tool of tools) {
+      const toolDict = tryToDict(tool);
+      if (toolDict) {
+        serializedTools.push(toolDict);
       }
-      return tool;
-    });
+    }
+    return serializedTools.length > 0 ? serializedTools : null;
   } catch {
     return null;
   }
 }
-function extractMetadata(params) {
+function extractGenerateContentMetadata(params) {
   const metadata = {};
   if (params.model) {
     metadata.model = params.model;
@@ -18116,12 +19335,25 @@ function extractMetadata(params) {
       });
     }
   }
-  const tools = serializeTools(params);
+  const tools = serializeGenerateContentTools(params);
   if (tools) {
     metadata.tools = tools;
   }
   return metadata;
 }
+function extractEmbedContentMetadata(params) {
+  const metadata = {};
+  if (params.model) {
+    metadata.model = params.model;
+  }
+  const config3 = params.config ? tryToDict(params.config) : null;
+  if (config3) {
+    Object.keys(config3).forEach((key) => {
+      metadata[key] = config3[key];
+    });
+  }
+  return metadata;
+}
 function extractGenerateContentMetrics(response, startTime) {
   const metrics = {};
   if (startTime !== void 0) {
@@ -18135,25 +19367,88 @@ function extractGenerateContentMetrics(response, startTime) {
   }
   return metrics;
 }
-function populateUsageMetrics(metrics, usage) {
-  if (usage.promptTokenCount !== void 0) {
-    metrics.prompt_tokens = usage.promptTokenCount;
+function extractEmbedContentMetrics(response, startTime) {
+  const metrics = {};
+  if (startTime !== void 0) {
+    const end = getCurrentUnixTimestamp();
+    metrics.start = startTime;
+    metrics.end = end;
+    metrics.duration = end - startTime;
   }
-  if (usage.candidatesTokenCount !== void 0) {
-    metrics.completion_tokens = usage.candidatesTokenCount;
+  if (response?.usageMetadata) {
+    populateUsageMetrics(metrics, response.usageMetadata);
   }
-  if (usage.totalTokenCount !== void 0) {
-    metrics.tokens = usage.totalTokenCount;
+  const embeddingTokenCount = extractEmbedPromptTokenCount(response);
+  if (embeddingTokenCount !== void 0) {
+    metrics.prompt_tokens = embeddingTokenCount;
+    metrics.tokens = embeddingTokenCount;
   }
-  if (usage.cachedContentTokenCount !== void 0) {
-    metrics.prompt_cached_tokens = usage.cachedContentTokenCount;
+  return metrics;
+}
+function extractEmbedPromptTokenCount(response) {
+  if (!response) {
+    return void 0;
   }
-  if (usage.thoughtsTokenCount !== void 0) {
-    metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
+  const usagePromptTokens = response.usageMetadata?.promptTokenCount;
+  if (typeof usagePromptTokens === "number" && Number.isFinite(usagePromptTokens)) {
+    return usagePromptTokens;
   }
-}
-function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
-  const end = getCurrentUnixTimestamp();
+  const usageTotalTokens = response.usageMetadata?.totalTokenCount;
+  if (typeof usageTotalTokens === "number" && Number.isFinite(usageTotalTokens)) {
+    return usageTotalTokens;
+  }
+  const embeddings = Array.isArray(response.embeddings) ? response.embeddings : response.embedding ? [response.embedding] : [];
+  if (embeddings.length === 0) {
+    return void 0;
+  }
+  let total = 0;
+  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;
+      sawAny = true;
+    }
+  }
+  return sawAny ? total : void 0;
+}
+function summarizeEmbedContentOutput(response) {
+  if (!response) {
+    return void 0;
+  }
+  const embeddings = Array.isArray(response.embeddings) ? response.embeddings : response.embedding ? [response.embedding] : [];
+  if (embeddings.length === 0) {
+    return void 0;
+  }
+  const firstValues = embeddings[0]?.values;
+  if (!Array.isArray(firstValues)) {
+    return void 0;
+  }
+  return {
+    embedding_count: embeddings.length,
+    embedding_length: firstValues.length
+  };
+}
+function populateUsageMetrics(metrics, usage) {
+  if (usage.promptTokenCount !== void 0) {
+    metrics.prompt_tokens = usage.promptTokenCount;
+  }
+  if (usage.candidatesTokenCount !== void 0) {
+    metrics.completion_tokens = usage.candidatesTokenCount;
+  }
+  if (usage.totalTokenCount !== void 0) {
+    metrics.tokens = usage.totalTokenCount;
+  }
+  if (usage.cachedContentTokenCount !== void 0) {
+    metrics.prompt_cached_tokens = usage.cachedContentTokenCount;
+  }
+  if (usage.thoughtsTokenCount !== void 0) {
+    metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
+  }
+}
+function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
+  const end = getCurrentUnixTimestamp();
   const metrics = {
     start: startTime,
     end,
@@ -18168,6 +19463,7 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
   let text = "";
   let thoughtText = "";
   const otherParts = [];
+  let groundingMetadata = void 0;
   let usageMetadata = null;
   let lastResponse = null;
   for (const chunk of chunks) {
@@ -18175,6 +19471,9 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
     if (chunk.usageMetadata) {
       usageMetadata = chunk.usageMetadata;
     }
+    if (chunk.groundingMetadata !== void 0) {
+      groundingMetadata = chunk.groundingMetadata;
+    }
     if (chunk.candidates && Array.isArray(chunk.candidates)) {
       for (const candidate of chunk.candidates) {
         if (candidate.content?.parts) {
@@ -18220,6 +19519,12 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
       if (candidate.finishReason !== void 0) {
         candidateDict.finishReason = candidate.finishReason;
       }
+      if (candidate.groundingMetadata !== void 0) {
+        candidateDict.groundingMetadata = candidate.groundingMetadata;
+        if (groundingMetadata === void 0) {
+          groundingMetadata = candidate.groundingMetadata;
+        }
+      }
       if (candidate.safetyRatings) {
         candidateDict.safetyRatings = candidate.safetyRatings;
       }
@@ -18231,6 +19536,9 @@ function aggregateGenerateContentChunks(chunks, startTime, firstTokenTime) {
     aggregated.usageMetadata = usageMetadata;
     populateUsageMetrics(metrics, usageMetadata);
   }
+  if (groundingMetadata !== void 0) {
+    aggregated.groundingMetadata = groundingMetadata;
+  }
   if (text) {
     aggregated.text = text;
   }
@@ -18245,6 +19553,31 @@ function cleanMetrics(metrics) {
   }
   return cleaned;
 }
+function extractResponseMetadata(response) {
+  const responseDict = tryToDict(response);
+  if (!responseDict) {
+    return void 0;
+  }
+  const metadata = {};
+  const responseGroundingMetadata = responseDict.groundingMetadata;
+  const candidateGroundingMetadata = [];
+  if (Array.isArray(responseDict.candidates)) {
+    for (const candidate of responseDict.candidates) {
+      const candidateDict = tryToDict(candidate);
+      if (candidateDict?.groundingMetadata !== void 0) {
+        candidateGroundingMetadata.push(candidateDict.groundingMetadata);
+      }
+    }
+  }
+  if (responseGroundingMetadata !== void 0) {
+    metadata.groundingMetadata = responseGroundingMetadata;
+  } else if (candidateGroundingMetadata.length === 1) {
+    [metadata.groundingMetadata] = candidateGroundingMetadata;
+  } else if (candidateGroundingMetadata.length > 1) {
+    metadata.groundingMetadata = candidateGroundingMetadata;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
 function tryToDict(obj) {
   if (obj === null || obj === void 0) {
     return null;
@@ -18259,6 +19592,385 @@ function tryToDict(obj) {
   return null;
 }
 
+// src/instrumentation/plugins/huggingface-channels.ts
+var huggingFaceChannels = defineChannels("@huggingface/inference", {
+  chatCompletion: channel({
+    channelName: "chatCompletion",
+    kind: "async"
+  }),
+  chatCompletionStream: channel({
+    channelName: "chatCompletionStream",
+    kind: "sync-stream"
+  }),
+  textGeneration: channel({
+    channelName: "textGeneration",
+    kind: "async"
+  }),
+  textGenerationStream: channel({
+    channelName: "textGenerationStream",
+    kind: "sync-stream"
+  }),
+  featureExtraction: channel({
+    channelName: "featureExtraction",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/huggingface-plugin.ts
+var REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "dimensions",
+  "encoding_format",
+  "endpointUrl",
+  "max_tokens",
+  "model",
+  "provider",
+  "seed",
+  "stop",
+  "stream",
+  "temperature",
+  "top_p"
+]);
+var RESPONSE_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "created",
+  "id",
+  "model",
+  "object"
+]);
+var HuggingFacePlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(
+      traceAsyncChannel(huggingFaceChannels.chatCompletion, {
+        name: "huggingface.chat_completion",
+        type: "llm" /* LLM */,
+        extractInput: extractChatInputWithMetadata,
+        extractOutput: (result) => result?.choices,
+        extractMetadata: (result) => extractResponseMetadata2(result),
+        extractMetrics: (result) => parseMetricsFromUsage(result?.usage)
+      }),
+      traceSyncStreamChannel(huggingFaceChannels.chatCompletionStream, {
+        name: "huggingface.chat_completion_stream",
+        type: "llm" /* LLM */,
+        extractInput: extractChatInputWithMetadata,
+        patchResult: ({ result, span, startTime }) => patchChatCompletionStream({
+          result,
+          span,
+          startTime
+        })
+      }),
+      traceAsyncChannel(huggingFaceChannels.textGeneration, {
+        name: "huggingface.text_generation",
+        type: "llm" /* LLM */,
+        extractInput: extractTextGenerationInputWithMetadata,
+        extractOutput: (result) => isObject(result) ? { generated_text: result.generated_text } : result,
+        extractMetadata: extractTextGenerationMetadata,
+        extractMetrics: (result) => extractTextGenerationMetrics(result?.details ?? null)
+      }),
+      traceSyncStreamChannel(huggingFaceChannels.textGenerationStream, {
+        name: "huggingface.text_generation_stream",
+        type: "llm" /* LLM */,
+        extractInput: extractTextGenerationInputWithMetadata,
+        patchResult: ({ result, span, startTime }) => patchTextGenerationStream({
+          result,
+          span,
+          startTime
+        })
+      }),
+      traceAsyncChannel(huggingFaceChannels.featureExtraction, {
+        name: "huggingface.feature_extraction",
+        type: "llm" /* LLM */,
+        extractInput: extractFeatureExtractionInputWithMetadata,
+        extractOutput: summarizeFeatureExtractionOutput,
+        extractMetrics: () => ({})
+      })
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function addProviderMetadata(metadata) {
+  return {
+    ...metadata,
+    provider: metadata.provider ?? "huggingface"
+  };
+}
+function normalizeArgs(args) {
+  if (Array.isArray(args)) {
+    return args;
+  }
+  if (isArrayLike2(args)) {
+    return Array.from(args);
+  }
+  return [args];
+}
+function isArrayLike2(value) {
+  return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
+}
+function getFirstObjectArg(args) {
+  const firstObjectArg = normalizeArgs(args).find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function pickRequestMetadata(params) {
+  if (!params) {
+    return addProviderMetadata({});
+  }
+  const metadata = {};
+  for (const key of REQUEST_METADATA_ALLOWLIST) {
+    const value = params[key];
+    if (value !== void 0) {
+      metadata[key] = value;
+    }
+  }
+  if (isObject(params.parameters)) {
+    metadata.parameters = params.parameters;
+  }
+  return addProviderMetadata(metadata);
+}
+function extractChatInputWithMetadata(args) {
+  const params = getFirstObjectArg(args);
+  const { messages, ...rawMetadata } = params ?? {};
+  return {
+    input: messages,
+    metadata: pickRequestMetadata(rawMetadata)
+  };
+}
+function extractTextGenerationInputWithMetadata(args) {
+  const params = getFirstObjectArg(args);
+  const { inputs, ...rawMetadata } = params ?? {};
+  return {
+    input: inputs,
+    metadata: pickRequestMetadata(rawMetadata)
+  };
+}
+function extractFeatureExtractionInputWithMetadata(args) {
+  const params = getFirstObjectArg(args);
+  const { inputs, ...rawMetadata } = params ?? {};
+  return {
+    input: inputs,
+    metadata: pickRequestMetadata(rawMetadata)
+  };
+}
+function extractResponseMetadata2(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const metadata = {};
+  for (const key of RESPONSE_METADATA_ALLOWLIST) {
+    const value = result[key];
+    if (value !== void 0) {
+      metadata[key] = value;
+    }
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function extractTextGenerationMetrics(details) {
+  if (!isObject(details)) {
+    return {};
+  }
+  const promptTokens = Array.isArray(details.prefill) ? details.prefill.length : void 0;
+  const completionTokens = typeof details.generated_tokens === "number" ? details.generated_tokens : Array.isArray(details.tokens) ? details.tokens.length : void 0;
+  const metrics = {};
+  if (promptTokens !== void 0) {
+    metrics.prompt_tokens = promptTokens;
+  }
+  if (completionTokens !== void 0) {
+    metrics.completion_tokens = completionTokens;
+  }
+  if (promptTokens !== void 0 || completionTokens !== void 0) {
+    metrics.tokens = (promptTokens ?? 0) + (completionTokens ?? 0);
+  }
+  return metrics;
+}
+function extractTextGenerationMetadata(result) {
+  if (!isObject(result?.details)) {
+    return void 0;
+  }
+  return typeof result.details.finish_reason === "string" ? {
+    finish_reason: result.details.finish_reason
+  } : void 0;
+}
+function summarizeFeatureExtractionOutput(result) {
+  if (!Array.isArray(result)) {
+    return void 0;
+  }
+  const first = result[0];
+  if (typeof first === "number") {
+    return { embedding_length: result.length };
+  }
+  if (Array.isArray(first) && first.every((value) => typeof value === "number")) {
+    return {
+      embedding_count: result.length,
+      embedding_length: first.length
+    };
+  }
+  if (Array.isArray(first) && first.length > 0 && Array.isArray(first[0]) && first[0].every((value) => typeof value === "number")) {
+    return {
+      embedding_batch_count: result.length,
+      embedding_count: first.length,
+      embedding_length: first[0].length
+    };
+  }
+  return void 0;
+}
+function patchChatCompletionStream(args) {
+  const { result, span, startTime } = args;
+  if (!result || !isAsyncIterable3(result)) {
+    return false;
+  }
+  let firstChunkTime;
+  patchStreamIfNeeded(result, {
+    onChunk: () => {
+      if (firstChunkTime === void 0) {
+        firstChunkTime = getCurrentUnixTimestamp();
+      }
+    },
+    onComplete: (chunks) => {
+      const lastChunk = chunks.at(-1);
+      const responseMetadata = extractResponseMetadata2(lastChunk);
+      const metrics = {
+        ...parseMetricsFromUsage(lastChunk?.usage),
+        ...firstChunkTime !== void 0 ? { time_to_first_token: firstChunkTime - startTime } : {}
+      };
+      span.log({
+        output: aggregateChatCompletionChunks2(chunks),
+        ...responseMetadata ? { metadata: responseMetadata } : {},
+        metrics
+      });
+      span.end();
+    },
+    onError: (error2) => {
+      span.log({
+        error: error2.message
+      });
+      span.end();
+    }
+  });
+  return true;
+}
+function patchTextGenerationStream(args) {
+  const { result, span, startTime } = args;
+  if (!result || !isAsyncIterable3(result)) {
+    return false;
+  }
+  let firstChunkTime;
+  patchStreamIfNeeded(result, {
+    onChunk: () => {
+      if (firstChunkTime === void 0) {
+        firstChunkTime = getCurrentUnixTimestamp();
+      }
+    },
+    onComplete: (chunks) => {
+      const lastChunk = chunks.at(-1);
+      const streamMetadata = extractTextGenerationStreamMetadata(chunks);
+      span.log({
+        output: aggregateTextGenerationStreamChunks(chunks),
+        ...streamMetadata ? { metadata: streamMetadata } : {},
+        metrics: {
+          ...extractTextGenerationMetrics(lastChunk?.details ?? null),
+          ...parseMetricsFromUsage(lastChunk?.usage),
+          ...firstChunkTime !== void 0 ? { time_to_first_token: firstChunkTime - startTime } : {}
+        }
+      });
+      span.end();
+    },
+    onError: (error2) => {
+      span.log({
+        error: error2.message
+      });
+      span.end();
+    }
+  });
+  return true;
+}
+function aggregateChatCompletionChunks2(chunks) {
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  const aggregatedChoices = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    for (const choice of chunk.choices ?? []) {
+      const index = typeof choice.index === "number" ? choice.index : 0;
+      const existing = aggregatedChoices.get(index) ?? { content: "" };
+      const delta = isObject(choice.delta) ? choice.delta : void 0;
+      const message = isObject(choice.message) ? choice.message : void 0;
+      if (typeof delta?.content === "string") {
+        existing.content += delta.content;
+      } else if (typeof message?.content === "string") {
+        existing.content = message.content;
+      }
+      if (typeof delta?.role === "string") {
+        existing.role = delta.role;
+      } else if (typeof message?.role === "string") {
+        existing.role = message.role;
+      }
+      if (choice.finish_reason !== void 0) {
+        existing.finish_reason = choice.finish_reason;
+      }
+      aggregatedChoices.set(index, existing);
+    }
+  }
+  return {
+    choices: [...aggregatedChoices.entries()].map(([index, choice]) => ({
+      index,
+      message: {
+        content: choice.content,
+        role: choice.role ?? "assistant"
+      },
+      ...choice.finish_reason !== void 0 ? { finish_reason: choice.finish_reason } : {}
+    }))
+  };
+}
+function aggregateTextGenerationStreamChunks(chunks) {
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  let generatedText = "";
+  let finishReason;
+  for (const chunk of chunks) {
+    if (typeof chunk.generated_text === "string") {
+      generatedText = chunk.generated_text;
+    } else if (typeof chunk.token?.text === "string" && !chunk.token.special) {
+      generatedText += chunk.token.text;
+    } else if (Array.isArray(chunk.choices)) {
+      for (const choice of chunk.choices) {
+        if (typeof choice.text === "string") {
+          generatedText += choice.text;
+        }
+        if (choice.finish_reason !== void 0) {
+          finishReason = choice.finish_reason;
+        }
+      }
+    }
+    if (isObject(chunk.details) && typeof chunk.details.finish_reason === "string") {
+      finishReason = chunk.details.finish_reason;
+    }
+  }
+  return {
+    generated_text: generatedText,
+    ...finishReason !== void 0 ? { finish_reason: finishReason } : {}
+  };
+}
+function extractTextGenerationStreamMetadata(chunks) {
+  for (let index = chunks.length - 1; index >= 0; index--) {
+    const chunk = chunks[index];
+    if (isObject(chunk?.details) && typeof chunk.details.finish_reason === "string") {
+      return {
+        finish_reason: chunk.details.finish_reason
+      };
+    }
+    if (!Array.isArray(chunk?.choices)) {
+      continue;
+    }
+    for (let choiceIndex = chunk.choices.length - 1; choiceIndex >= 0; choiceIndex--) {
+      const choice = chunk.choices[choiceIndex];
+      if (choice?.finish_reason !== void 0) {
+        return { finish_reason: choice.finish_reason };
+      }
+    }
+  }
+  return void 0;
+}
+
 // src/instrumentation/plugins/openrouter-agent-channels.ts
 var openRouterAgentChannels = defineChannels("@openrouter/agent", {
   callModel: channel({
@@ -18376,20 +20088,20 @@ var OpenRouterAgentPlugin = class extends BasePlugin {
     });
   }
 };
-function normalizeArgs(args) {
+function normalizeArgs2(args) {
   if (Array.isArray(args)) {
     return args;
   }
-  if (isArrayLike2(args)) {
+  if (isArrayLike3(args)) {
     return Array.from(args);
   }
   return [args];
 }
-function isArrayLike2(value) {
+function isArrayLike3(value) {
   return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
 }
 function getOpenRouterCallModelRequestArg(args) {
-  const normalizedArgs = normalizeArgs(args);
+  const normalizedArgs = normalizeArgs2(args);
   const keyedRequestArg = normalizedArgs.find(
     (arg) => isObject(arg) && ("input" in arg || "model" in arg || "tools" in arg)
   );
@@ -18675,7 +20387,7 @@ function traceToolExecution(args) {
   }
 }
 function publishToolResult(tracingChannel2, event, result) {
-  if (isPromiseLike3(result)) {
+  if (isPromiseLike(result)) {
     return result.then(
       (resolved) => {
         event.result = resolved;
@@ -18697,9 +20409,6 @@ function getToolCallId(context2) {
   const toolContext = context2;
   return typeof toolContext?.toolCall?.id === "string" ? toolContext.toolCall.id : void 0;
 }
-function isPromiseLike3(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
-}
 var OPENROUTER_WRAPPED_CALL_MODEL_RESULT = Symbol(
   "braintrust.openrouter.wrappedCallModelResult"
 );
@@ -19054,6 +20763,12 @@ var openRouterChannels = defineChannels("@openrouter/sdk", {
     channelName: "embeddings.generate",
     kind: "async"
   }),
+  rerankRerank: channel(
+    {
+      channelName: "rerank.rerank",
+      kind: "async"
+    }
+  ),
   betaResponsesSend: channel({
     channelName: "beta.responses.send",
     kind: "async"
@@ -19146,6 +20861,34 @@ var OpenRouterPlugin = class extends BasePlugin {
         }
       })
     );
+    this.unsubscribers.push(
+      traceAsyncChannel(openRouterChannels.rerankRerank, {
+        name: "openrouter.rerank.rerank",
+        type: "llm" /* LLM */,
+        extractInput: (args) => {
+          const request = getOpenRouterRequestArg(args);
+          const requestBody = isObject(request?.requestBody) ? request.requestBody : {};
+          const httpReferer = request?.httpReferer;
+          const xTitle = request?.xTitle ?? request?.appTitle;
+          const { documents, query, ...metadata } = requestBody;
+          return {
+            input: {
+              documents,
+              query
+            },
+            metadata: buildOpenRouterRerankMetadata(
+              metadata,
+              documents,
+              httpReferer,
+              xTitle
+            )
+          };
+        },
+        extractOutput: (result) => extractOpenRouterRerankOutput(result),
+        extractMetadata: (result) => extractOpenRouterResponseMetadata2(result),
+        extractMetrics: (result) => isObject(result) ? parseOpenRouterMetricsFromUsage2(result.usage) : {}
+      })
+    );
     this.unsubscribers.push(
       traceStreamingChannel(openRouterChannels.betaResponsesSend, {
         name: "openrouter.beta.responses.send",
@@ -19265,20 +21008,20 @@ var OpenRouterPlugin = class extends BasePlugin {
     });
   }
 };
-function normalizeArgs2(args) {
+function normalizeArgs3(args) {
   if (Array.isArray(args)) {
     return args;
   }
-  if (isArrayLike3(args)) {
+  if (isArrayLike4(args)) {
     return Array.from(args);
   }
   return [args];
 }
-function isArrayLike3(value) {
+function isArrayLike4(value) {
   return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
 }
 function getOpenRouterRequestArg(args) {
-  const normalizedArgs = normalizeArgs2(args);
+  const normalizedArgs = normalizeArgs3(args);
   const keyedCandidate = normalizedArgs.find(
     (arg) => isObject(arg) && ("chatGenerationParams" in arg || "requestBody" in arg || "openResponsesRequest" in arg)
   );
@@ -19289,7 +21032,7 @@ function getOpenRouterRequestArg(args) {
   return isObject(firstObjectArg) ? firstObjectArg : void 0;
 }
 function getOpenRouterCallModelRequestArg2(args) {
-  const firstObjectArg = normalizeArgs2(args).find((arg) => isObject(arg));
+  const firstObjectArg = normalizeArgs3(args).find((arg) => isObject(arg));
   return isObject(firstObjectArg) ? firstObjectArg : void 0;
 }
 var TOKEN_NAME_MAP3 = {
@@ -19459,6 +21202,13 @@ function buildOpenRouterEmbeddingMetadata(metadata, httpReferer, xTitle) {
     embedding_model: normalized.model
   } : normalized;
 }
+function buildOpenRouterRerankMetadata(metadata, documents, httpReferer, xTitle) {
+  const normalized = buildOpenRouterMetadata2(metadata, httpReferer, xTitle);
+  return {
+    ...normalized,
+    ...Array.isArray(documents) ? { document_count: documents.length } : {}
+  };
+}
 function extractOpenRouterCallModelInput2(request) {
   return isObject(request) && "input" in request ? sanitizeOpenRouterLoggedValue2(request.input) : void 0;
 }
@@ -19478,7 +21228,7 @@ function extractOpenRouterResponseMetadata2(result) {
   const metadataRecord = isObject(sanitized) ? sanitized : {};
   const { model, provider, ...rest } = metadataRecord;
   const normalizedModel = parseOpenRouterModelString2(model);
-  const normalizedProvider = (typeof provider === "string" ? provider : void 0) || normalizedModel.provider;
+  const normalizedProvider = (typeof provider === "string" ? provider.toLowerCase() : void 0) || normalizedModel.provider;
   const usageMetadata = extractOpenRouterUsageMetadata2(usage);
   const combined = {
     ...rest,
@@ -19497,6 +21247,15 @@ function extractOpenRouterResponseOutput2(response, fallbackOutput) {
   }
   return void 0;
 }
+function extractOpenRouterRerankOutput(result) {
+  if (!isObject(result) || !Array.isArray(result.results)) {
+    return void 0;
+  }
+  return result.results.slice(0, 100).map((item) => ({
+    index: isObject(item) && typeof item.index === "number" ? item.index : void 0,
+    relevance_score: isObject(item) && typeof item.relevanceScore === "number" ? item.relevanceScore : isObject(item) && typeof item.relevance_score === "number" ? item.relevance_score : void 0
+  }));
+}
 var OPENROUTER_WRAPPED_TOOL2 = Symbol("braintrust.openrouter.wrappedTool");
 function patchOpenRouterCallModelRequestTools2(request) {
   if (!Array.isArray(request.tools) || request.tools.length === 0) {
@@ -19567,7 +21326,7 @@ function traceToolExecution2(args) {
   }
 }
 function publishToolResult2(tracingChannel2, event, result) {
-  if (isPromiseLike4(result)) {
+  if (isPromiseLike(result)) {
     return result.then(
       (resolved) => {
         event.result = resolved;
@@ -19589,9 +21348,6 @@ function getToolCallId2(context2) {
   const toolContext = context2;
   return typeof toolContext?.toolCall?.id === "string" ? toolContext.toolCall.id : void 0;
 }
-function isPromiseLike4(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
-}
 function aggregateOpenRouterChatChunks(chunks) {
   let role;
   let content = "";
@@ -20231,20 +21987,20 @@ var MISTRAL_RESPONSE_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
 function camelToSnake3(value) {
   return value.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
 }
-function normalizeArgs3(args) {
+function normalizeArgs4(args) {
   if (Array.isArray(args)) {
     return args;
   }
-  if (isArrayLike4(args)) {
+  if (isArrayLike5(args)) {
     return Array.from(args);
   }
   return [args];
 }
-function isArrayLike4(value) {
+function isArrayLike5(value) {
   return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
 }
 function getMistralRequestArg(args) {
-  const firstObjectArg = normalizeArgs3(args).find((arg) => isObject(arg));
+  const firstObjectArg = normalizeArgs4(args).find((arg) => isObject(arg));
   return isObject(firstObjectArg) ? firstObjectArg : void 0;
 }
 function addMistralProviderMetadata(metadata) {
@@ -20323,229 +22079,1440 @@ function extractMistralMetrics(usage, startTime) {
   }
   return metrics;
 }
-function extractMistralStreamOutput(result) {
-  return isObject(result) ? result.choices : void 0;
-}
-function extractMistralStreamingMetrics(result, startTime) {
-  const metrics = isObject(result) ? parseMistralMetricsFromUsage(result.usage) : {};
-  if (startTime) {
-    metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+function extractMistralStreamOutput(result) {
+  return isObject(result) ? result.choices : void 0;
+}
+function extractMistralStreamingMetrics(result, startTime) {
+  const metrics = isObject(result) ? parseMistralMetricsFromUsage(result.usage) : {};
+  if (startTime) {
+    metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+  }
+  return metrics;
+}
+function extractDeltaText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const textParts = content.map((part) => {
+    if (!isObject(part) || part.type !== "text") {
+      return "";
+    }
+    return typeof part.text === "string" ? part.text : "";
+  }).filter((part) => part.length > 0);
+  return textParts.length > 0 ? textParts.join("") : void 0;
+}
+function getDeltaToolCalls(delta) {
+  const toolCalls = Array.isArray(delta.toolCalls) && delta.toolCalls || Array.isArray(delta.tool_calls) && delta.tool_calls || [];
+  return toolCalls.filter((toolCall) => isObject(toolCall));
+}
+function getToolCallIndex(toolCall) {
+  return typeof toolCall.index === "number" && toolCall.index >= 0 ? toolCall.index : void 0;
+}
+function createMergedToolCallDelta(delta) {
+  return {
+    ...delta,
+    function: {
+      ...delta.function,
+      arguments: typeof delta.function?.arguments === "string" ? delta.function.arguments : ""
+    }
+  };
+}
+function mergeToolCallDeltaPair(current, delta) {
+  const currentArguments = typeof current.function?.arguments === "string" ? current.function.arguments : "";
+  const deltaArguments = typeof delta.function?.arguments === "string" ? delta.function.arguments : "";
+  return {
+    ...current,
+    ...delta,
+    function: {
+      ...current.function || {},
+      ...delta.function || {},
+      arguments: `${currentArguments}${deltaArguments}`
+    }
+  };
+}
+function mergeToolCallDeltas(toolCalls, deltas) {
+  if (deltas.length === 0) {
+    return toolCalls;
+  }
+  const merged = toolCalls ? [...toolCalls] : [];
+  const indexToPosition = /* @__PURE__ */ new Map();
+  const idToPosition = /* @__PURE__ */ new Map();
+  for (const [position, toolCall] of merged.entries()) {
+    const index = getToolCallIndex(toolCall);
+    if (index !== void 0 && !indexToPosition.has(index)) {
+      indexToPosition.set(index, position);
+    }
+    if (typeof toolCall.id === "string" && !idToPosition.has(toolCall.id)) {
+      idToPosition.set(toolCall.id, position);
+    }
+  }
+  for (const delta of deltas) {
+    const deltaIndex = getToolCallIndex(delta);
+    const existingByIndex = deltaIndex !== void 0 ? indexToPosition.get(deltaIndex) : void 0;
+    const existingById = typeof delta.id === "string" ? idToPosition.get(delta.id) : void 0;
+    const existingPosition = existingByIndex ?? existingById;
+    if (existingPosition === void 0) {
+      const newToolCall = createMergedToolCallDelta(delta);
+      merged.push(newToolCall);
+      const newPosition = merged.length - 1;
+      const newIndex = getToolCallIndex(newToolCall);
+      if (newIndex !== void 0 && !indexToPosition.has(newIndex)) {
+        indexToPosition.set(newIndex, newPosition);
+      }
+      if (typeof newToolCall.id === "string" && !idToPosition.has(newToolCall.id)) {
+        idToPosition.set(newToolCall.id, newPosition);
+      }
+      continue;
+    }
+    const mergedToolCall = mergeToolCallDeltaPair(
+      merged[existingPosition],
+      delta
+    );
+    merged[existingPosition] = mergedToolCall;
+    const mergedIndex = getToolCallIndex(mergedToolCall);
+    if (mergedIndex !== void 0 && !indexToPosition.has(mergedIndex)) {
+      indexToPosition.set(mergedIndex, existingPosition);
+    }
+    if (typeof mergedToolCall.id === "string" && !idToPosition.has(mergedToolCall.id)) {
+      idToPosition.set(mergedToolCall.id, existingPosition);
+    }
+  }
+  return merged.length > 0 ? merged : void 0;
+}
+function getChoiceFinishReason(choice) {
+  if (typeof choice.finishReason === "string" || choice.finishReason === null) {
+    return choice.finishReason;
+  }
+  if (typeof choice.finish_reason === "string" || choice.finish_reason === null) {
+    return choice.finish_reason;
+  }
+  return void 0;
+}
+function parseMistralMetricsFromUsage(usage) {
+  if (!isObject(usage)) {
+    return {};
+  }
+  const metrics = {};
+  for (const [name, value] of Object.entries(usage)) {
+    if (typeof value === "number") {
+      metrics[TOKEN_NAME_MAP4[name] || camelToSnake3(name)] = value;
+      continue;
+    }
+    if (!isObject(value)) {
+      continue;
+    }
+    const prefix = TOKEN_DETAIL_PREFIX_MAP3[name];
+    if (!prefix) {
+      continue;
+    }
+    for (const [nestedName, nestedValue] of Object.entries(value)) {
+      if (typeof nestedValue !== "number") {
+        continue;
+      }
+      metrics[`${prefix}_${camelToSnake3(nestedName)}`] = nestedValue;
+    }
+  }
+  return metrics;
+}
+function aggregateMistralStreamChunks(chunks) {
+  const choiceAccumulators = /* @__PURE__ */ new Map();
+  const indexToAccumulatorKey = /* @__PURE__ */ new Map();
+  const positionToAccumulatorKey = /* @__PURE__ */ new Map();
+  let nextAccumulatorOrder = 0;
+  let metrics = {};
+  let metadata;
+  for (const event of chunks) {
+    const chunk = isMistralChatCompletionChunk(event?.data) ? event.data : void 0;
+    if (!chunk) {
+      continue;
+    }
+    if (isObject(chunk.usage)) {
+      metrics = {
+        ...metrics,
+        ...parseMistralMetricsFromUsage(chunk.usage)
+      };
+    }
+    const chunkMetadata = extractMistralResponseMetadata(chunk);
+    if (chunkMetadata) {
+      metadata = { ...metadata || {}, ...chunkMetadata };
+    }
+    for (const [choicePosition, rawChoice] of (chunk.choices || []).entries()) {
+      if (!isMistralChunkChoice(rawChoice)) {
+        continue;
+      }
+      const choice = rawChoice;
+      const choiceIndex = typeof choice.index === "number" && choice.index >= 0 ? choice.index : void 0;
+      let accumulatorKey = choiceIndex !== void 0 ? indexToAccumulatorKey.get(choiceIndex) : void 0;
+      if (!accumulatorKey) {
+        accumulatorKey = positionToAccumulatorKey.get(choicePosition);
+      }
+      if (!accumulatorKey) {
+        const initialIndex = choiceIndex ?? choicePosition;
+        const keyPrefix = choiceIndex !== void 0 ? "index" : "position";
+        accumulatorKey = `${keyPrefix}:${initialIndex}`;
+        choiceAccumulators.set(accumulatorKey, {
+          index: initialIndex,
+          order: nextAccumulatorOrder++
+        });
+      }
+      const accumulator = choiceAccumulators.get(accumulatorKey);
+      if (!accumulator) {
+        continue;
+      }
+      if (choiceIndex !== void 0) {
+        accumulator.index = choiceIndex;
+        indexToAccumulatorKey.set(choiceIndex, accumulatorKey);
+      }
+      positionToAccumulatorKey.set(choicePosition, accumulatorKey);
+      const delta = isObject(choice.delta) ? choice.delta : void 0;
+      if (delta) {
+        if (!accumulator.role && typeof delta.role === "string") {
+          accumulator.role = delta.role;
+        }
+        const deltaText = extractDeltaText(delta.content);
+        if (deltaText) {
+          accumulator.content = `${accumulator.content || ""}${deltaText}`;
+        }
+        accumulator.toolCalls = mergeToolCallDeltas(
+          accumulator.toolCalls,
+          getDeltaToolCalls(delta)
+        );
+      }
+      const choiceFinishReason = getChoiceFinishReason(choice);
+      if (choiceFinishReason !== void 0) {
+        accumulator.finishReason = choiceFinishReason;
+      }
+    }
+  }
+  const output = Array.from(choiceAccumulators.values()).sort(
+    (left, right) => left.index === right.index ? left.order - right.order : left.index - right.index
+  ).map((choice) => ({
+    index: choice.index,
+    message: {
+      ...choice.role ? { role: choice.role } : {},
+      content: choice.content ?? null,
+      ...choice.toolCalls ? { toolCalls: choice.toolCalls } : {}
+    },
+    ...choice.finishReason !== void 0 ? { finishReason: choice.finishReason } : {}
+  }));
+  return {
+    output,
+    metrics,
+    ...metadata ? { metadata } : {}
+  };
+}
+
+// src/instrumentation/plugins/google-adk-channels.ts
+var googleADKChannels = defineChannels("@google/adk", {
+  runnerRunAsync: channel({
+    channelName: "runner.runAsync",
+    kind: "sync-stream"
+  }),
+  agentRunAsync: channel({
+    channelName: "agent.runAsync",
+    kind: "sync-stream"
+  }),
+  toolRunAsync: channel({
+    channelName: "tool.runAsync",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/google-adk-plugin.ts
+var GoogleADKPlugin = class extends BasePlugin {
+  activeRunnerSpans = /* @__PURE__ */ new Map();
+  activeAgentSpans = /* @__PURE__ */ new Map();
+  onEnable() {
+    this.subscribeToRunnerRunAsync();
+    this.subscribeToAgentRunAsync();
+    this.subscribeToToolRunAsync();
+  }
+  onDisable() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    this.activeRunnerSpans.clear();
+    this.activeAgentSpans.clear();
+  }
+  subscribeToRunnerRunAsync() {
+    const tracingChannel2 = googleADKChannels.runnerRunAsync.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const createState = (event) => {
+      const params = event.arguments[0] ?? {};
+      const contextKey = extractRunnerContextKey(params);
+      const span = startSpan({
+        name: "Google ADK Runner",
+        spanAttributes: {
+          type: "task" /* TASK */
+        }
+      });
+      const startTime = getCurrentUnixTimestamp();
+      try {
+        const metadata = extractRunnerMetadata(params);
+        span.log({
+          input: extractRunnerInput(params),
+          metadata
+        });
+      } catch {
+      }
+      if (contextKey) {
+        this.activeRunnerSpans.set(contextKey, span);
+      }
+      return { span, startTime, events: [], contextKey };
+    };
+    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart3(
+      tracingChannel2,
+      states,
+      createState
+    );
+    const handlers = {
+      start: (event) => {
+        ensureState(states, event, () => createState(event));
+      },
+      end: (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        const result = event.result;
+        if (isAsyncIterable3(result)) {
+          bindAsyncIterableToCurrentSpan(result, state.span);
+          patchStreamIfNeeded(result, {
+            onChunk: (adkEvent) => {
+              state.events.push(adkEvent);
+            },
+            onComplete: () => {
+              finalizeRunnerSpan(state, this.activeRunnerSpans);
+              states.delete(event);
+            },
+            onError: (error2) => {
+              cleanupActiveRunnerSpan(state, this.activeRunnerSpans);
+              state.span.log({ error: error2.message });
+              state.span.end();
+              states.delete(event);
+            }
+          });
+          return;
+        }
+        try {
+          state.span.log({ output: result });
+        } finally {
+          cleanupActiveRunnerSpan(state, this.activeRunnerSpans);
+          state.span.end();
+          states.delete(event);
+        }
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (!state || !event.error) {
+          return;
+        }
+        cleanupActiveRunnerSpan(state, this.activeRunnerSpans);
+        state.span.log({ error: event.error.message });
+        state.span.end();
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToAgentRunAsync() {
+    const tracingChannel2 = googleADKChannels.agentRunAsync.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const createState = (event) => {
+      const parentContext = event.arguments[0];
+      const agentName = extractAgentName(parentContext);
+      const runnerParentSpan = findRunnerParentSpan(
+        parentContext,
+        this.activeRunnerSpans
+      );
+      const contextKey = extractInvocationContextKey(parentContext);
+      const span = startSpan({
+        name: agentName ? `Agent: ${agentName}` : "Google ADK Agent",
+        spanAttributes: {
+          type: "task" /* TASK */
+        },
+        ...runnerParentSpan ? {
+          parentSpanIds: {
+            spanId: runnerParentSpan.spanId,
+            rootSpanId: runnerParentSpan.rootSpanId
+          }
+        } : {}
+      });
+      const startTime = getCurrentUnixTimestamp();
+      try {
+        const metadata = {
+          provider: "google-adk"
+        };
+        if (agentName) {
+          metadata["google_adk.agent_name"] = agentName;
+        }
+        const modelName = extractModelName(parentContext);
+        if (modelName) {
+          metadata.model = modelName;
+        }
+        span.log({ metadata });
+      } catch {
+      }
+      if (contextKey && agentName) {
+        this.activeAgentSpans.set(agentContextKey(contextKey, agentName), span);
+      }
+      return { span, startTime, events: [], contextKey, name: agentName };
+    };
+    const unbindCurrentSpanStore = bindCurrentSpanStoreToStart3(
+      tracingChannel2,
+      states,
+      createState
+    );
+    const handlers = {
+      start: (event) => {
+        ensureState(states, event, () => createState(event));
+      },
+      end: (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        const result = event.result;
+        if (isAsyncIterable3(result)) {
+          bindAsyncIterableToCurrentSpan(result, state.span);
+          patchStreamIfNeeded(result, {
+            onChunk: (adkEvent) => {
+              state.events.push(adkEvent);
+            },
+            onComplete: () => {
+              finalizeAgentSpan(state, this.activeAgentSpans);
+              states.delete(event);
+            },
+            onError: (error2) => {
+              cleanupActiveAgentSpan(state, this.activeAgentSpans);
+              state.span.log({ error: error2.message });
+              state.span.end();
+              states.delete(event);
+            }
+          });
+          return;
+        }
+        try {
+          state.span.log({ output: result });
+        } finally {
+          cleanupActiveAgentSpan(state, this.activeAgentSpans);
+          state.span.end();
+          states.delete(event);
+        }
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (!state || !event.error) {
+          return;
+        }
+        cleanupActiveAgentSpan(state, this.activeAgentSpans);
+        state.span.log({ error: event.error.message });
+        state.span.end();
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      unbindCurrentSpanStore?.();
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+  subscribeToToolRunAsync() {
+    const tracingChannel2 = googleADKChannels.toolRunAsync.tracingChannel();
+    const states = /* @__PURE__ */ new WeakMap();
+    const handlers = {
+      start: (event) => {
+        const req = event.arguments[0] ?? {};
+        const tool = event.self;
+        const toolName = extractToolName(req, tool);
+        const parentSpan = findToolParentSpan(
+          req,
+          this.activeAgentSpans,
+          this.activeRunnerSpans
+        );
+        const createSpan = () => startSpan({
+          name: toolName ? `tool: ${toolName}` : "Google ADK Tool",
+          spanAttributes: {
+            type: "tool" /* TOOL */
+          },
+          event: {
+            input: req.args,
+            metadata: {
+              provider: "google-adk",
+              ...toolName && { "google_adk.tool_name": toolName },
+              ...extractToolCallId(req) && {
+                "google_adk.tool_call_id": extractToolCallId(req)
+              }
+            }
+          }
+        });
+        const span = parentSpan ? withCurrent(parentSpan, () => createSpan()) : createSpan();
+        const startTime = getCurrentUnixTimestamp();
+        states.set(event, { span, startTime });
+      },
+      asyncEnd: (event) => {
+        const state = states.get(event);
+        if (!state) {
+          return;
+        }
+        try {
+          const metrics = {};
+          const end = getCurrentUnixTimestamp();
+          metrics.start = state.startTime;
+          metrics.end = end;
+          metrics.duration = end - state.startTime;
+          state.span.log({
+            output: event.result,
+            metrics: cleanMetrics2(metrics)
+          });
+        } finally {
+          state.span.end();
+          states.delete(event);
+        }
+      },
+      error: (event) => {
+        const state = states.get(event);
+        if (!state || !event.error) {
+          return;
+        }
+        state.span.log({ error: event.error.message });
+        state.span.end();
+        states.delete(event);
+      }
+    };
+    tracingChannel2.subscribe(handlers);
+    this.unsubscribers.push(() => {
+      tracingChannel2.unsubscribe(handlers);
+    });
+  }
+};
+function ensureState(states, event, create) {
+  const existing = states.get(event);
+  if (existing) {
+    return existing;
+  }
+  const created = create();
+  states.set(event, created);
+  return created;
+}
+function bindAsyncIterableToCurrentSpan(stream, span) {
+  if (!isAsyncIterable3(stream)) {
+    return stream;
+  }
+  if (Object.isFrozen(stream) || Object.isSealed(stream)) {
+    return stream;
+  }
+  if ("next" in stream && typeof stream.next === "function") {
+    if ("__braintrust_current_span_bound" in stream) {
+      return stream;
+    }
+    try {
+      const iterator = stream;
+      const originalNext = iterator.next.bind(iterator);
+      iterator.next = (...args) => withCurrent(span, () => originalNext(...args));
+      if (typeof iterator.return === "function") {
+        const originalReturn = iterator.return.bind(iterator);
+        iterator.return = (...args) => withCurrent(span, () => originalReturn(...args));
+      }
+      if (typeof iterator.throw === "function") {
+        const originalThrow = iterator.throw.bind(iterator);
+        iterator.throw = (...args) => withCurrent(span, () => originalThrow(...args));
+      }
+      Object.defineProperty(stream, "__braintrust_current_span_bound", {
+        value: true
+      });
+      return stream;
+    } catch {
+      return stream;
+    }
+  }
+  const originalIteratorFn = stream[Symbol.asyncIterator];
+  if ("__braintrust_current_span_bound" in originalIteratorFn && originalIteratorFn.__braintrust_current_span_bound) {
+    return stream;
+  }
+  try {
+    const patchedIteratorFn = function() {
+      const iterator = originalIteratorFn.call(this);
+      const originalNext = iterator.next.bind(iterator);
+      iterator.next = (...args) => withCurrent(span, () => originalNext(...args));
+      if (typeof iterator.return === "function") {
+        const originalReturn = iterator.return.bind(iterator);
+        iterator.return = (...args) => withCurrent(span, () => originalReturn(...args));
+      }
+      if (typeof iterator.throw === "function") {
+        const originalThrow = iterator.throw.bind(iterator);
+        iterator.throw = (...args) => withCurrent(span, () => originalThrow(...args));
+      }
+      return iterator;
+    };
+    Object.defineProperty(
+      patchedIteratorFn,
+      "__braintrust_current_span_bound",
+      {
+        value: true
+      }
+    );
+    stream[Symbol.asyncIterator] = patchedIteratorFn;
+  } catch {
+    return stream;
+  }
+  return stream;
+}
+function bindCurrentSpanStoreToStart3(tracingChannel2, states, create) {
+  const state = _internalGetGlobalState();
+  const contextManager = state?.contextManager;
+  const startChannel = tracingChannel2.start;
+  const currentSpanStore = contextManager ? contextManager[BRAINTRUST_CURRENT_SPAN_STORE] : void 0;
+  if (!startChannel?.bindStore || !currentSpanStore) {
+    return void 0;
+  }
+  startChannel.bindStore(currentSpanStore, (event) => {
+    const span = ensureState(
+      states,
+      event,
+      () => create(event)
+    ).span;
+    return contextManager.wrapSpanForStore(span);
+  });
+  return () => {
+    startChannel.unbindStore?.(currentSpanStore);
+  };
+}
+function extractRunnerContextKey(paramsOrContext) {
+  const directUserId = "userId" in paramsOrContext ? paramsOrContext.userId : void 0;
+  const directSessionId = "sessionId" in paramsOrContext ? paramsOrContext.sessionId : void 0;
+  if (typeof directUserId === "string" && typeof directSessionId === "string") {
+    return `${directUserId}:${directSessionId}`;
+  }
+  const invocationContext = paramsOrContext;
+  return extractInvocationContextKey(invocationContext);
+}
+function extractInvocationContextKey(parentContext) {
+  const session = parentContext?.session;
+  const userId = session?.userId;
+  const sessionId = session?.id;
+  if (typeof userId !== "string" || typeof sessionId !== "string") {
+    return void 0;
+  }
+  return `${userId}:${sessionId}`;
+}
+function findRunnerParentSpan(parentContext, activeRunnerSpans) {
+  const contextKey = extractInvocationContextKey(parentContext);
+  return contextKey ? activeRunnerSpans.get(contextKey) : void 0;
+}
+function cleanupActiveRunnerSpan(state, activeRunnerSpans) {
+  if (state.contextKey) {
+    activeRunnerSpans.delete(state.contextKey);
+  }
+}
+function agentContextKey(contextKey, agentName) {
+  return `${contextKey}:${agentName}`;
+}
+function cleanupActiveAgentSpan(state, activeAgentSpans) {
+  if (state.contextKey && state.name) {
+    activeAgentSpans.delete(agentContextKey(state.contextKey, state.name));
+  }
+}
+function extractRunnerInput(paramsOrContext) {
+  const content = "newMessage" in paramsOrContext ? paramsOrContext.newMessage : paramsOrContext.userContent;
+  if (!content || typeof content !== "object") {
+    return void 0;
+  }
+  const normalizedContent = content;
+  if (normalizedContent.parts && Array.isArray(normalizedContent.parts)) {
+    const textParts = normalizedContent.parts.filter((p) => p.text !== void 0).map((p) => p.text);
+    if (textParts.length > 0) {
+      return {
+        messages: [
+          {
+            role: normalizedContent.role ?? "user",
+            content: textParts.join("")
+          }
+        ]
+      };
+    }
+  }
+  return { messages: [normalizedContent] };
+}
+function extractRunnerMetadata(paramsOrContext) {
+  const metadata = {
+    provider: "google-adk"
+  };
+  const directUserId = "userId" in paramsOrContext ? paramsOrContext.userId : void 0;
+  const directSessionId = "sessionId" in paramsOrContext ? paramsOrContext.sessionId : void 0;
+  if (typeof directUserId === "string") {
+    metadata["google_adk.user_id"] = directUserId;
+  }
+  if (typeof directSessionId === "string") {
+    metadata["google_adk.session_id"] = directSessionId;
+  }
+  const session = "session" in paramsOrContext ? paramsOrContext.session : void 0;
+  if (metadata["google_adk.user_id"] === void 0 && typeof session?.userId === "string") {
+    metadata["google_adk.user_id"] = session.userId;
+  }
+  if (metadata["google_adk.session_id"] === void 0 && typeof session?.id === "string") {
+    metadata["google_adk.session_id"] = session.id;
+  }
+  return metadata;
+}
+function extractAgentName(parentContext) {
+  if (!parentContext) {
+    return void 0;
+  }
+  const agent = parentContext.agent;
+  return agent?.name;
+}
+function extractModelName(parentContext) {
+  if (!parentContext) {
+    return void 0;
+  }
+  const agent = parentContext.agent;
+  if (!agent?.model) {
+    return void 0;
+  }
+  if (typeof agent.model === "string") {
+    return agent.model;
+  }
+  if (typeof agent.model === "object" && "model" in agent.model) {
+    return agent.model.model;
+  }
+  return void 0;
+}
+function extractToolCallId(req) {
+  const toolContext = req.toolContext;
+  return toolContext?.functionCallId;
+}
+function extractToolName(req, tool) {
+  if (typeof tool?.name === "string" && tool.name.length > 0) {
+    return tool.name;
+  }
+  const toolContext = req.toolContext;
+  const invocationContext = toolContext?.invocationContext;
+  const invocationTool = invocationContext?.tool;
+  const toolName = invocationTool?.name;
+  return typeof toolName === "string" && toolName.length > 0 ? toolName : void 0;
+}
+function extractToolAgentName(req) {
+  const toolContext = req.toolContext;
+  const directName = toolContext?.agentName;
+  if (typeof directName === "string" && directName.length > 0) {
+    return directName;
+  }
+  const invocationContext = toolContext?.invocationContext;
+  return extractAgentName(invocationContext);
+}
+function findToolParentSpan(req, activeAgentSpans, activeRunnerSpans) {
+  const toolContext = req.toolContext;
+  const invocationContext = toolContext?.invocationContext;
+  const contextKey = extractInvocationContextKey(invocationContext);
+  const agentName = extractToolAgentName(req);
+  if (contextKey && agentName) {
+    const agentSpan = activeAgentSpans.get(
+      agentContextKey(contextKey, agentName)
+    );
+    if (agentSpan) {
+      return agentSpan;
+    }
+  }
+  return contextKey ? activeRunnerSpans.get(contextKey) : void 0;
+}
+function finalizeRunnerSpan(state, activeRunnerSpans) {
+  try {
+    const lastEvent = getLastNonPartialEvent(state.events);
+    const metrics = {};
+    const end = getCurrentUnixTimestamp();
+    metrics.start = state.startTime;
+    metrics.end = end;
+    metrics.duration = end - state.startTime;
+    const usage = aggregateUsageFromEvents(state.events);
+    if (usage) {
+      populateUsageMetrics2(metrics, usage);
+    }
+    state.span.log({
+      output: lastEvent ? extractEventOutput(lastEvent) : void 0,
+      metrics: cleanMetrics2(metrics)
+    });
+  } finally {
+    cleanupActiveRunnerSpan(state, activeRunnerSpans);
+    state.span.end();
+  }
+}
+function finalizeAgentSpan(state, activeAgentSpans) {
+  try {
+    const lastEvent = getLastNonPartialEvent(state.events);
+    const metrics = {};
+    const end = getCurrentUnixTimestamp();
+    metrics.start = state.startTime;
+    metrics.end = end;
+    metrics.duration = end - state.startTime;
+    state.span.log({
+      output: lastEvent ? extractEventOutput(lastEvent) : void 0,
+      metrics: cleanMetrics2(metrics)
+    });
+  } finally {
+    cleanupActiveAgentSpan(state, activeAgentSpans);
+    state.span.end();
+  }
+}
+function getLastNonPartialEvent(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (!events[i].partial) {
+      return events[i];
+    }
+  }
+  return events.length > 0 ? events[events.length - 1] : void 0;
+}
+function extractEventOutput(event) {
+  if (!event.content) {
+    return void 0;
+  }
+  const output = {};
+  if (event.content.role) {
+    output.role = event.content.role;
+  }
+  if (event.content.parts && Array.isArray(event.content.parts)) {
+    const textParts = event.content.parts.filter((p) => p.text !== void 0 && !p.thought).map((p) => p.text);
+    const thoughtParts = event.content.parts.filter((p) => p.text !== void 0 && p.thought).map((p) => p.text);
+    const functionCalls = event.content.parts.filter((p) => p.functionCall).map((p) => p.functionCall);
+    if (textParts.length > 0) {
+      output.content = textParts.join("");
+    }
+    if (thoughtParts.length > 0) {
+      output.thought = thoughtParts.join("");
+    }
+    if (functionCalls.length > 0) {
+      output.functionCalls = functionCalls;
+    }
+  }
+  if (event.author) {
+    output.author = event.author;
+  }
+  return Object.keys(output).length > 0 ? output : void 0;
+}
+function aggregateUsageFromEvents(events) {
+  let hasUsage = false;
+  const aggregated = {};
+  for (const event of events) {
+    if (!event.usageMetadata) {
+      continue;
+    }
+    hasUsage = true;
+    const usage = event.usageMetadata;
+    if (usage.promptTokenCount !== void 0) {
+      aggregated.promptTokenCount = (aggregated.promptTokenCount ?? 0) + usage.promptTokenCount;
+    }
+    if (usage.candidatesTokenCount !== void 0) {
+      aggregated.candidatesTokenCount = (aggregated.candidatesTokenCount ?? 0) + usage.candidatesTokenCount;
+    }
+    if (usage.totalTokenCount !== void 0) {
+      aggregated.totalTokenCount = (aggregated.totalTokenCount ?? 0) + usage.totalTokenCount;
+    }
+    if (usage.cachedContentTokenCount !== void 0) {
+      aggregated.cachedContentTokenCount = (aggregated.cachedContentTokenCount ?? 0) + usage.cachedContentTokenCount;
+    }
+    if (usage.thoughtsTokenCount !== void 0) {
+      aggregated.thoughtsTokenCount = (aggregated.thoughtsTokenCount ?? 0) + usage.thoughtsTokenCount;
+    }
+  }
+  return hasUsage ? aggregated : void 0;
+}
+function populateUsageMetrics2(metrics, usage) {
+  if (usage.promptTokenCount !== void 0) {
+    metrics.prompt_tokens = usage.promptTokenCount;
+  }
+  if (usage.candidatesTokenCount !== void 0) {
+    metrics.completion_tokens = usage.candidatesTokenCount;
+  }
+  if (usage.totalTokenCount !== void 0) {
+    metrics.tokens = usage.totalTokenCount;
+  }
+  if (usage.cachedContentTokenCount !== void 0) {
+    metrics.prompt_cached_tokens = usage.cachedContentTokenCount;
+  }
+  if (usage.thoughtsTokenCount !== void 0) {
+    metrics.completion_reasoning_tokens = usage.thoughtsTokenCount;
+  }
+}
+function cleanMetrics2(metrics) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(metrics)) {
+    if (value !== null && value !== void 0) {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+
+// src/instrumentation/plugins/cohere-channels.ts
+var cohereChannels = defineChannels("cohere-ai", {
+  chat: channel({
+    channelName: "chat",
+    kind: "async"
+  }),
+  chatStream: channel({
+    channelName: "chatStream",
+    kind: "async"
+  }),
+  embed: channel({
+    channelName: "embed",
+    kind: "async"
+  }),
+  rerank: channel({
+    channelName: "rerank",
+    kind: "async"
+  })
+});
+
+// src/instrumentation/plugins/cohere-plugin.ts
+var CoherePlugin = class extends BasePlugin {
+  onEnable() {
+    this.subscribeToCohereChannels();
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+  subscribeToCohereChannels() {
+    this.unsubscribers.push(
+      traceStreamingChannel(cohereChannels.chat, {
+        name: "cohere.chat",
+        type: "llm" /* LLM */,
+        extractInput: extractChatInputWithMetadata2,
+        extractOutput: (result) => extractCohereChatOutput(result),
+        extractMetadata: (result) => extractCohereResponseMetadata(result),
+        extractMetrics: (result, startTime) => {
+          const metrics = parseCohereMetricsFromUsage(result);
+          if (startTime) {
+            metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
+          }
+          return metrics;
+        }
+      })
+    );
+    this.unsubscribers.push(
+      traceStreamingChannel(cohereChannels.chatStream, {
+        name: "cohere.chatStream",
+        type: "llm" /* LLM */,
+        extractInput: extractChatInputWithMetadata2,
+        extractOutput: () => void 0,
+        extractMetadata: () => void 0,
+        extractMetrics: () => ({}),
+        aggregateChunks: aggregateCohereChatStreamChunks
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(cohereChannels.embed, {
+        name: "cohere.embed",
+        type: "llm" /* LLM */,
+        extractInput: extractEmbedInputWithMetadata,
+        extractOutput: extractCohereEmbeddingOutput,
+        extractMetadata: (result) => extractCohereResponseMetadata(result),
+        extractMetrics: (result) => parseCohereMetricsFromUsage(result)
+      })
+    );
+    this.unsubscribers.push(
+      traceAsyncChannel(cohereChannels.rerank, {
+        name: "cohere.rerank",
+        type: "llm" /* LLM */,
+        extractInput: extractRerankInputWithMetadata,
+        extractOutput: (result) => {
+          if (!isObject(result) || !Array.isArray(result.results)) {
+            return void 0;
+          }
+          return result.results.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
+          }));
+        },
+        extractMetadata: (result) => extractCohereResponseMetadata(result),
+        extractMetrics: (result) => parseCohereMetricsFromUsage(result)
+      })
+    );
+  }
+};
+var CHAT_REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "conversationId",
+  "conversation_id",
+  "frequencyPenalty",
+  "frequency_penalty",
+  "k",
+  "maxInputTokens",
+  "max_input_tokens",
+  "maxTokens",
+  "max_tokens",
+  "model",
+  "p",
+  "preamble",
+  "presencePenalty",
+  "presence_penalty",
+  "priority",
+  "promptTruncation",
+  "prompt_truncation",
+  "rawPrompting",
+  "raw_prompting",
+  "responseFormat",
+  "response_format",
+  "safetyMode",
+  "safety_mode",
+  "searchQueriesOnly",
+  "search_queries_only",
+  "seed",
+  "stopSequences",
+  "stop_sequences",
+  "strictTools",
+  "strict_tools",
+  "temperature",
+  "toolChoice",
+  "tool_choice"
+]);
+var EMBED_REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "embeddingTypes",
+  "embedding_types",
+  "inputType",
+  "input_type",
+  "maxTokens",
+  "max_tokens",
+  "model",
+  "outputDimension",
+  "output_dimension",
+  "priority",
+  "truncate"
+]);
+var RERANK_REQUEST_METADATA_ALLOWLIST = /* @__PURE__ */ new Set([
+  "maxChunksPerDoc",
+  "max_chunks_per_doc",
+  "maxTokensPerDoc",
+  "max_tokens_per_doc",
+  "model",
+  "priority",
+  "rankFields",
+  "rank_fields",
+  "returnDocuments",
+  "return_documents",
+  "topN",
+  "top_n"
+]);
+var RESPONSE_METADATA_ALLOWLIST2 = /* @__PURE__ */ new Set([
+  "finishReason",
+  "finish_reason",
+  "generationId",
+  "generation_id",
+  "id",
+  "responseId",
+  "responseType",
+  "response_id",
+  "response_type"
+]);
+function normalizeArgs5(args) {
+  if (Array.isArray(args)) {
+    return args;
+  }
+  if (isArrayLike6(args)) {
+    return Array.from(args);
+  }
+  return [args];
+}
+function isArrayLike6(value) {
+  return isObject(value) && "length" in value && typeof value.length === "number" && Number.isInteger(value.length) && value.length >= 0;
+}
+function getRequestArg(args) {
+  const firstObjectArg = normalizeArgs5(args).find((arg) => isObject(arg));
+  return isObject(firstObjectArg) ? firstObjectArg : void 0;
+}
+function addCohereProviderMetadata(metadata) {
+  return {
+    ...metadata,
+    provider: "cohere"
+  };
+}
+function pickAllowedMetadata2(metadata, allowlist) {
+  if (!metadata) {
+    return {};
+  }
+  const picked = {};
+  for (const key of allowlist) {
+    const value = metadata[key];
+    if (value !== void 0) {
+      picked[key] = value;
+    }
+  }
+  return picked;
+}
+function extractChatInputWithMetadata2(args) {
+  const request = getRequestArg(args);
+  const { message, messages, ...rawMetadata } = request || {};
+  return {
+    input: processInputAttachments(messages ?? message),
+    metadata: addCohereProviderMetadata(
+      pickAllowedMetadata2(rawMetadata, CHAT_REQUEST_METADATA_ALLOWLIST)
+    )
+  };
+}
+function extractEmbedInputWithMetadata(args) {
+  const request = getRequestArg(args);
+  const { inputs, texts, images, ...rawMetadata } = request || {};
+  return {
+    input: inputs ?? texts ?? images,
+    metadata: addCohereProviderMetadata(
+      pickAllowedMetadata2(rawMetadata, EMBED_REQUEST_METADATA_ALLOWLIST)
+    )
+  };
+}
+function extractRerankInputWithMetadata(args) {
+  const request = getRequestArg(args);
+  const { query, documents, ...rawMetadata } = request || {};
+  return {
+    input: {
+      documents,
+      query
+    },
+    metadata: addCohereProviderMetadata({
+      ...pickAllowedMetadata2(rawMetadata, RERANK_REQUEST_METADATA_ALLOWLIST),
+      ...Array.isArray(documents) ? { document_count: documents.length } : {}
+    })
+  };
+}
+function extractCohereResponseMetadata(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const responseMetadata = pickAllowedMetadata2(
+    result,
+    RESPONSE_METADATA_ALLOWLIST2
+  );
+  const meta = isObject(result.meta) ? result.meta : void 0;
+  const apiVersion = isObject(meta?.apiVersion) && typeof meta.apiVersion.version === "string" && meta.apiVersion.version || isObject(meta?.api_version) && typeof meta.api_version.version === "string" && meta.api_version.version;
+  const metadata = {
+    ...responseMetadata,
+    ...apiVersion ? { api_version: apiVersion } : {}
+  };
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function extractCohereChatOutput(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  if (isObject(result.message)) {
+    return result.message;
+  }
+  if (typeof result.text !== "string") {
+    return void 0;
+  }
+  const toolCalls = Array.isArray(result.toolCalls) ? result.toolCalls : Array.isArray(result.tool_calls) ? result.tool_calls : void 0;
+  if (toolCalls && toolCalls.length > 0) {
+    return {
+      content: result.text,
+      role: "assistant",
+      toolCalls
+    };
+  }
+  return result.text;
+}
+function extractCohereEmbeddingOutput(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const embeddingLength = getFirstEmbeddingLength(result.embeddings);
+  if (embeddingLength === void 0) {
+    return void 0;
+  }
+  return {
+    embedding_length: embeddingLength
+  };
+}
+function getFirstEmbeddingLength(value) {
+  if (Array.isArray(value) && Array.isArray(value[0])) {
+    return value[0].length;
+  }
+  if (!isObject(value)) {
+    return void 0;
+  }
+  for (const key of Object.keys(value)) {
+    const entry = value[key];
+    if (Array.isArray(entry) && Array.isArray(entry[0])) {
+      return entry[0].length;
+    }
+  }
+  return void 0;
+}
+function setMetricIfNumber(metrics, key, value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    metrics[key] = value;
+  }
+}
+function mergeUsageMetrics(metrics, usage) {
+  if (!isObject(usage)) {
+    return metrics;
+  }
+  const source = usage;
+  setMetricIfNumber(
+    metrics,
+    "prompt_tokens",
+    source.inputTokens ?? source.input_tokens
+  );
+  setMetricIfNumber(
+    metrics,
+    "completion_tokens",
+    source.outputTokens ?? source.output_tokens
+  );
+  setMetricIfNumber(
+    metrics,
+    "tokens",
+    source.totalTokens ?? source.total_tokens
+  );
+  setMetricIfNumber(
+    metrics,
+    "prompt_cached_tokens",
+    source.cachedTokens ?? source.cached_tokens
+  );
+  const tokenContainer = isObject(source.tokens) ? source.tokens : void 0;
+  if (tokenContainer) {
+    setMetricIfNumber(
+      metrics,
+      "prompt_tokens",
+      tokenContainer.inputTokens ?? tokenContainer.input_tokens
+    );
+    setMetricIfNumber(
+      metrics,
+      "completion_tokens",
+      tokenContainer.outputTokens ?? tokenContainer.output_tokens
+    );
+    setMetricIfNumber(
+      metrics,
+      "tokens",
+      tokenContainer.totalTokens ?? tokenContainer.total_tokens
+    );
+  }
+  const billedUnits = (isObject(source.billedUnits) ? source.billedUnits : void 0) || (isObject(source.billed_units) ? source.billed_units : void 0);
+  if (billedUnits) {
+    setMetricIfNumber(
+      metrics,
+      "prompt_tokens",
+      billedUnits.inputTokens ?? billedUnits.input_tokens
+    );
+    setMetricIfNumber(
+      metrics,
+      "completion_tokens",
+      billedUnits.outputTokens ?? billedUnits.output_tokens
+    );
+    setMetricIfNumber(
+      metrics,
+      "search_units",
+      billedUnits.searchUnits ?? billedUnits.search_units
+    );
+    setMetricIfNumber(metrics, "classifications", billedUnits.classifications);
+    setMetricIfNumber(metrics, "images", billedUnits.images);
+    setMetricIfNumber(
+      metrics,
+      "image_tokens",
+      billedUnits.imageTokens ?? billedUnits.image_tokens
+    );
+  }
+  return metrics;
+}
+function parseCohereMetricsFromUsage(source) {
+  if (!isObject(source)) {
+    return {};
   }
-  return metrics;
-}
-function extractDeltaText(content) {
-  if (typeof content === "string") {
-    return content;
+  const metrics = {};
+  mergeUsageMetrics(metrics, source);
+  if ("usage" in source) {
+    mergeUsageMetrics(metrics, source.usage);
   }
-  if (!Array.isArray(content)) {
-    return void 0;
+  if ("meta" in source) {
+    mergeUsageMetrics(metrics, source.meta);
   }
-  const textParts = content.map((part) => {
-    if (!isObject(part) || part.type !== "text") {
-      return "";
-    }
-    return typeof part.text === "string" ? part.text : "";
-  }).filter((part) => part.length > 0);
-  return textParts.length > 0 ? textParts.join("") : void 0;
-}
-function getDeltaToolCalls(delta) {
-  const toolCalls = Array.isArray(delta.toolCalls) && delta.toolCalls || Array.isArray(delta.tool_calls) && delta.tool_calls || [];
-  return toolCalls.filter((toolCall) => isObject(toolCall));
+  if (metrics.tokens === void 0 && typeof metrics.prompt_tokens === "number" && typeof metrics.completion_tokens === "number") {
+    metrics.tokens = metrics.prompt_tokens + metrics.completion_tokens;
+  }
+  return metrics;
 }
-function getToolCallIndex(toolCall) {
-  return typeof toolCall.index === "number" && toolCall.index >= 0 ? toolCall.index : void 0;
+function toToolCallArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => isObject(item));
+  }
+  return isObject(value) ? [value] : [];
 }
-function createMergedToolCallDelta(delta) {
-  return {
-    ...delta,
-    function: {
-      ...delta.function,
-      arguments: typeof delta.function?.arguments === "string" ? delta.function.arguments : ""
-    }
-  };
+function getToolCallIndex2(toolCall, fallbackIndex) {
+  return typeof toolCall.index === "number" && Number.isInteger(toolCall.index) ? toolCall.index : fallbackIndex;
 }
-function mergeToolCallDeltaPair(current, delta) {
-  const currentArguments = typeof current.function?.arguments === "string" ? current.function.arguments : "";
-  const deltaArguments = typeof delta.function?.arguments === "string" ? delta.function.arguments : "";
+function appendToolCallDelta(existing, incoming) {
+  const currentArguments = isObject(existing?.function) && typeof existing.function.arguments === "string" ? existing.function.arguments : "";
+  const incomingArguments = isObject(incoming.function) && typeof incoming.function.arguments === "string" ? incoming.function.arguments : "";
   return {
-    ...current,
-    ...delta,
+    ...existing,
+    ...incoming,
     function: {
-      ...current.function || {},
-      ...delta.function || {},
-      arguments: `${currentArguments}${deltaArguments}`
+      ...isObject(existing?.function) ? existing.function : {},
+      ...isObject(incoming.function) ? incoming.function : {},
+      ...incomingArguments ? { arguments: `${currentArguments}${incomingArguments}` } : {}
     }
   };
 }
-function mergeToolCallDeltas(toolCalls, deltas) {
-  if (deltas.length === 0) {
-    return toolCalls;
-  }
-  const merged = toolCalls ? [...toolCalls] : [];
-  const indexToPosition = /* @__PURE__ */ new Map();
-  const idToPosition = /* @__PURE__ */ new Map();
-  for (const [position, toolCall] of merged.entries()) {
-    const index = getToolCallIndex(toolCall);
-    if (index !== void 0 && !indexToPosition.has(index)) {
-      indexToPosition.set(index, position);
-    }
-    if (typeof toolCall.id === "string" && !idToPosition.has(toolCall.id)) {
-      idToPosition.set(toolCall.id, position);
-    }
-  }
-  for (const delta of deltas) {
-    const deltaIndex = getToolCallIndex(delta);
-    const existingByIndex = deltaIndex !== void 0 ? indexToPosition.get(deltaIndex) : void 0;
-    const existingById = typeof delta.id === "string" ? idToPosition.get(delta.id) : void 0;
-    const existingPosition = existingByIndex ?? existingById;
-    if (existingPosition === void 0) {
-      const newToolCall = createMergedToolCallDelta(delta);
-      merged.push(newToolCall);
-      const newPosition = merged.length - 1;
-      const newIndex = getToolCallIndex(newToolCall);
-      if (newIndex !== void 0 && !indexToPosition.has(newIndex)) {
-        indexToPosition.set(newIndex, newPosition);
-      }
-      if (typeof newToolCall.id === "string" && !idToPosition.has(newToolCall.id)) {
-        idToPosition.set(newToolCall.id, newPosition);
-      }
-      continue;
-    }
-    const mergedToolCall = mergeToolCallDeltaPair(
-      merged[existingPosition],
-      delta
-    );
-    merged[existingPosition] = mergedToolCall;
-    const mergedIndex = getToolCallIndex(mergedToolCall);
-    if (mergedIndex !== void 0 && !indexToPosition.has(mergedIndex)) {
-      indexToPosition.set(mergedIndex, existingPosition);
-    }
-    if (typeof mergedToolCall.id === "string" && !idToPosition.has(mergedToolCall.id)) {
-      idToPosition.set(mergedToolCall.id, existingPosition);
-    }
+function extractV8DeltaText(chunk) {
+  if (!isObject(chunk.delta) || !isObject(chunk.delta.message)) {
+    return void 0;
   }
-  return merged.length > 0 ? merged : void 0;
-}
-function getChoiceFinishReason(choice) {
-  if (typeof choice.finishReason === "string" || choice.finishReason === null) {
-    return choice.finishReason;
+  const content = chunk.delta.message.content;
+  if (typeof content === "string") {
+    return content;
   }
-  if (typeof choice.finish_reason === "string" || choice.finish_reason === null) {
-    return choice.finish_reason;
+  if (isObject(content) && typeof content.text === "string") {
+    return content.text;
   }
   return void 0;
 }
-function parseMistralMetricsFromUsage(usage) {
-  if (!isObject(usage)) {
-    return {};
-  }
-  const metrics = {};
-  for (const [name, value] of Object.entries(usage)) {
-    if (typeof value === "number") {
-      metrics[TOKEN_NAME_MAP4[name] || camelToSnake3(name)] = value;
-      continue;
-    }
-    if (!isObject(value)) {
+function aggregateCohereChatStreamChunks(chunks) {
+  const textDeltas = [];
+  const toolCallsByIndex = {};
+  const toolCallOrder = [];
+  let terminalResponse;
+  let role;
+  let finishReason;
+  let metadata = {};
+  let metrics = {};
+  for (const chunk of chunks) {
+    if (!isObject(chunk)) {
       continue;
     }
-    const prefix = TOKEN_DETAIL_PREFIX_MAP3[name];
-    if (!prefix) {
+    const eventType = typeof chunk.eventType === "string" ? chunk.eventType : typeof chunk.event_type === "string" ? chunk.event_type : typeof chunk.type === "string" ? chunk.type : void 0;
+    if (eventType === "text-generation" && typeof chunk.text === "string") {
+      textDeltas.push(chunk.text);
       continue;
     }
-    for (const [nestedName, nestedValue] of Object.entries(value)) {
-      if (typeof nestedValue !== "number") {
-        continue;
+    if (eventType === "tool-calls-generation") {
+      const generatedToolCalls = toToolCallArray(
+        Array.isArray(chunk.toolCalls) ? chunk.toolCalls : chunk.tool_calls
+      );
+      for (const [index, toolCall] of generatedToolCalls.entries()) {
+        const normalizedIndex = getToolCallIndex2(toolCall, index);
+        if (!toolCallOrder.includes(normalizedIndex)) {
+          toolCallOrder.push(normalizedIndex);
+        }
+        toolCallsByIndex[normalizedIndex] = {
+          ...toolCallsByIndex[normalizedIndex],
+          ...toolCall
+        };
+      }
+      if (typeof chunk.text === "string") {
+        textDeltas.push(chunk.text);
       }
-      metrics[`${prefix}_${camelToSnake3(nestedName)}`] = nestedValue;
-    }
-  }
-  return metrics;
-}
-function aggregateMistralStreamChunks(chunks) {
-  const choiceAccumulators = /* @__PURE__ */ new Map();
-  const indexToAccumulatorKey = /* @__PURE__ */ new Map();
-  const positionToAccumulatorKey = /* @__PURE__ */ new Map();
-  let nextAccumulatorOrder = 0;
-  let metrics = {};
-  let metadata;
-  for (const event of chunks) {
-    const chunk = isMistralChatCompletionChunk(event?.data) ? event.data : void 0;
-    if (!chunk) {
       continue;
     }
-    if (isObject(chunk.usage)) {
+    if (eventType === "stream-end" && isObject(chunk.response)) {
+      terminalResponse = chunk.response;
       metrics = {
         ...metrics,
-        ...parseMistralMetricsFromUsage(chunk.usage)
+        ...parseCohereMetricsFromUsage(chunk.response)
       };
+      metadata = {
+        ...metadata,
+        ...extractCohereResponseMetadata(chunk.response) || {}
+      };
+      const responseFinishReason = typeof chunk.response.finishReason === "string" ? chunk.response.finishReason : typeof chunk.response.finish_reason === "string" ? chunk.response.finish_reason : void 0;
+      finishReason = responseFinishReason ?? finishReason;
+      continue;
     }
-    const chunkMetadata = extractMistralResponseMetadata(chunk);
-    if (chunkMetadata) {
-      metadata = { ...metadata || {}, ...chunkMetadata };
-    }
-    for (const [choicePosition, rawChoice] of (chunk.choices || []).entries()) {
-      if (!isMistralChunkChoice(rawChoice)) {
-        continue;
+    if (eventType === "message-start") {
+      if (typeof chunk.id === "string") {
+        metadata.id = chunk.id;
       }
-      const choice = rawChoice;
-      const choiceIndex = typeof choice.index === "number" && choice.index >= 0 ? choice.index : void 0;
-      let accumulatorKey = choiceIndex !== void 0 ? indexToAccumulatorKey.get(choiceIndex) : void 0;
-      if (!accumulatorKey) {
-        accumulatorKey = positionToAccumulatorKey.get(choicePosition);
-      }
-      if (!accumulatorKey) {
-        const initialIndex = choiceIndex ?? choicePosition;
-        const keyPrefix = choiceIndex !== void 0 ? "index" : "position";
-        accumulatorKey = `${keyPrefix}:${initialIndex}`;
-        choiceAccumulators.set(accumulatorKey, {
-          index: initialIndex,
-          order: nextAccumulatorOrder++
-        });
-      }
-      const accumulator = choiceAccumulators.get(accumulatorKey);
-      if (!accumulator) {
-        continue;
+      if (isObject(chunk.delta) && isObject(chunk.delta.message)) {
+        const messageRole = chunk.delta.message.role;
+        if (typeof messageRole === "string") {
+          role = messageRole;
+        }
       }
-      if (choiceIndex !== void 0) {
-        accumulator.index = choiceIndex;
-        indexToAccumulatorKey.set(choiceIndex, accumulatorKey);
+      continue;
+    }
+    if (eventType === "content-delta") {
+      const text = extractV8DeltaText(chunk);
+      if (text) {
+        textDeltas.push(text);
       }
-      positionToAccumulatorKey.set(choicePosition, accumulatorKey);
-      const delta = isObject(choice.delta) ? choice.delta : void 0;
-      if (delta) {
-        if (!accumulator.role && typeof delta.role === "string") {
-          accumulator.role = delta.role;
+      continue;
+    }
+    if (eventType === "tool-call-start") {
+      const toolCalls = isObject(chunk.delta) && isObject(chunk.delta.message) ? toToolCallArray(
+        Array.isArray(chunk.delta.message.toolCalls) ? chunk.delta.message.toolCalls : chunk.delta.message.toolCalls ?? chunk.delta.message.tool_calls
+      ) : [];
+      for (const [index, toolCall] of toolCalls.entries()) {
+        const normalizedIndex = getToolCallIndex2(
+          toolCall,
+          typeof chunk.index === "number" ? chunk.index : index
+        );
+        if (!toolCallOrder.includes(normalizedIndex)) {
+          toolCallOrder.push(normalizedIndex);
         }
-        const deltaText = extractDeltaText(delta.content);
-        if (deltaText) {
-          accumulator.content = `${accumulator.content || ""}${deltaText}`;
+        toolCallsByIndex[normalizedIndex] = {
+          ...toolCallsByIndex[normalizedIndex],
+          ...toolCall
+        };
+      }
+      continue;
+    }
+    if (eventType === "tool-call-delta") {
+      const toolCallDelta = isObject(chunk.delta) && isObject(chunk.delta.message) ? toToolCallArray(
+        chunk.delta.message.toolCalls ?? chunk.delta.message.tool_calls
+      ) : [];
+      if (toolCallDelta.length > 0) {
+        const delta = toolCallDelta[0];
+        const normalizedIndex = getToolCallIndex2(delta, chunk.index ?? 0);
+        if (!toolCallOrder.includes(normalizedIndex)) {
+          toolCallOrder.push(normalizedIndex);
         }
-        accumulator.toolCalls = mergeToolCallDeltas(
-          accumulator.toolCalls,
-          getDeltaToolCalls(delta)
+        toolCallsByIndex[normalizedIndex] = appendToolCallDelta(
+          toolCallsByIndex[normalizedIndex],
+          delta
         );
       }
-      const choiceFinishReason = getChoiceFinishReason(choice);
-      if (choiceFinishReason !== void 0) {
-        accumulator.finishReason = choiceFinishReason;
+      continue;
+    }
+    if (eventType === "message-end" && isObject(chunk.delta)) {
+      const delta = chunk.delta;
+      if (typeof delta.finishReason === "string") {
+        finishReason = delta.finishReason;
+      } else if (typeof delta.finish_reason === "string") {
+        finishReason = delta.finish_reason;
+      }
+      if (delta.error !== void 0) {
+        metadata.error = delta.error;
       }
+      metrics = {
+        ...metrics,
+        ...parseCohereMetricsFromUsage(delta.usage)
+      };
     }
   }
-  const output = Array.from(choiceAccumulators.values()).sort(
-    (left, right) => left.index === right.index ? left.order - right.order : left.index - right.index
-  ).map((choice) => ({
-    index: choice.index,
-    message: {
-      ...choice.role ? { role: choice.role } : {},
-      content: choice.content ?? null,
-      ...choice.toolCalls ? { toolCalls: choice.toolCalls } : {}
-    },
-    ...choice.finishReason !== void 0 ? { finishReason: choice.finishReason } : {}
-  }));
+  const mergedToolCalls = toolCallOrder.sort((left, right) => left - right).map((index) => toolCallsByIndex[index]).filter((toolCall) => isObject(toolCall));
+  let output = extractCohereChatOutput(terminalResponse);
+  if (output === void 0) {
+    const mergedText = textDeltas.join("");
+    if (mergedToolCalls.length > 0 || role || mergedText.length > 0) {
+      output = {
+        ...role ? { role } : {},
+        ...mergedText.length > 0 ? { content: mergedText } : {},
+        ...mergedToolCalls.length > 0 ? { toolCalls: mergedToolCalls } : {}
+      };
+    }
+  }
+  if (finishReason) {
+    metadata = {
+      ...metadata,
+      finish_reason: finishReason
+    };
+  }
   return {
-    output,
+    metadata,
     metrics,
-    ...metadata ? { metadata } : {}
+    output
   };
 }
 
@@ -20557,9 +23524,12 @@ var BraintrustPlugin = class extends BasePlugin {
   aiSDKPlugin = null;
   claudeAgentSDKPlugin = null;
   googleGenAIPlugin = null;
+  huggingFacePlugin = null;
   openRouterPlugin = null;
   openRouterAgentPlugin = null;
   mistralPlugin = null;
+  googleADKPlugin = null;
+  coherePlugin = null;
   constructor(config3 = {}) {
     super();
     this.config = config3;
@@ -20586,6 +23556,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.googleGenAIPlugin = new GoogleGenAIPlugin();
       this.googleGenAIPlugin.enable();
     }
+    if (integrations.huggingface !== false) {
+      this.huggingFacePlugin = new HuggingFacePlugin();
+      this.huggingFacePlugin.enable();
+    }
     if (integrations.openrouter !== false) {
       this.openRouterPlugin = new OpenRouterPlugin();
       this.openRouterPlugin.enable();
@@ -20598,6 +23572,14 @@ var BraintrustPlugin = class extends BasePlugin {
       this.mistralPlugin = new MistralPlugin();
       this.mistralPlugin.enable();
     }
+    if (integrations.googleADK !== false) {
+      this.googleADKPlugin = new GoogleADKPlugin();
+      this.googleADKPlugin.enable();
+    }
+    if (integrations.cohere !== false) {
+      this.coherePlugin = new CoherePlugin();
+      this.coherePlugin.enable();
+    }
   }
   onDisable() {
     if (this.openaiPlugin) {
@@ -20620,6 +23602,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.googleGenAIPlugin.disable();
       this.googleGenAIPlugin = null;
     }
+    if (this.huggingFacePlugin) {
+      this.huggingFacePlugin.disable();
+      this.huggingFacePlugin = null;
+    }
     if (this.openRouterPlugin) {
       this.openRouterPlugin.disable();
       this.openRouterPlugin = null;
@@ -20632,6 +23618,14 @@ var BraintrustPlugin = class extends BasePlugin {
       this.mistralPlugin.disable();
       this.mistralPlugin = null;
     }
+    if (this.googleADKPlugin) {
+      this.googleADKPlugin.disable();
+      this.googleADKPlugin = null;
+    }
+    if (this.coherePlugin) {
+      this.coherePlugin.disable();
+      this.coherePlugin = null;
+    }
   }
 };
 
@@ -20703,10 +23697,12 @@ var PluginRegistry = class {
       vercel: true,
       aisdk: true,
       google: true,
+      huggingface: true,
       claudeAgentSDK: true,
       openrouter: true,
       openrouterAgent: true,
-      mistral: true
+      mistral: true,
+      cohere: true
     };
   }
   /**
@@ -20929,7 +23925,7 @@ async function findCodeDefinition({
     if (location.type === "sandbox") {
       fn = evaluator.task;
     } else {
-      fn = location.position.type === "task" ? evaluator.task : evaluator.scores[location.position.index];
+      fn = location.position.type === "task" ? evaluator.task : location.position.type === "scorer" ? (evaluator.scores ?? [])[location.position.index] : (evaluator.classifiers ?? [])[location.position.index];
     }
   } else if (location.type === "function") {
     fn = outFileModule.functions[location.index].handler;
@@ -21617,23 +24613,42 @@ async function uploadHandleBundles({
           function_type: "task",
           origin
         },
-        ...evaluator.evaluator.scores.map((score, i) => {
-          const name = scorerName(score, i);
-          return {
-            ...baseInfo,
-            // There is a very small chance that someone names a function with the same convention, but
-            // let's assume it's low enough that it doesn't matter.
-            ...formatNameAndSlug(["eval", namePrefix, "scorer", name]),
-            description: `Score ${name} for eval ${namePrefix}`,
-            location: {
-              type: "experiment",
-              eval_name: evaluator.evaluator.evalName,
-              position: { type: "scorer", index: i }
-            },
-            function_type: "scorer",
-            origin
-          };
-        })
+        ...(evaluator.evaluator.scores ?? []).map(
+          (score, i) => {
+            const name = scorerName(score, i);
+            return {
+              ...baseInfo,
+              // There is a very small chance that someone names a function with the same convention, but
+              // let's assume it's low enough that it doesn't matter.
+              ...formatNameAndSlug(["eval", namePrefix, "scorer", name]),
+              description: `Score ${name} for eval ${namePrefix}`,
+              location: {
+                type: "experiment",
+                eval_name: evaluator.evaluator.evalName,
+                position: { type: "scorer", index: i }
+              },
+              function_type: "scorer",
+              origin
+            };
+          }
+        ),
+        ...(evaluator.evaluator.classifiers ?? []).map(
+          (classifier, i) => {
+            const name = classifierName(classifier, i);
+            return {
+              ...baseInfo,
+              ...formatNameAndSlug(["eval", namePrefix, "classifier", name]),
+              description: `Classifier ${name} for eval ${namePrefix}`,
+              location: {
+                type: "experiment",
+                eval_name: evaluator.evaluator.evalName,
+                position: { type: "classifier", index: i }
+              },
+              function_type: "classifier",
+              origin
+            };
+          }
+        )
       ];
       bundleSpecs.push(...fileSpecs);
       if (setCurrent) {
@@ -21645,9 +24660,14 @@ async function uploadHandleBundles({
           ...resolvedParameters ? {
             parameters: serializeRemoteEvalParametersContainer(resolvedParameters)
           } : {},
-          scores: evaluator.evaluator.scores.map((score, i) => ({
+          scores: (evaluator.evaluator.scores ?? []).map((score, i) => ({
             name: scorerName(score, i)
-          }))
+          })),
+          classifiers: (evaluator.evaluator.classifiers ?? []).map(
+            (classifier, i) => ({
+              name: classifierName(classifier, i)
+            })
+          )
         };
         bundleSpecs.push({
           ...baseInfo,
@@ -22423,7 +25443,8 @@ var baseAllowedHeaders = [
   "x-stainless-package-version",
   "x-stainless-runtime",
   "x-stainless-runtime-version",
-  "x-stainless-arch"
+  "x-stainless-arch",
+  "x-bt-use-gateway"
 ];
 
 // dev/stream.ts
@@ -22500,7 +25521,8 @@ var serializedParametersContainerSchema = import_v315.z.union([
 ]);
 var evaluatorDefinitionSchema = import_v315.z.object({
   parameters: serializedParametersContainerSchema.optional(),
-  scores: import_v315.z.array(import_v315.z.object({ name: import_v315.z.string() })).optional()
+  scores: import_v315.z.array(import_v315.z.object({ name: import_v315.z.string() })).optional(),
+  classifiers: import_v315.z.array(import_v315.z.object({ name: import_v315.z.string() })).optional()
 });
 var evaluatorDefinitionsSchema = import_v315.z.record(
   import_v315.z.string(),
@@ -22557,8 +25579,11 @@ function runDevServer(evaluators, opts) {
         }
         evalDefs[name] = {
           parameters,
-          scores: evaluator.scores.map((score, idx) => ({
+          scores: (evaluator.scores ?? []).map((score, idx) => ({
             name: scorerName(score, idx)
+          })),
+          classifiers: (evaluator.classifiers ?? []).map((classifier, idx) => ({
+            name: classifierName(classifier, idx)
           }))
         };
       }
@@ -22629,7 +25654,7 @@ function runDevServer(evaluators, opts) {
           {
             ...evaluator,
             data: evalData.data,
-            scores: evaluator.scores.concat(
+            scores: (evaluator.scores ?? []).concat(
               scores?.map(
                 (score) => makeScorer(
                   state,