braintrust 3.32.0 → 3.33.0

package/dist/edge-light.mjs

@@ -5671,6 +5671,7 @@ var INSTRUMENTATION_NAMES = {
   LANGSMITH: "langsmith",
   MASTRA: "mastra",
   MISTRAL: "mistral",
+  LANGGRAPH_SDK: "langgraph-sdk",
   OLLAMA: "ollama",
   OPENAI: "openai",
   OPENAI_AGENTS: "openai-agents",
@@ -5685,7 +5686,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,
@@ -9476,6 +9477,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 });
@@ -11087,10 +11120,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) {
@@ -13529,6 +13568,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"
@@ -13897,6 +13948,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([
@@ -13937,21 +14005,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),
@@ -14442,6 +14495,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, fallback2) {
+  if (value instanceof Error) {
+    return value;
+  }
+  const message = stringValue(read2(value, "message"));
+  return new Error(message ?? (typeof value === "string" ? value : fallback2));
+}
+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 fallback2 = 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 fallback2;
+  }
+};
+var interceptOpenAIAgentsTraceCapture = async (target, thisArg, args) => {
+  const fallback2 = await Reflect.apply(target, thisArg, args);
+  if (!args[0].state) {
+    return fallback2;
+  }
+  try {
+    return await captureEvent(args[0].state, args[0].event);
+  } catch (error) {
+    logInstrumentationError("could not capture event", error);
+    return fallback2;
+  }
+};
+var interceptOpenAIAgentsTraceFail = async (target, thisArg, args) => {
+  const fallback2 = await Reflect.apply(target, thisArg, args);
+  if (!args[0].state) {
+    return fallback2;
+  }
+  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 fallback2;
+  }
+};
+
 // src/instrumentation/plugins/openai-plugin.ts
 var OpenAIPlugin = class extends BasePlugin {
   constructor() {
@@ -14449,6 +15124,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
       ),
@@ -15009,7 +15691,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;
     }
@@ -15509,10 +16191,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);
 }
 
@@ -16907,27 +17589,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) {
@@ -17684,16 +18347,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 } : {}
@@ -20152,9 +20815,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:",
@@ -20162,7 +20825,7 @@ function patchAISDKStreamingResult(args) {
         );
       }
       finalize({
-        error: error instanceof Error ? error : new Error(String(loggedError))
+        error: error instanceof Error ? error : new Error(String(loggedError2))
       });
     }
   };
@@ -20275,9 +20938,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:",
@@ -20285,7 +20948,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);
         }
@@ -23179,7 +23842,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);
@@ -23189,7 +23852,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);
@@ -23271,7 +23934,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;
     }
@@ -23335,7 +23998,7 @@ async function handleToolUpdate(state, update) {
     if (!state.activeToolSpans.has(callId)) {
       state.activeToolSpans.set(
         callId,
-        await startToolSpan(state, {
+        await startToolSpan2(state, {
           args,
           callId,
           name,
@@ -23346,7 +24009,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,
@@ -23383,7 +24046,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,
@@ -23418,7 +24081,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,
@@ -23429,7 +24092,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,
@@ -23456,7 +24119,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",
@@ -23480,7 +24143,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),
@@ -23511,7 +24174,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,
@@ -23798,10 +24461,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) {
@@ -24639,6 +25302,10 @@ var googleGenAIChannels = defineChannels(
       channelName: "models.embedContent",
       kind: "async"
     }),
+    httpResponseJson: channel({
+      channelName: "httpResponse.json",
+      kind: "async"
+    }),
     interactionsCreate: channel({
       channelName: "interactions.create",
       kind: "async"
@@ -24787,13 +25454,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(
             {
@@ -24806,6 +25505,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
             INSTRUMENTATION_NAMES.GOOGLE_GENAI
           )
         );
+        embeddingSpans.add(span);
         return {
           span,
           startTime: getCurrentUnixTimestamp()
@@ -24817,7 +25517,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(
               {
@@ -24830,6 +25530,7 @@ var GoogleGenAIPlugin = class extends BasePlugin {
               INSTRUMENTATION_NAMES.GOOGLE_GENAI
             )
           );
+          embeddingSpans.add(span);
           return {
             span,
             startTime: getCurrentUnixTimestamp()
@@ -24842,20 +25543,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);
@@ -25090,15 +25799,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 = {
@@ -25286,19 +26033,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) {
@@ -25318,15 +26052,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;
 }
@@ -25365,41 +26107,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) {
@@ -29026,6 +29752,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 toolCalls2 = Array.isArray(value.tool_calls) && value.tool_calls.length ? value.tool_calls : additional.tool_calls;
+  if (Array.isArray(toolCalls2) && toolCalls2.length > 0) {
+    message.tool_calls = toolCalls2.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], invoke2) {
+  if (isAutoInstrumentationSuppressed()) return invoke2();
+  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 invoke2();
+  }
+  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(invoke2)
+    );
+  } 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",
@@ -29235,7 +30334,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;
   }
@@ -29281,7 +30380,7 @@ function normalizeMessages(messages) {
         toolCallId = pendingToolCallIds.get(toolName)?.shift();
       }
     }
-    const normalized = normalizeMessage(
+    const normalized = normalizeMessage2(
       ollamaMessage,
       toolCallId,
       syntheticToolCallIdOffset
@@ -29400,7 +30499,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
@@ -32120,14 +33219,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
   };
 }
@@ -32237,7 +33336,7 @@ function pickNumberMetrics(values) {
     })
   );
 }
-function stringValue(value) {
+function stringValue2(value) {
   return typeof value === "string" ? value : void 0;
 }
 
@@ -32922,7 +34021,7 @@ function subscribeToFlueContext(value, state) {
     try {
       unsubscribe?.();
     } catch (error) {
-      logInstrumentationError3("Flue context unsubscribe", error);
+      logInstrumentationError4("Flue context unsubscribe", error);
     }
   };
   try {
@@ -32938,7 +34037,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) {
@@ -32994,7 +34093,7 @@ var FlueObserveBridge = class {
     try {
       this.handleEvent(event, flueContextFromUnknown(ctx));
     } catch (error) {
-      logInstrumentationError3("Flue observe", error);
+      logInstrumentationError4("Flue observe", error);
     }
   }
   reset() {
@@ -33011,7 +34110,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();
   }
@@ -33217,7 +34316,7 @@ var FlueObserveBridge = class {
       this.runsById.delete(event.runId);
     }
     void flush().catch((error) => {
-      logInstrumentationError3("Flue flush", error);
+      logInstrumentationError4("Flue flush", error);
     });
   }
   handleOperationStart(event) {
@@ -33992,17 +35091,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);
 }
 
@@ -34570,10 +35669,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;
         }
@@ -34592,13 +35691,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;
     }
@@ -34631,7 +35730,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;
     }
@@ -34654,13 +35753,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] : [],
@@ -34752,7 +35851,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) {
@@ -34770,7 +35869,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) {
@@ -34975,7 +36074,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);
@@ -35108,12 +36207,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) {
@@ -35163,7 +36262,7 @@ function wrapPiToolExecutors(tools) {
       });
       tool.execute = wrappedExecute;
     } catch (error) {
-      logInstrumentationError4("Pi Coding Agent tool wrapping", error);
+      logInstrumentationError5("Pi Coding Agent tool wrapping", error);
     }
   }
 }
@@ -35242,7 +36341,7 @@ function patchAssistantMessageStream(stream, promptState, llmState) {
               try {
                 await iterator.return();
               } catch (cleanupError) {
-                logInstrumentationError4(
+                logInstrumentationError5(
                   "Pi Coding Agent stream cleanup",
                   cleanupError
                 );
@@ -35407,7 +36506,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);
     }
   }
 }
@@ -35739,10 +36838,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);
 }
 
@@ -35980,7 +37079,7 @@ function handleAgentStreamEvent(state, event) {
         finalizeModelSpan(state, event);
         break;
       case "beforeToolCallEvent":
-        startToolSpan2(state, event);
+        startToolSpan3(state, event);
         break;
       case "afterToolCallEvent":
         finalizeToolSpan(state, event);
@@ -36005,7 +37104,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) {
@@ -36041,7 +37140,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) {
@@ -36120,7 +37219,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)) {
@@ -36400,7 +37499,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;
   }
 }
@@ -36483,7 +37582,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;
   }
 }
@@ -36703,10 +37802,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);
 }
 
@@ -37109,10 +38208,10 @@ function observeAudioStream(value, observe, complete, cancel, span) {
     const getReader = value.getReader;
     value.getReader = function(...args) {
       const reader = Reflect.apply(getReader, this, args);
-      const read3 = reader.read;
+      const read4 = reader.read;
       reader.read = function(...readArgs) {
         return Promise.resolve(
-          withCurrent(span, () => Reflect.apply(read3, this, readArgs))
+          withCurrent(span, () => Reflect.apply(read4, this, readArgs))
         ).then(
           (result) => {
             if (result.value) safeObserve(result.value);
@@ -37629,14 +38728,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
@@ -37683,7 +38782,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);
@@ -37852,7 +38951,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) {
@@ -37970,7 +39069,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
           );
           spans.set(event, span);
         } catch (error) {
-          logInstrumentationError6("start", error);
+          logInstrumentationError7("start", error);
         }
       },
       asyncEnd: (event) => {
@@ -37990,7 +39089,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
             }
           }
         } catch (error) {
-          logInstrumentationError6("completion", error);
+          logInstrumentationError7("completion", error);
         } finally {
           safelyEndSpan(span);
         }
