braintrust 3.19.0 → 3.21.0

package/dist/cli.js

@@ -1232,7 +1232,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "3.19.0",
+      version: "3.21.0",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
@@ -1369,12 +1369,14 @@ var require_package = __commonJS({
         "util/dist/**/*",
         "bin/bt",
         "scripts/bt-helper.js",
-        "scripts/install.js"
+        "scripts/install.js",
+        "NOTICE",
+        "licenses/**/*"
       ],
       scripts: {
         postinstall: "node ./scripts/install.js",
         build: 'cross-env NODE_OPTIONS="--max-old-space-size=8192" tsup',
-        "check:typings": "tsc --noEmit",
+        "check:typings": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
         watch: "tsup --watch",
         clean: "rm -r dist/* && rm -r dev/dist/* && rm -r util/dist/*",
         docs: "typedoc --options typedoc.json src/node/index.ts",
@@ -1439,24 +1441,31 @@ var require_package = __commonJS({
         zod: "^3.25.34"
       },
       dependencies: {
-        "@apm-js-collab/code-transformer": "^0.12.0",
         "@next/env": "^14.2.3",
+        "@types/estree": "^1.0.8",
         "@vercel/functions": "^1.0.2",
+        acorn: "^8.16.0",
+        "acorn-import-attributes": "^1.9.5",
         ajv: "^8.20.0",
         argparse: "^2.0.1",
+        astring: "^1.9.0",
+        "cjs-module-lexer": "^2.2.0",
         "cli-progress": "^3.12.0",
         "cli-table3": "^0.6.5",
         cors: "^2.8.5",
         "dc-browser": "^1.0.4",
         dotenv: "^16.4.5",
         esbuild: "0.28.0",
+        esquery: "^1.7.0",
         "eventsource-parser": "^1.1.2",
         express: "^5.2.1",
         "http-errors": "^2.0.0",
+        meriyah: "^6.1.4",
         minimatch: "^10.2.5",
         "module-details-from-path": "^1.0.4",
         mustache: "^4.2.0",
         pluralize: "^8.0.0",
+        semifies: "^1.0.0",
         "simple-git": "^3.36.0",
         "source-map": "^0.7.4",
         "termi-link": "^1.0.1",
@@ -1782,8 +1791,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
@@ -2391,7 +2683,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");
     }
   }
@@ -2931,7 +3223,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}`);
     }
   }
@@ -3126,7 +3418,8 @@ var AclObjectType = import_v36.z.union([
     "role",
     "org_member",
     "project_log",
-    "org_project"
+    "org_project",
+    "org_audit_logs"
   ]),
   import_v36.z.null()
 ]);
@@ -3152,6 +3445,17 @@ var Acl = import_v36.z.object({
   _object_org_id: import_v36.z.string().uuid(),
   created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
 });
+var Agent = import_v36.z.object({
+  id: import_v36.z.string().uuid(),
+  project_id: import_v36.z.string().uuid(),
+  user_id: import_v36.z.string().uuid(),
+  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  name: import_v36.z.string(),
+  slug: import_v36.z.string(),
+  kind: import_v36.z.string(),
+  description: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
+  metadata: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional()
+});
 var AISecret = import_v36.z.object({
   id: import_v36.z.string().uuid(),
   created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
@@ -3298,6 +3602,7 @@ var AttachmentStatus = import_v36.z.object({
   upload_status: UploadStatus,
   error_message: import_v36.z.string().optional()
 });
+var AutomationStatus = import_v36.z.enum(["active", "paused"]);
 var FunctionTypeEnum = import_v36.z.enum([
   "llm",
   "scorer",
@@ -3343,7 +3648,9 @@ var TopicMapData = import_v36.z.object({
   topic_names: import_v36.z.record(import_v36.z.string()).optional(),
   generation_settings: TopicMapGenerationSettings.optional(),
   disable_reconciliation: import_v36.z.boolean().optional(),
-  distance_threshold: import_v36.z.number().optional()
+  distance_threshold: import_v36.z.number().optional(),
+  btql_filter: import_v36.z.string().optional(),
+  automation_btql_filter: import_v36.z.string().optional()
 });
 var BatchedFacetData = import_v36.z.object({
   type: import_v36.z.literal("batched_facet"),
@@ -3626,7 +3933,7 @@ var DatasetEvent = import_v36.z.object({
   origin: ObjectReferenceNullish.optional(),
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
-  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  facets: import_v36.z.union([import_v36.z.record(import_v36.z.union([import_v36.z.string(), import_v36.z.null()])), import_v36.z.null()]).optional(),
   classifications: import_v36.z.union([
     import_v36.z.record(
       import_v36.z.array(
@@ -3778,7 +4085,7 @@ var ExperimentEvent = import_v36.z.object({
   origin: ObjectReferenceNullish.optional(),
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
-  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  facets: import_v36.z.union([import_v36.z.record(import_v36.z.union([import_v36.z.string(), import_v36.z.null()])), import_v36.z.null()]).optional(),
   classifications: import_v36.z.union([
     import_v36.z.record(
       import_v36.z.array(
@@ -3916,7 +4223,8 @@ var PromptParserNullish = import_v36.z.union([
     use_cot: import_v36.z.boolean(),
     choice_scores: import_v36.z.record(import_v36.z.number().gte(0).lte(1)).optional(),
     choice: import_v36.z.array(import_v36.z.string()).optional(),
-    allow_no_match: import_v36.z.boolean().optional()
+    allow_no_match: import_v36.z.boolean().optional(),
+    allow_skip: import_v36.z.boolean().optional()
   }),
   import_v36.z.null()
 ]);
@@ -4246,6 +4554,9 @@ var Group = import_v36.z.object({
 var GroupScope = import_v36.z.object({
   type: import_v36.z.literal("group"),
   group_by: import_v36.z.string(),
+  interval_seconds: import_v36.z.number().gte(1).optional(),
+  max_traces: import_v36.z.number().int().gte(1).lte(64).optional(),
+  placement: import_v36.z.enum(["first", "each"]),
   idle_seconds: import_v36.z.number().optional()
 });
 var IfExists = import_v36.z.enum(["error", "ignore", "replace"]);
@@ -4394,6 +4705,10 @@ var RetentionObjectType = import_v36.z.enum([
   "experiment",
   "dataset"
 ]);
+var TopicAutomationFacetModel = import_v36.z.union([
+  import_v36.z.enum(["brain-facet-latest", "brain-facet-1", "brain-facet-2"]),
+  import_v36.z.null()
+]);
 var TopicMapFunctionAutomation = import_v36.z.object({
   function: SavedFunctionId.and(import_v36.z.unknown()),
   btql_filter: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
@@ -4406,7 +4721,9 @@ var TopicAutomationDataScope = import_v36.z.union([
 ]);
 var TopicAutomationConfig = import_v36.z.object({
   event_type: import_v36.z.literal("topic"),
+  status: AutomationStatus.optional(),
   sampling_rate: import_v36.z.number().gte(0).lte(1),
+  facet_model: TopicAutomationFacetModel.optional(),
   facet_functions: import_v36.z.array(SavedFunctionId),
   topic_map_functions: import_v36.z.array(TopicMapFunctionAutomation),
   scope: import_v36.z.union([SpanScope, TraceScope, GroupScope, import_v36.z.null()]).optional(),
@@ -4420,6 +4737,19 @@ var TopicAutomationConfig = import_v36.z.object({
     import_v36.z.null()
   ]).optional()
 });
+var TopicDigestAutomationConfig = import_v36.z.object({
+  event_type: import_v36.z.literal("topic_digest"),
+  status: AutomationStatus.optional(),
+  window_seconds: import_v36.z.number().int().gte(3600).lte(2592e3).optional().default(86400),
+  scheduled_time_minutes_utc: import_v36.z.number().int().gte(0).lte(1439),
+  action: import_v36.z.object({
+    type: import_v36.z.literal("slack"),
+    workspace_id: import_v36.z.string(),
+    channel: import_v36.z.string(),
+    message_template: import_v36.z.string().optional()
+  }),
+  topic_map_function_ids: import_v36.z.array(import_v36.z.string()).max(10).optional()
+});
 var ProjectAutomation = import_v36.z.object({
   id: import_v36.z.string().uuid(),
   project_id: import_v36.z.string().uuid(),
@@ -4444,6 +4774,7 @@ var ProjectAutomation = import_v36.z.object({
     }),
     import_v36.z.object({
       event_type: import_v36.z.literal("btql_export"),
+      status: AutomationStatus.optional(),
       export_definition: import_v36.z.union([
         import_v36.z.object({ type: import_v36.z.literal("log_traces") }),
         import_v36.z.object({ type: import_v36.z.literal("log_spans") }),
@@ -4466,6 +4797,21 @@ var ProjectAutomation = import_v36.z.object({
       ]),
       batch_size: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional()
     }),
+    import_v36.z.object({
+      event_type: import_v36.z.literal("async_query"),
+      status: AutomationStatus.optional(),
+      created_by_user_id: import_v36.z.string().uuid(),
+      object_type: import_v36.z.enum([
+        "project_logs",
+        "experiment",
+        "dataset",
+        "playground_logs"
+      ]),
+      object_id: import_v36.z.string(),
+      query: import_v36.z.string(),
+      format: import_v36.z.literal("jsonl"),
+      batch_size: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional()
+    }),
     import_v36.z.object({
       event_type: import_v36.z.literal("retention"),
       object_type: RetentionObjectType,
@@ -4484,7 +4830,8 @@ var ProjectAutomation = import_v36.z.object({
         })
       ])
     }),
-    TopicAutomationConfig
+    TopicAutomationConfig,
+    TopicDigestAutomationConfig
   ])
 });
 var ProjectLogsEvent = import_v36.z.object({
@@ -4523,7 +4870,7 @@ var ProjectLogsEvent = import_v36.z.object({
   comments: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   audit_data: import_v36.z.union([import_v36.z.array(import_v36.z.unknown()), import_v36.z.null()]).optional(),
   _async_scoring_state: import_v36.z.unknown().optional(),
-  facets: import_v36.z.union([import_v36.z.object({}).partial().passthrough(), import_v36.z.null()]).optional(),
+  facets: import_v36.z.union([import_v36.z.record(import_v36.z.union([import_v36.z.string(), import_v36.z.null()])), import_v36.z.null()]).optional(),
   classifications: import_v36.z.union([
     import_v36.z.record(
       import_v36.z.array(
@@ -4572,11 +4919,34 @@ var ProjectScoreCategories = import_v36.z.union([
   import_v36.z.array(import_v36.z.string()),
   import_v36.z.null()
 ]);
+var ProjectScoreCondition = import_v36.z.union([
+  import_v36.z.object({
+    when: import_v36.z.object({
+      clauses: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()]),
+      subspan_clauses: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()]),
+      trace_clauses: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()])
+    }).partial(),
+    behavior: import_v36.z.literal("hidden").optional().default("hidden")
+  }),
+  import_v36.z.null()
+]);
 var ProjectScoreConfig = import_v36.z.union([
   import_v36.z.object({
     multi_select: import_v36.z.union([import_v36.z.boolean(), import_v36.z.null()]),
     destination: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]),
-    online: OnlineScoreConfig
+    visibility: import_v36.z.union([
+      import_v36.z.object({
+        users: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()]),
+        groups: import_v36.z.union([import_v36.z.array(import_v36.z.string()), import_v36.z.null()])
+      }).partial(),
+      import_v36.z.null()
+    ]),
+    online: OnlineScoreConfig,
+    condition: ProjectScoreCondition,
+    object_types: import_v36.z.union([
+      import_v36.z.array(import_v36.z.enum(["project_logs", "dataset", "experiment"])),
+      import_v36.z.null()
+    ])
   }).partial(),
   import_v36.z.null()
 ]);
@@ -4761,8 +5131,7 @@ var User = import_v36.z.object({
   family_name: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   email: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
   avatar_url: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
-  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional(),
-  last_active_at: import_v36.z.union([import_v36.z.number(), import_v36.z.null()]).optional()
+  created: import_v36.z.union([import_v36.z.string(), import_v36.z.null()]).optional()
 });
 var ViewDataSearch = import_v36.z.union([
   import_v36.z.object({
@@ -6049,7 +6418,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();
@@ -6085,6 +6457,9 @@ var NoopSpan = class {
   async export() {
     return "";
   }
+  inject(carrier) {
+    return carrier ?? {};
+  }
   async permalink() {
     return NOOP_SPAN_PERMALINK;
   }
@@ -6135,6 +6510,10 @@ var loginSchema = import_v38.z.strictObject({
   debugLogLevelDisabled: import_v38.z.boolean().optional()
 });
 var stateNonce = 0;
+var V1_PROXY_SUFFIX = "/v1/proxy";
+function normalizeProxyConnUrl(proxyUrl) {
+  return proxyUrl.endsWith(V1_PROXY_SUFFIX) ? proxyUrl.slice(0, proxyUrl.length - V1_PROXY_SUFFIX.length) : proxyUrl;
+}
 var BraintrustState = class _BraintrustState {
   constructor(loginParams) {
     this.loginParams = loginParams;
@@ -6405,7 +6784,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;
   }
@@ -7091,7 +7473,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(),
@@ -7115,35 +7497,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 {
@@ -7344,6 +7738,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;
@@ -7438,12 +7848,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;
   }
@@ -7774,7 +8184,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({
@@ -8366,6 +8776,8 @@ function initDataset(projectOrOptions, optionalOptions) {
   const normalizedVersion = selection.version;
   const normalizedEnvironment = selection.environment;
   const normalizedSnapshotName = selection.snapshotName;
+  const cliInternalBtql = globalThis.__bt_eval_internal_btql;
+  const internalBtql = cliInternalBtql === void 0 ? _internal_btql : _internal_btql === void 0 ? cliInternalBtql : isObject(_internal_btql) ? { ...cliInternalBtql, ..._internal_btql } : _internal_btql;
   const state = stateArg ?? _globalState;
   const lazyMetadata = new LazyValue(
     async () => {
@@ -8417,7 +8829,7 @@ function initDataset(projectOrOptions, optionalOptions) {
     lazyMetadata,
     typeof resolvedVersion === "string" ? resolvedVersion : void 0,
     legacy,
-    _internal_btql,
+    internalBtql,
     resolvedVersion instanceof LazyValue || normalizedEnvironment !== void 0 || normalizedSnapshotName !== void 0 ? {
       ...resolvedVersion instanceof LazyValue ? {
         lazyPinnedVersion: resolvedVersion
@@ -8628,23 +9040,256 @@ 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 getSpanParentObject(options) {
+  return getSpanParentObjectAndPropagatedState(options).parentObject;
+}
+function currentBraintrustParent(state) {
+  const resolvedState = state ?? _globalState;
+  const experiment = currentExperiment({ state: resolvedState });
+  if (experiment) {
+    try {
+      return experiment._getOtelParent() ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  const logger = currentLogger({ state: resolvedState });
+  if (logger) {
+    try {
+      return logger._getOtelParent() ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function braintrustParentToComponents(braintrustParent) {
+  if (!braintrustParent) {
+    return void 0;
+  }
+  if (braintrustParent.startsWith("project_id:")) {
+    const objectId = braintrustParent.slice("project_id:".length);
+    return objectId ? {
+      objectType: 2 /* PROJECT_LOGS */,
+      objectId,
+      computeArgs: void 0
+    } : void 0;
+  }
+  if (braintrustParent.startsWith("project_name:")) {
+    const name = braintrustParent.slice("project_name:".length);
+    return name ? {
+      objectType: 2 /* PROJECT_LOGS */,
+      objectId: void 0,
+      computeArgs: { project_name: name }
+    } : void 0;
+  }
+  if (braintrustParent.startsWith("experiment_id:")) {
+    const objectId = braintrustParent.slice("experiment_id:".length);
+    return objectId ? {
+      objectType: 1 /* EXPERIMENT */,
+      objectId,
+      computeArgs: void 0
+    } : void 0;
+  }
+  return void 0;
+}
+function isMutableHeaderTupleArray(carrier) {
+  return Array.isArray(carrier) && carrier.every((item) => Array.isArray(item) && typeof item[0] === "string");
+}
+function setHeader(carrier, name, value) {
+  if (isMutableHeaderTupleArray(carrier)) {
+    const lowered2 = name.toLowerCase();
+    for (let i = carrier.length - 1; i >= 0; i--) {
+      if (carrier[i][0].toLowerCase() === lowered2) {
+        carrier.splice(i, 1);
+      }
+    }
+    carrier.push([name, value]);
+    return;
+  }
+  const setter = carrier.set;
+  if (typeof setter === "function") {
+    const deleter = carrier.delete;
+    if (typeof deleter === "function") {
+      try {
+        deleter.call(carrier, name);
+      } catch {
+      }
+    }
+    setter.call(carrier, name, value);
+    return;
+  }
+  const nodeSetter = carrier.setHeader;
+  if (typeof nodeSetter === "function") {
+    const remover = carrier.removeHeader;
+    if (typeof remover === "function") {
+      try {
+        remover.call(carrier, name);
+      } catch {
+      }
+    }
+    nodeSetter.call(carrier, name, value);
+    return;
+  }
+  const headerSetter = carrier.header;
+  if (typeof headerSetter === "function") {
+    const deleter = carrier.delete;
+    if (typeof deleter === "function") {
+      try {
+        deleter.call(carrier, name);
+      } catch {
+      }
+    }
+    const remover = carrier.removeHeader;
+    if (typeof remover === "function") {
+      try {
+        remover.call(carrier, name);
+      } catch {
+      }
+    }
+    headerSetter.call(carrier, name, value);
+    return;
+  }
+  const headerBag = carrier;
+  const lowered = name.toLowerCase();
+  for (const key of Object.keys(headerBag)) {
+    if (key !== name && key.toLowerCase() === lowered) {
+      delete headerBag[key];
+    }
+  }
+  headerBag[name] = value;
+}
+function deleteHeader(carrier, name) {
+  const lowered = name.toLowerCase();
+  if (isMutableHeaderTupleArray(carrier)) {
+    for (let i = carrier.length - 1; i >= 0; i--) {
+      if (carrier[i][0].toLowerCase() === lowered) {
+        carrier.splice(i, 1);
+      }
+    }
+    return;
+  }
+  const deleter = carrier.delete;
+  if (typeof deleter === "function") {
+    try {
+      deleter.call(carrier, name);
+      return;
+    } catch {
+    }
+  }
+  const remover = carrier.removeHeader;
+  if (typeof remover === "function") {
+    try {
+      remover.call(carrier, name);
+      return;
+    } catch {
+    }
+  }
+  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(context2, state) {
+  const traceparent = getHeader(context2, 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(context2, 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(context2, 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, error2) {
   let errorMessage = "<error>";
@@ -8696,19 +9341,23 @@ async function flush(options) {
 }
 function startSpanAndIsLogger(args) {
   const state = args?.state ?? _globalState;
-  const parentObject = getSpanParentObject({
+  const { parentObject, propagatedState } = getSpanParentObjectAndPropagatedState({
     asyncFlush: args?.asyncFlush,
     parent: args?.parent,
     state
   });
   if (parentObject instanceof SpanComponentsV3 || parentObject instanceof SpanComponentsV4) {
-    const parentSpanIds = parentObject.data.row_id ? {
+    const parentSpanIds = parentObject.data.row_id && parentSpanIdsUsable(
+      parentObject.data.span_id,
+      parentObject.data.root_span_id
+    ) ? {
       spanId: parentObject.data.span_id,
       rootSpanId: parentObject.data.root_span_id
     } : void 0;
+    const { parent: _ignoredParent, ...spanArgs } = args ?? {};
     const span = new SpanImpl({
       state,
-      ...args,
+      ...spanArgs,
       parentObjectType: parentObject.data.object_type,
       parentObjectId: new LazyValue(
         spanComponentsToObjectIdLambda(state, parentObject)
@@ -8716,7 +9365,8 @@ function startSpanAndIsLogger(args) {
       parentComputeObjectMetadataArgs: parentObject.data.compute_object_metadata_args ?? void 0,
       parentSpanIds,
       propagatedEvent: args?.propagatedEvent ?? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      (parentObject.data.propagated_event ?? void 0)
+      (parentObject.data.propagated_event ?? void 0),
+      propagatedState
     });
     return {
       span,
@@ -8959,11 +9609,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() {
@@ -9022,7 +9673,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
@@ -9371,6 +10022,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.
    */
@@ -9413,7 +10073,8 @@ var ReadonlyExperiment = class extends ObjectFetcher {
   async *asDataset(options) {
     const records = this.fetch(options);
     for await (const record of records) {
-      if (record.root_span_id !== record.span_id) {
+      const isRoot = record.is_root ?? record.root_span_id === record.span_id;
+      if (!isRoot) {
         continue;
       }
       const { output, expected: expectedRecord, metadata } = record;
@@ -9475,9 +10136,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);
@@ -9593,7 +10261,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(
@@ -9655,7 +10323,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
       })
     });
   }
@@ -9674,7 +10343,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
     });
@@ -9702,6 +10372,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
@@ -9837,6 +10543,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;
@@ -10351,6 +11058,7 @@ var Prompt2 = class _Prompt {
     this.metadata = metadata;
     this.defaults = defaults;
     this.noTrace = noTrace;
+    void this.__braintrust_prompt_marker;
   }
   parsedPromptData;
   hasParsedPromptData = false;
@@ -10587,6 +11295,7 @@ var Prompt2 = class _Prompt {
 var RemoteEvalParameters = class {
   constructor(metadata) {
     this.metadata = metadata;
+    void this.__braintrust_parameters_marker;
   }
   __braintrust_parameters_marker = true;
   get id() {
@@ -11812,15 +12521,21 @@ async function invoke(args) {
 
 // src/trace.ts
 var SpanFetcher = class _SpanFetcher extends ObjectFetcher {
-  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false) {
+  constructor(objectType, _objectId, rootSpanId, _state, spanTypeFilter, includeScorers = false, brainstoreRealtime = true) {
     const filterExpr = _SpanFetcher.buildFilter(
       rootSpanId,
       spanTypeFilter,
       includeScorers
     );
-    super(objectType, void 0, void 0, {
-      filter: filterExpr
-    });
+    super(
+      objectType,
+      void 0,
+      void 0,
+      {
+        filter: filterExpr
+      },
+      brainstoreRealtime
+    );
     this._objectId = _objectId;
     this.rootSpanId = rootSpanId;
     this._state = _state;
@@ -11874,7 +12589,7 @@ var CachedSpanFetcher = class {
   spanCache = /* @__PURE__ */ new Map();
   allFetched = false;
   fetchFn;
-  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState) {
+  constructor(objectTypeOrFetchFn, objectId, rootSpanId, getState, brainstoreRealtime = true) {
     if (typeof objectTypeOrFetchFn === "function") {
       this.fetchFn = (spanType) => objectTypeOrFetchFn(spanType);
     } else {
@@ -11887,7 +12602,8 @@ var CachedSpanFetcher = class {
           rootSpanId,
           state,
           spanType,
-          includeScorers
+          includeScorers,
+          brainstoreRealtime
         );
         const rows = await fetcher.fetchedData();
         return rows.map((row) => ({
@@ -12708,7 +13424,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             }
           };
           const parentStr = state.currentParent.getStore();
-          const parentComponents = parentStr ? SpanComponentsV3.fromStr(parentStr) : null;
+          const parentComponents = typeof parentStr === "string" ? SpanComponentsV4.fromStr(parentStr) : null;
           const trace = state ? new LocalTrace({
             objectType: parentComponents ? spanObjectTypeV3ToTypedString(
               parentComponents.data.object_type
@@ -14539,6 +15255,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 (error2) {
+    debugLogger.error(`Error in onError hook for ${args.channelName}:`, error2);
+  }
+}
 function traceAsyncChannel(channel2, config3) {
   const tracingChannel2 = channel2.tracingChannel();
   const states = /* @__PURE__ */ new WeakMap();
@@ -14700,6 +15432,14 @@ function traceStreamingChannel(channel2, config3) {
             }
           },
           onError: (error2) => {
+            runStreamingErrorHook({
+              channelName,
+              config: config3,
+              error: error2,
+              event: asyncEndEvent,
+              span,
+              startTime
+            });
             span.log({
               error: error2.message
             });
@@ -14757,6 +15497,17 @@ function traceStreamingChannel(channel2, config3) {
       }
     },
     error: (event) => {
+      const spanData = states.get(event);
+      if (spanData) {
+        runStreamingErrorHook({
+          channelName,
+          config: config3,
+          error: event.error,
+          event,
+          span: spanData.span,
+          startTime: spanData.startTime
+        });
+      }
       logErrorAndEnd(states, event);
     }
   };
@@ -17119,14 +17870,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();
@@ -17134,42 +17916,333 @@ function braintrustAISDKTelemetry() {
       console.error(`Error in Braintrust AI SDK telemetry ${name}:`, error2);
     }
   };
-  const startChildSpan = (callId, name, type, event) => {
-    const parent = operations.get(callId)?.span;
+  const startChildSpan = (operationKey, name, type, event) => {
+    const parent = operations.get(operationKey)?.span;
     const spanArgs = {
       name,
       spanAttributes: { type },
       ...event ? { event } : {}
     };
     const span = parent ? parent.startSpan(spanArgs) : startSpan(spanArgs);
-    const state = operations.get(callId);
+    const state = operations.get(operationKey);
     if (state && type === "llm" /* LLM */) {
       state.hadModelChild = true;
     }
     return span;
   };
+  const registerOperation = (state) => {
+    operations.set(state.operationKey, state);
+    const keys = operationKeysByCallId.get(state.callId) ?? [];
+    keys.push(state.operationKey);
+    operationKeysByCallId.set(state.callId, keys);
+  };
+  const deleteOperation = (operationKey) => {
+    const state = operations.get(operationKey);
+    if (!state) {
+      return;
+    }
+    operations.delete(operationKey);
+    if (workflowOperationKeyStore.getStore() === operationKey) {
+      workflowOperationKeyStore.enterWith(void 0);
+    }
+    const keys = operationKeysByCallId.get(state.callId);
+    if (!keys) {
+      return;
+    }
+    const index = keys.indexOf(operationKey);
+    if (index >= 0) {
+      keys.splice(index, 1);
+    }
+    if (keys.length === 0) {
+      operationKeysByCallId.delete(state.callId);
+    }
+  };
+  const explicitOperationKey = (event) => {
+    if (!isObject(event)) {
+      return void 0;
+    }
+    const key = event[BRAINTRUST_AI_SDK_V7_OPERATION_KEY];
+    return typeof key === "string" ? key : void 0;
+  };
+  const createOperationKey = (event, operationName) => {
+    const explicit = explicitOperationKey(event);
+    if (explicit) {
+      return explicit;
+    }
+    if (operationName === "WorkflowAgent.stream") {
+      workflowAgentOperationCounter += 1;
+      return `${event.callId}:${workflowAgentOperationCounter}`;
+    }
+    return event.callId;
+  };
+  const operationKeyForCallId = (callId, mode = "active") => {
+    const keys = operationKeysByCallId.get(callId);
+    if (!keys || keys.length === 0) {
+      return operations.has(callId) ? callId : void 0;
+    }
+    if (keys.length === 1) {
+      return keys[0];
+    }
+    const wrapperSpan = currentWorkflowAgentWrapperSpan();
+    if (wrapperSpan?.spanId) {
+      const key = keys.find(
+        (candidate) => operations.get(candidate)?.span.spanId === wrapperSpan.spanId
+      );
+      if (key) {
+        return key;
+      }
+    }
+    const workflowOperationKey = workflowOperationKeyStore.getStore();
+    if (workflowOperationKey && keys.includes(workflowOperationKey)) {
+      return workflowOperationKey;
+    }
+    if (callId === "workflow-agent") {
+      return void 0;
+    }
+    return mode === "finish" ? keys[0] : keys[keys.length - 1];
+  };
+  const operationKeyFromEvent = (event, mode = "active") => {
+    const explicit = explicitOperationKey(event);
+    if (explicit && operations.has(explicit)) {
+      return explicit;
+    }
+    if (isObject(event)) {
+      const callId = event.callId;
+      if (typeof callId === "string") {
+        const operationKey = operationKeyForCallId(callId, mode);
+        if (operationKey) {
+          return operationKey;
+        }
+        const workflowOperationKey2 = workflowOperationKeyStore.getStore();
+        if (workflowOperationKey2 && operations.has(workflowOperationKey2)) {
+          return workflowOperationKey2;
+        }
+        return callId === "workflow-agent" ? void 0 : callId;
+      }
+    }
+    const workflowOperationKey = workflowOperationKeyStore.getStore();
+    if (workflowOperationKey && operations.has(workflowOperationKey)) {
+      return workflowOperationKey;
+    }
+    const wrapperSpan = currentWorkflowAgentWrapperSpan();
+    if (wrapperSpan?.spanId) {
+      for (const [operationKey, state] of operations) {
+        if (state.operationName === "WorkflowAgent.stream" && state.span.spanId === wrapperSpan.spanId) {
+          return operationKey;
+        }
+      }
+    }
+    const workflowAgentKeys = operationKeysByCallId.get("workflow-agent");
+    if (workflowAgentKeys?.length === 1) {
+      return workflowAgentKeys[0];
+    }
+    if (operations.size === 1) {
+      return operations.keys().next().value;
+    }
+    return void 0;
+  };
+  const closeOpenChildSpans = (operationKey, error2) => {
+    const openModelSpans = modelSpans.get(operationKey);
+    if (openModelSpans) {
+      for (const span of openModelSpans) {
+        if (error2 !== void 0) {
+          logError(span, error2);
+        }
+        span.end();
+      }
+      modelSpans.delete(operationKey);
+    }
+    const openObjectSpan = objectSpans.get(operationKey);
+    if (openObjectSpan) {
+      if (error2 !== void 0) {
+        logError(openObjectSpan, error2);
+      }
+      openObjectSpan.end();
+      objectSpans.delete(operationKey);
+    }
+    for (const [embedCallId, embedState] of embedSpans) {
+      if (embedState.operationKey === operationKey) {
+        if (error2 !== void 0) {
+          logError(embedState.span, error2);
+        }
+        embedState.span.end();
+        embedSpans.delete(embedCallId);
+      }
+    }
+    const openRerankSpan = rerankSpans.get(operationKey);
+    if (openRerankSpan) {
+      if (error2 !== void 0) {
+        logError(openRerankSpan, error2);
+      }
+      openRerankSpan.end();
+      rerankSpans.delete(operationKey);
+    }
+    for (const [toolCallId, toolState] of toolSpans) {
+      if (toolState.operationKey === operationKey) {
+        if (error2 !== void 0) {
+          logError(toolState.span, error2);
+        }
+        toolState.span.end();
+        toolSpans.delete(toolCallId);
+      }
+    }
+  };
+  const abortReasonFromEvent = (event) => {
+    if (isObject(event)) {
+      const abortEvent = event;
+      if (abortEvent.error !== void 0) {
+        return abortEvent.error;
+      }
+      if (abortEvent.reason !== void 0) {
+        return abortEvent.reason;
+      }
+    }
+    return new Error("AI SDK operation aborted");
+  };
+  const shouldSkipTelemetryChildren = (state) => state?.operationName === "WorkflowAgent.stream" && !state.ownsSpan;
+  const onObjectStepEnd = (event) => {
+    runSafely("onObjectStepEnd", () => {
+      const operationKey = operationKeyFromEvent(event);
+      const span = operationKey ? objectSpans.get(operationKey) : void 0;
+      if (!operationKey || !span) {
+        return;
+      }
+      const result = {
+        ...event,
+        text: event.objectText
+      };
+      span.log({
+        ...shouldRecordOutputs(event) ? {
+          output: processAISDKOutput(result, DEFAULT_DENY_OUTPUT_PATHS)
+        } : {},
+        metrics: extractTokenMetrics(result)
+      });
+      span.end();
+      objectSpans.delete(operationKey);
+    });
+  };
+  const onEmbedEnd = (event) => {
+    runSafely("onEmbedEnd", () => {
+      const state = embedSpans.get(event.embedCallId);
+      if (!state) {
+        return;
+      }
+      const result = {
+        ...event,
+        embeddings: event.embeddings
+      };
+      state.span.log({
+        ...shouldRecordOutputs(event) ? {
+          output: processAISDKEmbeddingOutput(
+            result,
+            DEFAULT_DENY_OUTPUT_PATHS
+          )
+        } : {},
+        metrics: extractTokenMetrics(result)
+      });
+      state.span.end();
+      embedSpans.delete(event.embedCallId);
+    });
+  };
+  const onRerankEnd = (event) => {
+    runSafely("onRerankEnd", () => {
+      const operationKey = operationKeyFromEvent(event);
+      const span = operationKey ? rerankSpans.get(operationKey) : void 0;
+      if (!operationKey || !span) {
+        return;
+      }
+      const result = {
+        ranking: event.ranking?.map((entry) => ({
+          originalIndex: entry.index,
+          score: entry.relevanceScore
+        }))
+      };
+      span.log({
+        ...shouldRecordOutputs(event) ? {
+          output: processAISDKRerankOutput(
+            result,
+            DEFAULT_DENY_OUTPUT_PATHS
+          )
+        } : {}
+      });
+      span.end();
+      rerankSpans.delete(operationKey);
+    });
+  };
+  const onEnd = (event) => {
+    runSafely("onEnd", () => {
+      const operationKey = operationKeyFromEvent(event, "finish");
+      const state = operationKey ? operations.get(operationKey) : void 0;
+      if (!state) {
+        return;
+      }
+      if (!state.ownsSpan) {
+        deleteOperation(state.operationKey);
+        return;
+      }
+      const result = finishResult(event, state.operationName);
+      const metrics = state.hadModelChild ? {} : extractTokenMetrics(result);
+      const timeToFirstToken = state.operationName === "WorkflowAgent.stream" ? void 0 : extractTimeToFirstToken(result, state);
+      if (timeToFirstToken !== void 0) {
+        metrics.time_to_first_token = timeToFirstToken;
+      }
+      state.span.log({
+        ...shouldRecordOutputs(event) ? {
+          output: finishOutput(result, state.operationName)
+        } : {},
+        metrics
+      });
+      state.span.end();
+      deleteOperation(state.operationKey);
+    });
+  };
   return {
     onStart(event) {
       runSafely("onStart", () => {
         const operationName = operationNameFromId(event.operationId);
-        const span = startSpan({
+        const workflowAgent = operationName === "WorkflowAgent.stream";
+        const wrapperSpan = workflowAgent ? currentWorkflowAgentWrapperSpan() : void 0;
+        const ownsSpan = !wrapperSpan;
+        const span = ownsSpan ? startSpan({
           name: operationName,
           spanAttributes: { type: "function" /* FUNCTION */ }
-        });
-        operations.set(event.callId, {
+        }) : wrapperSpan;
+        const operationKey = createOperationKey(event, operationName);
+        registerOperation({
+          callId: event.callId,
           hadModelChild: false,
+          loggedInput: false,
           operationName,
+          operationKey,
+          ownsSpan,
           span,
           startTime: getCurrentUnixTimestamp()
         });
-        const metadata = metadataFromEvent(event);
+        if (!ownsSpan) {
+          return;
+        }
+        if (workflowAgent) {
+          workflowOperationKeyStore.enterWith(operationKey);
+        }
+        let metadata = metadataFromEvent(event);
         const logPayload = { metadata };
+        const workflowAgentCallInput = workflowAgent ? operationInput(event, operationName) : void 0;
+        if (workflowAgentCallInput) {
+          metadata = {
+            ...metadata,
+            ...extractWorkflowMetadataFromCallParams(workflowAgentCallInput)
+          };
+          logPayload.metadata = metadata;
+        }
         if (shouldRecordInputs(event)) {
-          const { input, outputPromise } = processAISDKCallInput(
-            operationInput(event, operationName)
-          );
+          const callInput = workflowAgentCallInput ?? operationInput(event, operationName);
+          const { input, outputPromise } = workflowAgent ? processAISDKWorkflowAgentCallInput(callInput) : processAISDKCallInput(callInput);
           logPayload.input = input;
-          if (outputPromise && input && typeof input === "object") {
+          const state = operations.get(operationKey);
+          if (state) {
+            state.loggedInput = hasPromptLikeInput(input);
+          }
+          if (outputPromise && !workflowAgent && input && typeof input === "object") {
             outputPromise.then((resolvedData) => {
               span.log({
                 input: {
@@ -17186,41 +18259,67 @@ function braintrustAISDKTelemetry() {
     },
     onLanguageModelCallStart(event) {
       runSafely("onLanguageModelCallStart", () => {
-        const state = operations.get(event.callId);
-        const openSpans = modelSpans.get(event.callId);
-        if (openSpans) {
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
+        const operationName = state?.operationName ?? "generateText";
+        const callInput = operationInput(event, operationName);
+        const workflowAgent = operationName === "WorkflowAgent.stream";
+        const processedInput = shouldRecordInputs(event) && workflowAgent ? processAISDKWorkflowAgentModelCallInput(callInput).input : shouldRecordInputs(event) ? processAISDKCallInput(callInput).input : void 0;
+        if (workflowAgent && state?.ownsSpan && !state.loggedInput && hasPromptLikeInput(processedInput)) {
+          state.span.log({
+            input: processedInput,
+            metadata: {
+              ...metadataFromEvent(event),
+              ...extractWorkflowMetadataFromCallParams(callInput)
+            }
+          });
+          state.loggedInput = true;
+        }
+        const openSpans = operationKey ? modelSpans.get(operationKey) : void 0;
+        if (operationKey && openSpans) {
           for (const span2 of openSpans) {
             span2.end();
           }
-          modelSpans.delete(event.callId);
+          modelSpans.delete(operationKey);
         }
         const span = startChildSpan(
-          event.callId,
-          state?.operationName === "streamText" ? "doStream" : "doGenerate",
+          operationKey ?? event.callId,
+          operationName === "streamText" ? "doStream" : "doGenerate",
           "llm" /* LLM */,
           {
             ...shouldRecordInputs(event) ? {
-              input: processAISDKCallInput(
-                operationInput(
-                  event,
-                  state?.operationName ?? "generateText"
-                )
-              ).input
+              input: processedInput
             } : {},
-            metadata: metadataFromEvent(event)
+            metadata: workflowAgent ? {
+              ...metadataFromEvent(event),
+              ...extractWorkflowMetadataFromCallParams(callInput)
+            } : metadataFromEvent(event)
           }
         );
-        const spans = modelSpans.get(event.callId) ?? [];
+        const spanKey = operationKey ?? event.callId;
+        const spans = modelSpans.get(spanKey) ?? [];
         spans.push(span);
-        modelSpans.set(event.callId, spans);
+        modelSpans.set(spanKey, spans);
       });
     },
     onLanguageModelCallEnd(event) {
       runSafely("onLanguageModelCallEnd", () => {
-        const span = shiftModelSpan(modelSpans, event.callId);
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
+        const span = operationKey ? shiftModelSpan(modelSpans, operationKey) : void 0;
         if (!span) {
           return;
         }
+        const timeToFirstOutputMs = safePerformance(event)?.timeToFirstOutputMs;
+        if (state?.operationName === "streamText" && state.firstChunkTime === void 0 && typeof timeToFirstOutputMs === "number") {
+          state.firstChunkTime = state.startTime + timeToFirstOutputMs / 1e3;
+        }
         const result = {
           ...event,
           response: event.responseId ? { id: event.responseId } : void 0
@@ -17236,14 +18335,18 @@ function braintrustAISDKTelemetry() {
     },
     onObjectStepStart(event) {
       runSafely("onObjectStepStart", () => {
-        const state = operations.get(event.callId);
-        const openSpan = objectSpans.get(event.callId);
-        if (openSpan) {
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
+        const openSpan = operationKey ? objectSpans.get(operationKey) : void 0;
+        if (operationKey && openSpan) {
           openSpan.end();
-          objectSpans.delete(event.callId);
+          objectSpans.delete(operationKey);
         }
         const span = startChildSpan(
-          event.callId,
+          operationKey ?? event.callId,
           state?.operationName === "streamObject" ? "doStream" : "doGenerate",
           "llm" /* LLM */,
           {
@@ -17255,40 +18358,25 @@ function braintrustAISDKTelemetry() {
             metadata: metadataFromEvent(event)
           }
         );
-        objectSpans.set(event.callId, span);
-      });
-    },
-    onObjectStepFinish(event) {
-      runSafely("onObjectStepFinish", () => {
-        const span = objectSpans.get(event.callId);
-        if (!span) {
-          return;
-        }
-        const result = {
-          ...event,
-          text: event.objectText
-        };
-        span.log({
-          ...shouldRecordOutputs(event) ? {
-            output: processAISDKOutput(result, DEFAULT_DENY_OUTPUT_PATHS)
-          } : {},
-          metrics: extractTokenMetrics(result)
-        });
-        span.end();
-        objectSpans.delete(event.callId);
+        objectSpans.set(operationKey ?? event.callId, span);
       });
     },
+    onObjectStepEnd,
     onEmbedStart(event) {
       runSafely("onEmbedStart", () => {
-        const state = operations.get(event.callId);
+        const operationKey = operationKeyFromEvent(event);
+        const state = operationKey ? operations.get(operationKey) : void 0;
+        if (shouldSkipTelemetryChildren(state)) {
+          return;
+        }
         for (const [embedCallId, embedState] of embedSpans) {
-          if (embedState.callId === event.callId && (state?.operationName === "embed" || embedState.values === event.values)) {
+          if (embedState.operationKey === operationKey && (state?.operationName === "embed" || embedState.values === event.values)) {
             embedState.span.end();
             embedSpans.delete(embedCallId);
           }
         }
         const span = startChildSpan(
-          event.callId,
+          operationKey ?? event.callId,
           "doEmbed",
           "llm" /* LLM */,
           {
@@ -17301,44 +18389,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 */,
           {
@@ -17352,41 +18423,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 */,
           {
@@ -17400,7 +18453,7 @@ function braintrustAISDKTelemetry() {
             }
           }
         );
-        toolSpans.set(toolCallId, { callId: event.callId, span });
+        toolSpans.set(toolCallId, { operationKey, span });
       });
     },
     onToolExecutionEnd(event) {
@@ -17411,14 +18464,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 error2 = toolOutput?.error ?? workflowToolError;
           state.span.log({
-            error: toolOutput.error instanceof Error ? toolOutput.error.message : String(toolOutput?.error),
+            error: error2 instanceof Error ? error2.message : String(error2),
             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 } : {}
           });
         }
@@ -17432,83 +18488,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 error2 = abortReasonFromEvent(event);
+        closeOpenChildSpans(operationKey, error2);
+        if (state.ownsSpan) {
+          logError(state.span, error2);
+          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 error2 = errorEvent.error ?? event;
-        const openModelSpans = modelSpans.get(callId);
-        if (openModelSpans) {
-          for (const span of openModelSpans) {
-            logError(span, error2);
-            span.end();
-          }
-          modelSpans.delete(callId);
-        }
-        const openObjectSpan = objectSpans.get(callId);
-        if (openObjectSpan) {
-          logError(openObjectSpan, error2);
-          openObjectSpan.end();
-          objectSpans.delete(callId);
-        }
-        for (const [embedCallId, embedState] of embedSpans) {
-          if (embedState.callId === callId) {
-            logError(embedState.span, error2);
-            embedState.span.end();
-            embedSpans.delete(embedCallId);
-          }
-        }
-        const openRerankSpan = rerankSpans.get(callId);
-        if (openRerankSpan) {
-          logError(openRerankSpan, error2);
-          openRerankSpan.end();
-          rerankSpans.delete(callId);
-        }
-        for (const [toolCallId, toolState] of toolSpans) {
-          if (toolState.callId === callId) {
-            logError(toolState.span, error2);
-            toolState.span.end();
-            toolSpans.delete(toolCallId);
-          }
+        closeOpenChildSpans(operationKey, error2);
+        if (state.ownsSpan) {
+          logError(state.span, error2);
+          state.span.end();
         }
-        logError(state.span, error2);
-        state.span.end();
-        operations.delete(callId);
+        deleteOperation(operationKey);
       });
     },
     executeTool({ toolCallId, execute }) {
@@ -17523,7 +18542,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) {
@@ -17569,6 +18597,7 @@ function operationInput(event, operationName) {
   }
   return {
     model: modelFromEvent(event),
+    instructions: event.instructions,
     system: event.system,
     prompt: event.prompt,
     messages: event.messages,
@@ -17617,6 +18646,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(
@@ -17693,6 +18746,10 @@ var aiSDKChannels = defineChannels("ai", {
     channelName: "ToolLoopAgent.stream",
     kind: "async"
   }),
+  workflowAgentStream: channel({
+    channelName: "WorkflowAgent.stream",
+    kind: "async"
+  }),
   v7CreateTelemetryDispatcher: channel({
     channelName: "createTelemetryDispatcher",
     kind: "sync-stream"
@@ -17703,14 +18760,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"
 ];
@@ -17722,6 +18784,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",
@@ -17730,14 +18804,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 {
@@ -17895,7 +18971,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(
@@ -17911,7 +18989,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)
@@ -17931,7 +19011,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,
@@ -17945,7 +19027,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(
@@ -17961,7 +19045,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)
@@ -17977,6 +19063,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() {
@@ -17988,7 +19110,11 @@ function subscribeToAISDKV7TelemetryDispatcher() {
       if (telemetryOptions?.isEnabled === false) {
         return;
       }
-      patchAISDKV7TelemetryDispatcher(event.result, telemetry);
+      patchAISDKV7TelemetryDispatcher(
+        event.result,
+        telemetry,
+        telemetryOptions
+      );
     }
   };
   channel2.subscribe(handlers);
@@ -17996,7 +19122,7 @@ function subscribeToAISDKV7TelemetryDispatcher() {
     channel2.unsubscribe(handlers);
   };
 }
-function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry) {
+function patchAISDKV7TelemetryDispatcher(dispatcher, telemetry, telemetryOptions) {
   if (!isObject(dispatcher)) {
     return;
   }
@@ -18005,6 +19131,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") {
@@ -18013,11 +19187,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;
@@ -18027,6 +19207,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()
   });
 }
@@ -18125,6 +19306,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);
   }
@@ -18158,10 +19341,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;
@@ -18325,7 +19508,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) => {
@@ -18344,7 +19541,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) {
@@ -18381,6 +19600,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: {
@@ -18392,6 +19614,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(
@@ -18407,12 +19636,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);
 }
@@ -18426,65 +19818,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 = {};
@@ -18492,6 +20047,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)) {
@@ -18529,33 +20122,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 {
@@ -18565,32 +20140,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 (isAsyncGenerator2(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) {
@@ -18606,15 +20228,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 */
           }
@@ -18622,8 +20244,7 @@ function prepareAISDKChildTracing(params, self, parentSpan, denyOutputPaths, aiS
       );
     };
     cleanup.push(() => {
-      tool.execute = originalExecute;
-      delete tool[AUTO_PATCHED_TOOL];
+      cleanupToolEntry(state);
     });
   };
   const patchTools = (tools) => {
@@ -18642,25 +20263,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) {
@@ -18757,99 +20395,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 (error2) {
+      span.log({ error: toLoggedError(error2) });
+    } finally {
+      finalize();
+    }
+  };
+  const createAsyncIterableHooks = () => {
+    let firstChunkTime;
+    return {
+      onChunk: (chunk) => {
+        if (firstChunkTime === void 0 && isAISDKContentAsyncIterableChunk(chunk)) {
+          firstChunkTime = getCurrentUnixTimestamp();
+        }
+      },
+      onComplete: async () => {
+        await logStreamingOutput(firstChunkTime);
+      },
+      onError: (error2) => {
+        if (!outputLogged) {
+          outputLogged = true;
+          span.log({
+            error: error2.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 (!isAsyncIterable3(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 isAsyncIterable3(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 (error2) {
+          span.log({ error: toLoggedError(error2) });
+          finalize();
+          controller.error(error2);
+        }
+      },
+      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: (error2) => {
-      span.log({
-        error: error2.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 = [
@@ -18881,34 +20610,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 (isAsyncIterable3(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 (error2) {
+        completed = true;
+        hooks.onError(
+          error2 instanceof Error ? error2 : new Error(String(error2))
+        );
+        controller.error(error2);
+      }
+    },
+    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 (error2) {
+        completed = true;
         hooks.onError(
           error2 instanceof Error ? error2 : new Error(String(error2))
         );
         throw error2;
+      } finally {
+        if (!completed) {
+          try {
+            await hooks.onCancel?.();
+          } catch {
+          }
+        }
       }
     }
   };
@@ -18983,6 +20750,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;
@@ -19006,7 +20807,45 @@ function isAsyncGenerator2(value) {
 function processAISDKOutput(output, denyOutputPaths) {
   if (!output) return output;
   const merged = extractSerializableOutputFields(output);
-  return normalizeAISDKLoggedOutput(omit(merged, denyOutputPaths));
+  const deleteOutputPaths = denyOutputPaths.filter(
+    (path8) => path8.toLowerCase().endsWith("headers")
+  );
+  const sanitized = omit(merged, denyOutputPaths, deleteOutputPaths);
+  for (const path8 of TRANSPORT_PAYLOAD_ROOT_PATHS) {
+    const stack = [{ obj: sanitized, keys: parsePath(path8) }];
+    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") {
@@ -19097,6 +20936,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,
@@ -19220,7 +21061,9 @@ function extractGetterValues(obj) {
   const getterValues = {};
   const getterNames = [
     "content",
+    "messages",
     "text",
+    "output",
     "object",
     "value",
     "values",
@@ -19260,7 +21103,9 @@ function extractGetterValues(obj) {
 function extractSerializableOutputFields(output) {
   const serialized = {};
   const directFieldNames = [
+    "messages",
     "steps",
+    "output",
     "request",
     "responseMessages",
     "warnings",
@@ -19442,7 +21287,7 @@ function parsePath(path8) {
   }
   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);
@@ -19452,29 +21297,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 path8 of paths) {
     const keys = parsePath(path8);
-    omitAtPath(result, keys);
+    omitAtPath(result, keys, deletePathSet.has(path8));
   }
   return result;
 }
@@ -29523,15 +31375,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() {
@@ -35085,7 +36940,7 @@ var MAIN_ORIGIN = "https://www.braintrust.dev";
 var WHITELISTED_ORIGINS = [
   MAIN_ORIGIN,
   "https://www.braintrustdata.com",
-  new RegExp("https://.*.preview.braintrust.dev")
+  new RegExp("^https://[^/]+\\.preview\\.braintrust\\.dev$")
 ].concat(
   process.env.WHITELISTED_ORIGIN ? [process.env.WHITELISTED_ORIGIN] : []
 ).concat(