braintrust 3.20.0 → 3.21.0

package/dist/index.mjs

@@ -1,8 +1,10 @@
 import {
   Attachment,
   AttachmentReference,
+  BAGGAGE_HEADER,
   BRAINTRUST_CURRENT_SPAN_STORE,
   BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
+  BRAINTRUST_PARENT_KEY,
   BaseAttachment,
   BraintrustLangChainCallbackHandler,
   BraintrustObservabilityExporter,
@@ -32,6 +34,7 @@ import {
   NOOP_SPAN,
   NOOP_SPAN_PERMALINK,
   NoopSpan,
+  OTELIDGenerator,
   ObjectFetcher,
   ObjectReference,
   Project,
@@ -41,8 +44,10 @@ import {
   ReadonlyExperiment,
   RemoteEvalParameters,
   RunEval,
-  SpanComponentsV3,
+  SpanComponentsV4,
   SpanImpl,
+  TRACEPARENT_HEADER,
+  TRACESTATE_HEADER,
   TestBackgroundLogger,
   ToolFunctionDefinition,
   UUIDGenerator,
@@ -63,11 +68,13 @@ import {
   currentExperiment,
   currentLogger,
   currentSpan,
+  currentWorkflowAgentWrapperSpan,
   debugLogger,
   deepCopyEvent,
   deserializePlainStringAsJSON,
   devNullWritableStream,
   extractAnthropicCacheTokens,
+  extractTraceContextFromHeaders,
   finalizeAnthropicTokens,
   flush,
   getBedrockRuntimeOperation,
@@ -81,6 +88,7 @@ import {
   initDataset,
   initExperiment,
   initLogger,
+  injectTraceContext,
   isEmpty,
   isObject,
   isTemplateFormat,
@@ -129,7 +137,7 @@ import {
   wrapMastraAgent,
   wrapTraced,
   zodToJsonSchema
-} from "./chunk-F73OMF66.mjs";
+} from "./chunk-O2P765XK.mjs";
 import {
   __export,
   aiSDKChannels,
@@ -152,15 +160,17 @@ import {
   openRouterChannels,
   piCodingAgentChannels,
   strandsAgentSDKChannels
-} from "./chunk-Y7W7WP6H.mjs";
+} from "./chunk-KMGUTPB7.mjs";
 
 // src/exports.ts
 var exports_exports = {};
 __export(exports_exports, {
   Attachment: () => Attachment,
   AttachmentReference: () => AttachmentReference,
+  BAGGAGE_HEADER: () => BAGGAGE_HEADER,
   BRAINTRUST_CURRENT_SPAN_STORE: () => BRAINTRUST_CURRENT_SPAN_STORE,
   BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME: () => BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
+  BRAINTRUST_PARENT_KEY: () => BRAINTRUST_PARENT_KEY,
   BaseAttachment: () => BaseAttachment,
   BaseExperiment: () => BaseExperiment,
   BraintrustLangChainCallbackHandler: () => BraintrustLangChainCallbackHandler,
@@ -193,6 +203,7 @@ __export(exports_exports, {
   NOOP_SPAN: () => NOOP_SPAN,
   NOOP_SPAN_PERMALINK: () => NOOP_SPAN_PERMALINK,
   NoopSpan: () => NoopSpan,
+  OTELIDGenerator: () => OTELIDGenerator,
   ObjectFetcher: () => ObjectFetcher,
   Project: () => Project2,
   ProjectNameIdMap: () => ProjectNameIdMap,
@@ -204,6 +215,8 @@ __export(exports_exports, {
   ScorerBuilder: () => ScorerBuilder,
   SpanFetcher: () => SpanFetcher,
   SpanImpl: () => SpanImpl,
+  TRACEPARENT_HEADER: () => TRACEPARENT_HEADER,
+  TRACESTATE_HEADER: () => TRACESTATE_HEADER,
   TestBackgroundLogger: () => TestBackgroundLogger,
   ToolBuilder: () => ToolBuilder,
   UUIDGenerator: () => UUIDGenerator,
@@ -213,6 +226,7 @@ __export(exports_exports, {
   _internalIso: () => isomorph_default,
   _internalSetInitialState: () => _internalSetInitialState,
   addAzureBlobHeaders: () => addAzureBlobHeaders,
+  agentAssertionScorer: () => agentAssertionScorer,
   braintrustAISDKTelemetry: () => braintrustAISDKTelemetry,
   braintrustFlueInstrumentation: () => braintrustFlueInstrumentation,
   braintrustFlueObserver: () => braintrustFlueObserver,
@@ -230,6 +244,7 @@ __export(exports_exports, {
   devNullWritableStream: () => devNullWritableStream,
   evaluatorDefinitionSchema: () => evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema: () => evaluatorDefinitionsSchema,
+  extractTraceContextFromHeaders: () => extractTraceContextFromHeaders,
   flush: () => flush,
   getContextManager: () => getContextManager,
   getIdGenerator: () => getIdGenerator,
@@ -243,6 +258,7 @@ __export(exports_exports, {
   initFunction: () => initFunction,
   initLogger: () => initLogger,
   initNodeTestSuite: () => initNodeTestSuite,
+  injectTraceContext: () => injectTraceContext,
   invoke: () => invoke,
   isTemplateFormat: () => isTemplateFormat,
   loadParameters: () => loadParameters,
@@ -874,6 +890,7 @@ function wrapAISDK(aiSDK, options = {}) {
         case "Agent":
         case "Experimental_Agent":
         case "ToolLoopAgent":
+        case "WorkflowAgent":
           return original ? wrapAgentClass(original, options) : original;
       }
       return original;
@@ -892,10 +909,10 @@ var wrapAgentClass = (AgentClass, options = {}) => {
       return new Proxy(instance, {
         get(instanceTarget, prop, instanceReceiver) {
           const original = Reflect.get(instanceTarget, prop, instanceTarget);
-          if (prop === "generate") {
+          if (prop === "generate" && typeof original === "function" && instanceTarget.constructor.name !== "WorkflowAgent") {
             return wrapAgentGenerate(original, instanceTarget, options);
           }
-          if (prop === "stream") {
+          if (prop === "stream" && typeof original === "function") {
             return wrapAgentStream(original, instanceTarget, options);
           }
           if (typeof original === "function") {
@@ -910,7 +927,7 @@ var wrapAgentClass = (AgentClass, options = {}) => {
 var wrapAgentGenerate = (generate, instance, options = {}) => {
   const defaultName = `${instance.constructor.name}.generate`;
   return async (params) => makeGenerateTextWrapper(
-    aiSDKChannels.generateText,
+    generateChannelForAgent(instance.constructor.name),
     defaultName,
     generate.bind(instance),
     {
@@ -920,19 +937,42 @@ var wrapAgentGenerate = (generate, instance, options = {}) => {
     options
   )({ ...instance.settings, ...params });
 };
+function generateChannelForAgent(agentName) {
+  if (agentName === "ToolLoopAgent") {
+    return aiSDKChannels.toolLoopAgentGenerate;
+  }
+  return aiSDKChannels.agentGenerate;
+}
 var wrapAgentStream = (stream, instance, options = {}) => {
   const defaultName = `${instance.constructor.name}.stream`;
-  return (params) => makeStreamWrapper(
-    aiSDKChannels.agentStream,
-    defaultName,
-    stream.bind(instance),
-    {
-      self: instance,
-      spanType: "function" /* FUNCTION */
-    },
-    options
-  )({ ...instance.settings, ...params });
+  return (params) => {
+    const workflowAgent = instance.constructor.name === "WorkflowAgent";
+    if (workflowAgent && currentWorkflowAgentWrapperSpan()) {
+      const { span_info: _spanInfo, ...cleanParams } = params;
+      return stream.call(instance, { ...instance.settings, ...cleanParams });
+    }
+    const trace = () => makeStreamWrapper(
+      streamChannelForAgent(instance.constructor.name),
+      defaultName,
+      stream.bind(instance),
+      {
+        self: instance,
+        spanType: "function" /* FUNCTION */
+      },
+      options
+    )({ ...instance.settings, ...params });
+    return trace();
+  };
 };
+function streamChannelForAgent(agentName) {
+  if (agentName === "ToolLoopAgent") {
+    return aiSDKChannels.toolLoopAgentStream;
+  }
+  if (agentName === "WorkflowAgent") {
+    return aiSDKChannels.workflowAgentStream;
+  }
+  return aiSDKChannels.agentStream;
+}
 var makeGenerateTextWrapper = (channel, name, generateText, contextOptions = {}, options = {}) => {
   const wrapper = async function(allParams) {
     const { span_info, ...params } = allParams;
@@ -1194,7 +1234,7 @@ var BraintrustLanguageModelWrapper = class {
       let time_to_first_token = void 0;
       let usage = void 0;
       let fullText = void 0;
-      const toolCalls = {};
+      const toolCalls2 = {};
       let finishReason = void 0;
       return {
         ...ret,
@@ -1213,7 +1253,7 @@ var BraintrustLanguageModelWrapper = class {
                   fullText += chunk.textDelta;
                   break;
                 case "tool-call":
-                  toolCalls[chunk.toolCallId] = {
+                  toolCalls2[chunk.toolCallId] = {
                     toolCallType: chunk.toolCallType,
                     toolCallId: chunk.toolCallId,
                     toolName: chunk.toolName,
@@ -1221,15 +1261,15 @@ var BraintrustLanguageModelWrapper = class {
                   };
                   break;
                 case "tool-call-delta":
-                  if (toolCalls[chunk.toolCallId] === void 0) {
-                    toolCalls[chunk.toolCallId] = {
+                  if (toolCalls2[chunk.toolCallId] === void 0) {
+                    toolCalls2[chunk.toolCallId] = {
                       toolCallType: chunk.toolCallType,
                       toolCallId: chunk.toolCallId,
                       toolName: chunk.toolName,
                       args: ""
                     };
                   }
-                  toolCalls[chunk.toolCallId].args += chunk.argsTextDelta;
+                  toolCalls2[chunk.toolCallId].args += chunk.argsTextDelta;
                   break;
                 case "finish":
                   usage = chunk.usage;
@@ -1242,7 +1282,7 @@ var BraintrustLanguageModelWrapper = class {
               span.log({
                 output: postProcessOutput(
                   fullText,
-                  Object.keys(toolCalls).length > 0 ? Object.values(toolCalls) : void 0,
+                  Object.keys(toolCalls2).length > 0 ? Object.values(toolCalls2) : void 0,
                   finishReason
                 ),
                 metrics: {
@@ -1343,15 +1383,15 @@ function postProcessPrompt(prompt) {
     }
   });
 }
-function postProcessOutput(text, toolCalls, finishReason) {
+function postProcessOutput(text, toolCalls2, finishReason) {
   return [
     {
       index: 0,
       message: {
         role: "assistant",
         content: text ?? "",
-        ...toolCalls && toolCalls.length > 0 ? {
-          tool_calls: toolCalls.map((toolCall) => ({
+        ...toolCalls2 && toolCalls2.length > 0 ? {
+          tool_calls: toolCalls2.map((toolCall) => ({
             id: toolCall.toolCallId,
             function: {
               name: toolCall.toolName,
@@ -1450,29 +1490,29 @@ function normalizeFinishReason(reason) {
   if (typeof reason !== "string") return void 0;
   return reason.replace(/-/g, "_");
 }
-function buildAssistantOutputWithToolCalls(result, toolCalls) {
+function buildAssistantOutputWithToolCalls(result, toolCalls2) {
   return [
     {
       index: 0,
       logprobs: null,
-      finish_reason: normalizeFinishReason(result?.finishReason) ?? (toolCalls.length ? "tool_calls" : void 0),
+      finish_reason: normalizeFinishReason(result?.finishReason) ?? (toolCalls2.length ? "tool_calls" : void 0),
       message: {
         role: "assistant",
-        tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+        tool_calls: toolCalls2.length > 0 ? toolCalls2 : void 0
       }
     }
   ];
 }
 function extractToolCallsFromSteps(steps) {
-  const toolCalls = [];
-  if (!Array.isArray(steps)) return toolCalls;
+  const toolCalls2 = [];
+  if (!Array.isArray(steps)) return toolCalls2;
   let idx = 0;
   for (const step of steps) {
     const blocks = step?.content;
     if (!Array.isArray(blocks)) continue;
     for (const block of blocks) {
       if (block && typeof block === "object" && block.type === "tool-call") {
-        toolCalls.push({
+        toolCalls2.push({
           id: block.toolCallId,
           type: "function",
           index: idx++,
@@ -1484,7 +1524,7 @@ function extractToolCallsFromSteps(steps) {
       }
     }
   }
-  return toolCalls;
+  return toolCalls2;
 }
 function extractToolCallsFromBlocks(blocks) {
   if (!Array.isArray(blocks)) return [];
@@ -1550,12 +1590,12 @@ function BraintrustMiddleware(config = {}) {
             metadata.model = modelId;
           }
         }
-        let toolCalls = extractToolCallsFromSteps(result?.steps);
-        if (!toolCalls || toolCalls.length === 0) {
-          toolCalls = extractToolCallsFromBlocks(result?.content);
+        let toolCalls2 = extractToolCallsFromSteps(result?.steps);
+        if (!toolCalls2 || toolCalls2.length === 0) {
+          toolCalls2 = extractToolCallsFromBlocks(result?.content);
         }
         span.log({
-          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : result?.content,
+          output: toolCalls2.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls2) : result?.content,
           metadata,
           metrics: normalizeUsageMetrics(
             result.usage,
@@ -1644,13 +1684,13 @@ function BraintrustMiddleware(config = {}) {
                 metadata.model = model;
               }
               if (toolBlocks.length > 0) {
-                const toolCalls = extractToolCallsFromSteps([
+                const toolCalls2 = extractToolCallsFromSteps([
                   { content: toolBlocks }
                 ]);
-                if (toolCalls.length > 0) {
+                if (toolCalls2.length > 0) {
                   output = buildAssistantOutputWithToolCalls(
                     resultForDetection,
-                    toolCalls
+                    toolCalls2
                   );
                 }
               }
@@ -5599,15 +5639,21 @@ var waterfall$1 = awaitify(waterfall);
 
 // src/trace.ts
 var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
-  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false) {
+  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false, brainstoreRealtime = true) {
     const filterExpr = _SpanFetcher.buildFilter(
       rootSpanId,
       spanTypeFilter,
       includeScorers
     );
-    super(objectType, void 0, void 0, {
-      filter: filterExpr
-    });
+    super(
+      objectType,
+      void 0,
+      void 0,
+      {
+        filter: filterExpr
+      },
+      brainstoreRealtime
+    );
     this._objectId = _objectId;
     this.rootSpanId = rootSpanId;
     this._state = _state;
@@ -5661,7 +5707,7 @@ var CachedSpanFetcher = class {
   spanCache = /* @__PURE__ */ new Map();
   allFetched = false;
   fetchFn;
-  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {
+  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState, brainstoreRealtime = true) {
     if (typeof objectTypeOrFetchFn === "function") {
       this.fetchFn = (spanType) => objectTypeOrFetchFn(spanType);
     } else {
@@ -5674,7 +5720,8 @@ var CachedSpanFetcher = class {
           rootSpanId,
           state,
           spanType,
-          includeScorers
+          includeScorers,
+          brainstoreRealtime
         );
         const rows = await fetcher.fetchedData();
         return rows.map((row) => ({
@@ -6504,7 +6551,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             }
           };
           const parentStr = state.currentParent.getStore();
-          const parentComponents = parentStr ? SpanComponentsV3.fromStr(parentStr) : null;
+          const parentComponents = typeof parentStr === "string" ? SpanComponentsV4.fromStr(parentStr) : null;
           const trace = state ? new LocalTrace({
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
@@ -7030,6 +7077,350 @@ var defaultReporter = {
   }
 };
 
+// src/agent-assertions.ts
+function agentAssertionScorer(callback, options = {}) {
+  return async (args) => {
+    const { trace: _trace, ...callbackArgs } = args;
+    const callbackMetadata = callbackArgs.metadata ?? {};
+    const assertions = await callback({
+      ...callbackArgs,
+      metadata: callbackMetadata,
+      assert: agentAssertionHelpers
+    });
+    const resources = {};
+    if (assertions.some((assertion) => assertion.requiresTrace)) {
+      resources.spans = await args.trace?.getSpans({ spanType: ["tool"] });
+    }
+    const results = await Promise.all(
+      assertions.map(async (assertion) => {
+        const result = await assertion.evaluate(resources);
+        return {
+          name: assertion.name,
+          passed: result.passed,
+          failure: result.failure
+        };
+      })
+    );
+    const passed = results.filter((result) => result.passed).length;
+    const total = results.length;
+    const failed = results.filter((result) => !result.passed).map(
+      (result) => `${result.name}: ${result.failure ?? "assertion did not pass"}`
+    );
+    return {
+      name: options.name ?? "assertions",
+      score: total === 0 ? 1 : passed / total,
+      metadata: {
+        assertions: results.map(({ name, passed: passed2 }) => ({ name, passed: passed2 })),
+        failed
+      }
+    };
+  };
+}
+var agentAssertionHelpers = {
+  equals: (actual, expected, name = "equals") => ({
+    name,
+    evaluate: () => {
+      const passed = deepEqual(actual, expected);
+      return {
+        passed,
+        failure: passed ? void 0 : `expected ${formatValue(actual)} to equal ${formatValue(expected)}`
+      };
+    }
+  }),
+  notEquals: (actual, expected, name = "not equals") => ({
+    name,
+    evaluate: () => {
+      const passed = !deepEqual(actual, expected);
+      return {
+        passed,
+        failure: passed ? void 0 : `expected ${formatValue(actual)} not to equal ${formatValue(expected)}`
+      };
+    }
+  }),
+  contains: (value, expected, name = "contains") => ({
+    name,
+    evaluate: () => {
+      const searchedValue = typeof value === "string" ? value : formatValue(value);
+      const passed = expected instanceof RegExp ? testRegex(expected, value) : searchedValue.includes(expected);
+      return {
+        passed,
+        failure: passed ? void 0 : `expected ${formatValue(value)} to contain ${formatValue(expected)}`
+      };
+    }
+  }),
+  matches: (value, schema, name = "matches schema") => ({
+    name,
+    evaluate: async () => {
+      const result = await validateSchema(schema, value);
+      return {
+        passed: result.passed,
+        failure: result.passed ? void 0 : `expected value to match schema: ${result.message}`
+      };
+    }
+  }),
+  calledTool: (toolName, options = {}, name = `called tool ${toolName}`) => ({
+    name,
+    requiresTrace: true,
+    evaluate: ({ spans }) => {
+      const calls = matchingToolCalls(spans ?? [], toolName, options);
+      const passed = options.times === void 0 ? calls.length > 0 : calls.length === options.times;
+      return {
+        passed,
+        failure: passed ? void 0 : options.times === void 0 ? `expected tool "${toolName}" to be called; found ${calls.length} matching call${calls.length === 1 ? "" : "s"}` : `expected tool "${toolName}" to be called ${options.times} time${options.times === 1 ? "" : "s"}; found ${calls.length} matching call${calls.length === 1 ? "" : "s"}`
+      };
+    }
+  }),
+  notCalledTool: (toolName, name = `did not call tool ${toolName}`) => ({
+    name,
+    requiresTrace: true,
+    evaluate: ({ spans }) => {
+      const calls = toolCalls(spans ?? []).filter(
+        (span) => getToolName(span) === toolName
+      );
+      const passed = calls.length === 0;
+      return {
+        passed,
+        failure: passed ? void 0 : `expected tool "${toolName}" not to be called; found ${calls.length} call${calls.length === 1 ? "" : "s"}`
+      };
+    }
+  }),
+  toolOrder: (toolNames, name = "tool order") => ({
+    name,
+    requiresTrace: true,
+    evaluate: ({ spans }) => {
+      const observed = toolCalls(spans ?? []).map(getToolName).filter((toolName) => toolName !== void 0);
+      let fromIndex = 0;
+      const passed = toolNames.every((toolName) => {
+        const index = observed.indexOf(toolName, fromIndex);
+        if (index === -1) return false;
+        fromIndex = index + 1;
+        return true;
+      });
+      return {
+        passed,
+        failure: passed ? void 0 : `expected tool order ${toolNames.join(" -> ")}; observed ${observed.join(" -> ") || "no tools"}`
+      };
+    }
+  }),
+  usedNoTools: (name = "used no tools") => ({
+    name,
+    requiresTrace: true,
+    evaluate: ({ spans }) => {
+      const calls = toolCalls(spans ?? []);
+      const passed = calls.length === 0;
+      return {
+        passed,
+        failure: passed ? void 0 : `expected no tool calls; found ${calls.length}`
+      };
+    }
+  }),
+  maxToolCalls: (max, name = `at most ${max} tool calls`) => ({
+    name,
+    requiresTrace: true,
+    evaluate: ({ spans }) => {
+      const calls = toolCalls(spans ?? []);
+      const passed = calls.length <= max;
+      return {
+        passed,
+        failure: passed ? void 0 : `expected at most ${max} tool call${max === 1 ? "" : "s"}; found ${calls.length}`
+      };
+    }
+  })
+};
+async function validateSchema(schema, value) {
+  try {
+    if ("safeParse" in schema) {
+      const result2 = schema.safeParse(value);
+      return result2.success ? { passed: true, message: "" } : { passed: false, message: formatSchemaError(result2.error) };
+    }
+    if ("parse" in schema) {
+      schema.parse(value);
+      return { passed: true, message: "" };
+    }
+    const result = await schema["~standard"].validate(value);
+    if (typeof result === "object" && result !== null && "issues" in result && Array.isArray(result.issues) && result.issues.length > 0) {
+      return { passed: false, message: formatValue(result.issues) };
+    }
+    return { passed: true, message: "" };
+  } catch (e) {
+    return { passed: false, message: formatSchemaError(e) };
+  }
+}
+function toolCalls(spans) {
+  return spans.filter((span) => span.span_attributes?.type === "tool");
+}
+function matchingToolCalls(spans, toolName, options) {
+  return toolCalls(spans).filter((span) => {
+    if (getToolName(span) !== toolName) return false;
+    if (Object.prototype.hasOwnProperty.call(options, "input") && !matchesValue(span.input, options.input)) {
+      return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(options, "output") && !matchesValue(span.output, options.output)) {
+      return false;
+    }
+    if (options.isError !== void 0 && Boolean(span.error) !== options.isError) {
+      return false;
+    }
+    return true;
+  });
+}
+function getToolName(span) {
+  const spanName = [span.span_attributes?.name, span.name].map(normalizeToolName).find((value) => value !== void 0);
+  if (spanName?.includes("/")) {
+    return spanName;
+  }
+  const metadataName = [
+    span.metadata?.tool_name,
+    span.metadata?.["gen_ai.tool.name"]
+  ].map(normalizeToolName).find((value) => value !== void 0);
+  const mcpServer = [
+    span.metadata?.["mcp.server"],
+    span.metadata?.["openai_codex.mcp.server"]
+  ].find((value) => typeof value === "string" && value !== "");
+  if (metadataName && mcpServer) {
+    return `${mcpServer}/${metadataName}`;
+  }
+  return metadataName ?? spanName;
+}
+function normalizeToolName(value) {
+  if (typeof value !== "string" || value === "") {
+    return void 0;
+  }
+  return value.startsWith("tool:") ? value.slice("tool:".length).trim() : value;
+}
+function matchesValue(actual, matcher) {
+  if (matcher instanceof RegExp) {
+    return testRegex(matcher, actual);
+  }
+  if (typeof matcher === "function") {
+    return matcher(actual);
+  }
+  if (Array.isArray(matcher)) {
+    return Array.isArray(actual) && actual.length === matcher.length && matcher.every((value, index) => matchesValue(actual[index], value));
+  }
+  if (isPlainObject(matcher) && isPlainObject(actual)) {
+    return Object.entries(matcher).every(
+      ([key, value]) => Object.prototype.hasOwnProperty.call(actual, key) && matchesValue(actual[key], value)
+    );
+  }
+  return deepEqual(actual, matcher);
+}
+function testRegex(matcher, value) {
+  matcher.lastIndex = 0;
+  return matcher.test(typeof value === "string" ? value : formatValue(value));
+}
+function deepEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((item, index) => deepEqual(item, right[index]));
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every(
+      (key) => Object.prototype.hasOwnProperty.call(right, key) && deepEqual(left[key], right[key])
+    );
+  }
+  return false;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function formatSchemaError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return formatValue(error);
+}
+function formatValue(value) {
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized !== void 0 && !hasUndefinedJsonValue(value)) {
+      return serialized;
+    }
+    return formatValueWithUndefined(value, /* @__PURE__ */ new Set());
+  } catch {
+    return String(value);
+  }
+}
+function hasUndefinedJsonValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === void 0) {
+    return true;
+  }
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (seen.has(value)) {
+    return false;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return Array.from({ length: value.length }).some(
+      (_, index) => hasUndefinedJsonValue(value[index], seen)
+    );
+  }
+  return Object.keys(value).some(
+    (key) => hasUndefinedJsonValue(value[key], seen)
+  );
+}
+function formatValueWithUndefined(value, seen) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint" || typeof value === "function") {
+    return String(value);
+  }
+  if (typeof value === "symbol") {
+    return String(value);
+  }
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (typeof value !== "object") {
+    return String(value);
+  }
+  if (seen.has(value)) {
+    return '"[Circular]"';
+  }
+  seen.add(value);
+  if (typeof value.toJSON === "function") {
+    const jsonValue = value.toJSON();
+    seen.delete(value);
+    return formatValueWithUndefined(jsonValue, seen);
+  }
+  if (Array.isArray(value)) {
+    const formatted2 = Array.from(
+      { length: value.length },
+      (_, index) => formatValueWithUndefined(value[index], seen)
+    );
+    seen.delete(value);
+    return `[${formatted2.join(",")}]`;
+  }
+  const formatted = Object.keys(value).map(
+    (key) => `${JSON.stringify(key)}:${formatValueWithUndefined(
+      value[key],
+      seen
+    )}`
+  );
+  seen.delete(value);
+  return `{${formatted.join(",")}}`;
+}
+
 // src/dataset-pipeline.ts
 function DatasetPipeline(definition) {
   if (!globalThis.__braintrust_dataset_pipelines) {
@@ -7606,8 +7997,10 @@ configureNode();
 export {
   Attachment,
   AttachmentReference,
+  BAGGAGE_HEADER,
   BRAINTRUST_CURRENT_SPAN_STORE,
   BRAINTRUST_LANGCHAIN_CALLBACK_HANDLER_NAME,
+  BRAINTRUST_PARENT_KEY,
   BaseAttachment,
   BaseExperiment,
   BraintrustLangChainCallbackHandler,
@@ -7640,6 +8033,7 @@ export {
   NOOP_SPAN,
   NOOP_SPAN_PERMALINK,
   NoopSpan,
+  OTELIDGenerator,
   ObjectFetcher,
   Project2 as Project,
   ProjectNameIdMap,
@@ -7651,6 +8045,8 @@ export {
   ScorerBuilder,
   SpanFetcher,
   SpanImpl,
+  TRACEPARENT_HEADER,
+  TRACESTATE_HEADER,
   TestBackgroundLogger,
   ToolBuilder,
   UUIDGenerator,
@@ -7660,6 +8056,7 @@ export {
   isomorph_default as _internalIso,
   _internalSetInitialState,
   addAzureBlobHeaders,
+  agentAssertionScorer,
   braintrustAISDKTelemetry,
   braintrustFlueInstrumentation,
   braintrustFlueObserver,
@@ -7678,6 +8075,7 @@ export {
   devNullWritableStream,
   evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema,
+  extractTraceContextFromHeaders,
   flush,
   getContextManager,
   getIdGenerator,
@@ -7691,6 +8089,7 @@ export {
   initFunction,
   initLogger,
   initNodeTestSuite,
+  injectTraceContext,
   invoke,
   isTemplateFormat,
   loadParameters,