braintrust 3.19.0 → 3.21.0

package/dist/instrumentation/index.mjs

@@ -499,8 +499,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
@@ -1108,7 +1391,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");
     }
   }
@@ -1550,7 +1833,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}`);
     }
   }
@@ -1683,7 +1966,8 @@ var AclObjectType = z6.union([
     "role",
     "org_member",
     "project_log",
-    "org_project"
+    "org_project",
+    "org_audit_logs"
   ]),
   z6.null()
 ]);
@@ -1709,6 +1993,17 @@ var Acl = z6.object({
   _object_org_id: z6.string().uuid(),
   created: z6.union([z6.string(), z6.null()]).optional()
 });
+var Agent = z6.object({
+  id: z6.string().uuid(),
+  project_id: z6.string().uuid(),
+  user_id: z6.string().uuid(),
+  created: z6.union([z6.string(), z6.null()]).optional(),
+  name: z6.string(),
+  slug: z6.string(),
+  kind: z6.string(),
+  description: z6.union([z6.string(), z6.null()]).optional(),
+  metadata: z6.union([z6.object({}).partial().passthrough(), z6.null()]).optional()
+});
 var AISecret = z6.object({
   id: z6.string().uuid(),
   created: z6.union([z6.string(), z6.null()]).optional(),
@@ -1855,6 +2150,7 @@ var AttachmentStatus = z6.object({
   upload_status: UploadStatus,
   error_message: z6.string().optional()
 });
+var AutomationStatus = z6.enum(["active", "paused"]);
 var FunctionTypeEnum = z6.enum([
   "llm",
   "scorer",
@@ -1900,7 +2196,9 @@ var TopicMapData = z6.object({
   topic_names: z6.record(z6.string()).optional(),
   generation_settings: TopicMapGenerationSettings.optional(),
   disable_reconciliation: z6.boolean().optional(),
-  distance_threshold: z6.number().optional()
+  distance_threshold: z6.number().optional(),
+  btql_filter: z6.string().optional(),
+  automation_btql_filter: z6.string().optional()
 });
 var BatchedFacetData = z6.object({
   type: z6.literal("batched_facet"),
@@ -2183,7 +2481,7 @@ var DatasetEvent = z6.object({
   origin: ObjectReferenceNullish.optional(),
   comments: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
   audit_data: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
-  facets: z6.union([z6.object({}).partial().passthrough(), z6.null()]).optional(),
+  facets: z6.union([z6.record(z6.union([z6.string(), z6.null()])), z6.null()]).optional(),
   classifications: z6.union([
     z6.record(
       z6.array(
@@ -2335,7 +2633,7 @@ var ExperimentEvent = z6.object({
   origin: ObjectReferenceNullish.optional(),
   comments: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
   audit_data: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
-  facets: z6.union([z6.object({}).partial().passthrough(), z6.null()]).optional(),
+  facets: z6.union([z6.record(z6.union([z6.string(), z6.null()])), z6.null()]).optional(),
   classifications: z6.union([
     z6.record(
       z6.array(
@@ -2473,7 +2771,8 @@ var PromptParserNullish = z6.union([
     use_cot: z6.boolean(),
     choice_scores: z6.record(z6.number().gte(0).lte(1)).optional(),
     choice: z6.array(z6.string()).optional(),
-    allow_no_match: z6.boolean().optional()
+    allow_no_match: z6.boolean().optional(),
+    allow_skip: z6.boolean().optional()
   }),
   z6.null()
 ]);
@@ -2803,6 +3102,9 @@ var Group = z6.object({
 var GroupScope = z6.object({
   type: z6.literal("group"),
   group_by: z6.string(),
+  interval_seconds: z6.number().gte(1).optional(),
+  max_traces: z6.number().int().gte(1).lte(64).optional(),
+  placement: z6.enum(["first", "each"]),
   idle_seconds: z6.number().optional()
 });
 var IfExists = z6.enum(["error", "ignore", "replace"]);
@@ -2951,6 +3253,10 @@ var RetentionObjectType = z6.enum([
   "experiment",
   "dataset"
 ]);
+var TopicAutomationFacetModel = z6.union([
+  z6.enum(["brain-facet-latest", "brain-facet-1", "brain-facet-2"]),
+  z6.null()
+]);
 var TopicMapFunctionAutomation = z6.object({
   function: SavedFunctionId.and(z6.unknown()),
   btql_filter: z6.union([z6.string(), z6.null()]).optional()
@@ -2963,7 +3269,9 @@ var TopicAutomationDataScope = z6.union([
 ]);
 var TopicAutomationConfig = z6.object({
   event_type: z6.literal("topic"),
+  status: AutomationStatus.optional(),
   sampling_rate: z6.number().gte(0).lte(1),
+  facet_model: TopicAutomationFacetModel.optional(),
   facet_functions: z6.array(SavedFunctionId),
   topic_map_functions: z6.array(TopicMapFunctionAutomation),
   scope: z6.union([SpanScope, TraceScope, GroupScope, z6.null()]).optional(),
@@ -2977,6 +3285,19 @@ var TopicAutomationConfig = z6.object({
     z6.null()
   ]).optional()
 });
+var TopicDigestAutomationConfig = z6.object({
+  event_type: z6.literal("topic_digest"),
+  status: AutomationStatus.optional(),
+  window_seconds: z6.number().int().gte(3600).lte(2592e3).optional().default(86400),
+  scheduled_time_minutes_utc: z6.number().int().gte(0).lte(1439),
+  action: z6.object({
+    type: z6.literal("slack"),
+    workspace_id: z6.string(),
+    channel: z6.string(),
+    message_template: z6.string().optional()
+  }),
+  topic_map_function_ids: z6.array(z6.string()).max(10).optional()
+});
 var ProjectAutomation = z6.object({
   id: z6.string().uuid(),
   project_id: z6.string().uuid(),
@@ -3001,6 +3322,7 @@ var ProjectAutomation = z6.object({
     }),
     z6.object({
       event_type: z6.literal("btql_export"),
+      status: AutomationStatus.optional(),
       export_definition: z6.union([
         z6.object({ type: z6.literal("log_traces") }),
         z6.object({ type: z6.literal("log_spans") }),
@@ -3023,6 +3345,21 @@ var ProjectAutomation = z6.object({
       ]),
       batch_size: z6.union([z6.number(), z6.null()]).optional()
     }),
+    z6.object({
+      event_type: z6.literal("async_query"),
+      status: AutomationStatus.optional(),
+      created_by_user_id: z6.string().uuid(),
+      object_type: z6.enum([
+        "project_logs",
+        "experiment",
+        "dataset",
+        "playground_logs"
+      ]),
+      object_id: z6.string(),
+      query: z6.string(),
+      format: z6.literal("jsonl"),
+      batch_size: z6.union([z6.number(), z6.null()]).optional()
+    }),
     z6.object({
       event_type: z6.literal("retention"),
       object_type: RetentionObjectType,
@@ -3041,7 +3378,8 @@ var ProjectAutomation = z6.object({
         })
       ])
     }),
-    TopicAutomationConfig
+    TopicAutomationConfig,
+    TopicDigestAutomationConfig
   ])
 });
 var ProjectLogsEvent = z6.object({
@@ -3080,7 +3418,7 @@ var ProjectLogsEvent = z6.object({
   comments: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
   audit_data: z6.union([z6.array(z6.unknown()), z6.null()]).optional(),
   _async_scoring_state: z6.unknown().optional(),
-  facets: z6.union([z6.object({}).partial().passthrough(), z6.null()]).optional(),
+  facets: z6.union([z6.record(z6.union([z6.string(), z6.null()])), z6.null()]).optional(),
   classifications: z6.union([
     z6.record(
       z6.array(
@@ -3129,11 +3467,34 @@ var ProjectScoreCategories = z6.union([
   z6.array(z6.string()),
   z6.null()
 ]);
+var ProjectScoreCondition = z6.union([
+  z6.object({
+    when: z6.object({
+      clauses: z6.union([z6.array(z6.string()), z6.null()]),
+      subspan_clauses: z6.union([z6.array(z6.string()), z6.null()]),
+      trace_clauses: z6.union([z6.array(z6.string()), z6.null()])
+    }).partial(),
+    behavior: z6.literal("hidden").optional().default("hidden")
+  }),
+  z6.null()
+]);
 var ProjectScoreConfig = z6.union([
   z6.object({
     multi_select: z6.union([z6.boolean(), z6.null()]),
     destination: z6.union([z6.string(), z6.null()]),
-    online: OnlineScoreConfig
+    visibility: z6.union([
+      z6.object({
+        users: z6.union([z6.array(z6.string()), z6.null()]),
+        groups: z6.union([z6.array(z6.string()), z6.null()])
+      }).partial(),
+      z6.null()
+    ]),
+    online: OnlineScoreConfig,
+    condition: ProjectScoreCondition,
+    object_types: z6.union([
+      z6.array(z6.enum(["project_logs", "dataset", "experiment"])),
+      z6.null()
+    ])
   }).partial(),
   z6.null()
 ]);
@@ -3318,8 +3679,7 @@ var User = z6.object({
   family_name: z6.union([z6.string(), z6.null()]).optional(),
   email: z6.union([z6.string(), z6.null()]).optional(),
   avatar_url: z6.union([z6.string(), z6.null()]).optional(),
-  created: z6.union([z6.string(), z6.null()]).optional(),
-  last_active_at: z6.union([z6.number(), z6.null()]).optional()
+  created: z6.union([z6.string(), z6.null()]).optional()
 });
 var ViewDataSearch = z6.union([
   z6.object({
@@ -4580,7 +4940,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();
@@ -4616,6 +4979,9 @@ var NoopSpan = class {
   async export() {
     return "";
   }
+  inject(carrier) {
+    return carrier ?? {};
+  }
   async permalink() {
     return NOOP_SPAN_PERMALINK;
   }
@@ -4666,6 +5032,10 @@ var loginSchema = z8.strictObject({
   debugLogLevelDisabled: z8.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;
@@ -4936,7 +5306,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;
   }
@@ -5609,7 +5982,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(),
@@ -5633,35 +6006,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 {
@@ -5862,6 +6247,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;
@@ -5956,12 +6357,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;
   }
@@ -6292,7 +6693,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({
@@ -6675,100 +7076,335 @@ 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 NOOP_SPAN;
+  return { parentObject: NOOP_SPAN, propagatedState: void 0 };
 }
-function logError(span, error) {
-  let errorMessage = "<error>";
-  let stackTrace = "";
-  if (error instanceof Error) {
-    errorMessage = error.message;
-    stackTrace = error.stack || "";
-  } else {
-    errorMessage = String(error);
+function currentBraintrustParent(state) {
+  const resolvedState = state ?? _globalState;
+  const experiment = currentExperiment({ state: resolvedState });
+  if (experiment) {
+    try {
+      return experiment._getOtelParent() ?? void 0;
+    } catch {
+      return void 0;
+    }
   }
-  span.log({ error: `${errorMessage}
-
-${stackTrace}` });
-}
-function startSpan(args) {
-  return startSpanAndIsLogger(args).span;
-}
-async function flush(options) {
-  const state = options?.state ?? _globalState;
-  return await state.bgLogger().flush();
+  const logger = currentLogger({ state: resolvedState });
+  if (logger) {
+    try {
+      return logger._getOtelParent() ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
 }
-function startSpanAndIsLogger(args) {
-  const state = args?.state ?? _globalState;
-  const parentObject = getSpanParentObject({
-    asyncFlush: args?.asyncFlush,
-    parent: args?.parent,
-    state
-  });
-  if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
-    const parentSpanIds = parentObject.data.row_id ? {
-      spanId: parentObject.data.span_id,
-      rootSpanId: parentObject.data.root_span_id
+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;
-    const span = new SpanImpl({
-      state,
-      ...args,
-      parentObjectType: parentObject.data.object_type,
-      parentObjectId: new LazyValue(
-        spanComponentsToObjectIdLambda(state, parentObject)
-      ),
-      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)
-    });
-    return {
-      span,
-      isSyncFlushLogger: parentObject.data.object_type === 2 /* PROJECT_LOGS */ && // Since there's no parent logger here, we're free to choose the async flush
-      // behavior, and therefore propagate along whatever we get from the arguments
-      args?.asyncFlush === false
-    };
-  } else {
-    const span = parentObject.startSpan(args);
-    return {
-      span,
-      isSyncFlushLogger: parentObject.kind === "logger" && parentObject.asyncFlush === false
-    };
   }
+  return void 0;
 }
-function withCurrent(span, callback, state = void 0) {
-  const currentState = state ?? _globalState;
-  return currentState.contextManager.runInContext(span, () => callback(span));
+function isMutableHeaderTupleArray(carrier) {
+  return Array.isArray(carrier) && carrier.every((item) => Array.isArray(item) && typeof item[0] === "string");
 }
-function _saveOrgInfo(state, org_info, org_name) {
-  if (org_info.length === 0) {
-    throw new LoginInvalidOrgError(
-      "This user is not part of any organizations."
-    );
+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;
   }
-  for (const org of org_info) {
-    if (org_name === void 0 || org.name === org_name) {
-      state.orgId = org.id;
-      state.orgName = org.name;
-      state.apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
-      state.proxyUrl = isomorph_default.getEnv("BRAINTRUST_PROXY_URL") ?? org.proxy_url;
-      state.gitMetadataSettings = org.git_metadata || void 0;
-      break;
+  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 {
+    }
+  }
+  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 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>";
+  let stackTrace = "";
+  if (error instanceof Error) {
+    errorMessage = error.message;
+    stackTrace = error.stack || "";
+  } else {
+    errorMessage = String(error);
+  }
+  span.log({ error: `${errorMessage}
+
+${stackTrace}` });
+}
+function startSpan(args) {
+  return startSpanAndIsLogger(args).span;
+}
+async function flush(options) {
+  const state = options?.state ?? _globalState;
+  return await state.bgLogger().flush();
+}
+function startSpanAndIsLogger(args) {
+  const state = args?.state ?? _globalState;
+  const { parentObject, propagatedState } = getSpanParentObjectAndPropagatedState({
+    asyncFlush: args?.asyncFlush,
+    parent: args?.parent,
+    state
+  });
+  if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
+    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,
+      ...spanArgs,
+      parentObjectType: parentObject.data.object_type,
+      parentObjectId: new LazyValue(
+        spanComponentsToObjectIdLambda(state, parentObject)
+      ),
+      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),
+      propagatedState
+    });
+    return {
+      span,
+      isSyncFlushLogger: parentObject.data.object_type === 2 /* PROJECT_LOGS */ && // Since there's no parent logger here, we're free to choose the async flush
+      // behavior, and therefore propagate along whatever we get from the arguments
+      args?.asyncFlush === false
+    };
+  } else {
+    const span = parentObject.startSpan(args);
+    return {
+      span,
+      isSyncFlushLogger: parentObject.kind === "logger" && parentObject.asyncFlush === false
+    };
+  }
+}
+function withCurrent(span, callback, state = void 0) {
+  const currentState = state ?? _globalState;
+  return currentState.contextManager.runInContext(span, () => callback(span));
+}
+function _saveOrgInfo(state, org_info, org_name) {
+  if (org_info.length === 0) {
+    throw new LoginInvalidOrgError(
+      "This user is not part of any organizations."
+    );
+  }
+  for (const org of org_info) {
+    if (org_name === void 0 || org.name === org_name) {
+      state.orgId = org.id;
+      state.orgName = org.name;
+      state.apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
+      state.proxyUrl = isomorph_default.getEnv("BRAINTRUST_PROXY_URL") ?? org.proxy_url;
+      state.gitMetadataSettings = org.git_metadata || void 0;
+      break;
     }
   }
   if (state.orgId === void 0) {
@@ -6962,11 +7598,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() {
@@ -7025,7 +7662,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
@@ -7374,6 +8011,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.
    */
@@ -7438,9 +8084,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);
@@ -7556,7 +8209,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(
@@ -7618,7 +8271,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
       })
     });
   }
@@ -7637,7 +8291,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
     });
@@ -7665,6 +8320,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
@@ -7800,6 +8491,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;
@@ -8766,6 +9458,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 tracingChannel = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
@@ -8927,6 +9635,14 @@ function traceStreamingChannel(channel2, config) {
             }
           },
           onError: (error) => {
+            runStreamingErrorHook({
+              channelName,
+              config,
+              error,
+              event: asyncEndEvent,
+              span,
+              startTime
+            });
             span.log({
               error: error.message
             });
@@ -8984,6 +9700,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);
     }
   };
@@ -11346,14 +12073,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();
@@ -11361,139 +12119,413 @@ 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;
   };
-  return {
-    onStart(event) {
-      runSafely("onStart", () => {
-        const operationName = operationNameFromId(event.operationId);
-        const span = startSpan({
-          name: operationName,
-          spanAttributes: { type: "function" /* FUNCTION */ }
-        });
-        operations.set(event.callId, {
-          hadModelChild: false,
-          operationName,
-          span,
-          startTime: getCurrentUnixTimestamp()
-        });
-        const metadata = metadataFromEvent(event);
-        const logPayload = { metadata };
-        if (shouldRecordInputs(event)) {
-          const { input, outputPromise } = processAISDKCallInput(
-            operationInput(event, operationName)
-          );
-          logPayload.input = input;
-          if (outputPromise && input && typeof input === "object") {
-            outputPromise.then((resolvedData) => {
-              span.log({
-                input: {
-                  ...input,
-                  ...resolvedData
-                }
-              });
-            }).catch(() => {
-            });
-          }
+  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;
         }
-        span.log(logPayload);
-      });
-    },
-    onLanguageModelCallStart(event) {
-      runSafely("onLanguageModelCallStart", () => {
-        const state = operations.get(event.callId);
-        const openSpans = modelSpans.get(event.callId);
-        if (openSpans) {
-          for (const span2 of openSpans) {
-            span2.end();
-          }
-          modelSpans.delete(event.callId);
+        const workflowOperationKey2 = workflowOperationKeyStore.getStore();
+        if (workflowOperationKey2 && operations.has(workflowOperationKey2)) {
+          return workflowOperationKey2;
         }
-        const span = startChildSpan(
-          event.callId,
-          state?.operationName === "streamText" ? "doStream" : "doGenerate",
-          "llm" /* LLM */,
-          {
-            ...shouldRecordInputs(event) ? {
-              input: processAISDKCallInput(
-                operationInput(
-                  event,
-                  state?.operationName ?? "generateText"
-                )
-              ).input
-            } : {},
-            metadata: metadataFromEvent(event)
-          }
-        );
-        const spans = modelSpans.get(event.callId) ?? [];
-        spans.push(span);
-        modelSpans.set(event.callId, spans);
-      });
-    },
-    onLanguageModelCallEnd(event) {
-      runSafely("onLanguageModelCallEnd", () => {
-        const span = shiftModelSpan(modelSpans, event.callId);
-        if (!span) {
-          return;
+        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);
         }
-        const result = {
-          ...event,
-          response: event.responseId ? { id: event.responseId } : void 0
-        };
-        span.log({
-          ...shouldRecordOutputs(event) ? {
-            output: processAISDKOutput(result, DEFAULT_DENY_OUTPUT_PATHS)
-          } : {},
-          metrics: extractTokenMetrics(result)
-        });
         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 workflowAgent = operationName === "WorkflowAgent.stream";
+        const wrapperSpan = workflowAgent ? currentWorkflowAgentWrapperSpan() : void 0;
+        const ownsSpan = !wrapperSpan;
+        const span = ownsSpan ? startSpan({
+          name: operationName,
+          spanAttributes: { type: "function" /* FUNCTION */ }
+        }) : wrapperSpan;
+        const operationKey = createOperationKey(event, operationName);
+        registerOperation({
+          callId: event.callId,
+          hadModelChild: false,
+          loggedInput: false,
+          operationName,
+          operationKey,
+          ownsSpan,
+          span,
+          startTime: getCurrentUnixTimestamp()
+        });
+        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 callInput = workflowAgentCallInput ?? operationInput(event, operationName);
+          const { input, outputPromise } = workflowAgent ? processAISDKWorkflowAgentCallInput(callInput) : processAISDKCallInput(callInput);
+          logPayload.input = input;
+          const state = operations.get(operationKey);
+          if (state) {
+            state.loggedInput = hasPromptLikeInput(input);
+          }
+          if (outputPromise && !workflowAgent && input && typeof input === "object") {
+            outputPromise.then((resolvedData) => {
+              span.log({
+                input: {
+                  ...input,
+                  ...resolvedData
+                }
+              });
+            }).catch(() => {
+            });
+          }
+        }
+        span.log(logPayload);
       });
     },
-    onObjectStepStart(event) {
-      runSafely("onObjectStepStart", () => {
-        const state = operations.get(event.callId);
-        const openSpan = objectSpans.get(event.callId);
-        if (openSpan) {
-          openSpan.end();
-          objectSpans.delete(event.callId);
+    onLanguageModelCallStart(event) {
+      runSafely("onLanguageModelCallStart", () => {
+        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(operationKey);
         }
         const span = startChildSpan(
-          event.callId,
-          state?.operationName === "streamObject" ? "doStream" : "doGenerate",
+          operationKey ?? event.callId,
+          operationName === "streamText" ? "doStream" : "doGenerate",
           "llm" /* LLM */,
           {
             ...shouldRecordInputs(event) ? {
-              input: {
-                prompt: event.promptMessages
-              }
+              input: processedInput
             } : {},
-            metadata: metadataFromEvent(event)
+            metadata: workflowAgent ? {
+              ...metadataFromEvent(event),
+              ...extractWorkflowMetadataFromCallParams(callInput)
+            } : metadataFromEvent(event)
           }
         );
-        objectSpans.set(event.callId, span);
+        const spanKey = operationKey ?? event.callId;
+        const spans = modelSpans.get(spanKey) ?? [];
+        spans.push(span);
+        modelSpans.set(spanKey, spans);
       });
     },
-    onObjectStepFinish(event) {
-      runSafely("onObjectStepFinish", () => {
-        const span = objectSpans.get(event.callId);
+    onLanguageModelCallEnd(event) {
+      runSafely("onLanguageModelCallEnd", () => {
+        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,
-          text: event.objectText
+          response: event.responseId ? { id: event.responseId } : void 0
         };
         span.log({
           ...shouldRecordOutputs(event) ? {
@@ -11502,20 +12534,52 @@ function braintrustAISDKTelemetry() {
           metrics: extractTokenMetrics(result)
         });
         span.end();
-        objectSpans.delete(event.callId);
       });
     },
+    onObjectStepStart(event) {
+      runSafely("onObjectStepStart", () => {
+        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(operationKey);
+        }
+        const span = startChildSpan(
+          operationKey ?? event.callId,
+          state?.operationName === "streamObject" ? "doStream" : "doGenerate",
+          "llm" /* LLM */,
+          {
+            ...shouldRecordInputs(event) ? {
+              input: {
+                prompt: event.promptMessages
+              }
+            } : {},
+            metadata: metadataFromEvent(event)
+          }
+        );
+        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 */,
           {
@@ -11528,44 +12592,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 */,
           {
@@ -11579,41 +12626,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 */,
           {
@@ -11627,7 +12656,7 @@ function braintrustAISDKTelemetry() {
             }
           }
         );
-        toolSpans.set(toolCallId, { callId: event.callId, span });
+        toolSpans.set(toolCallId, { operationKey, span });
       });
     },
     onToolExecutionEnd(event) {
@@ -11638,14 +12667,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 } : {}
           });
         }
@@ -11659,83 +12691,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 }) {
@@ -11750,7 +12745,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) {
@@ -11796,6 +12800,7 @@ function operationInput(event, operationName) {
   }
   return {
     model: modelFromEvent(event),
+    instructions: event.instructions,
     system: event.system,
     prompt: event.prompt,
     messages: event.messages,
@@ -11844,6 +12849,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 performance of performanceCandidates) {
+    const timeToFirstOutputMs = performance?.timeToFirstOutputMs;
+    if (typeof timeToFirstOutputMs === "number") {
+      return timeToFirstOutputMs / 1e3;
+    }
+  }
+  return void 0;
+}
+function safePerformance(value) {
+  if (!isObject(value)) {
+    return void 0;
+  }
+  const performance = value.performance;
+  return isObject(performance) ? performance : void 0;
+}
 function finishOutput(result, operationName) {
   if (operationName === "embed" || operationName === "embedMany") {
     return processAISDKEmbeddingOutput(
@@ -11920,6 +12949,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "ToolLoopAgent.stream",
     kind: "async"
   }),
+  workflowAgentStream: channel({
+    channelName: "WorkflowAgent.stream",
+    kind: "async"
+  }),
   v7CreateTelemetryDispatcher: channel({
     channelName: "createTelemetryDispatcher",
     kind: "sync-stream"
@@ -11930,14 +12963,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"
 ];
@@ -11949,6 +12987,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",
@@ -11957,14 +13007,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 {
@@ -12122,7 +13174,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(
@@ -12138,7 +13192,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)
@@ -12158,7 +13214,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,
@@ -12172,7 +13230,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(
@@ -12188,7 +13248,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)
@@ -12204,6 +13266,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() {
@@ -12215,7 +13313,11 @@ function subscribeToAISDKV7TelemetryDispatcher() {
       if (telemetryOptions?.isEnabled === false) {
         return;
       }
-      patchAISDKV7TelemetryDispatcher(event.result, telemetry);
+      patchAISDKV7TelemetryDispatcher(
+        event.result,
+        telemetry,
+        telemetryOptions
+      );
     }
   };
   channel2.subscribe(handlers);
@@ -12223,7 +13325,7 @@ function subscribeToAISDKV7TelemetryDispatcher() {
     channel2.unsubscribe(handlers);
   };
 }
-function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry) {
+function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry, telemetryOptions) {
   if (!isObject(dispatcher)) {
     return;
   }
@@ -12232,6 +13334,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") {
@@ -12240,11 +13390,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;
@@ -12254,6 +13410,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()
   });
 }
@@ -12352,6 +13509,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);
   }
@@ -12385,10 +13544,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;
@@ -12552,7 +13711,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) => {
@@ -12571,7 +13744,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) {
@@ -12608,6 +13803,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: {
@@ -12619,6 +13817,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(
@@ -12634,12 +13839,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);
 }
@@ -12653,65 +14021,228 @@ 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 = {};
@@ -12719,6 +14250,44 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
         let reasoning = "";
         const toolCalls = [];
         let object = void 0;
+        let streamSpanEnded = false;
+        const logAndEndStreamSpan = (usageUnavailableReason) => {
+          if (streamSpanEnded) {
+            return;
+          }
+          output.text = text;
+          output.reasoning = reasoning;
+          output.toolCalls = toolCalls;
+          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)) {
@@ -12756,33 +14325,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 {
@@ -12792,32 +14343,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) {
@@ -12833,15 +14431,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 */
           }
@@ -12849,8 +14447,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       );
     };
     cleanup.push(() => {
-      tool.execute = originalExecute;
-      delete tool[AUTO_PATCHED_TOOL];
+      cleanupToolEntry(state);
     });
   };
   const patchTools = (tools) => {
@@ -12869,25 +14466,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) {
@@ -12984,99 +14598,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 = [
@@ -13108,34 +14813,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 {
+          }
+        }
       }
     }
   };
@@ -13210,6 +14953,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;
@@ -13233,7 +15010,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") {
@@ -13324,6 +15139,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,
@@ -13447,7 +15264,9 @@ function extractGetterValues(obj) {
   const getterValues = {};
   const getterNames = [
     "content",
+    "messages",
     "text",
+    "output",
     "object",
     "value",
     "values",
@@ -13487,7 +15306,9 @@ function extractGetterValues(obj) {
 function extractSerializableOutputFields(output) {
   const serialized = {};
   const directFieldNames = [
+    "messages",
     "steps",
+    "output",
     "request",
     "responseMessages",
     "warnings",
@@ -13669,7 +15490,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);
@@ -13679,29 +15500,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;
 }
@@ -23750,15 +25578,18 @@ function observeFlue(event, ctx) {
   getObserveBridge().handle(event, ctx);
 }
 var interceptFlueExecution = (operation, ctx, next) => getObserveBridge().intercept(operation, ctx, next);
-var braintrustFlueObserver = Object.assign(
-  observeFlue,
-  {
+function braintrustFlueInstrumentation() {
+  return {
     dispose() {
     },
     interceptor: interceptFlueExecution,
     key: FLUE_INSTRUMENTATION_KEY,
     observe: observeFlue
-  }
+  };
+}
+var braintrustFlueObserver = Object.assign(
+  observeFlue,
+  braintrustFlueInstrumentation()
 );
 var FluePlugin = class extends BasePlugin {
   onEnable() {
@@ -27314,6 +29145,7 @@ export {
   BasePlugin,
   BraintrustPlugin,
   OpenAIAgentsTraceProcessor,
+  braintrustFlueInstrumentation,
   braintrustFlueObserver,
   configureInstrumentation,
   createChannelName,