braintrust 3.32.0 → 3.33.0

package/dist/instrumentation/index.js

@@ -5814,6 +5814,7 @@ var INSTRUMENTATION_NAMES = {
   LANGSMITH: "langsmith",
   MASTRA: "mastra",
   MISTRAL: "mistral",
+  LANGGRAPH_SDK: "langgraph-sdk",
   OLLAMA: "ollama",
   OPENAI: "openai",
   OPENAI_AGENTS: "openai-agents",
@@ -5828,7 +5829,7 @@ var INSTRUMENTATION_NAMES = {
 var INTERNAL_SPAN_INSTRUMENTATION_NAME = /* @__PURE__ */ Symbol.for(
   "braintrust.spanInstrumentationName"
 );
-var SDK_VERSION = true ? "3.32.0" : "0.0.0";
+var SDK_VERSION = true ? "3.33.0" : "0.0.0";
 function withSpanInstrumentationName(args, instrumentationName) {
   return {
     ...args,
@@ -8547,6 +8548,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 });
@@ -9853,10 +9886,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) {
@@ -11939,6 +11978,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"
@@ -12307,6 +12358,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([
@@ -12347,21 +12415,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),
@@ -12852,6 +12905,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() {
@@ -12859,6 +13534,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
       ),
@@ -13419,7 +14101,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;
     }
@@ -13919,10 +14601,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);
 }
 
@@ -15304,27 +15986,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) {
@@ -16081,16 +16744,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 } : {}
@@ -18549,9 +19212,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:",
@@ -18559,7 +19222,7 @@ function patchAISDKStreamingResult(args) {
         );
       }
       finalize({
-        error: error instanceof Error ? error : new Error(String(loggedError))
+        error: error instanceof Error ? error : new Error(String(loggedError2))
       });
     }
   };
@@ -18672,9 +19335,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:",
@@ -18682,7 +19345,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);
         }
@@ -21576,7 +22239,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);
@@ -21586,7 +22249,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);
@@ -21668,7 +22331,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;
     }
@@ -21732,7 +22395,7 @@ async function handleToolUpdate(state, update) {
     if (!state.activeToolSpans.has(callId)) {
       state.activeToolSpans.set(
         callId,
-        await startToolSpan(state, {
+        await startToolSpan2(state, {
           args,
           callId,
           name,
@@ -21743,7 +22406,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,
@@ -21780,7 +22443,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,
@@ -21815,7 +22478,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,
@@ -21826,7 +22489,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,
@@ -21853,7 +22516,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",
@@ -21877,7 +22540,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),
@@ -21908,7 +22571,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,
@@ -22195,10 +22858,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) {
@@ -23036,6 +23699,10 @@ var googleGenAIChannels = defineChannels(
       channelName: "models.embedContent",
       kind: "async"
     }),
+    httpResponseJson: channel({
+      channelName: "httpResponse.json",
+      kind: "async"
+    }),
     interactionsCreate: channel({
       channelName: "interactions.create",
       kind: "async"
@@ -23184,13 +23851,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(
             {
@@ -23203,6 +23902,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
             INSTRUMENTATION_NAMES.GOOGLE_GENAI
           )
         );
+        embeddingSpans.add(span);
         return {
           span,
           startTime: getCurrentUnixTimestamp()
@@ -23214,7 +23914,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(
               {
@@ -23227,6 +23927,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
               INSTRUMENTATION_NAMES.GOOGLE_GENAI
             )
           );
+          embeddingSpans.add(span);
           return {
             span,
             startTime: getCurrentUnixTimestamp()
@@ -23239,20 +23940,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);
@@ -23487,15 +24196,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 = {
@@ -23683,19 +24430,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) {
@@ -23715,15 +24449,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;
 }
@@ -23762,41 +24504,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) {
@@ -27423,6 +28149,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",
@@ -27632,7 +28731,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;
   }
@@ -27678,7 +28777,7 @@ function normalizeMessages(messages) {
         toolCallId = pendingToolCallIds.get(toolName)?.shift();
       }
     }
-    const normalized = normalizeMessage(
+    const normalized = normalizeMessage2(
       ollamaMessage,
       toolCallId,
       syntheticToolCallIdOffset
@@ -27797,7 +28896,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
@@ -30517,14 +31616,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
   };
 }
@@ -30634,7 +31733,7 @@ function pickNumberMetrics(values) {
     })
   );
 }
-function stringValue(value) {
+function stringValue2(value) {
   return typeof value === "string" ? value : void 0;
 }
 
@@ -31319,7 +32418,7 @@ function subscribeToFlueContext(value, state) {
     try {
       unsubscribe?.();
     } catch (error) {
-      logInstrumentationError3("Flue context unsubscribe", error);
+      logInstrumentationError4("Flue context unsubscribe", error);
     }
   };
   try {
@@ -31335,7 +32434,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) {
@@ -31391,7 +32490,7 @@ var FlueObserveBridge = class {
     try {
       this.handleEvent(event, flueContextFromUnknown(ctx));
     } catch (error) {
-      logInstrumentationError3("Flue observe", error);
+      logInstrumentationError4("Flue observe", error);
     }
   }
   reset() {
@@ -31408,7 +32507,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();
   }
@@ -31614,7 +32713,7 @@ var FlueObserveBridge = class {
       this.runsById.delete(event.runId);
     }
     void flush().catch((error) => {
-      logInstrumentationError3("Flue flush", error);
+      logInstrumentationError4("Flue flush", error);
     });
   }
   handleOperationStart(event) {
@@ -32389,17 +33488,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);
 }
 
@@ -32967,10 +34066,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;
         }
@@ -32989,13 +34088,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;
     }
@@ -33028,7 +34127,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;
     }
