@raindrop-ai/ai-sdk 0.2.0 → 0.3.0

package/dist/{chunk-RBVZVH46.mjs → chunk-GMY7QXIQ.mjs}

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'async_hooks';
 
-// ../core/dist/chunk-QTUH3BHZ.js
+// ../core/dist/chunk-YUIXRQWN.js
 function normalizeFeatureFlags(input) {
   if (Array.isArray(input)) {
     return Object.fromEntries(input.map((name) => [name, "true"]));
@@ -63,6 +63,311 @@ function base64Encode(bytes) {
   }
   return out;
 }
+function base64ToHex(value) {
+  if (!value) return "";
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(value, "base64").toString("hex");
+  }
+  const atobFn = globalThis.atob;
+  if (typeof atobFn !== "function") return "";
+  try {
+    const binary = atobFn(value);
+    let hex = "";
+    for (let i = 0; i < binary.length; i++) {
+      hex += (binary.charCodeAt(i) & 255).toString(16).padStart(2, "0");
+    }
+    return hex;
+  } catch (e) {
+    return "";
+  }
+}
+var HANDOFF_ATTRIBUTE_SUFFIXES = {
+  mode: "raindrop.handoff.mode",
+  childEventId: "raindrop.handoff.childEventId",
+  parentEventId: "raindrop.handoff.parentEventId",
+  parentSpanId: "raindrop.handoff.parentSpanId",
+  name: "raindrop.handoff.name",
+  terminal: "raindrop.handoff.terminal",
+  agentRole: "raindrop.agent.role"
+};
+var HANDOFF_ATTRIBUTE_PREFIXES = [
+  "ai.telemetry.metadata.",
+  "ai.settings.context.",
+  ""
+];
+var AI_SDK_METADATA_PREFIX = "ai.telemetry.metadata.";
+var DETACHED_MODE = "detached";
+var SUBAGENT_AGENT_ROLE = "subagent";
+var HANDOFF_TERMINAL_CANCELLED = "cancelled";
+var TOOL_EVENTS_SUFFIX = "raindrop.toolEvents";
+var TOOL_EVENTS_ALLOW = "allow";
+var SUBAGENT_ABORT_OPERATION_ID = "ai.subagent.failed";
+var SUBAGENT_ABORT_SPAN_NAME = SUBAGENT_ABORT_OPERATION_ID;
+var DEFAULT_DISPATCH_SPAN_NAME = "launch_subagent";
+var HANDOFF_TERMINAL_PROPERTY_KEY = HANDOFF_ATTRIBUTE_SUFFIXES.terminal;
+function defined(entries) {
+  const out = {};
+  for (const [key, value] of Object.entries(entries)) {
+    if (typeof value === "string" && value.trim().length > 0) out[key] = value;
+  }
+  return out;
+}
+function detachedDispatchMetadata(dispatch) {
+  return defined({
+    [HANDOFF_ATTRIBUTE_SUFFIXES.mode]: DETACHED_MODE,
+    [HANDOFF_ATTRIBUTE_SUFFIXES.childEventId]: dispatch.childEventId,
+    [HANDOFF_ATTRIBUTE_SUFFIXES.name]: dispatch.name
+  });
+}
+function detachedChildMetadata(link) {
+  return defined({
+    [HANDOFF_ATTRIBUTE_SUFFIXES.parentEventId]: link.parentEventId,
+    [HANDOFF_ATTRIBUTE_SUFFIXES.parentSpanId]: link.parentSpanId,
+    [HANDOFF_ATTRIBUTE_SUFFIXES.name]: link.name,
+    [HANDOFF_ATTRIBUTE_SUFFIXES.agentRole]: SUBAGENT_AGENT_ROLE
+  });
+}
+function cancelledTerminalMetadata() {
+  return { [HANDOFF_ATTRIBUTE_SUFFIXES.terminal]: HANDOFF_TERMINAL_CANCELLED };
+}
+function cancelledTerminalAttributes() {
+  const bare = cancelledTerminalMetadata();
+  return { ...bare, ...withMetadataPrefix(bare) };
+}
+function toolEventsAllowMetadata() {
+  return { [TOOL_EVENTS_SUFFIX]: TOOL_EVENTS_ALLOW };
+}
+function withMetadataPrefix(metadata) {
+  const out = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    out[key.startsWith(AI_SDK_METADATA_PREFIX) ? key : `${AI_SDK_METADATA_PREFIX}${key}`] = value;
+  }
+  return out;
+}
+function readHandoffField(metadata, suffix) {
+  for (const prefix of HANDOFF_ATTRIBUTE_PREFIXES) {
+    const value = metadata[`${prefix}${suffix}`];
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return void 0;
+}
+function readDetachedChildLink(metadata) {
+  if (!metadata) return void 0;
+  const parentEventId = readHandoffField(metadata, HANDOFF_ATTRIBUTE_SUFFIXES.parentEventId);
+  if (!parentEventId) return void 0;
+  return {
+    parentEventId,
+    parentSpanId: readHandoffField(metadata, HANDOFF_ATTRIBUTE_SUFFIXES.parentSpanId),
+    name: readHandoffField(metadata, HANDOFF_ATTRIBUTE_SUFFIXES.name)
+  };
+}
+var BAGGAGE_KEYS = {
+  eventId: "raindrop-event-id",
+  childEventId: "raindrop-child-event-id",
+  name: "raindrop-handoff-name",
+  convoId: "raindrop-convo-id",
+  userId: "raindrop-user-id",
+  // The dispatch span and its trace, carried as fields as well as in
+  // `traceparent`. Not redundant: OTel's HTTP instrumentations rewrite
+  // `traceparent` from whatever span is current as the request goes out, so by
+  // the time the child reads it the ids name the HTTP client span and its trace
+  // instead of the dispatch. The child would then point its reverse reference at
+  // a span the launcher's UI does not know as a dispatch. A field states which
+  // span it means rather than meaning "whoever wrote this header last".
+  dispatchSpanId: "raindrop-dispatch-span-id",
+  traceId: "raindrop-trace-id"
+};
+var TRACEPARENT_HEADER = "traceparent";
+var BAGGAGE_HEADER = "baggage";
+var W3C_TRACE_ID = /^[0-9a-f]{32}$/;
+var W3C_SPAN_ID = /^[0-9a-f]{16}$/;
+function isW3CTraceId(value) {
+  return value !== void 0 && W3C_TRACE_ID.test(value);
+}
+function isW3CSpanId(value) {
+  return value !== void 0 && W3C_SPAN_ID.test(value);
+}
+var warnedNonConformantIds = false;
+function warnNonConformantIdsOnce(traceId, spanId) {
+  if (warnedNonConformantIds) return;
+  warnedNonConformantIds = true;
+  console.warn(
+    `[raindrop] hand-off carrier ids are not W3C-shaped (traceId="${traceId}", spanId="${spanId}"). The child still reports as its own event, but its reverse reference names a span id the backend does not store, so the link back to the launcher will not resolve. A LangSmith carrier reads this way \u2014 its run ids are UUIDs; propagate Raindrop's own carrier (toHeaders) to link.`
+  );
+}
+var HANDOFF_HEADER = "x-raindrop-handoff";
+var LANGSMITH_TRACE_HEADER = "langsmith-trace";
+var LANGSMITH_METADATA_BAGGAGE_KEY = "langsmith-metadata";
+function encodeBaggage(entries) {
+  return Object.entries(entries).filter((entry) => Boolean(entry[1])).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join(",");
+}
+function decodeBaggage(header) {
+  if (!header) return {};
+  const parsed = {};
+  for (const part of header.split(",")) {
+    const [rawKey, ...rest] = part.split("=");
+    if (!rawKey || rest.length === 0) continue;
+    const key = rawKey.trim();
+    let value;
+    try {
+      value = decodeURIComponent(rest.join("=").trim());
+    } catch (e) {
+      value = rest.join("=").trim();
+    }
+    if (key in parsed && parsed[key] !== value) throw new ConflictingCarrierError(key);
+    parsed[key] = value;
+  }
+  return parsed;
+}
+function carrierBaggage(carrier) {
+  return {
+    [BAGGAGE_KEYS.eventId]: carrier.eventId,
+    [BAGGAGE_KEYS.childEventId]: carrier.childEventId,
+    [BAGGAGE_KEYS.name]: carrier.name,
+    [BAGGAGE_KEYS.convoId]: carrier.convoId,
+    [BAGGAGE_KEYS.userId]: carrier.userId,
+    [BAGGAGE_KEYS.dispatchSpanId]: carrier.spanId,
+    [BAGGAGE_KEYS.traceId]: carrier.traceId
+  };
+}
+function toHeaders(carrier) {
+  const fields = encodeBaggage(carrierBaggage(carrier));
+  const headers = {
+    [BAGGAGE_HEADER]: fields,
+    [HANDOFF_HEADER]: fields
+  };
+  if (isW3CTraceId(carrier.traceId) && isW3CSpanId(carrier.spanId)) {
+    headers[TRACEPARENT_HEADER] = `00-${carrier.traceId}-${carrier.spanId}-01`;
+  }
+  return headers;
+}
+function langsmithStamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "000000");
+}
+function toLangSmithHeaders(carrier) {
+  const stamp = langsmithStamp();
+  const dottedOrder = `${stamp}Z${carrier.traceId}.${stamp}Z${carrier.spanId}`;
+  return {
+    [LANGSMITH_TRACE_HEADER]: dottedOrder,
+    [BAGGAGE_HEADER]: encodeBaggage({
+      [LANGSMITH_METADATA_BAGGAGE_KEY]: JSON.stringify(carrierBaggage(carrier))
+    }),
+    // Carried here too: a LangSmith-shaped carrier is rewritten in transit
+    // exactly like the native one, and an injected `traceparent` is preferred
+    // over the dotted order on read.
+    [HANDOFF_HEADER]: encodeBaggage(carrierBaggage(carrier))
+  };
+}
+function isHeaderLookup(headers) {
+  return "get" in headers && typeof headers.get === "function";
+}
+var ConflictingCarrierError = class extends Error {
+};
+function readHeader(headers, name) {
+  var _a, _b, _c;
+  if (isHeaderLookup(headers)) return (_a = headers.get(name)) != null ? _a : void 0;
+  const value = (_c = headers[name]) != null ? _c : (_b = Object.entries(headers).find(([key]) => key.toLowerCase() === name)) == null ? void 0 : _b[1];
+  if (!Array.isArray(value)) return value;
+  const distinct = new Set(value);
+  if (distinct.size > 1) throw new ConflictingCarrierError(name);
+  return value[0];
+}
+function readTraceHeader(headers, name) {
+  const value = readHeader(headers, name);
+  if (!(value == null ? void 0 : value.includes(","))) return value;
+  const copies = value.split(",").map((copy) => copy.trim());
+  if (new Set(copies).size > 1) throw new ConflictingCarrierError(name);
+  return copies[0];
+}
+function fromHeaders(headers) {
+  var _a, _b;
+  let baggage;
+  let handoff;
+  let traceparent;
+  let langsmithTrace;
+  try {
+    baggage = decodeBaggage(readHeader(headers, BAGGAGE_HEADER));
+    handoff = decodeBaggage(readHeader(headers, HANDOFF_HEADER));
+    traceparent = readTraceHeader(headers, TRACEPARENT_HEADER);
+    langsmithTrace = readTraceHeader(headers, LANGSMITH_TRACE_HEADER);
+  } catch (error) {
+    if (error instanceof ConflictingCarrierError) return null;
+    throw error;
+  }
+  const langsmithMetadata = baggage[LANGSMITH_METADATA_BAGGAGE_KEY];
+  const nested = langsmithMetadata ? safeParseStringRecord(langsmithMetadata) : {};
+  for (const [key, value] of Object.entries(nested)) {
+    if (key in baggage && baggage[key] !== value) return null;
+  }
+  const fields = {
+    ...baggage,
+    ...nested,
+    // Last, so it wins: the standard headers may have been rewritten in transit
+    // by a propagator, this one is only ever written by us.
+    ...handoff
+  };
+  let traceId;
+  let spanId;
+  if (traceparent) {
+    const [, parsedTraceId, parsedSpanId] = traceparent.split("-");
+    if (isW3CTraceId(parsedTraceId) && isW3CSpanId(parsedSpanId)) {
+      traceId = parsedTraceId;
+      spanId = parsedSpanId;
+    }
+  }
+  if (!traceId && !spanId && langsmithTrace) {
+    const segments = langsmithTrace.split(".");
+    traceId = (_a = segments[0]) == null ? void 0 : _a.split("Z").pop();
+    spanId = (_b = segments[segments.length - 1]) == null ? void 0 : _b.split("Z").pop();
+  }
+  traceId = fields[BAGGAGE_KEYS.traceId] || traceId;
+  spanId = fields[BAGGAGE_KEYS.dispatchSpanId] || spanId;
+  const eventId = fields[BAGGAGE_KEYS.eventId];
+  if (!traceId || !spanId || !eventId) return null;
+  if (!isW3CTraceId(traceId) || !isW3CSpanId(spanId)) {
+    warnNonConformantIdsOnce(traceId, spanId);
+  }
+  const carrier = { traceId, spanId, eventId };
+  const childEventId = fields[BAGGAGE_KEYS.childEventId];
+  if (childEventId) carrier.childEventId = childEventId;
+  const name = fields[BAGGAGE_KEYS.name];
+  if (name) carrier.name = name;
+  const convoId = fields[BAGGAGE_KEYS.convoId];
+  if (convoId) carrier.convoId = convoId;
+  const userId = fields[BAGGAGE_KEYS.userId];
+  if (userId) carrier.userId = userId;
+  return carrier;
+}
+var UNRESOLVED_CARRIER_WARNING = `[raindrop] resume: headers were supplied but no hand-off carrier was found on them (searched ${HANDOFF_HEADER}, ${TRACEPARENT_HEADER}, ${BAGGAGE_HEADER}). This run reports as an UNLINKED event, and the launcher that dispatched it will stay on "queued" forever because nothing ever references its child. Passing headers means a parent handed off, so no carrier on them is almost certainly a defect: a gateway or proxy stripping ${HANDOFF_HEADER}, a middleware overwriting ${BAGGAGE_HEADER}, a request forwarded without its headers, or a hand-built carrier whose field names do not match. Send every header the launcher's dispatch returned. Logged once per process; pass no headers for a directly-invoked sub-agent to silence it.`;
+var UNRESOLVED_CARRIER_WARNED_KEY = /* @__PURE__ */ Symbol.for("raindrop.handoff.warnedUnresolvedCarrier");
+function warnedHolder() {
+  return globalThis;
+}
+function resetUnresolvedCarrierWarning() {
+  warnedHolder()[UNRESOLVED_CARRIER_WARNED_KEY] = false;
+}
+function warnUnresolvedCarrier(headers, carrier) {
+  if (carrier) return;
+  if (!headers) return;
+  const holder = warnedHolder();
+  if (holder[UNRESOLVED_CARRIER_WARNED_KEY]) return;
+  holder[UNRESOLVED_CARRIER_WARNED_KEY] = true;
+  console.warn(UNRESOLVED_CARRIER_WARNING);
+}
+function safeParseStringRecord(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "string") result[key] = value;
+    }
+    return result;
+  } catch (e) {
+    return {};
+  }
+}
 function runWithTracingSuppressed(fn) {
   const hook = globalThis.RAINDROP_SUPPRESS_TRACING;
   if (typeof hook !== "function") return fn();
@@ -826,6 +1131,193 @@ var EventShipper = class {
     }
   }
 };