@@ -38004,7 +39103,7 @@ var CloudflareAgentsPlugin = class extends BasePlugin {
         try {
           span.log({ error: event.error });
         } catch (error) {
-          logInstrumentationError6("rejection", error);
+          logInstrumentationError7("rejection", error);
         } finally {
           safelyEndSpan(span);
         }
@@ -38034,10 +39133,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
@@ -38062,6 +39161,7 @@ var BraintrustPlugin = class extends BasePlugin {
   openRouterPlugin = null;
   openRouterAgentPlugin = null;
   mistralPlugin = null;
+  langGraphSDKPlugin = null;
   ollamaPlugin = null;
   googleADKPlugin = null;
   coherePlugin = null;
@@ -38142,6 +39242,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();
@@ -38270,6 +39374,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;
@@ -38411,6 +39519,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",
@@ -38451,6 +39562,7 @@ function getDefaultInstrumentationIntegrations() {
     gitHubCopilot: true,
     langchain: true,
     langgraph: true,
+    langgraphSDK: true,
     langsmith: true,
     voyageai: true,
     elevenlabs: true,
@@ -38617,8 +39729,6 @@ __export(exports_exports, {
   BRAINTRUST_PARENT_KEY: () => BRAINTRUST_PARENT_KEY,
   BaseAttachment: () => BaseAttachment,
   BaseExperiment: () => BaseExperiment,
-  BatchScorer: () => BatchScorer,
-  BatchTask: () => BatchTask,
   BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
   BraintrustMiddleware: () => BraintrustMiddleware,
   BraintrustObservabilityExporter: () => BraintrustObservabilityExporter,
@@ -38632,8 +39742,6 @@ __export(exports_exports, {
   DEFAULT_MAX_REQUEST_SIZE: () => DEFAULT_MAX_REQUEST_SIZE,
   Dataset: () => Dataset2,
   DatasetPipeline: () => DatasetPipeline,
-  DurableEvalMemoryStore: () => DurableEvalMemoryStore,
-  DurableEvalRedisStore: () => DurableEvalRedisStore,
   ERR_PERMALINK: () => ERR_PERMALINK,
   Eval: () => Eval,
   EvalResultWithSummary: () => EvalResultWithSummary,
@@ -38668,6 +39776,10 @@ __export(exports_exports, {
   TestBackgroundLogger: () => TestBackgroundLogger,
   ToolBuilder: () => ToolBuilder,
   UUIDGenerator: () => UUIDGenerator,
+  WorkflowEvalMemoryStore: () => WorkflowEvalMemoryStore,
+  WorkflowEvalRedisStore: () => WorkflowEvalRedisStore,
+  WorkflowScorer: () => WorkflowScorer,
+  WorkflowTask: () => WorkflowTask,
   X_CACHED_HEADER: () => X_CACHED_HEADER,
   _exportsForTestingOnly: () => _exportsForTestingOnly,
   _internalGetGlobalState: () => _internalGetGlobalState,
@@ -38692,12 +39804,13 @@ __export(exports_exports, {
   currentSpan: () => currentSpan,
   deepCopyEvent: () => deepCopyEvent,
   defaultErrorScoreHandler: () => defaultErrorScoreHandler,
-  defineDurableEval: () => defineDurableEval,
+  defineWorkflowEval: () => defineWorkflowEval,
   deserializePlainStringAsJSON: () => deserializePlainStringAsJSON,
   devNullWritableStream: () => devNullWritableStream,
   evaluatorDefinitionSchema: () => evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema: () => evaluatorDefinitionsSchema,
   extractTraceContextFromHeaders: () => extractTraceContextFromHeaders,
+  failOpenAIAgentsTrace: () => failOpenAIAgentsTrace,
   flush: () => flush,
   getContextManager: () => getContextManager,
   getIdGenerator: () => getIdGenerator,
@@ -38744,12 +39857,14 @@ __export(exports_exports, {
   setFetch: () => setFetch,
   setMaskingFunction: () => setMaskingFunction,
   spanComponentsToObjectId: () => spanComponentsToObjectId,
+  startOpenAIAgentsTrace: () => startOpenAIAgentsTrace,
   startSpan: () => startSpan,
   summarize: () => summarize,
   templateRegistry: () => templateRegistry,
   toolFunctionDefinitionSchema: () => ToolFunctionDefinition,
   traceable: () => traceable,
   traced: () => traced,
+  updateOpenAIAgentsTrace: () => updateOpenAIAgentsTrace,
   updateSpan: () => updateSpan,
   uploadLogs3OverflowPayload: () => uploadLogs3OverflowPayload,
   utf8ByteLength: () => utf8ByteLength2,
@@ -38778,6 +39893,7 @@ __export(exports_exports, {
   wrapGroq: () => wrapGroq,
   wrapHuggingFace: () => wrapHuggingFace,
   wrapHuggingFaceTransformers: () => wrapHuggingFaceTransformers,
+  wrapLangGraphSDK: () => wrapLangGraphSDK,
   wrapLangSmithClient: () => wrapLangSmithClient,
   wrapLangSmithRunTrees: () => wrapLangSmithRunTrees,
   wrapLangSmithTraceable: () => wrapLangSmithTraceable,
@@ -38977,7 +40093,7 @@ function createLazyAPIPromise(ensureExecuted, ensureResponse, getAPIPromise) {
 }
 
 // src/openai-batch.ts
-function read2(value, key) {
+function read3(value, key) {
   if (value === null || typeof value !== "object" && typeof value !== "function") {
     return void 0;
   }
@@ -38988,7 +40104,7 @@ function read2(value, key) {
   }
 }
 function isAsyncIterable5(value) {
-  return typeof read2(value, Symbol.asyncIterator) === "function";
+  return typeof read3(value, Symbol.asyncIterator) === "function";
 }
 function teeAsyncIterable(source) {
   const iterator = source[Symbol.asyncIterator]();
@@ -39031,7 +40147,7 @@ function teeAsyncIterable(source) {
       }
     }
   };
-  const path = read2(source, "path");
+  const path = read3(source, "path");
   if (typeof path === "string") {
     Object.defineProperty(upload, "path", { value: path });
   }
@@ -39052,8 +40168,8 @@ function teeUpload(upload) {
 function openaiFilesCreateTraced(files) {
   return (params, options) => {
     const parent = getSpanParentObject();
-    const purpose = read2(params, "purpose");
-    const file = read2(params, "file");
+    const purpose = read3(params, "purpose");
+    const file = read3(params, "file");
     if (purpose !== "batch") {
       return files.create(params, options);
     }
@@ -39144,6 +40260,143 @@ async function completeOpenAIBatchTrace(args) {
   );
 }
 
+// src/openai-agents-api.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateStartArgs(value) {
+  if (!isRecord3(value)) {
+    throw new TypeError(
+      "startOpenAIAgentsTrace expected an OpenAI Agents parameters object"
+    );
+  }
+  const agent = value.agent;
+  if (agent !== void 0 && agent !== null && !isRecord3(agent)) {
+    throw new TypeError(
+      "startOpenAIAgentsTrace expected agent to be an object or null"
+    );
+  }
+  if (isRecord3(agent) && (agent.id !== void 0 && typeof agent.id !== "string" || agent.model !== void 0 && typeof agent.model !== "string" || agent.name !== void 0 && agent.name !== null && typeof agent.name !== "string")) {
+    throw new TypeError(
+      "startOpenAIAgentsTrace received invalid agent identity fields"
+    );
+  }
+  if (value.agent_id !== void 0 && typeof value.agent_id !== "string") {
+    throw new TypeError(
+      "startOpenAIAgentsTrace expected agent_id to be a string"
+    );
+  }
+  if (value.metadata !== void 0 && value.metadata !== null && !isRecord3(value.metadata)) {
+    throw new TypeError(
+      "startOpenAIAgentsTrace expected metadata to be an object or null"
+    );
+  }
+  return value;
+}
+function validateEvent(event) {
+  if (!isRecord3(event) || typeof event.type !== "string" || event.type.length === 0) {
+    throw new TypeError(
+      "updateOpenAIAgentsTrace expected an OpenAI Agents event object"
+    );
+  }
+  return event;
+}
+function createTraceState() {
+  const parent = _internalExportParentSynchronously(getSpanParentObject());
+  if (!parent) {
+    return null;
+  }
+  const parentComponents = SpanComponentsV4.fromStr(parent);
+  const rowId = newId();
+  const useLegacyIds = resolveUseLegacyUuidIds();
+  const spanId = useLegacyIds ? newId() : newId().replaceAll("-", "").slice(0, 16);
+  const rootSpanId = useLegacyIds ? spanId : newId().replaceAll("-", "");
+  const root = new SpanComponentsV4({
+    object_type: parentComponents.data.object_type,
+    ...parentComponents.data.object_id ? { object_id: parentComponents.data.object_id } : {
+      compute_object_metadata_args: parentComponents.data.compute_object_metadata_args ?? {}
+    },
+    propagated_event: parentComponents.data.propagated_event,
+    root_span_id: rootSpanId,
+    row_id: rowId,
+    span_id: spanId
+  }).toStr();
+  return {
+    callItems: {},
+    ended: false,
+    eventIds: [],
+    openTools: {},
+    root,
+    rootKey: spanId,
+    rootParent: parent,
+    startTime: getCurrentUnixTimestamp(),
+    subagents: {},
+    turnSubagents: {},
+    version: 1
+  };
+}
+function startOpenAIAgentsTrace(args) {
+  const validatedArgs = validateStartArgs(args);
+  const state = createTraceState();
+  if (!state) {
+    return null;
+  }
+  try {
+    void openAIChannels.agentsTraceStart.invoke(
+      async () => state,
+      void 0,
+      [{ args: validatedArgs, state }],
+      {}
+    ).catch((error) => {
+      debugLogger.debug(
+        "OpenAI Agents API instrumentation could not start:",
+        error
+      );
+    });
+  } catch (error) {
+    debugLogger.debug(
+      "OpenAI Agents API instrumentation could not start:",
+      error
+    );
+  }
+  return state;
+}
+async function updateOpenAIAgentsTrace(token, event) {
+  const state = token;
+  const validatedEvent = validateEvent(event);
+  try {
+    return await openAIChannels.agentsTraceCapture.invoke(
+      async () => state,
+      void 0,
+      [{ state, event: validatedEvent }],
+      {}
+    );
+  } catch (error) {
+    debugLogger.debug(
+      "OpenAI Agents API instrumentation could not update:",
+      error
+    );
+    return token;
+  }
+}
+async function failOpenAIAgentsTrace(token, error) {
+  const state = token;
+  try {
+    return await openAIChannels.agentsTraceFail.invoke(
+      async () => state,
+      void 0,
+      [{ state, error }],
+      {}
+    );
+  } catch (instrumentationError) {
+    debugLogger.debug(
+      "OpenAI Agents API instrumentation could not record failure:",
+      instrumentationError
+    );
+    return token;
+  }
+}
+
 // src/functions/invoke.ts
 async function invoke(args) {
   const {
@@ -40593,7 +41846,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 {
@@ -40605,15 +41882,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,
@@ -40622,7 +41911,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) {
@@ -40791,7 +42150,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 () => {
@@ -41117,9 +42486,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,
@@ -41988,17 +43362,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;
@@ -42009,116 +43399,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) {
@@ -42254,18 +43730,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
@@ -42621,17 +44133,20 @@ function modelOutput(event) {
   const reasoning = [];
   const toolCalls2 = [];
   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") {
       toolCalls2.push({
         function: {
-          arguments: safeJsonStringify(part.input),
-          name: part.toolName
+          arguments: safeJsonStringify(part["input"]),
+          name: part["toolName"]
         },
-        id: part.callId,
+        id: part["callId"],
         type: "function"
       });
     }
@@ -42650,13 +44165,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 } : {},
@@ -42693,10 +44208,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,
@@ -43933,6 +45514,7 @@ function wrapClient(client) {
 }
 
 // src/wrappers/google-genai.ts
+var patchedHttpResponses = /* @__PURE__ */ new WeakSet();
 function wrapGoogleGenAI(googleGenAI) {
   if (!googleGenAI || typeof googleGenAI !== "object") {
     console.warn("Invalid Google GenAI module. Not wrapping.");
@@ -43944,6 +45526,21 @@ function wrapGoogleGenAI(googleGenAI) {
     );
     return googleGenAI;
   }
+  const httpResponse = googleGenAI.HttpResponse;
+  if (typeof httpResponse === "function" && isObject(httpResponse.prototype) && typeof httpResponse.prototype.json === "function" && !patchedHttpResponses.has(httpResponse.prototype)) {
+    const prototype = httpResponse.prototype;
+    const originalJson = prototype.json;
+    if (Reflect.set(prototype, "json", function() {
+      return googleGenAIChannels.httpResponseJson.invoke(
+        originalJson,
+        this,
+        [],
+        {}
+      );
+    })) {
+      patchedHttpResponses.add(prototype);
+    }
+  }
   return new Proxy(googleGenAI, {
     get(target, prop, receiver) {
       if (prop === "GoogleGenAI") {
@@ -44194,17 +45791,17 @@ function wrapGenkit(genkit) {
   console.warn("Unsupported Genkit object. Not wrapping.");
   return genkit;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function isPropertyBag(value) {
-  return isRecord3(value) || typeof value === "function";
+  return isRecord4(value) || typeof value === "function";
 }
 function hasFunction(value, methodName) {
   return isPropertyBag(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isGenkitInstance(value) {
-  return isRecord3(value) && (hasFunction(value, "generate") || hasFunction(value, "generateStream") || hasFunction(value, "defineFlow") || hasFunction(value, "defineTool"));
+  return isRecord4(value) && (hasFunction(value, "generate") || hasFunction(value, "generateStream") || hasFunction(value, "defineFlow") || hasFunction(value, "defineTool"));
 }
 function isGenkitModule(value) {
   return hasFunction(value, "genkit");
@@ -44258,7 +45855,7 @@ function patchGenkitRegistry(instance) {
   patchGenkitRegistryConstructor(registry2);
 }
 function patchGenkitRegistryLookup(registry2) {
-  if (!isRecord3(registry2) || hasRegistryPatchedFlag(registry2) || !hasFunction(registry2, "lookupAction")) {
+  if (!isRecord4(registry2) || hasRegistryPatchedFlag(registry2) || !hasFunction(registry2, "lookupAction")) {
     return;
   }
   const originalLookupAction = registry2.lookupAction;
@@ -44284,7 +45881,7 @@ function patchGenkitRegistryLookup(registry2) {
   }
 }
 function patchGenkitRegistryConstructor(registry2) {
-  if (!isRecord3(registry2)) {
+  if (!isRecord4(registry2)) {
     return;
   }
   const constructor = registry2.constructor;
@@ -44300,7 +45897,7 @@ function patchGenkitRegistryConstructor(registry2) {
       configurable: true,
       value: (...args) => {
         const childRegistry = originalWithParent.apply(constructor, args);
-        if (args.some((arg) => isRecord3(arg) && hasRegistryPatchedFlag(arg))) {
+        if (args.some((arg) => isRecord4(arg) && hasRegistryPatchedFlag(arg))) {
           patchGenkitRegistryLookup(childRegistry);
           patchGenkitRegistryConstructor(childRegistry);
         }
@@ -44399,7 +45996,7 @@ function hasRegistryConstructorPatchedFlag(value) {
   );
 }
 function isPromiseLike2(value) {
-  return isRecord3(value) && "then" in value && typeof value.then === "function";
+  return isRecord4(value) && "then" in value && typeof value.then === "function";
 }
 
 // src/wrappers/huggingface.ts
@@ -44876,14 +46473,14 @@ function wrapMistral(mistral) {
   console.warn("Unsupported Mistral library. Not wrapping.");
   return mistral;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction3(value, methodName) {
-  return isRecord4(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord5(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedMistralClient(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return false;
   }
   return value.chat !== void 0 && hasChat(value.chat) || value.embeddings !== void 0 && hasEmbeddings(value.embeddings) || value.fim !== void 0 && hasFim(value.fim) || value.agents !== void 0 && hasAgents(value.agents) || value.classifiers !== void 0 && hasClassifiers(value.classifiers);
@@ -45058,6 +46655,42 @@ function wrapAgentsStream(stream) {
   });
 }
 
+// src/wrappers/langgraph-sdk.ts
+var clients = /* @__PURE__ */ new WeakMap();
+function wrapLangGraphSDK(client) {
+  const runsClient = isObject(client) ? client.runs : void 0;
+  if (!isObject(client) || !isObject(runsClient) || !["wait", "stream"].every((key) => typeof runsClient[key] === "function")) {
+    debugLogger.warn("Unsupported LangGraph SDK client. Not wrapping.");
+    return client;
+  }
+  const sdk = client;
+  const cached = clients.get(sdk);
+  if (cached) return cached;
+  const runs = new Proxy(sdk.runs, {
+    get(target, key) {
+      switch (key) {
+        case "wait":
+          return (...args) => langGraphSDKChannels.wait.invoke(target.wait, target, args, {});
+        case "stream":
+          return (...args) => langGraphSDKChannels.stream.invoke(target.stream, target, args, {});
+        default:
+          const value = Reflect.get(target, key, target);
+          return typeof value === "function" ? value.bind(target) : value;
+      }
+    }
+  });
+  const wrapped = new Proxy(sdk, {
+    get(target, key) {
+      if (key === "runs") return runs;
+      const value = Reflect.get(target, key, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  clients.set(sdk, wrapped);
+  clients.set(wrapped, wrapped);
+  return wrapped;
+}
+
 // src/wrappers/ollama.ts
 function wrapOllama(ollama) {
   if (isSupportedOllamaClient(ollama)) {
@@ -45144,14 +46777,14 @@ function wrapCohere(cohere) {
   return cohere;
 }
 var cohereProxyCache = /* @__PURE__ */ new WeakMap();
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction4(value, methodName) {
-  return isRecord5(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord6(value) && methodName in value && typeof value[methodName] === "function";
 }
 function isSupportedCohereClient(value) {
-  if (!isRecord5(value)) {
+  if (!isRecord6(value)) {
     return false;
   }
   return hasFunction4(value, "chat") || hasFunction4(value, "chatStream") || hasFunction4(value, "embed") || hasFunction4(value, "rerank");
@@ -45289,20 +46922,20 @@ function wrapGroq(groq) {
   console.warn("Unsupported Groq library. Not wrapping.");
   return groq;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 function hasFunction6(value, methodName) {
-  return isRecord6(value) && methodName in value && typeof value[methodName] === "function";
+  return isRecord7(value) && methodName in value && typeof value[methodName] === "function";
 }
 function hasChat2(value) {
-  return isRecord6(value) && isRecord6(value.completions) && hasFunction6(value.completions, "create");
+  return isRecord7(value) && isRecord7(value.completions) && hasFunction6(value.completions, "create");
 }
 function hasEmbeddings2(value) {
   return hasFunction6(value, "create");
 }
 function isSupportedGroqClient(value) {
-  return isRecord6(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
+  return isRecord7(value) && (value.chat !== void 0 && hasChat2(value.chat) || value.embeddings !== void 0 && hasEmbeddings2(value.embeddings));
 }
 function groqProxy(groq) {
   const privateMethodWorkaroundCache = /* @__PURE__ */ new WeakMap();
@@ -45385,11 +47018,11 @@ var BEDROCK_RUNTIME_OPERATION_METHODS = /* @__PURE__ */ new Set([
   "invokeModelWithBidirectionalStream",
   "invokeModelWithResponseStream"
 ]);
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 function isSupportedBedrockRuntimeClient(value) {
-  return isRecord7(value) && typeof value.send === "function";
+  return isRecord8(value) && typeof value.send === "function";
 }
 function bedrockRuntimeProxy(client) {
   const cached = bedrockRuntimeProxyCache.get(client);
@@ -47715,12 +49348,272 @@ function waterfall(tasks, callback) {
 }
 var waterfall$1 = awaitify(waterfall);
 
+// src/framework.ts
+import { v5 as uuidv5 } from "uuid";
+
 // src/trace.ts
+var spanFilterFields = /* @__PURE__ */ new Set([
+  "spanType",
+  "name",
+  "hasError",
+  "metadata",
+  "duration"
+]);
+function isRecord9(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function validateMetadataValue(value, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return;
+  }
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) {
+      return;
+    }
+    throw new Error("filters.metadata numbers must be finite");
+  }
+  if (typeof value !== "object" || value === null) {
+    throw new Error("filters.metadata values must be JSON-serializable");
+  }
+  if (!Array.isArray(value) && !isRecord9(value)) {
+    throw new Error("filters.metadata values must be JSON-serializable");
+  }
+  if (ancestors.has(value)) {
+    throw new Error("filters.metadata must not contain cycles");
+  }
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      validateMetadataValue(value[index], ancestors);
+    }
+  } else {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new Error("filters.metadata keys must be strings");
+    }
+    for (const nested of Object.values(value)) {
+      validateMetadataValue(nested, ancestors);
+    }
+  }
+  ancestors.delete(value);
+}
+function compileMetadataLeaves(metadata, path = [], ancestors = /* @__PURE__ */ new WeakSet()) {
+  if (Object.getOwnPropertySymbols(metadata).length > 0) {
+    throw new Error("filters.metadata keys must be strings");
+  }
+  if (ancestors.has(metadata)) {
+    throw new Error("filters.metadata must not contain cycles");
+  }
+  ancestors.add(metadata);
+  const leaves = [];
+  for (const [key, value] of Object.entries(metadata)) {
+    const childPath = [...path, key];
+    if (isRecord9(value)) {
+      leaves.push(...compileMetadataLeaves(value, childPath, ancestors));
+    } else {
+      validateMetadataValue(value, ancestors);
+      leaves.push([childPath, value]);
+    }
+  }
+  ancestors.delete(metadata);
+  return leaves;
+}
+function normalizeSpanFilters(filters, spanType) {
+  if (filters != null && !isRecord9(filters)) {
+    throw new Error("filters must be an object");
+  }
+  const values = { ...filters ?? {} };
+  if (spanType !== void 0) {
+    if (!Array.isArray(spanType) || !spanType.every((item) => typeof item === "string")) {
+      throw new Error("spanType must be an array of strings");
+    }
+    if (Object.hasOwn(values, "spanType")) {
+      throw new Error(
+        "spanType cannot be provided both directly and in filters"
+      );
+    }
+    if (spanType.length > 0) {
+      values.spanType = spanType;
+    }
+  }
+  if (Object.keys(values).some((field) => !spanFilterFields.has(field))) {
+    throw new Error("Unsupported span filter fields");
+  }
+  for (const field of ["spanType", "name"]) {
+    if (Object.hasOwn(values, field)) {
+      const items = values[field];
+      if (!Array.isArray(items) || !items.every((item) => typeof item === "string")) {
+        throw new Error(`filters.${field} must be an array of strings`);
+      }
+    }
+  }
+  if (Object.hasOwn(values, "hasError") && typeof values.hasError !== "boolean") {
+    throw new Error("filters.hasError must be a boolean");
+  }
+  let compiledMetadataLeaves = [];
+  if (Object.hasOwn(values, "metadata")) {
+    if (!isRecord9(values.metadata)) {
+      throw new Error("filters.metadata must be an object");
+    }
+    compiledMetadataLeaves = compileMetadataLeaves(values.metadata);
+  }
+  if (Object.hasOwn(values, "duration")) {
+    if (!isRecord9(values.duration) || Object.keys(values.duration).some(
+      (bound) => bound !== "min" && bound !== "max"
+    )) {
+      throw new Error("filters.duration must contain only min and/or max");
+    }
+    if (Object.values(values.duration).some(
+      (bound) => typeof bound !== "number" || !Number.isFinite(bound)
+    )) {
+      throw new Error("filters.duration bounds must be finite numbers");
+    }
+  }
+  const normalized = {};
+  if (Array.isArray(values.spanType)) {
+    normalized.spanType = values.spanType;
+  }
+  if (Array.isArray(values.name)) {
+    normalized.name = values.name;
+  }
+  if (typeof values.hasError === "boolean") {
+    normalized.hasError = values.hasError;
+  }
+  if (isRecord9(values.metadata)) {
+    normalized.metadata = values.metadata;
+  }
+  if (isRecord9(values.duration)) {
+    normalized.duration = {};
+    if (typeof values.duration.min === "number") {
+      normalized.duration.min = values.duration.min;
+    }
+    if (typeof values.duration.max === "number") {
+      normalized.duration.max = values.duration.max;
+    }
+  }
+  return { filters: normalized, metadataLeaves: compiledMetadataLeaves };
+}
+function metadataEqual(actual, expected) {
+  if (expected === null) {
+    return actual === null || actual === void 0;
+  }
+  if (Array.isArray(expected)) {
+    return Array.isArray(actual) && actual.length === expected.length && expected.every((value, index) => metadataEqual(actual[index], value));
+  }
+  if (isRecord9(expected)) {
+    if (!isRecord9(actual)) {
+      return false;
+    }
+    const expectedKeys = Object.keys(expected);
+    const actualKeys = Object.keys(actual);
+    return actualKeys.length === expectedKeys.length && expectedKeys.every(
+      (key) => Object.hasOwn(actual, key) && metadataEqual(actual[key], expected[key])
+    );
+  }
+  return actual === expected;
+}
+function matchesSpanFilters(span, compiledFilters) {
+  const { filters, metadataLeaves } = compiledFilters;
+  if (filters.spanType !== void 0 && !filters.spanType.includes(span.span_attributes?.type ?? "")) {
+    return false;
+  }
+  if (filters.name !== void 0 && !filters.name.includes(span.span_attributes?.name ?? "")) {
+    return false;
+  }
+  if (filters.hasError !== void 0 && (span.error !== null && span.error !== void 0) !== filters.hasError) {
+    return false;
+  }
+  for (const [path, expected] of metadataLeaves) {
+    let actual = span.metadata;
+    for (const key of path) {
+      actual = isRecord9(actual) && Object.hasOwn(actual, key) ? actual[key] : void 0;
+    }
+    if (!metadataEqual(actual, expected)) {
+      return false;
+    }
+  }
+  if (filters.duration && Object.keys(filters.duration).length > 0) {
+    const metrics = span.metrics;
+    const start = isRecord9(metrics) ? metrics.start : void 0;
+    const end = isRecord9(metrics) ? metrics.end : void 0;
+    if (typeof start !== "number" || !Number.isFinite(start) || typeof end !== "number" || !Number.isFinite(end)) {
+      return false;
+    }
+    const elapsed = end - start;
+    if (filters.duration.min !== void 0 && elapsed < filters.duration.min) {
+      return false;
+    }
+    if (filters.duration.max !== void 0 && elapsed > filters.duration.max) {
+      return false;
+    }
+  }
+  return true;
+}
+function btqlComparison(op, name, value) {
+  return {
+    op,
+    left: { op: "ident", name },
+    right: { op: "literal", value }
+  };
+}
+function btqlNullCheck(op, name) {
+  return { op, expr: { op: "ident", name } };
+}
+function spanFilterClauses(compiledFilters) {
+  const { filters, metadataLeaves } = compiledFilters;
+  const children = [];
+  for (const [field, attribute] of [
+    ["spanType", "type"],
+    ["name", "name"]
+  ]) {
+    const values = filters[field];
+    if (values !== void 0) {
+      children.push(
+        values.length > 0 ? btqlComparison("in", ["span_attributes", attribute], values) : { op: "literal", value: false }
+      );
+    }
+  }
+  if (filters.hasError !== void 0) {
+    children.push(
+      btqlNullCheck(filters.hasError ? "isnotnull" : "isnull", ["error"])
+    );
+  }
+  for (const [path, value] of metadataLeaves) {
+    const name = ["metadata", ...path];
+    children.push(
+      value === null ? btqlNullCheck("isnull", name) : btqlComparison("eq", name, value)
+    );
+  }
+  const elapsed = {
+    op: "sub",
+    left: { op: "ident", name: ["metrics", "end"] },
+    right: { op: "ident", name: ["metrics", "start"] }
+  };
+  if (filters.duration?.min !== void 0) {
+    children.push({
+      op: "ge",
+      left: elapsed,
+      right: { op: "literal", value: filters.duration.min }
+    });
+  }
+  if (filters.duration?.max !== void 0) {
+    children.push({
+      op: "le",
+      left: elapsed,
+      right: { op: "literal", value: filters.duration.max }
+    });
+  }
+  return children;
+}
 var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
-  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false, brainstoreRealtime = true) {
+  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false, brainstoreRealtime = true, filters) {
+    const normalizedFilters = normalizeSpanFilters(filters, spanTypeFilter);
     const filterExpr = _SpanFetcher.buildFilter(
       rootSpanId,
-      spanTypeFilter,
+      normalizedFilters,
       includeScorers
     );
     super(
@@ -47741,42 +49634,22 @@ var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
   rootSpanId;
   _state;
   spanTypeFilter;
-  static buildFilter(rootSpanId, spanTypeFilter, includeScorers = false) {
+  static buildFilter(rootSpanId, filters, includeScorers = false) {
+    const purpose = ["span_attributes", "purpose"];
     const children = [
-      // Base filter: root_span_id = 'value'
-      {
-        op: "eq",
-        left: { op: "ident", name: ["root_span_id"] },
-        right: { op: "literal", value: rootSpanId }
-      }
+      btqlComparison("eq", ["root_span_id"], rootSpanId)
     ];
     if (!includeScorers) {
       children.push({
         op: "or",
         children: [
-          {
-            op: "isnull",
-            expr: { op: "ident", name: ["span_attributes", "purpose"] }
-          },
-          {
-            op: "ne",
-            left: { op: "ident", name: ["span_attributes", "purpose"] },
-            right: { op: "literal", value: "scorer" }
-          }
+          btqlNullCheck("isnull", purpose),
+          btqlComparison("ne", purpose, "scorer")
         ]
       });
     }
-    if (spanTypeFilter && spanTypeFilter.length > 0) {
-      children.push({
-        op: "in",
-        left: { op: "ident", name: ["span_attributes", "type"] },
-        right: { op: "literal", value: spanTypeFilter }
-      });
-    }
-    return {
-      op: "and",
-      children
-    };
+    children.push(...spanFilterClauses(filters));
+    return { op: "and", children };
   }
   get id() {
     return Promise.resolve(this._objectId);
@@ -47791,67 +49664,80 @@ var CachedSpanFetcher = class {
   fetchFn;
   constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState, brainstoreRealtime = true) {
     if (typeof objectTypeOrFetchFn === "function") {
-      this.fetchFn = (spanType) => objectTypeOrFetchFn(spanType);
+      this.fetchFn = async (filters) => (await objectTypeOrFetchFn(filters.filters.spanType)).filter(
+        (span) => matchesSpanFilters(span, filters)
+      );
     } else {
       const objectType = objectTypeOrFetchFn;
-      this.fetchFn = async (spanType, includeScorers) => {
+      this.fetchFn = async (filters, includeScorers) => {
         const state = await getState();
         const fetcher = new SpanFetcher(
           objectType,
           objectId,
           rootSpanId,
           state,
-          spanType,
+          void 0,
           includeScorers,
-          brainstoreRealtime
+          brainstoreRealtime,
+          filters.filters
         );
-        const rows = await fetcher.fetchedData();
-        return rows.map((row) => ({
-          input: row.input,
-          output: row.output,
-          expected: row.expected,
-          error: row.error,
-          scores: row.scores,
-          metrics: row.metrics,
-          metadata: row.metadata,
-          span_id: row.span_id,
-          span_parents: row.span_parents,
-          is_root: row.is_root,
-          span_attributes: row.span_attributes,
-          id: row.id,
-          _xact_id: row._xact_id,
-          _pagination_key: row._pagination_key,
-          root_span_id: row.root_span_id,
-          created: row.created,
-          tags: row.tags
-        }));
+        let spans = (await fetcher.fetchedData()).map(
+          (row) => ({ ...row })
+        );
+        if (filters.filters.metadata !== void 0) {
+          spans = spans.filter((span) => matchesSpanFilters(span, filters));
+        }
+        return spans;
       };
     }
   }
   async getSpans({
-    spanType,
+    spanType: requestedSpanType,
+    filters,
     includeScorers = false
   } = {}) {
+    const normalizedFilters = normalizeSpanFilters(filters, requestedSpanType);
+    const spanType = normalizedFilters.filters.spanType;
+    const hasAdvancedFilters = Object.keys(normalizedFilters.filters).some(
+      (field) => field !== "spanType"
+    );
+    if (spanType?.length === 0) {
+      return [];
+    }
     if (includeScorers) {
-      return this.fetchFn(spanType, true);
+      return this.fetchFn(normalizedFilters, true);
     }
     if (this.allFetched) {
-      return this.getFromCache(spanType);
+      const spans = this.getFromCache(spanType);
+      return hasAdvancedFilters ? spans.filter((span) => matchesSpanFilters(span, normalizedFilters)) : spans;
     }
-    if (!spanType || spanType.length === 0) {
+    if (hasAdvancedFilters && spanType && spanType.every((type) => this.spanCache.has(type))) {
+      return this.getFromCache(spanType).filter(
+        (span) => matchesSpanFilters(span, normalizedFilters)
+      );
+    }
+    if (hasAdvancedFilters) {
+      return this.fetchFn(normalizedFilters, false);
+    }
+    if (!spanType) {
+      this.spanCache.clear();
       await this.fetchSpans(void 0);
-      this.allFetched = true;
+      if (this.spanCache.size > 0) {
+        this.allFetched = true;
+      }
       return this.getFromCache(void 0);
     }
-    const missingTypes = spanType.filter((t) => !this.spanCache.has(t));
-    if (missingTypes.length === 0) {
-      return this.getFromCache(spanType);
+    const missingTypes = spanType.filter((type) => !this.spanCache.has(type));
+    if (missingTypes.length > 0) {
+      await this.fetchSpans(missingTypes);
     }
-    await this.fetchSpans(missingTypes);
     return this.getFromCache(spanType);
   }
   async fetchSpans(spanType) {
-    const spans = await this.fetchFn(spanType, false);
+    const spans = await this.fetchFn(
+      normalizeSpanFilters(spanType ? { spanType } : void 0),
+      false
+    );
     for (const span of spans) {
       const type = span.span_attributes?.type ?? "";
       const existing = this.spanCache.get(type) ?? [];
@@ -47931,34 +49817,20 @@ var LocalTrace = class {
    */
   async getSpans({
     spanType,
+    filters,
     includeScorers = false
   } = {}) {
+    const normalizedFilters = normalizeSpanFilters(filters, spanType);
     const cachedSpans = this.state.spanCache.getByRootSpanId(this.rootSpanId);
     if (cachedSpans && cachedSpans.length > 0) {
-      let spans = includeScorers ? cachedSpans : cachedSpans.filter(
-        (span) => span.span_attributes?.purpose !== "scorer"
-      );
-      if (spanType && spanType.length > 0) {
-        spans = spans.filter(
-          (span) => spanType.includes(span.span_attributes?.type ?? "")
-        );
-      }
-      return spans.map((span) => ({
-        input: span.input,
-        output: span.output,
-        expected: span.expected,
-        error: span.error,
-        scores: span.scores,
-        metrics: span.metrics,
-        metadata: span.metadata,
-        span_id: span.span_id,
-        span_parents: span.span_parents,
-        is_root: span.is_root,
-        span_attributes: span.span_attributes,
-        tags: span.tags
-      }));
-    }
-    return this.cachedFetcher.getSpans({ spanType, includeScorers });
+      return cachedSpans.filter(
+        (span) => (includeScorers || span.span_attributes?.purpose !== "scorer") && matchesSpanFilters({ ...span }, normalizedFilters)
+      ).map((span) => ({ ...span }));
+    }
+    return this.cachedFetcher.getSpans({
+      filters: normalizedFilters.filters,
+      includeScorers
+    });
   }
   /**
    * Get the thread (preprocessed messages) for this trace.
@@ -48378,7 +50250,7 @@ async function Eval(name, evaluator, reporterOrOpts) {
       data,
       { disabled: Boolean(options.parent || options.noSendLogs) }
     );
-    if (experiment && typeof process !== "undefined" && globalThis.BRAINTRUST_CONTEXT_MANAGER !== void 0) {
+    if (experiment) {
       await experiment._waitForId();
     }
     if (experiment && options.onStart) {
@@ -48703,6 +50575,10 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         } : void 0;
         const parsedDatumOrigin = ObjectReference.safeParse(datum.origin);
         const origin = inlineDatasetOrigin ?? (parsedDatumOrigin?.success ? parsedDatumOrigin.data : void 0);
+        const upsertId = datum.upsert_id && trialIndex > 0 ? uuidv5(
+          `braintrust:eval:${datum.upsert_id}:trial:${trialIndex}`,
+          uuidv5.URL
+        ) : datum.upsert_id;
         const baseEvent = {
           name: "eval",
           spanAttributes: {
@@ -48713,7 +50589,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             expected: "expected" in datum ? datum.expected : void 0,
             tags: datum.tags,
             origin,
-            ...datum.upsert_id ? { id: datum.upsert_id } : {}
+            ...upsertId ? { id: upsertId } : {}
           }
         };
         const callback = async (rootSpan) => {
@@ -49222,14 +51098,14 @@ var defaultReporter = {
   }
 };
 
-// src/durable-eval.ts
+// src/workflow-eval.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
-var BATCH_TASK_KIND = "braintrust.durable.batch-task";
-var BATCH_SCORER_KIND = "braintrust.durable.batch-scorer";
-var DEFAULT_BATCH_SIZE = 1e3;
-var DurableEvalMemoryStore = class {
+var WORKFLOW_TASK_KIND = "braintrust.workflow.task";
+var WORKFLOW_SCORER_KIND = "braintrust.workflow.scorer";
+var WorkflowEvalMemoryStore = class {
   values = /* @__PURE__ */ new Map();
+  sets = /* @__PURE__ */ new Map();
   async read(key) {
     return this.values.get(key)?.slice();
   }
@@ -49242,8 +51118,16 @@ var DurableEvalMemoryStore = class {
     this.values.set(key, value.slice());
     return { value: value.slice(), created: true };
   }
+  async addToSet(key, member) {
+    let members = this.sets.get(key);
+    if (!members) this.sets.set(key, members = /* @__PURE__ */ new Set());
+    members.add(member);
+  }
+  async getSetSize(key) {
+    return this.sets.get(key)?.size ?? 0;
+  }
 };
-var DurableEvalRedisStore = class {
+var WorkflowEvalRedisStore = class {
   client;
   keyPrefix;
   ttlMs;
@@ -49252,14 +51136,16 @@ var DurableEvalRedisStore = class {
     this.keyPrefix = options.keyPrefix ?? "braintrust-eval:";
     this.ttlMs = options.ttlMs ?? 1e3 * 60 * 60 * 24 * 7;
     if (!Number.isInteger(this.ttlMs) || this.ttlMs < 1) {
-      throw new Error("DurableEvalRedisStore ttlMs must be a positive integer");
+      throw new Error(
+        "WorkflowEvalRedisStore ttlMs must be a positive integer"
+      );
     }
   }
   async read(key) {
     const value = await this.client.get(`${this.keyPrefix}${key}`);
     if (value == null) return void 0;
     if (typeof value !== "string") {
-      throw new Error("DurableEvalRedisStore expected GET to return a string");
+      throw new Error("WorkflowEvalRedisStore expected GET to return a string");
     }
     return base64ToUint8Array(value);
   }
@@ -49276,7 +51162,7 @@ var DurableEvalRedisStore = class {
       await set.call(client, redisKey, encoded, { px: this.ttlMs });
     } else {
       throw new Error(
-        "DurableEvalRedisStore requires a node-redis, ioredis, or @upstash/redis client"
+        "WorkflowEvalRedisStore requires a node-redis, ioredis, or @upstash/redis client"
       );
     }
   }
@@ -49294,49 +51180,73 @@ var DurableEvalRedisStore = class {
       setOptions = [{ px: this.ttlMs, nx: true, get: true }];
     } else {
       throw new Error(
-        "DurableEvalRedisStore getOrSet requires a node-redis, ioredis, or @upstash/redis client"
+        "WorkflowEvalRedisStore getOrSet requires a node-redis, ioredis, or @upstash/redis client"
       );
     }
     const existing = await set.call(client, redisKey, encoded, ...setOptions);
     if (existing === null) return { value: value.slice(), created: true };
     if (typeof existing !== "string") {
       throw new Error(
-        "DurableEvalRedisStore expected atomic SET to return a string or null"
+        "WorkflowEvalRedisStore expected atomic SET to return a string or null"
       );
     }
     return { value: base64ToUint8Array(existing), created: false };
   }
+  async addToSet(key, member) {
+    await this.evalSet(
+      "redis.call('SADD', KEYS[1], ARGV[1]); redis.call('PEXPIRE', KEYS[1], ARGV[2]); return 1",
+      key,
+      [member, String(this.ttlMs)]
+    );
+  }
+  async getSetSize(key) {
+    return this.evalSet("return redis.call('SCARD', KEYS[1])", key, []);
+  }
+  async evalSet(script, key, args) {
+    const client = this.client;
+    const redisKey = `${this.keyPrefix}${key}`;
+    const result = typeof client.defineCommand === "function" ? await client.eval(script, 1, redisKey, ...args) : typeof client.sendCommand === "function" ? await client.eval(script, { keys: [redisKey], arguments: args }) : await client.eval(script, [redisKey], args);
+    if (typeof result !== "number") {
+      throw new Error(
+        "WorkflowEvalRedisStore expected EVAL to return a number"
+      );
+    }
+    return result;
+  }
 };
-var BatchTask = class {
+var WorkflowTask = class {
   constructor(processor) {
     this.processor = processor;
   }
   processor;
-  kind = BATCH_TASK_KIND;
+  kind = WORKFLOW_TASK_KIND;
 };
-var BatchScorer = class {
+var WorkflowScorer = class {
   constructor(processor) {
     this.processor = processor;
     this.name = processor.name;
   }
   processor;
-  kind = BATCH_SCORER_KIND;
+  kind = WORKFLOW_SCORER_KIND;
   name;
 };
-function defineDurableEval(projectName, evaluator) {
+function defineWorkflowEval(projectName, evaluator) {
+  if (evaluator.maxConcurrency !== void 0 && (!Number.isInteger(evaluator.maxConcurrency) || evaluator.maxConcurrency < 1)) {
+    throw new Error("maxConcurrency must be a positive integer");
+  }
   const definition = {
     projectName,
     evalName: evaluator.experimentName ?? projectName,
     evaluator
   };
   return {
-    start: (options = {}) => startDurableEval(definition, options),
-    status: (options) => getDurableEvalStatus(definition, options),
-    poll: (options) => pollDurableEval(definition, options),
-    processBatchResult: (result) => processDurableBatchResult(definition, result)
+    start: (options = {}) => startWorkflowEval(definition, options),
+    status: (options) => getWorkflowEvalStatus(definition, options),
+    poll: (options) => pollWorkflowEval(definition, options),
+    processSubmissionResult: (result) => processWorkflowSubmissionResult(definition, result)
   };
 }
-async function startDurableEval(definition, options) {
+async function startWorkflowEval(definition, options) {
   const store = definition.evaluator.store;
   const runId = newId();
   const key = runKey(definition.projectName, definition.evalName, runId);
@@ -49356,7 +51266,7 @@ async function startDurableEval(definition, options) {
       update: true
     }
   );
-  if (!isBatchTask(definition.evaluator.task) && !(definition.evaluator.scores ?? []).some(isBatchScorer)) {
+  if (!isWorkflowTask(definition.evaluator.task) && !(definition.evaluator.scores ?? []).some(isWorkflowScorer)) {
     const result = await runEvaluator(
       experiment,
       {
@@ -49383,67 +51293,91 @@ async function startDurableEval(definition, options) {
       parameters: assertJsonValue(parameters, "eval parameters"),
       status: "completed",
       summary: result.summary,
+      caseCount: 0,
       cases: [],
-      batches: []
+      submissions: []
     };
     await experiment?.flush();
     await writeRunRecord(store, key, state2);
     return currentStatus(definition, state2);
   }
+  const cases = await materializeCases(definition, data, experiment);
   const state = {
     runId,
     experimentName,
     noSendLogs: options.noSendLogs ?? false,
     parameters: assertJsonValue(parameters, "eval parameters"),
     status: "running",
-    cases: await materializeCases(definition, data, experiment),
-    batches: []
+    caseCount: cases.length,
+    cases,
+    submissions: []
   };
+  await writeJson(
+    store,
+    `${key}/case-ids`,
+    cases.map(({ id }) => id)
+  );
   await writeCaseBaseRecords(store, key, state.cases);
   await writeRunRecord(store, key, state);
-  return advanceDurableEval(definition, state, store, key, experiment);
+  return advanceWorkflowEval(definition, state, store, key, experiment);
 }
-async function getDurableEvalStatus(definition, options) {
+async function getWorkflowEvalStatus(definition, options) {
   const store = definition.evaluator.store;
-  const state = await readRunState(
-    definition,
-    store,
-    runKey(definition.projectName, definition.evalName, options.runId)
+  const key = runKey(
+    definition.projectName,
+    definition.evalName,
+    options.runId
   );
-  if (!state) throw new Error(`Durable eval run ${options.runId} is missing`);
+  const state = await readJson(store, key);
+  if (!state) throw new Error(`Workflow eval run ${options.runId} is missing`);
   return currentStatus(definition, state);
 }
-async function processDurableBatchResult(definition, result) {
-  if (!result.batchId && !result.externalId) {
-    throw new Error("Batch results require batchId or externalId");
+async function processWorkflowSubmissionResult(definition, result) {
+  if (!result.submissionId && !result.externalId) {
+    throw new Error("Submission results require submissionId or externalId");
   }
   const store = definition.evaluator.store;
   const key = runKey(definition.projectName, definition.evalName, result.runId);
-  const state = await readRunState(definition, store, key);
-  if (!state) throw new Error(`Durable eval run ${result.runId} is missing`);
-  const byBatch = result.batchId ? state.batches.find((candidate) => candidate.id === result.batchId) : void 0;
-  const byExternal = result.externalId ? state.batches.find(
-    (candidate) => candidate.externalId === result.externalId
+  const run = await readJson(store, key);
+  if (!run) throw new Error(`Workflow eval run ${result.runId} is missing`);
+  const externalSubmissionId = result.externalId ? await readJson(
+    store,
+    `${key}/external/${encodedKeyPart(result.externalId)}`
+  ) : void 0;
+  if (result.submissionId && externalSubmissionId && result.submissionId !== externalSubmissionId) {
+    throw new Error(
+      "submissionId and externalId identify different submissions"
+    );
+  }
+  const submissionId = result.submissionId ?? externalSubmissionId;
+  const submission = submissionId ? await readJson(
+    store,
+    submissionRecordKey(key, submissionId)
   ) : void 0;
-  if (byBatch && byExternal && byBatch.id !== byExternal.id) {
-    throw new Error("batchId and externalId identify different batches");
-  }
-  const batch = byBatch ?? byExternal;
-  if (!batch) throw new Error("No submitted batch matches this result");
-  if (batch.status !== "complete") {
-    const records = await collectBatch(definition, state, batch);
-    batch.status = "complete";
-    await writeCaseRecords(store, key, records);
-    await writeBatchRecords(store, key, [batch]);
-  }
-  return advanceDurableEval(
+  if (!submission) throw new Error("No submission matches this result");
+  if (result.externalId && submission.externalId !== result.externalId) {
+    throw new Error(
+      "submissionId and externalId identify different submissions"
+    );
+  }
+  if (run.status === "completed") return currentStatus(definition, run);
+  const state = await readRunState(definition, store, key, [
+    submission.itemId
+  ]);
+  if (submission.status !== "complete") {
+    const record = await collectSubmission(definition, state, submission);
+    await writeCaseRecords(store, key, [record]);
+    submission.status = "complete";
+  }
+  await writeSubmissionRecords(store, key, [submission]);
+  return advanceWorkflowEval(
     definition,
-    await readRunState(definition, store, key),
+    await readRunState(definition, store, key, [submission.itemId]),
     store,
     key
   );
 }
-async function pollDurableEval(definition, options) {
+async function pollWorkflowEval(definition, options) {
   const store = definition.evaluator.store;
   const key = runKey(
     definition.projectName,
@@ -49451,39 +51385,53 @@ async function pollDurableEval(definition, options) {
     options.runId
   );
   const state = await readRunState(definition, store, key);
-  if (!state) throw new Error(`Durable eval run ${options.runId} is missing`);
-  const batches = state.batches.filter((batch) => {
-    if (batch.status === "complete") return false;
-    return processorForStage(definition, batch.kind, batch.scorerName).completion.mode === "poll";
-  });
-  const results = await Promise.all(
-    batches.map(async (batch) => ({
-      batch,
-      result: await processorForStage(definition, batch.kind, batch.scorerName).completion.poll(batch.submissionData, {
-        runId: state.runId,
-        batchId: batch.id
-      })
-    }))
-  );
-  const changedCases = /* @__PURE__ */ new Map();
-  const changedBatches = [];
-  for (const { batch, result } of results) {
+  if (!state) throw new Error(`Workflow eval run ${options.runId} is missing`);
+  const submissions = state.submissions.filter((submission) => {
+    if (submission.status === "complete") return false;
+    return processorForStage(definition, submission.kind, submission.scorerName).completion.mode === "poll";
+  });
+  const workers = queue(async (submission) => {
+    const completion = processorForStage(
+      definition,
+      submission.kind,
+      submission.scorerName
+    ).completion;
+    if (completion.mode !== "poll") return;
+    const result = await completion.poll(submission.submissionData, {
+      runId: state.runId,
+      submissionId: submission.id
+    });
     if (result.status === "failed") throw asError(result.error);
-    if (result.status !== "complete") continue;
-    for (const record of await collectBatch(definition, state, batch)) {
-      changedCases.set(record.id, record);
-    }
-    batch.status = "complete";
-    changedBatches.push(batch);
-  }
-  if (changedBatches.length > 0) {
-    await writeCaseRecords(store, key, [...changedCases.values()]);
-    await writeBatchRecords(store, key, changedBatches);
+    if (result.status === "complete") {
+      const record = await collectSubmission(definition, state, submission);
+      await writeCaseRecords(store, key, [record]);
+      submission.status = "complete";
+      await writeSubmissionRecords(store, key, [submission]);
+    }
+  }, definition.evaluator.maxConcurrency ?? 10);
+  const results = await Promise.allSettled(
+    submissions.map((submission) => workers.pushAsync(submission))
+  );
+  let status;
+  const errors = results.flatMap(
+    (result) => result.status === "rejected" ? [asError(result.reason)] : []
+  );
+  try {
+    status = await advanceWorkflowEval(
+      definition,
+      await readRunState(definition, store, key),
+      store,
+      key
+    );
+  } catch (error) {
+    errors.push(asError(error));
   }
-  const currentState = changedBatches.length > 0 ? await readRunState(definition, store, key) : state;
-  return advanceDurableEval(definition, currentState, store, key);
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1)
+    throw new AggregateError(errors, "Workflow submission callbacks failed");
+  return status;
 }
-async function openDurableExperiment(definition, state) {
+async function openWorkflowExperiment(definition, state) {
   const data = [];
   return await _internalInitEvaluatorExperiment(
     definition.projectName,
@@ -49496,45 +51444,49 @@ async function openDurableExperiment(definition, state) {
     }
   );
 }
-async function advanceDurableEval(definition, state, store, key, existingExperiment) {
+async function advanceWorkflowEval(definition, state, store, key, existingExperiment) {
   if (state.status === "completed") return currentStatus(definition, state);
-  const experiment = existingExperiment === void 0 ? await openDurableExperiment(definition, state) : existingExperiment;
+  const experiment = existingExperiment === void 0 ? await openWorkflowExperiment(definition, state) : existingExperiment;
+  const caseIds = state.cases.map(({ id }) => id);
   await runTaskStage(definition, state, store, key, experiment);
   await logCompletedTasks(definition, state, store, key, experiment);
-  state = await readRunState(definition, store, key) ?? state;
-  if (state.cases.some((record) => !record.taskComplete || !record.taskLogged)) {
-    return currentStatus(definition, state);
-  }
+  state = await readRunState(definition, store, key, caseIds) ?? state;
   await runScoreStages(definition, state, store, key, experiment);
-  state = await readRunState(definition, store, key) ?? state;
+  state = await readRunState(definition, store, key, caseIds) ?? state;
   const scorerNames = resolveScorers(definition.evaluator.scores ?? []).map(
     ({ name }) => name
   );
   const classifierNames = (definition.evaluator.classifiers ?? []).map(
     classifierName
   );
-  if (state.cases.some(
-    (record) => scorerNames.some(
-      (name) => !Object.hasOwn(record.scores, name) || !Object.hasOwn(record.loggedScores, name)
-    ) || classifierNames.some(
-      (name) => !Object.hasOwn(record.loggedClassifications, name)
-    )
-  )) {
+  await Promise.all(
+    state.cases.map(async (record) => {
+      if (record.taskComplete && record.taskLogged && scorerNames.every(
+        (name) => Object.hasOwn(record.scores, name) && Object.hasOwn(record.loggedScores, name)
+      ) && classifierNames.every(
+        (name) => Object.hasOwn(record.loggedClassifications, name)
+      )) {
+        await store.addToSet(`${key}/progress/cases`, record.id);
+      }
+    })
+  );
+  if (await store.getSetSize(`${key}/progress/cases`) !== state.caseCount) {
     return currentStatus(definition, state);
   }
   if (!await claimAction(store, key, "finish")) {
-    const latest = await readRunState(definition, store, key);
+    const latest = await readJson(store, key);
     return currentStatus(definition, latest ?? state);
   }
+  state = await readRunState(definition, store, key);
   state.summary = await finishExperiment(definition, state, experiment);
   state.status = "completed";
   await writeRunRecord(store, key, state);
   return currentStatus(definition, state);
 }
-function currentStatus(definition, state) {
+async function currentStatus(definition, state) {
   if (state.status === "completed") {
     if (!state.summary) {
-      throw new Error(`Durable eval run ${state.runId} has no saved summary`);
+      throw new Error(`Workflow eval run ${state.runId} has no saved summary`);
     }
     return {
       status: "completed",
@@ -49543,11 +51495,20 @@ function currentStatus(definition, state) {
       summary: state.summary
     };
   }
+  const key = runKey(definition.projectName, definition.evalName, state.runId);
+  const store = definition.evaluator.store;
   const pending = { poll: 0, webhook: 0 };
-  for (const batch of state.batches) {
-    if (batch.status === "complete") continue;
-    pending[processorForStage(definition, batch.kind, batch.scorerName).completion.mode]++;
-  }
+  await Promise.all(
+    ["poll", "webhook"].map(async (mode) => {
+      const completed = await store.getSetSize(
+        `${key}/progress/${mode}/complete`
+      );
+      const submitted = await store.getSetSize(
+        `${key}/progress/${mode}/submitted`
+      );
+      pending[mode] = submitted - completed;
+    })
+  );
   return { status: "waiting", runId: state.runId, pending };
 }
 async function startCaseRoot(definition, state, record, experiment) {
@@ -49608,7 +51569,7 @@ async function logTaskResult(definition, state, record, experiment, task) {
       expected: "expected" in datum ? datum.expected : void 0,
       metadata: {
         ...record.metadata,
-        durable_eval: {
+        workflow_eval: {
           run_id: state.runId,
           case_id: record.caseId,
           trial_index: record.trialIndex
@@ -49639,8 +51600,8 @@ async function logCompletedTasks(definition, state, store, key, experiment) {
   }
 }
 async function runTaskStage(definition, state, store, key, experiment) {
-  if (isBatchTask(definition.evaluator.task)) {
-    await ensureBatches(definition, state, store, key, "task");
+  if (isWorkflowTask(definition.evaluator.task)) {
+    await ensureSubmissions(definition, state, store, key, "task");
     return;
   }
   const task = definition.evaluator.task;
@@ -49666,8 +51627,9 @@ async function runScoreStages(definition, state, store, key, experiment) {
     changed.clear();
   };
   for (const { name, scorer } of scorers) {
-    if (isBatchScorer(scorer)) {
+    if (isWorkflowScorer(scorer)) {
       for (const record of state.cases) {
+        if (!record.taskComplete || !record.taskLogged) continue;
         if (Object.hasOwn(record.scores, name) && !Object.hasOwn(record.loggedScores, name)) {
           if (!await claimAction(store, key, "score-log", record.id, name)) {
             continue;
@@ -49683,10 +51645,11 @@ async function runScoreStages(definition, state, store, key, experiment) {
         }
       }
       await persistChangedCases();
-      await ensureBatches(definition, state, store, key, "score", name);
+      await ensureSubmissions(definition, state, store, key, "score", name);
       continue;
     }
     for (const record of state.cases) {
+      if (!record.taskComplete || !record.taskLogged) continue;
       if (Object.hasOwn(record.loggedScores, name)) continue;
       if (!await claimAction(store, key, "score", record.id, name)) continue;
       await evaluateAndLogScore(
@@ -49703,6 +51666,7 @@ async function runScoreStages(definition, state, store, key, experiment) {
   for (const [index, classifier] of (definition.evaluator.classifiers ?? []).entries()) {
     const name = classifierName(classifier, index);
     for (const record of state.cases) {
+      if (!record.taskComplete || !record.taskLogged) continue;
       if (Object.hasOwn(record.loggedClassifications, name)) continue;
       if (!await claimAction(store, key, "classification", record.id, name)) {
         continue;
@@ -49725,13 +51689,14 @@ function scorerArgs(record) {
   return {
     ...datum,
     metadata: record.metadata,
+    tags: record.tags,
     output: record.output
   };
 }
 function resumeCaseRoot(definition, record, experiment) {
   if (!experiment) return NOOP_SPAN;
   if (!record.rootSpan) {
-    throw new Error(`Durable eval case ${record.caseId} has no root span`);
+    throw new Error(`Workflow eval case ${record.caseId} has no root span`);
   }
   return _internalResumeSpan({
     exported: record.rootSpan,
@@ -49819,117 +51784,110 @@ async function evaluateAndLogClassification(definition, state, record, name, cla
     root.end();
   }
 }
-async function ensureBatches(definition, state, store, key, kind, scorerName2) {
+async function ensureSubmissions(definition, state, store, key, kind, scorerName2) {
   const processor = processorForStage(definition, kind, scorerName2);
-  const plans = plannedBatches(
+  const plans = plannedSubmissions(
     definition,
     state.runId,
     state.cases.map(({ id }) => id)
   );
   const casesById = new Map(state.cases.map((record) => [record.id, record]));
-  for (const plan of plans) {
-    if (plan.kind !== kind || plan.scorerName !== scorerName2) continue;
-    if (state.batches.some(({ id }) => id === plan.id)) continue;
-    const records = plan.itemIds.map((id) => casesById.get(id));
-    const ready = records.every(
-      (record) => kind === "task" ? !record.taskComplete : !Object.hasOwn(record.scores, scorerName2)
-    );
-    if (!ready) continue;
-    const batchId = plan.id;
+  const existingIds = new Set(state.submissions.map(({ id }) => id));
+  const workers = queue(async (plan) => {
+    if (plan.kind !== kind || plan.scorerName !== scorerName2) return;
+    if (existingIds.has(plan.id)) return;
+    const record = casesById.get(plan.itemId);
+    const ready = kind === "task" ? !record.taskComplete : record.taskComplete && record.taskLogged && !Object.hasOwn(record.scores, scorerName2);
+    if (!ready) return;
+    const submissionId = plan.id;
     const claim = await store.getOrSet(
-      claimRecordKey(key, "batch", batchId),
-      encoder.encode(batchId)
-    );
-    if (!claim.created) continue;
-    const context = { runId: state.runId, batchId };
-    const items = records.map(
-      (record) => kind === "task" ? taskBatchItem(record, state.parameters) : scorerBatchItem(record)
+      claimRecordKey(key, "submission", submissionId),
+      encoder.encode(submissionId)
     );
+    if (!claim.created) return;
+    const context = { runId: state.runId, submissionId };
+    const item = kind === "task" ? taskSubmissionItem(record, state.parameters) : scorerSubmissionItem(record);
     const submissionData = assertJsonValue(
-      await processor.submit(items, context),
-      `submission data for batch ${batchId}`
+      await processor.submit(item, context),
+      `submission data for submission ${submissionId}`
     );
     const externalId = processor.completion.mode === "webhook" ? processor.completion.getExternalId(submissionData, context) : void 0;
     if (externalId !== void 0 && !externalId.trim()) {
-      throw new Error(`Batch ${batchId} produced an empty externalId`);
+      throw new Error(
+        `Submission ${submissionId} produced an empty externalId`
+      );
     }
-    const batch = {
-      id: batchId,
+    const submission = {
+      id: submissionId,
       kind,
       scorerName: scorerName2,
-      itemIds: records.map((record) => record.id),
+      itemId: record.id,
       submissionData,
       externalId,
-      status: "submitted"
-    };
-    state.batches.push(batch);
-    await writeBatchRecords(store, key, [batch]);
-  }
+      status: "submitted",
+      completionMode: processor.completion.mode
+    };
+    state.submissions.push(submission);
+    await writeSubmissionRecords(store, key, [submission]);
+  }, definition.evaluator.maxConcurrency ?? 10);
+  const results = await Promise.allSettled(
+    plans.map((plan) => workers.pushAsync(plan))
+  );
+  const errors = results.flatMap(
+    (result) => result.status === "rejected" ? [asError(result.reason)] : []
+  );
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1)
+    throw new AggregateError(errors, "Workflow submissions failed");
 }
-async function collectBatch(definition, state, batch) {
-  const processor = processorForStage(definition, batch.kind, batch.scorerName);
-  const context = { runId: state.runId, batchId: batch.id };
-  const results = await processor.collect(batch.submissionData, context);
-  if (!Array.isArray(results)) {
-    throw new Error(`collect for batch ${batch.id} must return an array`);
+async function collectSubmission(definition, state, submission) {
+  const processor = processorForStage(
+    definition,
+    submission.kind,
+    submission.scorerName
+  );
+  const context = { runId: state.runId, submissionId: submission.id };
+  const result = await processor.collect(submission.submissionData, context);
+  if (typeof result !== "object" || result === null || Array.isArray(result)) {
+    throw new Error(
+      `collect for submission ${submission.id} must return a result object`
+    );
   }
-  const expectedIds = new Set(batch.itemIds);
-  const seen = /* @__PURE__ */ new Set();
-  const records = [];
-  for (const result of results) {
-    const id = resultItemId(result);
-    if (!expectedIds.has(id)) {
-      throw new Error(`Batch ${batch.id} returned unknown item ${id}`);
-    }
-    if (seen.has(id)) {
-      throw new Error(`Batch ${batch.id} returned item ${id} more than once`);
-    }
-    seen.add(id);
-    const record = state.cases.find((candidate) => candidate.id === id);
-    records.push(record);
-    if (batch.kind === "task") {
-      record.output = assertJsonValue(
-        result.output,
-        `task output for item ${id}`
-      );
-      if ("metadata" in result && result.metadata !== void 0) {
-        record.metadata = assertJsonValue(
-          {
-            ...record.metadata,
-            ...result.metadata
-          },
-          `metadata for ${id}`
-        );
-      }
-      if ("tags" in result && result.tags !== void 0)
-        record.tags = result.tags;
-      record.taskComplete = true;
-    } else {
-      record.scores[batch.scorerName] = assertJsonValue(
-        result.score,
-        `score output for item ${id}`
+  const record = state.cases.find(
+    (candidate) => candidate.id === submission.itemId
+  );
+  if (submission.kind === "task") {
+    record.output = assertJsonValue(
+      result.output,
+      `task output for item ${record.id}`
+    );
+    if (result.metadata !== void 0) {
+      record.metadata = assertJsonValue(
+        { ...record.metadata, ...result.metadata },
+        `metadata for ${record.id}`
       );
     }
-  }
-  const missing = batch.itemIds.filter((id) => !seen.has(id));
-  if (missing.length > 0) {
-    throw new Error(
-      `Batch ${batch.id} did not return results for: ${missing.join(", ")}`
+    if (result.tags !== void 0) record.tags = result.tags;
+    record.taskComplete = true;
+  } else {
+    record.scores[submission.scorerName] = assertJsonValue(
+      result.score,
+      `score output for item ${record.id}`
     );
   }
-  return records;
+  return record;
 }
 function processorForStage(definition, kind, scorerName2) {
   if (kind === "task") {
-    if (!isBatchTask(definition.evaluator.task)) {
-      throw new Error("Definition no longer contains the batch task");
+    if (!isWorkflowTask(definition.evaluator.task)) {
+      throw new Error("Definition no longer contains the submission task");
     }
     return definition.evaluator.task.processor;
   }
   const scorer = resolveScorers(definition.evaluator.scores ?? []).find(
     ({ name }) => name === scorerName2
   )?.scorer;
-  if (!isBatchScorer(scorer)) {
+  if (!isWorkflowScorer(scorer)) {
     throw new Error(`Definition no longer contains scorer ${scorerName2}`);
   }
   return scorer.processor;
@@ -49951,15 +51909,15 @@ async function materializeCases(definition, data, experiment) {
     const caseId = datum.id ?? datum.upsert_id ?? (evaluator.caseId ? await evaluator.caseId(datum) : void 0);
     if (!caseId) {
       throw new Error(
-        "Every durable eval case requires id, upsert_id, or caseId"
+        "Every workflow eval case requires id, upsert_id, or caseId"
       );
     }
     if (seen.has(caseId))
-      throw new Error(`Duplicate durable eval case id: ${caseId}`);
+      throw new Error(`Duplicate workflow eval case id: ${caseId}`);
     seen.add(caseId);
     const trialCount = datum.trialCount ?? evaluator.trialCount ?? 1;
     if (!Number.isInteger(trialCount) || trialCount < 1) {
-      throw new Error(`Invalid trialCount for durable eval case ${caseId}`);
+      throw new Error(`Invalid trialCount for workflow eval case ${caseId}`);
     }
     for (let trialIndex = 0; trialIndex < trialCount; trialIndex++) {
       records.push({
@@ -49983,7 +51941,7 @@ async function materializeCases(definition, data, experiment) {
   }
   return records;
 }
-function taskBatchItem(record, parameters) {
+function taskSubmissionItem(record, parameters) {
   const datum = record.datum;
   return {
     id: record.id,
@@ -49995,7 +51953,7 @@ function taskBatchItem(record, parameters) {
     trialIndex: record.trialIndex
   };
 }
-function scorerBatchItem(record) {
+function scorerSubmissionItem(record) {
   const datum = record.datum;
   return {
     id: record.id,
@@ -50066,12 +52024,12 @@ async function finishExperiment(definition, state, experiment) {
 }
 function resolveScorers(scorers) {
   return scorers.map((scorer, index) => ({
-    name: isBatchScorer(scorer) ? scorer.name : scorer.name || `scorer_${index}`,
+    name: isWorkflowScorer(scorer) ? scorer.name : scorer.name || `scorer_${index}`,
     scorer
   }));
 }
 function runKey(projectName, evalName, runId) {
-  return `durable-eval/v1/runs/${contentVersion(encoder.encode(`${projectName}\0${evalName}\0${runId}`))}`;
+  return `workflow-eval/v1/runs/${contentVersion(encoder.encode(`${projectName}\0${evalName}\0${runId}`))}`;
 }
 function encodedKeyPart(value) {
   return uint8ArrayToBase64(encoder.encode(value)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
@@ -50080,8 +52038,8 @@ function caseRecordKey(key, caseId, kind, ...names) {
   const suffix = names.map(encodedKeyPart).join("/");
   return `${key}/cases/${encodedKeyPart(caseId)}/${kind}${suffix ? `/${suffix}` : ""}`;
 }
-function batchRecordKey(key, batchId) {
-  return `${key}/batches/${encodedKeyPart(batchId)}`;
+function submissionRecordKey(key, submissionId) {
+  return `${key}/submissions/${encodedKeyPart(submissionId)}`;
 }
 function claimRecordKey(key, kind, ...parts) {
   const identity = stableStringify([kind, parts]);
@@ -50093,33 +52051,24 @@ async function claimAction(store, key, kind, ...parts) {
     encoder.encode("claimed")
   )).created;
 }
-function plannedBatches(definition, runId, caseIds) {
+function plannedSubmissions(definition, runId, caseIds) {
   const stages = [];
-  if (isBatchTask(definition.evaluator.task)) stages.push({ kind: "task" });
+  if (isWorkflowTask(definition.evaluator.task)) stages.push({ kind: "task" });
   for (const { name, scorer } of resolveScorers(
     definition.evaluator.scores ?? []
   )) {
-    if (isBatchScorer(scorer)) {
+    if (isWorkflowScorer(scorer)) {
       stages.push({ kind: "score", scorerName: name });
     }
   }
   const plans = [];
   for (const { kind, scorerName: scorerName2 } of stages) {
-    const batchSize = processorForStage(definition, kind, scorerName2).batchSize ?? DEFAULT_BATCH_SIZE;
-    if (!Number.isInteger(batchSize) || batchSize < 1) {
-      throw new Error(
-        `Invalid batchSize for ${scorerName2 ?? "task"}: ${batchSize}`
-      );
-    }
-    for (let offset = 0; offset < caseIds.length; offset += batchSize) {
-      const itemIds = caseIds.slice(offset, offset + batchSize);
+    for (const itemId of caseIds) {
       plans.push({
-        id: deterministicId(
-          stableStringify([runId, kind, scorerName2, itemIds])
-        ),
+        id: deterministicId(stableStringify([runId, kind, scorerName2, itemId])),
         kind,
         scorerName: scorerName2,
-        itemIds
+        itemId
       });
     }
   }
@@ -50179,7 +52128,7 @@ async function readCaseRecord(definition, store, key, id) {
       }))
     )
   ]);
-  if (!base) throw new Error(`Durable eval case ${id} is missing`);
+  if (!base) throw new Error(`Workflow eval case ${id} is missing`);
   const scores = /* @__PURE__ */ Object.create(null);
   for (const { name, value } of scoreValues) {
     if (value !== void 0) scores[name] = value;
@@ -50210,32 +52159,34 @@ async function readCaseRecord(definition, store, key, id) {
     loggedClassifications
   };
 }
-async function readRunState(definition, store, key) {
+async function readRunState(definition, store, key, caseIds) {
   const record = await readJson(store, key);
   if (!record) return void 0;
-  const plans = plannedBatches(definition, record.runId, record.caseIds);
-  const [cases, batchRecords] = await Promise.all([
+  const selectedIds = caseIds ?? (record.caseCount === 0 ? [] : await readJson(store, `${key}/case-ids`));
+  if (!selectedIds)
+    throw new Error(`Workflow eval run ${record.runId} has no case index`);
+  const plans = plannedSubmissions(definition, record.runId, selectedIds);
+  const [cases, submissionRecords] = await Promise.all([
     Promise.all(
-      record.caseIds.map((id) => readCaseRecord(definition, store, key, id))
+      selectedIds.map((id) => readCaseRecord(definition, store, key, id))
     ),
     Promise.all(
       plans.map(async ({ id }) => {
-        return readJson(store, batchRecordKey(key, id));
+        return readJson(
+          store,
+          submissionRecordKey(key, id)
+        );
       })
     )
   ]);
-  const batches = batchRecords.filter(
+  const submissions = submissionRecords.filter(
     (value) => value !== void 0
   );
-  const { caseIds: _caseIds, ...state } = record;
-  return { ...state, cases, batches };
+  return { ...record, cases, submissions };
 }
 async function writeRunRecord(store, key, state) {
-  const { cases, batches: _batches, ...record } = state;
-  await writeJson(store, key, {
-    ...record,
-    caseIds: cases.map(({ id }) => id)
-  });
+  const { cases: _cases, submissions: _submissions, ...record } = state;
+  await writeJson(store, key, record);
 }
 async function writeCaseBaseRecords(store, key, records) {
   await Promise.all(
@@ -50307,11 +52258,25 @@ async function writeCaseRecords(store, key, records) {
   }
   await Promise.all(writes);
 }
-async function writeBatchRecords(store, key, records) {
+async function writeSubmissionRecords(store, key, records) {
   await Promise.all(
-    records.map(
-      (record) => writeJson(store, batchRecordKey(key, record.id), record)
-    )
+    records.map(async (record) => {
+      if (record.externalId !== void 0) {
+        const locator = await store.getOrSet(
+          `${key}/external/${encodedKeyPart(record.externalId)}`,
+          encoder.encode(JSON.stringify(record.id))
+        );
+        if (JSON.parse(decoder.decode(locator.value)) !== record.id) {
+          throw new Error(`Duplicate externalId: ${record.externalId}`);
+        }
+      }
+      const progressKey = `${key}/progress/${record.completionMode}`;
+      await store.addToSet(`${progressKey}/submitted`, record.id);
+      if (record.status === "complete") {
+        await store.addToSet(`${progressKey}/complete`, record.id);
+      }
+      await writeJson(store, submissionRecordKey(key, record.id), record);
+    })
   );
 }
 function deterministicId(value) {
@@ -50356,17 +52321,11 @@ function assertJsonValue(value, label) {
     throw new Error(`${label} must be JSON serializable`, { cause: error });
   }
 }
-function resultItemId(value) {
-  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string") {
-    throw new Error("Batch results must contain a string id");
-  }
-  return value.id;
-}
-function isBatchTask(value) {
-  return typeof value === "object" && value !== null && "kind" in value && value.kind === BATCH_TASK_KIND;
+function isWorkflowTask(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === WORKFLOW_TASK_KIND;
 }
-function isBatchScorer(value) {
-  return typeof value === "object" && value !== null && "kind" in value && value.kind === BATCH_SCORER_KIND;
+function isWorkflowScorer(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === WORKFLOW_SCORER_KIND;
 }
 function asError(error) {
   return error instanceof Error ? error : new Error(String(error));
@@ -51294,13 +53253,13 @@ var evaluatorDefinitionsSchema = z13.record(
 );
 
 // src/wrappers/elevenlabs.ts
-var clients = /* @__PURE__ */ new WeakMap();
+var clients2 = /* @__PURE__ */ new WeakMap();
 function wrapElevenLabs(client) {
   if (!isObject(client) || !isObject(client.textToSpeech) || typeof client.textToSpeech.convert !== "function") {
     debugLogger.warn("Unsupported ElevenLabs client. Not wrapping.");
     return client;
   }
-  const cached = clients.get(client);
+  const cached = clients2.get(client);
   if (cached) return cached;
   const sdk = client;
   const speech = new Proxy(sdk.textToSpeech, {
@@ -51347,8 +53306,8 @@ function wrapElevenLabs(client) {
       return Reflect.get(target, prop, receiver);
     }
   });
-  clients.set(client, proxy);
-  clients.set(proxy, proxy);
+  clients2.set(client, proxy);
+  clients2.set(proxy, proxy);
   return proxy;
 }
 
@@ -51363,8 +53322,6 @@ export {
   BRAINTRUST_PARENT_KEY,
   BaseAttachment,
   BaseExperiment,
-  BatchScorer,
-  BatchTask,
   BraintrustLangChainCallbackHandler,
   BraintrustMiddleware,
   BraintrustObservabilityExporter,
@@ -51378,8 +53335,6 @@ export {
   DEFAULT_MAX_REQUEST_SIZE,
   Dataset2 as Dataset,
   DatasetPipeline,
-  DurableEvalMemoryStore,
-  DurableEvalRedisStore,
   ERR_PERMALINK,
   Eval,
   EvalResultWithSummary,
@@ -51414,6 +53369,10 @@ export {
   TestBackgroundLogger,
   ToolBuilder,
   UUIDGenerator,
+  WorkflowEvalMemoryStore,
+  WorkflowEvalRedisStore,
+  WorkflowScorer,
+  WorkflowTask,
   X_CACHED_HEADER,
   _exportsForTestingOnly,
   _internalGetGlobalState,
@@ -51439,12 +53398,13 @@ export {
   deepCopyEvent,
   exports_exports as default,
   defaultErrorScoreHandler,
-  defineDurableEval,
+  defineWorkflowEval,
   deserializePlainStringAsJSON,
   devNullWritableStream,
   evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema,
   extractTraceContextFromHeaders,
+  failOpenAIAgentsTrace,
   flush,
   getContextManager,
   getIdGenerator,
@@ -51491,12 +53451,14 @@ export {
   setFetch,
   setMaskingFunction,
   spanComponentsToObjectId,
+  startOpenAIAgentsTrace,
   startSpan,
   summarize,
   templateRegistry,
   ToolFunctionDefinition as toolFunctionDefinitionSchema,
   traceable,
   traced,
+  updateOpenAIAgentsTrace,
   updateSpan,
   uploadLogs3OverflowPayload,
   utf8ByteLength2 as utf8ByteLength,
@@ -51525,6 +53487,7 @@ export {
   wrapGroq,
   wrapHuggingFace,
   wrapHuggingFaceTransformers,
+  wrapLangGraphSDK,
   wrapLangSmithClient,
   wrapLangSmithRunTrees,
   wrapLangSmithTraceable,