@raindrop-ai/deep-agents 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -1,7 +1,69 @@
 // src/callback-handler.ts
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
 
-// ../core/dist/chunk-267IXHO5.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 getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -56,6 +118,39 @@ 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_TERMINAL_PROPERTY_KEY = HANDOFF_ATTRIBUTE_SUFFIXES.terminal;
+var TRACEPARENT_HEADER = "traceparent";
+var BAGGAGE_HEADER = "baggage";
+var HANDOFF_HEADER = "x-raindrop-handoff";
+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.`;
 function runWithTracingSuppressed(fn) {
   const hook = globalThis.RAINDROP_SUPPRESS_TRACING;
   if (typeof hook !== "function") return fn();
@@ -183,6 +278,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
@@ -284,6 +380,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/";
@@ -346,26 +491,29 @@ function resolveLocalDebuggerBaseUrl(baseUrl) {
   if (shouldAutoEnableLocalWorkshop()) return DEFAULT_LOCAL_WORKSHOP_URL;
   return 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(() => {
   });
 }
@@ -391,19 +539,52 @@ function projectIdHeaders(projectId) {
 var SHUTDOWN_DEADLINE_MS = 1e4;
 var POST_SHUTDOWN_TIMEOUT_MS = 5e3;
 function mergePatches(target, source) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const out = { ...target, ...source };
   if (target.properties || source.properties) {
     out.properties = { ...(_a = target.properties) != null ? _a : {}, ...(_b = source.properties) != null ? _b : {} };
   }
+  if (target.usage || source.usage) {
+    out.usage = { ...(_c = target.usage) != null ? _c : {} };
+    if (((_d = source.usage) == null ? void 0 : _d.promptTokens) !== void 0) {
+      out.usage.promptTokens = source.usage.promptTokens;
+    }
+    if (((_e = source.usage) == null ? void 0 : _e.completionTokens) !== void 0) {
+      out.usage.completionTokens = source.usage.completionTokens;
+    }
+  }
+  if (source.error === void 0) {
+    out.error = target.error;
+  }
   if (target.featureFlags || source.featureFlags) {
-    out.featureFlags = { ...(_c = target.featureFlags) != null ? _c : {}, ...(_d = source.featureFlags) != null ? _d : {} };
+    out.featureFlags = { ...(_f = target.featureFlags) != null ? _f : {}, ...(_g = source.featureFlags) != null ? _g : {} };
   }
   if (target.attachments || source.attachments) {
-    out.attachments = [...(_e = target.attachments) != null ? _e : [], ...(_f = source.attachments) != null ? _f : []];
+    out.attachments = [...(_h = target.attachments) != null ? _h : [], ...(_i = source.attachments) != null ? _i : []];
   }
   return out;
 }
+function isErrorLike(value) {
+  return value !== null && typeof value === "object";
+}
+function eventTelemetryProperties(patch) {
+  var _a, _b;
+  const properties = {};
+  if (((_a = patch.usage) == null ? void 0 : _a.promptTokens) !== void 0 && Number.isFinite(patch.usage.promptTokens)) {
+    properties["ai.usage.prompt_tokens"] = patch.usage.promptTokens;
+  }
+  if (((_b = patch.usage) == null ? void 0 : _b.completionTokens) !== void 0 && Number.isFinite(patch.usage.completionTokens)) {
+    properties["ai.usage.completion_tokens"] = patch.usage.completionTokens;
+  }
+  if (patch.error !== void 0 && patch.error !== null) {
+    const constructorName = patch.error instanceof Error && patch.error.constructor !== Error ? patch.error.constructor.name : void 0;
+    const errorType = patch.error instanceof Error ? patch.error.name && patch.error.name !== "Error" ? patch.error.name : constructorName || patch.error.name || "Error" : isErrorLike(patch.error) && typeof patch.error.name === "string" && patch.error.name.length > 0 ? patch.error.name : "Error";
+    const errorMessage = patch.error instanceof Error ? patch.error.message : isErrorLike(patch.error) && typeof patch.error.message === "string" ? patch.error.message : String(patch.error);
+    properties["error.type"] = errorType;
+    properties["error.message"] = errorMessage;
+  }
+  return properties;
+}
 var EventShipper = class {
   constructor(opts) {
     this.buffers = /* @__PURE__ */ new Map();
@@ -489,6 +670,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) };
@@ -547,6 +737,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 {
@@ -556,6 +749,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,
@@ -590,6 +785,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()) {
@@ -642,8 +839,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`);
@@ -651,9 +849,13 @@ var EventShipper = class {
       this.sticky.delete(eventId);
       return;
     }
