@raindrop-ai/ai-sdk 0.3.0 → 0.3.2

package/dist/index.browser.js

@@ -1,6 +1,68 @@
 'use strict';
 
-// ../core/dist/chunk-YUIXRQWN.js
+// ../core/dist/chunk-BYBMRLZM.js
+var EVAL_CORRELATION_ID_ATTRIBUTE = "raindrop.eval_correlation_id";
+var PROBE_SCOPE = { correlationId: "" };
+var EvalScopeStorage = class {
+  constructor() {
+    this._als = null;
+    this._probed = false;
+  }
+  maybeAdoptAsyncLocalStorage() {
+    if (this._probed) return;
+    this._probed = true;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (!Ctor) return;
+      const als = new Ctor();
+      als.run(PROBE_SCOPE, () => {
+      });
+      this._als = als;
+    } catch (e) {
+      this._als = null;
+    }
+  }
+  run(scope, callback) {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return this._als.run(scope, callback);
+    const previous = this._syncScope;
+    this._syncScope = scope;
+    try {
+      return callback();
+    } finally {
+      this._syncScope = previous;
+    }
+  }
+  current() {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return this._als.getStore();
+    return this._syncScope;
+  }
+};
+var EVAL_SCOPE_STORAGE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.evalScopeStorage");
+function evalScopeStorage() {
+  const holder = globalThis;
+  let storage = holder[EVAL_SCOPE_STORAGE_KEY];
+  if (!storage) {
+    storage = new EvalScopeStorage();
+    holder[EVAL_SCOPE_STORAGE_KEY] = storage;
+  }
+  return storage;
+}
+function currentEvalScope() {
+  try {
+    return evalScopeStorage().current();
+  } catch (e) {
+    return void 0;
+  }
+}
+function evalScopeAttributes() {
+  const scope = currentEvalScope();
+  if (!scope) return {};
+  return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
+}
+
+// ../core/dist/chunk-T53LQAH7.js
 function normalizeFeatureFlags(input) {
   if (Array.isArray(input)) {
     return Object.fromEntries(input.map((name) => [name, "true"]));
@@ -495,6 +557,7 @@ async function postJson(url, body, headers, opts) {
       const resp = await runWithTracingSuppressed(
         () => fetch(url, {
           method: "POST",
+          redirect: headers["X-Raindrop-Replay-Id"] !== void 0 ? "error" : "follow",
           headers: {
             "Content-Type": "application/json",
             ...headers
@@ -618,6 +681,55 @@ function buildExportTraceServiceRequest(spans, serviceName = "raindrop.core", se
     ]
   };
 }
+var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
+function state() {
+  const holder = globalThis;
+  let current = holder[STATE_KEY];
+  if (!current) {
+    let storage = null;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (Ctor) storage = new Ctor();
+    } catch (e) {
+      storage = null;
+    }
+    current = {
+      storage,
+      syncDestination: void 0,
+      spanDestinations: /* @__PURE__ */ new WeakMap()
+    };
+    holder[STATE_KEY] = current;
+  }
+  return current;
+}
+function currentReplayTraceDestination() {
+  var _a, _b;
+  const routing = state();
+  return (_b = (_a = routing.storage) == null ? void 0 : _a.getStore()) != null ? _b : routing.syncDestination;
+}
+function rememberReplayTraceDestination(span) {
+  const destination = currentReplayTraceDestination();
+  if (destination) state().spanDestinations.set(span, destination);
+}
+function copyReplayTraceDestination(source, target) {
+  const destination = state().spanDestinations.get(source);
+  if (destination) state().spanDestinations.set(target, destination);
+}
+function replayTraceDestinationFor(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return void 0;
+  }
+  return state().spanDestinations.get(value);
+}
+function recordReplayExportedSpan(destination, spanId, traceId) {
+  var _a, _b;
+  if (!destination || !spanId || !traceId) return;
+  (_a = destination.exportedSpanIds) == null ? void 0 : _a.add(spanId);
+  (_b = destination.exportedTraceIds) == null ? void 0 : _b.add(traceId);
+}
+function replayTraceUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
+}
 var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
 var WORKSHOP_ENV_VAR = "RAINDROP_WORKSHOP";
 var DEFAULT_LOCAL_WORKSHOP_URL = "http://localhost:5899/v1/";
@@ -683,31 +795,36 @@ function resolveLocalDebuggerBaseUrl(baseUrl) {
 function localDebuggerEnabled(baseUrl) {
   return resolveLocalDebuggerBaseUrl(baseUrl) !== null;
 }
+var LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS = 2e3;
 function mirrorTraceExportToLocalDebugger(body, options = {}) {
   var _a;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
-  if (!baseUrl) return;
-  void postJson(`${baseUrl}traces`, body, {}, {
+  if (!baseUrl) return Promise.resolve();
+  return postJson(`${baseUrl}traces`, body, {}, {
     maxAttempts: 1,
     debug: (_a = options.debug) != null ? _a : false,
-    sdkName: options.sdkName
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
   }).catch(() => {
   });
 }
 function mirrorPartialEventToLocalDebugger(event, options = {}) {
   var _a;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
-  if (!baseUrl) return;
+  if (!baseUrl) return Promise.resolve();
   const headers = options.writeKey ? { Authorization: `Bearer ${options.writeKey}` } : {};
-  void postJson(`${baseUrl}events/track_partial`, event, headers, {
+  return postJson(`${baseUrl}events/track_partial`, event, headers, {
     maxAttempts: 1,
     debug: (_a = options.debug) != null ? _a : false,
-    sdkName: options.sdkName
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
   }).catch(() => {
   });
 }
 function sendLocalDebuggerLiveEvent(event, options = {}) {
   var _a, _b;
+  const destination = currentReplayTraceDestination();
+  if (destination && destination.kind !== "workshop") return;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
   if (!baseUrl) return;
   void postJson(
@@ -879,6 +996,15 @@ var EventShipper = class {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     if (!this.enabled) return;
     if (!eventId || !eventId.trim()) return;
+    const capturedSticky = this.sticky.get(eventId);
+    const eventAlreadyKnown = capturedSticky !== void 0 || this.buffers.has(eventId);
+    const destination = currentReplayTraceDestination();
+    const cloudReplay = destination !== void 0 && destination.kind !== "workshop";
+    if ((capturedSticky == null ? void 0 : capturedSticky.replayOnly) === true || !eventAlreadyKnown && cloudReplay) {
+      if (patch.isPending === false) this.sticky.delete(eventId);
+      else this.sticky.set(eventId, { ...capturedSticky, replayOnly: true });
+      return;
+    }
     const maxChars = resolveMaxTextFieldChars(this.maxTextFieldCharsOpt);
     if (typeof patch.input === "string" && patch.input.length > maxChars) {
       patch = { ...patch, input: capText(patch.input, maxChars) };
@@ -937,6 +1063,9 @@ var EventShipper = class {
     try {
       for (const t of this.timers.values()) clearTimeout(t);
       this.timers.clear();
+      for (const [eventId, sticky] of this.sticky) {
+        if (sticky.replayOnly) this.sticky.delete(eventId);
+      }
       const settled = await raceWithTimeout(this.flush(), SHUTDOWN_DEADLINE_MS);
       if (!settled) this.warnShutdownDrop("in-flight request(s) at shutdown");
     } finally {
@@ -946,6 +1075,8 @@ var EventShipper = class {
   async trackSignal(signal) {
     var _a, _b;
     if (!this.enabled) return;
+    const destination = currentReplayTraceDestination();
+    if (destination && destination.kind !== "workshop") return;
     const body = [
       {
         event_id: signal.eventId,
@@ -980,6 +1111,8 @@ var EventShipper = class {
   }
   async identify(users) {
     if (!this.enabled) return;
+    const destination = currentReplayTraceDestination();
+    if (destination && destination.kind !== "workshop") return;
     const list = Array.isArray(users) ? users : [users];
     const body = list.filter((user) => {
       if (!(user == null ? void 0 : user.userId) || !user.userId.trim()) {
@@ -1032,8 +1165,9 @@ var EventShipper = class {
     this.buffers.delete(eventId);
     if (!accumulated) return;
     const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
-    const eventName = (_c = (_b = accumulated.eventName) != null ? _b : sticky.eventName) != null ? _c : this.defaultEventName;
-    const userId = (_d = accumulated.userId) != null ? _d : sticky.userId;
+    const isPending = (_c = (_b = accumulated.isPending) != null ? _b : sticky.isPending) != null ? _c : true;
+    const eventName = (_e = (_d = accumulated.eventName) != null ? _d : sticky.eventName) != null ? _e : this.defaultEventName;
+    const userId = (_f = accumulated.userId) != null ? _f : sticky.userId;
     if (!userId) {
       if (this.debug) {
         console.warn(`${this.prefix} skipping track_partial for ${eventId}: missing userId`);
@@ -1041,14 +1175,13 @@ var EventShipper = class {
       this.sticky.delete(eventId);
       return;
     }
-    const { wizardSession, ...restProperties } = (_e = accumulated.properties) != null ? _e : {};
+    const { wizardSession, ...restProperties } = (_g = accumulated.properties) != null ? _g : {};
     let telemetryProperties = {};
     try {
       telemetryProperties = eventTelemetryProperties(accumulated);
     } catch (e) {
     }
-    const convoId = (_f = accumulated.convoId) != null ? _f : sticky.convoId;
-    const isPending = (_h = (_g = accumulated.isPending) != null ? _g : sticky.isPending) != null ? _h : true;
+    const convoId = (_h = accumulated.convoId) != null ? _h : sticky.convoId;
     const payload = {
       event_id: eventId,
       user_id: userId,
@@ -1090,29 +1223,30 @@ var EventShipper = class {
         endpoint: url
       });
     }
-    if (this.localDebuggerUrl) {
-      mirrorPartialEventToLocalDebugger(payload, {
-        baseUrl: this.localDebuggerUrl,
-        writeKey: this.writeKey,
-        debug: this.debug,
-        sdkName: this.sdkName
-      });
-    }
+    const mirror = this.localDebuggerUrl ? mirrorPartialEventToLocalDebugger(payload, {
+      baseUrl: this.localDebuggerUrl,
+      writeKey: this.writeKey,
+      debug: this.debug,
+      sdkName: this.sdkName
+    }) : void 0;
     if (!this.writeKey) {
       if (!isPending) this.sticky.delete(eventId);
+      if (mirror) await mirror;
       return;
     }
     const opts = this.requestOpts();
     if (!opts) {
       this.warnShutdownDrop(`track_partial ${eventId}`);
       if (!isPending) this.sticky.delete(eventId);
+      if (mirror) await mirror;
       return;
     }
     const p = postJson(url, payload, this.requestHeaders(), opts);
-    this.inFlight.add(p);
+    const combined = mirror ? Promise.all([mirror, p]).then(() => void 0) : p;
+    this.inFlight.add(combined);
     try {
       try {
-        await p;
+        await combined;
         if (this.debug) {
           console.log(`${this.prefix} sent track_partial ${eventId} (${eventName})`);
         }
@@ -1124,7 +1258,7 @@ var EventShipper = class {
         );
       }
     } finally {
-      this.inFlight.delete(p);
+      this.inFlight.delete(combined);
     }
     if (!isPending) {
       this.sticky.delete(eventId);
@@ -1132,6 +1266,7 @@ var EventShipper = class {
   }
 };
 var MODEL_USAGE_ATTRIBUTES = {
+  usageSource: "raindrop.usage.source",
   providerName: "gen_ai.provider.name",
   requestModel: "gen_ai.request.model",
   responseModel: "gen_ai.response.model",
@@ -1140,20 +1275,22 @@ var MODEL_USAGE_ATTRIBUTES = {
   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"
-};
+  providerReportedCost: "gen_ai.usage.provider_reported_cost"};
 var MODEL_PROVIDER_NAMES = [
+  ["google.vertex.anthropic", "google-vertex"],
+  ["google.vertex_ai", "google-vertex"],
   ["google.vertex", "google-vertex"],
+  ["gcp.vertex_ai", "google-vertex"],
+  ["gcp.gemini", "google"],
+  ["google_vertexai", "google-vertex"],
   ["vertex.anthropic", "google-vertex"],
   ["amazon-bedrock", "amazon-bedrock"],
+  ["aws.bedrock", "amazon-bedrock"],
   ["bedrock", "amazon-bedrock"],
   ["anthropic", "anthropic"],
   ["openai", "openai"],
   ["google", "google"],
+  ["az.ai.openai", "azure"],
   ["azure", "azure"],
   ["openrouter", "openrouter"]
 ];
@@ -1164,60 +1301,20 @@ function canonicalModelProvider(provider) {
   const match = MODEL_PROVIDER_NAMES.find(
     ([family]) => normalizedProvider === family || normalizedProvider.startsWith(`${family}.`)
   );
-  return (_a = match == null ? void 0 : match[1]) != null ? _a : provider;
+  return (_a = match == null ? void 0 : match[1]) != null ? _a : normalizedProvider;
 }
 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)
-  ] : [];
+function buildRawModelUsageAttributes(usage) {
+  const providerReportedCost = typeof usage.providerReportedCost === "number" && Number.isFinite(usage.providerReportedCost) && usage.providerReportedCost >= 0 ? usage.providerReportedCost : void 0;
   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
+    attrInt(MODEL_USAGE_ATTRIBUTES.inputTokens, tokenCount(usage.inputTokens)),
+    attrInt(MODEL_USAGE_ATTRIBUTES.outputTokens, tokenCount(usage.outputTokens)),
+    attrInt(MODEL_USAGE_ATTRIBUTES.reasoningTokens, tokenCount(usage.reasoningTokens)),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheReadInputTokens, tokenCount(usage.cacheReadInputTokens)),
+    attrInt(MODEL_USAGE_ATTRIBUTES.cacheWriteInputTokens, tokenCount(usage.cacheWriteInputTokens)),
+    attrDouble(MODEL_USAGE_ATTRIBUTES.providerReportedCost, providerReportedCost)
   ].filter((attribute) => attribute !== void 0);
 }
 var STRING_ALIASES = {
@@ -1509,7 +1606,10 @@ var TraceShipper = class {
       try {
         const result = this.transformSpanHook(current);
         if (result === null) return null;
-        if (result !== void 0) current = result;
+        if (result !== void 0) {
+          copyReplayTraceDestination(current, result);
+          current = result;
+        }
       } catch (err) {
         if (this.debug) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -1519,13 +1619,19 @@ var TraceShipper = class {
       }
     }
     try {
-      current = normalizeModelUsageSpan(current);
+      const normalized = normalizeModelUsageSpan(current);
+      copyReplayTraceDestination(current, normalized);
+      current = normalized;
     } catch (e) {
     }
     if (!this.disableDefaultRedaction) {
-      current = defaultTransformSpan(current);
+      const redacted = defaultTransformSpan(current);
+      copyReplayTraceDestination(current, redacted);
+      current = redacted;
     }
-    return this.capSpanAttributes(current);
+    const capped = this.capSpanAttributes(current);
+    copyReplayTraceDestination(current, capped);
+    return capped;
   }
   isDebugEnabled() {
     return this.debug;
@@ -1543,33 +1649,54 @@ var TraceShipper = class {
     const attrs = [
       attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
       ...identityAttrs(args),
-      attrString("ai.operationId", args.operationId)
+      attrString("ai.operationId", args.operationId),
+      ...Object.entries(evalScopeAttributes()).map(([key, value]) => attrString(key, value))
     ];
     if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
-    const span = { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
-    this.mirrorToLocalDebugger(
-      buildOtlpSpan({
-        ids: span.ids,
-        name: span.name,
-        startTimeUnixNano: span.startTimeUnixNano,
-        endTimeUnixNano: span.startTimeUnixNano,
-        // placeholder — will be updated on endSpan
-        attributes: span.attributes,
-        status: { code: SpanStatusCode.UNSET }
-      })
-    );
+    const span = {
+      ids,
+      name: args.name,
+      startTimeUnixNano: started,
+      attributes: attrs
+    };
+    rememberReplayTraceDestination(span);
+    const openSpan = buildOtlpSpan({
+      ids: span.ids,
+      name: span.name,
+      startTimeUnixNano: span.startTimeUnixNano,
+      endTimeUnixNano: span.startTimeUnixNano,
+      // placeholder — will be updated on endSpan
+      attributes: span.attributes,
+      status: { code: SpanStatusCode.UNSET }
+    });
+    copyReplayTraceDestination(span, openSpan);
+    this.mirrorToLocalDebugger(openSpan);
     return span;
   }
-  mirrorToLocalDebugger(span) {
-    if (!this.localDebuggerUrl) return;
+  mirrorToLocalDebugger(span, completed = false) {
+    const destination = replayTraceDestinationFor(span);
+    if (destination && destination.kind !== "workshop") return;
+    const localDebuggerUrl = (destination == null ? void 0 : destination.kind) === "workshop" ? destination.url : this.localDebuggerUrl;
+    if (!localDebuggerUrl) return;
     const redacted = this.redactSpan(span);
     if (redacted === null) return;
+    if (completed && (destination == null ? void 0 : destination.kind) === "workshop") {
+      recordReplayExportedSpan(
+        destination,
+        base64ToHex(redacted.spanId),
+        base64ToHex(redacted.traceId)
+      );
+    }
     const body = buildExportTraceServiceRequest([redacted], this.serviceName, this.serviceVersion);
-    mirrorTraceExportToLocalDebugger(body, {
-      baseUrl: this.localDebuggerUrl,
+    const p = mirrorTraceExportToLocalDebugger(body, {
+      baseUrl: localDebuggerUrl,
       debug: false,
       sdkName: this.sdkName
     });
+    this.inFlight.add(p);
+    void p.finally(() => {
+      this.inFlight.delete(p);
+    });
   }
   endSpan(span, extra) {
     var _a, _b;
@@ -1591,15 +1718,17 @@ var TraceShipper = class {
       attributes: span.attributes,
       status
     });
+    copyReplayTraceDestination(span, otlp);
     this.enqueue(otlp);
-    this.mirrorToLocalDebugger(otlp);
+    this.mirrorToLocalDebugger(otlp, true);
   }
   createSpan(args) {
     var _a;
     const ids = createSpanIds(args.parent);
     const attrs = [
       attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
-      ...identityAttrs(args)
+      ...identityAttrs(args),
+      ...Object.entries(evalScopeAttributes()).map(([key, value]) => attrString(key, value))
     ];
     if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
     const otlp = buildOtlpSpan({
@@ -1610,8 +1739,9 @@ var TraceShipper = class {
       attributes: attrs,
       status: args.status
     });
+    rememberReplayTraceDestination(otlp);
     this.enqueue(otlp);
-    this.mirrorToLocalDebugger(otlp);
+    this.mirrorToLocalDebugger(otlp, true);
   }
   enqueue(span) {
     if (!this.enabled) return;
@@ -1625,6 +1755,13 @@ var TraceShipper = class {
     }
     const redacted = this.redactSpan(span);
     if (redacted === null) return;
+    const destination = replayTraceDestinationFor(redacted);
+    recordReplayExportedSpan(
+      destination,
+      base64ToHex(redacted.spanId),
+      base64ToHex(redacted.traceId)
+    );
+    if ((destination == null ? void 0 : destination.kind) === "workshop") return;
     if (this.queue.length >= this.maxQueueSize) {
       this.queue.shift();
     }
@@ -1643,47 +1780,67 @@ var TraceShipper = class {
     }
   }
   async flush() {
-    if (!this.enabled) return;
+    var _a;
+    if (!this.enabled) {
+      await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+      })));
+      return;
+    }
     if (this.timer) {
       clearTimeout(this.timer);
       this.timer = void 0;
     }
     while (this.queue.length > 0) {
       const batch = this.queue.splice(0, this.maxBatchSize);
-      if (!this.writeKey) continue;
-      const opts = this.requestOpts();
-      if (!opts) {
-        rateLimitedLog(
-          `${this.prefix}.shutdown_deadline`,
-          () => console.warn(
-            `${this.prefix} shutdown flush deadline exceeded; dropping ${batch.length} spans`
-          )
-        );
-        continue;
-      }
-      const body = buildExportTraceServiceRequest(batch, this.serviceName, this.serviceVersion);
-      const url = `${this.baseUrl}traces`;
-      if (this.debug) {
-        console.log(`${this.prefix} sending traces batch`, {
-          spans: batch.length,
-          endpoint: url
-        });
+      const groups = /* @__PURE__ */ new Map();
+      for (const span of batch) {
+        const destination = replayTraceDestinationFor(span);
+        const spans = groups.get(destination);
+        if (spans) spans.push(span);
+        else groups.set(destination, [span]);
       }
-      const p = postJson(url, body, this.requestHeaders(), opts);
-      this.inFlight.add(p);
-      try {
-        try {
-          await p;
-          if (this.debug) console.log(`${this.prefix} sent ${batch.length} spans`);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
+      for (const [destination, spans] of groups) {
+        if (!destination && !this.writeKey) continue;
+        if ((destination == null ? void 0 : destination.kind) === "workshop") continue;
+        const opts = this.requestOpts();
+        if (!opts) {
           rateLimitedLog(
-            `${this.prefix}.send_spans_failed`,
-            () => console.warn(`${this.prefix} failed to send ${batch.length} spans: ${msg}`)
+            `${this.prefix}.shutdown_deadline`,
+            () => console.warn(
+              `${this.prefix} shutdown flush deadline exceeded; dropping ${spans.length} spans`
+            )
           );
+          continue;
+        }
+        const body = buildExportTraceServiceRequest(spans, this.serviceName, this.serviceVersion);
+        const url = destination ? replayTraceUrl(destination.url) : `${this.baseUrl}traces`;
+        const headers = destination ? {
+          Authorization: `Bearer ${destination.apiKey}`,
+          "X-Raindrop-Replay-Id": destination.replayId,
+          "X-Raindrop-Project-Id": (_a = destination.projectId) != null ? _a : "default"
+        } : this.requestHeaders();
+        if (this.debug) {
+          console.log(`${this.prefix} sending traces batch`, {
+            spans: spans.length,
+            endpoint: url
+          });
+        }
+        const p = postJson(url, body, headers, opts);
+        this.inFlight.add(p);
+        try {
+          try {
+            await p;
+            if (this.debug) console.log(`${this.prefix} sent ${spans.length} spans`);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            rateLimitedLog(
+              `${this.prefix}.send_spans_failed`,
+              () => console.warn(`${this.prefix} failed to send ${spans.length} spans: ${msg}`)
+            );
+          }
+        } finally {
+          this.inFlight.delete(p);
         }
-      } finally {
-        this.inFlight.delete(p);
       }
     }
   }
@@ -1726,7 +1883,9 @@ var TraceShipper = class {
       if (!settled) {
         rateLimitedLog(
           `${this.prefix}.shutdown_deadline`,
-          () => console.warn(`${this.prefix} shutdown flush deadline exceeded; abandoning in-flight spans`)
+          () => console.warn(
+            `${this.prefix} shutdown flush deadline exceeded; abandoning in-flight spans`
+          )
         );
       }
     } finally {
@@ -1821,7 +1980,8 @@ function withCurrent(span, callback) {
   return getContextManager().runInContext(span, callback);
 }
 async function getCurrentParentSpanContext() {
-  return getContextManager().getParentSpanIds();
+  var _a, _b;
+  return (_b = getContextManager().getParentSpanIds()) != null ? _b : (_a = currentReplayTraceDestination()) == null ? void 0 : _a.parentSpanContext;
 }
 async function runWithParentSpanContext(ctx, fn) {
   const cm = getContextManager();
@@ -1855,7 +2015,7 @@ async function* asyncGeneratorWithCurrent(span, gen) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.3.0"};
+  version: "0.3.2"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -3099,29 +3259,6 @@ function firstTokenCount(...values) {
   }
   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"],
@@ -3138,7 +3275,7 @@ function cacheWriteTokensFromProviderMetadata(providerMetadata) {
     })
   );
 }
-function extractUsageMetricsFromUsage(usage, provider, providerMetadata) {
+function extractUsageMetricsFromUsage(usage, _provider, providerMetadata) {
   if (!isRecord(usage)) return {};
   const inputTokenValue = usage["inputTokens"];
   const outputTokenValue = usage["outputTokens"];
@@ -3206,7 +3343,7 @@ function extractUsageMetricsFromUsage(usage, provider, providerMetadata) {
     cacheReadInputTokens,
     cachedInputTokens: cacheReadInputTokens,
     cacheWriteInputTokens,
-    ...hasStructuredUsage ? {} : flatUsageSemantics(provider)
+    ...hasStructuredUsage ? { usageSource: "ai-sdk-structured" } : {}
   };
 }
 
@@ -3404,13 +3541,13 @@ var RaindropTelemetryIntegration = class {
     };
     // ── onStepStart ─────────────────────────────────────────────────────────
     this.onStepStart = (event) => {
-      const state = this.getState(event.callId);
-      if (!(state == null ? void 0 : state.rootSpan) || !state.rootParent) return;
-      const isStream = state.operationId === "ai.streamText" || state.operationId === "ai.streamObject";
-      const stepOperationId = isStream ? `${state.operationId}.doStream` : `${state.operationId}.doGenerate`;
-      const { operationName, resourceName } = opName(stepOperationId, state.functionId);
+      const state2 = this.getState(event.callId);
+      if (!(state2 == null ? void 0 : state2.rootSpan) || !state2.rootParent) return;
+      const isStream = state2.operationId === "ai.streamText" || state2.operationId === "ai.streamObject";
+      const stepOperationId = isStream ? `${state2.operationId}.doStream` : `${state2.operationId}.doGenerate`;
+      const { operationName, resourceName } = opName(stepOperationId, state2.functionId);
       const inputAttrs = [];
-      if (state.recordInputs) {
+      if (state2.recordInputs) {
         if (event.promptMessages) {
           inputAttrs.push(attrString("ai.prompt.messages", safeJsonWithUint8(event.promptMessages)));
         }
@@ -3433,25 +3570,25 @@ var RaindropTelemetryIntegration = class {
       }
       const stepSpan = this.traceShipper.startSpan({
         name: stepOperationId,
-        parent: state.rootParent,
-        eventId: state.eventId,
-        ...state.identity,
+        parent: state2.rootParent,
+        eventId: state2.eventId,
+        ...state2.identity,
         operationId: stepOperationId,
         attributes: [
           attrString("operation.name", operationName),
           attrString("resource.name", resourceName),
-          attrString("ai.telemetry.functionId", state.functionId),
+          attrString("ai.telemetry.functionId", state2.functionId),
           ...attrsFromModelProvider(event.provider),
           attrString("ai.model.id", event.modelId),
           attrString(MODEL_USAGE_ATTRIBUTES.requestModel, event.modelId),
           ...inputAttrs,
-          ...handoffSpanAttrs(state.handoff)
+          ...handoffSpanAttrs(state2.handoff)
         ]
       });
-      state.stepSpan = stepSpan;
-      state.stepParent = this.spanParentRef(stepSpan);
-      state.stepProvider = event.provider;
-      state.stepModelId = event.modelId;
+      state2.stepSpan = stepSpan;
+      state2.stepParent = this.spanParentRef(stepSpan);
+      state2.stepProvider = event.provider;
+      state2.stepModelId = event.modelId;
     };
     this.onToolExecutionStart = (event) => this.toolExecutionStart(event);
     this.onToolExecutionEnd = (event) => this.toolExecutionEnd(event);
@@ -3478,33 +3615,33 @@ var RaindropTelemetryIntegration = class {
       var _a, _b, _c, _d, _e;
       const callId = (_b = event.callId) != null ? _b : (_a = event.chunk) == null ? void 0 : _a.callId;
       if (!callId) return;
-      const state = this.getState(callId);
-      if (!state) return;
+      const state2 = this.getState(callId);
+      if (!state2) return;
       const chunk = event.chunk;
       if (!chunk || typeof chunk !== "object") return;
       if (chunk.type === "text-delta") {
         const delta = (_c = chunk.textDelta) != null ? _c : chunk.delta;
         if (typeof delta === "string") {
-          if (state.accumulatedText.length <= effectiveMaxTextFieldChars()) {
-            state.accumulatedText += delta;
+          if (state2.accumulatedText.length <= effectiveMaxTextFieldChars()) {
+            state2.accumulatedText += delta;
           }
-          this.emitLive(state, "text_delta", delta);
+          this.emitLive(state2, "text_delta", delta);
         }
       } else if (chunk.type === "reasoning" || chunk.type === "reasoning-delta") {
         const text = (_e = (_d = chunk.textDelta) != null ? _d : chunk.text) != null ? _e : chunk.delta;
         if (typeof text === "string") {
-          this.emitLive(state, "reasoning_delta", text);
+          this.emitLive(state2, "reasoning_delta", text);
         }
       }
     };
     // ── onStepFinish ────────────────────────────────────────────────────────
     this.onStepFinish = (event) => {
       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 state2 = this.getState(event.callId);
+      if (!(state2 == null ? void 0 : state2.stepSpan)) return;
+      const responseModelId = (_b = (_a = event.response) == null ? void 0 : _a.modelId) != null ? _b : state2.stepModelId;
       const outputAttrs = [];
-      if (state.recordOutputs) {
+      if (state2.recordOutputs) {
         outputAttrs.push(
           attrString("ai.response.finishReason", event.finishReason),
           attrString("ai.response.text", capText2((_c = event.text) != null ? _c : void 0)),
@@ -3549,7 +3686,7 @@ var RaindropTelemetryIntegration = class {
       if (usage) {
         const usageMetrics = extractUsageMetricsFromUsage(
           usage,
-          state.stepProvider,
+          state2.stepProvider,
           event.providerMetadata
         );
         outputAttrs.push(
@@ -3558,54 +3695,55 @@ var RaindropTelemetryIntegration = class {
           attrInt("ai.usage.totalTokens", usageMetrics.totalTokens),
           attrInt("ai.usage.reasoningTokens", usageMetrics.reasoningTokens),
           attrInt("ai.usage.cachedInputTokens", usageMetrics.cachedInputTokens),
-          ...buildModelUsageAttributes(usageMetrics)
+          attrString(MODEL_USAGE_ATTRIBUTES.usageSource, usageMetrics.usageSource),
+          ...buildRawModelUsageAttributes(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;
+      this.emitProviderExecutedToolSpans(event, state2);
+      this.traceShipper.endSpan(state2.stepSpan, { attributes: outputAttrs });
+      state2.stepSpan = void 0;
+      state2.stepParent = void 0;
+      state2.stepProvider = void 0;
+      state2.stepModelId = void 0;
     };
     // ── onEmbedStart ────────────────────────────────────────────────────────
     this.onEmbedStart = (event) => {
-      const state = this.getState(event.callId);
-      if (!(state == null ? void 0 : state.rootSpan) || !state.rootParent) return;
-      const { operationName, resourceName } = opName(event.operationId, state.functionId);
-      const inputAttrs = state.recordInputs ? [attrString("ai.values", safeJsonWithUint8(event.values))] : [];
+      const state2 = this.getState(event.callId);
+      if (!(state2 == null ? void 0 : state2.rootSpan) || !state2.rootParent) return;
+      const { operationName, resourceName } = opName(event.operationId, state2.functionId);
+      const inputAttrs = state2.recordInputs ? [attrString("ai.values", safeJsonWithUint8(event.values))] : [];
       const embedSpan = this.traceShipper.startSpan({
         name: event.operationId,
-        parent: state.rootParent,
-        eventId: state.eventId,
-        ...state.identity,
+        parent: state2.rootParent,
+        eventId: state2.eventId,
+        ...state2.identity,
         operationId: event.operationId,
         attributes: [
           attrString("operation.name", operationName),
           attrString("resource.name", resourceName),
-          attrString("ai.telemetry.functionId", state.functionId),
+          attrString("ai.telemetry.functionId", state2.functionId),
           ...inputAttrs,
-          ...handoffSpanAttrs(state.handoff)
+          ...handoffSpanAttrs(state2.handoff)
         ]
       });
-      state.embedSpans.set(event.embedCallId, embedSpan);
+      state2.embedSpans.set(event.embedCallId, embedSpan);
     };
     // ── onEmbedFinish ───────────────────────────────────────────────────────
     this.onEmbedFinish = (event) => {
       var _a;
-      const state = this.getState(event.callId);
-      if (!state) return;
-      const embedSpan = state.embedSpans.get(event.embedCallId);
+      const state2 = this.getState(event.callId);
+      if (!state2) return;
+      const embedSpan = state2.embedSpans.get(event.embedCallId);
       if (!embedSpan) return;
       const outputAttrs = [];
-      if (state.recordOutputs) {
+      if (state2.recordOutputs) {
         outputAttrs.push(attrString("ai.embeddings", safeJsonWithUint8(event.embeddings)));
       }
       if (((_a = event.usage) == null ? void 0 : _a.tokens) != null) {
         outputAttrs.push(attrInt("ai.usage.tokens", event.usage.tokens));
       }
       this.traceShipper.endSpan(embedSpan, { attributes: outputAttrs });
-      state.embedSpans.delete(event.embedCallId);
+      state2.embedSpans.delete(event.embedCallId);
     };
     // v7 canary.159 renamed `onEmbedFinish` -> `onEmbedEnd`. Both names forward
     // to the same implementation; the installed SDK only wires up whichever it
@@ -3613,16 +3751,16 @@ var RaindropTelemetryIntegration = class {
     this.onEmbedEnd = (event) => this.onEmbedFinish(event);
     // ── onFinish ────────────────────────────────────────────────────────────
     this.onFinish = (event) => {
-      const state = this.getState(event.callId);
-      if (!state) return;
-      const isEmbed = state.operationId === "ai.embed" || state.operationId === "ai.embedMany";
+      const state2 = this.getState(event.callId);
+      if (!state2) return;
+      const isEmbed = state2.operationId === "ai.embed" || state2.operationId === "ai.embedMany";
       if (isEmbed) {
-        this.finishEmbed(event, state);
+        this.finishEmbed(event, state2);
       } else {
-        this.finishGenerate(event, state);
+        this.finishGenerate(event, state2);
       }
-      if (state.subagentToolCallSpan) {
-        this.traceShipper.endSpan(state.subagentToolCallSpan);
+      if (state2.subagentToolCallSpan) {
+        this.traceShipper.endSpan(state2.subagentToolCallSpan);
       }
       this.cleanup(event.callId);
     };
@@ -3637,42 +3775,42 @@ var RaindropTelemetryIntegration = class {
       var _a;
       const event = error;
       if (!(event == null ? void 0 : event.callId)) return;
-      const state = this.getState(event.callId);
-      if (!state) return;
+      const state2 = this.getState(event.callId);
+      if (!state2) return;
       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;
+      if (state2.stepSpan) {
+        this.traceShipper.endSpan(state2.stepSpan, { error: actualError });
+        state2.stepProvider = void 0;
+        state2.stepModelId = void 0;
       }
-      for (const embedSpan of state.embedSpans.values()) {
+      for (const embedSpan of state2.embedSpans.values()) {
         this.traceShipper.endSpan(embedSpan, { error: actualError });
       }
-      state.embedSpans.clear();
-      for (const toolCallId of state.parentContextToolCallIds) {
+      state2.embedSpans.clear();
+      for (const toolCallId of state2.parentContextToolCallIds) {
         this.priorParentContexts.delete(toolCallId);
       }
-      state.parentContextToolCallIds.clear();
-      for (const toolSpan of state.toolSpans.values()) {
+      state2.parentContextToolCallIds.clear();
+      for (const toolSpan of state2.toolSpans.values()) {
         this.traceShipper.endSpan(toolSpan, { error: actualError });
       }
-      state.toolSpans.clear();
+      state2.toolSpans.clear();
       const abortReason = describeAbortReason(actualError);
-      if (state.rootSpan) {
-        this.traceShipper.endSpan(state.rootSpan, {
+      if (state2.rootSpan) {
+        this.traceShipper.endSpan(state2.rootSpan, {
           error: actualError,
-          attributes: this.abortOutcomeAttrs(state, abortReason, "error")
+          attributes: this.abortOutcomeAttrs(state2, abortReason, "error")
         });
       }
-      if (state.subagentToolCallSpan) {
-        this.traceShipper.endSpan(state.subagentToolCallSpan, { error: actualError });
+      if (state2.subagentToolCallSpan) {
+        this.traceShipper.endSpan(state2.subagentToolCallSpan, { error: actualError });
       }
-      const isEmbed = state.operationId === "ai.embed" || state.operationId === "ai.embedMany";
+      const isEmbed = state2.operationId === "ai.embed" || state2.operationId === "ai.embedMany";
       if (!isEmbed) {
-        const errorIsTheRunsOutcome = state.handoff !== void 0 && !state.nestedInEvent;
+        const errorIsTheRunsOutcome = state2.handoff !== void 0 && !state2.nestedInEvent;
         this.finalizeGenerateEvent(
-          state,
-          state.accumulatedText || void 0,
+          state2,
+          state2.accumulatedText || void 0,
           void 0,
           false,
           errorIsTheRunsOutcome ? { fallbackOutput: abortReason } : void 0
@@ -3691,51 +3829,51 @@ var RaindropTelemetryIntegration = class {
     this.onAbort = (event) => {
       const callId = event == null ? void 0 : event.callId;
       if (!callId) return;
-      const state = this.getState(callId);
-      if (!state) return;
+      const state2 = this.getState(callId);
+      if (!state2) return;
       const abortedAttr = attrString("ai.response.aborted", "true");
-      if (state.stepSpan) {
-        this.traceShipper.endSpan(state.stepSpan, { attributes: [abortedAttr] });
-        state.stepSpan = void 0;
-        state.stepParent = void 0;
-        state.stepProvider = void 0;
-        state.stepModelId = void 0;
+      if (state2.stepSpan) {
+        this.traceShipper.endSpan(state2.stepSpan, { attributes: [abortedAttr] });
+        state2.stepSpan = void 0;
+        state2.stepParent = void 0;
+        state2.stepProvider = void 0;
+        state2.stepModelId = void 0;
       }
-      for (const embedSpan of state.embedSpans.values()) {
+      for (const embedSpan of state2.embedSpans.values()) {
         this.traceShipper.endSpan(embedSpan, { attributes: [abortedAttr] });
       }
-      state.embedSpans.clear();
-      for (const toolCallId of state.parentContextToolCallIds) {
+      state2.embedSpans.clear();
+      for (const toolCallId of state2.parentContextToolCallIds) {
         this.priorParentContexts.delete(toolCallId);
       }
-      state.parentContextToolCallIds.clear();
-      for (const toolSpan of state.toolSpans.values()) {
+      state2.parentContextToolCallIds.clear();
+      for (const toolSpan of state2.toolSpans.values()) {
         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, {
+      state2.toolSpans.clear();
+      const abortIsTheRunsOutcome = state2.handoff !== void 0 && !state2.nestedInEvent;
+      if (state2.rootSpan) {
+        this.traceShipper.endSpan(state2.rootSpan, {
           attributes: [
             abortedAttr,
-            attrInt("ai.toolCall.count", state.toolCallCount),
+            attrInt("ai.toolCall.count", state2.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") : []
+            ...abortIsTheRunsOutcome ? this.abortOutcomeAttrs(state2, SUBAGENT_CANCELLED_OUTPUT, "stop") : []
           ]
         });
       }
-      if (state.subagentToolCallSpan) {
-        this.traceShipper.endSpan(state.subagentToolCallSpan, {
+      if (state2.subagentToolCallSpan) {
+        this.traceShipper.endSpan(state2.subagentToolCallSpan, {
           attributes: [abortedAttr]
         });
       }
       this.finalizeGenerateEvent(
-        state,
-        state.accumulatedText || void 0,
+        state2,
+        state2.accumulatedText || void 0,
         void 0,
         false,
         abortIsTheRunsOutcome ? {
@@ -3743,7 +3881,7 @@ var RaindropTelemetryIntegration = class {
           properties: { [HANDOFF_TERMINAL_PROPERTY_KEY]: HANDOFF_TERMINAL_CANCELLED }
         } : void 0
       );
-      if (abortIsTheRunsOutcome) this.subagents.noteSettled(state.eventId);
+      if (abortIsTheRunsOutcome) this.subagents.noteSettled(state2.eventId);
       this.cleanup(callId);
     };
     // ── executeTool ─────────────────────────────────────────────────────────
@@ -3752,14 +3890,14 @@ var RaindropTelemetryIntegration = class {
       toolCallId,
       execute
     }) => {
-      const state = this.getState(callId);
-      const toolSpan = state == null ? void 0 : state.toolSpans.get(toolCallId);
+      const state2 = this.getState(callId);
+      const toolSpan = state2 == null ? void 0 : state2.toolSpans.get(toolCallId);
       if (!toolSpan) return execute();
       return runWithParentSpanContext(
         {
           traceIdB64: toolSpan.ids.traceIdB64,
           spanIdB64: toolSpan.ids.spanIdB64,
-          eventId: state.eventId
+          eventId: state2.eventId
         },
         () => execute()
       );
@@ -3808,35 +3946,35 @@ var RaindropTelemetryIntegration = class {
   activeDispatch() {
     var _a;
     const parentTool = getCurrentParentToolContext();
-    let state = parentTool ? this.getState(parentTool.parentCallId) : void 0;
+    let state2 = parentTool ? this.getState(parentTool.parentCallId) : void 0;
     const inheritedEventId = (_a = getContextManager().getParentSpanIds()) == null ? void 0 : _a.eventId;
-    if (!state && inheritedEventId) {
+    if (!state2 && inheritedEventId) {
       for (const candidate of this.callStates.values()) {
         if (candidate.eventId === inheritedEventId) {
-          state = candidate;
+          state2 = candidate;
           break;
         }
       }
     }
-    if (!state) return void 0;
+    if (!state2) 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(
+      eventId: state2.eventId,
+      userId: state2.identity.userId,
+      convoId: state2.identity.convoId,
+      dispatchSpan: parentTool ? state2.toolSpans.get(parentTool.toolCallId) : void 0,
+      turnSpans: [state2.rootSpan, state2.stepSpan].filter(
         (span) => span !== void 0
       ),
-      recordInputs: state.recordInputs
+      recordInputs: state2.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);
+    for (const state2 of this.callStates.values()) {
+      if (state2.eventId !== eventId) continue;
+      if (state2.rootSpan) spans.push(state2.rootSpan);
+      if (state2.stepSpan) spans.push(state2.stepSpan);
     }
     return spans;
   }
@@ -3856,10 +3994,10 @@ var RaindropTelemetryIntegration = class {
    * 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 [];
+  abortOutcomeAttrs(state2, reason, finishReason) {
+    if (!state2.handoff || state2.nestedInEvent) return [];
     return [
-      attrString("ai.response.text", capText2(state.accumulatedText || reason)),
+      attrString("ai.response.text", capText2(state2.accumulatedText || reason)),
       attrString("ai.response.finishReason", finishReason)
     ];
   }
@@ -3873,19 +4011,19 @@ var RaindropTelemetryIntegration = class {
   spanParentRef(span) {
     return { traceIdB64: span.ids.traceIdB64, spanIdB64: span.ids.spanIdB64 };
   }
-  emitLive(state, type, content, extra) {
+  emitLive(state2, type, content, extra) {
     var _a, _b, _c, _d, _e, _f;
-    if (!localDebuggerEnabled() || !state.rootSpan) return;
-    const callMeta = this.extractRaindropMetadata(state.metadata);
+    if (!localDebuggerEnabled() || !state2.rootSpan) return;
+    const callMeta = this.extractRaindropMetadata(state2.metadata);
     sendLocalDebuggerLiveEvent({
-      traceId: state.rootSpan.ids.traceIdB64,
+      traceId: state2.rootSpan.ids.traceIdB64,
       type,
       content,
       metadata: {
         userId: (_b = callMeta.userId) != null ? _b : (_a = this.defaultContext) == null ? void 0 : _a.userId,
         convoId: (_d = callMeta.convoId) != null ? _d : (_c = this.defaultContext) == null ? void 0 : _c.convoId,
         eventName: (_f = callMeta.eventName) != null ? _f : (_e = this.defaultContext) == null ? void 0 : _e.eventName,
-        eventId: state.eventId,
+        eventId: state2.eventId,
         ...extra
       }
     });
@@ -3963,29 +4101,29 @@ var RaindropTelemetryIntegration = class {
       toolCallId: toolCall.toolCallId,
       toolName: toolCall.toolName
     });
-    const state = this.getState(event.callId);
-    state == null ? void 0 : state.parentContextToolCallIds.add(toolCall.toolCallId);
-    if (!(state == null ? void 0 : state.stepParent)) return;
-    const { operationName, resourceName } = opName("ai.toolCall", state.functionId);
-    const inputAttrs = state.recordInputs ? [attrString("ai.toolCall.args", safeJsonWithUint8(toolCall.input))] : [];
+    const state2 = this.getState(event.callId);
+    state2 == null ? void 0 : state2.parentContextToolCallIds.add(toolCall.toolCallId);
+    if (!(state2 == null ? void 0 : state2.stepParent)) return;
+    const { operationName, resourceName } = opName("ai.toolCall", state2.functionId);
+    const inputAttrs = state2.recordInputs ? [attrString("ai.toolCall.args", safeJsonWithUint8(toolCall.input))] : [];
     const toolSpan = this.traceShipper.startSpan({
       name: "ai.toolCall",
-      parent: state.stepParent,
-      eventId: state.eventId,
-      ...state.identity,
+      parent: state2.stepParent,
+      eventId: state2.eventId,
+      ...state2.identity,
       operationId: "ai.toolCall",
       attributes: [
         attrString("operation.name", operationName),
         attrString("resource.name", resourceName),
-        attrString("ai.telemetry.functionId", state.functionId),
+        attrString("ai.telemetry.functionId", state2.functionId),
         attrString("ai.toolCall.name", toolCall.toolName),
         attrString("ai.toolCall.id", toolCall.toolCallId),
         ...inputAttrs,
-        ...handoffSpanAttrs(state.handoff)
+        ...handoffSpanAttrs(state2.handoff)
       ]
     });
-    state.toolSpans.set(toolCall.toolCallId, toolSpan);
-    this.emitLive(state, "tool_start", toolCall.toolName, { args: toolCall.input });
+    state2.toolSpans.set(toolCall.toolCallId, toolSpan);
+    this.emitLive(state2, "tool_start", toolCall.toolName, { args: toolCall.input });
   }
   toolExecutionEnd(event) {
     var _a;
@@ -3999,20 +4137,20 @@ var RaindropTelemetryIntegration = class {
         clearParentToolContext();
       }
     }
-    const state = this.getState(event.callId);
-    if (!state) return;
-    const toolSpan = state.toolSpans.get(event.toolCall.toolCallId);
+    const state2 = this.getState(event.callId);
+    if (!state2) return;
+    const toolSpan = state2.toolSpans.get(event.toolCall.toolCallId);
     if (!toolSpan) return;
-    state.toolCallCount += 1;
+    state2.toolCallCount += 1;
     const outcome = "toolOutput" in event ? event.toolOutput.type === "tool-result" ? { success: true, output: event.toolOutput.output } : { success: false, error: event.toolOutput.error } : event.success ? { success: true, output: event.output } : { success: false, error: event.error };
     if (outcome.success) {
-      const outputAttrs = state.recordOutputs ? [attrString("ai.toolCall.result", safeJsonWithUint8(outcome.output))] : [];
+      const outputAttrs = state2.recordOutputs ? [attrString("ai.toolCall.result", safeJsonWithUint8(outcome.output))] : [];
       this.traceShipper.endSpan(toolSpan, { attributes: outputAttrs });
     } else {
       this.traceShipper.endSpan(toolSpan, { error: outcome.error });
     }
-    this.emitLive(state, "tool_result", event.toolCall.toolName);
-    state.toolSpans.delete(event.toolCall.toolCallId);
+    this.emitLive(state2, "tool_result", event.toolCall.toolName);
+    state2.toolSpans.delete(event.toolCall.toolCallId);
   }
   // ── provider-executed tool calls ─────────────────────────────────────────
   //
@@ -4031,8 +4169,8 @@ var RaindropTelemetryIntegration = class {
   //
   // Client-executed tools are excluded (`providerExecuted` falsy) — they were
   // already spanned during execution, so this never double-emits.
-  emitProviderExecutedToolSpans(event, state) {
-    if (!state.stepParent) return;
+  emitProviderExecutedToolSpans(event, state2) {
+    if (!state2.stepParent) return;
     const content = Array.isArray(event.content) ? event.content : [];
     const providerToolCalls = content.filter(
       (part) => (part == null ? void 0 : part.type) === "tool-call" && part.providerExecuted === true
@@ -4045,42 +4183,42 @@ var RaindropTelemetryIntegration = class {
       }
     }
     for (const call of providerToolCalls) {
-      const { operationName, resourceName } = opName("ai.toolCall", state.functionId);
-      const inputAttrs = state.recordInputs ? [attrString("ai.toolCall.args", safeJsonWithUint8(call.input))] : [];
+      const { operationName, resourceName } = opName("ai.toolCall", state2.functionId);
+      const inputAttrs = state2.recordInputs ? [attrString("ai.toolCall.args", safeJsonWithUint8(call.input))] : [];
       const toolSpan = this.traceShipper.startSpan({
         name: "ai.toolCall",
-        parent: state.stepParent,
-        eventId: state.eventId,
-        ...state.identity,
+        parent: state2.stepParent,
+        eventId: state2.eventId,
+        ...state2.identity,
         operationId: "ai.toolCall",
         attributes: [
           attrString("operation.name", operationName),
           attrString("resource.name", resourceName),
-          attrString("ai.telemetry.functionId", state.functionId),
+          attrString("ai.telemetry.functionId", state2.functionId),
           attrString("ai.toolCall.name", call.toolName),
           attrString("ai.toolCall.id", call.toolCallId),
           attrString("ai.toolCall.providerExecuted", "true"),
           ...inputAttrs,
-          ...handoffSpanAttrs(state.handoff)
+          ...handoffSpanAttrs(state2.handoff)
         ]
       });
-      state.toolCallCount += 1;
-      this.emitLive(state, "tool_start", call.toolName, { args: call.input });
+      state2.toolCallCount += 1;
+      this.emitLive(state2, "tool_start", call.toolName, { args: call.input });
       const resultPart = resultsByCallId.get(call.toolCallId);
       if ((resultPart == null ? void 0 : resultPart.type) === "tool-error") {
         this.traceShipper.endSpan(toolSpan, { error: resultPart.error });
       } else {
-        const outputAttrs = state.recordOutputs && resultPart && "output" in resultPart ? [attrString("ai.toolCall.result", safeJsonWithUint8(resultPart.output))] : [];
+        const outputAttrs = state2.recordOutputs && resultPart && "output" in resultPart ? [attrString("ai.toolCall.result", safeJsonWithUint8(resultPart.output))] : [];
         this.traceShipper.endSpan(toolSpan, { attributes: outputAttrs });
       }
-      this.emitLive(state, "tool_result", call.toolName);
+      this.emitLive(state2, "tool_result", call.toolName);
     }
   }
-  finishGenerate(event, state) {
+  finishGenerate(event, state2) {
     var _a, _b, _c, _d, _e, _f;
-    if (state.rootSpan) {
+    if (state2.rootSpan) {
       const outputAttrs = [];
-      if (state.recordOutputs) {
+      if (state2.recordOutputs) {
         outputAttrs.push(
           attrString("ai.response.finishReason", event.finishReason),
           attrString("ai.response.text", capText2((_a = event.text) != null ? _a : void 0)),
@@ -4121,12 +4259,12 @@ var RaindropTelemetryIntegration = class {
           attrInt("ai.usage.cachedInputTokens", usageMetrics.cachedInputTokens)
         );
       }
-      outputAttrs.push(attrInt("ai.toolCall.count", state.toolCallCount));
-      this.traceShipper.endSpan(state.rootSpan, { attributes: outputAttrs });
+      outputAttrs.push(attrInt("ai.toolCall.count", state2.toolCallCount));
+      this.traceShipper.endSpan(state2.rootSpan, { attributes: outputAttrs });
     }
     this.finalizeGenerateEvent(
-      state,
-      (_e = event.text) != null ? _e : state.accumulatedText || void 0,
+      state2,
+      (_e = event.text) != null ? _e : state2.accumulatedText || void 0,
       (_f = event.response) == null ? void 0 : _f.modelId,
       hasUnresolvedToolApproval(event)
     );
@@ -4142,29 +4280,29 @@ 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, detachedOutcome) {
+  finalizeGenerateEvent(state2, 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;
+    const suppressSubagentEvent = state2.subagentName !== void 0 && state2.subagentToolCallSpan !== void 0;
     if (!this.sendEvents || suppressSubagentEvent) return;
-    if (this.subagents.wasSettledExplicitly(state.eventId)) return;
-    const callMeta = this.extractRaindropMetadata(state.metadata);
+    if (this.subagents.wasSettledExplicitly(state2.eventId)) return;
+    const callMeta = this.extractRaindropMetadata(state2.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 eventName = (_e = (_d = callMeta.eventName) != null ? _d : (_c = this.defaultContext) == null ? void 0 : _c.eventName) != null ? _e : state2.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 reportedOutput = state2.handoff && detachedOutcome && !(cappedOutput == null ? void 0 : cappedOutput.trim()) ? detachedOutcome.fallbackOutput : cappedOutput;
+    const input = capText2(state2.inputText);
     const properties = {
       ...(_f = this.defaultContext) == null ? void 0 : _f.properties,
       ...callMeta.properties,
-      ...state.handoff ? detachedOutcome == null ? void 0 : detachedOutcome.properties : void 0
+      ...state2.handoff ? detachedOutcome == null ? void 0 : detachedOutcome.properties : void 0
     };
     const featureFlags = {
       ...((_g = this.defaultContext) == null ? void 0 : _g.featureFlags) ? normalizeFeatureFlags(this.defaultContext.featureFlags) : {},
       ...callMeta.featureFlags
     };
     const convoId = (_i = callMeta.convoId) != null ? _i : (_h = this.defaultContext) == null ? void 0 : _h.convoId;
-    void this.eventShipper.patch(state.eventId, {
+    void this.eventShipper.patch(state2.eventId, {
       eventName,
       userId,
       convoId,
@@ -4182,12 +4320,12 @@ var RaindropTelemetryIntegration = class {
       }
     });
   }
-  finishEmbed(event, state) {
+  finishEmbed(event, state2) {
     var _a;
-    if (!state.rootSpan) return;
+    if (!state2.rootSpan) return;
     const outputAttrs = [];
-    const isMany = state.operationId === "ai.embedMany";
-    if (state.recordOutputs) {
+    const isMany = state2.operationId === "ai.embedMany";
+    if (state2.recordOutputs) {
       if (isMany) {
         outputAttrs.push(attrString("ai.embeddings", safeJsonWithUint8(event.embedding)));
       } else {
@@ -4197,7 +4335,7 @@ var RaindropTelemetryIntegration = class {
     if (((_a = event.usage) == null ? void 0 : _a.tokens) != null) {
       outputAttrs.push(attrInt("ai.usage.tokens", event.usage.tokens));
     }
-    this.traceShipper.endSpan(state.rootSpan, { attributes: outputAttrs });
+    this.traceShipper.endSpan(state2.rootSpan, { attributes: outputAttrs });
   }
 };
 
@@ -4506,9 +4644,7 @@ function extractRaindropMetadata(metadata) {
     } catch (e) {
     }
   } else if (featureFlags && typeof featureFlags === "object") {
-    result.featureFlags = normalizeFeatureFlags(
-      featureFlags
-    );
+    result.featureFlags = normalizeFeatureFlags(featureFlags);
   }
   return result;
 }
@@ -4719,12 +4855,7 @@ function setupOperation(params) {
       ...attrsFromTelemetryMetadata(telemetry == null ? void 0 : telemetry.metadata),
       ...attrsFromHeaders(isRecord(arg) ? arg["headers"] : void 0),
       ...attrsFromSettings(arg),
-      ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
-        attrString(
-          "ai.prompt",
-          safeJsonWithUint8(normalizePromptAttr(arg))
-        )
-      ]
+      ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [attrString("ai.prompt", safeJsonWithUint8(normalizePromptAttr(arg)))]
     ]
   }) : void 0;
   const rootParentForChildren = rootSpan ? { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64 } : inheritedParent;
@@ -5074,7 +5205,10 @@ function wrapAISDK(aiSDK, deps) {
   }
   const useNative = deps.options.nativeTelemetry === true;
   if (useNative) {
-    const wrapTimeCtx = resolveContext(deps.options.context, { operation: "wrap", args: void 0 });
+    const wrapTimeCtx = resolveContext(deps.options.context, {
+      operation: "wrap",
+      args: void 0
+    });
     const integration = new RaindropTelemetryIntegration({
       traceShipper: deps.traceShipper,
       eventShipper: deps.eventShipper,
@@ -5319,7 +5453,13 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
         ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
           attrString(
             "ai.prompt",
-            safeJsonWithUint8(normalizePromptAttr({ system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"], prompt: mergedArgs["prompt"], messages: mergedArgs["messages"] }))
+            safeJsonWithUint8(
+              normalizePromptAttr({
+                system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"],
+                prompt: mergedArgs["prompt"],
+                messages: mergedArgs["messages"]
+              })
+            )
           )
         ]
       ]
@@ -5533,7 +5673,13 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
         ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
           attrString(
             "ai.prompt",
-            safeJsonWithUint8(normalizePromptAttr({ system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"], prompt: mergedArgs["prompt"], messages: mergedArgs["messages"] }))
+            safeJsonWithUint8(
+              normalizePromptAttr({
+                system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"],
+                prompt: mergedArgs["prompt"],
+                messages: mergedArgs["messages"]
+              })
+            )
           )
         ]
       ]
@@ -5910,9 +6056,19 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                 for (const part of content) {
                   if (isRecord(part)) {
                     if ((part["type"] === "reasoning" || part["type"] === "thinking") && typeof ((_a = part["text"]) != null ? _a : part["thinking"]) === "string") {
-                      sendLocalDebuggerLiveEvent({ traceId, type: "reasoning_delta", content: (_b = part["text"]) != null ? _b : part["thinking"], metadata: liveMeta });
+                      sendLocalDebuggerLiveEvent({
+                        traceId,
+                        type: "reasoning_delta",
+                        content: (_b = part["text"]) != null ? _b : part["thinking"],
+                        metadata: liveMeta
+                      });
                     } else if (part["type"] === "text" && typeof part["text"] === "string") {
-                      sendLocalDebuggerLiveEvent({ traceId, type: "text_delta", content: part["text"], metadata: liveMeta });
+                      sendLocalDebuggerLiveEvent({
+                        traceId,
+                        type: "text_delta",
+                        content: part["text"],
+                        metadata: liveMeta
+                      });
                     }
                   }
                 }
@@ -5993,7 +6149,10 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
               attributes: [
                 ...((_a = ctx.telemetry) == null ? void 0 : _a.recordOutputs) === false ? [] : [
                   attrString("ai.response.finishReason", finishReason),
-                  attrString("ai.response.text", activeText.length ? capText2(activeText) : void 0),
+                  attrString(
+                    "ai.response.text",
+                    activeText.length ? capText2(activeText) : void 0
+                  ),
                   attrString(
                     "ai.response.toolCalls",
                     safeJsonWithUint8(toolCallsLocal.length ? toolCallsLocal : void 0)
@@ -6011,7 +6170,8 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                 ...finishReason ? [attrStringArray("gen_ai.response.finish_reasons", [finishReason])] : [],
                 attrString("gen_ai.response.id", responseId),
                 attrString(MODEL_USAGE_ATTRIBUTES.responseModel, finalResponseModelId),
-                ...buildModelUsageAttributes(usageMetrics),
+                attrString(MODEL_USAGE_ATTRIBUTES.usageSource, usageMetrics.usageSource),
+                ...buildRawModelUsageAttributes(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)] : [],
@@ -6065,19 +6225,44 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                   if ("providerMetadata" in value) providerMetadata = value["providerMetadata"];
                   if (localDebuggerEnabled() && ctx.rootParentForChildren) {
                     const traceId = ctx.rootParentForChildren.traceIdB64;
-                    const liveMeta = getLocalDebuggerMetadata({ ...ctx.context, eventId: ctx.eventId });
+                    const liveMeta = getLocalDebuggerMetadata({
+                      ...ctx.context,
+                      eventId: ctx.eventId
+                    });
                     if (type === "text-delta") {
                       const text = typeof value["delta"] === "string" ? value["delta"] : typeof value["textDelta"] === "string" ? value["textDelta"] : typeof value["text"] === "string" ? value["text"] : void 0;
-                      if (typeof text === "string" && text) sendLocalDebuggerLiveEvent({ traceId, type: "text_delta", content: text, metadata: liveMeta });
+                      if (typeof text === "string" && text)
+                        sendLocalDebuggerLiveEvent({
+                          traceId,
+                          type: "text_delta",
+                          content: text,
+                          metadata: liveMeta
+                        });
                     } else if (type === "reasoning" || type === "reasoning-delta") {
                       const text = typeof value["delta"] === "string" ? value["delta"] : typeof value["text"] === "string" ? value["text"] : typeof value["thinking"] === "string" ? value["thinking"] : void 0;
-                      if (typeof text === "string" && text) sendLocalDebuggerLiveEvent({ traceId, type: "reasoning_delta", content: text, metadata: liveMeta });
+                      if (typeof text === "string" && text)
+                        sendLocalDebuggerLiveEvent({
+                          traceId,
+                          type: "reasoning_delta",
+                          content: text,
+                          metadata: liveMeta
+                        });
                     } else if (type === "tool-call") {
                       const toolName = typeof value["toolName"] === "string" ? value["toolName"] : "tool";
-                      sendLocalDebuggerLiveEvent({ traceId, type: "tool_start", content: toolName, metadata: { ...liveMeta, args: value["args"] } });
+                      sendLocalDebuggerLiveEvent({
+                        traceId,
+                        type: "tool_start",
+                        content: toolName,
+                        metadata: { ...liveMeta, args: value["args"] }
+                      });
                     } else if (type === "tool-result") {
                       const toolName = typeof value["toolName"] === "string" ? value["toolName"] : "tool";
-                      sendLocalDebuggerLiveEvent({ traceId, type: "tool_result", content: toolName, metadata: { ...liveMeta, result: value["result"] } });
+                      sendLocalDebuggerLiveEvent({
+                        traceId,
+                        type: "tool_result",
+                        content: toolName,
+                        metadata: { ...liveMeta, result: value["result"] }
+                      });
                     }
                   }
                 }
@@ -6157,11 +6342,7 @@ function endDoGenerateSpan(span, result, modelInfo, ctx) {
   } else {
     responseTimestampIso = (/* @__PURE__ */ new Date()).toISOString();
   }
-  const usageMetrics = extractUsageMetricsFromUsage(
-    usage,
-    modelInfo.provider,
-    providerMetadata
-  );
+  const usageMetrics = extractUsageMetricsFromUsage(usage, modelInfo.provider, providerMetadata);
   const { inputTokens, outputTokens } = usageMetrics;
   ctx.traceShipper.endSpan(span, {
     attributes: [
@@ -6182,7 +6363,8 @@ function endDoGenerateSpan(span, result, modelInfo, ctx) {
       ...finishReason ? [attrStringArray("gen_ai.response.finish_reasons", [finishReason])] : [],
       attrString("gen_ai.response.id", responseId),
       attrString(MODEL_USAGE_ATTRIBUTES.responseModel, responseModelId),
-      ...buildModelUsageAttributes(usageMetrics)
+      attrString(MODEL_USAGE_ATTRIBUTES.usageSource, usageMetrics.usageSource),
+      ...buildRawModelUsageAttributes(usageMetrics)
     ]
   });
 }