braintrust 3.31.0 → 3.32.0

package/dist/instrumentation/index.mjs

@@ -2914,6 +2914,14 @@ var ChatCompletionContentPartImageWithTitle = z6.object({
     ttl: z6.enum(["5m", "1h"]).optional()
   }).optional()
 });
+var ChatCompletionContentPartInputAudioWithTitle = z6.object({
+  input_audio: z6.object({ data: z6.string(), format: z6.enum(["wav", "mp3"]) }),
+  type: z6.literal("input_audio"),
+  cache_control: z6.object({
+    type: z6.literal("ephemeral"),
+    ttl: z6.enum(["5m", "1h"]).optional()
+  }).optional()
+});
 var ChatCompletionContentPartFileFile = z6.object({ file_data: z6.string(), filename: z6.string(), file_id: z6.string() }).partial();
 var ChatCompletionContentPartFileWithTitle = z6.object({
   file: ChatCompletionContentPartFileFile,
@@ -2926,6 +2934,7 @@ var ChatCompletionContentPartFileWithTitle = z6.object({
 var ChatCompletionContentPart = z6.union([
   ChatCompletionContentPartTextWithTitle,
   ChatCompletionContentPartImageWithTitle,
+  ChatCompletionContentPartInputAudioWithTitle,
   ChatCompletionContentPartFileWithTitle
 ]);
 var ChatCompletionContentPartText = z6.object({
@@ -5753,6 +5762,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",
@@ -5768,12 +5778,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.31.0" : "0.0.0";
+var SDK_VERSION = true ? "3.32.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -10351,6 +10362,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 [
               {
@@ -22619,6 +22640,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 = (log) => {
+      if (ended) return;
+      ended = true;
+      try {
+        log();
+      } 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",
@@ -24262,7 +24619,7 @@ var HuggingFaceTransformersPlugin = class extends BasePlugin {
           getTask(event)
         ),
         extractInput: (args, event) => ({
-          input: extractInput(
+          input: extractInput2(
             getTask(event),
             args
           ),
@@ -24352,7 +24709,7 @@ function modelIdentifier(pipeline) {
   }
   return void 0;
 }
-function extractInput(task, args) {
+function extractInput2(task, args) {
   switch (task) {
     case "feature-extraction":
       return args[0];
@@ -34706,6 +35063,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 invoke = () => Reflect.apply(target, self, args);
+    if (isAutoInstrumentationSuppressed()) return invoke();
+    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 invoke();
+    }
+    if (!span) return invoke();
+    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(invoke)
+      );
+    } 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 read2 = reader.read;
+      reader.read = function(...readArgs) {
+        return Promise.resolve(
+          withCurrent(span, () => Reflect.apply(read2, 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",
@@ -34773,7 +35601,7 @@ var VoyageAIPlugin = class extends BasePlugin {
     this.unsubscribers = unsubscribeAll(this.unsubscribers);
   }
 };
-function interceptVoyageAICall(channel2, name, extractInput2, extractOutput2, extractMetrics2 = extractUsageMetrics3) {
+function interceptVoyageAICall(channel2, name, extractInput3, extractOutput2, extractMetrics2 = extractUsageMetrics3) {
   return channel2.intercept((target, thisArg, args) => {
     const invokeTarget = () => Reflect.apply(target, thisArg, args);
     if (isAutoInstrumentationSuppressed()) {
@@ -34781,7 +35609,7 @@ function interceptVoyageAICall(channel2, name, extractInput2, extractOutput2, ex
     }
     let span;
     try {
-      const { input, metadata } = extractInput2(args);
+      const { input, metadata } = extractInput3(args);
       span = startSpan(
         withSpanInstrumentationName(
           {
@@ -35557,6 +36385,7 @@ var BraintrustPlugin = class extends BasePlugin {
   cloudflareThinkPlugin = null;
   cursorSDKPlugin = null;
   openAIAgentsPlugin = null;
+  googleGenerativeAIPlugin = null;
   googleGenAIPlugin = null;
   huggingFacePlugin = null;
   huggingFaceTransformersPlugin = null;
@@ -35575,6 +36404,7 @@ var BraintrustPlugin = class extends BasePlugin {
   langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
+  elevenLabsPlugin = null;
   voyageAIPlugin = null;
   cloudflareAIChatPlugin = null;
   cloudflareAgentsPlugin = null;
@@ -35616,6 +36446,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();
@@ -35650,6 +36484,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();
@@ -35734,6 +36572,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;
@@ -35770,6 +36612,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;
@@ -37982,6 +38828,8 @@ var envIntegrationAliases = {
   "openai-agents-core": "openAIAgents",
   openaiagentscore: "openAIAgents",
   google: "google",
+  "google-generative-ai": "googleGenerativeAI",
+  googlegenerativeai: "googleGenerativeAI",
   "google-genai": "googleGenAI",
   googlegenai: "googleGenAI",
   huggingface: "huggingface",
@@ -38015,7 +38863,9 @@ var envIntegrationAliases = {
   langsmith: "langsmith",
   voyage: "voyageai",
   "voyage-ai": "voyageai",
-  voyageai: "voyageai"
+  voyageai: "voyageai",
+  elevenlabs: "elevenlabs",
+  "@elevenlabs/elevenlabs-js": "elevenlabs"
 };
 function getDefaultInstrumentationIntegrations() {
   return {
@@ -38026,6 +38876,7 @@ function getDefaultInstrumentationIntegrations() {
     aisdk: true,
     google: true,
     googleGenAI: true,
+    googleGenerativeAI: true,
     googleADK: true,
     huggingface: true,
     claudeAgentSDK: true,
@@ -38051,6 +38902,7 @@ function getDefaultInstrumentationIntegrations() {
     langgraph: true,
     langsmith: true,
     voyageai: true,
+    elevenlabs: true,
     piCodingAgent: true,
     strandsAgentSDK: true,
     cloudflareAgents: true