+var MODEL_USAGE_ATTRIBUTES = {
+  providerName: "gen_ai.provider.name",
+  requestModel: "gen_ai.request.model",
+  responseModel: "gen_ai.response.model",
+  inputTokens: "gen_ai.usage.input_tokens",
+  outputTokens: "gen_ai.usage.output_tokens",
+  reasoningTokens: "gen_ai.usage.reasoning_tokens",
+  cacheReadInputTokens: "gen_ai.usage.cache_read_input_tokens",
+  cacheWriteInputTokens: "gen_ai.usage.cache_write_input_tokens",
+  nonCachedInputTokens: "raindrop.usage.input_tokens.non_cached",
+  nonReasoningOutputTokens: "raindrop.usage.output_tokens.non_reasoning",
+  reasoningOutputTokens: "raindrop.usage.output_tokens.reasoning",
+  cacheReadTokens: "raindrop.usage.input_tokens.cache_read",
+  cacheWriteTokens: "raindrop.usage.input_tokens.cache_write"
+};
+var MODEL_PROVIDER_NAMES = [
+  ["google.vertex", "google-vertex"],
+  ["vertex.anthropic", "google-vertex"],
+  ["amazon-bedrock", "amazon-bedrock"],
+  ["bedrock", "amazon-bedrock"],
+  ["anthropic", "anthropic"],
+  ["openai", "openai"],
+  ["google", "google"],
+  ["azure", "azure"],
+  ["openrouter", "openrouter"]
+];
+function canonicalModelProvider(provider) {
+  var _a;
+  const normalizedProvider = provider.trim().toLowerCase();
+  if (normalizedProvider === "gateway") return "vercel";
+  const match = MODEL_PROVIDER_NAMES.find(
+    ([family]) => normalizedProvider === family || normalizedProvider.startsWith(`${family}.`)
+  );
+  return (_a = match == null ? void 0 : match[1]) != null ? _a : provider;
+}
+function tokenCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function exclusiveTokens({
+  explicit,
+  total,
+  parts,
+  semantics
+}) {
+  if (explicit !== void 0) return explicit;
+  if (total === void 0) return void 0;
+  if (semantics === "exclusive") return total;
+  const observedParts = parts.filter((part) => part !== void 0 && part > 0);
+  if (semantics === void 0 && observedParts.length > 0) return void 0;
+  const exclusive = total - observedParts.reduce((sum, part) => sum + part, 0);
+  return exclusive >= 0 ? exclusive : void 0;
+}
+function buildModelUsageAttributes(usage) {
+  const inputTokens = tokenCount(usage.inputTokens);
+  const outputTokens = tokenCount(usage.outputTokens);
+  const explicitNonCachedInputTokens = tokenCount(usage.nonCachedInputTokens);
+  const explicitNonReasoningOutputTokens = tokenCount(usage.nonReasoningOutputTokens);
+  const reasoningTokens = tokenCount(usage.reasoningTokens);
+  const cacheReadInputTokens = tokenCount(usage.cacheReadInputTokens);
+  const cacheWriteInputTokens = tokenCount(usage.cacheWriteInputTokens);
+  const nonCachedInputTokens = exclusiveTokens({
+    explicit: explicitNonCachedInputTokens,
+    total: inputTokens,
+    parts: [cacheReadInputTokens, cacheWriteInputTokens],
+    semantics: usage.inputTokenSemantics
+  });
+  const nonReasoningOutputTokens = exclusiveTokens({
+    explicit: explicitNonReasoningOutputTokens,
+    total: outputTokens,
+    parts: [reasoningTokens],
+    semantics: usage.outputTokenSemantics
+  });
+  const exclusivePoolAttributes = nonCachedInputTokens !== void 0 && nonReasoningOutputTokens !== void 0 ? [
+    // backend consumes this complete raindrop.* set as one atomic billing-pool contract.
+    attrInt(MODEL_USAGE_ATTRIBUTES.nonCachedInputTokens, nonCachedInputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.nonReasoningOutputTokens, nonReasoningOutputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.reasoningOutputTokens, reasoningTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheReadTokens, cacheReadInputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheWriteTokens, cacheWriteInputTokens)
+  ] : [];
+  return [
+    attrInt(MODEL_USAGE_ATTRIBUTES.inputTokens, inputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.outputTokens, outputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.reasoningTokens, reasoningTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheReadInputTokens, cacheReadInputTokens),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheWriteInputTokens, cacheWriteInputTokens),
+    ...exclusivePoolAttributes
+  ].filter((attribute) => attribute !== void 0);
+}
+var STRING_ALIASES = {
+  [MODEL_USAGE_ATTRIBUTES.requestModel]: ["ai.model.id", "ai.model"]
+};
+var NUMBER_ALIASES = {
+  [MODEL_USAGE_ATTRIBUTES.inputTokens]: [
+    "gen_ai.usage.prompt_tokens",
+    "ai.usage.prompt_tokens",
+    "ai.usage.promptTokens",
+    "ai.usage.input_tokens",
+    "ai.usage.inputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.outputTokens]: [
+    "gen_ai.usage.completion_tokens",
+    "ai.usage.completion_tokens",
+    "ai.usage.completionTokens",
+    "ai.usage.output_tokens",
+    "ai.usage.outputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.reasoningTokens]: [
+    "gen_ai.usage.reasoning.output_tokens",
+    "ai.usage.reasoningTokens",
+    "ai.usage.thoughts_tokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.cacheReadInputTokens]: [
+    "gen_ai.usage.cache_read_tokens",
+    "gen_ai.usage.cache_read.input_tokens",
+    "ai.usage.cachedInputTokens",
+    "ai.usage.cached_tokens",
+    "ai.usage.cache_read_tokens",
+    "ai.usage.cache_read_input_tokens",
+    "ai.usage.cacheReadInputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.cacheWriteInputTokens]: [
+    "gen_ai.usage.cache_creation_input_tokens",
+    "gen_ai.usage.cache_creation.input_tokens",
+    "ai.usage.cacheWriteInputTokens",
+    "ai.usage.cache_creation_input_tokens",
+    "ai.usage.cacheCreationInputTokens"
+  ]
+};
+function hasAttribute(attributes, key) {
+  return attributes.some((attribute) => attribute.key === key);
+}
+function findStringAttribute(attributes, keys) {
+  return attributes.find(
+    (attribute) => keys.includes(attribute.key) && typeof attribute.value.stringValue === "string" && attribute.value.stringValue.length > 0
+  );
+}
+function findNumberAttribute(attributes, keys) {
+  return attributes.find((attribute) => {
+    if (!keys.includes(attribute.key)) return false;
+    if (typeof attribute.value.doubleValue === "number" && Number.isSafeInteger(attribute.value.doubleValue) && attribute.value.doubleValue >= 0) {
+      return true;
+    }
+    const intValue = attribute.value.intValue;
+    return integerValue(intValue) !== void 0;
+  });
+}
+function integerValue(value) {
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+  }
+  if (typeof value !== "string") return void 0;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function appendAlias(attributes, target, source) {
+  if (!source || hasAttribute(attributes, target)) return attributes;
+  return [...attributes, { key: target, value: { ...source.value } }];
+}
+function appendProviderAlias(attributes) {
+  if (hasAttribute(attributes, MODEL_USAGE_ATTRIBUTES.providerName)) return attributes;
+  const source = findStringAttribute(attributes, ["gen_ai.system", "ai.model.provider"]);
+  if (!(source == null ? void 0 : source.value.stringValue)) return attributes;
+  const attribute = attrString(
+    MODEL_USAGE_ATTRIBUTES.providerName,
+    canonicalModelProvider(source.value.stringValue)
+  );
+  return attribute ? [...attributes, attribute] : attributes;
+}
+function normalizeModelUsageSpan(span) {
+  const original = span.attributes;
+  if (!original || original.length === 0) return span;
+  const responseModel = findStringAttribute(original, [
+    MODEL_USAGE_ATTRIBUTES.responseModel,
+    "ai.response.model"
+  ]);
+  if (!responseModel) return span;
+  let attributes = appendAlias(original, MODEL_USAGE_ATTRIBUTES.responseModel, responseModel);
+  attributes = appendProviderAlias(attributes);
+  for (const [target, aliases] of Object.entries(STRING_ALIASES)) {
+    attributes = appendAlias(attributes, target, findStringAttribute(attributes, aliases));
+  }
+  for (const [target, aliases] of Object.entries(NUMBER_ALIASES)) {
+    attributes = appendAlias(attributes, target, findNumberAttribute(attributes, aliases));
+  }
+  return attributes === original ? span : { ...span, attributes };
+}
 var DEFAULT_SECRET_KEY_NAMES = [
   "apikey",
   "apisecret",
@@ -1026,6 +1518,10 @@ var TraceShipper = class {
         return null;
       }
     }
