braintrust 3.20.0 → 3.21.0

package/dist/edge-light.js

@@ -32,8 +32,10 @@ var edge_light_exports = {};
 __export(edge_light_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,
@@ -66,6 +68,7 @@ __export(edge_light_exports, {
   NOOP_SPAN: () => NOOP_SPAN,
   NOOP_SPAN_PERMALINK: () => NOOP_SPAN_PERMALINK,
   NoopSpan: () => NoopSpan,
+  OTELIDGenerator: () => OTELIDGenerator,
   ObjectFetcher: () => ObjectFetcher,
   Project: () => Project2,
   ProjectNameIdMap: () => ProjectNameIdMap,
@@ -77,6 +80,8 @@ __export(edge_light_exports, {
   ScorerBuilder: () => ScorerBuilder,
   SpanFetcher: () => SpanFetcher,
   SpanImpl: () => SpanImpl,
+  TRACEPARENT_HEADER: () => TRACEPARENT_HEADER,
+  TRACESTATE_HEADER: () => TRACESTATE_HEADER,
   TestBackgroundLogger: () => TestBackgroundLogger,
   ToolBuilder: () => ToolBuilder,
   UUIDGenerator: () => UUIDGenerator,
@@ -86,6 +91,7 @@ __export(edge_light_exports, {
   _internalIso: () => isomorph_default,
   _internalSetInitialState: () => _internalSetInitialState,
   addAzureBlobHeaders: () => addAzureBlobHeaders,
+  agentAssertionScorer: () => agentAssertionScorer,
   braintrustAISDKTelemetry: () => braintrustAISDKTelemetry,
   braintrustFlueInstrumentation: () => braintrustFlueInstrumentation,
   braintrustFlueObserver: () => braintrustFlueObserver,
@@ -104,6 +110,7 @@ __export(edge_light_exports, {
   devNullWritableStream: () => devNullWritableStream,
   evaluatorDefinitionSchema: () => evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema: () => evaluatorDefinitionsSchema,
+  extractTraceContextFromHeaders: () => extractTraceContextFromHeaders,
   flush: () => flush,
   getContextManager: () => getContextManager,
   getIdGenerator: () => getIdGenerator,
@@ -117,6 +124,7 @@ __export(edge_light_exports, {
   initFunction: () => initFunction,
   initLogger: () => initLogger,
   initNodeTestSuite: () => initNodeTestSuite,
+  injectTraceContext: () => injectTraceContext,
   invoke: () => invoke,
   isTemplateFormat: () => isTemplateFormat,
   loadParameters: () => loadParameters,
@@ -155,7 +163,7 @@ __export(edge_light_exports, {
   traced: () => traced,
   updateSpan: () => updateSpan,
   uploadLogs3OverflowPayload: () => uploadLogs3OverflowPayload,
-  utf8ByteLength: () => utf8ByteLength,
+  utf8ByteLength: () => utf8ByteLength2,
   withCurrent: () => withCurrent,
   withDataset: () => withDataset,
   withExperiment: () => withExperiment,
@@ -470,8 +478,291 @@ var UUIDGenerator = class extends IDGenerator {
     return true;
   }
 };
+function generateHexId(bytes) {
+  let result = "";
+  for (let i = 0; i < bytes; i++) {
+    result += Math.floor(Math.random() * 256).toString(16).padStart(2, "0");
+  }
+  return result;
+}
+var OTELIDGenerator = class extends IDGenerator {
+  getSpanId() {
+    return generateHexId(8);
+  }
+  getTraceId() {
+    return generateHexId(16);
+  }
+  shareRootSpanId() {
+    return false;
+  }
+};
+function parseEnvBool(name) {
+  const raw = isomorph_default.getEnv(name);
+  if (raw === void 0 || raw === null) {
+    return false;
+  }
+  const normalized = raw.trim().toLowerCase();
+  return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "y" || normalized === "on";
+}
+var _warnedLegacyUuidConflict = false;
+function resolveUseLegacyUuidIds() {
+  const legacy = parseEnvBool("BRAINTRUST_LEGACY_IDS");
+  if (parseEnvBool("BRAINTRUST_OTEL_COMPAT")) {
+    if (legacy && !_warnedLegacyUuidConflict) {
+      _warnedLegacyUuidConflict = true;
+      debugLogger.warn(
+        "BRAINTRUST_LEGACY_IDS is ignored because BRAINTRUST_OTEL_COMPAT requires OpenTelemetry-compatible hex span IDs. Using hex IDs."
+      );
+    }
+    return false;
+  }
+  return legacy;
+}
 function getIdGenerator() {
-  return globalThis.BRAINTRUST_ID_GENERATOR !== void 0 ? new globalThis.BRAINTRUST_ID_GENERATOR() : new UUIDGenerator();
+  if (globalThis.BRAINTRUST_ID_GENERATOR !== void 0) {
+    return new globalThis.BRAINTRUST_ID_GENERATOR();
+  }
+  return resolveUseLegacyUuidIds() ? new UUIDGenerator() : new OTELIDGenerator();
+}
+
+// src/propagation.ts
+var TRACEPARENT_HEADER = "traceparent";
+var TRACESTATE_HEADER = "tracestate";
+var BAGGAGE_HEADER = "baggage";
+var BRAINTRUST_PARENT_KEY = "braintrust.parent";
+var DEFAULT_TRACE_FLAGS = "01";
+var TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+var ZERO_TRACE_ID = "0".repeat(32);
+var ZERO_SPAN_ID = "0".repeat(16);
+var MAX_BAGGAGE_LENGTH = 8192;
+var MAX_BAGGAGE_MEMBERS = 64;
+var _utf8Encoder = new TextEncoder();
+function utf8ByteLength(value) {
+  return _utf8Encoder.encode(value).length;
+}
+function capBaggageToMemberBoundary(value) {
+  const totalBytes = utf8ByteLength(value);
+  const withinBytes = totalBytes <= MAX_BAGGAGE_LENGTH;
+  let commaCount = 0;
+  for (let i = 0; i < value.length; i++) {
+    if (value.charCodeAt(i) === 44) {
+      commaCount++;
+    }
+  }
+  const withinMembers = commaCount < MAX_BAGGAGE_MEMBERS;
+  if (withinBytes && withinMembers) {
+    return value;
+  }
+  const kept = [];
+  let length = 0;
+  for (const rawMember of value.split(",")) {
+    if (kept.length >= MAX_BAGGAGE_MEMBERS) {
+      break;
+    }
+    const cost = utf8ByteLength(rawMember) + (kept.length ? 1 : 0);
+    if (length + cost > MAX_BAGGAGE_LENGTH) {
+      break;
+    }
+    kept.push(rawMember);
+    length += cost;
+  }
+  if (!kept.length) {
+    return "";
+  }
+  return kept.join(",");
+}
+function isTraceContextHeaderTupleArray(value) {
+  return Array.isArray(value) && value.every(
+    (item) => Array.isArray(item) && typeof item[0] === "string" && typeof item[1] === "string"
+  );
+}
+function isListHeader(name) {
+  const lowered = name.toLowerCase();
+  return lowered === BAGGAGE_HEADER || lowered === TRACESTATE_HEADER;
+}
+function headerValueToString(value, name) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const stringValues = value.filter((item) => {
+      return typeof item === "string";
+    });
+    if (!stringValues.length) {
+      return void 0;
+    }
+    return isListHeader(name) ? stringValues.join(",") : stringValues[0];
+  }
+  return typeof value === "string" ? value : String(value);
+}
+function getHeader(headers, name) {
+  if (!headers) {
+    return void 0;
+  }
+  if (isTraceContextHeaderTupleArray(headers)) {
+    const lowered2 = name.toLowerCase();
+    const matches = headers.filter(([key]) => key.toLowerCase() === lowered2).map(([, value]) => value);
+    if (!matches.length) {
+      return void 0;
+    }
+    return headerValueToString(matches, name);
+  }
+  const getter = headers.get;
+  if (typeof getter === "function") {
+    try {
+      const value = headerValueToString(getter.call(headers, name), name);
+      if (value !== void 0) {
+        return value;
+      }
+    } catch {
+    }
+  }
+  const nodeGetter = headers.getHeader;
+  if (typeof nodeGetter === "function") {
+    try {
+      const value = headerValueToString(nodeGetter.call(headers, name), name);
+      if (value !== void 0) {
+        return value;
+      }
+    } catch {
+    }
+  }
+  const headerBag = headers;
+  const exact = headerValueToString(headerBag[name], name);
+  if (exact !== void 0) {
+    return exact;
+  }
+  const lowered = name.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    if (key !== name && key.toLowerCase() === lowered) {
+      const value = headerValueToString(headerBag[key], name);
+      if (value !== void 0) {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
+function isHex(value, length) {
+  if (typeof value !== "string" || value.length !== length) {
+    return false;
+  }
+  for (let i = 0; i < value.length; i++) {
+    const c = value[i];
+    const isDigit = c >= "0" && c <= "9";
+    const isLowerHex = c >= "a" && c <= "f";
+    if (!isDigit && !isLowerHex) {
+      return false;
+    }
+  }
+  return true;
+}
+function parseTraceparent(value) {
+  if (!value || typeof value !== "string") {
+    return void 0;
+  }
+  const match = TRACEPARENT_RE.exec(value.trim());
+  if (!match) {
+    return void 0;
+  }
+  const traceId = match[1];
+  const spanId = match[2];
+  const traceFlags = match[3];
+  if (traceId === ZERO_TRACE_ID || spanId === ZERO_SPAN_ID) {
+    return void 0;
+  }
+  return { traceId, spanId, traceFlags };
+}
+function formatTraceparent(traceId, spanId, traceFlags = DEFAULT_TRACE_FLAGS) {
+  if (!isHex(traceId, 32) || traceId === ZERO_TRACE_ID) {
+    return void 0;
+  }
+  if (!isHex(spanId, 16) || spanId === ZERO_SPAN_ID) {
+    return void 0;
+  }
+  const flags = isHex(traceFlags, 2) ? traceFlags : DEFAULT_TRACE_FLAGS;
+  return `00-${traceId}-${spanId}-${flags}`;
+}
+function percentEncode(value) {
+  return encodeURIComponent(value);
+}
+function percentDecode(value) {
+  if (!value.includes("%")) {
+    return value;
+  }
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseBaggage(value) {
+  const result = {};
+  if (!value || typeof value !== "string") {
+    return result;
+  }
+  const bounded = capBaggageToMemberBoundary(value);
+  for (let member of bounded.split(",")) {
+    member = member.trim();
+    if (!member || !member.includes("=")) {
+      continue;
+    }
+    member = member.split(";", 1)[0];
+    const eq = member.indexOf("=");
+    const key = percentDecode(member.slice(0, eq).trim());
+    const val = member.slice(eq + 1).trim();
+    if (!key) {
+      continue;
+    }
+    result[key] = percentDecode(val);
+  }
+  return result;
+}
+function mergeBaggage(existing, braintrustParent) {
+  let btMember = void 0;
+  if (braintrustParent) {
+    const encodedKey = percentEncode(BRAINTRUST_PARENT_KEY);
+    const encodedVal = percentEncode(String(braintrustParent));
+    btMember = `${encodedKey}=${encodedVal}`;
+    if (utf8ByteLength(btMember) > MAX_BAGGAGE_LENGTH) {
+      btMember = void 0;
+    }
+  }
+  let byteBudget = MAX_BAGGAGE_LENGTH;
+  let memberBudget = MAX_BAGGAGE_MEMBERS;
+  if (btMember !== void 0) {
+    byteBudget -= utf8ByteLength(btMember) + 1;
+    memberBudget -= 1;
+  }
+  const relayed = [];
+  let length = 0;
+  if (existing && typeof existing === "string") {
+    for (const rawMember of existing.split(",")) {
+      const member = rawMember.trim();
+      if (!member || !member.includes("=")) {
+        continue;
+      }
+      const keyPart = member.split(";", 1)[0].split("=", 1)[0];
+      const key = percentDecode(keyPart.trim());
+      if (key === BRAINTRUST_PARENT_KEY) {
+        continue;
+      }
+      if (relayed.length >= memberBudget) {
+        break;
+      }
+      const cost = utf8ByteLength(member) + (relayed.length ? 1 : 0);
+      if (length + cost > byteBudget) {
+        break;
+      }
+      relayed.push(member);
+      length += cost;
+    }
+  }
+  const members = btMember !== void 0 ? [...relayed, btMember] : relayed;
+  if (!members.length) {
+    return void 0;
+  }
+  return members.join(",");
 }
 
 // util/db_fields.ts
@@ -1079,7 +1370,7 @@ var SpanComponentsV3 = class _SpanComponentsV3 {
       case 3 /* PLAYGROUND_LOGS */:
         return { prompt_session_id: this.data.object_id, log_id: "x" };
       default:
-        const _ = this.data.object_type;
+        this.data.object_type;
         throw new Error("Impossible");
     }
   }
@@ -1608,7 +1899,7 @@ var SpanComponentsV4 = class _SpanComponentsV4 {
       case 3 /* PLAYGROUND_LOGS */:
         return { prompt_session_id: this.data.object_id, log_id: "x" };
       default:
-        const _ = this.data.object_type;
+        this.data.object_type;
         throw new Error(`Invalid object_type ${this.data.object_type}`);
     }
   }
@@ -1787,7 +2078,8 @@ var AclObjectType = import_v36.z.union([
     "role",
     "org_member",
     "project_log",
-    "org_project"
+    "org_project",
+    "org_audit_logs"
   ]),
   import_v36.z.null()
 ]);
@@ -1813,6 +2105,17 @@ var Acl = import_v36.z.object({
   _object_org_id: import_v36.z.string().uuid(),
   created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
 });
+var Agent = import_v36.z.object({
+  id: import_v36.z.string().uuid(),
+  project_id: import_v36.z.string().uuid(),
+  user_id: import_v36.z.string().uuid(),
+  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  name: import_v36.z.string(),
+  slug: import_v36.z.string(),
+  kind: import_v36.z.string(),
+  description: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  metadata: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional()
+});
 var AISecret = import_v36.z.object({
   id: import_v36.z.string().uuid(),
   created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
@@ -1959,6 +2262,7 @@ var AttachmentStatus = import_v36.z.object({
   upload_status: UploadStatus,
   error_message: import_v36.z.string().optional()
 });
+var AutomationStatus = import_v36.z.enum(["active", "paused"]);
 var FunctionTypeEnum = import_v36.z.enum([
   "llm",
   "scorer",
@@ -2004,7 +2308,9 @@ var TopicMapData = import_v36.z.object({
   topic_names: import_v36.z.record(import_v36.z.string()).optional(),
   generation_settings: TopicMapGenerationSettings.optional(),
   disable_reconciliation: import_v36.z.boolean().optional(),
-  distance_threshold: import_v36.z.number().optional()
+  distance_threshold: import_v36.z.number().optional(),
+  btql_filter: import_v36.z.string().optional(),
+  automation_btql_filter: import_v36.z.string().optional()
 });
 var BatchedFacetData = import_v36.z.object({
   type: import_v36.z.literal("batched_facet"),
@@ -2287,7 +2593,7 @@ var DatasetEvent = import_v36.z.object({
   origin: ObjectReferenceNullish.optional(),
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
-  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  facets: import_v36.z.union([import_v36.z.record(import_v36.z.union([import_v36.z.string(), import_v36.z.null()])), import_v36.z.null()]).optional(),
   classifications: import_v36.z.union([
     import_v36.z.record(
       import_v36.z.array(
@@ -2439,7 +2745,7 @@ var ExperimentEvent = import_v36.z.object({
   origin: ObjectReferenceNullish.optional(),
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
-  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  facets: import_v36.z.union([import_v36.z.record(import_v36.z.union([import_v36.z.string(), import_v36.z.null()])), import_v36.z.null()]).optional(),
   classifications: import_v36.z.union([
     import_v36.z.record(
       import_v36.z.array(
@@ -2577,7 +2883,8 @@ var PromptParserNullish = import_v36.z.union([
     use_cot: import_v36.z.boolean(),
     choice_scores: import_v36.z.record(import_v36.z.number().gte(0).lte(1)).optional(),
     choice: import_v36.z.array(import_v36.z.string()).optional(),
-    allow_no_match: import_v36.z.boolean().optional()
+    allow_no_match: import_v36.z.boolean().optional(),
+    allow_skip: import_v36.z.boolean().optional()
   }),
   import_v36.z.null()
 ]);
@@ -2907,6 +3214,9 @@ var Group = import_v36.z.object({
 var GroupScope = import_v36.z.object({
   type: import_v36.z.literal("group"),
   group_by: import_v36.z.string(),
+  interval_seconds: import_v36.z.number().gte(1).optional(),
+  max_traces: import_v36.z.number().int().gte(1).lte(64).optional(),
+  placement: import_v36.z.enum(["first", "each"]),
   idle_seconds: import_v36.z.number().optional()
 });
 var IfExists = import_v36.z.enum(["error", "ignore", "replace"]);
@@ -3055,6 +3365,10 @@ var RetentionObjectType = import_v36.z.enum([
   "experiment",
   "dataset"
 ]);
+var TopicAutomationFacetModel = import_v36.z.union([
+  import_v36.z.enum(["brain-facet-latest", "brain-facet-1", "brain-facet-2"]),
+  import_v36.z.null()
+]);
 var TopicMapFunctionAutomation = import_v36.z.object({
   function: SavedFunctionId.and(import_v36.z.unknown()),
   btql_filter: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
@@ -3067,7 +3381,9 @@ var TopicAutomationDataScope = import_v36.z.union([
 ]);
 var TopicAutomationConfig = import_v36.z.object({
   event_type: import_v36.z.literal("topic"),
+  status: AutomationStatus.optional(),
   sampling_rate: import_v36.z.number().gte(0).lte(1),
+  facet_model: TopicAutomationFacetModel.optional(),
   facet_functions: import_v36.z.array(SavedFunctionId),
   topic_map_functions: import_v36.z.array(TopicMapFunctionAutomation),
   scope: import_v36.z.union([SpanScope, TraceScope, GroupScope, import_v36.z.null()]).optional(),
@@ -3081,6 +3397,19 @@ var TopicAutomationConfig = import_v36.z.object({
     import_v36.z.null()
   ]).optional()
 });
+var TopicDigestAutomationConfig = import_v36.z.object({
+  event_type: import_v36.z.literal("topic_digest"),
+  status: AutomationStatus.optional(),
+  window_seconds: import_v36.z.number().int().gte(3600).lte(2592e3).optional().default(86400),
+  scheduled_time_minutes_utc: import_v36.z.number().int().gte(0).lte(1439),
+  action: import_v36.z.object({
+    type: import_v36.z.literal("slack"),
+    workspace_id: import_v36.z.string(),
+    channel: import_v36.z.string(),
+    message_template: import_v36.z.string().optional()
+  }),
+  topic_map_function_ids: import_v36.z.array(import_v36.z.string()).max(10).optional()
+});
 var ProjectAutomation = import_v36.z.object({
   id: import_v36.z.string().uuid(),
   project_id: import_v36.z.string().uuid(),
@@ -3105,6 +3434,7 @@ var ProjectAutomation = import_v36.z.object({
     }),
     import_v36.z.object({
       event_type: import_v36.z.literal("btql_export"),
+      status: AutomationStatus.optional(),
       export_definition: import_v36.z.union([
         import_v36.z.object({ type: import_v36.z.literal("log_traces") }),
         import_v36.z.object({ type: import_v36.z.literal("log_spans") }),
@@ -3127,6 +3457,21 @@ var ProjectAutomation = import_v36.z.object({
       ]),
       batch_size: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional()
     }),
+    import_v36.z.object({
+      event_type: import_v36.z.literal("async_query"),
+      status: AutomationStatus.optional(),
+      created_by_user_id: import_v36.z.string().uuid(),
+      object_type: import_v36.z.enum([
+        "project_logs",
+        "experiment",
+        "dataset",
+        "playground_logs"
+      ]),
+      object_id: import_v36.z.string(),
+      query: import_v36.z.string(),
+      format: import_v36.z.literal("jsonl"),
+      batch_size: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional()
+    }),
     import_v36.z.object({
       event_type: import_v36.z.literal("retention"),
       object_type: RetentionObjectType,
@@ -3145,7 +3490,8 @@ var ProjectAutomation = import_v36.z.object({
         })
       ])
     }),
-    TopicAutomationConfig
+    TopicAutomationConfig,
+    TopicDigestAutomationConfig
   ])
 });
 var ProjectLogsEvent = import_v36.z.object({
@@ -3184,7 +3530,7 @@ var ProjectLogsEvent = import_v36.z.object({
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   _async_scoring_state: import_v36.z.unknown().optional(),
-  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  facets: import_v36.z.union([import_v36.z.record(import_v36.z.union([import_v36.z.string(), import_v36.z.null()])), import_v36.z.null()]).optional(),
   classifications: import_v36.z.union([
     import_v36.z.record(
       import_v36.z.array(
@@ -3233,11 +3579,34 @@ var ProjectScoreCategories = import_v36.z.union([
   import_v36.z.array(import_v36.z.string()),
   import_v36.z.null()
 ]);
+var ProjectScoreCondition = import_v36.z.union([
+  import_v36.z.object({
+    when: import_v36.z.object({
+      clauses: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()]),
+      subspan_clauses: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()]),
+      trace_clauses: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()])
+    }).partial(),
+    behavior: import_v36.z.literal("hidden").optional().default("hidden")
+  }),
+  import_v36.z.null()
+]);
 var ProjectScoreConfig = import_v36.z.union([
   import_v36.z.object({
     multi_select: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
     destination: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
-    online: OnlineScoreConfig
+    visibility: import_v36.z.union([
+      import_v36.z.object({
+        users: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()]),
+        groups: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()])
+      }).partial(),
+      import_v36.z.null()
+    ]),
+    online: OnlineScoreConfig,
+    condition: ProjectScoreCondition,
+    object_types: import_v36.z.union([
+      import_v36.z.array(import_v36.z.enum(["project_logs", "dataset", "experiment"])),
+      import_v36.z.null()
+    ])
   }).partial(),
   import_v36.z.null()
 ]);
@@ -3422,8 +3791,7 @@ var User = import_v36.z.object({
   family_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   email: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   avatar_url: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
-  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
-  last_active_at: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional()
+  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
 });
 var ViewDataSearch = import_v36.z.union([
   import_v36.z.object({
@@ -4710,7 +5078,10 @@ var BraintrustContextManager = class extends ContextManager {
   }
 };
 function getSpanComponentsClass() {
-  return globalThis.BRAINTRUST_SPAN_COMPONENT ? globalThis.BRAINTRUST_SPAN_COMPONENT : SpanComponentsV3;
+  if (globalThis.BRAINTRUST_SPAN_COMPONENT) {
+    return globalThis.BRAINTRUST_SPAN_COMPONENT;
+  }
+  return resolveUseLegacyUuidIds() ? SpanComponentsV3 : SpanComponentsV4;
 }
 function getContextManager() {
   return globalThis.BRAINTRUST_CONTEXT_MANAGER ? new globalThis.BRAINTRUST_CONTEXT_MANAGER() : new BraintrustContextManager();
@@ -4746,6 +5117,9 @@ var NoopSpan = class {
   async export() {
     return "";
   }
+  inject(carrier) {
+    return carrier ?? {};
+  }
   async permalink() {
     return NOOP_SPAN_PERMALINK;
   }
@@ -4796,6 +5170,10 @@ var loginSchema = import_v38.z.strictObject({
   debugLogLevelDisabled: import_v38.z.boolean().optional()
 });
 var stateNonce = 0;
+var V1_PROXY_SUFFIX = "/v1/proxy";
+function normalizeProxyConnUrl(proxyUrl) {
+  return proxyUrl.endsWith(V1_PROXY_SUFFIX) ? proxyUrl.slice(0, proxyUrl.length - V1_PROXY_SUFFIX.length) : proxyUrl;
+}
 var BraintrustState = class _BraintrustState {
   constructor(loginParams) {
     this.loginParams = loginParams;
@@ -5066,7 +5444,10 @@ var BraintrustState = class _BraintrustState {
       if (!this.proxyUrl) {
         throw new Error("Must initialize proxyUrl before requesting proxyConn");
       }
-      this._proxyConn = new HTTPConnection(this.proxyUrl, this.fetch);
+      this._proxyConn = new HTTPConnection(
+        normalizeProxyConnUrl(this.proxyUrl),
+        this.fetch
+      );
     }
     return this._proxyConn;
   }
@@ -5824,7 +6205,7 @@ function updateSpan({
   ...event
 }) {
   const resolvedState = state ?? _globalState;
-  const components = getSpanComponentsClass().fromStr(exported);
+  const components = SpanComponentsV4.fromStr(exported);
   if (!components.data.row_id) {
     throw new Error("Exported span must have a row id");
   }
@@ -5924,7 +6305,7 @@ async function permalink(slug, opts) {
     return state.appUrl;
   };
   try {
-    const components = getSpanComponentsClass().fromStr(slug);
+    const components = SpanComponentsV4.fromStr(slug);
     const object_type = spanObjectTypeV3ToString(components.data.object_type);
     const [orgName, appUrl, object_id] = await Promise.all([
       getOrgName(),
@@ -5948,35 +6329,47 @@ function startSpanParentArgs(args) {
   let argParentObjectId = void 0;
   let argParentSpanIds = void 0;
   let argPropagatedEvent = void 0;
-  if (args.parent) {
+  let argPropagatedState = void 0;
+  const { parentSlug, propagatedState: parentPropagatedState } = normalizeParent(args.parent, args.state);
+  if (parentSlug) {
     if (args.parentSpanIds) {
       throw new Error("Cannot specify both parent and parentSpanIds");
     }
-    const parentComponents = getSpanComponentsClass().fromStr(args.parent);
+    const parentComponents = SpanComponentsV4.fromStr(parentSlug);
     if (args.parentObjectType !== parentComponents.data.object_type) {
       throw new Error(
         `Mismatch between expected span parent object type ${args.parentObjectType} and provided type ${parentComponents.data.object_type}`
       );
     }
     argParentObjectId = args.parentObjectId;
-    if (parentComponents.data.row_id) {
+    if (parentComponents.data.row_id && parentSpanIdsUsable(
+      parentComponents.data.span_id,
+      parentComponents.data.root_span_id
+    )) {
       argParentSpanIds = {
         spanId: parentComponents.data.span_id,
         rootSpanId: parentComponents.data.root_span_id
       };
     }
     argPropagatedEvent = args.propagatedEvent ?? (parentComponents.data.propagated_event ?? void 0);
+    const propagatedState = args.propagatedState ?? parentPropagatedState;
+    if (propagatedState) {
+      const { braintrustParent: _ignoredBraintrustParent, ...w3cState } = propagatedState;
+      argPropagatedState = w3cState;
+    }
   } else {
     argParentObjectId = args.parentObjectId;
     argParentSpanIds = args.parentSpanIds;
     argPropagatedEvent = args.propagatedEvent;
+    argPropagatedState = args.propagatedState;
   }
   return {
     parentObjectType: args.parentObjectType,
     parentObjectId: argParentObjectId,
     parentComputeObjectMetadataArgs: args.parentComputeObjectMetadataArgs,
     parentSpanIds: argParentSpanIds,
-    propagatedEvent: argPropagatedEvent
+    propagatedEvent: argPropagatedEvent,
+    propagatedState: argPropagatedState
   };
 }
 var Logger = class {
@@ -6177,6 +6570,22 @@ var Logger = class {
   _getLinkBaseUrl() {
     return _getLinkBaseUrl(this.state, this._linkArgs);
   }
+  /**
+   * Return this logger's Braintrust parent string (`project_id:<id>` or
+   * `project_name:<name>`) for the `braintrust.parent` baggage entry, or
+   * undefined when it cannot be determined synchronously.
+   */
+  _getOtelParent() {
+    const id = this.computeMetadataArgs?.project_id || this.lazyId.getSync().value;
+    if (id) {
+      return `project_id:${id}`;
+    }
+    const name = this.computeMetadataArgs?.project_name;
+    if (name) {
+      return `project_name:${name}`;
+    }
+    return void 0;
+  }
 };
 function castLogger(logger, asyncFlush) {
   if (logger === void 0) return void 0;
@@ -6271,12 +6680,12 @@ function stringifyWithOverflowMeta(item) {
       object_ids: pickLogs3OverflowObjectIds(record),
       is_delete: record[OBJECT_DELETE_FIELD] === true,
       input_row: {
-        byte_size: utf8ByteLength(str)
+        byte_size: utf8ByteLength2(str)
       }
     }
   };
 }
-function utf8ByteLength(value) {
+function utf8ByteLength2(value) {
   if (typeof TextEncoder !== "undefined") {
     return new TextEncoder().encode(value).length;
   }
@@ -6664,7 +7073,7 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
   }) {
     const conn = await this.apiConn.get();
     const dataStr = constructLogs3Data(items);
-    const payloadBytes = utf8ByteLength(dataStr);
+    const payloadBytes = utf8ByteLength2(dataStr);
     const useOverflow = canUseOverflow && payloadBytes > maxRequestSize;
     if (this.allPublishPayloadsDir) {
       await _HTTPBackgroundLogger.writePayloadToDir({
@@ -7285,6 +7694,8 @@ function initDataset(projectOrOptions, optionalOptions) {
   const normalizedVersion = selection.version;
   const normalizedEnvironment = selection.environment;
   const normalizedSnapshotName = selection.snapshotName;
+  const cliInternalBtql = globalThis.__bt_eval_internal_btql;
+  const internalBtql = cliInternalBtql === void 0 ? _internal_btql : _internal_btql === void 0 ? cliInternalBtql : isObject(_internal_btql) ? { ...cliInternalBtql, ..._internal_btql } : _internal_btql;
   const state = stateArg ?? _globalState;
   const lazyMetadata = new LazyValue(
     async () => {
@@ -7336,7 +7747,7 @@ function initDataset(projectOrOptions, optionalOptions) {
     lazyMetadata,
     typeof resolvedVersion === "string" ? resolvedVersion : void 0,
     legacy,
-    _internal_btql,
+    internalBtql,
     resolvedVersion instanceof LazyValue || normalizedEnvironment !== void 0 || normalizedSnapshotName !== void 0 ? {
       ...resolvedVersion instanceof LazyValue ? {
         lazyPinnedVersion: resolvedVersion
@@ -7800,23 +8211,285 @@ function currentSpan(options) {
   const state = options?.state ?? _globalState;
   return state.contextManager.getCurrentSpan() ?? NOOP_SPAN;
 }
-function getSpanParentObject(options) {
+function getSpanParentObjectAndPropagatedState(options) {
   const state = options?.state ?? _globalState;
   const parentSpan = currentSpan({ state });
   if (!Object.is(parentSpan, NOOP_SPAN)) {
-    return parentSpan;
+    return { parentObject: parentSpan, propagatedState: void 0 };
+  }
+  const parent = options?.parent ?? state.currentParent.getStore();
+  const { parentSlug, propagatedState } = normalizeParent(parent, state);
+  if (parentSlug) {
+    return {
+      parentObject: SpanComponentsV4.fromStr(parentSlug),
+      propagatedState
+    };
   }
-  const parentStr = options?.parent ?? state.currentParent.getStore();
-  if (parentStr) return getSpanComponentsClass().fromStr(parentStr);
   const experiment = currentExperiment();
   if (experiment) {
-    return experiment;
+    return { parentObject: experiment, propagatedState: void 0 };
   }
   const logger = currentLogger(options);
   if (logger) {
-    return logger;
+    return { parentObject: logger, propagatedState: void 0 };
+  }
+  return { parentObject: NOOP_SPAN, propagatedState: void 0 };
+}
+function getSpanParentObject(options) {
+  return getSpanParentObjectAndPropagatedState(options).parentObject;
+}
+function currentBraintrustParent(state) {
+  const resolvedState = state ?? _globalState;
+  const experiment = currentExperiment({ state: resolvedState });
+  if (experiment) {
+    try {
+      return experiment._getOtelParent() ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  const logger = currentLogger({ state: resolvedState });
+  if (logger) {
+    try {
+      return logger._getOtelParent() ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function braintrustParentToComponents(braintrustParent) {
+  if (!braintrustParent) {
+    return void 0;
+  }
+  if (braintrustParent.startsWith("project_id:")) {
+    const objectId = braintrustParent.slice("project_id:".length);
+    return objectId ? {
+      objectType: 2 /* PROJECT_LOGS */,
+      objectId,
+      computeArgs: void 0
+    } : void 0;
+  }
+  if (braintrustParent.startsWith("project_name:")) {
+    const name = braintrustParent.slice("project_name:".length);
+    return name ? {
+      objectType: 2 /* PROJECT_LOGS */,
+      objectId: void 0,
+      computeArgs: { project_name: name }
+    } : void 0;
+  }
+  if (braintrustParent.startsWith("experiment_id:")) {
+    const objectId = braintrustParent.slice("experiment_id:".length);
+    return objectId ? {
+      objectType: 1 /* EXPERIMENT */,
+      objectId,
+      computeArgs: void 0
+    } : void 0;
+  }
+  return void 0;
+}
+function isMutableHeaderTupleArray(carrier) {
+  return Array.isArray(carrier) && carrier.every((item) => Array.isArray(item) && typeof item[0] === "string");
+}
+function setHeader(carrier, name, value) {
+  if (isMutableHeaderTupleArray(carrier)) {
+    const lowered2 = name.toLowerCase();
+    for (let i = carrier.length - 1; i >= 0; i--) {
+      if (carrier[i][0].toLowerCase() === lowered2) {
+        carrier.splice(i, 1);
+      }
+    }
+    carrier.push([name, value]);
+    return;
+  }
+  const setter = carrier.set;
+  if (typeof setter === "function") {
+    const deleter = carrier.delete;
+    if (typeof deleter === "function") {
+      try {
+        deleter.call(carrier, name);
+      } catch {
+      }
+    }
+    setter.call(carrier, name, value);
+    return;
+  }
+  const nodeSetter = carrier.setHeader;
+  if (typeof nodeSetter === "function") {
+    const remover = carrier.removeHeader;
+    if (typeof remover === "function") {
+      try {
+        remover.call(carrier, name);
+      } catch {
+      }
+    }
+    nodeSetter.call(carrier, name, value);
+    return;
+  }
+  const headerSetter = carrier.header;
+  if (typeof headerSetter === "function") {
+    const deleter = carrier.delete;
+    if (typeof deleter === "function") {
+      try {
+        deleter.call(carrier, name);
+      } catch {
+      }
+    }
+    const remover = carrier.removeHeader;
+    if (typeof remover === "function") {
+      try {
+        remover.call(carrier, name);
+      } catch {
+      }
+    }
+    headerSetter.call(carrier, name, value);
+    return;
+  }
+  const headerBag = carrier;
+  const lowered = name.toLowerCase();
+  for (const key of Object.keys(headerBag)) {
+    if (key !== name && key.toLowerCase() === lowered) {
+      delete headerBag[key];
+    }
+  }
+  headerBag[name] = value;
+}
+function deleteHeader(carrier, name) {
+  const lowered = name.toLowerCase();
+  if (isMutableHeaderTupleArray(carrier)) {
+    for (let i = carrier.length - 1; i >= 0; i--) {
+      if (carrier[i][0].toLowerCase() === lowered) {
+        carrier.splice(i, 1);
+      }
+    }
+    return;
+  }
+  const deleter = carrier.delete;
+  if (typeof deleter === "function") {
+    try {
+      deleter.call(carrier, name);
+      return;
+    } catch {
+    }
+  }
+  const remover = carrier.removeHeader;
+  if (typeof remover === "function") {
+    try {
+      remover.call(carrier, name);
+      return;
+    } catch {
+    }
   }
-  return NOOP_SPAN;
+  const headerBag = carrier;
+  for (const key of Object.keys(headerBag)) {
+    if (key.toLowerCase() === lowered) {
+      delete headerBag[key];
+    }
+  }
+}
+function _injectIntoCarrier(carrier, args) {
+  const traceFlags = args.propagatedState?.traceFlags;
+  const traceparent = traceFlags ? formatTraceparent(args.traceId, args.spanId, traceFlags) : formatTraceparent(args.traceId, args.spanId);
+  if (traceparent === void 0) {
+    return;
+  }
+  setHeader(carrier, TRACEPARENT_HEADER, traceparent);
+  const tracestate = args.propagatedState?.tracestate;
+  if (tracestate) {
+    setHeader(carrier, TRACESTATE_HEADER, tracestate);
+  }
+  const existing = getHeader(carrier, BAGGAGE_HEADER);
+  const baggageValue = mergeBaggage(existing, args.braintrustParent);
+  if (baggageValue !== void 0) {
+    setHeader(carrier, BAGGAGE_HEADER, baggageValue);
+  } else if (existing !== void 0) {
+    deleteHeader(carrier, BAGGAGE_HEADER);
+  }
+}
+function injectTraceContext(carrier, options) {
+  const resolvedCarrier = carrier ?? {};
+  const span = options?.span ?? currentSpan({ state: options?.state });
+  try {
+    return span.inject(resolvedCarrier);
+  } catch (e) {
+    debugLogger.warn(`Error injecting trace context: ${e}`);
+    return resolvedCarrier;
+  }
+}
+function extractTraceContextFromHeaders(headers) {
+  if (!headers) {
+    return void 0;
+  }
+  const traceparent = getHeader(headers, TRACEPARENT_HEADER);
+  if (!traceparent || parseTraceparent(traceparent) === void 0) {
+    return void 0;
+  }
+  const context = { [TRACEPARENT_HEADER]: traceparent };
+  const baggageValue = getHeader(headers, BAGGAGE_HEADER);
+  if (baggageValue) {
+    context[BAGGAGE_HEADER] = baggageValue;
+  }
+  const tracestate = getHeader(headers, TRACESTATE_HEADER);
+  if (tracestate) {
+    context[TRACESTATE_HEADER] = tracestate;
+  }
+  return context;
+}
+function resolveW3cParent(context, state) {
+  const traceparent = getHeader(context, TRACEPARENT_HEADER);
+  const parsed = traceparent ? parseTraceparent(traceparent) : void 0;
+  if (parsed === void 0) {
+    return { parentSlug: void 0, propagatedState: void 0 };
+  }
+  const { traceId, spanId, traceFlags } = parsed;
+  let braintrustParent = void 0;
+  const baggageValue = getHeader(context, BAGGAGE_HEADER);
+  if (baggageValue) {
+    braintrustParent = parseBaggage(baggageValue)[BRAINTRUST_PARENT_KEY];
+  }
+  if (!braintrustParent) {
+    braintrustParent = currentBraintrustParent(state);
+  }
+  if (!braintrustParent) {
+    debugLogger.warn(
+      "Received traceparent without a braintrust.parent and no active logger/experiment; cannot route the trace. Starting a fresh local span instead."
+    );
+    return { parentSlug: void 0, propagatedState: void 0 };
+  }
+  const parsedParent = braintrustParentToComponents(braintrustParent);
+  if (parsedParent === void 0) {
+    debugLogger.warn(
+      `Invalid braintrust.parent: ${JSON.stringify(braintrustParent)}`
+    );
+    return { parentSlug: void 0, propagatedState: void 0 };
+  }
+  const { objectType, objectId, computeArgs } = parsedParent;
+  const tracestate = getHeader(context, TRACESTATE_HEADER);
+  const slug = new SpanComponentsV4({
+    object_type: objectType,
+    ...computeArgs ? { compute_object_metadata_args: computeArgs } : { object_id: objectId },
+    row_id: "bt-propagation",
+    // non-empty to enable span_id/root_span_id
+    span_id: spanId,
+    root_span_id: traceId
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  }).toStr();
+  return {
+    parentSlug: slug,
+    propagatedState: { tracestate, traceFlags, braintrustParent }
+  };
+}
+function normalizeParent(parent, state) {
+  if (parent && typeof parent === "object") {
+    return resolveW3cParent(parent, state);
+  }
+  return {
+    parentSlug: parent ?? void 0,
+    propagatedState: void 0
+  };
+}
+function parentSpanIdsUsable(spanId, rootSpanId) {
+  return Boolean(spanId) && Boolean(rootSpanId);
 }
 function logError(span, error) {
   let errorMessage = "<error>";
@@ -8024,19 +8697,23 @@ function setFetch(fetch2) {
 }
 function startSpanAndIsLogger(args) {
   const state = args?.state ?? _globalState;
-  const parentObject = getSpanParentObject({
+  const { parentObject, propagatedState } = getSpanParentObjectAndPropagatedState({
     asyncFlush: args?.asyncFlush,
     parent: args?.parent,
     state
   });
   if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
-    const parentSpanIds = parentObject.data.row_id ? {
+    const parentSpanIds = parentObject.data.row_id && parentSpanIdsUsable(
+      parentObject.data.span_id,
+      parentObject.data.root_span_id
+    ) ? {
       spanId: parentObject.data.span_id,
       rootSpanId: parentObject.data.root_span_id
     } : void 0;
+    const { parent: _ignoredParent, ...spanArgs } = args ?? {};
     const span = new SpanImpl({
       state,
-      ...args,
+      ...spanArgs,
       parentObjectType: parentObject.data.object_type,
       parentObjectId: new LazyValue(
         spanComponentsToObjectIdLambda(state, parentObject)
@@ -8044,7 +8721,8 @@ function startSpanAndIsLogger(args) {
       parentComputeObjectMetadataArgs: parentObject.data.compute_object_metadata_args ?? void 0,
       parentSpanIds,
       propagatedEvent: args?.propagatedEvent ?? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      (parentObject.data.propagated_event ?? void 0)
+      (parentObject.data.propagated_event ?? void 0),
+      propagatedState
     });
     return {
       span,
@@ -8333,11 +9011,12 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
 var DEFAULT_FETCH_BATCH_SIZE = 1e3;
 var MAX_BTQL_ITERATIONS = 1e4;
 var ObjectFetcher = class {
-  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {
+  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql, _internalBrainstoreRealtime = true) {
     this.objectType = objectType;
     this.pinnedVersion = pinnedVersion;
     this.mutateRecord = mutateRecord;
     this._internal_btql = _internal_btql;
+    this._internalBrainstoreRealtime = _internalBrainstoreRealtime;
   }
   _fetchedData = void 0;
   get id() {
@@ -8396,7 +9075,7 @@ var ObjectFetcher = class {
             ...internalBtqlWithoutReservedQueryKeys
           },
           use_columnstore: false,
-          brainstore_realtime: true,
+          brainstore_realtime: this._internalBrainstoreRealtime,
           query_source: `js_sdk_object_fetcher_${this.objectType}`,
           ...this.pinnedVersion !== void 0 ? {
             version: this.pinnedVersion
@@ -8745,6 +9424,15 @@ View complete results in Braintrust or run experiment.summarize() again.`
       object_id: await this.id
     }).toStr();
   }
+  /**
+   * Return this experiment's Braintrust parent string (`experiment_id:<id>`) for
+   * the `braintrust.parent` baggage entry, or undefined when it cannot be
+   * determined synchronously.
+   */
+  _getOtelParent() {
+    const id = this.lazyId.getSync().value;
+    return id ? `experiment_id:${id}` : void 0;
+  }
   /**
    * Flush any pending rows to the server.
    */
@@ -8787,7 +9475,8 @@ var ReadonlyExperiment = class extends ObjectFetcher {
   async *asDataset(options) {
     const records = this.fetch(options);
     for await (const record of records) {
-      if (record.root_span_id !== record.span_id) {
+      const isRoot = record.is_root ?? record.root_span_id === record.span_id;
+      if (!isRoot) {
         continue;
       }
       const { output, expected: expectedRecord, metadata } = record;
@@ -8849,9 +9538,16 @@ var SpanImpl = class _SpanImpl {
   _spanId;
   _rootSpanId;
   _spanParents;
+  // Inbound W3C trace-context state (tracestate + raw traceparent flags) to
+  // forward on outbound propagation. Captured at the span that received it (via
+  // extractTraceContextFromHeaders) and inherited by all subspans, so that any
+  // inject() within the trace re-emits the upstream state unchanged, per the W3C
+  // Trace Context spec. Not interpreted.
+  _propagatedState;
   kind = "span";
   constructor(args) {
     this._state = args.state;
+    this._propagatedState = args.propagatedState;
     const spanAttributes = args.spanAttributes ?? {};
     const rawEvent = args.event ?? {};
     const type = args.type ?? (args.parentSpanIds ? void 0 : args.defaultRootType);
@@ -8967,7 +9663,7 @@ var SpanImpl = class _SpanImpl {
         tags: partialRecord.tags,
         span_id: this._spanId,
         span_parents: this._spanParents,
-        is_root: this._spanId === this._rootSpanId,
+        is_root: !this._spanParents || this._spanParents.length === 0,
         span_attributes: partialRecord.span_attributes
       };
       this._state.spanCache.queueWrite(
@@ -9029,7 +9725,8 @@ var SpanImpl = class _SpanImpl {
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: args?.propagatedEvent ?? this.propagatedEvent
+        propagatedEvent: args?.propagatedEvent ?? this.propagatedEvent,
+        propagatedState: this._propagatedState
       })
     });
   }
@@ -9048,7 +9745,8 @@ var SpanImpl = class _SpanImpl {
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: args?.propagatedEvent ?? this.propagatedEvent
+        propagatedEvent: args?.propagatedEvent ?? this.propagatedEvent,
+        propagatedState: this._propagatedState
       }),
       spanId
     });
@@ -9076,6 +9774,42 @@ var SpanImpl = class _SpanImpl {
       propagated_event: this.propagatedEvent
     }).toStr();
   }
+  /**
+   * Return this span's Braintrust parent string (`project_id:<id>`,
+   * `project_name:<name>`, or `experiment_id:<id>`) for the `braintrust.parent`
+   * baggage entry, or undefined when it cannot be determined synchronously.
+   */
+  _getOtelParent() {
+    if (this.parentObjectType === 2 /* PROJECT_LOGS */) {
+      const id = this.parentComputeObjectMetadataArgs?.project_id || this.parentObjectId.getSync().value;
+      const name = this.parentComputeObjectMetadataArgs?.project_name;
+      if (id) {
+        return `project_id:${id}`;
+      } else if (name) {
+        return `project_name:${name}`;
+      }
+    } else if (this.parentObjectType === 1 /* EXPERIMENT */) {
+      const id = this.parentComputeObjectMetadataArgs?.experiment_id || this.parentObjectId.getSync().value;
+      if (id) {
+        return `experiment_id:${id}`;
+      }
+    }
+    return void 0;
+  }
+  inject(carrier) {
+    const resolvedCarrier = carrier ?? {};
+    try {
+      _injectIntoCarrier(resolvedCarrier, {
+        traceId: this._rootSpanId,
+        spanId: this._spanId,
+        braintrustParent: this._getOtelParent() ?? this._propagatedState?.braintrustParent,
+        propagatedState: this._propagatedState
+      });
+    } catch (e) {
+      debugLogger.warn(`Error injecting trace context: ${e}`);
+    }
+    return resolvedCarrier;
+  }
   async permalink() {
     return await permalink(await this.export(), {
       state: this._state
@@ -9211,6 +9945,7 @@ var Dataset2 = class extends ObjectFetcher {
       _internal_btql
     );
     this.state = state;
+    void this.__braintrust_dataset_marker;
     this.lazyMetadata = lazyMetadata;
     this.lazyPinnedVersion = pinState?.lazyPinnedVersion;
     this.pinnedEnvironment = pinState?.pinnedEnvironment;
@@ -9728,6 +10463,7 @@ var Prompt2 = class _Prompt {
     this.metadata = metadata;
     this.defaults = defaults;
     this.noTrace = noTrace;
+    void this.__braintrust_prompt_marker;
   }
   parsedPromptData;
   hasParsedPromptData = false;
@@ -9964,6 +10700,7 @@ var Prompt2 = class _Prompt {
 var RemoteEvalParameters = class {
   constructor(metadata) {
     this.metadata = metadata;
+    void this.__braintrust_parameters_marker;
   }
   __braintrust_parameters_marker = true;
   get id() {
@@ -10100,6 +10837,7 @@ var _exportsForTestingOnly = {
   isAsyncGeneratorFunction,
   resetIdGenStateForTests,
   validateTags,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   isomorph: isomorph_default
   // Expose isomorph for build type detection
 };
@@ -11051,6 +11789,22 @@ function runStreamingCompletionHook(args) {
     );
   }
 }
+function runStreamingErrorHook(args) {
+  if (!args.config.onError) {
+    return;
+  }
+  try {
+    args.config.onError({
+      channelName: args.channelName,
+      error: args.error,
+      event: args.event,
+      span: args.span,
+      startTime: args.startTime
+    });
+  } catch (error) {
+    debugLogger.error(`Error in onError hook for ${args.channelName}:`, error);
+  }
+}
 function traceAsyncChannel(channel2, config) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
@@ -11212,6 +11966,14 @@ function traceStreamingChannel(channel2, config) {
             }
           },
           onError: (error) => {
+            runStreamingErrorHook({
+              channelName,
+              config,
+              error,
+              event: asyncEndEvent,
+              span,
+              startTime
+            });
             span.log({
               error: error.message
             });
@@ -11269,6 +12031,17 @@ function traceStreamingChannel(channel2, config) {
       }
     },
     error: (event) => {
+      const spanData = states.get(event);
+      if (spanData) {
+        runStreamingErrorHook({
+          channelName,
+          config,
+          error: event.error,
+          event,
+          span: spanData.span,
+          startTime: spanData.startTime
+        });
+      }
       logErrorAndEnd(states, event);
     }
   };
@@ -13631,14 +14404,45 @@ function serializeAISDKToolsForLogging(tools) {
   return serialized;
 }
 
+// src/vendor-sdk-types/ai-sdk-v7-telemetry.ts
+var BRAINTRUST_AI_SDK_V7_OPERATION_KEY = /* @__PURE__ */ Symbol.for(
+  "braintrust.ai-sdk.v7.telemetry-operation-key"
+);
+
+// src/wrappers/ai-sdk/workflow-agent-context.ts
+var workflowAgentWrapperSpans = /* @__PURE__ */ new Map();
+function registerWorkflowAgentWrapperSpan(span) {
+  if (span.spanId) {
+    workflowAgentWrapperSpans.set(span.spanId, span);
+  }
+}
+function unregisterWorkflowAgentWrapperSpan(span) {
+  if (span.spanId) {
+    workflowAgentWrapperSpans.delete(span.spanId);
+  }
+}
+function currentWorkflowAgentWrapperSpan() {
+  const parentSpanIds = _internalGetGlobalState().contextManager.getParentSpanIds()?.spanParents ?? [];
+  for (const parentSpanId of parentSpanIds) {
+    const span = workflowAgentWrapperSpans.get(parentSpanId);
+    if (span) {
+      return span;
+    }
+  }
+  return void 0;
+}
+
 // src/wrappers/ai-sdk/telemetry.ts
 function braintrustAISDKTelemetry() {
   const operations = /* @__PURE__ */ new Map();
+  const operationKeysByCallId = /* @__PURE__ */ new Map();
+  const workflowOperationKeyStore = isomorph_default.newAsyncLocalStorage();
   const modelSpans = /* @__PURE__ */ new Map();
   const objectSpans = /* @__PURE__ */ new Map();
   const embedSpans = /* @__PURE__ */ new Map();
   const rerankSpans = /* @__PURE__ */ new Map();
   const toolSpans = /* @__PURE__ */ new Map();
+  let workflowAgentOperationCounter = 0;
   const runSafely = (name, callback) => {
     try {
       callback();
@@ -13646,42 +14450,333 @@ function braintrustAISDKTelemetry() {
       console.error(`Error in Braintrust AI SDK telemetry ${name}:`, error);
     }
   };
-  const startChildSpan = (callId, name, type, event) => {
-    const parent = operations.get(callId)?.span;
+  const startChildSpan = (operationKey, name, type, event) => {
+    const parent = operations.get(operationKey)?.span;
     const spanArgs = {
       name,
       spanAttributes: { type },
       ...event ? { event } : {}
     };
     const span = parent ? parent.startSpan(spanArgs) : startSpan(spanArgs);
-    const state = operations.get(callId);
+    const state = operations.get(operationKey);
     if (state && type === "llm" /* LLM */) {
       state.hadModelChild = true;
     }
     return span;
   };
+  const registerOperation = (state) => {
+    operations.set(state.operationKey, state);
+    const keys = operationKeysByCallId.get(state.callId) ?? [];
+    keys.push(state.operationKey);
+    operationKeysByCallId.set(state.callId, keys);
+  };
+  const deleteOperation = (operationKey) => {
+    const state = operations.get(operationKey);
+    if (!state) {
+      return;
+    }
+    operations.delete(operationKey);
+    if (workflowOperationKeyStore.getStore() === operationKey) {
+      workflowOperationKeyStore.enterWith(void 0);
+    }
+    const keys = operationKeysByCallId.get(state.callId);
+    if (!keys) {
+      return;
+    }
+    const index = keys.indexOf(operationKey);
+    if (index >= 0) {
+      keys.splice(index, 1);
+    }
+    if (keys.length === 0) {
+      operationKeysByCallId.delete(state.callId);
+    }
+  };
+  const explicitOperationKey = (event) => {
+    if (!isObject(event)) {
+      return void 0;
+    }
+    const key = event[BRAINTRUST_AI_SDK_V7_OPERATION_KEY];
+    return typeof key === "string" ? key : void 0;
+  };
+  const createOperationKey = (event, operationName) => {
+    const explicit = explicitOperationKey(event);
+    if (explicit) {
+      return explicit;
+    }
+    if (operationName === "WorkflowAgent.stream") {
+      workflowAgentOperationCounter += 1;
+      return `${event.callId}:${workflowAgentOperationCounter}`;
+    }
+    return event.callId;
+  };
+  const operationKeyForCallId = (callId, mode = "active") => {
+    const keys = operationKeysByCallId.get(callId);
+    if (!keys || keys.length === 0) {
+      return operations.has(callId) ? callId : void 0;
+    }
+    if (keys.length === 1) {
+      return keys[0];
+    }
+    const wrapperSpan = currentWorkflowAgentWrapperSpan();
+    if (wrapperSpan?.spanId) {
+      const key = keys.find(
+        (candidate) => operations.get(candidate)?.span.spanId === wrapperSpan.spanId
+      );
+      if (key) {
+        return key;
+      }
+    }
+    const workflowOperationKey = workflowOperationKeyStore.getStore();
+    if (workflowOperationKey && keys.includes(workflowOperationKey)) {
+      return workflowOperationKey;
+    }
+    if (callId === "workflow-agent") {
+      return void 0;
+    }
+    return mode === "finish" ? keys[0] : keys[keys.length - 1];
+  };
+  const operationKeyFromEvent = (event, mode = "active") => {
+    const explicit = explicitOperationKey(event);
+    if (explicit && operations.has(explicit)) {
+      return explicit;
+    }
+    if (isObject(event)) {
+      const callId = event.callId;
+      if (typeof callId === "string") {
+        const operationKey = operationKeyForCallId(callId, mode);
+        if (operationKey) {
+          return operationKey;
+        }
+        const workflowOperationKey2 = workflowOperationKeyStore.getStore();
+        if (workflowOperationKey2 && operations.has(workflowOperationKey2)) {
+          return workflowOperationKey2;
+        }
+        return callId === "workflow-agent" ? void 0 : callId;
+      }
+    }
+    const workflowOperationKey = workflowOperationKeyStore.getStore();
+    if (workflowOperationKey && operations.has(workflowOperationKey)) {
+      return workflowOperationKey;
+    }
+    const wrapperSpan = currentWorkflowAgentWrapperSpan();
+    if (wrapperSpan?.spanId) {
+      for (const [operationKey, state] of operations) {
+        if (state.operationName === "WorkflowAgent.stream" && state.span.spanId === wrapperSpan.spanId) {
+          return operationKey;
+        }
+      }
+    }
+    const workflowAgentKeys = operationKeysByCallId.get("workflow-agent");
+    if (workflowAgentKeys?.length === 1) {
+      return workflowAgentKeys[0];
+    }
+    if (operations.size === 1) {
+      return operations.keys().next().value;
+    }
+    return void 0;
+  };
+  const closeOpenChildSpans = (operationKey, error) => {
+    const openModelSpans = modelSpans.get(operationKey);
+    if (openModelSpans) {
+      for (const span of openModelSpans) {
+        if (error !== void 0) {
+          logError(span, error);
+        }
+        span.end();
+      }
+      modelSpans.delete(operationKey);
+    }
+    const openObjectSpan = objectSpans.get(operationKey);
+    if (openObjectSpan) {
+      if (error !== void 0) {
+        logError(openObjectSpan, error);
+      }
+      openObjectSpan.end();
+      objectSpans.delete(operationKey);
+    }
+    for (const [embedCallId, embedState] of embedSpans) {
+      if (embedState.operationKey === operationKey) {
+        if (error !== void 0) {
+          logError(embedState.span, error);
+        }
+        embedState.span.end();
+        embedSpans.delete(embedCallId);
+      }
+    }
+    const openRerankSpan = rerankSpans.get(operationKey);
+    if (openRerankSpan) {
+      if (error !== void 0) {
+        logError(openRerankSpan, error);
+      }
+      openRerankSpan.end();
+      rerankSpans.delete(operationKey);
+    }
+    for (const [toolCallId, toolState] of toolSpans) {
+      if (toolState.operationKey === operationKey) {
+        if (error !== void 0) {
+          logError(toolState.span, error);
+        }
+        toolState.span.end();
+        toolSpans.delete(toolCallId);
+      }
+    }
+  };
+  const abortReasonFromEvent = (event) => {
+    if (isObject(event)) {
+      const abortEvent = event;
+      if (abortEvent.error !== void 0) {
+        return abortEvent.error;
+      }
+      if (abortEvent.reason !== void 0) {
+        return abortEvent.reason;
+      }
+    }
+    return new Error("AI SDK operation aborted");
+  };
+  const shouldSkipTelemetryChildren = (state) => state?.operationName === "WorkflowAgent.stream" && !state.ownsSpan;
+  const onObjectStepEnd = (event) => {
+    runSafely("onObjectStepEnd", () => {
+      const operationKey = operationKeyFromEvent(event);
+      const span = operationKey ? objectSpans.get(operationKey) : void 0;
+      if (!operationKey || !span) {
+        return;
+      }
+      const result = {
+        ...event,
+        text: event.objectText
+      };
+      span.log({
+        ...shouldRecordOutputs(event) ? {
+          output: processAISDKOutput(result, DEFAULT_DENY_OUTPUT_PATHS)
+        } : {},
+        metrics: extractTokenMetrics(result)
+      });
+      span.end();
+      objectSpans.delete(operationKey);
+    });
+  };
+  const onEmbedEnd = (event) => {
+    runSafely("onEmbedEnd", () => {
+      const state = embedSpans.get(event.embedCallId);
+      if (!state) {
+        return;
+      }
+      const result = {
+        ...event,
+        embeddings: event.embeddings
+      };
+      state.span.log({
+        ...shouldRecordOutputs(event) ? {
+          output: processAISDKEmbeddingOutput(
+            result,
+            DEFAULT_DENY_OUTPUT_PATHS
+          )
+        } : {},
+        metrics: extractTokenMetrics(result)
+      });
+      state.span.end();
+      embedSpans.delete(event.embedCallId);
+    });
+  };
+  const onRerankEnd = (event) => {
+    runSafely("onRerankEnd", () => {
+      const operationKey = operationKeyFromEvent(event);
+      const span = operationKey ? rerankSpans.get(operationKey) : void 0;
+      if (!operationKey || !span) {
+        return;
+      }
+      const result = {
+        ranking: event.ranking?.map((entry) => ({
+          originalIndex: entry.index,
+          score: entry.relevanceScore
+        }))
+      };
+      span.log({
+        ...shouldRecordOutputs(event) ? {
+          output: processAISDKRerankOutput(
+            result,
+            DEFAULT_DENY_OUTPUT_PATHS
+          )
+        } : {}
+      });
+      span.end();
+      rerankSpans.delete(operationKey);
+    });
+  };
+  const onEnd = (event) => {
+    runSafely("onEnd", () => {
+      const operationKey = operationKeyFromEvent(event, "finish");
+      const state = operationKey ? operations.get(operationKey) : void 0;
+      if (!state) {
+        return;
+      }
+      if (!state.ownsSpan) {
+        deleteOperation(state.operationKey);
+        return;
+      }
+      const result = finishResult(event, state.operationName);
+      const metrics = state.hadModelChild ? {} : extractTokenMetrics(result);
+      const timeToFirstToken = state.operationName === "WorkflowAgent.stream" ? void 0 : extractTimeToFirstToken(result, state);
+      if (timeToFirstToken !== void 0) {
+        metrics.time_to_first_token = timeToFirstToken;
+      }
+      state.span.log({
+        ...shouldRecordOutputs(event) ? {
+          output: finishOutput(result, state.operationName)
+        } : {},
+        metrics
+      });
+      state.span.end();
+      deleteOperation(state.operationKey);
+    });
+  };
   return {
     onStart(event) {
       runSafely("onStart", () => {
         const operationName = operationNameFromId(event.operationId);
-        const span = startSpan({
+        const workflowAgent = operationName === "WorkflowAgent.stream";
+        const wrapperSpan = workflowAgent ? currentWorkflowAgentWrapperSpan() : void 0;
+        const ownsSpan = !wrapperSpan;
+        const span = ownsSpan ? startSpan({
           name: operationName,
           spanAttributes: { type: "function" /* FUNCTION */ }
-        });
-        operations.set(event.callId, {
+        }) : wrapperSpan;
+        const operationKey = createOperationKey(event, operationName);
+        registerOperation({
+          callId: event.callId,
           hadModelChild: false,
+          loggedInput: false,
           operationName,
+          operationKey,
+          ownsSpan,
           span,
           startTime: getCurrentUnixTimestamp()
         });
-        const metadata = metadataFromEvent(event);
+        if (!ownsSpan) {
+          return;
+        }
+        if (workflowAgent) {
+          workflowOperationKeyStore.enterWith(operationKey);
+        }
+        let metadata = metadataFromEvent(event);
         const logPayload = { metadata };
+        const workflowAgentCallInput = workflowAgent ? operationInput(event, operationName) : void 0;
+        if (workflowAgentCallInput) {
+          metadata = {
+            ...metadata,
+            ...extractWorkflowMetadataFromCallParams(workflowAgentCallInput)
+          };
+          logPayload.metadata = metadata;
+        }
         if (shouldRecordInputs(event)) {
-          const { input, outputPromise } = processAISDKCallInput(
-            operationInput(event, operationName)
-          );
+          const callInput = workflowAgentCallInput ?? operationInput(event, operationName);
+          const { input, outputPromise } = workflowAgent ? processAISDKWorkflowAgentCallInput(callInput) : processAISDKCallInput(callInput);
           logPayload.input = input;
-          if (outputPromise && input && typeof input === "object") {
+          const state = operations.get(operationKey);
+          if (state) {
+            state.loggedInput = hasPromptLikeInput(input);
+          }
+          if (outputPromise && !workflowAgent && input && typeof input === "object") {
             outputPromise.then((resolvedData) => {
               span.log({
                 input: {
@@ -13698,41 +14793,67 @@ function braintrustAISDKTelemetry() {
     },
     onLanguageModelCallStart(event) {
       runSafely("onLanguageModelCallStart", () => {
-        const state = operations.get(event.callId);
-        const openSpans = modelSpans.get(event.callId);
-        if (openSpans) {
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
+        const operationName = state?.operationName ?? "generateText";
+        const callInput = operationInput(event, operationName);
+        const workflowAgent = operationName === "WorkflowAgent.stream";
+        const processedInput = shouldRecordInputs(event) && workflowAgent ? processAISDKWorkflowAgentModelCallInput(callInput).input : shouldRecordInputs(event) ? processAISDKCallInput(callInput).input : void 0;
+        if (workflowAgent && state?.ownsSpan && !state.loggedInput && hasPromptLikeInput(processedInput)) {
+          state.span.log({
+            input: processedInput,
+            metadata: {
+              ...metadataFromEvent(event),
+              ...extractWorkflowMetadataFromCallParams(callInput)
+            }
+          });
+          state.loggedInput = true;
+        }
+        const openSpans = operationKey ? modelSpans.get(operationKey) : void 0;
+        if (operationKey && openSpans) {
           for (const span2 of openSpans) {
             span2.end();
           }
-          modelSpans.delete(event.callId);
+          modelSpans.delete(operationKey);
         }
         const span = startChildSpan(
-          event.callId,
-          state?.operationName === "streamText" ? "doStream" : "doGenerate",
+          operationKey ?? event.callId,
+          operationName === "streamText" ? "doStream" : "doGenerate",
           "llm" /* LLM */,
           {
             ...shouldRecordInputs(event) ? {
-              input: processAISDKCallInput(
-                operationInput(
-                  event,
-                  state?.operationName ?? "generateText"
-                )
-              ).input
+              input: processedInput
             } : {},
-            metadata: metadataFromEvent(event)
+            metadata: workflowAgent ? {
+              ...metadataFromEvent(event),
+              ...extractWorkflowMetadataFromCallParams(callInput)
+            } : metadataFromEvent(event)
           }
         );
-        const spans = modelSpans.get(event.callId) ?? [];
+        const spanKey = operationKey ?? event.callId;
+        const spans = modelSpans.get(spanKey) ?? [];
         spans.push(span);
-        modelSpans.set(event.callId, spans);
+        modelSpans.set(spanKey, spans);
       });
     },
     onLanguageModelCallEnd(event) {
       runSafely("onLanguageModelCallEnd", () => {
-        const span = shiftModelSpan(modelSpans, event.callId);
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
+        const span = operationKey ? shiftModelSpan(modelSpans, operationKey) : void 0;
         if (!span) {
           return;
         }
+        const timeToFirstOutputMs = safePerformance(event)?.timeToFirstOutputMs;
+        if (state?.operationName === "streamText" && state.firstChunkTime === void 0 && typeof timeToFirstOutputMs === "number") {
+          state.firstChunkTime = state.startTime + timeToFirstOutputMs / 1e3;
+        }
         const result = {
           ...event,
           response: event.responseId ? { id: event.responseId } : void 0
@@ -13748,14 +14869,18 @@ function braintrustAISDKTelemetry() {
     },
     onObjectStepStart(event) {
       runSafely("onObjectStepStart", () => {
-        const state = operations.get(event.callId);
-        const openSpan = objectSpans.get(event.callId);
-        if (openSpan) {
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
+        const openSpan = operationKey ? objectSpans.get(operationKey) : void 0;
+        if (operationKey && openSpan) {
           openSpan.end();
-          objectSpans.delete(event.callId);
+          objectSpans.delete(operationKey);
         }
         const span = startChildSpan(
-          event.callId,
+          operationKey ?? event.callId,
           state?.operationName === "streamObject" ? "doStream" : "doGenerate",
           "llm" /* LLM */,
           {
@@ -13767,40 +14892,25 @@ function braintrustAISDKTelemetry() {
             metadata: metadataFromEvent(event)
           }
         );
-        objectSpans.set(event.callId, span);
-      });
-    },
-    onObjectStepFinish(event) {
-      runSafely("onObjectStepFinish", () => {
-        const span = objectSpans.get(event.callId);
-        if (!span) {
-          return;
-        }
-        const result = {
-          ...event,
-          text: event.objectText
-        };
-        span.log({
-          ...shouldRecordOutputs(event) ? {
-            output: processAISDKOutput(result, DEFAULT_DENY_OUTPUT_PATHS)
-          } : {},
-          metrics: extractTokenMetrics(result)
-        });
-        span.end();
-        objectSpans.delete(event.callId);
+        objectSpans.set(operationKey ?? event.callId, span);
       });
     },
+    onObjectStepEnd,
     onEmbedStart(event) {
       runSafely("onEmbedStart", () => {
-        const state = operations.get(event.callId);
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
         for (const [embedCallId, embedState] of embedSpans) {
-          if (embedState.callId === event.callId && (state?.operationName === "embed" || embedState.values === event.values)) {
+          if (embedState.operationKey === operationKey && (state?.operationName === "embed" || embedState.values === event.values)) {
             embedState.span.end();
             embedSpans.delete(embedCallId);
           }
         }
         const span = startChildSpan(
-          event.callId,
+          operationKey ?? event.callId,
           "doEmbed",
           "llm" /* LLM */,
           {
@@ -13813,44 +14923,27 @@ function braintrustAISDKTelemetry() {
           }
         );
         embedSpans.set(event.embedCallId, {
-          callId: event.callId,
+          operationKey: operationKey ?? event.callId,
           span,
           values: event.values
         });
       });
     },
-    onEmbedFinish(event) {
-      runSafely("onEmbedFinish", () => {
-        const state = embedSpans.get(event.embedCallId);
-        if (!state) {
-          return;
-        }
-        const result = {
-          ...event,
-          embeddings: event.embeddings
-        };
-        state.span.log({
-          ...shouldRecordOutputs(event) ? {
-            output: processAISDKEmbeddingOutput(
-              result,
-              DEFAULT_DENY_OUTPUT_PATHS
-            )
-          } : {},
-          metrics: extractTokenMetrics(result)
-        });
-        state.span.end();
-        embedSpans.delete(event.embedCallId);
-      });
-    },
+    onEmbedEnd,
     onRerankStart(event) {
       runSafely("onRerankStart", () => {
-        const openSpan = rerankSpans.get(event.callId);
-        if (openSpan) {
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
+        const openSpan = operationKey ? rerankSpans.get(operationKey) : void 0;
+        if (operationKey && openSpan) {
           openSpan.end();
-          rerankSpans.delete(event.callId);
+          rerankSpans.delete(operationKey);
         }
         const span = startChildSpan(
-          event.callId,
+          operationKey ?? event.callId,
           "doRerank",
           "llm" /* LLM */,
           {
@@ -13864,41 +14957,23 @@ function braintrustAISDKTelemetry() {
             metadata: metadataFromEvent(event)
           }
         );
-        rerankSpans.set(event.callId, span);
-      });
-    },
-    onRerankFinish(event) {
-      runSafely("onRerankFinish", () => {
-        const span = rerankSpans.get(event.callId);
-        if (!span) {
-          return;
-        }
-        const result = {
-          ranking: event.ranking?.map((entry) => ({
-            originalIndex: entry.index,
-            score: entry.relevanceScore
-          }))
-        };
-        span.log({
-          ...shouldRecordOutputs(event) ? {
-            output: processAISDKRerankOutput(
-              result,
-              DEFAULT_DENY_OUTPUT_PATHS
-            )
-          } : {}
-        });
-        span.end();
-        rerankSpans.delete(event.callId);
+        rerankSpans.set(operationKey ?? event.callId, span);
       });
     },
+    onRerankEnd,
     onToolExecutionStart(event) {
       runSafely("onToolExecutionStart", () => {
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
         const toolCallId = event.toolCall.toolCallId;
-        if (!toolCallId) {
+        if (!operationKey || !toolCallId) {
           return;
         }
         const span = startChildSpan(
-          event.callId,
+          operationKey,
           event.toolCall.toolName || "tool",
           "tool" /* TOOL */,
           {
@@ -13912,7 +14987,7 @@ function braintrustAISDKTelemetry() {
             }
           }
         );
-        toolSpans.set(toolCallId, { callId: event.callId, span });
+        toolSpans.set(toolCallId, { operationKey, span });
       });
     },
     onToolExecutionEnd(event) {
@@ -13923,14 +14998,17 @@ function braintrustAISDKTelemetry() {
           return;
         }
         const toolOutput = event.toolOutput;
-        if (toolOutput?.type === "tool-error") {
+        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;
           state.span.log({
-            error: toolOutput.error instanceof Error ? toolOutput.error.message : String(toolOutput?.error),
+            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;
           state.span.log({
-            ...shouldRecordOutputs(event) ? { output: toolOutput?.output } : {},
+            ...shouldRecordOutputs(event) ? { output } : {},
             metrics: typeof event.durationMs === "number" ? { duration_ms: event.durationMs } : {}
           });
         }
@@ -13944,83 +15022,46 @@ function braintrustAISDKTelemetry() {
         if (!callId) {
           return;
         }
-        const state = operations.get(callId);
+        const operationKey = operationKeyForCallId(callId);
+        const state = operationKey ? operations.get(operationKey) : void 0;
         if (!state || state.firstChunkTime !== void 0) {
           return;
         }
         state.firstChunkTime = getCurrentUnixTimestamp();
       });
     },
-    onFinish(event) {
-      runSafely("onFinish", () => {
-        const state = operations.get(event.callId);
-        if (!state) {
+    onEnd,
+    onAbort(event) {
+      runSafely("onAbort", () => {
+        const operationKey = operationKeyFromEvent(event, "finish");
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (!operationKey || !state) {
           return;
         }
-        const result = finishResult(event, state.operationName);
-        const metrics = state.hadModelChild ? {} : extractTokenMetrics(result);
-        if (state.firstChunkTime !== void 0) {
-          metrics.time_to_first_token = state.firstChunkTime - state.startTime;
+        const error = abortReasonFromEvent(event);
+        closeOpenChildSpans(operationKey, error);
+        if (state.ownsSpan) {
+          logError(state.span, error);
+          state.span.end();
         }
-        state.span.log({
-          ...shouldRecordOutputs(event) ? {
-            output: finishOutput(result, state.operationName)
-          } : {},
-          metrics
-        });
-        state.span.end();
-        operations.delete(event.callId);
+        deleteOperation(operationKey);
       });
     },
     onError(event) {
       runSafely("onError", () => {
         const errorEvent = isObject(event) ? event : {};
-        const callId = typeof errorEvent.callId === "string" ? errorEvent.callId : void 0;
-        if (!callId) {
-          return;
-        }
-        const state = operations.get(callId);
-        if (!state) {
+        const operationKey = operationKeyFromEvent(errorEvent, "finish");
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (!operationKey || !state) {
           return;
         }
         const error = errorEvent.error ?? event;
-        const openModelSpans = modelSpans.get(callId);
-        if (openModelSpans) {
-          for (const span of openModelSpans) {
-            logError(span, error);
-            span.end();
-          }
-          modelSpans.delete(callId);
-        }
-        const openObjectSpan = objectSpans.get(callId);
-        if (openObjectSpan) {
-          logError(openObjectSpan, error);
-          openObjectSpan.end();
-          objectSpans.delete(callId);
-        }
-        for (const [embedCallId, embedState] of embedSpans) {
-          if (embedState.callId === callId) {
-            logError(embedState.span, error);
-            embedState.span.end();
-            embedSpans.delete(embedCallId);
-          }
-        }
-        const openRerankSpan = rerankSpans.get(callId);
-        if (openRerankSpan) {
-          logError(openRerankSpan, error);
-          openRerankSpan.end();
-          rerankSpans.delete(callId);
-        }
-        for (const [toolCallId, toolState] of toolSpans) {
-          if (toolState.callId === callId) {
-            logError(toolState.span, error);
-            toolState.span.end();
-            toolSpans.delete(toolCallId);
-          }
+        closeOpenChildSpans(operationKey, error);
+        if (state.ownsSpan) {
+          logError(state.span, error);
+          state.span.end();
         }
-        logError(state.span, error);
-        state.span.end();
-        operations.delete(callId);
+        deleteOperation(operationKey);
       });
     },
     executeTool({ toolCallId, execute }) {
@@ -14035,7 +15076,16 @@ function shouldRecordInputs(event) {
 function shouldRecordOutputs(event) {
   return event.recordOutputs !== false;
 }
+function hasPromptLikeInput(input) {
+  if (!isObject(input)) {
+    return false;
+  }
+  return input.prompt !== void 0 || input.messages !== void 0;
+}
 function operationNameFromId(operationId) {
+  if (operationId === "ai.workflowAgent.stream") {
+    return "WorkflowAgent.stream";
+  }
   return operationId?.startsWith("ai.") ? operationId.slice("ai.".length) : operationId || "ai-sdk";
 }
 function modelFromEvent(event) {
@@ -14081,6 +15131,7 @@ function operationInput(event, operationName) {
   }
   return {
     model: modelFromEvent(event),
+    instructions: event.instructions,
     system: event.system,
     prompt: event.prompt,
     messages: event.messages,
@@ -14129,6 +15180,30 @@ function finishResult(event, operationName) {
   }
   return event;
 }
+function extractTimeToFirstToken(result, state) {
+  if (state.firstChunkTime !== void 0) {
+    return state.firstChunkTime - state.startTime;
+  }
+  const performanceCandidates = [
+    safePerformance(result),
+    safePerformance(result.finalStep),
+    ...Array.isArray(result.steps) ? (result.steps ?? []).map(safePerformance) : []
+  ];
+  for (const performance2 of performanceCandidates) {
+    const timeToFirstOutputMs = performance2?.timeToFirstOutputMs;
+    if (typeof timeToFirstOutputMs === "number") {
+      return timeToFirstOutputMs / 1e3;
+    }
+  }
+  return void 0;
+}
+function safePerformance(value) {
+  if (!isObject(value)) {
+    return void 0;
+  }
+  const performance2 = value.performance;
+  return isObject(performance2) ? performance2 : void 0;
+}
 function finishOutput(result, operationName) {
   if (operationName === "embed" || operationName === "embedMany") {
     return processAISDKEmbeddingOutput(
@@ -14205,6 +15280,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "ToolLoopAgent.stream",
     kind: "async"
   }),
+  workflowAgentStream: channel({
+    channelName: "WorkflowAgent.stream",
+    kind: "async"
+  }),
   v7CreateTelemetryDispatcher: channel({
     channelName: "createTelemetryDispatcher",
     kind: "sync-stream"
@@ -14215,14 +15294,19 @@ var aiSDKChannels = defineChannels("ai", {
 var DEFAULT_DENY_OUTPUT_PATHS = [
   // v3
   "roundtrips[].request.body",
+  "roundtrips[].request.headers",
   "roundtrips[].response.headers",
   "rawResponse.headers",
   "responseMessages",
   // v5
   "request.body",
+  "request.headers",
+  "responses[].headers",
   "response.body",
   "response.headers",
   "steps[].request.body",
+  "steps[].request.headers",
+  "steps[].responses[].headers",
   "steps[].response.body",
   "steps[].response.headers"
 ];
@@ -14234,6 +15318,18 @@ var AUTO_PATCHED_V7_TELEMETRY_DISPATCHER = /* @__PURE__ */ Symbol.for(
 var RUNTIME_DENY_OUTPUT_PATHS = /* @__PURE__ */ Symbol.for(
   "braintrust.ai-sdk.deny-output-paths"
 );
+var aiSDKV7TelemetryOperationCounter = 0;
+var TRANSPORT_PAYLOAD_ROOT_PATHS = [
+  "rawResponse",
+  "request",
+  "response",
+  "responses[]",
+  "roundtrips[].request",
+  "roundtrips[].response",
+  "steps[].request",
+  "steps[].response",
+  "steps[].responses[]"
+];
 var AI_SDK_V7_TELEMETRY_CALLBACKS = [
   "onStart",
   "onStepStart",
@@ -14242,14 +15338,16 @@ var AI_SDK_V7_TELEMETRY_CALLBACKS = [
   "onToolExecutionStart",
   "onToolExecutionEnd",
   "onChunk",
+  "onStepEnd",
   "onStepFinish",
   "onObjectStepStart",
-  "onObjectStepFinish",
+  "onObjectStepEnd",
   "onEmbedStart",
-  "onEmbedFinish",
+  "onEmbedEnd",
   "onRerankStart",
-  "onRerankFinish",
-  "onFinish",
+  "onRerankEnd",
+  "onEnd",
+  "onAbort",
   "onError"
 ];
 var AISDKPlugin = class extends BasePlugin {
@@ -14407,7 +15505,9 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.agentGenerate, {
         name: "Agent.generate",
         type: "function" /* FUNCTION */,
-        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths, {
+          agentOwner: true
+        }),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(
@@ -14423,7 +15523,9 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.agentStream, {
         name: "Agent.stream",
         type: "function" /* FUNCTION */,
-        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths, {
+          agentOwner: true
+        }),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
           resolveDenyOutputPaths(endEvent, denyOutputPaths)
@@ -14443,7 +15545,9 @@ var AISDKPlugin = class extends BasePlugin {
       traceSyncStreamChannel(aiSDKChannels.agentStreamSync, {
         name: "Agent.stream",
         type: "function" /* FUNCTION */,
-        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths, {
+          agentOwner: true
+        }),
         patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
           defaultDenyOutputPaths: denyOutputPaths,
           endEvent,
@@ -14457,7 +15561,9 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.toolLoopAgentGenerate, {
         name: "ToolLoopAgent.generate",
         type: "function" /* FUNCTION */,
-        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths, {
+          agentOwner: true
+        }),
         extractOutput: (result, endEvent) => {
           finalizeAISDKChildTracing(endEvent);
           return processAISDKOutput(
@@ -14473,7 +15579,9 @@ var AISDKPlugin = class extends BasePlugin {
       traceStreamingChannel(aiSDKChannels.toolLoopAgentStream, {
         name: "ToolLoopAgent.stream",
         type: "function" /* FUNCTION */,
-        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths),
+        extractInput: ([params], event, span) => prepareAISDKCallInput(params, event, span, denyOutputPaths, {
+          agentOwner: true
+        }),
         extractOutput: (result, endEvent) => processAISDKOutput(
           result,
           resolveDenyOutputPaths(endEvent, denyOutputPaths)
@@ -14489,6 +15597,42 @@ var AISDKPlugin = class extends BasePlugin {
         })
       })
     );
+    this.unsubscribers.push(
+      traceStreamingChannel(aiSDKChannels.workflowAgentStream, {
+        name: "WorkflowAgent.stream",
+        type: "function" /* FUNCTION */,
+        extractInput: ([params], event, span) => prepareAISDKWorkflowAgentStreamInput(
+          params,
+          event,
+          span,
+          denyOutputPaths
+        ),
+        extractOutput: (result, endEvent) => {
+          finalizeAISDKChildTracing(endEvent);
+          return processAISDKOutput(
+            result,
+            resolveDenyOutputPaths(endEvent, denyOutputPaths)
+          );
+        },
+        extractMetrics: (result, _startTime, endEvent) => extractTopLevelAISDKMetrics(result, endEvent),
+        aggregateChunks: aggregateAISDKChunks,
+        onComplete: ({ span }) => {
+          unregisterWorkflowAgentWrapperSpan(span);
+        },
+        onError: ({ event, span }) => {
+          finalizeAISDKChildTracing(event);
+          unregisterWorkflowAgentWrapperSpan(span);
+        },
+        patchResult: ({ endEvent, result, span, startTime }) => patchAISDKStreamingResult({
+          defaultDenyOutputPaths: denyOutputPaths,
+          endEvent,
+          onComplete: () => unregisterWorkflowAgentWrapperSpan(span),
+          result,
+          span,
+          startTime
+        })
+      })
+    );
   }
 };
 function subscribeToAISDKV7TelemetryDispatcher() {
@@ -14500,7 +15644,11 @@ function subscribeToAISDKV7TelemetryDispatcher() {
       if (telemetryOptions?.isEnabled === false) {
         return;
       }
-      patchAISDKV7TelemetryDispatcher(event.result, telemetry);
+      patchAISDKV7TelemetryDispatcher(
+        event.result,
+        telemetry,
+        telemetryOptions
+      );
     }
   };
   channel2.subscribe(handlers);
@@ -14508,7 +15656,7 @@ function subscribeToAISDKV7TelemetryDispatcher() {
     channel2.unsubscribe(handlers);
   };
 }
-function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry) {
+function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry, telemetryOptions) {
   if (!isObject(dispatcher)) {
     return;
   }
@@ -14517,6 +15665,54 @@ function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry) {
     return;
   }
   dispatcherRecord[AUTO_PATCHED_V7_TELEMETRY_DISPATCHER] = true;
+  let operationKey;
+  const telemetryEventFields = {};
+  if (typeof telemetryOptions?.recordInputs === "boolean") {
+    telemetryEventFields.recordInputs = telemetryOptions.recordInputs;
+  }
+  if (typeof telemetryOptions?.recordOutputs === "boolean") {
+    telemetryEventFields.recordOutputs = telemetryOptions.recordOutputs;
+  }
+  if (typeof telemetryOptions?.functionId === "string") {
+    telemetryEventFields.functionId = telemetryOptions.functionId;
+  }
+  const eventWithOperationKey = (event) => {
+    if (!isObject(event)) {
+      return event;
+    }
+    const eventRecord = event;
+    const callId = typeof eventRecord.callId === "string" ? eventRecord.callId : "unknown";
+    operationKey ??= `${callId}:${++aiSDKV7TelemetryOperationCounter}`;
+    if (Object.keys(telemetryEventFields).length > 0) {
+      const augmentedEvent = {
+        ...telemetryEventFields,
+        ...event
+      };
+      try {
+        Object.defineProperty(augmentedEvent, BRAINTRUST_AI_SDK_V7_OPERATION_KEY, {
+          configurable: true,
+          enumerable: false,
+          value: operationKey
+        });
+      } catch {
+        augmentedEvent[BRAINTRUST_AI_SDK_V7_OPERATION_KEY] = operationKey;
+      }
+      return augmentedEvent;
+    }
+    try {
+      Object.defineProperty(eventRecord, BRAINTRUST_AI_SDK_V7_OPERATION_KEY, {
+        configurable: true,
+        enumerable: false,
+        value: operationKey
+      });
+      return event;
+    } catch {
+      return {
+        ...event,
+        [BRAINTRUST_AI_SDK_V7_OPERATION_KEY]: operationKey
+      };
+    }
+  };
   for (const key of AI_SDK_V7_TELEMETRY_CALLBACKS) {
     const braintrustCallback = telemetry[key];
     if (typeof braintrustCallback !== "function") {
@@ -14525,11 +15721,17 @@ function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry) {
     const existingCallback = dispatcherRecord[key];
     dispatcherRecord[key] = (event) => {
       const existingResult = typeof existingCallback === "function" ? existingCallback.call(dispatcher, event) : void 0;
-      const braintrustResult = braintrustCallback.call(telemetry, event);
-      const pending = [existingResult, braintrustResult].filter(isPromiseLike);
-      if (pending.length > 0) {
-        return Promise.allSettled(pending).then(() => void 0);
+      try {
+        const braintrustResult = braintrustCallback.call(
+          telemetry,
+          eventWithOperationKey(event)
+        );
+        if (isPromiseLike(braintrustResult)) {
+          void Promise.resolve(braintrustResult).catch(() => void 0);
+        }
+      } catch {
       }
+      return existingResult;
     };
   }
   const braintrustExecuteTool = telemetry.executeTool;
@@ -14539,6 +15741,7 @@ function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry) {
   const existingExecuteTool = dispatcherRecord.executeTool;
   dispatcherRecord.executeTool = (args) => braintrustExecuteTool.call(telemetry, {
     ...args,
+    ...operationKey ? { [BRAINTRUST_AI_SDK_V7_OPERATION_KEY]: operationKey } : {},
     execute: () => typeof existingExecuteTool === "function" ? existingExecuteTool.call(dispatcher, args) : args.execute()
   });
 }
@@ -14637,6 +15840,8 @@ var serializeOutputObject = (output, model) => {
 var processInputAttachmentsSync = (input) => {
   if (!input) return { input };
   const processed = { ...input };
+  delete processed.headers;
+  delete processed.experimental_output;
   if (input.messages && Array.isArray(input.messages)) {
     processed.messages = input.messages.map(processMessage);
   }
@@ -14670,10 +15875,10 @@ var processInputAttachmentsSync = (input) => {
       processed.output = serialized;
     }
   }
-  if ("prepareCall" in processed && typeof processed.prepareCall === "function") {
-    processed.prepareCall = "[Function]";
-  }
-  return { input: processed, outputPromise };
+  return {
+    input: sanitizeAISDKCallInputValue(processed),
+    outputPromise
+  };
 };
 var processMessage = (message) => {
   if (!message || typeof message !== "object") return message;
@@ -14837,7 +16042,21 @@ var convertDataToAttachment = (data, mimeType, filename) => {
 function processAISDKCallInput(params) {
   return processInputAttachmentsSync(params);
 }
-function prepareAISDKCallInput(params, event, span, defaultDenyOutputPaths) {
+function processAISDKWorkflowAgentCallInput(params) {
+  const processed = processAISDKCallInput(params);
+  return {
+    ...processed,
+    input: extractWorkflowAgentInput(processed.input)
+  };
+}
+function processAISDKWorkflowAgentModelCallInput(params) {
+  const processed = processAISDKCallInput(params);
+  return {
+    ...processed,
+    input: extractWorkflowAgentModelInput(processed.input)
+  };
+}
+function prepareAISDKCallInput(params, event, span, defaultDenyOutputPaths, childTracingOptions = {}) {
   const { input, outputPromise } = processAISDKCallInput(params);
   if (outputPromise && input && typeof input === "object") {
     outputPromise.then((resolvedData) => {
@@ -14856,7 +16075,29 @@ function prepareAISDKCallInput(params, event, span, defaultDenyOutputPaths) {
     event.self,
     span,
     defaultDenyOutputPaths,
-    event.aiSDK
+    event.aiSDK,
+    childTracingOptions
+  );
+  event.modelWrapped = childTracing.modelWrapped;
+  if (childTracing.cleanup) {
+    event.__braintrust_ai_sdk_cleanup = childTracing.cleanup;
+  }
+  return {
+    input,
+    metadata
+  };
+}
+function prepareAISDKWorkflowAgentStreamInput(params, event, span, defaultDenyOutputPaths) {
+  registerWorkflowAgentWrapperSpan(span);
+  const { input } = processAISDKWorkflowAgentCallInput(params);
+  const metadata = extractWorkflowMetadataFromCallParams(params, event.self);
+  const childTracing = prepareAISDKChildTracing(
+    params,
+    event.self,
+    span,
+    defaultDenyOutputPaths,
+    event.aiSDK,
+    { agentOwner: true, workflowAgent: true }
   );
   event.modelWrapped = childTracing.modelWrapped;
   if (childTracing.cleanup) {
@@ -14893,6 +16134,9 @@ function extractTopLevelAISDKMetrics(result, event, startTime) {
 function hasModelChildTracing(event) {
   return event?.modelWrapped === true || event?.__braintrust_ai_sdk_model_wrapped === true;
 }
+function serializeToolExecutionInput(args) {
+  return args.length > 0 ? args[0] : args;
+}
 function createAISDKIntegrationMetadata() {
   return {
     braintrust: {
@@ -14904,6 +16148,13 @@ function createAISDKIntegrationMetadata() {
 function resolveModelFromSelf(self) {
   return self && typeof self === "object" && "model" in self && self.model ? self.model : self && typeof self === "object" && "settings" in self && self.settings?.model ? self.settings?.model : void 0;
 }
+function resolveToolsFromSelf(self) {
+  if (!self || typeof self !== "object") {
+    return void 0;
+  }
+  const selfRecord = self;
+  return selfRecord.tools ?? selfRecord.settings?.tools;
+}
 function extractBaseMetadata(model, self) {
   const metadata = createAISDKIntegrationMetadata();
   const { model: modelId, provider } = serializeModelWithProvider(
@@ -14919,12 +16170,175 @@ function extractBaseMetadata(model, self) {
 }
 function extractMetadataFromCallParams(params, self) {
   const metadata = extractBaseMetadata(params.model, self);
-  const tools = serializeAISDKToolsForLogging(params.tools);
+  const tools = serializeAISDKToolsForLogging(
+    params.tools ?? resolveToolsFromSelf(self)
+  );
   if (tools) {
     metadata.tools = tools;
   }
   return metadata;
 }
+function extractWorkflowMetadataFromCallParams(params, self) {
+  const metadata = extractMetadataFromCallParams(params, self);
+  const options = extractAISDKCallOptionsForMetadata(params);
+  if (Object.keys(options).length > 0) {
+    metadata.options = options;
+  }
+  return metadata;
+}
+function extractWorkflowAgentInput(params) {
+  const input = {};
+  if (params.instructions !== void 0) {
+    input.instructions = params.instructions;
+  }
+  if (params.system !== void 0) {
+    input.system = params.system;
+  }
+  if (Array.isArray(params.messages)) {
+    return { ...input, messages: params.messages };
+  }
+  if (typeof params.prompt === "string") {
+    return { ...input, prompt: params.prompt };
+  }
+  if (Array.isArray(params.prompt)) {
+    return { ...input, prompt: params.prompt };
+  }
+  return input;
+}
+function extractWorkflowAgentModelInput(params) {
+  const input = {};
+  if (params.instructions !== void 0) {
+    input.instructions = params.instructions;
+  }
+  if (params.system !== void 0) {
+    input.system = params.system;
+  }
+  if (Array.isArray(params.messages)) {
+    return { ...input, messages: params.messages };
+  }
+  if (typeof params.prompt === "string") {
+    return { ...input, prompt: params.prompt };
+  }
+  if (Array.isArray(params.prompt)) {
+    return { ...input, messages: params.prompt };
+  }
+  return input;
+}
+function sanitizeAISDKCallInputValue(value, depth = 0) {
+  if (value === void 0 || typeof value === "function") {
+    return void 0;
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (isPromiseLike(value)) {
+    return "[Promise]";
+  }
+  if (typeof AbortSignal !== "undefined" && value instanceof AbortSignal) {
+    return "[AbortSignal]";
+  }
+  if (depth >= 8) {
+    return "[Object]";
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeAISDKCallInputValue(item, depth + 1)).filter((item) => item !== void 0);
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, nested] of Object.entries(value)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype" || key.toLowerCase() === "headers") {
+      continue;
+    }
+    const sanitizedNested = sanitizeAISDKCallInputValue(nested, depth + 1);
+    if (sanitizedNested !== void 0) {
+      sanitized[key] = sanitizedNested;
+    }
+  }
+  return sanitized;
+}
+function extractAISDKCallOptionsForMetadata(params) {
+  const options = {};
+  const inputOrTopLevelKeys = /* @__PURE__ */ new Set([
+    "model",
+    "instructions",
+    "messages",
+    "prompt",
+    "system",
+    "tools",
+    "headers",
+    "abortSignal",
+    "signal",
+    "experimental_output"
+  ]);
+  for (const [key, value] of Object.entries(params)) {
+    if (inputOrTopLevelKeys.has(key) || key === "__proto__" || key === "constructor" || key === "prototype" || /^on[A-Z]/.test(key) && typeof value === "function") {
+      continue;
+    }
+    const sanitized = sanitizeAISDKMetadataValue(value);
+    if (sanitized !== void 0) {
+      options[key] = sanitized;
+    }
+  }
+  return options;
+}
+function sanitizeAISDKMetadataValue(value, depth = 0) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (isPromiseLike(value)) {
+    return "[Promise]";
+  }
+  if (typeof AbortSignal !== "undefined" && value instanceof AbortSignal) {
+    return "[AbortSignal]";
+  }
+  if (depth >= 8) {
+    return "[Object]";
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeAISDKMetadataValue(item, depth + 1)).filter((item) => item !== void 0);
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, nested] of Object.entries(value)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype" || key.toLowerCase() === "headers") {
+      continue;
+    }
+    const sanitizedNested = sanitizeAISDKMetadataValue(nested, depth + 1);
+    if (sanitizedNested !== void 0) {
+      sanitized[key] = sanitizedNested;
+    }
+  }
+  return sanitized;
+}
+function buildAISDKModelStartEvent(callOptions, baseMetadata, options) {
+  if (!options.workflowAgent) {
+    return {
+      input: processAISDKCallInput(callOptions).input,
+      metadata: baseMetadata
+    };
+  }
+  return {
+    input: processAISDKWorkflowAgentModelCallInput(callOptions).input,
+    metadata: {
+      ...baseMetadata,
+      ...extractWorkflowMetadataFromCallParams(callOptions)
+    }
+  };
+}
 function extractMetadataFromEmbedParams(params, self) {
   return extractBaseMetadata(params.model, self);
 }
@@ -14938,72 +16352,273 @@ function extractMetadataFromRerankParams(params, self) {
   }
   return metadata;
 }
-function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiSDK) {
+function activeAISDKChildPatchEntry(entries) {
+  const activeSpan = currentSpan();
+  const activeSpanId = activeSpan.spanId;
+  if (activeSpanId) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+      const entry = entries[index];
+      if (entry?.activeSpanIds.has(activeSpanId)) {
+        return entry;
+      }
+    }
+  }
+  const activeParentSpanIds = activeSpan.spanParents ?? [];
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry?.parentSpan.spanId && activeParentSpanIds.includes(entry.parentSpan.spanId)) {
+      return entry;
+    }
+  }
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry?.parentSpan.spanId === activeSpanId) {
+      return entry;
+    }
+  }
+  return entries[entries.length - 1];
+}
+function attachNestedAISDKChildPatchEntry(entries, nestedSpan, cleanup) {
+  const activeSpanId = currentSpan().spanId;
+  if (!activeSpanId || activeSpanId === nestedSpan.spanId) {
+    return false;
+  }
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry?.parentSpan.spanId === activeSpanId || entry?.activeSpanIds.has(activeSpanId)) {
+      entry.activeSpanIds.add(nestedSpan.spanId);
+      cleanup.push(() => {
+        entry.activeSpanIds.delete(nestedSpan.spanId);
+      });
+      return true;
+    }
+  }
+  return false;
+}
+function shadowActiveAISDKChildPatchEntry(entries, entry, nestedSpan, cleanup) {
+  const activeSpanId = currentSpan().spanId;
+  if (!activeSpanId || activeSpanId === nestedSpan.spanId) {
+    return;
+  }
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const existingEntry = entries[index];
+    if (existingEntry?.parentSpan.spanId === activeSpanId || existingEntry?.activeSpanIds.has(activeSpanId)) {
+      entry.activeSpanIds.add(activeSpanId);
+      cleanup.push(() => {
+        entry.activeSpanIds.delete(activeSpanId);
+      });
+      return;
+    }
+  }
+}
+function closeOpenAISDKModelPatchSpans(entry) {
+  for (const span of entry.openSpans) {
+    span.end();
+  }
+  entry.openSpans.clear();
+}
+function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiSDK, childTracingOptions = {}) {
   const cleanup = [];
-  const patchedModels = /* @__PURE__ */ new WeakSet();
+  const patchedModels = /* @__PURE__ */ new WeakMap();
   const patchedTools = /* @__PURE__ */ new WeakSet();
   let modelWrapped = false;
   const patchModel = (model) => {
     const resolvedModel = resolveAISDKModel(model, aiSDK);
-    if (!resolvedModel || typeof resolvedModel !== "object" || typeof resolvedModel.doGenerate !== "function" || patchedModels.has(resolvedModel) || resolvedModel[AUTO_PATCHED_MODEL]) {
+    if (!resolvedModel || typeof resolvedModel !== "object" || typeof resolvedModel.doGenerate !== "function") {
       return resolvedModel;
     }
-    patchedModels.add(resolvedModel);
-    resolvedModel[AUTO_PATCHED_MODEL] = true;
+    const existingWrappedModel = patchedModels.get(resolvedModel);
+    if (existingWrappedModel) {
+      modelWrapped = true;
+      return existingWrappedModel;
+    }
     modelWrapped = true;
+    const modelRecord = resolvedModel;
+    const entry = {
+      activeSpanIds: /* @__PURE__ */ new Set([parentSpan.spanId]),
+      baseMetadata: buildAISDKChildMetadata(resolvedModel),
+      childTracingOptions,
+      denyOutputPaths,
+      openSpans: /* @__PURE__ */ new Set(),
+      parentSpan
+    };
+    const cleanupModelEntry = (state2, patchedModel) => {
+      closeOpenAISDKModelPatchSpans(entry);
+      const index = state2.entries.indexOf(entry);
+      if (index >= 0) {
+        state2.entries.splice(index, 1);
+      }
+      if (state2.entries.length > 0) {
+        return;
+      }
+      patchedModel.doGenerate = state2.originalDoGenerate;
+      patchedModel.doStream = state2.originalDoStream;
+      delete patchedModel[AUTO_PATCHED_MODEL];
+    };
+    const existingState = modelRecord[AUTO_PATCHED_MODEL];
+    if (existingState) {
+      patchedModels.set(resolvedModel, resolvedModel);
+      if (childTracingOptions.agentOwner && attachNestedAISDKChildPatchEntry(
+        existingState.entries,
+        parentSpan,
+        cleanup
+      )) {
+        return resolvedModel;
+      }
+      if (!childTracingOptions.agentOwner) {
+        shadowActiveAISDKChildPatchEntry(
+          existingState.entries,
+          entry,
+          parentSpan,
+          cleanup
+        );
+      }
+      existingState.entries.push(entry);
+      cleanup.push(() => {
+        cleanupModelEntry(existingState, modelRecord);
+      });
+      return resolvedModel;
+    }
     const originalDoGenerate = resolvedModel.doGenerate;
     const originalDoStream = resolvedModel.doStream;
-    const baseMetadata = buildAISDKChildMetadata(resolvedModel);
-    resolvedModel.doGenerate = async function doGeneratePatched(options) {
-      return parentSpan.traced(
+    const wrappedModel = Object.create(
+      Object.getPrototypeOf(resolvedModel)
+    );
+    Object.defineProperties(
+      wrappedModel,
+      Object.getOwnPropertyDescriptors(resolvedModel)
+    );
+    const wrappedModelRecord = wrappedModel;
+    const state = {
+      entries: [entry],
+      originalDoGenerate,
+      originalDoStream
+    };
+    Object.defineProperty(wrappedModel, AUTO_PATCHED_MODEL, {
+      configurable: true,
+      value: state
+    });
+    wrappedModel.doGenerate = async function doGeneratePatched(callOptions) {
+      const activeEntry = activeAISDKChildPatchEntry(state.entries);
+      if (!activeEntry) {
+        return Reflect.apply(originalDoGenerate, resolvedModel, [callOptions]);
+      }
+      closeOpenAISDKModelPatchSpans(activeEntry);
+      return activeEntry.parentSpan.traced(
         async (span) => {
-          const result = await Reflect.apply(
-            originalDoGenerate,
-            resolvedModel,
-            [options]
-          );
-          span.log({
-            output: processAISDKOutput(result, denyOutputPaths),
-            metrics: extractTokenMetrics(result),
-            ...buildResolvedMetadataPayload(result)
-          });
-          return result;
+          activeEntry.openSpans.add(span);
+          try {
+            const result = await Reflect.apply(
+              originalDoGenerate,
+              resolvedModel,
+              [callOptions]
+            );
+            const output = processAISDKOutput(
+              result,
+              activeEntry.denyOutputPaths
+            );
+            const metrics = extractTokenMetrics(result);
+            const metadataPayload = buildResolvedMetadataPayload(result);
+            const missingUsageMetadata = buildMissingUsageMetadata(
+              output,
+              metrics,
+              "ai_sdk_result_missing_usage"
+            );
+            span.log({
+              output,
+              metrics,
+              ...mergeMetadataPayload(metadataPayload, missingUsageMetadata)
+            });
+            return result;
+          } finally {
+            activeEntry.openSpans.delete(span);
+          }
         },
         {
           name: "doGenerate",
           spanAttributes: {
             type: "llm" /* LLM */
           },
-          event: {
-            input: processAISDKCallInput(options).input,
-            metadata: baseMetadata
-          }
+          event: buildAISDKModelStartEvent(
+            callOptions,
+            activeEntry.baseMetadata,
+            {
+              workflowAgent: activeEntry.childTracingOptions.workflowAgent
+            }
+          )
         }
       );
     };
     if (originalDoStream) {
-      resolvedModel.doStream = async function doStreamPatched(options) {
-        const span = parentSpan.startSpan({
+      wrappedModel.doStream = async function doStreamPatched(callOptions) {
+        const activeEntry = activeAISDKChildPatchEntry(state.entries);
+        if (!activeEntry) {
+          return Reflect.apply(originalDoStream, resolvedModel, [callOptions]);
+        }
+        closeOpenAISDKModelPatchSpans(activeEntry);
+        const span = activeEntry.parentSpan.startSpan({
           name: "doStream",
           spanAttributes: {
             type: "llm" /* LLM */
           },
-          event: {
-            input: processAISDKCallInput(options).input,
-            metadata: baseMetadata
-          }
+          event: buildAISDKModelStartEvent(
+            callOptions,
+            activeEntry.baseMetadata,
+            {
+              workflowAgent: activeEntry.childTracingOptions.workflowAgent
+            }
+          )
         });
+        activeEntry.openSpans.add(span);
         const streamStartTime = getCurrentUnixTimestamp();
         const result = await withCurrent(
           span,
-          () => Reflect.apply(originalDoStream, resolvedModel, [options])
+          () => Reflect.apply(originalDoStream, resolvedModel, [callOptions])
         );
         let firstChunkTime;
         const output = {};
         let text = "";
         let reasoning = "";
-        const toolCalls = [];
+        const toolCalls2 = [];
         let object = void 0;
+        let streamSpanEnded = false;
+        const logAndEndStreamSpan = (usageUnavailableReason) => {
+          if (streamSpanEnded) {
+            return;
+          }
+          output.text = text;
+          output.reasoning = reasoning;
+          output.toolCalls = toolCalls2;
+          if (object !== void 0) {
+            output.object = object;
+          }
+          const metrics = extractTokenMetrics(output);
+          if (firstChunkTime !== void 0 && !activeEntry.childTracingOptions.workflowAgent) {
+            metrics.time_to_first_token = Math.max(
+              firstChunkTime - streamStartTime,
+              1e-6
+            );
+          }
+          const metadataPayload = buildResolvedMetadataPayload(
+            output
+          );
+          const missingUsageMetadata = usageUnavailableReason ? { usage_unavailable_reason: usageUnavailableReason } : buildMissingUsageMetadata(
+            output,
+            metrics,
+            "ai_sdk_result_missing_usage"
+          );
+          span.log({
+            output: processAISDKOutput(
+              output,
+              activeEntry.denyOutputPaths
+            ),
+            metrics,
+            ...mergeMetadataPayload(metadataPayload, missingUsageMetadata)
+          });
+          activeEntry.openSpans.delete(span);
+          span.end();
+          streamSpanEnded = true;
+        };
         const transformStream = new TransformStream({
           transform(chunk, controller) {
             if (firstChunkTime === void 0 && isAISDKContentStreamChunk(chunk)) {
@@ -15021,7 +16636,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
                 }
                 break;
               case "tool-call":
-                toolCalls.push(chunk);
+                toolCalls2.push(chunk);
                 break;
               case "object":
                 object = chunk.object;
@@ -15041,33 +16656,15 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
                 }
                 break;
               case "finish":
-                output.text = text;
-                output.reasoning = reasoning;
-                output.toolCalls = toolCalls;
                 output.finishReason = chunk.finishReason;
                 output.usage = chunk.usage;
-                if (object !== void 0) {
-                  output.object = object;
-                }
-                const metrics = extractTokenMetrics(output);
-                if (firstChunkTime !== void 0) {
-                  metrics.time_to_first_token = Math.max(
-                    firstChunkTime - streamStartTime,
-                    1e-6
-                  );
-                }
-                span.log({
-                  output: processAISDKOutput(
-                    output,
-                    denyOutputPaths
-                  ),
-                  metrics,
-                  ...buildResolvedMetadataPayload(output)
-                });
-                span.end();
+                logAndEndStreamSpan();
                 break;
             }
             controller.enqueue(chunk);
+          },
+          flush() {
+            logAndEndStreamSpan("ai_sdk_stream_finished_without_usage");
           }
         });
         return {
@@ -15077,32 +16674,79 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       };
     }
     cleanup.push(() => {
-      resolvedModel.doGenerate = originalDoGenerate;
-      if (originalDoStream) {
-        resolvedModel.doStream = originalDoStream;
-      }
-      delete resolvedModel[AUTO_PATCHED_MODEL];
+      cleanupModelEntry(state, wrappedModelRecord);
     });
-    return resolvedModel;
+    patchedModels.set(resolvedModel, wrappedModel);
+    patchedModels.set(wrappedModel, wrappedModel);
+    return wrappedModel;
   };
   const patchTool = (tool, name) => {
-    if (tool == null || typeof tool !== "object" || !("execute" in tool) || typeof tool.execute !== "function" || patchedTools.has(tool) || tool[AUTO_PATCHED_TOOL]) {
+    if (tool == null || typeof tool !== "object" || !("execute" in tool) || typeof tool.execute !== "function" || patchedTools.has(tool)) {
       return;
     }
     patchedTools.add(tool);
-    tool[AUTO_PATCHED_TOOL] = true;
-    const originalExecute = tool.execute;
+    const toolRecord = tool;
+    const entry = {
+      activeSpanIds: /* @__PURE__ */ new Set([parentSpan.spanId]),
+      childTracingOptions,
+      name,
+      parentSpan
+    };
+    const cleanupToolEntry = (state2) => {
+      const index = state2.entries.indexOf(entry);
+      if (index >= 0) {
+        state2.entries.splice(index, 1);
+      }
+      if (state2.entries.length > 0) {
+        return;
+      }
+      tool.execute = state2.originalExecute;
+      delete toolRecord[AUTO_PATCHED_TOOL];
+    };
+    const existingState = toolRecord[AUTO_PATCHED_TOOL];
+    if (existingState) {
+      if (childTracingOptions.agentOwner && attachNestedAISDKChildPatchEntry(
+        existingState.entries,
+        parentSpan,
+        cleanup
+      )) {
+        return;
+      }
+      if (!childTracingOptions.agentOwner) {
+        shadowActiveAISDKChildPatchEntry(
+          existingState.entries,
+          entry,
+          parentSpan,
+          cleanup
+        );
+      }
+      existingState.entries.push(entry);
+      cleanup.push(() => {
+        cleanupToolEntry(existingState);
+      });
+      return;
+    }
+    const originalExecute = toolRecord.execute;
+    const state = {
+      entries: [entry],
+      originalExecute
+    };
+    toolRecord[AUTO_PATCHED_TOOL] = state;
     tool.execute = function executePatched(...args) {
+      const activeEntry = activeAISDKChildPatchEntry(state.entries);
       const result = Reflect.apply(originalExecute, this, args);
+      if (!activeEntry) {
+        return result;
+      }
       if (isAsyncGenerator(result)) {
         return (async function* () {
-          const span = parentSpan.startSpan({
-            name,
+          const span = activeEntry.parentSpan.startSpan({
+            name: activeEntry.name,
             spanAttributes: {
               type: "tool" /* TOOL */
             }
           });
-          span.log({ input: args.length === 1 ? args[0] : args });
+          span.log({ input: serializeToolExecutionInput(args) });
           try {
             let lastValue;
             for await (const value of result) {
@@ -15118,15 +16762,15 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
           }
         })();
       }
-      return parentSpan.traced(
+      return activeEntry.parentSpan.traced(
         async (span) => {
-          span.log({ input: args.length === 1 ? args[0] : args });
+          span.log({ input: serializeToolExecutionInput(args) });
           const awaitedResult = await result;
           span.log({ output: awaitedResult });
           return awaitedResult;
         },
         {
-          name,
+          name: activeEntry.name,
           spanAttributes: {
             type: "tool" /* TOOL */
           }
@@ -15134,8 +16778,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       );
     };
     cleanup.push(() => {
-      tool.execute = originalExecute;
-      delete tool[AUTO_PATCHED_TOOL];
+      cleanupToolEntry(state);
     });
   };
   const patchTools = (tools) => {
@@ -15154,25 +16797,42 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
     }
   };
   if (params && typeof params === "object") {
-    const patchedParamModel = patchModel(params.model);
-    if (typeof params.model === "string" && patchedParamModel && typeof patchedParamModel === "object") {
+    const originalParamModel = params.model;
+    const patchedParamModel = patchModel(originalParamModel);
+    if (patchedParamModel && patchedParamModel !== originalParamModel) {
       params.model = patchedParamModel;
+      cleanup.push(() => {
+        params.model = originalParamModel;
+      });
     }
     patchTools(params.tools);
   }
   if (self && typeof self === "object") {
     const selfRecord = self;
     if (selfRecord.model !== void 0) {
-      const patchedSelfModel = patchModel(selfRecord.model);
-      if (typeof selfRecord.model === "string" && patchedSelfModel && typeof patchedSelfModel === "object") {
+      const originalSelfModel = selfRecord.model;
+      const patchedSelfModel = patchModel(originalSelfModel);
+      if (patchedSelfModel && patchedSelfModel !== originalSelfModel) {
         selfRecord.model = patchedSelfModel;
+        cleanup.push(() => {
+          selfRecord.model = originalSelfModel;
+        });
       }
     }
+    if (selfRecord.tools !== void 0) {
+      patchTools(selfRecord.tools);
+    }
     if (selfRecord.settings && typeof selfRecord.settings === "object") {
       if (selfRecord.settings.model !== void 0) {
-        const patchedSettingsModel = patchModel(selfRecord.settings.model);
-        if (typeof selfRecord.settings.model === "string" && patchedSettingsModel && typeof patchedSettingsModel === "object") {
+        const originalSettingsModel = selfRecord.settings.model;
+        const patchedSettingsModel = patchModel(originalSettingsModel);
+        if (patchedSettingsModel && patchedSettingsModel !== originalSettingsModel) {
           selfRecord.settings.model = patchedSettingsModel;
+          cleanup.push(() => {
+            if (selfRecord.settings) {
+              selfRecord.settings.model = originalSettingsModel;
+            }
+          });
         }
       }
       if (selfRecord.settings.tools !== void 0) {
@@ -15269,99 +16929,190 @@ function isAISDKContentAsyncIterableChunk(chunk) {
   return isObject(part) && typeof part.type !== "string";
 }
 function patchAISDKStreamingResult(args) {
-  const { defaultDenyOutputPaths, endEvent, result, span, startTime } = args;
+  const {
+    defaultDenyOutputPaths,
+    endEvent,
+    onComplete,
+    result,
+    span,
+    startTime
+  } = args;
   if (!result || typeof result !== "object") {
     return false;
   }
   const resultRecord = result;
   attachKnownResultPromiseHandlers(resultRecord);
+  let finalized = false;
+  const finalize = () => {
+    if (finalized) {
+      return;
+    }
+    finalized = true;
+    finalizeAISDKChildTracing(endEvent);
+    span.end();
+    onComplete?.();
+  };
+  let outputLogged = false;
+  const logStreamingOutput = async (firstChunkTime) => {
+    if (outputLogged) {
+      return;
+    }
+    outputLogged = true;
+    try {
+      const metrics = extractTopLevelAISDKMetrics(result, endEvent);
+      if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
+        metrics.time_to_first_token = firstChunkTime - startTime;
+      }
+      const output = await processAISDKStreamingOutput(
+        result,
+        resolveDenyOutputPaths(endEvent, defaultDenyOutputPaths)
+      );
+      const metadata = buildResolvedMetadataPayload(result).metadata;
+      span.log({
+        output,
+        ...metadata ? { metadata } : {},
+        metrics
+      });
+    } catch (error) {
+      span.log({ error: toLoggedError(error) });
+    } finally {
+      finalize();
+    }
+  };
+  const createAsyncIterableHooks = () => {
+    let firstChunkTime;
+    return {
+      onChunk: (chunk) => {
+        if (firstChunkTime === void 0 && isAISDKContentAsyncIterableChunk(chunk)) {
+          firstChunkTime = getCurrentUnixTimestamp();
+        }
+      },
+      onComplete: async () => {
+        await logStreamingOutput(firstChunkTime);
+      },
+      onError: (error) => {
+        if (!outputLogged) {
+          outputLogged = true;
+          span.log({
+            error: error.message
+          });
+        }
+        finalize();
+      },
+      onCancel: finalize
+    };
+  };
+  const patchAsyncIterable = (stream) => isReadableStreamLike(stream) ? createPatchedReadableStream(stream, createAsyncIterableHooks()) : createPatchedAsyncIterable(stream, createAsyncIterableHooks());
+  const patchAsyncIterableField = (field) => {
+    let descriptorOwner = resultRecord;
+    let descriptor;
+    while (descriptorOwner) {
+      descriptor = Object.getOwnPropertyDescriptor(descriptorOwner, field);
+      if (descriptor) {
+        break;
+      }
+      descriptorOwner = Object.getPrototypeOf(descriptorOwner);
+    }
+    if (!descriptor || descriptorOwner === resultRecord && !descriptor.configurable) {
+      return false;
+    }
+    if ("value" in descriptor) {
+      if (!isAsyncIterable(descriptor.value)) {
+        return false;
+      }
+      try {
+        Object.defineProperty(resultRecord, field, {
+          configurable: descriptorOwner === resultRecord ? descriptor.configurable : true,
+          enumerable: descriptor.enumerable,
+          value: patchAsyncIterable(descriptor.value),
+          writable: descriptor.writable
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    if (typeof descriptor.get !== "function") {
+      return false;
+    }
+    const originalGet = descriptor.get;
+    const originalSet = descriptor.set;
+    try {
+      Object.defineProperty(resultRecord, field, {
+        configurable: descriptorOwner === resultRecord ? descriptor.configurable : true,
+        enumerable: descriptor.enumerable,
+        get() {
+          const stream = originalGet.call(this);
+          return isAsyncIterable(stream) ? patchAsyncIterable(stream) : stream;
+        },
+        ...originalSet ? {
+          set(value) {
+            originalSet.call(this, value);
+          }
+        } : {}
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  let patched = false;
   if (isReadableStreamLike(resultRecord.baseStream)) {
-    let firstChunkTime2;
-    const wrappedBaseStream = resultRecord.baseStream.pipeThrough(
+    let firstChunkTime;
+    const transformedBaseStream = resultRecord.baseStream.pipeThrough(
       new TransformStream({
         transform(chunk, controller) {
-          if (firstChunkTime2 === void 0 && isAISDKContentStreamChunk(chunk)) {
-            firstChunkTime2 = getCurrentUnixTimestamp();
+          if (firstChunkTime === void 0 && isAISDKContentStreamChunk(chunk)) {
+            firstChunkTime = getCurrentUnixTimestamp();
           }
           controller.enqueue(chunk);
         },
         async flush() {
-          const metrics = extractTopLevelAISDKMetrics(result, endEvent);
-          if (metrics.time_to_first_token === void 0 && firstChunkTime2 !== void 0) {
-            metrics.time_to_first_token = firstChunkTime2 - startTime;
-          }
-          const output = await processAISDKStreamingOutput(
-            result,
-            resolveDenyOutputPaths(endEvent, defaultDenyOutputPaths)
-          );
-          const metadata = buildResolvedMetadataPayload(result).metadata;
-          span.log({
-            output,
-            ...metadata ? { metadata } : {},
-            metrics
-          });
-          finalizeAISDKChildTracing(endEvent);
-          span.end();
+          await logStreamingOutput(firstChunkTime);
         }
       })
     );
+    const reader = transformedBaseStream.getReader();
+    const wrappedBaseStream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          controller.enqueue(value);
+        } catch (error) {
+          span.log({ error: toLoggedError(error) });
+          finalize();
+          controller.error(error);
+        }
+      },
+      async cancel(reason) {
+        try {
+          finalize();
+        } finally {
+          await reader.cancel(reason);
+        }
+      }
+    });
     Object.defineProperty(resultRecord, "baseStream", {
       configurable: true,
       enumerable: true,
       value: wrappedBaseStream,
       writable: true
     });
-    return true;
+    patched = true;
   }
-  const streamField = findAsyncIterableField(resultRecord, [
+  for (const field of [
     "partialObjectStream",
     "textStream",
     "fullStream",
     "stream"
-  ]);
-  if (!streamField) {
-    return false;
+  ]) {
+    patched = patchAsyncIterableField(field) || patched;
   }
-  let firstChunkTime;
-  const wrappedStream = createPatchedAsyncIterable(streamField.stream, {
-    onChunk: (chunk) => {
-      if (firstChunkTime === void 0 && isAISDKContentAsyncIterableChunk(chunk)) {
-        firstChunkTime = getCurrentUnixTimestamp();
-      }
-    },
-    onComplete: async () => {
-      const metrics = extractTopLevelAISDKMetrics(result, endEvent);
-      if (metrics.time_to_first_token === void 0 && firstChunkTime !== void 0) {
-        metrics.time_to_first_token = firstChunkTime - startTime;
-      }
-      const output = await processAISDKStreamingOutput(
-        result,
-        resolveDenyOutputPaths(endEvent, defaultDenyOutputPaths)
-      );
-      const metadata = buildResolvedMetadataPayload(result).metadata;
-      span.log({
-        output,
-        ...metadata ? { metadata } : {},
-        metrics
-      });
-      finalizeAISDKChildTracing(endEvent);
-      span.end();
-    },
-    onError: (error) => {
-      span.log({
-        error: error.message
-      });
-      finalizeAISDKChildTracing(endEvent);
-      span.end();
-    }
-  });
-  Object.defineProperty(resultRecord, streamField.field, {
-    configurable: true,
-    enumerable: true,
-    value: wrappedStream,
-    writable: true
-  });
-  return true;
+  return patched;
 }
 function attachKnownResultPromiseHandlers(result) {
   const promiseLikeFields = [
@@ -15393,34 +17144,72 @@ function attachKnownResultPromiseHandlers(result) {
   }
 }
 function isReadableStreamLike(value) {
-  return value != null && typeof value === "object" && typeof value.pipeThrough === "function";
-}
-function findAsyncIterableField(result, candidateFields) {
-  for (const field of candidateFields) {
-    try {
-      const stream = result[field];
-      if (isAsyncIterable(stream)) {
-        return { field, stream };
+  return value != null && typeof value === "object" && typeof value.getReader === "function" && typeof value.pipeThrough === "function";
+}
+function createPatchedReadableStream(stream, hooks) {
+  let reader;
+  let completed = false;
+  return new ReadableStream({
+    async pull(controller) {
+      reader ??= stream.getReader();
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          completed = true;
+          await hooks.onComplete();
+          controller.close();
+          return;
+        }
+        hooks.onChunk(value);
+        controller.enqueue(value);
+      } catch (error) {
+        completed = true;
+        hooks.onError(
+          error instanceof Error ? error : new Error(String(error))
+        );
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      if (!completed) {
+        completed = true;
+        try {
+          await hooks.onCancel?.();
+        } catch {
+        }
+      }
+      if (reader) {
+        await reader.cancel(reason);
+      } else if (stream.cancel) {
+        await stream.cancel(reason);
       }
-    } catch {
     }
-  }
-  return null;
+  });
 }
 function createPatchedAsyncIterable(stream, hooks) {
   return {
     async *[Symbol.asyncIterator]() {
+      let completed = false;
       try {
         for await (const chunk of stream) {
           hooks.onChunk(chunk);
           yield chunk;
         }
+        completed = true;
         await hooks.onComplete();
       } catch (error) {
+        completed = true;
         hooks.onError(
           error instanceof Error ? error : new Error(String(error))
         );
         throw error;
+      } finally {
+        if (!completed) {
+          try {
+            await hooks.onCancel?.();
+          } catch {
+          }
+        }
       }
     }
   };
@@ -15495,6 +17284,40 @@ function buildResolvedMetadataPayload(result) {
   }
   return Object.keys(metadata).length > 0 ? { metadata } : {};
 }
+function mergeMetadataPayload(metadataPayload, extraMetadata) {
+  if (!extraMetadata || Object.keys(extraMetadata).length === 0) {
+    return metadataPayload;
+  }
+  return {
+    metadata: {
+      ...metadataPayload.metadata ?? {},
+      ...extraMetadata
+    }
+  };
+}
+function buildMissingUsageMetadata(output, metrics, reason) {
+  if (!hasLoggedOutput(output) || hasTokenUsageMetrics(metrics)) {
+    return void 0;
+  }
+  return { usage_unavailable_reason: reason };
+}
+function hasLoggedOutput(output) {
+  if (output === null || output === void 0) {
+    return false;
+  }
+  if (Array.isArray(output)) {
+    return output.length > 0;
+  }
+  if (typeof output === "object") {
+    return Object.keys(output).length > 0;
+  }
+  return true;
+}
+function hasTokenUsageMetrics(metrics) {
+  return Object.keys(metrics).some(
+    (key) => key !== "estimated_cost" && key !== "time_to_first_token"
+  );
+}
 function resolveAISDKModel(model, aiSDK) {
   if (typeof model !== "string") {
     return model;
@@ -15518,7 +17341,45 @@ function isAsyncGenerator(value) {
 function processAISDKOutput(output, denyOutputPaths) {
   if (!output) return output;
   const merged = extractSerializableOutputFields(output);
-  return normalizeAISDKLoggedOutput(omit(merged, denyOutputPaths));
+  const deleteOutputPaths = denyOutputPaths.filter(
+    (path) => path.toLowerCase().endsWith("headers")
+  );
+  const sanitized = omit(merged, denyOutputPaths, deleteOutputPaths);
+  for (const path of TRANSPORT_PAYLOAD_ROOT_PATHS) {
+    const stack = [{ obj: sanitized, keys: parsePath(path) }];
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      if (!entry || entry.keys.length === 0) {
+        continue;
+      }
+      const firstKey = entry.keys[0];
+      const remainingKeys = entry.keys.slice(1);
+      if (firstKey === "[]") {
+        if (Array.isArray(entry.obj)) {
+          for (const item of entry.obj) {
+            stack.push({
+              obj: item,
+              keys: remainingKeys
+            });
+          }
+        }
+        continue;
+      }
+      if (!entry.obj || typeof entry.obj !== "object" || !(firstKey in entry.obj)) {
+        continue;
+      }
+      const record = entry.obj;
+      if (remainingKeys.length === 0) {
+        record[firstKey] = sanitizeAISDKMetadataValue(record[firstKey]);
+        continue;
+      }
+      stack.push({
+        obj: record[firstKey],
+        keys: remainingKeys
+      });
+    }
+  }
+  return normalizeAISDKLoggedOutput(sanitized);
 }
 function processAISDKEmbeddingOutput(output, denyOutputPaths) {
   if (!output || typeof output !== "object") {
@@ -15609,6 +17470,8 @@ function extractTokenMetrics(result) {
   );
   if (totalTokens !== void 0) {
     metrics.tokens = totalTokens;
+  } else if (promptTokens !== void 0 && completionTokens !== void 0) {
+    metrics.tokens = promptTokens + completionTokens;
   }
   const promptCachedTokens = firstNumber2(
     usage.inputTokens?.cacheRead,
@@ -15720,9 +17583,9 @@ function aggregateAISDKChunks(chunks, _result, endEvent) {
     if (finishReason !== void 0) {
       output.finishReason = finishReason;
     }
-    const toolCalls = safeSerializableFieldRead(lastChunk, "toolCalls");
-    if (toolCalls !== void 0) {
-      output.toolCalls = toolCalls;
+    const toolCalls2 = safeSerializableFieldRead(lastChunk, "toolCalls");
+    if (toolCalls2 !== void 0) {
+      output.toolCalls = toolCalls2;
     }
   }
   finalizeAISDKChildTracing(endEvent);
@@ -15732,7 +17595,9 @@ function extractGetterValues(obj) {
   const getterValues = {};
   const getterNames = [
     "content",
+    "messages",
     "text",
+    "output",
     "object",
     "value",
     "values",
@@ -15772,7 +17637,9 @@ function extractGetterValues(obj) {
 function extractSerializableOutputFields(output) {
   const serialized = {};
   const directFieldNames = [
+    "messages",
     "steps",
+    "output",
     "request",
     "responseMessages",
     "warnings",
@@ -15954,7 +17821,7 @@ function parsePath(path) {
   }
   return keys;
 }
-function omitAtPath(obj, keys) {
+function omitAtPath(obj, keys, deleteLeaf = false) {
   if (keys.length === 0) return;
   const firstKey = keys[0];
   const remainingKeys = keys.slice(1);
@@ -15964,29 +17831,36 @@ function omitAtPath(obj, keys) {
         if (remainingKeys.length > 0) {
           omitAtPath(
             item,
-            remainingKeys
+            remainingKeys,
+            deleteLeaf
           );
         }
       });
     }
   } else if (remainingKeys.length === 0) {
     if (obj && typeof obj === "object" && firstKey in obj) {
-      obj[firstKey] = "<omitted>";
+      if (deleteLeaf) {
+        delete obj[firstKey];
+      } else {
+        obj[firstKey] = "<omitted>";
+      }
     }
   } else {
     if (obj && typeof obj === "object" && firstKey in obj) {
       omitAtPath(
         obj[firstKey],
-        remainingKeys
+        remainingKeys,
+        deleteLeaf
       );
     }
   }
 }
-function omit(obj, paths) {
+function omit(obj, paths, deletePaths = []) {
   const result = deepCopy(obj);
+  const deletePathSet = new Set(deletePaths);
   for (const path of paths) {
     const keys = parsePath(path);
-    omitAtPath(result, keys);
+    omitAtPath(result, keys, deletePathSet.has(path));
   }
   return result;
 }
@@ -20195,8 +22069,8 @@ function getChatToolCallDeltas(value) {
   if (!Array.isArray(value?.tool_calls)) {
     return void 0;
   }
-  const toolCalls = value.tool_calls.filter((toolCall) => isObject(toolCall));
-  return toolCalls.length > 0 ? toolCalls : void 0;
+  const toolCalls2 = value.tool_calls.filter((toolCall) => isObject(toolCall));
+  return toolCalls2.length > 0 ? toolCalls2 : void 0;
 }
 function mergeChatToolCallDeltas(toolCallsByIndex, toolCallDeltas) {
   for (const toolDelta of toolCallDeltas) {
@@ -21685,7 +23559,7 @@ function aggregateOpenRouterChatChunks(chunks) {
   let reasoningContent = "";
   let hasReasoningContent = false;
   let reasoningDetails;
-  let toolCalls;
+  let toolCalls2;
   let finishReason;
   let metrics = {};
   for (const chunk of chunks) {
@@ -21738,9 +23612,9 @@ function aggregateOpenRouterChatChunks(chunks) {
         continue;
       }
       const toolIndex = toolDelta.index ?? 0;
-      const existingToolCall = toolCalls?.[toolIndex];
+      const existingToolCall = toolCalls2?.[toolIndex];
       if (!existingToolCall || toolDelta.id && existingToolCall.id !== void 0 && existingToolCall.id !== toolDelta.id) {
-        const nextToolCalls = [...toolCalls || []];
+        const nextToolCalls = [...toolCalls2 || []];
         nextToolCalls[toolIndex] = {
           index: toolIndex,
           id: toolDelta.id,
@@ -21750,7 +23624,7 @@ function aggregateOpenRouterChatChunks(chunks) {
             arguments: toolDelta.function.arguments || ""
           }
         };
-        toolCalls = nextToolCalls;
+        toolCalls2 = nextToolCalls;
         continue;
       }
       const current = existingToolCall;
@@ -21776,7 +23650,7 @@ function aggregateOpenRouterChatChunks(chunks) {
           ...hasReasoning || hasReasoningContent ? { reasoning } : {},
           ...hasReasoningContent ? { reasoning_content: reasoningContent } : {},
           ...reasoningDetails ? { reasoning_details: reasoningDetails } : {},
-          ...toolCalls ? { tool_calls: toolCalls } : {}
+          ...toolCalls2 ? { tool_calls: toolCalls2 } : {}
         },
         logprobs: null,
         finish_reason: finishReason
@@ -22621,8 +24495,8 @@ function appendMistralContent(accumulator, content) {
   delete accumulator.content;
 }
 function getDeltaToolCalls(delta) {
-  const toolCalls = Array.isArray(delta.toolCalls) && delta.toolCalls || Array.isArray(delta.tool_calls) && delta.tool_calls || [];
-  return toolCalls.filter((toolCall) => isObject(toolCall));
+  const toolCalls2 = Array.isArray(delta.toolCalls) && delta.toolCalls || Array.isArray(delta.tool_calls) && delta.tool_calls || [];
+  return toolCalls2.filter((toolCall) => isObject(toolCall));
 }
 function getToolCallIndex(toolCall) {
   return typeof toolCall.index === "number" && toolCall.index >= 0 ? toolCall.index : void 0;
@@ -22649,11 +24523,11 @@ function mergeToolCallDeltaPair(current, delta) {
     }
   };
 }
-function mergeToolCallDeltas(toolCalls, deltas) {
+function mergeToolCallDeltas(toolCalls2, deltas) {
   if (deltas.length === 0) {
-    return toolCalls;
+    return toolCalls2;
   }
-  const merged = toolCalls ? [...toolCalls] : [];
+  const merged = toolCalls2 ? [...toolCalls2] : [];
   const indexToPosition = /* @__PURE__ */ new Map();
   const idToPosition = /* @__PURE__ */ new Map();
   for (const [position, toolCall] of merged.entries()) {
@@ -23724,12 +25598,12 @@ function extractCohereChatOutput(result) {
   if (typeof result.text !== "string") {
     return void 0;
   }
-  const toolCalls = Array.isArray(result.toolCalls) ? result.toolCalls : Array.isArray(result.tool_calls) ? result.tool_calls : void 0;
-  if (toolCalls && toolCalls.length > 0) {
+  const toolCalls2 = Array.isArray(result.toolCalls) ? result.toolCalls : Array.isArray(result.tool_calls) ? result.tool_calls : void 0;
+  if (toolCalls2 && toolCalls2.length > 0) {
     return {
       content: result.text,
       role: "assistant",
-      toolCalls
+      toolCalls: toolCalls2
     };
   }
   return result.text;
@@ -24062,10 +25936,10 @@ function aggregateCohereChatStreamChunks(chunks) {
       continue;
     }
     if (eventType === "tool-call-start") {
-      const toolCalls = isObject(chunk.delta) && isObject(chunk.delta.message) ? toToolCallArray(
+      const toolCalls2 = isObject(chunk.delta) && isObject(chunk.delta.message) ? toToolCallArray(
         Array.isArray(chunk.delta.message.toolCalls) ? chunk.delta.message.toolCalls : chunk.delta.message.toolCalls ?? chunk.delta.message.tool_calls
       ) : [];
-      for (const [index, toolCall] of toolCalls.entries()) {
+      for (const [index, toolCall] of toolCalls2.entries()) {
         const normalizedIndex = getToolCallIndex2(
           toolCall,
           typeof chunk.index === "number" ? chunk.index : index
@@ -28140,14 +30014,14 @@ function normalizeAssistantMessage(message) {
   const thinking = message.content.flatMap(
     (part) => part.type === "thinking" && !part.redacted ? [part.thinking] : []
   ).join("");
-  const toolCalls = message.content.flatMap(
+  const toolCalls2 = message.content.flatMap(
     (part) => part.type === "toolCall" ? [normalizeToolCall(part)] : []
   );
   return {
     role: "assistant",
-    content: text || (toolCalls.length > 0 ? null : ""),
+    content: text || (toolCalls2.length > 0 ? null : ""),
     ...thinking ? { reasoning: thinking } : {},
-    ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+    ...toolCalls2.length > 0 ? { tool_calls: toolCalls2 } : {}
   };
 }
 function normalizeToolResultMessage(message) {
@@ -29645,8 +31519,10 @@ 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,
@@ -29679,6 +31555,7 @@ __export(exports_exports, {
   NOOP_SPAN: () => NOOP_SPAN,
   NOOP_SPAN_PERMALINK: () => NOOP_SPAN_PERMALINK,
   NoopSpan: () => NoopSpan,
+  OTELIDGenerator: () => OTELIDGenerator,
   ObjectFetcher: () => ObjectFetcher,
   Project: () => Project2,
   ProjectNameIdMap: () => ProjectNameIdMap,
@@ -29690,6 +31567,8 @@ __export(exports_exports, {
   ScorerBuilder: () => ScorerBuilder,
   SpanFetcher: () => SpanFetcher,
   SpanImpl: () => SpanImpl,
+  TRACEPARENT_HEADER: () => TRACEPARENT_HEADER,
+  TRACESTATE_HEADER: () => TRACESTATE_HEADER,
   TestBackgroundLogger: () => TestBackgroundLogger,
   ToolBuilder: () => ToolBuilder,
   UUIDGenerator: () => UUIDGenerator,
@@ -29699,6 +31578,7 @@ __export(exports_exports, {
   _internalIso: () => isomorph_default,
   _internalSetInitialState: () => _internalSetInitialState,
   addAzureBlobHeaders: () => addAzureBlobHeaders,
+  agentAssertionScorer: () => agentAssertionScorer,
   braintrustAISDKTelemetry: () => braintrustAISDKTelemetry,
   braintrustFlueInstrumentation: () => braintrustFlueInstrumentation,
   braintrustFlueObserver: () => braintrustFlueObserver,
@@ -29716,6 +31596,7 @@ __export(exports_exports, {
   devNullWritableStream: () => devNullWritableStream,
   evaluatorDefinitionSchema: () => evaluatorDefinitionSchema,
   evaluatorDefinitionsSchema: () => evaluatorDefinitionsSchema,
+  extractTraceContextFromHeaders: () => extractTraceContextFromHeaders,
   flush: () => flush,
   getContextManager: () => getContextManager,
   getIdGenerator: () => getIdGenerator,
@@ -29729,6 +31610,7 @@ __export(exports_exports, {
   initFunction: () => initFunction,
   initLogger: () => initLogger,
   initNodeTestSuite: () => initNodeTestSuite,
+  injectTraceContext: () => injectTraceContext,
   invoke: () => invoke,
   isTemplateFormat: () => isTemplateFormat,
   loadParameters: () => loadParameters,
@@ -29767,7 +31649,7 @@ __export(exports_exports, {
   traced: () => traced,
   updateSpan: () => updateSpan,
   uploadLogs3OverflowPayload: () => uploadLogs3OverflowPayload,
-  utf8ByteLength: () => utf8ByteLength,
+  utf8ByteLength: () => utf8ByteLength2,
   withCurrent: () => withCurrent,
   withDataset: () => withDataset,
   withExperiment: () => withExperiment,
@@ -30360,6 +32242,7 @@ function wrapAISDK(aiSDK, options = {}) {
         case "Agent":
         case "Experimental_Agent":
         case "ToolLoopAgent":
+        case "WorkflowAgent":
           return original ? wrapAgentClass(original, options) : original;
       }
       return original;
@@ -30378,10 +32261,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") {
@@ -30396,7 +32279,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),
     {
@@ -30406,19 +32289,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 = (channel2, name, generateText, contextOptions = {}, options = {}) => {
   const wrapper = async function(allParams) {
     const { span_info, ...params } = allParams;
@@ -30680,7 +32586,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,
@@ -30699,7 +32605,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,
@@ -30707,15 +32613,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;
@@ -30728,7 +32634,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: {
@@ -30829,15 +32735,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,
@@ -30936,29 +32842,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++,
@@ -30970,7 +32876,7 @@ function extractToolCallsFromSteps(steps) {
       }
     }
   }
-  return toolCalls;
+  return toolCalls2;
 }
 function extractToolCallsFromBlocks(blocks) {
   if (!Array.isArray(blocks)) return [];
@@ -31036,12 +32942,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,
@@ -31130,13 +33036,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
                   );
                 }
               }
@@ -31771,9 +33677,9 @@ function isModuleNamespace3(obj) {
   const descriptor = Object.getOwnPropertyDescriptor(obj, keys[0]);
   return descriptor ? !descriptor.configurable && !descriptor.writable : false;
 }
-function wrapCursorAgentClass(Agent) {
+function wrapCursorAgentClass(Agent2) {
   const cache = /* @__PURE__ */ new Map();
-  return new Proxy(Agent, {
+  return new Proxy(Agent2, {
     get(target, prop, receiver) {
       if (cache.has(prop)) {
         return cache.get(prop);
@@ -35321,15 +37227,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;
@@ -35383,7 +37295,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 {
@@ -35396,7 +37308,8 @@ var CachedSpanFetcher = class {
           rootSpanId,
           state,
           spanType,
-          includeScorers
+          includeScorers,
+          brainstoreRealtime
         );
         const rows = await fetcher.fetchedData();
         return rows.map((row) => ({
@@ -36226,7 +38139,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
@@ -36752,6 +38665,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) {