braintrust 3.31.0 → 3.33.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",
@@ -5760,6 +5770,7 @@ var INSTRUMENTATION_NAMES = {
   LANGSMITH: "langsmith",
   MASTRA: "mastra",
   MISTRAL: "mistral",
+  LANGGRAPH_SDK: "langgraph-sdk",
   OLLAMA: "ollama",
   OPENAI: "openai",
   OPENAI_AGENTS: "openai-agents",
@@ -5768,12 +5779,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.33.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -8492,6 +8504,38 @@ function getSpanParentObjectAndPropagatedState(options) {
 function getSpanParentObject(options) {
   return getSpanParentObjectAndPropagatedState(options).parentObject;
 }
+function _internalExportParentSynchronously(parent) {
+  if ("toStr" in parent) {
+    return parent.toStr();
+  }
+  if ("getParentInfo" in parent) {
+    const parentInfo = parent.getParentInfo();
+    if (!parentInfo) {
+      return void 0;
+    }
+    const objectId = parentInfo.objectId.getSync().value;
+    if (!objectId && !parentInfo.computeObjectMetadataArgs) {
+      return void 0;
+    }
+    return new SpanComponentsV4({
+      object_type: parentInfo.objectType,
+      ...objectId ? { object_id: objectId } : {
+        compute_object_metadata_args: parentInfo.computeObjectMetadataArgs ?? {}
+      },
+      row_id: parent.id,
+      root_span_id: parent.rootSpanId,
+      span_id: parent.spanId
+    }).toStr();
+  }
+  const components = braintrustParentToComponents(parent._getOtelParent());
+  if (!components) {
+    return void 0;
+  }
+  return new SpanComponentsV4({
+    object_type: components.objectType,
+    ...components.objectId ? { object_id: components.objectId } : { compute_object_metadata_args: components.computeArgs ?? {} }
+  }).toStr();
+}
 function currentBraintrustParent(state) {
   const resolvedState = state ?? _globalState;
   const experiment = currentExperiment({ state: resolvedState });
@@ -9798,10 +9842,16 @@ var SpanImpl = class _SpanImpl {
   inject(carrier) {
     const resolvedCarrier = carrier ?? {};
     try {
+      const braintrustParent = this._getOtelParent() ?? this._propagatedState?.braintrustParent;
+      if (!braintrustParent) {
+        debugLogger.forState(this._state).warn(
+          "Injecting trace context without braintrust.parent because the span's destination is not available yet. The receiver will start a new local trace instead of continuing this one."
+        );
+      }
       _injectIntoCarrier(resolvedCarrier, {
         traceId: this._rootSpanId,
         spanId: this._spanId,
-        braintrustParent: this._getOtelParent() ?? this._propagatedState?.braintrustParent,
+        braintrustParent,
         propagatedState: this._propagatedState
       });
     } catch (e) {
@@ -10351,6 +10401,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 [
               {
@@ -11874,6 +11934,18 @@ function defineChannels(pkg, channels, options) {
 var openAIChannels = defineChannels(
   "openai",
   {
+    agentsTraceStart: channel({
+      channelName: "agents.trace.start",
+      kind: "async"
+    }),
+    agentsTraceCapture: channel({
+      channelName: "agents.trace.capture",
+      kind: "async"
+    }),
+    agentsTraceFail: channel({
+      channelName: "agents.trace.fail",
+      kind: "async"
+    }),
     filesCreateTraced: channel({
       channelName: "files.create-traced",
       kind: "async"
@@ -12242,6 +12314,23 @@ function getCachedMetricFromHeaders(headers) {
   return parseCachedHeader(headers.get(LEGACY_CACHED_HEADER));
 }
 
+// src/instrumentation/plugins/openai-manual-instrumentation-utils.ts
+async function deterministicDigest(namespace, ...parts) {
+  const encoded = new TextEncoder().encode(
+    [namespace, ...parts].map((part) => `${part.length}:${part}`).join("\0")
+  );
+  return new Uint8Array(
+    await globalThis.crypto.subtle.digest("SHA-256", encoded)
+  );
+}
+function digestHex(bytes, length) {
+  return Array.from(bytes.slice(0, length)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function digestUuid(bytes) {
+  const hex = digestHex(bytes, 16);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
 // src/instrumentation/plugins/openai-batch-instrumentation.ts
 var SUPPORTED_ENDPOINTS = /* @__PURE__ */ new Set(["/v1/chat/completions", "/v1/responses"]);
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
@@ -12282,21 +12371,6 @@ async function exportParent(parent) {
   }
   return void 0;
 }
-async function deterministicDigest(namespace, ...parts) {
-  const encoded = new TextEncoder().encode(
-    [namespace, ...parts].map((part) => `${part.length}:${part}`).join("\0")
-  );
-  return new Uint8Array(
-    await globalThis.crypto.subtle.digest("SHA-256", encoded)
-  );
-}
-function digestHex(bytes, length) {
-  return Array.from(bytes.slice(0, length)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function digestUuid(bytes) {
-  const hex = digestHex(bytes, 16);
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
 async function batchSpanIds(inputFileId) {
   const [row, span, root] = await Promise.all([
     deterministicDigest("openai:batch:row", inputFileId),
@@ -12787,6 +12861,628 @@ var interceptOpenAIBatchTraceComplete = (target, thisArg, args) => Promise.resol
   return result;
 });
 
+// src/instrumentation/plugins/openai-agents-api-instrumentation.ts
+var TERMINAL_TURN_EVENTS = /* @__PURE__ */ new Set([
+  "agent.session.turn.completed",
+  "agent.session.turn.failed",
+  "agent.session.turn.cancelled"
+]);
+var TURN_LIFECYCLE_EVENTS = /* @__PURE__ */ new Set([
+  "agent.session.turn.created",
+  "agent.session.turn.in_progress",
+  ...TERMINAL_TURN_EVENTS
+]);
+var SESSION_EVENTS = /* @__PURE__ */ new Set([
+  "agent.session.created",
+  "agent.session.failed",
+  "agent.session.idle",
+  "agent.session.in_progress",
+  "agent.session.requires_action"
+]);
+var SUBAGENT_EVENTS = /* @__PURE__ */ new Set([
+  "agent.session.subagent.active",
+  "agent.session.subagent.closed",
+  "agent.session.subagent.created"
+]);
+function read2(value, key) {
+  if (!isObject(value)) {
+    return void 0;
+  }
+  try {
+    return Reflect.get(value, key);
+  } catch {
+    return void 0;
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function recordValue(record, key) {
+  return Object.hasOwn(record, key) ? record[key] : void 0;
+}
+function setRecordValue(record, key, value) {
+  Object.defineProperty(record, key, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+function loggedError(value, fallback) {
+  if (value instanceof Error) {
+    return value;
+  }
+  const message = stringValue(read2(value, "message"));
+  return new Error(message ?? (typeof value === "string" ? value : fallback));
+}
+function logInstrumentationError(context, error) {
+  debugLogger.debug(`OpenAI Agents API instrumentation ${context}:`, error);
+}
+async function childSpanIds2(rootKey, kind, providerId) {
+  const [row, span] = await Promise.all([
+    deterministicDigest("openai:agents:row", rootKey, kind, providerId),
+    deterministicDigest("openai:agents:span", rootKey, kind, providerId)
+  ]);
+  return { rowId: digestUuid(row), spanId: digestHex(span, 8) };
+}
+function traceMetadata(args) {
+  const metadata = {};
+  const suppliedMetadata = read2(args, "metadata");
+  if (isObject(suppliedMetadata)) {
+    try {
+      for (const key of Object.keys(suppliedMetadata)) {
+        metadata[key] = read2(suppliedMetadata, key);
+      }
+    } catch (error) {
+      logInstrumentationError("could not read supplied metadata", error);
+    }
+  }
+  const agent = read2(args, "agent");
+  const agentId = stringValue(read2(agent, "id")) ?? stringValue(read2(args, "agent_id"));
+  const agentName = stringValue(read2(agent, "name"));
+  const model = stringValue(read2(agent, "model"));
+  return {
+    ...metadata,
+    api: "agents",
+    ...agentId ? { agent_id: agentId } : {},
+    ...agentName ? { agent_name: agentName } : {},
+    ...model ? { model } : {},
+    provider: "openai"
+  };
+}
+function copyState(state) {
+  return {
+    ...state,
+    callItems: { ...state.callItems },
+    eventIds: [...state.eventIds],
+    openTools: { ...state.openTools },
+    subagents: { ...state.subagents },
+    turnSubagents: { ...state.turnSubagents }
+  };
+}
+function startRootSpan(state) {
+  const root = SpanComponentsV4.fromStr(state.root);
+  const parent = SpanComponentsV4.fromStr(state.rootParent);
+  const rowId = stringValue(root.data.row_id);
+  const rootSpanId = stringValue(root.data.root_span_id);
+  const spanId = stringValue(root.data.span_id);
+  if (!rowId || !rootSpanId || !spanId) {
+    throw new Error("OpenAI Agents trace root is invalid");
+  }
+  const hasParentSpan = Boolean(
+    parent.data.row_id && parent.data.span_id && parent.data.root_span_id
+  );
+  return withCurrent(
+    NOOP_SPAN,
+    () => _internalStartSpanWithInitialMergeAndParentSpanIds(
+      withSpanInstrumentationName(
+        {
+          name: "openai.agents.turn",
+          type: "task" /* TASK */,
+          parent: state.rootParent,
+          ...!hasParentSpan ? {
+            parentSpanIds: {
+              parentSpanIds: [],
+              rootSpanId
+            }
+          } : {},
+          spanId,
+          startTime: state.startTime,
+          event: { id: rowId }
+        },
+        INSTRUMENTATION_NAMES.OPENAI
+      )
+    )
+  );
+}
+async function startSubagentSpan(state, subagentId, input, metadata, visiting = /* @__PURE__ */ new Set()) {
+  const subagent = recordValue(state.subagents, subagentId);
+  let parent = state.root;
+  if (subagent?.parentAgentId && subagent.parentAgentId !== subagentId && recordValue(state.subagents, subagent.parentAgentId) && !visiting.has(subagent.parentAgentId)) {
+    visiting.add(subagentId);
+    parent = await (await startSubagentSpan(
+      state,
+      subagent.parentAgentId,
+      void 0,
+      void 0,
+      visiting
+    )).export();
+  }
+  const ids = await childSpanIds2(state.rootKey, "subagent", subagentId);
+  return withCurrent(
+    NOOP_SPAN,
+    () => _internalStartSpanWithInitialMerge(
+      withSpanInstrumentationName(
+        {
+          name: "openai.agents.subagent",
+          type: "task" /* TASK */,
+          parent,
+          spanId: ids.spanId,
+          startTime: subagent?.openedAt,
+          event: {
+            id: ids.rowId,
+            ...input !== void 0 ? { input } : {},
+            metadata: {
+              ...metadata,
+              agent_id: subagentId,
+              ...subagent?.parentAgentId ? { parent_agent_id: subagent.parentAgentId } : {},
+              provider: "openai"
+            }
+          }
+        },
+        INSTRUMENTATION_NAMES.OPENAI
+      )
+    )
+  );
+}
+async function parentForTurn(state, turnId) {
+  const subagentId = turnId ? recordValue(state.turnSubagents, turnId) : void 0;
+  if (!subagentId) {
+    return state.root;
+  }
+  return await (await startSubagentSpan(state, subagentId)).export();
+}
+async function startToolSpan(state, tool, input) {
+  const ids = await childSpanIds2(state.rootKey, "tool", tool.itemId);
+  return withCurrent(
+    NOOP_SPAN,
+    async () => _internalStartSpanWithInitialMerge(
+      withSpanInstrumentationName(
+        {
+          name: tool.name,
+          type: "tool" /* TOOL */,
+          parent: await parentForTurn(state, tool.turnId),
+          spanId: ids.spanId,
+          startTime: tool.startTime,
+          event: {
+            id: ids.rowId,
+            ...input !== void 0 ? { input } : {},
+            metadata: {
+              item_id: tool.itemId,
+              provider: "openai",
+              tool_type: tool.toolType,
+              ...tool.turnId ? { turn_id: tool.turnId } : {}
+            }
+          }
+        },
+        INSTRUMENTATION_NAMES.OPENAI
+      )
+    )
+  );
+}
+function toolFromItem(item, observedAt) {
+  const itemId = stringValue(read2(item, "id"));
+  const toolType = stringValue(read2(item, "type"));
+  if (!itemId || !toolType) {
+    return void 0;
+  }
+  const turnId = stringValue(read2(item, "turn_id"));
+  switch (toolType) {
+    case "function_call":
+      return {
+        input: read2(item, "arguments"),
+        tool: {
+          itemId,
+          name: stringValue(read2(item, "name")) ?? "Function call",
+          startTime: observedAt,
+          toolType,
+          ...turnId ? { turnId } : {}
+        }
+      };
+    case "mcp_call": {
+      const name = stringValue(read2(item, "name")) ?? "MCP call";
+      const server = stringValue(read2(item, "server_label"));
+      return {
+        input: read2(item, "arguments"),
+        tool: {
+          itemId,
+          name: server ? `${server}.${name}` : name,
+          startTime: observedAt,
+          toolType,
+          ...turnId ? { turnId } : {}
+        }
+      };
+    }
+    case "web_search_call":
+      return {
+        input: read2(item, "action"),
+        tool: {
+          itemId,
+          name: "Web search",
+          startTime: observedAt,
+          toolType,
+          ...turnId ? { turnId } : {}
+        }
+      };
+    case "command_execution":
+      return {
+        input: {
+          command: read2(item, "command"),
+          cwd: read2(item, "cwd")
+        },
+        tool: {
+          itemId,
+          name: "Command execution",
+          startTime: observedAt,
+          toolType,
+          ...turnId ? { turnId } : {}
+        }
+      };
+    default:
+      return void 0;
+  }
+}
+function textFromContent(content) {
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const text = [];
+  for (const part of content) {
+    const partText = read2(part, "text");
+    if (read2(part, "type") === "output_text" && typeof partText === "string") {
+      text.push(partText);
+    }
+  }
+  return text.length > 0 ? text.join("") : void 0;
+}
+function toolOutput(item, toolType) {
+  switch (toolType) {
+    case "function_call":
+      return read2(item, "output");
+    case "mcp_call":
+      return read2(item, "output");
+    case "web_search_call":
+      return read2(item, "action");
+    case "command_execution":
+      return read2(item, "output");
+    default:
+      return void 0;
+  }
+}
+function toolFailed(item, toolType) {
+  const status = read2(item, "status");
+  const explicitError = read2(item, "error");
+  if (explicitError !== void 0 && explicitError !== null) {
+    return loggedError(explicitError, `OpenAI ${toolType} failed`);
+  }
+  if (status === "failed" || status === "incomplete") {
+    return new Error(`OpenAI ${toolType} ${status}`);
+  }
+  if (toolType === "command_execution" && typeof read2(item, "exit_code") === "number" && read2(item, "exit_code") !== 0) {
+    return new Error(
+      `OpenAI command exited with code ${read2(item, "exit_code")}`
+    );
+  }
+  return void 0;
+}
+async function completeTool(state, tool, item, endTime) {
+  const span = await startToolSpan(state, tool);
+  const output = toolOutput(item, tool.toolType);
+  const error = toolFailed(item, tool.toolType);
+  span.log({
+    ...output !== void 0 ? { output } : {},
+    ...error ? { error } : {},
+    metadata: {
+      status: read2(item, "status"),
+      ...tool.toolType === "command_execution" ? { exit_code: read2(item, "exit_code") } : {}
+    }
+  });
+  span.end({ endTime });
+  Reflect.deleteProperty(state.openTools, tool.itemId);
+}
+async function captureMessage(state, item) {
+  if (read2(item, "type") !== "message" || read2(item, "role") !== "assistant" || read2(item, "phase") !== "final_answer") {
+    return;
+  }
+  const output = textFromContent(read2(item, "content"));
+  if (output === void 0) {
+    return;
+  }
+  const turnId = stringValue(read2(item, "turn_id"));
+  const subagentId = turnId ? recordValue(state.turnSubagents, turnId) : void 0;
+  if (subagentId) {
+    (await startSubagentSpan(state, subagentId)).log({ output });
+  } else {
+    startRootSpan(state).log({ output });
+  }
+}
+async function captureItem(state, item, isDone, observedAt) {
+  await captureMessage(state, item);
+  const itemType = stringValue(read2(item, "type"));
+  if (itemType === "function_call_output") {
+    const callId = stringValue(read2(item, "call_id"));
+    const itemId = callId ? recordValue(state.callItems, callId) : void 0;
+    const tool2 = itemId ? recordValue(state.openTools, itemId) : void 0;
+    if (tool2) {
+      await completeTool(state, tool2, item, observedAt);
+    }
+    return;
+  }
+  const descriptor = toolFromItem(item, observedAt);
+  if (!descriptor) {
+    return;
+  }
+  const existing = recordValue(state.openTools, descriptor.tool.itemId);
+  const tool = existing ?? descriptor.tool;
+  setRecordValue(state.openTools, tool.itemId, tool);
+  if (itemType === "function_call") {
+    const callId = stringValue(read2(item, "call_id"));
+    if (callId) {
+      setRecordValue(state.callItems, callId, tool.itemId);
+    }
+  }
+  await startToolSpan(state, tool, descriptor.input);
+  const status = read2(item, "status");
+  const terminalFunctionCall = itemType === "function_call" && (status === "failed" || status === "incomplete");
+  if (itemType !== "function_call" && (isDone || status !== "in_progress") || terminalFunctionCall) {
+    await completeTool(state, tool, item, observedAt);
+  }
+}
+function updateSessionMetadata(state, session) {
+  const sessionId = stringValue(read2(session, "id"));
+  const agent = read2(session, "agent");
+  startRootSpan(state).log({
+    metadata: {
+      ...sessionId ? { session_id: sessionId } : {},
+      ...stringValue(read2(agent, "id")) ? { agent_id: read2(agent, "id") } : {},
+      ...stringValue(read2(agent, "name")) ? { agent_name: read2(agent, "name") } : {},
+      ...stringValue(read2(agent, "model")) ? { model: read2(agent, "model") } : {}
+    }
+  });
+}
+async function captureSubagent(state, eventType, subagent, observedAt) {
+  const subagentId = stringValue(read2(subagent, "id"));
+  if (!subagentId) {
+    return;
+  }
+  const existing = recordValue(state.subagents, subagentId);
+  const observedOpenedAt = read2(subagent, "opened_at");
+  const openedAt = typeof observedOpenedAt === "number" && Number.isFinite(observedOpenedAt) && observedOpenedAt >= 0 ? observedOpenedAt : existing?.openedAt ?? observedAt;
+  const observedClosedAt = read2(subagent, "closed_at");
+  const closedAt = typeof observedClosedAt === "number" && Number.isFinite(observedClosedAt) && observedClosedAt >= 0 ? observedClosedAt : existing?.closedAt;
+  const parentAgentId = stringValue(read2(subagent, "parent_agent_id")) ?? existing?.parentAgentId;
+  setRecordValue(state.subagents, subagentId, {
+    ...closedAt !== void 0 ? { closedAt } : {},
+    openedAt,
+    ...parentAgentId ? { parentAgentId } : {}
+  });
+  const span = await startSubagentSpan(
+    state,
+    subagentId,
+    read2(subagent, "instructions"),
+    {
+      ...stringValue(read2(subagent, "name")) ? { agent_name: read2(subagent, "name") } : {},
+      status: read2(subagent, "status")
+    }
+  );
+  if (eventType === "agent.session.subagent.closed") {
+    span.end({ endTime: closedAt ?? observedAt });
+  }
+}
+async function closeTrace(state, endTime, error, usage) {
+  if (state.ended) {
+    return;
+  }
+  for (const tool of Object.values(state.openTools)) {
+    const span = await startToolSpan(state, tool);
+    span.log({
+      error: error ?? new Error("OpenAI Agents turn ended before tool completion")
+    });
+    span.end({ endTime });
+  }
+  state.openTools = {};
+  for (const subagentId of Object.keys(state.subagents)) {
+    const subagent = state.subagents[subagentId];
+    const span = await startSubagentSpan(state, subagentId);
+    span.end({ endTime: subagent.closedAt ?? endTime });
+  }
+  const root = startRootSpan(state);
+  root.log({
+    ...error ? { error } : {},
+    metrics: parseMetricsFromUsage(usage)
+  });
+  root.end({ endTime });
+  state.ended = true;
+}
+async function captureTurnLifecycle(state, event, eventType, observedAt) {
+  const turn = read2(event, "turn");
+  const turnId = stringValue(read2(event, "turn_id")) ?? stringValue(read2(turn, "id"));
+  const subagentId = stringValue(read2(turn, "subagent_id"));
+  if (turnId && subagentId) {
+    setRecordValue(state.turnSubagents, turnId, subagentId);
+    if (!recordValue(state.subagents, subagentId)) {
+      const createdAt = read2(turn, "created_at");
+      setRecordValue(state.subagents, subagentId, {
+        openedAt: typeof createdAt === "number" && Number.isFinite(createdAt) && createdAt >= 0 ? createdAt : observedAt
+      });
+    }
+    await startSubagentSpan(state, subagentId);
+  }
+  const sessionId = stringValue(read2(event, "session_id"));
+  if (sessionId) {
+    startRootSpan(state).log({ metadata: { session_id: sessionId } });
+  }
+  if (!TERMINAL_TURN_EVENTS.has(eventType) || subagentId) {
+    if (subagentId && eventType === "agent.session.turn.failed") {
+      (await startSubagentSpan(state, subagentId)).log({
+        error: loggedError(read2(turn, "error"), "OpenAI subagent turn failed")
+      });
+    }
+    return;
+  }
+  const completedAt = read2(turn, "completed_at");
+  const endTime = typeof completedAt === "number" && Number.isFinite(completedAt) && completedAt >= 0 ? completedAt : observedAt;
+  const usage = read2(event, "usage") ?? read2(turn, "usage");
+  const error = eventType === "agent.session.turn.completed" ? void 0 : loggedError(
+    read2(turn, "error"),
+    eventType === "agent.session.turn.cancelled" ? "OpenAI Agents turn cancelled" : "OpenAI Agents turn failed"
+  );
+  await closeTrace(state, endTime, error, usage);
+}
+async function captureEvent(state, event) {
+  if (state.ended) {
+    return state;
+  }
+  const eventType = stringValue(read2(event, "type"));
+  const eventId = stringValue(read2(event, "event_id"));
+  if (!eventType || eventId && state.eventIds.includes(eventId)) {
+    return state;
+  }
+  const next = copyState(state);
+  const observedAt = getCurrentUnixTimestamp();
+  let handled = false;
+  if (SESSION_EVENTS.has(eventType)) {
+    const session = read2(event, "session");
+    if (session) {
+      updateSessionMetadata(next, session);
+    }
+    handled = true;
+  }
+  if (eventType === "agent.session.turn.item.added") {
+    await captureItem(next, read2(event, "item"), false, observedAt);
+    handled = true;
+  } else if (eventType === "agent.session.turn.item.done") {
+    await captureItem(next, read2(event, "item"), true, observedAt);
+    handled = true;
+  } else if (TURN_LIFECYCLE_EVENTS.has(eventType)) {
+    await captureTurnLifecycle(next, event, eventType, observedAt);
+    handled = true;
+  } else if (SUBAGENT_EVENTS.has(eventType)) {
+    await captureSubagent(next, eventType, read2(event, "subagent"), observedAt);
+    handled = true;
+  } else if (eventType === "agent.session.turn.output_text.delta" && next.firstTokenAt === void 0 && stringValue(read2(event, "delta"))) {
+    next.firstTokenAt = observedAt;
+    startRootSpan(next).log({
+      metrics: { time_to_first_token: observedAt - next.startTime }
+    });
+    handled = true;
+  } else if (eventType === "agent.session.failed") {
+    const session = read2(event, "session");
+    const lastActiveAt = read2(session, "last_active_at");
+    const endTime = typeof lastActiveAt === "number" && Number.isFinite(lastActiveAt) && lastActiveAt >= 0 ? lastActiveAt : observedAt;
+    await closeTrace(
+      next,
+      endTime,
+      loggedError(read2(session, "error"), "OpenAI Agents session failed"),
+      read2(session, "usage")
+    );
+    handled = true;
+  } else if (eventType === "error") {
+    await closeTrace(
+      next,
+      observedAt,
+      loggedError(read2(event, "error"), "OpenAI Agents session failed")
+    );
+    handled = true;
+  }
+  if (!handled) {
+    return state;
+  }
+  if (eventId) {
+    next.eventIds.push(eventId);
+  }
+  return next;
+}
+var interceptOpenAIAgentsTraceStart = async (target, thisArg, args) => {
+  const fallback = await Reflect.apply(target, thisArg, args);
+  try {
+    const state = args[0].state;
+    const parent = state.rootParent;
+    const traceArgs = args[0].args;
+    const parentComponents = SpanComponentsV4.fromStr(parent);
+    const hasParentSpan = Boolean(
+      parentComponents.data.row_id && parentComponents.data.span_id && parentComponents.data.root_span_id
+    );
+    const rootComponents = SpanComponentsV4.fromStr(state.root);
+    const rowId = stringValue(rootComponents.data.row_id);
+    const rootSpanId = stringValue(rootComponents.data.root_span_id);
+    const spanId = stringValue(rootComponents.data.span_id);
+    if (!rowId || !rootSpanId || !spanId) {
+      throw new Error("OpenAI Agents trace root is invalid");
+    }
+    withCurrent(
+      NOOP_SPAN,
+      () => _internalStartSpanWithInitialMergeAndParentSpanIds(
+        withSpanInstrumentationName(
+          {
+            name: "openai.agents.turn",
+            type: "task" /* TASK */,
+            parent,
+            ...!hasParentSpan ? {
+              parentSpanIds: {
+                parentSpanIds: [],
+                rootSpanId
+              }
+            } : {},
+            spanId,
+            startTime: state.startTime,
+            event: {
+              id: rowId,
+              input: read2(traceArgs, "input"),
+              metadata: traceMetadata(traceArgs)
+            }
+          },
+          INSTRUMENTATION_NAMES.OPENAI
+        )
+      )
+    );
+    return state;
+  } catch (error) {
+    logInstrumentationError("could not start trace", error);
+    return fallback;
+  }
+};
+var interceptOpenAIAgentsTraceCapture = async (target, thisArg, args) => {
+  const fallback = await Reflect.apply(target, thisArg, args);
+  if (!args[0].state) {
+    return fallback;
+  }
+  try {
+    return await captureEvent(args[0].state, args[0].event);
+  } catch (error) {
+    logInstrumentationError("could not capture event", error);
+    return fallback;
+  }
+};
+var interceptOpenAIAgentsTraceFail = async (target, thisArg, args) => {
+  const fallback = await Reflect.apply(target, thisArg, args);
+  if (!args[0].state) {
+    return fallback;
+  }
+  try {
+    const next = copyState(args[0].state);
+    await closeTrace(
+      next,
+      getCurrentUnixTimestamp(),
+      loggedError(args[0].error, "OpenAI Agents request failed")
+    );
+    return next;
+  } catch (error) {
+    logInstrumentationError("could not fail trace", error);
+    return fallback;
+  }
+};
+
 // src/instrumentation/plugins/openai-plugin.ts
 var OpenAIPlugin = class extends BasePlugin {
   constructor() {
@@ -12794,6 +13490,13 @@ var OpenAIPlugin = class extends BasePlugin {
   }
   onEnable() {
     this.unsubscribers.push(
+      openAIChannels.agentsTraceStart.intercept(
+        interceptOpenAIAgentsTraceStart
+      ),
+      openAIChannels.agentsTraceCapture.intercept(
+        interceptOpenAIAgentsTraceCapture
+      ),
+      openAIChannels.agentsTraceFail.intercept(interceptOpenAIAgentsTraceFail),
       openAIChannels.filesCreateTraced.intercept(
         interceptOpenAIFilesCreateTraced
       ),
@@ -13354,7 +14057,7 @@ async function* patchCodexEventStream(events, state) {
       try {
         await handleCodexEvent(state, event);
       } catch (error) {
-        logInstrumentationError("OpenAI Codex stream event", error);
+        logInstrumentationError2("OpenAI Codex stream event", error);
       }
       yield event;
     }
@@ -13854,10 +14557,10 @@ function safeLog(span, event) {
   try {
     span.log(event);
   } catch (error) {
-    logInstrumentationError("OpenAI Codex span log", error);
+    logInstrumentationError2("OpenAI Codex span log", error);
   }
 }
-function logInstrumentationError(context, error) {
+function logInstrumentationError2(context, error) {
   debugLogger.error(`Error processing ${context}:`, error);
 }
 
@@ -15239,27 +15942,8 @@ function continuationParentFromCreateSessionParams(params) {
   }
   return context.parent;
 }
-function exportSpanSynchronously(span) {
-  const parentInfo = span.getParentInfo();
-  if (!parentInfo) {
-    return void 0;
-  }
-  const objectId = parentInfo.objectId.getSync().value;
-  if (!objectId && !parentInfo.computeObjectMetadataArgs) {
-    return void 0;
-  }
-  return new SpanComponentsV4({
-    object_type: parentInfo.objectType,
-    ...objectId ? { object_id: objectId } : {
-      compute_object_metadata_args: parentInfo.computeObjectMetadataArgs ?? {}
-    },
-    row_id: span.id,
-    root_span_id: span.rootSpanId,
-    span_id: span.spanId
-  }).toStr();
-}
 function exportedParent(parent) {
-  return typeof parent === "string" ? parent : exportSpanSynchronously(parent);
+  return typeof parent === "string" ? parent : _internalExportParentSynchronously(parent);
 }
 function addSerializedContext(args) {
   if (!isObject(args.continuation) || args.sessionId === void 0) {
@@ -16016,16 +16700,16 @@ function braintrustAISDKTelemetry() {
         if (!toolCallId || !state) {
           return;
         }
-        const toolOutput = event.toolOutput;
+        const toolOutput2 = event.toolOutput;
         const workflowToolError = event.success === false && "error" in event ? event.error : void 0;
-        if (toolOutput?.type === "tool-error" || workflowToolError !== void 0) {
-          const error = toolOutput?.error ?? workflowToolError;
+        if (toolOutput2?.type === "tool-error" || workflowToolError !== void 0) {
+          const error = toolOutput2?.error ?? workflowToolError;
           state.span.log({
             error: error instanceof Error ? error.message : String(error),
             metrics: typeof event.durationMs === "number" ? { duration_ms: event.durationMs } : {}
           });
         } else {
-          const output = toolOutput && "output" in toolOutput ? toolOutput.output : event.output;
+          const output = toolOutput2 && "output" in toolOutput2 ? toolOutput2.output : event.output;
           state.span.log({
             ...shouldRecordOutputs(event) ? { output } : {},
             metrics: typeof event.durationMs === "number" ? { duration_ms: event.durationMs } : {}
@@ -18484,9 +19168,9 @@ function patchAISDKStreamingResult(args) {
       }
       finalize({ metrics, output });
     } catch (error) {
-      const loggedError = toLoggedError(error);
+      const loggedError2 = toLoggedError(error);
       try {
-        span.log({ error: loggedError });
+        span.log({ error: loggedError2 });
       } catch (loggingError) {
         debugLogger.error(
           "Error logging AI SDK streaming failure:",
@@ -18494,7 +19178,7 @@ function patchAISDKStreamingResult(args) {
         );
       }
       finalize({
-        error: error instanceof Error ? error : new Error(String(loggedError))
+        error: error instanceof Error ? error : new Error(String(loggedError2))
       });
     }
   };
@@ -18607,9 +19291,9 @@ function patchAISDKStreamingResult(args) {
           }
           controller.enqueue(value);
         } catch (error) {
-          const loggedError = toLoggedError(error);
+          const loggedError2 = toLoggedError(error);
           try {
-            span.log({ error: loggedError });
+            span.log({ error: loggedError2 });
           } catch (loggingError) {
             debugLogger.error(
               "Error logging AI SDK base stream failure:",
@@ -18617,7 +19301,7 @@ function patchAISDKStreamingResult(args) {
             );
           }
           finalize({
-            error: error instanceof Error ? error : new Error(String(loggedError))
+            error: error instanceof Error ? error : new Error(String(loggedError2))
           });
           controller.error(error);
         }
@@ -21511,7 +22195,7 @@ function wrapSendOptionsCallbacks(options, state) {
       try {
         await handleInteractionUpdate(state, args.update);
       } catch (error) {
-        logInstrumentationError2("Cursor SDK onDelta", error);
+        logInstrumentationError3("Cursor SDK onDelta", error);
       }
       if (originalOnDelta) {
         return originalOnDelta(args);
@@ -21521,7 +22205,7 @@ function wrapSendOptionsCallbacks(options, state) {
       try {
         handleStepUpdate(state, args.step);
       } catch (error) {
-        logInstrumentationError2("Cursor SDK onStep", error);
+        logInstrumentationError3("Cursor SDK onStep", error);
       }
       if (originalOnStep) {
         return originalOnStep(args);
@@ -21603,7 +22287,7 @@ async function* patchCursorStream(stream, state) {
       try {
         await handleStreamMessage2(state, message);
       } catch (error) {
-        logInstrumentationError2("Cursor SDK stream", error);
+        logInstrumentationError3("Cursor SDK stream", error);
       }
       yield message;
     }
@@ -21667,7 +22351,7 @@ async function handleToolUpdate(state, update) {
     if (!state.activeToolSpans.has(callId)) {
       state.activeToolSpans.set(
         callId,
-        await startToolSpan(state, {
+        await startToolSpan2(state, {
           args,
           callId,
           name,
@@ -21678,7 +22362,7 @@ async function handleToolUpdate(state, update) {
     }
     return;
   }
-  const toolState = state.activeToolSpans.get(callId) ?? await startToolSpan(state, {
+  const toolState = state.activeToolSpans.get(callId) ?? await startToolSpan2(state, {
     args,
     callId,
     name,
@@ -21715,7 +22399,7 @@ async function handleStreamMessage2(state, message) {
       } else if (block?.type === "tool_use" && block.id) {
         state.activeToolSpans.set(
           block.id,
-          await startToolSpan(state, {
+          await startToolSpan2(state, {
             args: block.input,
             callId: block.id,
             name: block.name,
@@ -21750,7 +22434,7 @@ async function handleToolMessage(state, message) {
     if (!state.activeToolSpans.has(callId)) {
       state.activeToolSpans.set(
         callId,
-        await startToolSpan(state, {
+        await startToolSpan2(state, {
           args: message.args,
           callId,
           name: message.name,
@@ -21761,7 +22445,7 @@ async function handleToolMessage(state, message) {
     }
     return;
   }
-  const toolState = state.activeToolSpans.get(callId) ?? await startToolSpan(state, {
+  const toolState = state.activeToolSpans.get(callId) ?? await startToolSpan2(state, {
     args: message.args,
     callId,
     name: message.name,
@@ -21788,7 +22472,7 @@ async function handleConversation(state, turns) {
       const command = turn.turn?.shellCommand?.command;
       if (command) {
         const callId = `shell:${state.activeToolSpans.size}:${command}`;
-        const toolState = await startToolSpan(state, {
+        const toolState = await startToolSpan2(state, {
           args: turn.turn?.shellCommand,
           callId,
           name: "shell",
@@ -21812,7 +22496,7 @@ async function handleConversationStep(state, step) {
   }
   const toolCall = step.message;
   const callId = typeof toolCall?.callId === "string" ? toolCall.callId : `conversation-tool:${state.activeToolSpans.size}`;
-  const toolState = await startToolSpan(state, {
+  const toolState = await startToolSpan2(state, {
     args: extractToolArgs(toolCall),
     callId,
     name: extractToolName(toolCall),
@@ -21843,7 +22527,7 @@ function handleStepUpdate(state, step) {
     state.stepText.push(step.message.text);
   }
 }
-async function startToolSpan(state, args) {
+async function startToolSpan2(state, args) {
   const name = args.name || "unknown";
   const metadata = {
     "cursor_sdk.tool.status": args.status,
@@ -22130,10 +22814,10 @@ function safeLog2(span, event) {
   try {
     span.log(event);
   } catch (error) {
-    logInstrumentationError2("Cursor SDK span log", error);
+    logInstrumentationError3("Cursor SDK span log", error);
   }
 }
-function logInstrumentationError2(context, error) {
+function logInstrumentationError3(context, error) {
   debugLogger.error(`Error processing ${context}:`, error);
 }
 function cleanMetrics2(metrics) {
@@ -22619,6 +23303,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",
@@ -22635,6 +23655,10 @@ var googleGenAIChannels = defineChannels(
       channelName: "models.embedContent",
       kind: "async"
     }),
+    httpResponseJson: channel({
+      channelName: "httpResponse.json",
+      kind: "async"
+    }),
     interactionsCreate: channel({
       channelName: "interactions.create",
       kind: "async"
@@ -22783,13 +23807,45 @@ var GoogleGenAIPlugin = class extends BasePlugin {
   subscribeToEmbedContentChannel() {
     const tracingChannel = googleGenAIChannels.embedContent.tracingChannel();
     const states = /* @__PURE__ */ new WeakMap();
+    const embeddingSpans = /* @__PURE__ */ new WeakSet();
+    this.unsubscribers.push(
+      googleGenAIChannels.httpResponseJson.intercept(
+        (target, thisArg, args) => {
+          const span = currentSpan();
+          const result = Reflect.apply(target, thisArg, args);
+          if (embeddingSpans.has(span)) {
+            void Promise.resolve(result).then(
+              (response) => {
+                try {
+                  const metrics = cleanMetrics3(
+                    extractEmbedContentMetrics(response)
+                  );
+                  if (embeddingSpans.has(span) && Object.keys(metrics).length > 0) {
+                    span.log({ metrics });
+                  }
+                } catch (error) {
+                  debugLogger.error(
+                    "Error reading Google GenAI embedding usage:",
+                    error
+                  );
+                }
+              },
+              () => {
+              }
+              // The embedding channel handles the original rejection.
+            );
+          }
+          return result;
+        }
+      )
+    );
     const unbindCurrentSpanStore = bindCurrentSpanStoreToStart2(
       tracingChannel,
       states,
       (event) => {
         const params = event.arguments[0];
         const input = serializeEmbedContentInput(params);
-        const metadata = extractEmbedContentMetadata(params);
+        const metadata = { provider: "google", model: params.model };
         const span = startSpan(
           withSpanInstrumentationName(
             {
@@ -22802,6 +23858,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
             INSTRUMENTATION_NAMES.GOOGLE_GENAI
           )
         );
+        embeddingSpans.add(span);
         return {
           span,
           startTime: getCurrentUnixTimestamp()
@@ -22813,7 +23870,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
         ensureSpanState(states, event, () => {
           const params = event.arguments[0];
           const input = serializeEmbedContentInput(params);
-          const metadata = extractEmbedContentMetadata(params);
+          const metadata = { provider: "google", model: params.model };
           const span = startSpan(
             withSpanInstrumentationName(
               {
@@ -22826,6 +23883,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
               INSTRUMENTATION_NAMES.GOOGLE_GENAI
             )
           );
+          embeddingSpans.add(span);
           return {
             span,
             startTime: getCurrentUnixTimestamp()
@@ -22838,20 +23896,28 @@ var GoogleGenAIPlugin = class extends BasePlugin {
           return;
         }
         try {
-          const output = summarizeEmbedContentOutput(event.result);
           spanState.span.log({
-            ...output ? { output } : {},
+            output: summarizeEmbedContentOutput(event.result),
             metrics: cleanMetrics3(
               extractEmbedContentMetrics(event.result, spanState.startTime)
             )
           });
         } finally {
+          embeddingSpans.delete(spanState.span);
           spanState.span.end();
           states.delete(event);
         }
       },
       error: (event) => {
-        logErrorAndEndSpan(states, event);
+        const spanState = states.get(event);
+        if (!spanState) return;
+        try {
+          spanState.span.log({ error: event.error, output: { count: 0 } });
+        } finally {
+          embeddingSpans.delete(spanState.span);
+          spanState.span.end();
+          states.delete(event);
+        }
       }
     };
     tracingChannel.subscribe(handlers);
@@ -23086,15 +24152,53 @@ function serializeGenerateContentInput(params) {
   return input;
 }
 function serializeEmbedContentInput(params) {
+  let contents = Array.isArray(params.contents) ? params.contents : [params.contents];
+  if (params.model.includes("gemini-embedding-2") && contents.length > 0 && contents.every(
+    (content) => typeof content === "string" || !Array.isArray(content) && !("parts" in content)
+  )) {
+    contents = [contents];
+  }
   const input = {
-    model: params.model,
-    contents: serializeContentCollection(params.contents)
+    inputs: contents.map((content) => {
+      const parts = typeof content === "string" ? [content] : Array.isArray(content) ? content : "parts" in content ? content.parts : [content];
+      const normalized = parts.flatMap((part) => {
+        if (typeof part === "string") return [{ type: "text", text: part }];
+        if (part.text !== void 0) return [{ type: "text", text: part.text }];
+        const media = part.inlineData ?? part.fileData;
+        if (!media) return [];
+        const data = "data" in media ? `data:${media.mimeType};base64,${typeof media.data === "string" ? media.data : uint8ArrayToBase64(media.data)}` : media.fileUri;
+        return media.mimeType?.startsWith("image/") ? [{ type: "image_url", image_url: { url: data } }] : [
+          {
+            type: "file",
+            file: {
+              file_data: data,
+              ..."displayName" in media && media.displayName ? { filename: media.displayName } : {}
+            }
+          }
+        ];
+      });
+      return {
+        content: normalized.length === 1 && normalized[0].type === "text" ? normalized[0].text : normalized
+      };
+    }),
+    ...params.config?.outputDimensionality !== void 0 ? { output_dimensions: params.config.outputDimensionality } : {}
   };
-  const config = params.config ? tryToDict(params.config) : null;
-  if (config) {
-    input.config = config;
+  try {
+    const processed = processInputAttachments(input);
+    const hasInlineMedia = processed.inputs.some(
+      ({ content }) => Array.isArray(content) && content.some((part) => {
+        const data = part.type === "image_url" ? part.image_url.url : part.type === "file" ? part.file.file_data : void 0;
+        return typeof data === "string" && data.startsWith("data:");
+      })
+    );
+    return hasInlineMedia ? input : processed;
+  } catch (error) {
+    debugLogger.error(
+      "Error processing Google GenAI embedding attachments:",
+      error
+    );
+    return input;
   }
-  return input;
 }
 function serializeInteractionInput(params) {
   const input = {
@@ -23282,19 +24386,6 @@ function extractGenerateContentMetadata(params) {
   }
   return metadata;
 }
-function extractEmbedContentMetadata(params) {
-  const metadata = {};
-  if (params.model) {
-    metadata.model = params.model;
-  }
-  const config = params.config ? tryToDict(params.config) : null;
-  if (config) {
-    Object.keys(config).forEach((key) => {
-      metadata[key] = config[key];
-    });
-  }
-  return metadata;
-}
 function extractGenerateContentMetrics(response, startTime) {
   const metrics = {};
   if (startTime !== void 0) {
@@ -23314,15 +24405,23 @@ function extractEmbedContentMetrics(response, startTime) {
     const end = getCurrentUnixTimestamp();
     metrics.start = startTime;
     metrics.end = end;
-    metrics.duration = end - startTime;
-  }
-  if (response?.usageMetadata) {
-    populateUsageMetrics(metrics, response.usageMetadata);
   }
   const embeddingTokenCount = extractEmbedPromptTokenCount(response);
   if (embeddingTokenCount !== void 0) {
     metrics.prompt_tokens = embeddingTokenCount;
-    metrics.tokens = embeddingTokenCount;
+  }
+  const totalTokens = response?.usageMetadata?.totalTokenCount ?? embeddingTokenCount;
+  if (totalTokens !== void 0) {
+    metrics.tokens = totalTokens;
+  }
+  const audioTokens = (response?.usageMetadata?.promptTokenDetails ?? response?.usageMetadata?.promptTokensDetails)?.filter(
+    (detail) => detail.modality === "AUDIO" && detail.tokenCount !== void 0
+  );
+  if (audioTokens?.length) {
+    metrics.prompt_audio_tokens = audioTokens.reduce(
+      (sum, detail) => sum + (detail.tokenCount ?? 0),
+      0
+    );
   }
   return metrics;
 }
@@ -23361,41 +24460,25 @@ function extractEmbedPromptTokenCount(response) {
   if (typeof usagePromptTokens === "number" && Number.isFinite(usagePromptTokens)) {
     return usagePromptTokens;
   }
-  const usageTotalTokens = response.usageMetadata?.totalTokenCount;
-  if (typeof usageTotalTokens === "number" && Number.isFinite(usageTotalTokens)) {
-    return usageTotalTokens;
-  }
   const embeddings = Array.isArray(response.embeddings) ? response.embeddings : response.embedding ? [response.embedding] : [];
   if (embeddings.length === 0) {
     return void 0;
   }
   let total = 0;
-  let sawAny = false;
   for (const embedding of embeddings) {
     const embeddingStats = tryToDict(tryToDict(embedding)?.statistics);
     const tokenCount2 = embeddingStats?.tokenCount;
     if (typeof tokenCount2 === "number" && Number.isFinite(tokenCount2)) {
       total += tokenCount2;
-      sawAny = true;
+    } else {
+      return void 0;
     }
   }
-  return sawAny ? total : void 0;
+  return total;
 }
 function summarizeEmbedContentOutput(response) {
-  if (!response) {
-    return void 0;
-  }
-  const embeddings = Array.isArray(response.embeddings) ? response.embeddings : response.embedding ? [response.embedding] : [];
-  if (embeddings.length === 0) {
-    return void 0;
-  }
-  const firstValues = embeddings[0]?.values;
-  if (!Array.isArray(firstValues)) {
-    return void 0;
-  }
   return {
-    embedding_count: embeddings.length,
-    embedding_length: firstValues.length
+    count: Array.isArray(response?.embeddings) ? response.embeddings.length : response?.embedding ? 1 : 0
   };
 }
 function populateUsageMetrics(metrics, usage) {
@@ -24262,7 +25345,7 @@ var HuggingFaceTransformersPlugin = class extends BasePlugin {
           getTask(event)
         ),
         extractInput: (args, event) => ({
-          input: extractInput(
+          input: extractInput2(
             getTask(event),
             args
           ),
@@ -24352,7 +25435,7 @@ function modelIdentifier(pipeline) {
   }
   return void 0;
 }
-function extractInput(task, args) {
+function extractInput2(task, args) {
   switch (task) {
     case "feature-extraction":
       return args[0];
@@ -27022,6 +28105,379 @@ function aggregateMistralStreamChunks(chunks) {
   };
 }
 
+// src/instrumentation/plugins/langgraph-sdk-channels.ts
+var langGraphSDKChannels = defineChannels(
+  "@langchain/langgraph-sdk",
+  {
+    wait: channel({
+      channelName: "runs.wait",
+      kind: "async"
+    }),
+    stream: channel({
+      channelName: "runs.stream",
+      kind: "sync-stream"
+    })
+  },
+  { instrumentationName: INSTRUMENTATION_NAMES.LANGGRAPH_SDK }
+);
+
+// src/instrumentation/plugins/langgraph-sdk-plugin.ts
+var LangGraphSDKPlugin = class extends BasePlugin {
+  onEnable() {
+    this.unsubscribers.push(
+      langGraphSDKChannels.wait.intercept(
+        (target, self, args) => instrumentRun("wait", args, () => Reflect.apply(target, self, args))
+      ),
+      langGraphSDKChannels.stream.intercept(
+        (target, self, args) => instrumentRun("stream", args, () => Reflect.apply(target, self, args))
+      )
+    );
+  }
+  onDisable() {
+    this.unsubscribers = unsubscribeAll(this.unsubscribers);
+  }
+};
+function normalizeMessage(value) {
+  if (!isObject(value)) return value;
+  const role = value.role ?? (value.type === "human" ? "user" : value.type === "ai" || value.type === "AIMessageChunk" ? "assistant" : value.type === "system" || value.type === "tool" || value.type === "function" ? value.type : void 0);
+  if (typeof role !== "string") return value;
+  const message = {
+    role,
+    content: value.content ?? ""
+  };
+  for (const key of ["name", "tool_call_id", "refusal"]) {
+    if (value[key] !== void 0) message[key] = value[key];
+  }
+  const additional = isObject(value.additional_kwargs) ? value.additional_kwargs : {};
+  const toolCalls = Array.isArray(value.tool_calls) && value.tool_calls.length ? value.tool_calls : additional.tool_calls;
+  if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+    message.tool_calls = toolCalls.map((call) => {
+      if (!isObject(call)) return call;
+      if (isObject(call.function)) return call;
+      return {
+        id: call.id,
+        type: "function",
+        function: {
+          name: call.name,
+          arguments: typeof call.args === "string" ? call.args : JSON.stringify(call.args ?? {})
+        }
+      };
+    });
+  }
+  if (Array.isArray(value.invalid_tool_calls) && value.invalid_tool_calls.length > 0)
+    message.invalid_tool_calls = value.invalid_tool_calls;
+  if (message.refusal === void 0 && additional.refusal !== void 0)
+    message.refusal = additional.refusal;
+  return message;
+}
+function normalizeRunError(value) {
+  let name;
+  let message;
+  if (value instanceof Error) {
+    name = value.name;
+    message = value.message;
+  } else if (isObject(value) && typeof value.error === "string" && typeof value.message === "string") {
+    name = value.error;
+    message = value.message;
+  } else {
+    return value;
+  }
+  for (let depth = 0; depth < 3; depth++) {
+    try {
+      const nested = JSON.parse(
+        message.startsWith(`${name}: `) ? message.slice(name.length + 2) : message
+      );
+      if (!isObject(nested) || typeof nested.error !== "string" || typeof nested.message !== "string")
+        break;
+      name = nested.error;
+      message = nested.message;
+    } catch {
+      break;
+    }
+  }
+  if (value instanceof Error && name === value.name && message === value.message)
+    return value;
+  return Object.assign(new Error(message), { name });
+}
+function normalizeState(value) {
+  if (!isObject(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, field]) => {
+      if (key === "messages" && Array.isArray(field))
+        return [key, field.map(normalizeMessage)];
+      if (key === "__error__") {
+        const error = normalizeRunError(field);
+        if (error instanceof Error)
+          return [key, { error: error.name, message: error.message }];
+      }
+      return [key, field];
+    })
+  );
+}
+function normalizeRunOutput(value, input) {
+  if (!isObject(value)) return value;
+  if (Array.isArray(value.messages)) {
+    if (value.__interrupt__ !== void 0 || value.__error__ !== void 0)
+      return void 0;
+    const inputMessages = isObject(input) && Array.isArray(input.messages) ? input.messages : [];
+    let inputPrefixLength = 0;
+    while (inputPrefixLength < inputMessages.length) {
+      const previous = inputMessages[inputPrefixLength];
+      const message = value.messages[inputPrefixLength];
+      if (isObject(previous) && isObject(message) && previous.id !== void 0 && message.id !== void 0 && previous.id !== message.id || JSON.stringify(normalizeMessage(previous)) !== JSON.stringify(normalizeMessage(message)))
+        break;
+      inputPrefixLength++;
+    }
+    for (let index = value.messages.length - 1; index >= inputPrefixLength; index--) {
+      const message = value.messages[index];
+      const normalized = normalizeMessage(message);
+      if (!isObject(normalized)) continue;
+      if (normalized.role === "user") return void 0;
+      if (normalized.role !== "assistant") continue;
+      if (inputMessages.some((previous) => {
+        if (!isObject(previous) || !isObject(message)) return false;
+        return previous.id !== void 0 && previous.id === message.id && JSON.stringify(normalizeMessage(previous)) === JSON.stringify(normalized);
+      }))
+        continue;
+      return normalized;
+    }
+    return void 0;
+  }
+  const result = Object.fromEntries(
+    Object.entries(value).filter(
+      ([key]) => key !== "__interrupt__" && key !== "__error__"
+    )
+  );
+  return !Object.keys(result).length && (value.__interrupt__ !== void 0 || value.__error__ !== void 0) ? void 0 : result;
+}
+function instrumentRun(operation, [threadId, assistantId, options], invoke) {
+  if (isAutoInstrumentationSuppressed()) return invoke();
+  const start = getCurrentUnixTimestamp();
+  let span;
+  try {
+    const metadata = {
+      "langgraph.thread_id": threadId,
+      "langgraph.assistant_id": assistantId
+    };
+    for (const key of [
+      "streamMode",
+      "streamSubgraphs",
+      "interruptBefore",
+      "interruptAfter",
+      "multitaskStrategy",
+      "durability"
+    ]) {
+      if (options?.[key] !== void 0) metadata[key] = options[key];
+    }
+    span = startSpan(
+      withSpanInstrumentationName(
+        {
+          name: `langgraph.runs.${operation}`,
+          spanAttributes: { type: "task" /* TASK */ },
+          event: {
+            input: options?.command === void 0 ? normalizeState(options?.input) : {
+              input: normalizeState(options.input),
+              command: options.command
+            },
+            metadata
+          }
+        },
+        INSTRUMENTATION_NAMES.LANGGRAPH_SDK
+      )
+    );
+  } catch (error) {
+    debugLogger.error("Error starting LangGraph SDK span:", error);
+    return invoke();
+  }
+  let ended = false;
+  let output;
+  let streamError;
+  let firstToken;
+  const updates = [];
+  const usageByMessage = /* @__PURE__ */ new Map();
+  const captureUsage = (id, usage) => {
+    if (!isObject(usage)) return;
+    const metrics = {};
+    for (const [source, destination] of [
+      ["input_tokens", "prompt_tokens"],
+      ["output_tokens", "completion_tokens"],
+      ["total_tokens", "tokens"]
+    ]) {
+      const value = usage[source];
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        metrics[destination] = value;
+    }
+    if (metrics.tokens === void 0 && metrics.prompt_tokens !== void 0 && metrics.completion_tokens !== void 0)
+      metrics.tokens = metrics.prompt_tokens + metrics.completion_tokens;
+    usageByMessage.set(id, { ...usageByMessage.get(id), ...metrics });
+  };
+  const messages = /* @__PURE__ */ new Map();
+  const messageSnapshots = /* @__PURE__ */ new Map();
+  const finish = (error) => {
+    if (ended) return;
+    ended = true;
+    try {
+      const metrics = {};
+      for (const usage of usageByMessage.values()) {
+        for (const [key, value] of Object.entries(usage))
+          metrics[key] = (metrics[key] ?? 0) + value;
+      }
+      if (firstToken !== void 0)
+        metrics.time_to_first_token = firstToken - start;
+      const finalMessages = [
+        ...new Map([...messages, ...messageSnapshots]).values()
+      ];
+      let loggedOutput = normalizeRunOutput(output, options?.input);
+      if (loggedOutput === void 0 && finalMessages.length)
+        loggedOutput = normalizeRunOutput(
+          { messages: finalMessages },
+          void 0
+        );
+      if (output === void 0 && !finalMessages.length && updates.length) {
+        const results = updates.map((update) => normalizeRunOutput(update, options?.input)).filter((update) => update !== void 0);
+        if (results.length) loggedOutput = { updates: results };
+      }
+      const interrupted = [output, ...updates].find(
+        (state) => isObject(state) && state.__interrupt__ !== void 0
+      );
+      span.log({
+        ...loggedOutput !== void 0 ? { output: loggedOutput } : {},
+        ...isObject(interrupted) ? { metadata: { "langgraph.interrupts": interrupted.__interrupt__ } } : {},
+        ...error !== void 0 || streamError !== void 0 ? { error: normalizeRunError(error ?? streamError) } : {},
+        metrics
+      });
+    } catch (error2) {
+      debugLogger.error("Error logging LangGraph SDK span:", error2);
+    }
+    try {
+      span.end();
+    } catch (error2) {
+      debugLogger.error("Error ending LangGraph SDK span:", error2);
+    }
+  };
+  const observeMessages = (value, streaming) => {
+    if (!isObject(value) || !Array.isArray(value.messages)) return;
+    const inputMessages = isObject(options?.input) && Array.isArray(options.input.messages) ? options.input.messages : [];
+    for (const message of value.messages) {
+      if (!isObject(message) || message.type !== "ai" && message.role !== "assistant")
+        continue;
+      if (message.id !== void 0 && inputMessages.some(
+        (input) => isObject(input) && input.id === message.id
+      ))
+        continue;
+      captureUsage(
+        typeof message.id === "string" ? message.id : "message",
+        message.usage_metadata
+      );
+      if (streaming && (typeof message.content === "string" ? message.content.length > 0 : Array.isArray(message.content) && message.content.some(
+        (part) => isObject(part) && typeof part.text === "string" && part.text.length > 0
+      )))
+        firstToken ??= getCurrentUnixTimestamp();
+    }
+  };
+  const onChunk = ({ event, data }) => {
+    if (ended) return;
+    if (event === "metadata" && isObject(data)) {
+      if (typeof data.run_id === "string")
+        span.log({ metadata: { "langgraph.run_id": data.run_id } });
+    } else if (event === "error") {
+      streamError = normalizeRunError(data);
+    } else if (event === "values") {
+      output = data;
+      observeMessages(data, true);
+    } else if (event === "updates") {
+      if (isObject(data)) {
+        const stateUpdates = [];
+        for (const [node, update] of Object.entries(data)) {
+          observeMessages(update, true);
+          if (isObject(update) && Array.isArray(update.messages)) {
+            for (const message of update.messages) {
+              if (isObject(message))
+                messageSnapshots.set(
+                  typeof message.id === "string" ? message.id : `update-${messageSnapshots.size}`,
+                  message
+                );
+            }
+            const state = Object.fromEntries(
+              Object.entries(update).filter(([key]) => key !== "messages")
+            );
+            if (Object.keys(state).length) stateUpdates.push([node, state]);
+          } else {
+            stateUpdates.push([node, update]);
+          }
+        }
+        if (stateUpdates.length) updates.push(Object.fromEntries(stateUpdates));
+      } else {
+        updates.push(data);
+      }
+    } else if ((event === "messages" || event === "messages/partial" || event === "messages/complete") && Array.isArray(data)) {
+      const parts = event === "messages" ? [data[0]] : data;
+      for (const part of parts) {
+        if (!isObject(part)) continue;
+        const id = typeof part.id === "string" ? part.id : "message";
+        captureUsage(id, part.usage_metadata);
+        const previous = messages.get(id);
+        messages.set(
+          id,
+          event === "messages" && previous && typeof part.content === "string" && typeof previous.content === "string" ? { ...part, content: previous.content + part.content } : part
+        );
+        if (typeof part.content === "string" && part.content.length > 0)
+          firstToken ??= getCurrentUnixTimestamp();
+      }
+    }
+  };
+  let result;
+  try {
+    result = withCurrent(
+      span,
+      () => runWithAutoInstrumentationSuppressed(invoke)
+    );
+  } catch (error) {
+    finish(error);
+    throw error;
+  }
+  if (operation === "stream") {
+    try {
+      patchStreamIfNeeded(result, {
+        shouldCollect: (chunk) => {
+          try {
+            onChunk(chunk);
+          } catch (error) {
+            debugLogger.error(
+              "Error processing LangGraph stream event:",
+              error
+            );
+          }
+          return false;
+        },
+        aroundNext: (next) => withCurrent(span, () => runWithAutoInstrumentationSuppressed(next)),
+        onComplete: () => finish(),
+        onCancel: () => finish(),
+        onError: (error) => finish(error)
+      });
+    } catch (error) {
+      debugLogger.error("Error observing LangGraph stream:", error);
+      finish();
+    }
+  } else {
+    void Promise.resolve(result).then(
+      (value) => {
+        try {
+          output = value;
+          observeMessages(value, false);
+          if (isObject(value) && isObject(value.__error__))
+            streamError = normalizeRunError(value.__error__);
+          finish();
+        } catch (error) {
+          finish(error);
+        }
+      },
+      (error) => finish(error)
+    );
+  }
+  return result;
+}
+
 // src/instrumentation/plugins/ollama-channels.ts
 var ollamaChannels = defineChannels(
   "ollama",
@@ -27231,7 +28687,7 @@ function normalizeTextAndImages(content, images) {
     ...unrecognizedImages.length > 0 ? { unrecognizedImages } : {}
   };
 }
-function normalizeMessage(message, toolCallId, syntheticToolCallIdOffset = 0) {
+function normalizeMessage2(message, toolCallId, syntheticToolCallIdOffset = 0) {
   if (typeof message.role !== "string") {
     return void 0;
   }
@@ -27277,7 +28733,7 @@ function normalizeMessages(messages) {
         toolCallId = pendingToolCallIds.get(toolName)?.shift();
       }
     }
-    const normalized = normalizeMessage(
+    const normalized = normalizeMessage2(
       ollamaMessage,
       toolCallId,
       syntheticToolCallIdOffset
@@ -27396,7 +28852,7 @@ function extractOllamaChatOutput(result, syntheticToolCallIdOffset = 0) {
   if (!isObject(result) || !isObject(result.message)) {
     return void 0;
   }
-  const message = normalizeMessage(
+  const message = normalizeMessage2(
     result.message,
     void 0,
     syntheticToolCallIdOffset
@@ -30116,14 +31572,14 @@ function extractActionSpanMetadata(args) {
   const options = extractRunInNewSpanOptions(args);
   const labels = isObject(options?.labels) ? options.labels : void 0;
   const metadata = isObject(options?.metadata) ? options.metadata : void 0;
-  const actionType = stringValue(labels?.["genkit:metadata:subtype"]);
-  const name = stringValue(metadata?.name);
+  const actionType = stringValue2(labels?.["genkit:metadata:subtype"]);
+  const name = stringValue2(metadata?.name);
   if (!actionType || !name) {
     return void 0;
   }
   return {
     actionType,
-    key: stringValue(labels?.["genkit:key"]),
+    key: stringValue2(labels?.["genkit:key"]),
     name
   };
 }
@@ -30233,7 +31689,7 @@ function pickNumberMetrics(values) {
     })
   );
 }
-function stringValue(value) {
+function stringValue2(value) {
   return typeof value === "string" ? value : void 0;
 }
 
@@ -30918,7 +32374,7 @@ function subscribeToFlueContext(value, state) {
     try {
       unsubscribe?.();
     } catch (error) {
-      logInstrumentationError3("Flue context unsubscribe", error);
+      logInstrumentationError4("Flue context unsubscribe", error);
     }
   };
   try {
@@ -30934,7 +32390,7 @@ function subscribeToFlueContext(value, state) {
     });
     state.contexts.add(value);
   } catch (error) {
-    logInstrumentationError3("Flue context subscription", error);
+    logInstrumentationError4("Flue context subscription", error);
   }
 }
 function isAutoContextTerminalEvent(event, ctx) {
@@ -30990,7 +32446,7 @@ var FlueObserveBridge = class {
     try {
       this.handleEvent(event, flueContextFromUnknown(ctx));
     } catch (error) {
-      logInstrumentationError3("Flue observe", error);
+      logInstrumentationError4("Flue observe", error);
     }
   }
   reset() {
@@ -31007,7 +32463,7 @@ var FlueObserveBridge = class {
     try {
       span = this.spanForExecutionOperation(operation, executionContext);
     } catch (error) {
-      logInstrumentationError3("Flue execution interceptor", error);
+      logInstrumentationError4("Flue execution interceptor", error);
     }
     return span ? runWithCurrentSpanStore(span, next) : next();
   }
@@ -31213,7 +32669,7 @@ var FlueObserveBridge = class {
       this.runsById.delete(event.runId);
     }
     void flush().catch((error) => {
-      logInstrumentationError3("Flue flush", error);
+      logInstrumentationError4("Flue flush", error);
     });
   }
   handleOperationStart(event) {
@@ -31988,17 +33444,17 @@ function safeLog3(span, event) {
   try {
     span.log(event);
   } catch (error) {
-    logInstrumentationError3("Flue span log", error);
+    logInstrumentationError4("Flue span log", error);
   }
 }
 function safeEnd(span, endTime) {
   try {
     span.end(endTime === void 0 ? void 0 : { endTime });
   } catch (error) {
-    logInstrumentationError3("Flue span end", error);
+    logInstrumentationError4("Flue span end", error);
   }
 }
-function logInstrumentationError3(label, error) {
+function logInstrumentationError4(label, error) {
   debugLogger.debug(`Error in ${label} instrumentation:`, error);
 }
 
@@ -32566,10 +34022,10 @@ var LangSmithPlugin = class extends BasePlugin {
     const creates = ownValue(batch, "runCreates");
     if (Array.isArray(creates)) {
       const parentFirst = [...creates].sort((left, right) => {
-        const leftId = stringValue2(ownValue(left, "id"));
-        const rightId = stringValue2(ownValue(right, "id"));
-        const leftParent = stringValue2(ownValue(left, "parent_run_id"));
-        const rightParent = stringValue2(ownValue(right, "parent_run_id"));
+        const leftId = stringValue3(ownValue(left, "id"));
+        const rightId = stringValue3(ownValue(right, "id"));
+        const leftParent = stringValue3(ownValue(left, "parent_run_id"));
+        const rightParent = stringValue3(ownValue(right, "parent_run_id"));
         if (leftParent && leftParent === rightId) {
           return 1;
         }
@@ -32588,13 +34044,13 @@ var LangSmithPlugin = class extends BasePlugin {
     if (Array.isArray(updates)) {
       for (const run of updates) {
         this.containLifecycleFailure("batchIngestRuns update", () => {
-          this.processUpdate(stringValue2(ownValue(run, "id")) ?? "", run);
+          this.processUpdate(stringValue3(ownValue(run, "id")) ?? "", run);
         });
       }
     }
   }
   processCreate(run) {
-    const id = stringValue2(ownValue(run, "id"));
+    const id = stringValue3(ownValue(run, "id"));
     if (!id || this.completedRuns.get(id)) {
       return;
     }
@@ -32627,7 +34083,7 @@ var LangSmithPlugin = class extends BasePlugin {
     this.endIfComplete(id, activeRun, run);
   }
   processUpdate(explicitId, run) {
-    const id = stringValue2(explicitId) ?? stringValue2(ownValue(run, "id"));
+    const id = stringValue3(explicitId) ?? stringValue3(ownValue(run, "id"));
     if (!id || this.completedRuns.get(id)) {
       return;
     }
@@ -32650,13 +34106,13 @@ var LangSmithPlugin = class extends BasePlugin {
     this.endIfComplete(id, active, active.run);
   }
   startRunSpan(id, run) {
-    const traceId = stringValue2(ownValue(run, "trace_id")) ?? id;
-    const parentId = stringValue2(ownValue(run, "parent_run_id")) ?? stringValue2(ownValue(ownValue(run, "parent_run"), "id"));
+    const traceId = stringValue3(ownValue(run, "trace_id")) ?? id;
+    const parentId = stringValue3(ownValue(run, "parent_run_id")) ?? stringValue3(ownValue(ownValue(run, "parent_run"), "id"));
     const startTime = timestampSeconds(ownValue(run, "start_time"));
     return startSpan(
       withSpanInstrumentationName(
         {
-          name: stringValue2(ownValue(run, "name")) ?? "LangSmith run",
+          name: stringValue3(ownValue(run, "name")) ?? "LangSmith run",
           spanId: id,
           parentSpanIds: {
             parentSpanIds: parentId ? [parentId] : [],
@@ -32748,7 +34204,7 @@ function mergeRuns(previous, current) {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function stringValue2(value) {
+function stringValue3(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function timestampSeconds(value) {
@@ -32766,7 +34222,7 @@ function timestampSeconds(value) {
   return void 0;
 }
 function dottedOrderDepth(run) {
-  const dottedOrder = stringValue2(ownValue(run, "dotted_order"));
+  const dottedOrder = stringValue3(ownValue(run, "dotted_order"));
   return dottedOrder ? dottedOrder.split(".").length : Number.MAX_SAFE_INTEGER;
 }
 function mapRunType(runType) {
@@ -32971,7 +34427,7 @@ var PiCodingAgentPlugin = class extends BasePlugin {
               }
             );
           } catch (error) {
-            logInstrumentationError4("Pi Coding Agent prompt start", error);
+            logInstrumentationError5("Pi Coding Agent prompt start", error);
           }
           if (!state) {
             return runWithAutoInstrumentationSuppressed(invokeTarget);
@@ -33104,12 +34560,12 @@ function installPiAgentInstrumentation(agent) {
           () => handlePiAgentEvent(state, event)
         );
       } catch (error) {
-        logInstrumentationError4("Pi Coding Agent event", error);
+        logInstrumentationError5("Pi Coding Agent event", error);
       }
     });
     piAgentEventSubscriptions.add(agent);
   } catch (error) {
-    logInstrumentationError4("Pi Coding Agent event subscription", error);
+    logInstrumentationError5("Pi Coding Agent event subscription", error);
   }
 }
 function makeInstrumentedStreamFunction(agent, originalStreamFunction, property) {
@@ -33159,7 +34615,7 @@ function wrapPiToolExecutors(tools) {
       });
       tool.execute = wrappedExecute;
     } catch (error) {
-      logInstrumentationError4("Pi Coding Agent tool wrapping", error);
+      logInstrumentationError5("Pi Coding Agent tool wrapping", error);
     }
   }
 }
@@ -33238,7 +34694,7 @@ function patchAssistantMessageStream(stream, promptState, llmState) {
               try {
                 await iterator.return();
               } catch (cleanupError) {
-                logInstrumentationError4(
+                logInstrumentationError5(
                   "Pi Coding Agent stream cleanup",
                   cleanupError
                 );
@@ -33403,7 +34859,7 @@ function finishPiPromptRun(state, error) {
     try {
       state.span.end();
     } catch (endError) {
-      logInstrumentationError4("Pi Coding Agent prompt end", endError);
+      logInstrumentationError5("Pi Coding Agent prompt end", endError);
     }
   }
 }
@@ -33735,10 +35191,10 @@ function safeLog4(span, event) {
   try {
     span.log(event);
   } catch (error) {
-    logInstrumentationError4("Pi Coding Agent span log", error);
+    logInstrumentationError5("Pi Coding Agent span log", error);
   }
 }
-function logInstrumentationError4(context, error) {
+function logInstrumentationError5(context, error) {
   debugLogger.debug(`${context}:`, error);
 }
 
@@ -33976,7 +35432,7 @@ function handleAgentStreamEvent(state, event) {
         finalizeModelSpan(state, event);
         break;
       case "beforeToolCallEvent":
-        startToolSpan2(state, event);
+        startToolSpan3(state, event);
         break;
       case "afterToolCallEvent":
         finalizeToolSpan(state, event);
@@ -34001,7 +35457,7 @@ function handleAgentStreamEvent(state, event) {
         break;
     }
   } catch (error) {
-    logInstrumentationError5("Strands Agent SDK event", error);
+    logInstrumentationError6("Strands Agent SDK event", error);
   }
 }
 function handleMultiAgentStreamEvent(state, event, activeChildParents) {
@@ -34037,7 +35493,7 @@ function handleMultiAgentStreamEvent(state, event, activeChildParents) {
         break;
     }
   } catch (error) {
-    logInstrumentationError5("Strands Agent SDK multi-agent event", error);
+    logInstrumentationError6("Strands Agent SDK multi-agent event", error);
   }
 }
 function buildModelSpanInput(event, attachmentCache) {
@@ -34116,7 +35572,7 @@ function finalizeModelSpan(state, event) {
   });
   modelState.span.end();
 }
-function startToolSpan2(state, event) {
+function startToolSpan3(state, event) {
   const toolUse = event.toolUse;
   const key = toolKey2(toolUse);
   if (state.activeTools.has(key)) {
@@ -34396,7 +35852,7 @@ function getModelConfig(model) {
   try {
     return model.getConfig();
   } catch (error) {
-    logInstrumentationError5("Strands Agent SDK model config", error);
+    logInstrumentationError6("Strands Agent SDK model config", error);
     return void 0;
   }
 }
@@ -34479,7 +35935,7 @@ function processStrandsInputAttachments(input, cache = createStrandsAttachmentCa
   try {
     return processStrandsInputNode(input, cache);
   } catch (error) {
-    logInstrumentationError5("Strands Agent SDK input attachments", error);
+    logInstrumentationError6("Strands Agent SDK input attachments", error);
     return input;
   }
 }
@@ -34699,13 +36155,484 @@ function safeLog5(span, event) {
   try {
     span.log(event);
   } catch (error) {
-    logInstrumentationError5("Strands Agent SDK span log", error);
+    logInstrumentationError6("Strands Agent SDK span log", error);
   }
 }
-function logInstrumentationError5(context, error) {
+function logInstrumentationError6(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 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",
@@ -34773,7 +36700,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 +36708,7 @@ function interceptVoyageAICall(channel2, name, extractInput2, extractOutput2, ex
     }
     let span;
     try {
-      const { input, metadata } = extractInput2(args);
+      const { input, metadata } = extractInput3(args);
       span = startSpan(
         withSpanInstrumentationName(
           {
@@ -35131,14 +37058,14 @@ var CloudflareAIChatPlugin = class extends BasePlugin {
           const result = event.arguments[0];
           state = agent ? this.findResponseState(
             agent,
-            stringValue3(ownValue2(result, "requestId"))
+            stringValue4(ownValue2(result, "requestId"))
           ) : void 0;
           if (!state) {
             return;
           }
           state.responseObserved = true;
           const output = serializeMessage(ownValue2(result, "message"));
-          const status = stringValue3(ownValue2(result, "status"));
+          const status = stringValue4(ownValue2(result, "status"));
           const error = ownValue2(result, "error");
           const input = ownValue2(result, "continuation") === true ? state.input : serializeMessages(readProperty(agent, "messages"))?.filter(
             (message) => typeof output?.id !== "string" || message.id !== output.id
@@ -35185,7 +37112,7 @@ var CloudflareAIChatPlugin = class extends BasePlugin {
     }
     try {
       const agent = asObject(event.self);
-      const requestId = stringValue3(event.arguments[0]);
+      const requestId = stringValue4(event.arguments[0]);
       const key = requestId ?? /* @__PURE__ */ Symbol("cloudflare-ai-chat-turn");
       const activeForAgent = agent ? this.getActiveTurns(agent) : void 0;
       const existing = activeForAgent?.get(key);
@@ -35354,7 +37281,7 @@ function ownValue2(value, key) {
   const descriptor = Object.getOwnPropertyDescriptor(object, key);
   return descriptor && "value" in descriptor ? descriptor.value : void 0;
 }
-function stringValue3(value) {
+function stringValue4(value) {
   return typeof value === "string" ? value : void 0;
 }
 function serializeMessages(value) {
@@ -35472,7 +37399,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
           );
           spans.set(event, span);
         } catch (error) {
-          logInstrumentationError6("start", error);
+          logInstrumentationError7("start", error);
         }
       },
       asyncEnd: (event) => {
@@ -35492,7 +37419,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
             }
           }
         } catch (error) {
-          logInstrumentationError6("completion", error);
+          logInstrumentationError7("completion", error);
         } finally {
           safelyEndSpan(span);
         }
@@ -35506,7 +37433,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
         try {
           span.log({ error: event.error });
         } catch (error) {
-          logInstrumentationError6("rejection", error);
+          logInstrumentationError7("rejection", error);
         } finally {
           safelyEndSpan(span);
         }
@@ -35536,10 +37463,10 @@ function safelyEndSpan(span) {
   try {
     span.end();
   } catch (error) {
-    logInstrumentationError6("span end", error);
+    logInstrumentationError7("span end", error);
   }
 }
-function logInstrumentationError6(operation, error) {
+function logInstrumentationError7(operation, error) {
   debugLogger.error(
     `Failed to process Cloudflare Agents ${operation} instrumentation:`,
     error
@@ -35557,12 +37484,14 @@ var BraintrustPlugin = class extends BasePlugin {
   cloudflareThinkPlugin = null;
   cursorSDKPlugin = null;
   openAIAgentsPlugin = null;
+  googleGenerativeAIPlugin = null;
   googleGenAIPlugin = null;
   huggingFacePlugin = null;
   huggingFaceTransformersPlugin = null;
   openRouterPlugin = null;
   openRouterAgentPlugin = null;
   mistralPlugin = null;
+  langGraphSDKPlugin = null;
   ollamaPlugin = null;
   googleADKPlugin = null;
   coherePlugin = null;
@@ -35575,6 +37504,7 @@ var BraintrustPlugin = class extends BasePlugin {
   langSmithPlugin = null;
   piCodingAgentPlugin = null;
   strandsAgentSDKPlugin = null;
+  elevenLabsPlugin = null;
   voyageAIPlugin = null;
   cloudflareAIChatPlugin = null;
   cloudflareAgentsPlugin = null;
@@ -35616,6 +37546,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();
@@ -35638,6 +37572,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.mistralPlugin = new MistralPlugin();
       this.mistralPlugin.enable();
     }
+    if (integrations.langgraphSDK !== false) {
+      this.langGraphSDKPlugin = new LangGraphSDKPlugin();
+      this.langGraphSDKPlugin.enable();
+    }
     if (integrations.ollama !== false) {
       this.ollamaPlugin = new OllamaPlugin();
       this.ollamaPlugin.enable();
@@ -35650,6 +37588,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 +37676,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;
@@ -35758,6 +37704,10 @@ var BraintrustPlugin = class extends BasePlugin {
       this.mistralPlugin.disable();
       this.mistralPlugin = null;
     }
+    if (this.langGraphSDKPlugin) {
+      this.langGraphSDKPlugin.disable();
+      this.langGraphSDKPlugin = null;
+    }
     if (this.ollamaPlugin) {
       this.ollamaPlugin.disable();
       this.ollamaPlugin = null;
@@ -35770,6 +37720,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;
@@ -35828,7 +37782,31 @@ var MAX_STORED_LLM_INPUTS = 100;
 var MAX_STORED_REASONING_BLOCKS = 100;
 var MAX_STORED_SPAN_REFERENCES = 1e4;
 var MAX_STORED_STEP_STARTS = 1e4;
+var EVE_HANDLED_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "action.result",
+  "actions.requested",
+  "message.completed",
+  "message.received",
+  "reasoning.completed",
+  "result.completed",
+  "session.completed",
+  "session.failed",
+  "session.started",
+  "step.completed",
+  "step.failed",
+  "step.started",
+  "subagent.called",
+  "subagent.completed",
+  "turn.completed",
+  "turn.failed",
+  "turn.started"
+]);
 function braintrustEveHook(options) {
+  if (!options || typeof options.defineState !== "function") {
+    throw new TypeError(
+      "braintrustEveHook requires Eve's defineState function"
+    );
+  }
   const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
   const bridge = new EveBridge(state);
   return {
@@ -35840,15 +37818,27 @@ function braintrustEveHook(options) {
   };
 }
 function createLegacyEveInstrumentation(options) {
+  if (!options || typeof options.defineState !== "function") {
+    throw new TypeError(
+      "braintrustEveInstrumentation requires Eve's defineState function"
+    );
+  }
   const state = options.defineState(EVE_TRACE_STATE_KEY, emptyEveTraceState);
   return {
     events: {
       "step.started": (input) => {
         try {
+          if (!isEveInstrumentationStepStartedEventInput(input)) {
+            debugLogger.warn(
+              "Ignoring malformed Eve instrumentation step.started event"
+            );
+            return void 0;
+          }
           captureEveModelInput(state, input);
         } catch (error) {
           debugLogger.warn("Error in Eve LLM input capture:", error);
         }
+        return void 0;
       }
     },
     recordInputs: false,
@@ -35857,7 +37847,77 @@ function createLegacyEveInstrumentation(options) {
   };
 }
 function isEveHandleMessageStreamEvent(event) {
-  return isObject(event) && typeof event["type"] === "string";
+  if (!isObject(event) || typeof event["type"] !== "string") {
+    return false;
+  }
+  const type = event["type"];
+  if (type === "session.completed") {
+    return true;
+  }
+  if (!isObject(event["data"])) {
+    return false;
+  }
+  const data = event["data"];
+  if (type === "session.started") {
+    return true;
+  }
+  if (type === "session.failed") {
+    return typeof data["sessionId"] === "string" && typeof data["code"] === "string" && typeof data["message"] === "string";
+  }
+  if (type === "session.waiting") {
+    return data["wait"] === "next-user-message";
+  }
+  if (typeof data["turnId"] !== "string" || typeof data["sequence"] !== "number" || !Number.isFinite(data["sequence"])) {
+    return false;
+  }
+  if (type === "turn.started" || type === "turn.completed" || type === "subagent.called" || type === "subagent.completed") {
+    if (type === "subagent.called") {
+      return typeof data["callId"] === "string" && typeof data["childSessionId"] === "string" && typeof data["name"] === "string";
+    }
+    if (type === "subagent.completed") {
+      return typeof data["callId"] === "string" && typeof data["subagentName"] === "string";
+    }
+    return true;
+  }
+  if (type === "turn.failed") {
+    return typeof data["code"] === "string" && typeof data["message"] === "string";
+  }
+  if (type === "message.received") {
+    return typeof data["message"] === "string";
+  }
+  if (typeof data["stepIndex"] !== "number" || !Number.isFinite(data["stepIndex"]) || data["stepIndex"] < 0) {
+    return false;
+  }
+  switch (type) {
+    case "step.started":
+      return true;
+    case "message.completed":
+      return typeof data["finishReason"] === "string" && (typeof data["message"] === "string" || data["message"] === null);
+    case "reasoning.completed":
+      return typeof data["reasoning"] === "string";
+    case "result.completed":
+      return true;
+    case "step.completed":
+      return typeof data["finishReason"] === "string";
+    case "step.failed":
+      return typeof data["code"] === "string" && typeof data["message"] === "string";
+    case "actions.requested":
+      return Array.isArray(data["actions"]);
+    case "action.result":
+      return isObject(data["result"]) && (data["status"] === "completed" || data["status"] === "failed" || data["status"] === "rejected");
+    default:
+      return false;
+  }
+}
+function isEveInstrumentationStepStartedEventInput(input) {
+  if (!isObject(input)) {
+    return false;
+  }
+  const modelInput = input["modelInput"];
+  const session = input["session"];
+  const step = input["step"];
+  const turn = input["turn"];
+  return isObject(modelInput) && Array.isArray(modelInput["messages"]) && isObject(session) && typeof session["id"] === "string" && isObject(step) && typeof step["index"] === "number" && Number.isFinite(step["index"]) && step["index"] >= 0 && isObject(turn) && typeof turn["id"] === "string" && typeof turn["sequence"] === "number" && Number.isFinite(turn["sequence"]);
 }
 var ResumedEveSpan = class {
   constructor(reference) {
@@ -36026,7 +38086,17 @@ var EveBridge = class {
     });
   }
   async handle(event, ctx, hookMetadata) {
+    try {
+      await this.handleUnchecked(event, ctx, hookMetadata);
+    } catch (error) {
+      debugLogger.warn("Error in Eve hook instrumentation:", error);
+    }
+  }
+  async handleUnchecked(event, ctx, hookMetadata) {
     if (!isEveHandleMessageStreamEvent(event)) {
+      if (isObject(event) && typeof event["type"] === "string" && EVE_HANDLED_EVENT_TYPES.has(event["type"])) {
+        debugLogger.warn(`Ignoring malformed Eve hook ${event["type"]} event`);
+      }
       return;
     }
     const run = async () => {
@@ -36352,9 +38422,14 @@ var EveBridge = class {
     }
     for (const action of traceActions) {
       const name = action.kind === "tool-call" ? action.toolName : action.subagentName ?? action.name ?? "agent";
+      let args = "null";
+      try {
+        args = JSON.stringify(action.input) ?? "null";
+      } catch {
+      }
       toolCallsById.set(action.callId, {
         function: {
-          arguments: JSON.stringify(action.input),
+          arguments: args,
           name
         },
         id: action.callId,
@@ -37223,17 +39298,33 @@ function consumeCapturedEveModelInput(state, sessionId, turnId, stepIndex) {
   }
 }
 function capturedModelInput(modelInput) {
-  const { instructions, messages } = modelInput;
-  const value = [];
-  if (typeof instructions === "string") {
-    value.push({ content: instructions, role: "system" });
-  } else if (Array.isArray(instructions)) {
-    value.push(...instructions.map(capturedEveModelMessage));
-  } else if (instructions) {
-    value.push(capturedEveModelMessage(instructions));
-  }
-  value.push(...messages.map(capturedEveModelMessage));
   try {
+    if (!isObject(modelInput) || !Array.isArray(modelInput["messages"])) {
+      return void 0;
+    }
+    const value = [];
+    const instructions = modelInput["instructions"];
+    if (typeof instructions === "string") {
+      value.push({ content: instructions, role: "system" });
+    } else if (Array.isArray(instructions)) {
+      for (const instruction of instructions) {
+        const captured = capturedEveModelMessage(instruction);
+        if (captured?.role === "system") {
+          value.push(captured);
+        }
+      }
+    } else {
+      const captured = capturedEveModelMessage(instructions);
+      if (captured?.role === "system") {
+        value.push(captured);
+      }
+    }
+    for (const message of modelInput["messages"]) {
+      const captured = capturedEveModelMessage(message);
+      if (captured) {
+        value.push(captured);
+      }
+    }
     const cloned = JSON.parse(JSON.stringify(value));
     if (!Array.isArray(cloned)) {
       return void 0;
@@ -37244,116 +39335,202 @@ function capturedModelInput(modelInput) {
   }
 }
 function capturedEveModelMessage(message) {
-  const { content, role } = message;
+  if (!isObject(message)) {
+    return void 0;
+  }
+  const role = message["role"];
+  if (role !== "system" && role !== "user" && role !== "assistant" && role !== "tool") {
+    return void 0;
+  }
+  const content = message["content"];
   if (typeof content === "string") {
     return { content, role };
   }
-  return { content: content.map(capturedEveModelContentPart), role };
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const capturedContent = [];
+  for (const part of content) {
+    const captured = capturedEveModelContentPart(part);
+    if (captured) {
+      capturedContent.push(captured);
+    }
+  }
+  return { content: capturedContent, role };
 }
 function capturedEveModelContentPart(part) {
-  switch (part.type) {
+  if (!isObject(part) || typeof part["type"] !== "string") {
+    return void 0;
+  }
+  switch (part["type"]) {
     case "text":
-    case "reasoning":
-      return { text: part.text, type: part.type };
+    case "reasoning": {
+      const text = part["text"];
+      return typeof text === "string" ? { text, type: part["type"] } : void 0;
+    }
     case "image":
+      if (!Object.hasOwn(part, "image")) {
+        return void 0;
+      }
       return {
-        image: part.image,
-        ...part.mediaType !== void 0 ? { mediaType: part.mediaType } : {},
+        image: part["image"],
+        ...typeof part["mediaType"] === "string" ? { mediaType: part["mediaType"] } : {},
         type: "image"
       };
     case "file":
-    case "reasoning-file":
+    case "reasoning-file": {
+      if (!Object.hasOwn(part, "data") || typeof part["mediaType"] !== "string") {
+        return void 0;
+      }
       return {
-        data: part.data,
-        ...part.type === "file" && part.filename !== void 0 ? { filename: part.filename } : {},
-        mediaType: part.mediaType,
-        type: part.type
+        data: part["data"],
+        ...part["type"] === "file" && typeof part["filename"] === "string" ? { filename: part["filename"] } : {},
+        mediaType: part["mediaType"],
+        type: part["type"]
       };
+    }
     case "custom":
       return {
-        ..."kind" in part ? { kind: part.kind } : {},
+        ...typeof part["kind"] === "string" ? { kind: part["kind"] } : {},
         type: "custom"
       };
-    case "tool-call":
+    case "tool-call": {
+      if (typeof part["toolCallId"] !== "string" || typeof part["toolName"] !== "string") {
+        return void 0;
+      }
       return {
-        input: part.input,
-        ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {},
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
+        input: part["input"],
+        ...typeof part["providerExecuted"] === "boolean" ? { providerExecuted: part["providerExecuted"] } : {},
+        toolCallId: part["toolCallId"],
+        toolName: part["toolName"],
         type: "tool-call"
       };
+    }
     case "tool-result": {
-      const output = part.output;
+      const output = part["output"];
+      if (typeof part["toolCallId"] !== "string" || typeof part["toolName"] !== "string" || !isObject(output) || typeof output["type"] !== "string") {
+        return void 0;
+      }
       let capturedOutput;
-      switch (output.type) {
+      switch (output["type"]) {
         case "text":
-        case "error-text":
-          capturedOutput = { type: output.type, value: output.value };
+        case "error-text": {
+          if (typeof output["value"] !== "string") {
+            return void 0;
+          }
+          capturedOutput = {
+            type: output["type"],
+            value: output["value"]
+          };
           break;
+        }
         case "json":
         case "error-json":
-          capturedOutput = { type: output.type, value: output.value };
+          capturedOutput = {
+            type: output["type"],
+            value: output["value"]
+          };
           break;
         case "execution-denied":
           capturedOutput = {
-            ...output.reason !== void 0 ? { reason: output.reason } : {},
+            ...typeof output["reason"] === "string" ? { reason: output["reason"] } : {},
             type: "execution-denied"
           };
           break;
-        case "content":
+        case "content": {
+          if (!Array.isArray(output["value"])) {
+            return void 0;
+          }
+          const value = [];
+          for (const outputPart of output["value"]) {
+            const captured = capturedEveModelContentPart(outputPart);
+            if (captured) {
+              value.push(captured);
+            }
+          }
           capturedOutput = {
             type: "content",
-            value: output.value.map(capturedEveModelContentPart)
+            value
           };
           break;
+        }
+        default:
+          return void 0;
       }
       return {
         output: capturedOutput,
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
+        toolCallId: part["toolCallId"],
+        toolName: part["toolName"],
         type: "tool-result"
       };
     }
-    case "tool-approval-request":
+    case "tool-approval-request": {
+      if (typeof part["approvalId"] !== "string" || typeof part["toolCallId"] !== "string") {
+        return void 0;
+      }
       return {
-        approvalId: part.approvalId,
-        ...part.isAutomatic !== void 0 ? { isAutomatic: part.isAutomatic } : {},
-        ...part.signature !== void 0 ? { signature: part.signature } : {},
-        toolCallId: part.toolCallId,
+        approvalId: part["approvalId"],
+        ...typeof part["isAutomatic"] === "boolean" ? { isAutomatic: part["isAutomatic"] } : {},
+        ...typeof part["signature"] === "string" ? { signature: part["signature"] } : {},
+        toolCallId: part["toolCallId"],
         type: "tool-approval-request"
       };
-    case "tool-approval-response":
+    }
+    case "tool-approval-response": {
+      if (typeof part["approvalId"] !== "string" || typeof part["approved"] !== "boolean") {
+        return void 0;
+      }
       return {
-        approvalId: part.approvalId,
-        approved: part.approved,
-        ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {},
-        ...part.reason !== void 0 ? { reason: part.reason } : {},
+        approvalId: part["approvalId"],
+        approved: part["approved"],
+        ...typeof part["providerExecuted"] === "boolean" ? { providerExecuted: part["providerExecuted"] } : {},
+        ...typeof part["reason"] === "string" ? { reason: part["reason"] } : {},
         type: "tool-approval-response"
       };
+    }
     case "file-data":
-    case "image-data":
+    case "image-data": {
+      if (typeof part["data"] !== "string" || typeof part["mediaType"] !== "string") {
+        return void 0;
+      }
       return {
-        data: part.data,
-        ...part.type === "file-data" && part.filename !== void 0 ? { filename: part.filename } : {},
-        mediaType: part.mediaType,
-        type: part.type
+        data: part["data"],
+        ...part["type"] === "file-data" && typeof part["filename"] === "string" ? { filename: part["filename"] } : {},
+        mediaType: part["mediaType"],
+        type: part["type"]
       };
+    }
     case "file-url":
-    case "image-url":
+    case "image-url": {
+      if (typeof part["url"] !== "string") {
+        return void 0;
+      }
       return {
-        ...part.type === "file-url" && part.mediaType !== void 0 ? { mediaType: part.mediaType } : {},
-        type: part.type,
-        url: part.url
+        ...part["type"] === "file-url" && typeof part["mediaType"] === "string" ? { mediaType: part["mediaType"] } : {},
+        type: part["type"],
+        url: part["url"]
       };
+    }
     case "file-id":
-    case "image-file-id":
-      return { fileId: part.fileId, type: part.type };
+    case "image-file-id": {
+      const fileId = part["fileId"];
+      if (typeof fileId !== "string" && !isObject(fileId)) {
+        return void 0;
+      }
+      return { fileId, type: part["type"] };
+    }
     case "file-reference":
-    case "image-file-reference":
+    case "image-file-reference": {
+      if (!isObject(part["providerReference"])) {
+        return void 0;
+      }
       return {
-        providerReference: part.providerReference,
-        type: part.type
+        providerReference: part["providerReference"],
+        type: part["type"]
       };
+    }
+    default:
+      return void 0;
   }
 }
 function isCapturedModelInput(input) {
@@ -37489,18 +39666,54 @@ function createEveInstrumentationProvider(options = {}) {
       recordOutputs: true
     }),
     events: {
-      "action.completed": (event, context) => bridge.handleActionTerminal(event, context),
-      "action.failed": (event, context) => bridge.handleActionTerminal(event, context),
-      "action.started": (event, context) => bridge.handleActionStarted(event, context),
-      "model.call.completed": (event, context) => bridge.handleModelTerminal(event, context),
-      "model.call.failed": (event, context) => bridge.handleModelTerminal(event, context),
-      "model.call.started": (event, context) => bridge.handleModelStarted(event, context),
-      "step.attempt.completed": (event) => bridge.handleStepAttemptTerminal(event),
-      "step.attempt.failed": (event) => bridge.handleStepAttemptTerminal(event),
-      "turn.cancelled": (event, context) => bridge.handleTurnTerminal(event, context),
-      "turn.completed": (event, context) => bridge.handleTurnTerminal(event, context),
-      "turn.failed": (event, context) => bridge.handleTurnTerminal(event, context),
-      "turn.started": (event, context) => bridge.handleTurnStarted(event, context)
+      "action.completed": providerHandler(
+        "action.completed",
+        bridge.handleActionTerminal.bind(bridge)
+      ),
+      "action.failed": providerHandler(
+        "action.failed",
+        bridge.handleActionTerminal.bind(bridge)
+      ),
+      "action.started": providerHandler(
+        "action.started",
+        bridge.handleActionStarted.bind(bridge)
+      ),
+      "model.call.completed": providerHandler(
+        "model.call.completed",
+        bridge.handleModelTerminal.bind(bridge)
+      ),
+      "model.call.failed": providerHandler(
+        "model.call.failed",
+        bridge.handleModelTerminal.bind(bridge)
+      ),
+      "model.call.started": providerHandler(
+        "model.call.started",
+        bridge.handleModelStarted.bind(bridge)
+      ),
+      "step.attempt.completed": providerHandler(
+        "step.attempt.completed",
+        (event) => bridge.handleStepAttemptTerminal(event)
+      ),
+      "step.attempt.failed": providerHandler(
+        "step.attempt.failed",
+        (event) => bridge.handleStepAttemptTerminal(event)
+      ),
+      "turn.cancelled": providerHandler(
+        "turn.cancelled",
+        bridge.handleTurnTerminal.bind(bridge)
+      ),
+      "turn.completed": providerHandler(
+        "turn.completed",
+        bridge.handleTurnTerminal.bind(bridge)
+      ),
+      "turn.failed": providerHandler(
+        "turn.failed",
+        bridge.handleTurnTerminal.bind(bridge)
+      ),
+      "turn.started": providerHandler(
+        "turn.started",
+        bridge.handleTurnStarted.bind(bridge)
+      )
     },
     flush,
     setup: options.setup
@@ -37856,17 +40069,20 @@ function modelOutput(event) {
   const reasoning = [];
   const toolCalls = [];
   for (const part of content) {
-    if (part.type === "text") {
-      text += part.text;
-    } else if (part.type === "reasoning" && part.text.trim().length > 0) {
-      reasoning.push({ content: part.text });
-    } else if (part.type === "tool-call") {
+    if (!isObject(part)) {
+      continue;
+    }
+    if (part["type"] === "text" && typeof part["text"] === "string") {
+      text += part["text"];
+    } else if (part["type"] === "reasoning" && typeof part["text"] === "string" && part["text"].trim().length > 0) {
+      reasoning.push({ content: part["text"] });
+    } else if (part["type"] === "tool-call" && typeof part["toolName"] === "string" && typeof part["callId"] === "string") {
       toolCalls.push({
         function: {
-          arguments: safeJsonStringify(part.input),
-          name: part.toolName
+          arguments: safeJsonStringify(part["input"]),
+          name: part["toolName"]
         },
-        id: part.callId,
+        id: part["callId"],
         type: "function"
       });
     }
@@ -37885,13 +40101,13 @@ function modelOutput(event) {
   ];
 }
 function usageMetrics(usage) {
-  const promptTokens = nonNegativeNumber(usage.inputTokens);
-  const completionTokens = nonNegativeNumber(usage.outputTokens);
+  const promptTokens = nonNegativeNumber(usage?.inputTokens);
+  const completionTokens = nonNegativeNumber(usage?.outputTokens);
   const cachedTokens = nonNegativeNumber(
-    usage.inputTokenDetails?.cacheReadTokens
+    usage?.inputTokenDetails?.cacheReadTokens
   );
   const cacheCreationTokens = nonNegativeNumber(
-    usage.inputTokenDetails?.cacheWriteTokens
+    usage?.inputTokenDetails?.cacheWriteTokens
   );
   return {
     ...promptTokens !== void 0 ? { prompt_tokens: promptTokens } : {},
@@ -37928,10 +40144,76 @@ function turnIdempotencyKey(sessionId, turnId) {
 function actionIdempotencyKey(sessionId, turnId, callId) {
   return `action:${sessionId}:${turnId}:${callId}`;
 }
+function providerHandler(type, handler) {
+  return async (event, context) => {
+    try {
+      if (!isEveProviderEvent(event, type) || !isEveProviderContext(context)) {
+        debugLogger.warn(`Ignoring malformed Eve provider ${type} event`);
+        return;
+      }
+      await handler(event, context);
+    } catch (error) {
+      debugLogger.warn(`Error in Eve provider ${type}:`, error);
+    }
+  };
+}
+function isEveProviderEvent(event, type) {
+  if (!isObject(event) || event["type"] !== type || typeof event["idempotencyKey"] !== "string" || event["idempotencyKey"].length === 0) {
+    return false;
+  }
+  if (type === "turn.started") {
+    const parentLineage = event["parentLineage"];
+    return typeof event["rootSessionId"] === "string" && typeof event["sessionId"] === "string" && typeof event["turnId"] === "string" && typeof event["sequence"] === "number" && Number.isFinite(event["sequence"]) && (parentLineage === void 0 || isEveProviderParentLineage(parentLineage));
+  }
+  if (type === "turn.cancelled" || type === "turn.completed" || type === "turn.failed") {
+    return typeof event["sessionId"] === "string" && typeof event["turnId"] === "string";
+  }
+  if (!isEveProviderScope(event["scope"])) {
+    return false;
+  }
+  if (type === "model.call.started") {
+    const model = event["model"];
+    return isObject(model) && typeof model["modelId"] === "string" && typeof model["provider"] === "string";
+  }
+  if (type === "model.call.completed") {
+    return typeof event["finishReason"] === "string" && isObject(event["usage"]) && (event["content"] === void 0 || Array.isArray(event["content"]));
+  }
+  if (type === "model.call.failed") {
+    return true;
+  }
+  if (type === "action.started") {
+    return typeof event["callId"] === "string" && typeof event["name"] === "string" && (event["kind"] === "load-skill" || event["kind"] === "remote-agent-call" || event["kind"] === "subagent-call" || event["kind"] === "tool-call");
+  }
+  if (type === "action.completed") {
+    const output = event["output"];
+    return event["outcome"] === "completed" && isObject(output) && (output["type"] === "result" || output["type"] === "error");
+  }
+  if (type === "action.failed") {
+    return event["outcome"] === "abandoned" || event["outcome"] === "cancelled" || event["outcome"] === "failed" || event["outcome"] === "rejected";
+  }
+  return type === "step.attempt.completed" || type === "step.attempt.failed";
+}
+function isEveProviderContext(value) {
+  if (!isObject(value) || !isObject(value["state"])) {
+    return false;
+  }
+  return typeof value["state"]["get"] === "function" && typeof value["state"]["set"] === "function";
+}
+function isEveProviderScope(value) {
+  return isObject(value) && typeof value["attemptId"] === "string" && typeof value["attemptIndex"] === "number" && Number.isFinite(value["attemptIndex"]) && typeof value["sessionId"] === "string" && typeof value["stepIndex"] === "number" && Number.isFinite(value["stepIndex"]) && typeof value["turnId"] === "string" && (value["rootSessionId"] === void 0 || typeof value["rootSessionId"] === "string");
+}
+function isEveProviderParentLineage(value) {
+  return isObject(value) && typeof value["callId"] === "string" && typeof value["sessionId"] === "string" && typeof value["turnId"] === "string";
+}
 
 // src/instrumentation/plugins/eve-instrumentation.ts
 var EVE_INSTRUMENTATION_PROVIDER = /* @__PURE__ */ Symbol.for("eve.instrumentation.provider");
 function braintrustEveInstrumentation(options) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError(
+      "braintrustEveInstrumentation requires an options object"
+    );
+  }
   const definition = "defineState" in options ? createLegacyEveInstrumentation(options) : createEveInstrumentationProvider(options);
   const declaration = {
     ...definition,
@@ -37982,6 +40264,8 @@ var envIntegrationAliases = {
   "openai-agents-core": "openAIAgents",
   openaiagentscore: "openAIAgents",
   google: "google",
+  "google-generative-ai": "googleGenerativeAI",
+  googlegenerativeai: "googleGenerativeAI",
   "google-genai": "googleGenAI",
   googlegenai: "googleGenAI",
   huggingface: "huggingface",
@@ -38012,10 +40296,15 @@ var envIntegrationAliases = {
   "langchain-js": "langchain",
   "@langchain": "langchain",
   langgraph: "langgraph",
+  langgraphsdk: "langgraphSDK",
+  "langgraph-sdk": "langgraphSDK",
+  "@langchain/langgraph-sdk": "langgraphSDK",
   langsmith: "langsmith",
   voyage: "voyageai",
   "voyage-ai": "voyageai",
-  voyageai: "voyageai"
+  voyageai: "voyageai",
+  elevenlabs: "elevenlabs",
+  "@elevenlabs/elevenlabs-js": "elevenlabs"
 };
 function getDefaultInstrumentationIntegrations() {
   return {
@@ -38026,6 +40315,7 @@ function getDefaultInstrumentationIntegrations() {
     aisdk: true,
     google: true,
     googleGenAI: true,
+    googleGenerativeAI: true,
     googleADK: true,
     huggingface: true,
     claudeAgentSDK: true,
@@ -38049,8 +40339,10 @@ function getDefaultInstrumentationIntegrations() {
     gitHubCopilot: true,
     langchain: true,
     langgraph: true,
+    langgraphSDK: true,
     langsmith: true,
     voyageai: true,
+    elevenlabs: true,
     piCodingAgent: true,
     strandsAgentSDK: true,
     cloudflareAgents: true