+    try {
+      current = normalizeModelUsageSpan(current);
+    } catch (e) {
+    }
     if (!this.disableDefaultRedaction) {
       current = defaultTransformSpan(current);
     }
@@ -2060,6 +2556,15 @@ function attrsFromHeaders(headers) {
   if (!isRecord(headers)) return [];
   return Object.entries(headers).filter(([, v]) => typeof v === "string").map(([k, v]) => attrString(`ai.request.headers.${k}`, v));
 }
+function attrsFromModelProvider(provider) {
+  if (typeof provider !== "string" || provider.length === 0) return [];
+  const providerName = canonicalModelProvider(provider);
+  return [
+    attrString("ai.model.provider", provider),
+    attrString(MODEL_USAGE_ATTRIBUTES.providerName, providerName),
+    attrString("gen_ai.system", provider)
+  ];
+}
 function attrsFromSettings(args) {
   if (!isRecord(args)) return [];
   const result = [];
@@ -2242,6 +2747,473 @@ function runWithParentToolContext(ctx, fn) {
   return getStorage2().run(ctx, fn);
 }
 
+// src/internal/subagents.ts
+var SUBAGENT_CANCELLED_OUTPUT = "Cancelled before producing a result.";
+var SUBAGENT_ABORTED_OUTPUT = "Aborted before producing a result.";
+var SUBAGENT_FAILED_OPERATION_ID = SUBAGENT_ABORT_OPERATION_ID;
+var MAX_SETTLED_EVENT_IDS = 1024;
+function isTraceCarrier(value) {
+  const candidate = value;
+  return typeof candidate.traceId === "string" && typeof candidate.spanId === "string" && typeof candidate.eventId === "string";
+}
+function attrsFrom(metadata) {
+  return Object.entries(withMetadataPrefix(metadata)).map(([key, value]) => attrString(key, value));
+}
+function attrsExact(attributes) {
+  return Object.entries(attributes).map(([key, value]) => attrString(key, value));
+}
+function handoffSpanAttrs(link) {
+  if (!link) return [];
+  return attrsFrom(detachedChildMetadata(link));
+}
+function subagentNameAttrs(name, link) {
+  if (!name || (link == null ? void 0 : link.name)) return [];
+  return attrsFrom({ [HANDOFF_ATTRIBUTE_SUFFIXES.name]: name });
+}
+function cancelledSpanAttrs() {
+  return attrsExact(cancelledTerminalAttributes());
+}
+function describeAbortReason(reason) {
+  if (reason instanceof Error) return `Aborted: ${reason.message}`;
+  if (typeof reason === "string" && reason.trim().length > 0) return reason;
+  if (reason === void 0 || reason === null) return SUBAGENT_ABORTED_OUTPUT;
+  const serialized = boundedStringify(reason);
+  return serialized ? `Aborted: ${serialized}` : SUBAGENT_ABORTED_OUTPUT;
+}
+function stampOpenSpan(span, metadata) {
+  if (span.endTimeUnixNano) return;
+  span.attributes.push(...attrsFrom(metadata));
+}
+function stampOpenSpanExact(span, attributes) {
+  if (span.endTimeUnixNano) return;
+  span.attributes.push(...attrsExact(attributes));
+}
+var SubagentApi = class {
+  constructor(opts) {
+    var _a;
+    this.opts = opts;
+    this.settledEventIds = (_a = opts.settledEventIds) != null ? _a : /* @__PURE__ */ new Set();
+  }
+  /** True when this child's outcome has already been reported. */
+  wasSettledExplicitly(eventId) {
+    return this.settledEventIds.has(eventId);
+  }
+  /**
+   * Record an outcome reported somewhere other than `cancel()` / `fail()`, so
+   * first-outcome-wins holds across every path that can state one.
+   *
+   * An aborted generation is such a path: an AbortSignal cancellation IS the
+   * run's outcome, and the `fail(err)` that a catch block around the aborted
+   * call naturally reports would otherwise error the child's spans — which is
+   * the only thing separating `failed` from `cancelled`.
+   */
+  noteSettled(eventId) {
+    this.remember(eventId);
+  }
+  remember(eventId) {
+    if (this.settledEventIds.has(eventId)) return;
+    if (this.settledEventIds.size >= MAX_SETTLED_EVENT_IDS) {
+      const oldest = this.settledEventIds.values().next();
+      if (!oldest.done) this.settledEventIds.delete(oldest.value);
+    }
+    this.settledEventIds.add(eventId);
+  }
+  /**
+   * Record a detached sub-agent on this turn: allocate the child's event id,
+   * stamp the dispatch, and return the headers to send with the job.
+   *
+   * This dispatches nothing — you do, moments later, with the returned headers.
+   * Nothing here waits for the child either, or claims to know how it is doing.
+   * Readers derive that from the child's own event.
+   */
+  subagent(options = {}) {
+    var _a;
+    const childEventId = (_a = options.childEventId) != null ? _a : randomUUID();
+    const name = options.name;
+    try {
+      return this.recordLaunch(childEventId, name, options);
+    } catch (err) {
+      if (this.opts.debug) {
+        console.warn(
+          `[raindrop-ai/ai-sdk] sub-agent dispatch not recorded: ${err instanceof Error ? err.message : err}`
+        );
+      }
+      return { childEventId, name, headers: {}, carrier: null };
+    }
+  }
+  recordLaunch(childEventId, name, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    const active = (_a = this.opts.spanSource) == null ? void 0 : _a.activeDispatch();
+    const inherited = getContextManager().getParentSpanIds();
+    const eventId = (_e = (_c = (_b = options.eventId) != null ? _b : active == null ? void 0 : active.eventId) != null ? _c : inherited == null ? void 0 : inherited.eventId) != null ? _e : (_d = this.opts.defaultContext) == null ? void 0 : _d.eventId;
+    const userId = (_h = (_f = options.userId) != null ? _f : active == null ? void 0 : active.userId) != null ? _h : (_g = this.opts.defaultContext) == null ? void 0 : _g.userId;
+    const convoId = (_k = (_i = options.convoId) != null ? _i : active == null ? void 0 : active.convoId) != null ? _k : (_j = this.opts.defaultContext) == null ? void 0 : _j.convoId;
+    if (!eventId) {
+      return { childEventId, name, headers: {}, carrier: null };
+    }
+    const dispatch = detachedDispatchMetadata({ childEventId, name });
+    const toolEvents = toolEventsAllowMetadata();
+    for (const span of (_l = active == null ? void 0 : active.turnSpans) != null ? _l : []) {
+      stampOpenSpan(span, toolEvents);
+    }
+    let dispatchIds;
+    if (active == null ? void 0 : active.dispatchSpan) {
+      stampOpenSpan(active.dispatchSpan, dispatch);
+      dispatchIds = active.dispatchSpan.ids;
+    } else if (this.opts.sendTraces) {
+      dispatchIds = this.synthesizeDispatchSpan({
+        childEventId,
+        name,
+        toolName: options.toolName,
+        eventId,
+        userId,
+        convoId,
+        input: options.input,
+        // No active turn means no telemetry setting to honor: `input` is then
+        // recorded on the explicit say-so of whoever passed it.
+        recordInputs: (_m = active == null ? void 0 : active.recordInputs) != null ? _m : true,
+        dispatch,
+        parent: (inherited == null ? void 0 : inherited.eventId) === eventId ? inherited : void 0
+      }).ids;
+    }
+    const traceId = base64ToHex((_o = (_n = dispatchIds == null ? void 0 : dispatchIds.traceIdB64) != null ? _n : inherited == null ? void 0 : inherited.traceIdB64) != null ? _o : "");
+    const spanId = base64ToHex((_p = dispatchIds == null ? void 0 : dispatchIds.spanIdB64) != null ? _p : "");
+    if (!traceId || !spanId) {
+      if (this.opts.debug) {
+        console.warn(
+          "[raindrop-ai/ai-sdk] sub-agent dispatch recorded without a carrier: no dispatch span to reference (traces disabled?)"
+        );
+      }
+      return { childEventId, name, headers: {}, carrier: null };
+    }
+    const carrier = {
+      traceId,
+      spanId,
+      eventId,
+      childEventId,
+      ...name ? { name } : {},
+      ...convoId ? { convoId } : {},
+      ...userId ? { userId } : {}
+    };
+    return { childEventId, name, headers: toHeaders(carrier), carrier };
+  }
+  /**
+   * Record a dispatch span for a launch with no open tool-call span to decorate:
+   * a launch from outside a tool's `execute`, or from a caller that is not an
+   * LLM turn at all (an HTTP handler that enqueues jobs). Shaped as a tool call
+   * so it reads identically to a model-issued launch.
+   */
+  synthesizeDispatchSpan(args) {
+    var _a;
+    const spanName = (_a = args.toolName) != null ? _a : DEFAULT_DISPATCH_SPAN_NAME;
+    const span = this.opts.traceShipper.startSpan({
+      name: spanName,
+      parent: args.parent,
+      eventId: args.eventId,
+      userId: args.userId,
+      convoId: args.convoId,
+      operationId: "ai.toolCall",
+      attributes: [
+        attrString("operation.name", "ai.toolCall"),
+        attrString("resource.name", spanName),
+        attrString("ai.toolCall.name", spanName),
+        attrString("ai.toolCall.id", `call_${args.childEventId.replace(/-/g, "").slice(0, 12)}`),
+        // Gated like every other input the turn's spans record: a caller that
+        // disabled input capture must not leak the payload through the one
+        // span this API synthesizes on its behalf.
+        ...args.recordInputs ? [attrString("ai.toolCall.args", boundedStringify(args.input))] : [],
+        ...attrsFrom(args.dispatch)
+      ]
+    });
+    this.opts.traceShipper.endSpan(span, {
+      // A dispatch returns a handle, not an answer — the answer is the child's.
+      attributes: [
+        attrString(
+          "ai.toolCall.result",
+          boundedStringify({ jobId: args.childEventId, status: "accepted" })
+        )
+      ]
+    });
+    return span;
+  }
+  /**
+   * Adopt a carrier as the current run's parent reference.
+   *
+   * A missing carrier is a legitimate state — the child was invoked directly
+   * rather than dispatched — so this always returns a usable run and leaves
+   * `parent` null. Call sites stay unconditional.
+   */
+  resume(carrierOrHeaders, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const carrier = carrierOrHeaders ? isTraceCarrier(carrierOrHeaders) ? carrierOrHeaders : this.readCarrier(carrierOrHeaders) : null;
+    warnUnresolvedCarrier(carrierOrHeaders, carrier);
+    const name = (_a = carrier == null ? void 0 : carrier.name) != null ? _a : options.name;
+    const eventId = (_c = (_b = carrier == null ? void 0 : carrier.childEventId) != null ? _b : options.eventId) != null ? _c : randomUUID();
+    const userId = (_f = (_d = carrier == null ? void 0 : carrier.userId) != null ? _d : options.userId) != null ? _f : (_e = this.opts.defaultContext) == null ? void 0 : _e.userId;
+    const convoId = (_i = (_g = carrier == null ? void 0 : carrier.convoId) != null ? _g : options.convoId) != null ? _i : (_h = this.opts.defaultContext) == null ? void 0 : _h.convoId;
+    const parent = carrier ? {
+      parentEventId: carrier.eventId,
+      ...carrier.spanId ? { parentSpanId: carrier.spanId } : {},
+      ...name ? { name } : {}
+    } : null;
+    return {
+      eventId,
+      name,
+      userId,
+      convoId,
+      parent,
+      metadata: {
+        eventId,
+        ...userId ? { userId } : {},
+        ...convoId ? { convoId } : {},
+        ...parent ? { subagent: parent } : {}
+      },
+      cancel: (reason) => this.settle(eventId, { userId, convoId, name, cancelled: true, output: reason }),
+      fail: (reason) => this.settle(eventId, {
+        userId,
+        convoId,
+        name,
+        handoff: parent != null ? parent : void 0,
+        cancelled: false,
+        output: describeAbortReason(reason),
+        error: reason
+      })
+    };
+  }
+  /**
+   * A carrier arrives from outside this process, so a hostile or merely broken
+   * header bag must cost the job its link, never its run.
+   */
+  readCarrier(headers) {
+    try {
+      return fromHeaders(headers);
+    } catch (err) {
+      if (this.opts.debug) {
+        console.warn(
+          `[raindrop-ai/ai-sdk] sub-agent carrier ignored: ${err instanceof Error ? err.message : err}`
+        );
+      }
+      return null;
+    }
+  }
+  /**
+   * Mark a failed child's own spans as errored.
+   *
+   * Reporting the reason as output is what gets the child an event at all, but
+   * output alone is not enough: status is derived from span shape, and a child
+   * with final output and no error spans derives `finished`. A failed job
+   * reporting success is worse than one reporting nothing, so the failure has
+   * to land on the telemetry too, not just in the text.
+   *
+   * This is the child describing its own run, not a caller writing a status it
+   * cannot observe — the child's own spans are exactly where the contract puts
+   * failure.
+   */
+  recordFailureOnSpans(eventId, args, reason) {
+    var _a, _b, _c;
+    if (!this.opts.sendTraces) return;
+    const failure = (_a = args.error) != null ? _a : reason;
+    let marked = 0;
+    for (const span2 of (_c = (_b = this.opts.spanSource) == null ? void 0 : _b.openSpansForEvent(eventId)) != null ? _c : []) {
+      if (span2.endTimeUnixNano) continue;
+      this.opts.traceShipper.endSpan(span2, { error: failure });
+      marked++;
+    }
+    if (marked > 0) return;
+    const spanName = SUBAGENT_ABORT_SPAN_NAME;
+    const span = this.opts.traceShipper.startSpan({
+      name: spanName,
+      eventId,
+      userId: args.userId,
+      convoId: args.convoId,
+      // Required, not decorative: ingest drops any span carrying no
+      // `ai.operationId` (or traceloop / `gen_ai.*` key) and still answers 200,
+      // so without this the failure disappears silently. The value is
+      // deliberately none of the generate/stream/tool/embed forms, which is
+      // what classifies the span as INTERNAL rather than mislabelling a failed
+      // job as a model call or a tool call.
+      operationId: SUBAGENT_FAILED_OPERATION_ID,
+      // Carries the reverse reference like every other span the child emits:
+      // this is often the child's ONLY span, and a span read on its own is the
+      // whole reason the reference cannot live on the root alone. The name is
+      // stamped even for an unlinked run, which has no caller to reference —
+      // `span_name` no longer says which sub-agent this was, so the attribute
+      // is the only thing that can.
+      attributes: [
+        attrString("resource.name", spanName),
+        ...handoffSpanAttrs(args.handoff),
+        ...subagentNameAttrs(args.name, args.handoff)
+      ]
+    });
+    this.opts.traceShipper.endSpan(span, { error: failure });
+  }
+  async settle(eventId, args) {
+    var _a, _b;
+    if (this.settledEventIds.has(eventId)) {
+      if (this.opts.debug) {
+        console.warn(
+          `[raindrop-ai/ai-sdk] sub-agent ${eventId} already reported an outcome; ignoring the second one`
+        );
+      }
+      return;
+    }
+    this.remember(eventId);
+    const output = args.output && args.output.trim().length > 0 ? args.output : args.cancelled ? SUBAGENT_CANCELLED_OUTPUT : SUBAGENT_ABORTED_OUTPUT;
+    try {
+      if (args.cancelled) {
+        for (const span of (_b = (_a = this.opts.spanSource) == null ? void 0 : _a.openSpansForEvent(eventId)) != null ? _b : []) {
+          stampOpenSpanExact(span, cancelledTerminalAttributes());
+        }
+      } else {
+        this.recordFailureOnSpans(eventId, args, output);
+      }
+    } catch (err) {
+      if (this.opts.debug) {
+        console.warn(
+          `[raindrop-ai/ai-sdk] sub-agent outcome not recorded on spans: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    }
+    if (!this.opts.sendEvents) return;
+    await this.opts.eventShipper.patch(eventId, {
+      userId: args.userId,
+      convoId: args.convoId,
+      // An event is only created from a run that reported something. A child
+      // that dies silently produces no event at all, which pins the caller on
+      // `queued` forever — indistinguishable from a job that never started.
+      output,
+      ...args.cancelled ? { properties: { [HANDOFF_TERMINAL_PROPERTY_KEY]: HANDOFF_TERMINAL_CANCELLED } } : {},
+      isPending: false
+    }).catch((err) => {
+      if (this.opts.debug) {
+        console.warn(
+          `[raindrop-ai/ai-sdk] sub-agent outcome patch failed: ${err instanceof Error ? err.message : err}`
+        );
+      }
+    });
+  }
+};
+
+// src/internal/usage.ts
+function firstTokenCount(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function flatUsageSemantics(provider) {
+  const normalizedProvider = typeof provider === "string" ? provider.trim().toLowerCase() : void 0;
+  if (normalizedProvider === "anthropic" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("anthropic.")) || normalizedProvider === "vertex.anthropic" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("vertex.anthropic."))) {
+    return {
+      inputTokenSemantics: "exclusive",
+      outputTokenSemantics: "total"
+    };
+  }
+  if (normalizedProvider === "openai" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("openai.")) || normalizedProvider === "azure" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("azure."))) {
+    return {
+      inputTokenSemantics: "total",
+      outputTokenSemantics: "total"
+    };
+  }
+  if (normalizedProvider === "google" || (normalizedProvider == null ? void 0 : normalizedProvider.startsWith("google."))) {
+    return {
+      inputTokenSemantics: "total",
+      // Google v5 reports candidate output and thoughts separately.
+      outputTokenSemantics: "exclusive"
+    };
+  }
+  return {};
+}
+var CACHE_WRITE_METADATA_KEYS = [
+  ["anthropic", "cacheCreationInputTokens"],
+  ["openai", "cacheWriteTokens"],
+  ["bedrock", "cacheWriteInputTokens"]
+];
+function cacheWriteTokensFromProviderMetadata(providerMetadata) {
+  if (!isRecord(providerMetadata)) return void 0;
+  return firstTokenCount(
+    ...CACHE_WRITE_METADATA_KEYS.flatMap(([namespace, key]) => {
+      const scope = providerMetadata[namespace];
+      if (!isRecord(scope)) return [];
+      const usage = scope["usage"];
+      return [scope[key], isRecord(usage) ? usage[key] : void 0];
+    })
+  );
+}
+function extractUsageMetricsFromUsage(usage, provider, providerMetadata) {
+  if (!isRecord(usage)) return {};
+  const inputTokenValue = usage["inputTokens"];
+  const outputTokenValue = usage["outputTokens"];
+  const inputTokenDetails = usage["inputTokenDetails"];
+  const outputTokenDetails = usage["outputTokenDetails"];
+  const hasStructuredUsage = isRecord(inputTokenValue) || isRecord(outputTokenValue) || isRecord(inputTokenDetails) || isRecord(outputTokenDetails);
+  const inputTokens = firstTokenCount(
+    isRecord(inputTokenValue) ? inputTokenValue["total"] : void 0,
+    inputTokenValue,
+    usage["promptTokens"],
+    usage["prompt_tokens"]
+  );
+  const outputTokens = firstTokenCount(
+    isRecord(outputTokenValue) ? outputTokenValue["total"] : void 0,
+    outputTokenValue,
+    usage["completionTokens"],
+    usage["completion_tokens"]
+  );
+  const reasoningTokens = firstTokenCount(
+    isRecord(outputTokenValue) ? outputTokenValue["reasoning"] : void 0,
+    isRecord(outputTokenDetails) ? outputTokenDetails["reasoningTokens"] : void 0,
+    usage["reasoningTokens"],
+    usage["completionReasoningTokens"],
+    usage["completion_reasoning_tokens"],
+    usage["reasoning_tokens"],
+    usage["thinkingTokens"],
+    usage["thinking_tokens"]
+  );
+  const cacheReadInputTokens = firstTokenCount(
+    isRecord(inputTokenValue) ? inputTokenValue["cacheRead"] : void 0,
+    isRecord(inputTokenDetails) ? inputTokenDetails["cacheReadTokens"] : void 0,
+    usage["cachedInputTokens"],
+    usage["promptCachedTokens"],
+    usage["prompt_cached_tokens"]
+  );
+  const cacheWriteInputTokens = firstTokenCount(
+    isRecord(inputTokenValue) ? inputTokenValue["cacheWrite"] : void 0,
+    isRecord(inputTokenDetails) ? inputTokenDetails["cacheWriteTokens"] : void 0,
+    usage["cacheWriteInputTokens"],
+    usage["cacheCreationInputTokens"],
+    usage["cache_creation_input_tokens"],
+    cacheWriteTokensFromProviderMetadata(providerMetadata)
+  );
+  const nonCachedInputTokens = firstTokenCount(
+    isRecord(inputTokenValue) ? inputTokenValue["noCache"] : void 0,
+    isRecord(inputTokenDetails) ? inputTokenDetails["noCacheTokens"] : void 0
+  );
+  const nonReasoningOutputTokens = firstTokenCount(
+    isRecord(outputTokenValue) ? outputTokenValue["text"] : void 0,
+    isRecord(outputTokenDetails) ? outputTokenDetails["textTokens"] : void 0
+  );
+  const totalTokens = firstTokenCount(
+    usage["totalTokens"],
+    usage["tokens"],
+    usage["total_tokens"],
+    inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0
+  );
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    nonCachedInputTokens,
+    nonReasoningOutputTokens,
+    reasoningTokens,
+    cacheReadInputTokens,
+    cachedInputTokens: cacheReadInputTokens,
+    cacheWriteInputTokens,
+    ...hasStructuredUsage ? {} : flatUsageSemantics(provider)
+  };
+}
+
 // src/internal/raindrop-telemetry-integration.ts
 function hasUnresolvedToolApproval(event) {
   var _a;
@@ -2314,6 +3286,7 @@ var RaindropTelemetryIntegration = class {
         eventName: (_f = callMeta.eventName) != null ? _f : (_e = this.defaultContext) == null ? void 0 : _e.eventName
       };
       const inherited = getContextManager().getParentSpanIds();
+      const handoff = readDetachedChildLink(metadata);
       const eventIdGenerated = (metadata == null ? void 0 : metadata["raindrop.internal.eventIdGenerated"]) === "true" || (metadata == null ? void 0 : metadata["raindrop.internal.eventIdGenerated"]) === true || (callContextMetadata == null ? void 0 : callContextMetadata.eventIdGenerated) === true;
       const explicitEventId = callMeta.eventId && !eventIdGenerated ? callMeta.eventId : void 0;
       const eventId = (_j = (_i = (_h = explicitEventId != null ? explicitEventId : (_g = this.defaultContext) == null ? void 0 : _g.eventId) != null ? _h : inherited == null ? void 0 : inherited.eventId) != null ? _i : callMeta.eventId) != null ? _j : randomUUID();
@@ -2343,7 +3316,10 @@ var RaindropTelemetryIntegration = class {
             attrString("ai.toolCall.name", subagentName),
             attrString("raindrop.subagent.name", subagentName),
             attrString("raindrop.agent.role", "subagent"),
-            ...parentAttrs
+            ...parentAttrs,
+            // Top of this child's tree, so the reverse reference matters as much
+            // here as on the root: these are the spans a reader lands on first.
+            ...handoffSpanAttrs(handoff)
           ]
         });
         const subagentParentRef = this.spanParentRef(subagentToolCallSpan);
@@ -2356,7 +3332,8 @@ var RaindropTelemetryIntegration = class {
           attributes: [
             attrString("operation.name", "agent.subagent"),
             attrString("raindrop.span.kind", "llm_call"),
-            attrString("raindrop.subagent.name", subagentName)
+            attrString("raindrop.subagent.name", subagentName),
+            ...handoffSpanAttrs(handoff)
           ]
         });
         this.traceShipper.endSpan(markerSpan);
@@ -2411,6 +3388,8 @@ var RaindropTelemetryIntegration = class {
         rootParent: rootSpan ? this.spanParentRef(rootSpan) : rootParentOverride != null ? rootParentOverride : inheritedParent,
         stepSpan: void 0,
         stepParent: void 0,
+        stepProvider: void 0,
+        stepModelId: void 0,
         toolSpans: /* @__PURE__ */ new Map(),
         embedSpans: /* @__PURE__ */ new Map(),
         parentContextToolCallIds: /* @__PURE__ */ new Set(),
@@ -2422,7 +3401,9 @@ var RaindropTelemetryIntegration = class {
         inputText: isEmbed ? void 0 : this.extractInputText(event),
         toolCallCount: 0,
         subagentName,
-        subagentToolCallSpan
+        subagentToolCallSpan,
+        handoff,
+        nestedInEvent: inheritedParent !== void 0
       });
     };
     // ── onStepStart ─────────────────────────────────────────────────────────
@@ -2464,15 +3445,17 @@ var RaindropTelemetryIntegration = class {
           attrString("operation.name", operationName),
           attrString("resource.name", resourceName),
           attrString("ai.telemetry.functionId", state.functionId),
-          attrString("ai.model.provider", event.provider),
+          ...attrsFromModelProvider(event.provider),
           attrString("ai.model.id", event.modelId),
-          attrString("gen_ai.system", event.provider),
-          attrString("gen_ai.request.model", event.modelId),
-          ...inputAttrs
+          attrString(MODEL_USAGE_ATTRIBUTES.requestModel, event.modelId),
+          ...inputAttrs,
+          ...handoffSpanAttrs(state.handoff)
         ]
       });
       state.stepSpan = stepSpan;
       state.stepParent = this.spanParentRef(stepSpan);
+      state.stepProvider = event.provider;
+      state.stepModelId = event.modelId;
     };
     this.onToolExecutionStart = (event) => this.toolExecutionStart(event);
     this.onToolExecutionEnd = (event) => this.toolExecutionEnd(event);
@@ -2523,23 +3506,24 @@ var RaindropTelemetryIntegration = class {
       var _a, _b, _c, _d, _e, _f, _g, _h, _i;
       const state = this.getState(event.callId);
       if (!(state == null ? void 0 : state.stepSpan)) return;
+      const responseModelId = (_b = (_a = event.response) == null ? void 0 : _a.modelId) != null ? _b : state.stepModelId;
       const outputAttrs = [];
       if (state.recordOutputs) {
         outputAttrs.push(
           attrString("ai.response.finishReason", event.finishReason),
-          attrString("ai.response.text", capText2((_a = event.text) != null ? _a : void 0)),
-          attrString("ai.response.id", (_b = event.response) == null ? void 0 : _b.id),
-          attrString("ai.response.model", (_c = event.response) == null ? void 0 : _c.modelId),
+          attrString("ai.response.text", capText2((_c = event.text) != null ? _c : void 0)),
+          attrString("ai.response.id", (_d = event.response) == null ? void 0 : _d.id),
+          attrString("ai.response.model", responseModelId),
           attrString(
             "ai.response.timestamp",
-            ((_d = event.response) == null ? void 0 : _d.timestamp) instanceof Date ? event.response.timestamp.toISOString() : (_e = event.response) == null ? void 0 : _e.timestamp
+            ((_e = event.response) == null ? void 0 : _e.timestamp) instanceof Date ? event.response.timestamp.toISOString() : (_f = event.response) == null ? void 0 : _f.timestamp
           ),
           attrString(
             "ai.response.providerMetadata",
             event.providerMetadata ? safeJsonWithUint8(event.providerMetadata) : void 0
           )
         );
-        if (((_f = event.toolCalls) == null ? void 0 : _f.length) > 0) {
+        if (((_g = event.toolCalls) == null ? void 0 : _g.length) > 0) {
           outputAttrs.push(
             attrString(
               "ai.response.toolCalls",
@@ -2553,7 +3537,7 @@ var RaindropTelemetryIntegration = class {
             )
           );
         }
-        if (((_g = event.reasoning) == null ? void 0 : _g.length) > 0) {
+        if (((_h = event.reasoning) == null ? void 0 : _h.length) > 0) {
           const reasoningText = event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n");
           if (reasoningText) {
             outputAttrs.push(attrString("ai.response.reasoning", capText2(reasoningText)));
@@ -2562,25 +3546,31 @@ var RaindropTelemetryIntegration = class {
       }
       outputAttrs.push(
         attrStringArray("gen_ai.response.finish_reasons", [event.finishReason]),
-        attrString("gen_ai.response.id", (_h = event.response) == null ? void 0 : _h.id),
-        attrString("gen_ai.response.model", (_i = event.response) == null ? void 0 : _i.modelId)
+        attrString("gen_ai.response.id", (_i = event.response) == null ? void 0 : _i.id),
+        attrString(MODEL_USAGE_ATTRIBUTES.responseModel, responseModelId)
       );
       const usage = event.usage;
       if (usage) {
+        const usageMetrics = extractUsageMetricsFromUsage(
+          usage,
+          state.stepProvider,
+          event.providerMetadata
+        );
         outputAttrs.push(
-          attrInt("ai.usage.inputTokens", usage.inputTokens),
-          attrInt("ai.usage.outputTokens", usage.outputTokens),
-          attrInt("ai.usage.totalTokens", usage.totalTokens),
-          attrInt("ai.usage.reasoningTokens", usage.reasoningTokens),
-          attrInt("ai.usage.cachedInputTokens", usage.cachedInputTokens),
-          attrInt("gen_ai.usage.input_tokens", usage.inputTokens),
-          attrInt("gen_ai.usage.output_tokens", usage.outputTokens)
+          attrInt("ai.usage.inputTokens", usageMetrics.inputTokens),
+          attrInt("ai.usage.outputTokens", usageMetrics.outputTokens),
+          attrInt("ai.usage.totalTokens", usageMetrics.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usageMetrics.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usageMetrics.cachedInputTokens),
+          ...buildModelUsageAttributes(usageMetrics)
         );
       }
       this.emitProviderExecutedToolSpans(event, state);
       this.traceShipper.endSpan(state.stepSpan, { attributes: outputAttrs });
       state.stepSpan = void 0;
       state.stepParent = void 0;
+      state.stepProvider = void 0;
+      state.stepModelId = void 0;
     };
     // ── onEmbedStart ────────────────────────────────────────────────────────
     this.onEmbedStart = (event) => {
@@ -2598,7 +3588,8 @@ var RaindropTelemetryIntegration = class {
           attrString("operation.name", operationName),
           attrString("resource.name", resourceName),
           attrString("ai.telemetry.functionId", state.functionId),
-          ...inputAttrs
+          ...inputAttrs,
+          ...handoffSpanAttrs(state.handoff)
         ]
       });
       state.embedSpans.set(event.embedCallId, embedSpan);
@@ -2655,6 +3646,8 @@ var RaindropTelemetryIntegration = class {
       const actualError = (_a = event.error) != null ? _a : error;
       if (state.stepSpan) {
         this.traceShipper.endSpan(state.stepSpan, { error: actualError });
+        state.stepProvider = void 0;
+        state.stepModelId = void 0;
       }
       for (const embedSpan of state.embedSpans.values()) {
         this.traceShipper.endSpan(embedSpan, { error: actualError });
@@ -2668,15 +3661,26 @@ var RaindropTelemetryIntegration = class {
         this.traceShipper.endSpan(toolSpan, { error: actualError });
       }
       state.toolSpans.clear();
+      const abortReason = describeAbortReason(actualError);
       if (state.rootSpan) {
-        this.traceShipper.endSpan(state.rootSpan, { error: actualError });
+        this.traceShipper.endSpan(state.rootSpan, {
+          error: actualError,
+          attributes: this.abortOutcomeAttrs(state, abortReason, "error")
+        });
       }
       if (state.subagentToolCallSpan) {
         this.traceShipper.endSpan(state.subagentToolCallSpan, { error: actualError });
       }
       const isEmbed = state.operationId === "ai.embed" || state.operationId === "ai.embedMany";
       if (!isEmbed) {
-        this.finalizeGenerateEvent(state, state.accumulatedText || void 0, void 0);
+        const errorIsTheRunsOutcome = state.handoff !== void 0 && !state.nestedInEvent;
+        this.finalizeGenerateEvent(
+          state,
+          state.accumulatedText || void 0,
+          void 0,
+          false,
+          errorIsTheRunsOutcome ? { fallbackOutput: abortReason } : void 0
+        );
       }
       this.cleanup(event.callId);
     };
@@ -2698,6 +3702,8 @@ var RaindropTelemetryIntegration = class {
         this.traceShipper.endSpan(state.stepSpan, { attributes: [abortedAttr] });
         state.stepSpan = void 0;
         state.stepParent = void 0;
+        state.stepProvider = void 0;
+        state.stepModelId = void 0;
       }
       for (const embedSpan of state.embedSpans.values()) {
         this.traceShipper.endSpan(embedSpan, { attributes: [abortedAttr] });
@@ -2711,9 +3717,19 @@ var RaindropTelemetryIntegration = class {
         this.traceShipper.endSpan(toolSpan, { attributes: [abortedAttr] });
       }
       state.toolSpans.clear();
+      const abortIsTheRunsOutcome = state.handoff !== void 0 && !state.nestedInEvent;
       if (state.rootSpan) {
         this.traceShipper.endSpan(state.rootSpan, {
-          attributes: [abortedAttr, attrInt("ai.toolCall.count", state.toolCallCount)]
+          attributes: [
+            abortedAttr,
+            attrInt("ai.toolCall.count", state.toolCallCount),
+            // An aborted detached child IS a cancelled sub-agent, and a cancelled
+            // run is span-for-span identical to a finished one — spans close,
+            // nothing errors, there is just no answer. So it is the one outcome
+            // that has to be stated, and the child states it on itself.
+            ...abortIsTheRunsOutcome ? cancelledSpanAttrs() : [],
+            ...abortIsTheRunsOutcome ? this.abortOutcomeAttrs(state, SUBAGENT_CANCELLED_OUTPUT, "stop") : []
+          ]
         });
       }
       if (state.subagentToolCallSpan) {
@@ -2721,7 +3737,17 @@ var RaindropTelemetryIntegration = class {
           attributes: [abortedAttr]
         });
       }
-      this.finalizeGenerateEvent(state, state.accumulatedText || void 0, void 0);
+      this.finalizeGenerateEvent(
+        state,
+        state.accumulatedText || void 0,
+        void 0,
+        false,
+        abortIsTheRunsOutcome ? {
+          fallbackOutput: SUBAGENT_CANCELLED_OUTPUT,
+          properties: { [HANDOFF_TERMINAL_PROPERTY_KEY]: HANDOFF_TERMINAL_CANCELLED }
+        } : void 0
+      );
+      if (abortIsTheRunsOutcome) this.subagents.noteSettled(state.eventId);
       this.cleanup(callId);
     };
     // ── executeTool ─────────────────────────────────────────────────────────
@@ -2749,6 +3775,97 @@ var RaindropTelemetryIntegration = class {
     this.subagentWrapping = opts.subagentWrapping !== false;
     this.debug = opts.debug === true;
     this.defaultContext = opts.context;
+    this.subagents = new SubagentApi({
+      traceShipper: this.traceShipper,
+      eventShipper: this.eventShipper,
+      sendTraces: this.sendTraces,
+      sendEvents: this.sendEvents,
+      debug: this.debug,
+      defaultContext: this.defaultContext,
+      settledEventIds: opts.settledEventIds,
+      spanSource: {
+        activeDispatch: () => this.activeDispatch(),
+        openSpansForEvent: (eventId) => this.openSpansForEvent(eventId)
+      }
+    });
+  }
+  /**
+   * Record a detached sub-agent on the turn that is live right now.
+   *
+   * Returns the dispatch — the child's event id and the headers to send with
+   * the job. Dispatching is still yours to do; this only states that you are
+   * about to, so a reader can follow the link before the child exists.
+   */
+  subagent(options = {}) {
+    return this.subagents.subagent(options);
+  }
+  // ── detached sub-agent hand-offs ─────────────────────────────────────────
+  /**
+   * The turn a `subagent()` dispatch is happening inside.
+   *
+   * Resolved from the parent-tool context first, which is the only way to reach
+   * the EXACT span that dispatched: the tool call the model itself issued, still
+   * open while its `execute` runs. Falling back to the event id lets a launch
+   * from elsewhere in the turn (a queue producer called mid-generation) still
+   * find the turn's spans, which is where the tool-events opt-in has to land.
+   */
+  activeDispatch() {
+    var _a;
+    const parentTool = getCurrentParentToolContext();
+    let state = parentTool ? this.getState(parentTool.parentCallId) : void 0;
+    const inheritedEventId = (_a = getContextManager().getParentSpanIds()) == null ? void 0 : _a.eventId;
+    if (!state && inheritedEventId) {
+      for (const candidate of this.callStates.values()) {
+        if (candidate.eventId === inheritedEventId) {
+          state = candidate;
+          break;
+        }
+      }
+    }
+    if (!state) return void 0;
+    return {
+      eventId: state.eventId,
+      userId: state.identity.userId,
+      convoId: state.identity.convoId,
+      dispatchSpan: parentTool ? state.toolSpans.get(parentTool.toolCallId) : void 0,
+      turnSpans: [state.rootSpan, state.stepSpan].filter(
+        (span) => span !== void 0
+      ),
+      recordInputs: state.recordInputs
+    };
+  }
+  /** Spans still open for an event, so a late outcome can still be stated. */
+  openSpansForEvent(eventId) {
+    const spans = [];
+    for (const state of this.callStates.values()) {
+      if (state.eventId !== eventId) continue;
+      if (state.rootSpan) spans.push(state.rootSpan);
+      if (state.stepSpan) spans.push(state.stepSpan);
+    }
+    return spans;
+  }
+  /**
+   * End-attributes that keep a detached child legible when it ends without an
+   * answer — an error, an abort, a cancellation.
+   *
+   * An event is created from an LLM span only when it has a finish reason and
+   * non-empty output, so a child that dies silently produces NO event, and the
+   * caller's hand-off pill stays on `queued` forever — indistinguishable from a
+   * job that never started. Reporting the abort reason as the run's output is
+   * what makes the outcome visible. Only detached children get this: an inline
+   * generation's failure is already legible from its caller's own event.
+   *
+   * And only the run's OUTERMOST generation gets it (see `nestedInEvent`): an
+   * inner sub-call ending badly is not the run ending, and since an event is
+   * created from an LLM span with output, `ai.response.text` here would state
+   * the run's outcome through the span while the turn is still working.
+   */
+  abortOutcomeAttrs(state, reason, finishReason) {
+    if (!state.handoff || state.nestedInEvent) return [];
+    return [
+      attrString("ai.response.text", capText2(state.accumulatedText || reason)),
+      attrString("ai.response.finishReason", finishReason)
+    ];
   }
   // ── helpers ──────────────────────────────────────────────────────────────
   getState(callId) {
@@ -2867,7 +3984,8 @@ var RaindropTelemetryIntegration = class {
         attrString("ai.telemetry.functionId", state.functionId),
         attrString("ai.toolCall.name", toolCall.toolName),
         attrString("ai.toolCall.id", toolCall.toolCallId),
-        ...inputAttrs
+        ...inputAttrs,
+        ...handoffSpanAttrs(state.handoff)
       ]
     });
     state.toolSpans.set(toolCall.toolCallId, toolSpan);
@@ -2946,7 +4064,8 @@ var RaindropTelemetryIntegration = class {
           attrString("ai.toolCall.name", call.toolName),
           attrString("ai.toolCall.id", call.toolCallId),
           attrString("ai.toolCall.providerExecuted", "true"),
-          ...inputAttrs
+          ...inputAttrs,
+          ...handoffSpanAttrs(state.handoff)
         ]
       });
       state.toolCallCount += 1;
@@ -2997,12 +4116,13 @@ var RaindropTelemetryIntegration = class {
       }
       const usage = (_d = event.totalUsage) != null ? _d : event.usage;
       if (usage) {
+        const usageMetrics = extractUsageMetricsFromUsage(usage);
         outputAttrs.push(
-          attrInt("ai.usage.inputTokens", usage.inputTokens),
-          attrInt("ai.usage.outputTokens", usage.outputTokens),
-          attrInt("ai.usage.totalTokens", usage.totalTokens),
-          attrInt("ai.usage.reasoningTokens", usage.reasoningTokens),
-          attrInt("ai.usage.cachedInputTokens", usage.cachedInputTokens)
+          attrInt("ai.usage.inputTokens", usageMetrics.inputTokens),
+          attrInt("ai.usage.outputTokens", usageMetrics.outputTokens),
+          attrInt("ai.usage.totalTokens", usageMetrics.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usageMetrics.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usageMetrics.cachedInputTokens)
         );
       }
       outputAttrs.push(attrInt("ai.toolCall.count", state.toolCallCount));
@@ -3026,19 +4146,22 @@ var RaindropTelemetryIntegration = class {
    * is finalized by that resume — otherwise each execution would finalize the
    * same event ID into a separate canonical row.
    */
-  finalizeGenerateEvent(state, output, model, keepPending = false) {
+  finalizeGenerateEvent(state, output, model, keepPending = false, detachedOutcome) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const suppressSubagentEvent = state.subagentName !== void 0 && state.subagentToolCallSpan !== void 0;
     if (!this.sendEvents || suppressSubagentEvent) return;
+    if (this.subagents.wasSettledExplicitly(state.eventId)) return;
     const callMeta = this.extractRaindropMetadata(state.metadata);
     const userId = (_b = callMeta.userId) != null ? _b : (_a = this.defaultContext) == null ? void 0 : _a.userId;
     if (!userId) return;
     const eventName = (_e = (_d = callMeta.eventName) != null ? _d : (_c = this.defaultContext) == null ? void 0 : _c.eventName) != null ? _e : state.operationId;
     const cappedOutput = capText2(output);
+    const reportedOutput = state.handoff && detachedOutcome && !(cappedOutput == null ? void 0 : cappedOutput.trim()) ? detachedOutcome.fallbackOutput : cappedOutput;
     const input = capText2(state.inputText);
     const properties = {
       ...(_f = this.defaultContext) == null ? void 0 : _f.properties,
-      ...callMeta.properties
+      ...callMeta.properties,
+      ...state.handoff ? detachedOutcome == null ? void 0 : detachedOutcome.properties : void 0
     };
     const featureFlags = {
       ...((_g = this.defaultContext) == null ? void 0 : _g.featureFlags) ? normalizeFeatureFlags(this.defaultContext.featureFlags) : {},
@@ -3050,7 +4173,7 @@ var RaindropTelemetryIntegration = class {
       userId,
       convoId,
       input,
-      output: cappedOutput,
+      output: reportedOutput,
       model,
       properties: Object.keys(properties).length > 0 ? properties : void 0,
       featureFlags: Object.keys(featureFlags).length > 0 ? featureFlags : void 0,
@@ -3442,14 +4565,6 @@ function runWithParentSpanContextSync(ctx, fn) {
 function isAsyncIterable(value) {
   return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
 }
-function firstFiniteNumber(...values) {
-  for (const value of values) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
-    }
-  }
-  return void 0;
-}
 function resolveUsageRecord(result) {
   if (!isRecord(result)) return void 0;
   let usage;
@@ -3465,50 +4580,7 @@ function resolveUsageRecord(result) {
   return isRecord(usage) ? usage : void 0;
 }
 function extractUsageMetrics(result) {
-  const usage = resolveUsageRecord(result);
-  if (!usage) return {};
-  const inputTokenValue = usage["inputTokens"];
-  const outputTokenValue = usage["outputTokens"];
-  const inputTokens = firstFiniteNumber(
-    isRecord(inputTokenValue) ? inputTokenValue["total"] : void 0,
-    inputTokenValue,
-    usage["promptTokens"],
-    usage["prompt_tokens"]
-  );
-  const outputTokens = firstFiniteNumber(
-    isRecord(outputTokenValue) ? outputTokenValue["total"] : void 0,
-    outputTokenValue,
-    usage["completionTokens"],
-    usage["completion_tokens"]
-  );
-  const totalTokens = firstFiniteNumber(
-    usage["totalTokens"],
-    usage["tokens"],
-    usage["total_tokens"],
-    inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0
-  );
-  const reasoningTokens = firstFiniteNumber(
-    isRecord(outputTokenValue) ? outputTokenValue["reasoning"] : void 0,
-    usage["reasoningTokens"],
-    usage["completionReasoningTokens"],
-    usage["completion_reasoning_tokens"],
-    usage["reasoning_tokens"],
-    usage["thinkingTokens"],
-    usage["thinking_tokens"]
-  );
-  const cachedInputTokens = firstFiniteNumber(
-    isRecord(inputTokenValue) ? inputTokenValue["cacheRead"] : void 0,
-    usage["cachedInputTokens"],
-    usage["promptCachedTokens"],
-    usage["prompt_cached_tokens"]
-  );
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens,
-    reasoningTokens,
-    cachedInputTokens
-  };
+  return extractUsageMetricsFromUsage(resolveUsageRecord(result));
 }
 function isObjectOperation(operation) {
   return operation === "generateObject" || operation === "streamObject";
@@ -4000,6 +5072,7 @@ function wrapAISDK(aiSDK, deps) {
       sendTraces: ((_a = deps.options.send) == null ? void 0 : _a.traces) !== false,
       sendEvents: ((_b = deps.options.send) == null ? void 0 : _b.events) !== false,
       debug,
+      settledEventIds: deps.settledEventIds,
       context: {
         userId: wrapTimeCtx.userId,
         eventId: wrapTimeCtx.eventId,
@@ -4899,8 +5972,13 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
             ended = true;
             const msToFirstChunk = firstChunkMs !== void 0 ? firstChunkMs - startMs : void 0;
             const msToFinish = finishMs !== void 0 ? finishMs - startMs : void 0;
-            const inputTokens = extractNestedTokens(usage, "inputTokens");
-            const outputTokens = extractNestedTokens(usage, "outputTokens");
+            const usageMetrics = extractUsageMetricsFromUsage(
+              usage,
+              modelInfo.provider,
+              providerMetadata
+            );
+            const finalResponseModelId = responseModelId != null ? responseModelId : modelInfo.modelId;
+            const { inputTokens, outputTokens } = usageMetrics;
             const avgOutTokensPerSecond = msToFinish && outputTokens !== void 0 && msToFinish > 0 ? 1e3 * outputTokens / msToFinish : void 0;
             ctx.traceShipper.endSpan(span, {
               attributes: [
@@ -4912,7 +5990,7 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                     safeJsonWithUint8(toolCallsLocal.length ? toolCallsLocal : void 0)
                   ),
                   attrString("ai.response.id", responseId),
-                  attrString("ai.response.model", responseModelId),
+                  attrString("ai.response.model", finalResponseModelId),
                   attrString("ai.response.timestamp", responseTimestampIso),
                   attrString(
                     "ai.response.providerMetadata",
@@ -4923,9 +6001,8 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                 attrInt("ai.usage.outputTokens", outputTokens),
                 ...finishReason ? [attrStringArray("gen_ai.response.finish_reasons", [finishReason])] : [],
                 attrString("gen_ai.response.id", responseId),
-                attrString("gen_ai.response.model", responseModelId),
-                attrInt("gen_ai.usage.input_tokens", inputTokens),
-                attrInt("gen_ai.usage.output_tokens", outputTokens),
+                attrString(MODEL_USAGE_ATTRIBUTES.responseModel, finalResponseModelId),
+                ...buildModelUsageAttributes(usageMetrics),
                 ...msToFirstChunk !== void 0 ? [attrInt("ai.stream.msToFirstChunk", msToFirstChunk)] : [],
                 ...msToFinish !== void 0 ? [attrInt("ai.stream.msToFinish", msToFinish)] : [],
                 ...avgOutTokensPerSecond !== void 0 ? [attrDouble("ai.stream.avgOutputTokensPerSecond", avgOutTokensPerSecond)] : [],
@@ -5031,15 +6108,14 @@ function startDoGenerateSpan(operationId, options, modelInfo, parent, ctx) {
       attrString("operation.name", operationName),
       attrString("resource.name", resourceName),
       attrString("ai.telemetry.functionId", (_b = ctx.telemetry) == null ? void 0 : _b.functionId),
-      attrString("ai.model.provider", modelInfo.provider),
+      ...attrsFromModelProvider(modelInfo.provider),
       attrString("ai.model.id", modelInfo.modelId),
       ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [
         attrString("ai.prompt.messages", promptJson),
         attrStringArray("ai.prompt.tools", toolsJson),
         attrString("ai.prompt.toolChoice", toolChoiceJson)
       ],
-      attrString("gen_ai.system", modelInfo.provider),
-      attrString("gen_ai.request.model", modelInfo.modelId),
+      attrString(MODEL_USAGE_ATTRIBUTES.requestModel, modelInfo.modelId),
       ...attrsFromGenAiRequest(options),
       attrProviderOptions(options)
     ]
@@ -5072,8 +6148,12 @@ function endDoGenerateSpan(span, result, modelInfo, ctx) {
   } else {
     responseTimestampIso = (/* @__PURE__ */ new Date()).toISOString();
   }
-  const inputTokens = extractNestedTokens(usage, "inputTokens");
-  const outputTokens = extractNestedTokens(usage, "outputTokens");
+  const usageMetrics = extractUsageMetricsFromUsage(
+    usage,
+    modelInfo.provider,
+    providerMetadata
+  );
+  const { inputTokens, outputTokens } = usageMetrics;
   ctx.traceShipper.endSpan(span, {
     attributes: [
       ...((_a = ctx.telemetry) == null ? void 0 : _a.recordOutputs) === false ? [] : [
@@ -5092,9 +6172,8 @@ function endDoGenerateSpan(span, result, modelInfo, ctx) {
       attrInt("ai.usage.completionTokens", outputTokens),
       ...finishReason ? [attrStringArray("gen_ai.response.finish_reasons", [finishReason])] : [],
       attrString("gen_ai.response.id", responseId),
-      attrString("gen_ai.response.model", responseModelId),
-      attrInt("gen_ai.usage.input_tokens", inputTokens),
-      attrInt("gen_ai.usage.output_tokens", outputTokens)
+      attrString(MODEL_USAGE_ATTRIBUTES.responseModel, responseModelId),
+      ...buildModelUsageAttributes(usageMetrics)
     ]
   });
 }
@@ -5115,15 +6194,14 @@ function startDoStreamSpan(operationId, options, modelInfo, parent, ctx) {
       attrString("operation.name", operationName),
       attrString("resource.name", resourceName),
       attrString("ai.telemetry.functionId", (_b = ctx.telemetry) == null ? void 0 : _b.functionId),
-      attrString("ai.model.provider", modelInfo.provider),
+      ...attrsFromModelProvider(modelInfo.provider),
       attrString("ai.model.id", modelInfo.modelId),
       ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [
         attrString("ai.prompt.messages", promptJson),
         attrStringArray("ai.prompt.tools", toolsJson),
         attrString("ai.prompt.toolChoice", toolChoiceJson)
       ],
-      attrString("gen_ai.system", modelInfo.provider),
-      attrString("gen_ai.request.model", modelInfo.modelId),
+      attrString(MODEL_USAGE_ATTRIBUTES.requestModel, modelInfo.modelId),
       ...attrsFromGenAiRequest(options),
       attrProviderOptions(options)
     ]
@@ -5188,18 +6266,11 @@ function mergeAttachments(...groups) {
   }
   return merged.length ? merged : void 0;
 }
-function extractNestedTokens(usage, key) {
-  if (!isRecord(usage)) return void 0;
-  const val = usage[key];
-  if (typeof val === "number") return val;
-  if (isRecord(val) && typeof val["total"] === "number") return val["total"];
-  return void 0;
-}
 
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.2.0"};
+  version: "0.3.0"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -5246,6 +6317,8 @@ function eventMetadata(options) {
   if (options.properties) result["raindrop.properties"] = JSON.stringify(options.properties);
   if (options.featureFlags)
     result["raindrop.featureFlags"] = JSON.stringify(normalizeFeatureFlags(options.featureFlags));
+  if (options.subagent) Object.assign(result, detachedChildMetadata(options.subagent));
+  if (options.toolEvents) result[TOOL_EVENTS_SUFFIX] = options.toolEvents;
   return result;
 }
 function deriveChatTurnMessageId(request) {
@@ -5328,12 +6401,22 @@ function createRaindropAISDK(opts) {
     transformSpan: (_j = opts.traces) == null ? void 0 : _j.transformSpan,
     disableDefaultRedaction: (_k = opts.traces) == null ? void 0 : _k.disableDefaultRedaction
   });
+  const settledEventIds = /* @__PURE__ */ new Set();
+  const subagentApi = new SubagentApi({
+    traceShipper,
+    eventShipper,
+    sendTraces: tracesEnabled,
+    sendEvents: eventsEnabled,
+    debug: envDebug,
+    settledEventIds
+  });
   return {
     wrap(aiSDK, options) {
       return wrapAISDK(aiSDK, {
         options: options != null ? options : {},
         eventShipper,
-        traceShipper
+        traceShipper,
+        settledEventIds
       });
     },
     createSelfDiagnosticsTool(options = {}) {
@@ -5370,9 +6453,14 @@ function createRaindropAISDK(opts) {
         sendEvents: eventsEnabled,
         subagentWrapping,
         debug: envDebug,
+        settledEventIds,
         context
       });
     },
+    subagents: subagentApi,
+    subagent(options = {}) {
+      return subagentApi.subagent(options);
+    },
     events: {
       async patch(eventId, patch) {
         await eventShipper.patch(eventId, patch);
@@ -5492,4 +6580,4 @@ function raindrop(options = {}) {
   return client.createTelemetryIntegration({ context, subagentWrapping });
 }
 
-export { DEFAULT_MAX_TEXT_FIELD_CHARS2 as DEFAULT_MAX_TEXT_FIELD_CHARS, DEFAULT_REDACT_ATTRIBUTE_KEYS, DEFAULT_SECRET_KEY_NAMES, REDACTED_PLACEHOLDER, RaindropTelemetryIntegration, TRUNCATION_MARKER2 as TRUNCATION_MARKER, _resetParentToolContextStorage, _resetRaindropCallMetadataStorage, _resetWarnedMissingUserId, boundedStringify, capText2 as capText, clearParentToolContext, createRaindropAISDK, currentSpan, defaultTransformSpan, enterParentToolContext, eventMetadata, eventMetadataFromChatRequest, getContextManager, getCurrentParentToolContext, getCurrentRaindropCallMetadata, normalizeFeatureFlags, raindrop, readRaindropCallMetadataFromArgs, redactJsonAttributeValue, redactSecretsInObject, runWithParentToolContext, runWithRaindropCallMetadata, withCurrent };
+export { DEFAULT_MAX_TEXT_FIELD_CHARS2 as DEFAULT_MAX_TEXT_FIELD_CHARS, DEFAULT_REDACT_ATTRIBUTE_KEYS, DEFAULT_SECRET_KEY_NAMES, DETACHED_MODE, HANDOFF_ATTRIBUTE_PREFIXES, HANDOFF_ATTRIBUTE_SUFFIXES, HANDOFF_TERMINAL_CANCELLED, HANDOFF_TERMINAL_PROPERTY_KEY, REDACTED_PLACEHOLDER, RaindropTelemetryIntegration, SUBAGENT_ABORTED_OUTPUT, SUBAGENT_AGENT_ROLE, SUBAGENT_CANCELLED_OUTPUT, TOOL_EVENTS_ALLOW, TRUNCATION_MARKER2 as TRUNCATION_MARKER, _resetParentToolContextStorage, _resetRaindropCallMetadataStorage, _resetWarnedMissingUserId, boundedStringify, capText2 as capText, clearParentToolContext, createRaindropAISDK, currentSpan, defaultTransformSpan, enterParentToolContext, eventMetadata, eventMetadataFromChatRequest, fromHeaders, getContextManager, getCurrentParentToolContext, getCurrentRaindropCallMetadata, normalizeFeatureFlags, raindrop, readRaindropCallMetadataFromArgs, redactJsonAttributeValue, redactSecretsInObject, resetUnresolvedCarrierWarning, runWithParentToolContext, runWithRaindropCallMetadata, toHeaders, toLangSmithHeaders, withCurrent };