-    const { wizardSession, ...restProperties } = (_e = accumulated.properties) != null ? _e : {};
-    const convoId = (_f = accumulated.convoId) != null ? _f : sticky.convoId;
-    const isPending = (_h = (_g = accumulated.isPending) != null ? _g : sticky.isPending) != null ? _h : true;
+    const { wizardSession, ...restProperties } = (_g = accumulated.properties) != null ? _g : {};
+    let telemetryProperties = {};
+    try {
+      telemetryProperties = eventTelemetryProperties(accumulated);
+    } catch (e) {
+    }
+    const convoId = (_h = accumulated.convoId) != null ? _h : sticky.convoId;
     const payload = {
       event_id: eventId,
       user_id: userId,
@@ -661,12 +863,13 @@ var EventShipper = class {
       timestamp: (_i = accumulated.timestamp) != null ? _i : (/* @__PURE__ */ new Date()).toISOString(),
       ai_data: {
         input: accumulated.input,
-        output: accumulated.output,
+        output: accumulated.error !== void 0 && accumulated.error !== null ? void 0 : accumulated.output,
         model: accumulated.model,
         convo_id: convoId
       },
       properties: {
         ...restProperties,
+        ...telemetryProperties,
         ...wizardSession ? { "raindrop.wizardSession": wizardSession } : {},
         $context: this.context
       },
@@ -694,29 +897,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})`);
         }
@@ -728,13 +932,156 @@ var EventShipper = class {
         );
       }
     } finally {
-      this.inFlight.delete(p);
+      this.inFlight.delete(combined);
     }
     if (!isPending) {
       this.sticky.delete(eventId);
     }
   }
 };
+var MODEL_USAGE_ATTRIBUTES = {
+  usageSource: "raindrop.usage.source",
+  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",
+  providerReportedCost: "gen_ai.usage.provider_reported_cost",
+  nonCachedInputTokens: "raindrop.usage.input_tokens.non_cached",
+  nonReasoningOutputTokens: "raindrop.usage.output_tokens.non_reasoning",
+  totalOutputTokens: "raindrop.usage.output_tokens.total",
+  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.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"]
+];
+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 : normalizedProvider;
+}
+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",
@@ -824,6 +1171,13 @@ function redactJsonAttributeValue(key, value) {
   if (scrubbedJson === json) return void 0;
   return { stringValue: scrubbedJson };
 }
+function identityAttrs(args) {
+  return [
+    attrString("ai.telemetry.metadata.raindrop.ai.userId", args.userId),
+    attrString("ai.telemetry.metadata.raindrop.convoId", args.convoId),
+    attrString("ai.telemetry.metadata.raindrop.eventName", args.eventName)
+  ];
+}
 function applyOtelSpanAttributeLimit(limit) {
   var _a, _b;
   try {
@@ -919,7 +1273,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);
@@ -928,10 +1285,20 @@ var TraceShipper = class {
         return null;
       }
     }
+    try {
+      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;
@@ -948,33 +1315,55 @@ var TraceShipper = class {
     const started = (_a = args.startTimeUnixNano) != null ? _a : nowUnixNanoString();
     const attrs = [
       attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
-      attrString("ai.operationId", args.operationId)
+      ...identityAttrs(args),
+      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;
@@ -996,14 +1385,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)
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
+      ...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({
@@ -1014,8 +1406,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;
@@ -1029,6 +1422,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();
     }
@@ -1047,47 +1447,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);
       }
     }
   }
@@ -1130,7 +1550,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 {
@@ -1282,6 +1704,10 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
       });
     }
   }
+  rootErrorPatch(runId, error) {
+    const rootId = this.rootRunIds.get(runId) ?? runId;
+    return rootId === runId ? { error } : void 0;
+  }
   // ---------------------------------------------------------------------------
   // LLM events
   // ---------------------------------------------------------------------------
@@ -1377,8 +1803,6 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
         ]
       });
       const properties = {};
-      if (promptTokens != null) properties["ai.usage.prompt_tokens"] = promptTokens;
-      if (completionTokens != null) properties["ai.usage.completion_tokens"] = completionTokens;
       if (cachedTokens != null) properties["ai.usage.cached_tokens"] = cachedTokens;
       if (reasoningTokens != null) properties["ai.usage.thoughts_tokens"] = reasoningTokens;
       if (finishReason != null) properties["ai.finish_reason"] = finishReason;
@@ -1386,6 +1810,7 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
       await this.finalizeEventIfRoot(runId, {
         output: cappedOutput,
         model,
+        usage: { promptTokens, completionTokens },
         properties: Object.keys(properties).length > 0 ? properties : void 0
       });
     } catch {
@@ -1403,14 +1828,7 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
       if (span) {
         this.traceShipper.endSpan(span, { error: err });
       }
-      const errorInfo = extractErrorInfo(err);
-      await this.finalizeEventIfRoot(runId, {
-        output: `[Error] ${errorInfo.type}: ${errorInfo.message}`,
-        properties: {
-          "error.type": errorInfo.type,
-          "error.message": errorInfo.message
-        }
-      });
+      await this.finalizeEventIfRoot(runId, this.rootErrorPatch(runId, err));
     } catch {
     } finally {
       this.cleanup(runId);
@@ -1472,14 +1890,7 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
         const span = this.spans.get(runId);
         if (span) this.traceShipper.endSpan(span, { error: err });
       }
-      const errorInfo = extractErrorInfo(err);
-      await this.finalizeEventIfRoot(runId, {
-        output: `[Error] ${errorInfo.type}: ${errorInfo.message}`,
-        properties: {
-          "error.type": errorInfo.type,
-          "error.message": errorInfo.message
-        }
-      });
+      await this.finalizeEventIfRoot(runId, this.rootErrorPatch(runId, err));
     } catch {
     } finally {
       this.cleanup(runId);
@@ -1534,14 +1945,7 @@ var RaindropDeepAgentsHandler = class extends BaseCallbackHandler {
     try {
       const span = this.spans.get(runId);
       if (span) this.traceShipper.endSpan(span, { error: err });
-      const errorInfo = extractErrorInfo(err);
-      await this.finalizeEventIfRoot(runId, {
-        output: `[Error] ${errorInfo.type}: ${errorInfo.message}`,
-        properties: {
-          "error.type": errorInfo.type,
-          "error.message": errorInfo.message
-        }
-      });
+      await this.finalizeEventIfRoot(runId, this.rootErrorPatch(runId, err));
     } catch {
     } finally {
       this.cleanup(runId);
@@ -1706,18 +2110,6 @@ function asNumber(val) {
   const n = typeof val === "number" ? val : Number(val);
   return Number.isFinite(n) ? n : void 0;
 }
-function extractErrorInfo(err) {
-  if (err instanceof Error) {
-    return { type: err.name || err.constructor.name, message: err.message };
-  }
-  if (typeof err === "object" && err !== null) {
-    const e = err;
-    const type = e.name ?? e.constructor?.name ?? "Error";
-    const message = e.message ?? safeStringify(err);
-    return { type, message };
-  }
-  return { type: "Error", message: String(err) };
-}
 
 // src/version.ts
 var libraryName = "@raindrop-ai/deep-agents";