braintrust 3.30.0 → 3.32.0

package/dist/edge-light.js

@@ -192,9 +192,11 @@ __export(edge_light_exports, {
   wrapCohere: () => wrapCohere,
   wrapCopilotClient: () => wrapCopilotClient,
   wrapCursorSDK: () => wrapCursorSDK,
+  wrapElevenLabs: () => wrapElevenLabs,
   wrapGenkit: () => wrapGenkit,
   wrapGoogleADK: () => wrapGoogleADK,
   wrapGoogleGenAI: () => wrapGoogleGenAI,
+  wrapGoogleGenerativeAI: () => wrapGoogleGenerativeAI,
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
   wrapHuggingFaceTransformers: () => wrapHuggingFaceTransformers,
@@ -3028,6 +3030,14 @@ var ChatCompletionContentPartImageWithTitle = import_v36.z.object({
     ttl: import_v36.z.enum(["5m", "1h"]).optional()
   }).optional()
 });
+var ChatCompletionContentPartInputAudioWithTitle = import_v36.z.object({
+  input_audio: import_v36.z.object({ data: import_v36.z.string(), format: import_v36.z.enum(["wav", "mp3"]) }),
+  type: import_v36.z.literal("input_audio"),
+  cache_control: import_v36.z.object({
+    type: import_v36.z.literal("ephemeral"),
+    ttl: import_v36.z.enum(["5m", "1h"]).optional()
+  }).optional()
+});
 var ChatCompletionContentPartFileFile = import_v36.z.object({ file_data: import_v36.z.string(), filename: import_v36.z.string(), file_id: import_v36.z.string() }).partial();
 var ChatCompletionContentPartFileWithTitle = import_v36.z.object({
   file: ChatCompletionContentPartFileFile,
@@ -3040,6 +3050,7 @@ var ChatCompletionContentPartFileWithTitle = import_v36.z.object({
 var ChatCompletionContentPart = import_v36.z.union([
   ChatCompletionContentPartTextWithTitle,
   ChatCompletionContentPartImageWithTitle,
+  ChatCompletionContentPartInputAudioWithTitle,
   ChatCompletionContentPartFileWithTitle
 ]);
 var ChatCompletionContentPartText = import_v36.z.object({
@@ -4031,6 +4042,7 @@ var ProjectSettings = import_v36.z.union([
     ]),
     disable_realtime_queries: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
     monitor_charts_use_metrics_start: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
+    blind_reviews: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
     default_preprocessor: NullableSavedFunctionId
   }).partial(),
   import_v36.z.null()
@@ -4092,6 +4104,7 @@ var WindowedAutomationConfig = import_v36.z.object({
     auto_approve_tools: import_v36.z.array(import_v36.z.string().min(1)).optional().default([]),
     harness: import_v36.z.enum(["native", "codex", "claude-code"]).optional(),
     model: import_v36.z.string().min(1).optional(),
+    endpoint_name: import_v36.z.string().min(1).optional(),
     reasoning_effort: import_v36.z.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).optional()
   }).optional(),
   actions: import_v36.z.array(
@@ -5863,6 +5876,7 @@ var INSTRUMENTATION_NAMES = {
   GENKIT: "genkit",
   GITHUB_COPILOT: "github-copilot",
   GOOGLE_ADK: "google-adk",
+  GOOGLE_GENERATIVE_AI: "google-generative-ai",
   GOOGLE_GENAI: "google-genai",
   GROQ: "groq",
   HUGGINGFACE: "huggingface",
@@ -5878,12 +5892,13 @@ var INSTRUMENTATION_NAMES = {
   OPENROUTER_AGENT: "openrouter-agent",
   PI_CODING_AGENT: "pi-coding-agent",
   STRANDS_AGENT_SDK: "strands-agent-sdk",
-  VOYAGEAI: "voyageai"
+  VOYAGEAI: "voyageai",
+  ELEVENLABS: "elevenlabs"
 };
 var INTERNAL_SPAN_INSTRUMENTATION_NAME = /* @__PURE__ */ Symbol.for(
   "braintrust.spanInstrumentationName"
 );
-var SDK_VERSION = true ? "3.30.0" : "0.0.0";
+var SDK_VERSION = true ? "3.32.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -11841,6 +11856,16 @@ function renderMessageImpl(render, message, variables) {
                 }
               }
             ];
+          case "input_audio":
+            return [
+              {
+                ...c,
+                input_audio: {
+                  ...c.input_audio,
+                  data: render(c.input_audio.data)
+                }
+              }
+            ];
           case "file":
             return [
               {
@@ -20034,6 +20059,12 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       if (!activeEntry) {
         return result;
       }
+      const executionOptions = args[1];
+      const toolCallId = isObject(executionOptions) ? executionOptions.toolCallId : void 0;
+      const toolInput = {
+        input: serializeToolExecutionInput(args),
+        ...typeof toolCallId === "string" ? { metadata: { toolCallId } } : {}
+      };
       if (isAsyncGenerator(result)) {
         return (async function* () {
           const span = activeEntry.parentSpan.startSpan(
@@ -20047,7 +20078,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
               INSTRUMENTATION_NAMES.AI_SDK
             )
           );
-          span.log({ input: serializeToolExecutionInput(args) });
+          span.log(toolInput);
           try {
             let lastValue;
             for await (const value of result) {
@@ -20065,7 +20096,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       }
       return activeEntry.parentSpan.traced(
         async (span) => {
-          span.log({ input: serializeToolExecutionInput(args) });
+          span.log(toolInput);
           const awaitedResult = await result;
           span.log({ output: awaitedResult });
           return awaitedResult;
@@ -24469,6 +24500,342 @@ var OpenAIAgentsPlugin = class extends BasePlugin {
   }
 };
 
+// src/instrumentation/plugins/google-generative-ai-channels.ts
+var googleGenerativeAIChannels = defineChannels(
+  "@google/generative-ai",
+  {
+    generateContent: channel({ channelName: "GenerativeModel.generateContent", kind: "async" }),
+    generateContentStream: channel({ channelName: "GenerativeModel.generateContentStream", kind: "async" }),
+    embedContent: channel({ channelName: "GenerativeModel.embedContent", kind: "async" }),
+    batchEmbedContents: channel({ channelName: "GenerativeModel.batchEmbedContents", kind: "async" }),
+    sendMessage: channel({ channelName: "ChatSession.sendMessage", kind: "async" }),
+    sendMessageStream: channel({ channelName: "ChatSession.sendMessageStream", kind: "async" })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.GOOGLE_GENERATIVE_AI }
+);
+
+// src/instrumentation/plugins/google-generative-ai-plugin.ts
+var GENERATION_CONFIG_KEYS = [
+  "temperature",
+  "topP",
+  "topK",
+  "candidateCount",
+  "maxOutputTokens",
+  "stopSequences",
+  "responseMimeType",
+  "responseSchema",
+  "presencePenalty",
+  "frequencyPenalty",
+  "responseLogprobs",
+  "logprobs",
+  "thinkingConfig"
+];
+var GoogleGenerativeAIPlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(
+      interceptCall(
+        googleGenerativeAIChannels.generateContent,
+        "generateContent"
+      ),
+      interceptCall(
+        googleGenerativeAIChannels.generateContentStream,
+        "generateContentStream"
+      ),
+      interceptCall(googleGenerativeAIChannels.sendMessage, "sendMessage"),
+      interceptCall(
+        googleGenerativeAIChannels.sendMessageStream,
+        "sendMessageStream"
+      ),
+      interceptCall(googleGenerativeAIChannels.embedContent, "embedContent"),
+      interceptCall(
+        googleGenerativeAIChannels.batchEmbedContents,
+        "batchEmbedContents"
+      )
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function interceptCall(channel2, operation) {
+  return channel2.intercept((target, thisArg, args) => {
+    const invokeTarget = () => Reflect.apply(target, thisArg, args);
+    if (isAutoInstrumentationSuppressed()) return invokeTarget();
+    const self = thisArg;
+    const chat = operation.startsWith("sendMessage");
+    const embedding = operation === "embedContent" || operation === "batchEmbedContents";
+    const start = getCurrentUnixTimestamp();
+    let span;
+    try {
+      span = startSpan(
+        withSpanInstrumentationName(
+          {
+            name: embedding ? operation === "embedContent" ? "embed_content" : "batch_embed_contents" : "generate_content",
+            spanAttributes: { type: "llm" /* LLM */ },
+            event: extractInput(self, args[0], operation)
+          },
+          INSTRUMENTATION_NAMES.GOOGLE_GENERATIVE_AI
+        )
+      );
+    } catch (error) {
+      debugLogger.error("Error starting Google Generative AI span:", error);
+      return invokeTarget();
+    }
+    let ended = false;
+    const finish = (log3) => {
+      if (ended) return;
+      ended = true;
+      try {
+        log3();
+      } catch (error) {
+        debugLogger.error("Error logging Google Generative AI span:", error);
+      }
+      try {
+        span.end();
+      } catch (error) {
+        debugLogger.error("Error ending Google Generative AI span:", error);
+      }
+    };
+    if (chat) {
+      try {
+        void self._sendPromise.then(
+          () => {
+            try {
+              span.log(extractInput(self, args[0], operation));
+            } catch (error) {
+              debugLogger.error("Error capturing Google chat history:", error);
+            }
+          },
+          () => {
+          }
+        );
+      } catch (error) {
+        debugLogger.error("Error observing Google chat history:", error);
+      }
+    }
+    let result;
+    try {
+      result = withCurrent(
+        span,
+        () => runWithAutoInstrumentationSuppressed(invokeTarget)
+      );
+    } catch (error) {
+      finish(() => span.log({ error }));
+      throw error;
+    }
+    void Promise.resolve(result).then(
+      (value) => {
+        try {
+          if ("stream" in value) {
+            let firstToken = false;
+            const partial = { candidates: [] };
+            const candidates = /* @__PURE__ */ new Map();
+            patchStreamIfNeeded(value.stream, {
+              aroundNext: (callback) => withCurrent(span, callback),
+              onChunk: (chunk) => {
+                for (const candidate of chunk.candidates ?? []) {
+                  const index = candidate.index ?? 0;
+                  const previous = candidates.get(index);
+                  const parts = [...previous?.content?.parts ?? []];
+                  for (const part of candidate.content?.parts ?? []) {
+                    const last = parts[parts.length - 1];
+                    if (part.text !== void 0 && last?.text !== void 0) {
+                      parts[parts.length - 1] = {
+                        ...last,
+                        text: last.text + part.text
+                      };
+                    } else parts.push(part);
+                  }
+                  candidates.set(index, {
+                    ...previous,
+                    ...candidate,
+                    content: {
+                      role: candidate.content?.role ?? previous?.content?.role ?? "model",
+                      parts
+                    }
+                  });
+                }
+                partial.candidates = Array.from(candidates.values());
+                if (chunk.usageMetadata)
+                  partial.usageMetadata = chunk.usageMetadata;
+                if (!firstToken && chunk.candidates?.some(
+                  (candidate) => candidate.content?.parts.some(
+                    (part) => part.text !== void 0 ? part.text.length > 0 : Object.keys(part).length > 0
+                  )
+                )) {
+                  firstToken = true;
+                  span.log({
+                    metrics: {
+                      time_to_first_token: getCurrentUnixTimestamp() - start
+                    }
+                  });
+                }
+              },
+              onComplete: () => {
+              },
+              onError: (error) => finish(() => {
+                logResponse(span, partial);
+                span.log({ error });
+              }),
+              onCancel: () => finish(() => logResponse(span, partial))
+            });
+            void value.response.then(
+              (response) => finish(() => logResponse(span, response)),
+              (error) => finish(() => {
+                logResponse(span, partial);
+                span.log({ error });
+              })
+            );
+          } else if ("response" in value) {
+            finish(() => logResponse(span, value.response));
+          } else {
+            const metrics = {};
+            const promptTokens = value.usageMetadata?.promptTokenCount;
+            if (typeof promptTokens === "number" && Number.isFinite(promptTokens) && promptTokens >= 0) {
+              metrics.prompt_tokens = promptTokens;
+              metrics.tokens = promptTokens;
+            }
+            for (const detail of value.usageMetadata?.promptTokenDetails ?? []) {
+              if (detail.modality === "AUDIO" && typeof detail.tokenCount === "number" && Number.isFinite(detail.tokenCount) && detail.tokenCount >= 0) {
+                metrics.prompt_audio_tokens = (metrics.prompt_audio_tokens ?? 0) + detail.tokenCount;
+              }
+            }
+            finish(
+              () => span.log({
+                metrics,
+                output: {
+                  count: value.embeddings?.length ?? (value.embedding ? 1 : 0)
+                }
+              })
+            );
+          }
+        } catch (error) {
+          debugLogger.error(
+            "Error observing Google Generative AI result:",
+            error
+          );
+          finish(() => {
+          });
+        }
+      },
+      (error) => finish(() => span.log({ error }))
+    );
+    return result;
+  });
+}
+function normalizeContent(message) {
+  const parts = (typeof message === "string" ? [message] : message).map(
+    (part) => typeof part === "string" ? { text: part } : part
+  );
+  return {
+    role: parts.some((part) => part.functionResponse) ? "function" : "user",
+    parts
+  };
+}
+function extractInput(self, request, operation) {
+  const model = self.model.replace(/^models\//, "");
+  if (operation === "embedContent" || operation === "batchEmbedContents") {
+    const requests = operation === "batchEmbedContents" ? request.requests : [
+      typeof request === "string" || Array.isArray(request) ? { content: normalizeContent(request) } : request
+    ];
+    const dimensions = requests[0]?.outputDimensionality;
+    return {
+      input: {
+        inputs: convertAttachments(requests).map((item) => ({
+          content: item.content.parts.length === 1 && item.content.parts[0].text !== void 0 ? item.content.parts[0].text : item.content.parts.map((part) => {
+            if (part.text !== void 0)
+              return { type: "text", text: part.text };
+            const mimeType = part.inlineData?.mimeType ?? part.fileData?.mimeType;
+            const data = part.inlineData ? typeof part.inlineData.data === "string" ? `data:${mimeType};base64,${part.inlineData.data}` : part.inlineData.data : part.fileData?.fileUri;
+            return mimeType?.startsWith("image/") ? { type: "image_url", image_url: { url: data } } : { type: "file", file: { file_data: data } };
+          })
+        })),
+        ...dimensions !== void 0 && requests.every((item) => item.outputDimensionality === dimensions) ? { output_dimensions: dimensions } : {}
+      },
+      metadata: { model, provider: "google" }
+    };
+  }
+  const chat = operation.startsWith("sendMessage");
+  const config = chat ? self.params ?? {} : self;
+  const params = typeof request === "string" || Array.isArray(request) ? { contents: [normalizeContent(request)] } : request;
+  const system = params.systemInstruction ?? config.systemInstruction;
+  const systemContent = typeof system === "string" ? { role: "system", parts: [{ text: system }] } : system && "parts" in system ? { ...system, role: "system" } : system ? { role: "system", parts: [system] } : void 0;
+  const contents = [
+    ...systemContent ? [systemContent] : [],
+    ...chat ? self._history : [],
+    ...params.contents
+  ];
+  const metadata = { model, provider: "google" };
+  const generation = params.generationConfig ?? config.generationConfig;
+  for (const key of GENERATION_CONFIG_KEYS) {
+    if (generation && Object.hasOwn(generation, key))
+      metadata[key] = generation[key];
+  }
+  for (const key of ["tools", "toolConfig", "safetySettings"]) {
+    const value = params[key] ?? config[key];
+    if (value !== void 0) metadata[key] = value;
+  }
+  const cached = params.cachedContent ?? config.cachedContent;
+  if (cached)
+    metadata.cachedContent = typeof cached === "string" ? cached : cached.name;
+  return { input: convertAttachments({ model, contents }), metadata };
+}
+function convertAttachments(value) {
+  const convert = (node) => {
+    if (Array.isArray(node)) return node.map(convert);
+    if (!isObject(node)) return node;
+    if (isObject(node.inlineData)) {
+      const { data, mimeType } = node.inlineData;
+      const processed = processInputAttachments({
+        type: "file",
+        file: { file_data: `data:${mimeType};base64,${data}` }
+      });
+      if (typeof processed.file.file_data === "string")
+        throw new Error("Unable to convert Google inline data");
+      return {
+        ...node,
+        inlineData: { ...node.inlineData, data: processed.file.file_data }
+      };
+    }
+    return Object.fromEntries(
+      Object.entries(node).map(([key, item]) => [key, convert(item)])
+    );
+  };
+  try {
+    return convert(value);
+  } catch (error) {
+    debugLogger.error(
+      "Error converting Google Generative AI attachments:",
+      error
+    );
+    return value;
+  }
+}
+function logResponse(span, response) {
+  const usage = response.usageMetadata;
+  const metrics = {};
+  if (usage) {
+    if (usage.promptTokenCount !== void 0)
+      metrics.prompt_tokens = usage.promptTokenCount;
+    if (usage.candidatesTokenCount !== void 0 || usage.thoughtsTokenCount !== void 0)
+      metrics.completion_tokens = (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0);
+    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;
+  }
+  span.log({
+    output: convertAttachments({
+      candidates: response.candidates,
+      promptFeedback: response.promptFeedback
+    }),
+    metrics,
+    ...response.modelVersion ? { metadata: { model: response.modelVersion } } : {}
+  });
+}
+
 // src/instrumentation/plugins/google-genai-channels.ts
 var googleGenAIChannels = defineChannels(
   "@google/genai",
@@ -26112,7 +26479,7 @@ var HuggingFaceTransformersPlugin = class extends BasePlugin {
           getTask(event)
         ),
         extractInput: (args, event) => ({
-          input: extractInput(
+          input: extractInput2(
             getTask(event),
             args
           ),
@@ -26202,7 +26569,7 @@ function modelIdentifier(pipeline) {
   }
   return void 0;
 }
-function extractInput(task, args) {
+function extractInput2(task, args) {
   switch (task) {
     case "feature-extraction":
       return args[0];
@@ -34187,14 +34554,17 @@ function getMetricsFromResponse(response) {
     if (!isRecord(usageMetadata)) {
       continue;
     }
-    const inputTokenDetails = usageMetadata.input_token_details;
+    const inputTokenDetails = isRecord(usageMetadata.input_token_details) ? usageMetadata.input_token_details : {};
     const outputTokenDetails = usageMetadata.output_token_details;
     return normalizeTokenMetrics({
       total_tokens: usageMetadata.total_tokens,
       prompt_tokens: usageMetadata.input_tokens,
       completion_tokens: usageMetadata.output_tokens,
-      prompt_cache_creation_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_creation : void 0,
-      prompt_cached_tokens: isRecord(inputTokenDetails) ? inputTokenDetails.cache_read : void 0,
+      // Prefer TTL-specific cache writes over the aggregate when available.
+      prompt_cache_creation_tokens: inputTokenDetails.ephemeral_5m_input_tokens == null && inputTokenDetails.ephemeral_1h_input_tokens == null ? inputTokenDetails.cache_creation : void 0,
+      prompt_cache_creation_5m_tokens: inputTokenDetails.ephemeral_5m_input_tokens,
+      prompt_cache_creation_1h_tokens: inputTokenDetails.ephemeral_1h_input_tokens,
+      prompt_cached_tokens: inputTokenDetails.cache_read,
       completion_reasoning_tokens: isRecord(outputTokenDetails) ? outputTokenDetails.reasoning : void 0
     });
   }
@@ -36553,6 +36923,477 @@ function logInstrumentationError5(context, error) {
   debugLogger.debug(`${context}:`, error);
 }
 
+// src/instrumentation/plugins/elevenlabs-channels.ts
+var elevenLabsChannels = defineChannels(
+  "@elevenlabs/elevenlabs-js",
+  {
+    convert: channel({
+      channelName: "textToSpeech.convert",
+      kind: "async"
+    }),
+    stream: channel({
+      channelName: "textToSpeech.stream",
+      kind: "async"
+    }),
+    convertWithTimestamps: channel({ channelName: "textToSpeech.convertWithTimestamps", kind: "async" }),
+    streamWithTimestamps: channel({ channelName: "textToSpeech.streamWithTimestamps", kind: "async" }),
+    transcribe: channel({ channelName: "speechToText.convert", kind: "async" })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.ELEVENLABS }
+);
+
+// src/instrumentation/plugins/elevenlabs-plugin.ts
+var ElevenLabsPlugin = class extends BasePlugin {
+  onEnable() {
+    for (const method of [
+      "convert",
+      "stream",
+      "convertWithTimestamps",
+      "streamWithTimestamps"
+    ]) {
+      this.unsubscribers.push(
+        interceptCall2(
+          elevenLabsChannels[method],
+          `elevenlabs.textToSpeech.${method}`,
+          ([voice, request]) => ({
+            input: {
+              operation: "speech",
+              prompt: request.text,
+              parameters: {
+                voice,
+                format: request.outputFormat,
+                language: request.languageCode,
+                speed: request.voiceSettings?.speed
+              }
+            },
+            metadata: {
+              provider: "elevenlabs",
+              model: request.modelId ?? "eleven_multilingual_v2"
+            }
+          }),
+          (value, args, span, finish, headers, started) => captureSpeech(
+            value,
+            args[1],
+            method,
+            span,
+            finish,
+            started,
+            headers
+          )
+        )
+      );
+    }
+    this.unsubscribers.push(
+      interceptCall2(
+        elevenLabsChannels.transcribe,
+        "elevenlabs.speechToText.convert",
+        ([request]) => {
+          if (request.webhook) return void 0;
+          const file = request.file;
+          const filename = typeof File !== "undefined" && file instanceof File ? file.name : "audio";
+          const contentType = file instanceof Blob ? file.type || "application/octet-stream" : "application/octet-stream";
+          const blob = file instanceof Blob ? file : file instanceof Uint8Array ? new Blob([new Uint8Array(file)], { type: contentType }) : file instanceof ArrayBuffer ? new Blob([file.slice(0)], { type: contentType }) : void 0;
+          const fileData = blob ? new Attachment({ data: blob, filename, contentType }) : request.cloudStorageUrl;
+          return {
+            input: {
+              operation: "transcribe",
+              content: fileData ? [{ type: "file", file: { filename, file_data: fileData } }] : [],
+              parameters: {
+                language: request.languageCode,
+                timestamp_granularities: request.timestampsGranularity
+              }
+            },
+            metadata: { provider: "elevenlabs", model: request.modelId }
+          };
+        },
+        (value, _args, span, finish) => {
+          const result = value;
+          const transcripts = result.transcripts ?? [result];
+          span.log({
+            output: {
+              content: transcripts.flatMap(
+                (transcript) => typeof transcript.text === "string" ? [{ type: "text", text: transcript.text }] : []
+              ),
+              annotations: {
+                language: result.languageCode,
+                words: result.words ?? (result.transcripts ? result.transcripts.flatMap(
+                  (transcript) => transcript.words ?? []
+                ) : void 0)
+              }
+            }
+          });
+          finish();
+        },
+        ([request], span) => {
+          const file = request.file;
+          if (!isAsyncIterable(file)) return;
+          const chunks = [];
+          const filename = isObject(file) && typeof file.path === "string" ? file.path.split(/[\\/]/).pop() || "audio" : "audio";
+          observeAudioStream(
+            file,
+            (chunk) => chunks.push(new Uint8Array(chunk)),
+            () => {
+              const contentType = "application/octet-stream";
+              const data = new Blob(chunks, {
+                type: contentType
+              });
+              chunks.length = 0;
+              span.log({
+                input: {
+                  content: [
+                    {
+                      type: "file",
+                      file: {
+                        filename,
+                        file_data: new Attachment({
+                          data,
+                          filename,
+                          contentType
+                        })
+                      }
+                    }
+                  ]
+                }
+              });
+            },
+            () => {
+              chunks.length = 0;
+            },
+            span
+          );
+        }
+      )
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function interceptCall2(channel2, name, input, output, beforeInvoke) {
+  return channel2.intercept((target, self, args) => {
+    const invoke2 = () => Reflect.apply(target, self, args);
+    if (isAutoInstrumentationSuppressed()) return invoke2();
+    const started = Date.now() / 1e3;
+    let span;
+    try {
+      const event = input(args);
+      if (event !== void 0)
+        span = startSpan(
+          withSpanInstrumentationName(
+            {
+              name,
+              spanAttributes: { type: "llm" /* LLM */ },
+              event
+            },
+            INSTRUMENTATION_NAMES.ELEVENLABS
+          )
+        );
+    } catch (error) {
+      debugLogger.error("Error starting ElevenLabs span", error);
+      return invoke2();
+    }
+    if (!span) return invoke2();
+    const activeSpan = span;
+    let ended = false;
+    const finish = (error) => {
+      if (ended) return;
+      ended = true;
+      try {
+        if (error !== void 0) activeSpan.log({ error });
+        activeSpan.end();
+      } catch (loggingError) {
+        debugLogger.error("Error ending ElevenLabs span", loggingError);
+      }
+    };
+    try {
+      beforeInvoke?.(args, span);
+    } catch (error) {
+      debugLogger.error("Error observing ElevenLabs input", error);
+    }
+    let result;
+    try {
+      result = withCurrent(
+        span,
+        () => runWithAutoInstrumentationSuppressed(invoke2)
+      );
+    } catch (error) {
+      finish(error);
+      throw error;
+    }
+    const capture = (value, headers) => {
+      try {
+        output(value, args, span, finish, headers, started);
+      } catch (error) {
+        debugLogger.error("Error capturing ElevenLabs output", error);
+        finish();
+      }
+    };
+    try {
+      if (isObject(result) && typeof result.withRawResponse === "function") {
+        void result.withRawResponse().then(
+          ({
+            data,
+            rawResponse
+          }) => capture(data, rawResponse?.headers),
+          finish
+        );
+      } else {
+        void Promise.resolve(result).then((value) => capture(value), finish);
+      }
+    } catch (error) {
+      debugLogger.error("Error observing ElevenLabs result", error);
+      finish();
+    }
+    return result;
+  });
+}
+function captureSpeech(value, request, method, span, finish, started, headers) {
+  const format = request.outputFormat ?? "mp3_44100_128";
+  const formatType = format.startsWith("mp3_") ? "audio/mpeg" : format.startsWith("pcm_") ? "audio/pcm" : format.startsWith("opus_") ? "audio/ogg" : format.startsWith("ulaw_") ? "audio/basic" : format.startsWith("alaw_") ? "audio/x-alaw" : void 0;
+  const headerType = headers?.get("content-type")?.split(";")[0];
+  const contentType = headerType?.startsWith("audio/") ? headerType : formatType;
+  const disposition = headers?.get("content-disposition");
+  const headerFilename = disposition?.match(
+    /filename="([^"]+)"|filename=([^;]+)/i
+  );
+  const filename = headerFilename?.[1] ?? headerFilename?.[2]?.trim() ?? `speech.${contentType ? getExtensionFromMediaType(contentType) : "bin"}`;
+  const chunks = [];
+  const alignments = [];
+  let bytes = 0;
+  let first = true;
+  let stopped = false;
+  const observe = (chunk) => {
+    if (stopped || chunk.byteLength === 0) return;
+    if (first && method.startsWith("stream")) {
+      span.log({
+        metrics: { time_to_first_token: Date.now() / 1e3 - started }
+      });
+    }
+    first = false;
+    chunks.push(new Uint8Array(chunk));
+    bytes += chunk.byteLength;
+  };
+  const complete = () => {
+    if (stopped) return;
+    stopped = true;
+    try {
+      const content = [];
+      if (contentType && bytes) {
+        const data = new Uint8Array(bytes);
+        let offset = 0;
+        for (const chunk of chunks) {
+          data.set(chunk, offset);
+          offset += chunk.length;
+        }
+        content.push({
+          type: "file",
+          file: {
+            filename,
+            byte_size: bytes,
+            file_data: new Attachment({
+              data: new Blob([data], { type: contentType }),
+              filename,
+              contentType
+            })
+          }
+        });
+      }
+      span.log({
+        output: {
+          content,
+          ...alignments.length ? { annotations: alignments } : {}
+        }
+      });
+    } finally {
+      chunks.length = 0;
+      finish();
+    }
+  };
+  const cancel = (error) => {
+    stopped = true;
+    chunks.length = 0;
+    finish(error);
+  };
+  const timestampChunk = (chunk) => {
+    const binary = atob(chunk.audioBase64);
+    observe(Uint8Array.from(binary, (character) => character.charCodeAt(0)));
+    if (chunk.alignment || chunk.normalizedAlignment)
+      alignments.push({
+        alignment: chunk.alignment,
+        normalized_alignment: chunk.normalizedAlignment
+      });
+  };
+  if (method === "convertWithTimestamps") {
+    timestampChunk(value);
+    complete();
+  } else if (method === "streamWithTimestamps") {
+    patchStreamIfNeeded(value, {
+      shouldCollect: (chunk) => {
+        try {
+          timestampChunk(chunk);
+        } catch (error) {
+          debugLogger.error("Error collecting ElevenLabs timestamps", error);
+          cancel();
+        }
+        return false;
+      },
+      onComplete: complete,
+      onCancel: () => cancel(),
+      onError: cancel,
+      aroundNext: (next) => withCurrent(span, next)
+    });
+  } else {
+    observeAudioStream(value, observe, complete, cancel, span);
+  }
+}
+function observeAudioStream(value, observe, complete, cancel, span) {
+  let ended = false;
+  const safeObserve = (chunk) => {
+    if (ended) return;
+    try {
+      observe(chunk);
+    } catch (error) {
+      debugLogger.error("Error collecting ElevenLabs audio", error);
+      end(false);
+    }
+  };
+  const end = (success, error) => {
+    if (ended) return;
+    ended = true;
+    try {
+      if (success) complete();
+      else cancel(error);
+    } catch (loggingError) {
+      debugLogger.error("Error logging ElevenLabs audio", loggingError);
+      cancel();
+    }
+  };
+  if (!isObject(value) || !Object.isExtensible(value)) {
+    end(false);
+    return;
+  }
+  if (typeof value.read === "function" && typeof value.on === "function") {
+    value.on("end", () => end(true));
+    value.on("close", () => end(false));
+    const emit2 = value.emit;
+    if (typeof emit2 === "function")
+      value.emit = function(event, ...args) {
+        if (event === "data" && args[0] instanceof Uint8Array)
+          safeObserve(args[0]);
+        if (event === "error") end(false, args[0]);
+        return Reflect.apply(emit2, this, [event, ...args]);
+      };
+    return;
+  }
+  if (typeof value.getReader === "function") {
+    const webStream = value;
+    const pipeTo = webStream.pipeTo;
+    const pipeThrough = webStream.pipeThrough;
+    webStream.pipeTo = function(destination, options) {
+      if (!isObject(destination) || this.locked || destination.locked)
+        return pipeTo.call(this, destination, options);
+      const tap = new TransformStream({
+        transform(chunk, controller) {
+          safeObserve(chunk);
+          controller.enqueue(chunk);
+        },
+        flush() {
+          end(true);
+        }
+      });
+      const observed = pipeThrough.call(
+        this,
+        tap,
+        options
+      );
+      return observed.pipeTo(destination, options).catch((error) => {
+        end(false, error);
+        throw error;
+      });
+    };
+    webStream.pipeThrough = function(transform, options) {
+      if (this.locked || transform.writable.locked || transform.readable.locked)
+        return pipeThrough.call(this, transform, options);
+      const result = webStream.pipeTo.call(this, transform.writable, options);
+      void result.catch(() => {
+      });
+      return transform.readable;
+    };
+    const getReader = value.getReader;
+    value.getReader = function(...args) {
+      const reader = Reflect.apply(getReader, this, args);
+      const read3 = reader.read;
+      reader.read = function(...readArgs) {
+        return Promise.resolve(
+          withCurrent(span, () => Reflect.apply(read3, this, readArgs))
+        ).then(
+          (result) => {
+            if (result.value) safeObserve(result.value);
+            if (result.done) end(true);
+            return result;
+          },
+          (error) => {
+            end(false, error);
+            throw error;
+          }
+        );
+      };
+      const readerCancel = reader.cancel;
+      reader.cancel = function(...cancelArgs) {
+        const result = Reflect.apply(readerCancel, this, cancelArgs);
+        end(false);
+        return result;
+      };
+      return reader;
+    };
+    const streamCancel = value.cancel;
+    if (typeof streamCancel === "function")
+      value.cancel = function(...args) {
+        const result = Reflect.apply(streamCancel, this, args);
+        void Promise.resolve(result).then(
+          () => end(false),
+          () => {
+          }
+        );
+        return result;
+      };
+  }
+  if (typeof value.getReader === "function" && typeof value.values === "function") {
+    const values = value.values;
+    const iterate = function(...args) {
+      const iterator = Reflect.apply(values, this, args);
+      patchStreamIfNeeded(iterator, {
+        shouldCollect(chunk) {
+          safeObserve(chunk);
+          return false;
+        },
+        onComplete: () => end(true),
+        onCancel: () => end(false),
+        onError: (error) => end(false, error),
+        aroundNext: (next) => withCurrent(span, next)
+      });
+      return iterator;
+    };
+    value.values = iterate;
+    Object.defineProperty(value, Symbol.asyncIterator, {
+      configurable: true,
+      writable: true,
+      value: iterate
+    });
+  } else if (isAsyncIterable(value)) {
+    patchStreamIfNeeded(value, {
+      shouldCollect: (chunk) => {
+        safeObserve(chunk);
+        return false;
+      },
+      onComplete: () => end(true),
+      onCancel: () => end(false),
+      onError: (error) => end(false, error),
+      aroundNext: (next) => withCurrent(span, next)
+    });
+  } else if (typeof value.getReader !== "function") end(false);
+}
+
 // src/instrumentation/plugins/voyageai-channels.ts
 var voyageAIChannels = defineChannels(
   "voyageai",
@@ -36620,7 +37461,7 @@ var VoyageAIPlugin = class extends BasePlugin {
     this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
 };
-function interceptVoyageAICall(channel2, name, extractInput3, extractOutput2, extractMetrics2 = extractUsageMetrics3) {
+function interceptVoyageAICall(channel2, name, extractInput4, extractOutput2, extractMetrics2 = extractUsageMetrics3) {
   return channel2.intercept((target, thisArg, args) => {
     const invokeTarget = () => Reflect.apply(target, thisArg, args);
     if (isAutoInstrumentationSuppressed()) {
@@ -36628,7 +37469,7 @@ function interceptVoyageAICall(channel2, name, extractInput3, extractOutput2, ex
     }
     let span;
     try {
-      const { input, metadata } = extractInput3(args);
+      const { input, metadata } = extractInput4(args);
       span = startSpan(
         withSpanInstrumentationName(
           {
@@ -37427,6 +38268,7 @@ var BraintrustPlugin = class extends BasePlugin {
   cloudflareThinkPlugin = null;
   cursorSDKPlugin = null;
   openAIAgentsPlugin = null;
+  googleGenerativeAIPlugin = null;
   googleGenAIPlugin = null;
   huggingFacePlugin = null;
   huggingFaceTransformersPlugin = null;
@@ -37445,6 +38287,7 @@ var BraintrustPlugin = class extends BasePlugin {
   langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
+  elevenLabsPlugin = null;
   voyageAIPlugin = null;
   cloudflareAIChatPlugin = null;
   cloudflareAgentsPlugin = null;
@@ -37486,6 +38329,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.openAIAgentsPlugin = new OpenAIAgentsPlugin();
       this.openAIAgentsPlugin.enable();
     }
+    if (integrations.googleGenerativeAI !== false) {
+      this.googleGenerativeAIPlugin = new GoogleGenerativeAIPlugin();
+      this.googleGenerativeAIPlugin.enable();
+    }
     if (integrations.googleGenAI !== false && integrations.google !== false) {
       this.googleGenAIPlugin = new GoogleGenAIPlugin();
       this.googleGenAIPlugin.enable();
@@ -37520,6 +38367,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.coherePlugin = new CoherePlugin();
       this.coherePlugin.enable();
     }
+    if (integrations.elevenlabs !== false) {
+      this.elevenLabsPlugin = new ElevenLabsPlugin();
+      this.elevenLabsPlugin.enable();
+    }
     if (integrations.voyageai !== false) {
       this.voyageAIPlugin = new VoyageAIPlugin();
       this.voyageAIPlugin.enable();
@@ -37604,6 +38455,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.openAIAgentsPlugin.disable();
       this.openAIAgentsPlugin = null;
     }
+    if (this.googleGenerativeAIPlugin) {
+      this.googleGenerativeAIPlugin.disable();
+      this.googleGenerativeAIPlugin = null;
+    }
     if (this.googleGenAIPlugin) {
       this.googleGenAIPlugin.disable();
       this.googleGenAIPlugin = null;
@@ -37640,6 +38495,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.coherePlugin.disable();
       this.coherePlugin = null;
     }
+    if (this.elevenLabsPlugin) {
+      this.elevenLabsPlugin.disable();
+      this.elevenLabsPlugin = null;
+    }
     if (this.voyageAIPlugin) {
       this.voyageAIPlugin.disable();
       this.voyageAIPlugin = null;
@@ -37733,6 +38592,8 @@ var envIntegrationAliases = {
   "openai-agents-core": "openAIAgents",
   openaiagentscore: "openAIAgents",
   google: "google",
+  "google-generative-ai": "googleGenerativeAI",
+  googlegenerativeai: "googleGenerativeAI",
   "google-genai": "googleGenAI",
   googlegenai: "googleGenAI",
   huggingface: "huggingface",
@@ -37766,7 +38627,9 @@ var envIntegrationAliases = {
   langsmith: "langsmith",
   voyage: "voyageai",
   "voyage-ai": "voyageai",
-  voyageai: "voyageai"
+  voyageai: "voyageai",
+  elevenlabs: "elevenlabs",
+  "@elevenlabs/elevenlabs-js": "elevenlabs"
 };
 function getDefaultInstrumentationIntegrations() {
   return {
@@ -37777,6 +38640,7 @@ function getDefaultInstrumentationIntegrations() {
     aisdk: true,
     google: true,
     googleGenAI: true,
+    googleGenerativeAI: true,
     googleADK: true,
     huggingface: true,
     claudeAgentSDK: true,
@@ -37802,6 +38666,7 @@ function getDefaultInstrumentationIntegrations() {
     langgraph: true,
     langsmith: true,
     voyageai: true,
+    elevenlabs: true,
     piCodingAgent: true,
     strandsAgentSDK: true,
     cloudflareAgents: true
@@ -38118,9 +38983,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,
@@ -39730,7 +40597,7 @@ function extractToolCallsFromBlocks(blocks) {
   if (!Array.isArray(blocks)) return [];
   return extractToolCallsFromSteps([{ content: blocks }]);
 }
-function extractInput2(params) {
+function extractInput3(params) {
   return params?.prompt ?? params?.messages ?? params?.system;
 }
 var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
@@ -39752,7 +40619,7 @@ function BraintrustMiddleware(config = {}) {
       params,
       model: modelFromWrapGenerate
     }) => {
-      const rawInput = extractInput2(params);
+      const rawInput = extractInput3(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
         name: config.spanInfo?.name || "ai-sdk.doGenerate",
@@ -39816,7 +40683,7 @@ function BraintrustMiddleware(config = {}) {
       }
     },
     wrapStream: async ({ doStream, params }) => {
-      const rawInput = extractInput2(params);
+      const rawInput = extractInput3(params);
       const processedInput = processInputAttachments(rawInput);
       const spanArgs = {
         name: config.spanInfo?.name || "ai-sdk.doStream",
@@ -43209,6 +44076,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") {
@@ -45206,8 +46142,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 [];
 }
@@ -47790,19 +48726,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" && !isEmpty2(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" && !isEmpty2(scoreValue)) {
-    results = [scoreValue];
+    results = [{ ...scoreValue, name: scoreValue.name ?? name }];
   } else {
     results = [{ name, score: scoreValue }];
   }
@@ -50560,5 +51506,64 @@ var evaluatorDefinitionsSchema = import_v313.z.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/edge-light/index.ts
 configureEdgeLight();