braintrust 3.30.0 → 3.32.0

package/dist/index.mjs

@@ -143,7 +143,7 @@ import {
   wrapMastraAgent,
   wrapTraced,
   zodToJsonSchema
-} from "./chunk-BU6SM54N.mjs";
+} from "./chunk-4QSAHP7D.mjs";
 import {
   INSTRUMENTATION_NAMES,
   __export,
@@ -156,10 +156,12 @@ import {
   cohereChannels,
   cursorSDKChannels,
   debugLogger,
+  elevenLabsChannels,
   genkitChannels,
   gitHubCopilotChannels,
   googleADKChannels,
   googleGenAIChannels,
+  googleGenerativeAIChannels,
   groqChannels,
   harnessAgentChannels,
   huggingFaceChannels,
@@ -177,7 +179,7 @@ import {
   strandsAgentSDKChannels,
   voyageAIChannels,
   withSpanInstrumentationName
-} from "./chunk-N3JKQ3D3.mjs";
+} from "./chunk-WV6QZI2W.mjs";
 
 // src/exports.ts
 var exports_exports = {};
@@ -343,9 +345,11 @@ __export(exports_exports, {
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
+  wrapElevenLabs: () => wrapElevenLabs,
   wrapGenkit: () => wrapGenkit,
   wrapGoogleADK: () => wrapGoogleADK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
+  wrapGoogleGenerativeAI: () => wrapGoogleGenerativeAI,
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
   wrapHuggingFaceTransformers: () => wrapHuggingFaceTransformers,
@@ -5214,6 +5218,75 @@ function isModuleNamespace5(value) {
   }
 }
 
+// src/wrappers/google-generative-ai.ts
+function wrapGoogleGenerativeAI(client) {
+  if (!isObject(client) || typeof client.getGenerativeModel !== "function")
+    return client;
+  return wrapClient(client);
+}
+var proxies = /* @__PURE__ */ new WeakMap();
+function wrapClient(client) {
+  const cached = proxies.get(client);
+  if (cached) return cached;
+  const proxy = new Proxy(client, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      if (prop === "getGenerativeModel" || prop === "getGenerativeModelFromCachedContent" || prop === "startChat") {
+        return (...args) => wrapClient(Reflect.apply(value, target, args));
+      }
+      switch (prop) {
+        case "generateContent":
+          return (...args) => googleGenerativeAIChannels.generateContent.invoke(
+            value,
+            target,
+            args,
+            {}
+          );
+        case "generateContentStream":
+          return (...args) => googleGenerativeAIChannels.generateContentStream.invoke(
+            value,
+            target,
+            args,
+            {}
+          );
+        case "embedContent":
+          return (...args) => googleGenerativeAIChannels.embedContent.invoke(
+            value,
+            target,
+            args,
+            {}
+          );
+        case "batchEmbedContents":
+          return (...args) => googleGenerativeAIChannels.batchEmbedContents.invoke(
+            value,
+            target,
+            args,
+            {}
+          );
+        case "sendMessage":
+          return (...args) => googleGenerativeAIChannels.sendMessage.invoke(
+            value,
+            target,
+            args,
+            {}
+          );
+        case "sendMessageStream":
+          return (...args) => googleGenerativeAIChannels.sendMessageStream.invoke(
+            value,
+            target,
+            args,
+            {}
+          );
+      }
+      return value.bind(target);
+    }
+  });
+  proxies.set(client, proxy);
+  proxies.set(proxy, proxy);
+  return proxy;
+}
+
 // src/wrappers/google-genai.ts
 function wrapGoogleGenAI(googleGenAI) {
   if (!googleGenAI || typeof googleGenAI !== "object") {
@@ -7170,8 +7243,8 @@ function normalizeScores(result) {
       (s) => s !== null && s !== void 0 && typeof s === "object" && isScore(s)
     );
   }
-  if (typeof result === "object" && result !== null && isScore(result)) {
-    return [result];
+  if (typeof result === "object" && result !== null && "score" in result) {
+    return [{ ...result, name: result.name ?? "score" }];
   }
   return [];
 }
@@ -9754,19 +9827,29 @@ function buildSpanScores(results) {
 function _internalPrepareEvaluatorScore(scoreValue, name) {
   if (scoreValue === null) return { results: null };
   if (Array.isArray(scoreValue)) {
+    const names = /* @__PURE__ */ new Set();
     for (const score of scoreValue) {
       if (!(typeof score === "object" && !isEmpty(score))) {
         throw new Error(
           `When returning an array of scores, each score must be a non-empty object. Got: ${JSON.stringify(score)}`
         );
       }
+      if (typeof score.name !== "string") {
+        throw new Error(
+          `When returning an array of scores, each score must have a name. Got: ${JSON.stringify(score)}`
+        );
+      }
+      if (names.has(score.name)) {
+        throw new Error(`Duplicate score name '${score.name}' in score array`);
+      }
+      names.add(score.name);
     }
   }
   let results;
   if (Array.isArray(scoreValue)) {
     results = scoreValue;
   } else if (typeof scoreValue === "object" && !isEmpty(scoreValue)) {
-    results = [scoreValue];
+    results = [{ ...scoreValue, name: scoreValue.name ?? name }];
   } else {
     results = [{ name, score: scoreValue }];
   }
@@ -12524,6 +12607,65 @@ var evaluatorDefinitionsSchema = z5.record(
   evaluatorDefinitionSchema
 );
 
+// src/wrappers/elevenlabs.ts
+var clients = /* @__PURE__ */ new WeakMap();
+function wrapElevenLabs(client) {
+  if (!isObject(client) || !isObject(client.textToSpeech) || typeof client.textToSpeech.convert !== "function") {
+    debugLogger.warn("Unsupported ElevenLabs client. Not wrapping.");
+    return client;
+  }
+  const cached = clients.get(client);
+  if (cached) return cached;
+  const sdk = client;
+  const speech = new Proxy(sdk.textToSpeech, {
+    get(target, prop, receiver) {
+      switch (prop) {
+        case "convert":
+        case "stream":
+          return (...args) => elevenLabsChannels[prop].invoke(target[prop], target, args, {});
+        case "convertWithTimestamps":
+          return (...args) => elevenLabsChannels.convertWithTimestamps.invoke(
+            target.convertWithTimestamps,
+            target,
+            args,
+            {}
+          );
+        case "streamWithTimestamps":
+          return (...args) => elevenLabsChannels.streamWithTimestamps.invoke(
+            target.streamWithTimestamps,
+            target,
+            args,
+            {}
+          );
+        default:
+          return Reflect.get(target, prop, receiver);
+      }
+    }
+  });
+  const transcription = new Proxy(sdk.speechToText, {
+    get(target, prop, receiver) {
+      if (prop === "convert")
+        return (request, options) => elevenLabsChannels.transcribe.invoke(
+          target.convert,
+          target,
+          [request, options],
+          {}
+        );
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  const proxy = new Proxy(sdk, {
+    get(target, prop, receiver) {
+      if (prop === "textToSpeech") return speech;
+      if (prop === "speechToText") return transcription;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  clients.set(client, proxy);
+  clients.set(proxy, proxy);
+  return proxy;
+}
+
 // src/node/index.ts
 configureNode();
 export {
@@ -12689,9 +12831,11 @@ export {
   wrapCohere,
   wrapCopilotClient,
   wrapCursorSDK,
+  wrapElevenLabs,
   wrapGenkit,
   wrapGoogleADK,
   wrapGoogleGenAI,
+  wrapGoogleGenerativeAI,
   wrapGroq,
   wrapHuggingFace,
   wrapHuggingFaceTransformers,