@@ -33051,13 +34150,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] : [],
@@ -33149,7 +34248,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) {
@@ -33167,7 +34266,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) {
@@ -33372,7 +34471,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);
@@ -33505,12 +34604,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) {
@@ -33560,7 +34659,7 @@ function wrapPiToolExecutors(tools) {
       });
       tool.execute = wrappedExecute;
     } catch (error) {
-      logInstrumentationError4("Pi Coding Agent tool wrapping", error);
+      logInstrumentationError5("Pi Coding Agent tool wrapping", error);
     }
   }
 }
@@ -33639,7 +34738,7 @@ function patchAssistantMessageStream(stream, promptState, llmState) {
               try {
                 await iterator.return();
               } catch (cleanupError) {
-                logInstrumentationError4(
+                logInstrumentationError5(
                   "Pi Coding Agent stream cleanup",
                   cleanupError
                 );
@@ -33804,7 +34903,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);
     }
   }
 }
@@ -34136,10 +35235,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);
 }
 
@@ -34377,7 +35476,7 @@ function handleAgentStreamEvent(state, event) {
         finalizeModelSpan(state, event);
         break;
       case "beforeToolCallEvent":
-        startToolSpan2(state, event);
+        startToolSpan3(state, event);
         break;
       case "afterToolCallEvent":
         finalizeToolSpan(state, event);
@@ -34402,7 +35501,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) {
@@ -34438,7 +35537,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) {
@@ -34517,7 +35616,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)) {
@@ -34797,7 +35896,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;
   }
 }
@@ -34880,7 +35979,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;
   }
 }
@@ -35100,10 +36199,10 @@ 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);
 }
 
@@ -35506,10 +36605,10 @@ function observeAudioStream(value, observe, complete, cancel, span) {
     const getReader = value.getReader;
     value.getReader = function(...args) {
       const reader = Reflect.apply(getReader, this, args);
-      const read2 = reader.read;
+      const read3 = reader.read;
       reader.read = function(...readArgs) {
         return Promise.resolve(
-          withCurrent(span, () => Reflect.apply(read2, this, readArgs))
+          withCurrent(span, () => Reflect.apply(read3, this, readArgs))
         ).then(
           (result) => {
             if (result.value) safeObserve(result.value);
@@ -36003,14 +37102,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
@@ -36057,7 +37156,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);
@@ -36226,7 +37325,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) {
@@ -36344,7 +37443,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
           );
           spans.set(event, span);
         } catch (error) {
-          logInstrumentationError6("start", error);
+          logInstrumentationError7("start", error);
         }
       },
       asyncEnd: (event) => {
@@ -36364,7 +37463,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
             }
           }
         } catch (error) {
-          logInstrumentationError6("completion", error);
+          logInstrumentationError7("completion", error);
         } finally {
           safelyEndSpan(span);
         }
@@ -36378,7 +37477,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
         try {
           span.log({ error: event.error });
         } catch (error) {
-          logInstrumentationError6("rejection", error);
+          logInstrumentationError7("rejection", error);
         } finally {
           safelyEndSpan(span);
         }
@@ -36408,10 +37507,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
@@ -36436,6 +37535,7 @@ var BraintrustPlugin = class extends BasePlugin {
   openRouterPlugin = null;
   openRouterAgentPlugin = null;
   mistralPlugin = null;
+  langGraphSDKPlugin = null;
   ollamaPlugin = null;
   googleADKPlugin = null;
   coherePlugin = null;
@@ -36516,6 +37616,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();
@@ -36644,6 +37748,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;
@@ -36718,7 +37826,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 {
@@ -36730,15 +37862,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,
@@ -36747,7 +37891,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) {
@@ -36916,7 +38130,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 () => {
@@ -37242,9 +38466,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,
@@ -38113,17 +39342,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;
@@ -38134,116 +39379,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) {
@@ -38379,18 +39710,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
@@ -38746,17 +40113,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"
       });
     }
@@ -38775,13 +40145,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 } : {},
@@ -38818,10 +40188,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,
@@ -38904,6 +40340,9 @@ 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",
@@ -38944,6 +40383,7 @@ function getDefaultInstrumentationIntegrations() {
     gitHubCopilot: true,
     langchain: true,
     langgraph: true,
+    langgraphSDK: true,
     langsmith: true,
     voyageai: true,
     elevenlabs: true,