@raindrop-ai/ai-sdk 0.0.17 → 0.0.19-beta.1

package/dist/{chunk-IPXCP2EO.mjs → chunk-52PIGUHD.mjs}

@@ -1,4 +1,4 @@
-// ../core/dist/chunk-FTBZHS25.js
+// ../core/dist/chunk-FOHDGBT5.js
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -269,6 +269,7 @@ var EventShipper = class {
       console.log(`${this.prefix} queue patch`, {
         eventId,
         userId: patch.userId,
+        convoId: patch.convoId,
         eventName: patch.eventName,
         hasInput: typeof patch.input === "string" && patch.input.length > 0,
         hasOutput: typeof patch.output === "string" && patch.output.length > 0,
@@ -397,16 +398,18 @@ var EventShipper = class {
       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 payload = {
       event_id: eventId,
       user_id: userId,
       event: eventName,
-      timestamp: (_f = accumulated.timestamp) != null ? _f : (/* @__PURE__ */ new Date()).toISOString(),
+      timestamp: (_i = accumulated.timestamp) != null ? _i : (/* @__PURE__ */ new Date()).toISOString(),
       ai_data: {
         input: accumulated.input,
         output: accumulated.output,
         model: accumulated.model,
-        convo_id: (_g = accumulated.convoId) != null ? _g : sticky.convoId
+        convo_id: convoId
       },
       properties: {
         ...restProperties,
@@ -414,7 +417,7 @@ var EventShipper = class {
         $context: this.context
       },
       attachments: accumulated.attachments,
-      is_pending: ((_i = (_h = accumulated.isPending) != null ? _h : sticky.isPending) != null ? _i : true) !== false
+      is_pending: isPending
     };
     const url = `${this.baseUrl}events/track_partial`;
     if (this.debug) {
@@ -422,7 +425,8 @@ var EventShipper = class {
         eventId,
         eventName,
         userId,
-        isPending: payload.is_pending,
+        convoId,
+        isPending,
         inputPreview: typeof accumulated.input === "string" ? accumulated.input.slice(0, 120) : void 0,
         outputPreview: typeof accumulated.output === "string" ? accumulated.output.slice(0, 120) : void 0,
         attachments: (_k = (_j = accumulated.attachments) == null ? void 0 : _j.length) != null ? _k : 0,
@@ -454,7 +458,6 @@ var EventShipper = class {
     } finally {
       this.inFlight.delete(p);
     }
-    const isPending = payload.is_pending;
     if (!isPending) {
       this.sticky.delete(eventId);
     }
@@ -782,7 +785,7 @@ async function* asyncGeneratorWithCurrent(span, gen) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.0.17"};
+  version: "0.0.19-beta.1"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -801,19 +804,6 @@ var EventShipper2 = class extends EventShipper {
   }
 };
 
-// src/internal/traces.ts
-var TraceShipper2 = class extends TraceShipper {
-  constructor(opts) {
-    var _a, _b, _c;
-    super({
-      ...opts,
-      sdkName: (_a = opts.sdkName) != null ? _a : "ai-sdk",
-      serviceName: (_b = opts.serviceName) != null ? _b : "raindrop.ai-sdk",
-      serviceVersion: (_c = opts.serviceVersion) != null ? _c : libraryVersion
-    });
-  }
-};
-
 // src/internal/wrap/helpers.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -1168,6 +1158,145 @@ function extractResponseMessages(result) {
   }
   return [];
 }
+function buildToolCallMatchKey(info) {
+  if (typeof info.toolCallId === "string" && info.toolCallId.length > 0) {
+    return `id:${info.toolCallId}`;
+  }
+  if (typeof info.toolName === "string" && info.toolName.length > 0) {
+    const inputJson = safeJsonWithUint8(info.input);
+    return inputJson !== void 0 ? `name:${info.toolName}|input:${inputJson}` : `name:${info.toolName}`;
+  }
+  return void 0;
+}
+function isTranscriptToolResultError(part, result) {
+  if (part["isError"] === true || part["type"] === "tool-error") {
+    return true;
+  }
+  if (isRecord(result) && typeof result["type"] === "string") {
+    return result["type"].startsWith("error") || result["type"] === "execution-denied";
+  }
+  return false;
+}
+function getTranscriptToolErrorMessage(result) {
+  if (typeof result === "string" && result.length > 0) {
+    return result;
+  }
+  if (isRecord(result)) {
+    if (typeof result["value"] === "string" && result["value"].length > 0) {
+      return result["value"];
+    }
+    if (typeof result["reason"] === "string" && result["reason"].length > 0) {
+      return result["reason"];
+    }
+    if (typeof result["message"] === "string" && result["message"].length > 0) {
+      return result["message"];
+    }
+  }
+  return safeJsonWithUint8(result);
+}
+function getTranscriptMessageParts(message) {
+  if (!isRecord(message)) return [];
+  const content = message["content"];
+  if (Array.isArray(content)) {
+    return content.filter(isRecord);
+  }
+  return isRecord(content) ? [content] : [];
+}
+function getTranscriptToolCallInput(part) {
+  return "input" in part ? part["input"] : "args" in part ? part["args"] : void 0;
+}
+function getTranscriptToolCallId(part) {
+  const toolCallId = part["toolCallId"];
+  return typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
+}
+function getTranscriptToolResultValue(part) {
+  if ("output" in part) return part["output"];
+  if ("result" in part) return part["result"];
+  return part["error"];
+}
+function rememberPendingTranscriptToolCallKey(pendingKeysByToolName, toolName, key) {
+  var _a;
+  if (!toolName) return;
+  const pendingKeys = (_a = pendingKeysByToolName.get(toolName)) != null ? _a : [];
+  if (pendingKeys.includes(key)) return;
+  pendingKeys.push(key);
+  pendingKeysByToolName.set(toolName, pendingKeys);
+}
+function takePendingTranscriptToolCallKey(pendingKeysByToolName, toolName) {
+  if (!toolName) return void 0;
+  const pendingKeys = pendingKeysByToolName.get(toolName);
+  if (!pendingKeys || pendingKeys.length === 0) return void 0;
+  const key = pendingKeys.shift();
+  if (key === void 0) return void 0;
+  if (pendingKeys.length === 0) {
+    pendingKeysByToolName.delete(toolName);
+  }
+  return key;
+}
+function mergeTranscriptToolCallPart(params) {
+  var _a, _b, _c, _d;
+  const { spans, pendingKeysByToolName, part } = params;
+  const toolCallId = getTranscriptToolCallId(part);
+  const toolName = typeof part["toolName"] === "string" ? part["toolName"] : void 0;
+  const input = getTranscriptToolCallInput(part);
+  const key = buildToolCallMatchKey({ toolCallId, toolName, input });
+  if (!key) return;
+  const placeholderKey = toolCallId == null ? buildToolCallMatchKey({ toolCallId: void 0, toolName, input: void 0 }) : void 0;
+  const placeholder = placeholderKey && placeholderKey !== key ? spans.get(placeholderKey) : void 0;
+  const existing = (_a = spans.get(key)) != null ? _a : placeholder;
+  spans.set(key, {
+    key,
+    toolCallId: (_b = existing == null ? void 0 : existing.toolCallId) != null ? _b : toolCallId,
+    toolName: (_c = existing == null ? void 0 : existing.toolName) != null ? _c : toolName,
+    input: (_d = existing == null ? void 0 : existing.input) != null ? _d : input,
+    result: existing == null ? void 0 : existing.result,
+    status: existing == null ? void 0 : existing.status,
+    errorMessage: existing == null ? void 0 : existing.errorMessage
+  });
+  if (placeholderKey && placeholderKey !== key) {
+    spans.delete(placeholderKey);
+  }
+  if (!toolCallId && (existing == null ? void 0 : existing.result) === void 0) {
+    rememberPendingTranscriptToolCallKey(pendingKeysByToolName, toolName, key);
+  }
+}
+function mergeTranscriptToolResultPart(params) {
+  var _a, _b, _c;
+  const { spans, pendingKeysByToolName, part } = params;
+  const toolCallId = getTranscriptToolCallId(part);
+  const toolName = typeof part["toolName"] === "string" ? part["toolName"] : void 0;
+  const result = getTranscriptToolResultValue(part);
+  const fallbackKey = buildToolCallMatchKey({ toolCallId, toolName, input: void 0 });
+  const key = toolCallId != null ? fallbackKey : (_a = takePendingTranscriptToolCallKey(pendingKeysByToolName, toolName)) != null ? _a : fallbackKey;
+  if (!key) return;
+  const existing = spans.get(key);
+  const isError = isTranscriptToolResultError(part, result);
+  spans.set(key, {
+    key,
+    toolCallId: (_b = existing == null ? void 0 : existing.toolCallId) != null ? _b : toolCallId,
+    toolName: (_c = existing == null ? void 0 : existing.toolName) != null ? _c : toolName,
+    input: existing == null ? void 0 : existing.input,
+    result,
+    status: isError ? "ERROR" : "OK",
+    errorMessage: isError ? getTranscriptToolErrorMessage(result) : void 0
+  });
+}
+function extractToolSpansFromMessages(messages) {
+  const spans = /* @__PURE__ */ new Map();
+  const pendingKeysByToolName = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const part of getTranscriptMessageParts(message)) {
+      if (part["type"] === "tool-call") {
+        mergeTranscriptToolCallPart({ spans, pendingKeysByToolName, part });
+        continue;
+      }
+      if (part["type"] === "tool-result" || part["type"] === "tool-error") {
+        mergeTranscriptToolResultPart({ spans, pendingKeysByToolName, part });
+      }
+    }
+  }
+  return [...spans.values()];
+}
 function extractTextFromLmContent(content) {
   if (!Array.isArray(content)) return void 0;
   let result = "";
@@ -1183,7 +1312,7 @@ function extractToolCallsFromLmContent(content) {
   const calls = [];
   for (const part of content) {
     if (!isRecord(part) || part["type"] !== "tool-call") continue;
-    const toolCallId = typeof part["toolCallId"] === "string" ? part["toolCallId"] : void 0;
+    const toolCallId = getTranscriptToolCallId(part);
     const toolName = typeof part["toolName"] === "string" ? part["toolName"] : void 0;
     if (toolCallId || toolName) {
       calls.push({ toolCallId, toolName, input: part["input"] });
@@ -1222,7 +1351,7 @@ function toOtlpAttr(key, value) {
 }
 function attrsFromTelemetryMetadata(metadata) {
   if (!metadata) return [];
-  return Object.entries(metadata).map(([k, v]) => {
+  return Object.entries(metadata).filter(([k]) => !k.startsWith("raindrop.internal.")).map(([k, v]) => {
     const key = k === "raindrop.userId" ? "raindrop.ai.userId" : k;
     return toOtlpAttr(`ai.telemetry.metadata.${key}`, v);
   });
@@ -1290,6 +1419,538 @@ function attrsFromGenAiRequest(options) {
   ];
 }
 
+// src/internal/raindrop-telemetry-integration.ts
+var RaindropTelemetryIntegration = class {
+  constructor(opts) {
+    this.callStates = /* @__PURE__ */ new Map();
+    // ── onStart ─────────────────────────────────────────────────────────────
+    this.onStart = (event) => {
+      var _a, _b, _c;
+      if (event.isEnabled !== true) return;
+      const isEmbed = event.operationId === "ai.embed" || event.operationId === "ai.embedMany";
+      const recordInputs = event.recordInputs !== false;
+      const recordOutputs = event.recordOutputs !== false;
+      const functionId = event.functionId;
+      const metadata = event.metadata;
+      const callMeta = this.extractRaindropMetadata(metadata);
+      const eventId = (_c = (_b = callMeta.eventId) != null ? _b : (_a = this.defaultContext) == null ? void 0 : _a.eventId) != null ? _c : randomUUID();
+      const inherited = getContextManager().getParentSpanIds();
+      const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
+      const { operationName, resourceName } = opName(
+        event.operationId,
+        functionId
+      );
+      let rootSpan;
+      if (this.sendTraces) {
+        const promptAttrs = !isEmbed && recordInputs ? [
+          attrString(
+            "ai.prompt",
+            safeJsonWithUint8({
+              system: event.system,
+              prompt: event.prompt,
+              messages: event.messages
+            })
+          )
+        ] : [];
+        const embedAttrs = isEmbed && recordInputs ? event.operationId === "ai.embedMany" ? [
+          attrString(
+            "ai.values",
+            safeJsonWithUint8(event.value)
+          )
+        ] : [attrString("ai.value", safeJsonWithUint8(event.value))] : [];
+        rootSpan = this.traceShipper.startSpan({
+          name: event.operationId,
+          parent: inheritedParent,
+          eventId,
+          operationId: event.operationId,
+          attributes: [
+            attrString("operation.name", operationName),
+            attrString("resource.name", resourceName),
+            attrString("ai.telemetry.functionId", functionId),
+            attrString("ai.model.provider", event.provider),
+            attrString("ai.model.id", event.modelId),
+            ...attrsFromTelemetryMetadata(metadata),
+            ...promptAttrs,
+            ...embedAttrs
+          ]
+        });
+      }
+      this.callStates.set(event.callId, {
+        operationId: event.operationId,
+        eventId,
+        rootSpan,
+        rootParent: rootSpan ? this.spanParentRef(rootSpan) : inheritedParent,
+        stepSpan: void 0,
+        stepParent: void 0,
+        toolSpans: /* @__PURE__ */ new Map(),
+        embedSpans: /* @__PURE__ */ new Map(),
+        recordInputs,
+        recordOutputs,
+        functionId,
+        metadata,
+        accumulatedText: "",
+        inputText: isEmbed ? void 0 : this.extractInputText(event),
+        toolCallCount: 0
+      });
+    };
+    // ── 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 inputAttrs = [];
+      if (state.recordInputs) {
+        if (event.promptMessages) {
+          inputAttrs.push(
+            attrString(
+              "ai.prompt.messages",
+              safeJsonWithUint8(event.promptMessages)
+            )
+          );
+        }
+        if (event.stepTools) {
+          inputAttrs.push(
+            attrStringArray(
+              "ai.prompt.tools",
+              event.stepTools.map((t) => JSON.stringify(t))
+            )
+          );
+        }
+        if (event.stepToolChoice != null) {
+          inputAttrs.push(
+            attrString(
+              "ai.prompt.toolChoice",
+              JSON.stringify(event.stepToolChoice)
+            )
+          );
+        }
+      }
+      const stepSpan = this.traceShipper.startSpan({
+        name: stepOperationId,
+        parent: state.rootParent,
+        eventId: state.eventId,
+        operationId: stepOperationId,
+        attributes: [
+          attrString("operation.name", operationName),
+          attrString("resource.name", resourceName),
+          attrString("ai.telemetry.functionId", state.functionId),
+          attrString("ai.model.provider", event.provider),
+          attrString("ai.model.id", event.modelId),
+          attrString("gen_ai.system", event.provider),
+          attrString("gen_ai.request.model", event.modelId),
+          ...inputAttrs
+        ]
+      });
+      state.stepSpan = stepSpan;
+      state.stepParent = this.spanParentRef(stepSpan);
+    };
+    // ── onToolCallStart ─────────────────────────────────────────────────────
+    this.onToolCallStart = (event) => {
+      const state = this.getState(event.callId);
+      if (!(state == null ? void 0 : state.stepParent)) return;
+      const { toolCall } = event;
+      const { operationName, resourceName } = opName(
+        "ai.toolCall",
+        state.functionId
+      );
+      const inputAttrs = state.recordInputs ? [attrString("ai.toolCall.args", safeJsonWithUint8(toolCall.input))] : [];
+      const toolSpan = this.traceShipper.startSpan({
+        name: "ai.toolCall",
+        parent: state.stepParent,
+        eventId: state.eventId,
+        operationId: "ai.toolCall",
+        attributes: [
+          attrString("operation.name", operationName),
+          attrString("resource.name", resourceName),
+          attrString("ai.telemetry.functionId", state.functionId),
+          attrString("ai.toolCall.name", toolCall.toolName),
+          attrString("ai.toolCall.id", toolCall.toolCallId),
+          ...inputAttrs
+        ]
+      });
+      state.toolSpans.set(toolCall.toolCallId, toolSpan);
+    };
+    // ── onToolCallFinish ────────────────────────────────────────────────────
+    this.onToolCallFinish = (event) => {
+      const state = this.getState(event.callId);
+      if (!state) return;
+      const toolSpan = state.toolSpans.get(event.toolCall.toolCallId);
+      if (!toolSpan) return;
+      state.toolCallCount += 1;
+      if (event.success) {
+        const outputAttrs = state.recordOutputs ? [attrString("ai.toolCall.result", safeJsonWithUint8(event.output))] : [];
+        this.traceShipper.endSpan(toolSpan, { attributes: outputAttrs });
+      } else {
+        this.traceShipper.endSpan(toolSpan, { error: event.error });
+      }
+      state.toolSpans.delete(event.toolCall.toolCallId);
+    };
+    // ── onChunk (streaming) ─────────────────────────────────────────────────
+    this.onChunk = (event) => {
+      var _a, _b, _c;
+      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 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") {
+          state.accumulatedText += delta;
+        }
+      }
+    };
+    // ── 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 outputAttrs = [];
+      if (state.recordOutputs) {
+        outputAttrs.push(
+          attrString("ai.response.finishReason", event.finishReason),
+          attrString("ai.response.text", (_a = event.text) != null ? _a : void 0),
+          attrString("ai.response.id", (_b = event.response) == null ? void 0 : _b.id),
+          attrString("ai.response.model", (_c = event.response) == null ? void 0 : _c.modelId),
+          attrString(
+            "ai.response.timestamp",
+            ((_d = event.response) == null ? void 0 : _d.timestamp) instanceof Date ? event.response.timestamp.toISOString() : (_e = event.response) == null ? void 0 : _e.timestamp
+          ),
+          attrString(
+            "ai.response.providerMetadata",
+            event.providerMetadata ? safeJsonWithUint8(event.providerMetadata) : void 0
+          )
+        );
+        if (((_f = event.toolCalls) == null ? void 0 : _f.length) > 0) {
+          outputAttrs.push(
+            attrString(
+              "ai.response.toolCalls",
+              JSON.stringify(
+                event.toolCalls.map((tc) => ({
+                  toolCallId: tc.toolCallId,
+                  toolName: tc.toolName,
+                  input: tc.input
+                }))
+              )
+            )
+          );
+        }
+        if (((_g = event.reasoning) == null ? void 0 : _g.length) > 0) {
+          const reasoningText = event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n");
+          if (reasoningText) {
+            outputAttrs.push(attrString("ai.response.reasoning", reasoningText));
+          }
+        }
+      }
+      outputAttrs.push(
+        attrStringArray("gen_ai.response.finish_reasons", [event.finishReason]),
+        attrString("gen_ai.response.id", (_h = event.response) == null ? void 0 : _h.id),
+        attrString("gen_ai.response.model", (_i = event.response) == null ? void 0 : _i.modelId)
+      );
+      const usage = event.usage;
+      if (usage) {
+        outputAttrs.push(
+          attrInt("ai.usage.inputTokens", usage.inputTokens),
+          attrInt("ai.usage.outputTokens", usage.outputTokens),
+          attrInt("ai.usage.totalTokens", usage.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usage.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usage.cachedInputTokens),
+          attrInt("gen_ai.usage.input_tokens", usage.inputTokens),
+          attrInt("gen_ai.usage.output_tokens", usage.outputTokens)
+        );
+      }
+      this.traceShipper.endSpan(state.stepSpan, { attributes: outputAttrs });
+      state.stepSpan = void 0;
+      state.stepParent = 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 embedSpan = this.traceShipper.startSpan({
+        name: event.operationId,
+        parent: state.rootParent,
+        eventId: state.eventId,
+        operationId: event.operationId,
+        attributes: [
+          attrString("operation.name", operationName),
+          attrString("resource.name", resourceName),
+          attrString("ai.telemetry.functionId", state.functionId),
+          ...inputAttrs
+        ]
+      });
+      state.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);
+      if (!embedSpan) return;
+      const outputAttrs = [];
+      if (state.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);
+    };
+    // ── onFinish ────────────────────────────────────────────────────────────
+    this.onFinish = (event) => {
+      const state = this.getState(event.callId);
+      if (!state) return;
+      const isEmbed = state.operationId === "ai.embed" || state.operationId === "ai.embedMany";
+      if (isEmbed) {
+        this.finishEmbed(event, state);
+      } else {
+        this.finishGenerate(event, state);
+      }
+      this.cleanup(event.callId);
+    };
+    // ── onError ─────────────────────────────────────────────────────────────
+    this.onError = (error) => {
+      var _a;
+      const event = error;
+      if (!(event == null ? void 0 : event.callId)) return;
+      const state = this.getState(event.callId);
+      if (!state) return;
+      const actualError = (_a = event.error) != null ? _a : error;
+      if (state.stepSpan) {
+        this.traceShipper.endSpan(state.stepSpan, { error: actualError });
+      }
+      for (const embedSpan of state.embedSpans.values()) {
+        this.traceShipper.endSpan(embedSpan, { error: actualError });
+      }
+      state.embedSpans.clear();
+      for (const toolSpan of state.toolSpans.values()) {
+        this.traceShipper.endSpan(toolSpan, { error: actualError });
+      }
+      state.toolSpans.clear();
+      if (state.rootSpan) {
+        this.traceShipper.endSpan(state.rootSpan, { error: actualError });
+      }
+      this.cleanup(event.callId);
+    };
+    // ── executeTool ─────────────────────────────────────────────────────────
+    this.executeTool = async ({
+      callId,
+      toolCallId,
+      execute
+    }) => {
+      const state = this.getState(callId);
+      const toolSpan = state == null ? void 0 : state.toolSpans.get(toolCallId);
+      if (!toolSpan) return execute();
+      return runWithParentSpanContext(
+        {
+          traceIdB64: toolSpan.ids.traceIdB64,
+          spanIdB64: toolSpan.ids.spanIdB64,
+          eventId: state.eventId
+        },
+        () => execute()
+      );
+    };
+    this.traceShipper = opts.traceShipper;
+    this.eventShipper = opts.eventShipper;
+    this.sendTraces = opts.sendTraces !== false;
+    this.sendEvents = opts.sendEvents !== false;
+    this.debug = opts.debug === true;
+    this.defaultContext = opts.context;
+  }
+  // ── helpers ──────────────────────────────────────────────────────────────
+  getState(callId) {
+    return this.callStates.get(callId);
+  }
+  cleanup(callId) {
+    this.callStates.delete(callId);
+  }
+  spanParentRef(span) {
+    return { traceIdB64: span.ids.traceIdB64, spanIdB64: span.ids.spanIdB64 };
+  }
+  extractRaindropMetadata(metadata) {
+    if (!metadata) return {};
+    const result = {};
+    const userId = metadata["raindrop.userId"];
+    if (typeof userId === "string" && userId) result.userId = userId;
+    const eventId = metadata["raindrop.eventId"];
+    if (typeof eventId === "string" && eventId) result.eventId = eventId;
+    const convoId = metadata["raindrop.convoId"];
+    if (typeof convoId === "string" && convoId) result.convoId = convoId;
+    const eventName = metadata["raindrop.eventName"];
+    if (typeof eventName === "string" && eventName) result.eventName = eventName;
+    const properties = metadata["raindrop.properties"];
+    if (typeof properties === "string") {
+      try {
+        result.properties = JSON.parse(properties);
+      } catch (e) {
+      }
+    } else if (properties && typeof properties === "object") {
+      result.properties = properties;
+    }
+    return result;
+  }
+  /**
+   * Extract the user-facing input text from an onStart event.
+   * Mirrors the logic in the v4-v6 Proxy path (lastUserMessageTextFromArgs / extractInputFromArgs).
+   */
+  extractInputText(event) {
+    if (typeof event.prompt === "string") return event.prompt;
+    if (Array.isArray(event.messages)) {
+      for (let i = event.messages.length - 1; i >= 0; i--) {
+        const msg = event.messages[i];
+        if ((msg == null ? void 0 : msg.role) === "user") {
+          if (typeof msg.content === "string") return msg.content;
+          if (Array.isArray(msg.content)) {
+            const textPart = msg.content.find(
+              (p) => (p == null ? void 0 : p.type) === "text" && typeof p.text === "string"
+            );
+            if (textPart) return textPart.text;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  finishGenerate(event, state) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    if (state.rootSpan) {
+      const outputAttrs = [];
+      if (state.recordOutputs) {
+        outputAttrs.push(
+          attrString("ai.response.finishReason", event.finishReason),
+          attrString("ai.response.text", (_a = event.text) != null ? _a : void 0),
+          attrString(
+            "ai.response.providerMetadata",
+            event.providerMetadata ? safeJsonWithUint8(event.providerMetadata) : void 0
+          )
+        );
+        if (((_b = event.toolCalls) == null ? void 0 : _b.length) > 0) {
+          outputAttrs.push(
+            attrString(
+              "ai.response.toolCalls",
+              JSON.stringify(
+                event.toolCalls.map((tc) => ({
+                  toolCallId: tc.toolCallId,
+                  toolName: tc.toolName,
+                  input: tc.input
+                }))
+              )
+            )
+          );
+        }
+        if (((_c = event.reasoning) == null ? void 0 : _c.length) > 0) {
+          const reasoningText = event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n");
+          if (reasoningText) {
+            outputAttrs.push(attrString("ai.response.reasoning", reasoningText));
+          }
+        }
+      }
+      const usage = (_d = event.totalUsage) != null ? _d : event.usage;
+      if (usage) {
+        outputAttrs.push(
+          attrInt("ai.usage.inputTokens", usage.inputTokens),
+          attrInt("ai.usage.outputTokens", usage.outputTokens),
+          attrInt("ai.usage.totalTokens", usage.totalTokens),
+          attrInt("ai.usage.reasoningTokens", usage.reasoningTokens),
+          attrInt("ai.usage.cachedInputTokens", usage.cachedInputTokens)
+        );
+      }
+      outputAttrs.push(
+        attrInt("ai.toolCall.count", state.toolCallCount)
+      );
+      this.traceShipper.endSpan(state.rootSpan, { attributes: outputAttrs });
+    }
+    if (this.sendEvents) {
+      const callMeta = this.extractRaindropMetadata(state.metadata);
+      const userId = (_f = callMeta.userId) != null ? _f : (_e = this.defaultContext) == null ? void 0 : _e.userId;
+      if (userId) {
+        const eventName = (_i = (_h = callMeta.eventName) != null ? _h : (_g = this.defaultContext) == null ? void 0 : _g.eventName) != null ? _i : state.operationId;
+        const output = (_j = event.text) != null ? _j : state.accumulatedText || void 0;
+        const input = state.inputText;
+        const model = (_k = event.response) == null ? void 0 : _k.modelId;
+        const properties = {
+          ...(_l = this.defaultContext) == null ? void 0 : _l.properties,
+          ...callMeta.properties
+        };
+        const convoId = (_n = callMeta.convoId) != null ? _n : (_m = this.defaultContext) == null ? void 0 : _m.convoId;
+        void this.eventShipper.patch(state.eventId, {
+          eventName,
+          userId,
+          convoId,
+          input,
+          output,
+          model,
+          properties: Object.keys(properties).length > 0 ? properties : void 0,
+          isPending: false
+        }).catch((err) => {
+          if (this.debug) {
+            console.warn(
+              `[raindrop-ai/ai-sdk] event patch failed: ${err instanceof Error ? err.message : err}`
+            );
+          }
+        });
+      }
+    }
+  }
+  finishEmbed(event, state) {
+    var _a;
+    if (!state.rootSpan) return;
+    const outputAttrs = [];
+    const isMany = state.operationId === "ai.embedMany";
+    if (state.recordOutputs) {
+      if (isMany) {
+        outputAttrs.push(
+          attrString("ai.embeddings", safeJsonWithUint8(event.embedding))
+        );
+      } else {
+        outputAttrs.push(
+          attrString("ai.embedding", safeJsonWithUint8(event.embedding))
+        );
+      }
+    }
+    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 });
+  }
+};
+
+// src/internal/traces.ts
+var TraceShipper2 = class extends TraceShipper {
+  constructor(opts) {
+    var _a, _b, _c;
+    super({
+      ...opts,
+      sdkName: (_a = opts.sdkName) != null ? _a : "ai-sdk",
+      serviceName: (_b = opts.serviceName) != null ? _b : "raindrop.ai-sdk",
+      serviceVersion: (_c = opts.serviceVersion) != null ? _c : libraryVersion
+    });
+  }
+};
+
 // src/internal/wrap/wrapAISDK.ts
 var AGENT_REPORTING_TOOL_NAME_DEFAULT = "__raindrop_report";
 var AGENT_REPORTING_SIGNALS_DEFAULT = {
@@ -1311,6 +1972,50 @@ var AGENT_REPORTING_SIGNALS_DEFAULT = {
   }
 };
 var AGENT_REPORTING_TOOL_PREAMBLE = "You have a diagnostic tool for flagging serious failures for developer review. Only call this when you hit a significant, unrecoverable problem \u2014 not for minor hiccups or routine clarifications. If you can still help the user, do that instead of calling this tool. This tool is invisible to the user \u2014 never mention it or its output.";
+var pendingStoresByShipper = /* @__PURE__ */ new WeakMap();
+var PendingToolSpanStore = class _PendingToolSpanStore {
+  constructor() {
+    this.spans = /* @__PURE__ */ new Map();
+  }
+  static for(traceShipper, eventId) {
+    let byEvent = pendingStoresByShipper.get(traceShipper);
+    if (!byEvent) {
+      byEvent = /* @__PURE__ */ new Map();
+      pendingStoresByShipper.set(traceShipper, byEvent);
+    }
+    let store = byEvent.get(eventId);
+    if (!store) {
+      store = new _PendingToolSpanStore();
+      byEvent.set(eventId, store);
+    }
+    return store;
+  }
+  resolve(resolvedToolSpans, ctx) {
+    for (const [key, span] of this.spans) {
+      const toolCall = resolvedToolSpans.get(key);
+      if (!toolCall) continue;
+      finishToolSpan(toolCall, span, ctx, span.startTimeUnixNano);
+      this.spans.delete(key);
+    }
+  }
+  remember(toolCall, rootSpan, ctx, startTimeUnixNano) {
+    if (this.spans.has(toolCall.key)) return;
+    this.spans.set(toolCall.key, startToolSpan(toolCall, rootSpan, ctx, startTimeUnixNano));
+  }
+  closeAll(traceShipper) {
+    for (const [, span] of this.spans) {
+      traceShipper.endSpan(span, { endTimeUnixNano: span.startTimeUnixNano });
+    }
+    this.spans.clear();
+  }
+  cleanup(traceShipper, eventId) {
+    if (this.spans.size > 0) return;
+    const byEvent = pendingStoresByShipper.get(traceShipper);
+    if (!byEvent) return;
+    byEvent.delete(eventId);
+    if (byEvent.size === 0) pendingStoresByShipper.delete(traceShipper);
+  }
+};
 var warnedMissingUserId = false;
 function warnMissingUserIdOnce() {
   if (warnedMissingUserId) return;
@@ -1337,6 +2042,10 @@ function extractRaindropMetadata(metadata) {
   if (typeof userId === "string" && userId) result.userId = userId;
   const eventId = metadata["raindrop.eventId"];
   if (typeof eventId === "string" && eventId) result.eventId = eventId;
+  const eventIdGenerated = metadata["raindrop.internal.eventIdGenerated"];
+  if (eventIdGenerated === true || eventIdGenerated === "true" || eventIdGenerated === "1") {
+    result.eventIdGenerated = true;
+  }
   const convoId = metadata["raindrop.convoId"];
   if (typeof convoId === "string" && convoId) result.convoId = convoId;
   const eventName = metadata["raindrop.eventName"];
@@ -1451,6 +2160,9 @@ function detectAISDKVersion(aiSDK) {
   if (isFunction(aiSDK["tool"])) return "5";
   return "4";
 }
+function hasStructuredTelemetryEvents(aiSDK) {
+  return isRecord(aiSDK) && isFunction(aiSDK["registerTelemetryIntegration"]) && isFunction(aiSDK["experimental_streamModelCall"]);
+}
 function asVercelSchema(jsonSchemaObj) {
   const validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
   const schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
@@ -1619,6 +2331,10 @@ function logFinalizeError(debug, err) {
     );
   }
 }
+function shouldKeepEventPending(params) {
+  if (params.error != null || !params.canKeepEventPending) return false;
+  return params.finishReason === "tool-calls" || params.finishReason === "tool_calls";
+}
 async function safeFinalize(finalize, debug, result, error) {
   try {
     await finalize(result, error);
@@ -1672,7 +2388,9 @@ function setupOperation(params) {
   const callTimeCtx = extractRaindropMetadata(telemetry == null ? void 0 : telemetry.metadata);
   const mergedCtx = mergeContexts(wrapTimeCtx, callTimeCtx);
   if (!mergedCtx.userId) warnMissingUserIdOnce();
-  const eventId = (_c = (_b = (_a = callTimeCtx.eventId) != null ? _a : mergedCtx.eventId) != null ? _b : inherited == null ? void 0 : inherited.eventId) != null ? _c : randomUUID();
+  const hasCallTimeEventId = callTimeCtx.eventId != null;
+  const hasWrapTimeEventId = wrapTimeCtx.eventId != null;
+  const eventId = (_c = (_b = (_a = callTimeCtx.eventId) != null ? _a : wrapTimeCtx.eventId) != null ? _b : inherited == null ? void 0 : inherited.eventId) != null ? _c : randomUUID();
   const ctx = { ...mergedCtx, eventId };
   const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
   const outerOperationId = `ai.${operation}`;
@@ -1724,6 +2442,7 @@ function setupOperation(params) {
   return {
     eventId,
     ctx,
+    canKeepEventPending: hasCallTimeEventId ? callTimeCtx.eventIdGenerated !== true : hasWrapTimeEventId,
     telemetry,
     rootSpan,
     wrappedArgs,
@@ -1746,6 +2465,12 @@ function createFinalize(params) {
     var _a, _b, _c, _d;
     const usage = extractUsageMetrics(result);
     const model = extractModel(result);
+    const finishReason = extractFinishReason(result);
+    const keepEventPending = shouldKeepEventPending({
+      finishReason,
+      error,
+      canKeepEventPending: setup.canKeepEventPending
+    });
     const inputAttachments = autoAttachmentEnabled ? extractInputAttachmentsFromArgs(arg) : void 0;
     const outputAttachments = autoAttachmentEnabled ? await extractOutputAttachmentsFromResult(result) : void 0;
     const baseMessages = coerceMessagesFromArgs(arg);
@@ -1767,7 +2492,18 @@ function createFinalize(params) {
     const output = patch.output;
     const finalModel = (_c = patch.model) != null ? _c : model;
     if (setup.rootSpan) {
-      const finishReason = extractFinishReason(result);
+      const spanEndTimeUnixNano = nowUnixNanoString();
+      const syntheticToolCallCount = emitTranscriptToolCallSpans({
+        baseMessages,
+        responseMessages,
+        rootSpan: setup.rootSpan,
+        eventId: setup.eventId,
+        telemetry: setup.telemetry,
+        toolCalls: setup.toolCalls,
+        traceShipper,
+        endTimeUnixNano: spanEndTimeUnixNano,
+        keepEventPending
+      });
       const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
       const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : setup.toolCalls.length ? safeJsonWithUint8(setup.toolCalls) : void 0;
       traceShipper.endSpan(setup.rootSpan, {
@@ -1785,10 +2521,11 @@ function createFinalize(params) {
           attrInt("ai.usage.totalTokens", usage == null ? void 0 : usage.totalTokens),
           attrInt("ai.usage.reasoningTokens", usage == null ? void 0 : usage.reasoningTokens),
           attrInt("ai.usage.cachedInputTokens", usage == null ? void 0 : usage.cachedInputTokens),
-          attrInt("ai.toolCall.count", setup.toolCalls.length),
+          attrInt("ai.toolCall.count", setup.toolCalls.length + syntheticToolCallCount),
           ...error ? [attrString("error.message", error instanceof Error ? error.message : String(error))] : []
         ],
-        error
+        error,
+        endTimeUnixNano: spanEndTimeUnixNano
       });
     }
     if (sendEvents) {
@@ -1801,7 +2538,7 @@ function createFinalize(params) {
         model: finalModel,
         properties: patch.properties,
         attachments: patch.attachments,
-        isPending: false
+        isPending: keepEventPending
       }).catch((err) => {
         if (debug) {
           console.warn(
@@ -1812,6 +2549,89 @@ function createFinalize(params) {
     }
   };
 }
+function hasToolResult(toolCall) {
+  return toolCall.result !== void 0 || toolCall.status === "ERROR";
+}
+function getExecutedToolCallKeys(toolCalls) {
+  return new Set(
+    toolCalls.map((tc) => buildToolCallMatchKey({ toolCallId: tc.id, toolName: tc.name, input: tc.args })).filter((key) => typeof key === "string" && key.length > 0)
+  );
+}
+function getResolvedToolSpans(messages, executedKeys) {
+  return new Map(
+    extractToolSpansFromMessages(messages).filter((tc) => hasToolResult(tc) && !executedKeys.has(tc.key)).map((tc) => [tc.key, tc])
+  );
+}
+function startToolSpan(toolCall, rootSpan, ctx, startTimeUnixNano) {
+  var _a, _b, _c;
+  const { operationName, resourceName } = opName("ai.toolCall", (_a = ctx.telemetry) == null ? void 0 : _a.functionId);
+  return ctx.traceShipper.startSpan({
+    name: "ai.toolCall",
+    parent: { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64 },
+    eventId: ctx.eventId,
+    operationId: "ai.toolCall",
+    attributes: [
+      attrString("operation.name", operationName),
+      attrString("resource.name", resourceName),
+      attrString("ai.telemetry.functionId", (_b = ctx.telemetry) == null ? void 0 : _b.functionId),
+      attrString("ai.toolCall.name", toolCall.toolName),
+      attrString("ai.toolCall.id", toolCall.toolCallId),
+      ...((_c = ctx.telemetry) == null ? void 0 : _c.recordInputs) === false ? [] : [attrString("ai.toolCall.args", safeJsonWithUint8(toolCall.input))]
+    ],
+    startTimeUnixNano
+  });
+}
+function finishToolSpan(toolCall, span, ctx, endTimeUnixNano) {
+  var _a, _b, _c;
+  const endAttributes = toolCall.status === "ERROR" ? [attrString("error.message", (_a = toolCall.errorMessage) != null ? _a : "Tool call failed")] : ((_b = ctx.telemetry) == null ? void 0 : _b.recordOutputs) === false ? [] : [attrString("ai.toolCall.result", safeJsonWithUint8(toolCall.result))];
+  ctx.traceShipper.endSpan(span, {
+    attributes: endAttributes,
+    ...toolCall.status === "ERROR" ? { error: new Error((_c = toolCall.errorMessage) != null ? _c : "Tool call failed") } : {},
+    endTimeUnixNano
+  });
+}
+function emitToolSpan(toolCall, rootSpan, ctx, timeUnixNano) {
+  const span = startToolSpan(toolCall, rootSpan, ctx, timeUnixNano);
+  finishToolSpan(toolCall, span, ctx, timeUnixNano);
+}
+function emitTranscriptToolCallSpans(params) {
+  const store = PendingToolSpanStore.for(params.traceShipper, params.eventId);
+  const responseToolSpans = extractToolSpansFromMessages(params.responseMessages);
+  if (responseToolSpans.length === 0 && params.baseMessages.length === 0) {
+    if (!params.keepEventPending) {
+      store.closeAll(params.traceShipper);
+    }
+    store.cleanup(params.traceShipper, params.eventId);
+    return 0;
+  }
+  const ctx = {
+    eventId: params.eventId,
+    telemetry: params.telemetry,
+    traceShipper: params.traceShipper
+  };
+  const executedKeys = getExecutedToolCallKeys(params.toolCalls);
+  const resolvedSpans = getResolvedToolSpans(
+    [...params.baseMessages, ...params.responseMessages],
+    executedKeys
+  );
+  store.resolve(resolvedSpans, ctx);
+  let syntheticToolCallCount = 0;
+  for (const toolCall of responseToolSpans) {
+    if (executedKeys.has(toolCall.key)) continue;
+    executedKeys.add(toolCall.key);
+    syntheticToolCallCount += 1;
+    if (hasToolResult(toolCall) || !params.keepEventPending) {
+      emitToolSpan(toolCall, params.rootSpan, ctx, params.endTimeUnixNano);
+    } else {
+      store.remember(toolCall, params.rootSpan, ctx, params.endTimeUnixNano);
+    }
+  }
+  if (!params.keepEventPending) {
+    store.closeAll(params.traceShipper);
+  }
+  store.cleanup(params.traceShipper, params.eventId);
+  return syntheticToolCallCount;
+}
 function executeStreamingOperation(params) {
   const {
     operation,
@@ -1925,8 +2745,93 @@ async function executeNonStreamingOperation(params) {
   }
 }
 function wrapAISDK(aiSDK, deps) {
-  var _a, _b;
+  var _a, _b, _c, _d;
   const debug = deps.eventShipper.isDebugEnabled() || deps.traceShipper.isDebugEnabled();
+  if (deps.options.nativeTelemetry === true) {
+    if (!hasStructuredTelemetryEvents(aiSDK)) {
+      throw new Error(
+        "[raindrop-ai/ai-sdk] nativeTelemetry requires AI SDK v7+. The AI SDK module passed to wrap() does not support structured telemetry events. Remove nativeTelemetry or upgrade to AI SDK v7."
+      );
+    }
+  }
+  const useNative = deps.options.nativeTelemetry === true;
+  if (useNative) {
+    const wrapTimeCtx = resolveContext(deps.options.context, { operation: "wrap", args: void 0 });
+    const integration = new RaindropTelemetryIntegration({
+      traceShipper: deps.traceShipper,
+      eventShipper: deps.eventShipper,
+      sendTraces: ((_a = deps.options.send) == null ? void 0 : _a.traces) !== false,
+      sendEvents: ((_b = deps.options.send) == null ? void 0 : _b.events) !== false,
+      debug,
+      context: {
+        userId: wrapTimeCtx.userId,
+        eventId: wrapTimeCtx.eventId,
+        eventName: wrapTimeCtx.eventName,
+        convoId: wrapTimeCtx.convoId,
+        properties: wrapTimeCtx.properties
+      }
+    });
+    const registerFn = aiSDK["registerTelemetryIntegration"];
+    if (isFunction(registerFn)) {
+      registerFn(integration);
+    }
+    if (debug) {
+      console.log("[raindrop-ai/ai-sdk] nativeTelemetry: registered RaindropTelemetryIntegration (no Proxy)");
+    }
+    const selfDiagnostics2 = normalizeSelfDiagnosticsConfig(deps.options.selfDiagnostics);
+    if (selfDiagnostics2) {
+      const textOps = /* @__PURE__ */ new Set(["generateText", "streamText"]);
+      const jsonSchemaFactory = resolveJsonSchemaFactory(aiSDK);
+      const proxyTarget2 = isModuleNamespace(aiSDK) ? Object.setPrototypeOf({}, aiSDK) : aiSDK;
+      return new Proxy(proxyTarget2, {
+        get(target, prop, receiver) {
+          const original = Reflect.get(target, prop, receiver);
+          if (typeof prop !== "string" || !textOps.has(prop) || !isFunction(original)) {
+            return original;
+          }
+          return (...callArgs) => {
+            var _a2, _b2;
+            const arg = callArgs[0];
+            if (!isRecord(arg)) return original.call(aiSDK, ...callArgs);
+            const telemetry = extractExperimentalTelemetry(arg);
+            const callMeta = (telemetry == null ? void 0 : telemetry.metadata) ? extractRaindropMetadata(telemetry.metadata) : {};
+            const perCallEventId = (_b2 = (_a2 = callMeta.eventId) != null ? _a2 : wrapTimeCtx.eventId) != null ? _b2 : randomUUID();
+            const perCallCtx = {
+              eventId: perCallEventId,
+              telemetry,
+              sendTraces: false,
+              debug,
+              eventShipper: deps.eventShipper,
+              traceShipper: deps.traceShipper,
+              rootParentForChildren: void 0,
+              jsonSchemaFactory,
+              selfDiagnostics: selfDiagnostics2,
+              aiSDKVersion: "7"
+            };
+            const tools = isRecord(arg["tools"]) ? { ...arg["tools"] } : {};
+            const toolName = selfDiagnostics2.toolName;
+            if (!(toolName in tools)) {
+              const reportTool = createSelfDiagnosticsTool(perCallCtx);
+              if (reportTool) tools[toolName] = reportTool;
+            }
+            const existingTelemetry = isRecord(arg["experimental_telemetry"]) ? arg["experimental_telemetry"] : {};
+            const existingMetadata = isRecord(existingTelemetry["metadata"]) ? existingTelemetry["metadata"] : {};
+            const mergedMetadata = existingMetadata["raindrop.eventId"] ? existingMetadata : { ...existingMetadata, "raindrop.eventId": perCallEventId };
+            callArgs[0] = {
+              ...arg,
+              tools,
+              experimental_telemetry: {
+                ...existingTelemetry,
+                metadata: mergedMetadata
+              }
+            };
+            return original.call(aiSDK, ...callArgs);
+          };
+        }
+      });
+    }
+    return aiSDK;
+  }
   const instrumentedOps = /* @__PURE__ */ new Set([
     "generateText",
     "streamText",
@@ -1934,8 +2839,8 @@ function wrapAISDK(aiSDK, deps) {
     "streamObject"
   ]);
   const agentClasses = /* @__PURE__ */ new Set(["Agent", "Experimental_Agent", "ToolLoopAgent"]);
-  const sendEvents = ((_a = deps.options.send) == null ? void 0 : _a.events) !== false;
-  const sendTraces = ((_b = deps.options.send) == null ? void 0 : _b.traces) !== false;
+  const sendEvents = ((_c = deps.options.send) == null ? void 0 : _c.events) !== false;
+  const sendTraces = ((_d = deps.options.send) == null ? void 0 : _d.traces) !== false;
   const autoAttachmentEnabled = deps.options.autoAttachment !== false;
   const selfDiagnostics = normalizeSelfDiagnosticsConfig(deps.options.selfDiagnostics);
   const proxyTarget = isModuleNamespace(aiSDK) ? Object.setPrototypeOf({}, aiSDK) : aiSDK;
@@ -2119,6 +3024,18 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
       const output = patch.output;
       const finalModel = (_c2 = patch.model) != null ? _c2 : model;
       if (rootSpan) {
+        const spanEndTimeUnixNano = nowUnixNanoString();
+        const syntheticToolCallCount = emitTranscriptToolCallSpans({
+          baseMessages,
+          responseMessages,
+          rootSpan,
+          eventId,
+          telemetry,
+          toolCalls,
+          traceShipper: deps.traceShipper,
+          endTimeUnixNano: spanEndTimeUnixNano,
+          keepEventPending: false
+        });
         const finishReason = extractFinishReason(result);
         const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
         const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
@@ -2137,7 +3054,7 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
             attrInt("ai.usage.totalTokens", usage == null ? void 0 : usage.totalTokens),
             attrInt("ai.usage.reasoningTokens", usage == null ? void 0 : usage.reasoningTokens),
             attrInt("ai.usage.cachedInputTokens", usage == null ? void 0 : usage.cachedInputTokens),
-            attrInt("ai.toolCall.count", toolCalls.length),
+            attrInt("ai.toolCall.count", toolCalls.length + syntheticToolCallCount),
             ...error ? [
               attrString(
                 "error.message",
@@ -2145,7 +3062,8 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
               )
             ] : []
           ],
-          error
+          error,
+          endTimeUnixNano: spanEndTimeUnixNano
         });
       }
       if (sendEvents) {
@@ -2313,6 +3231,18 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
       const output = patch.output;
       const finalModel = (_c2 = patch.model) != null ? _c2 : model;
       if (rootSpan) {
+        const spanEndTimeUnixNano = nowUnixNanoString();
+        const syntheticToolCallCount = emitTranscriptToolCallSpans({
+          baseMessages,
+          responseMessages,
+          rootSpan,
+          eventId,
+          telemetry,
+          toolCalls,
+          traceShipper: deps.traceShipper,
+          endTimeUnixNano: spanEndTimeUnixNano,
+          keepEventPending: false
+        });
         const finishReason = extractFinishReason(result);
         const providerMetadata = isRecord(result) ? result["providerMetadata"] : void 0;
         const resultToolCalls = isRecord(result) && Array.isArray(result["toolCalls"]) ? safeJsonWithUint8(result["toolCalls"]) : toolCalls.length ? safeJsonWithUint8(toolCalls) : void 0;
@@ -2331,7 +3261,7 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
             attrInt("ai.usage.totalTokens", usage == null ? void 0 : usage.totalTokens),
             attrInt("ai.usage.reasoningTokens", usage == null ? void 0 : usage.reasoningTokens),
             attrInt("ai.usage.cachedInputTokens", usage == null ? void 0 : usage.cachedInputTokens),
-            attrInt("ai.toolCall.count", toolCalls.length),
+            attrInt("ai.toolCall.count", toolCalls.length + syntheticToolCallCount),
             ...error ? [
               attrString(
                 "error.message",
@@ -2339,7 +3269,8 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
               )
             ] : []
           ],
-          error
+          error,
+          endTimeUnixNano: spanEndTimeUnixNano
         });
       }
       if (sendEvents) {
@@ -2509,10 +3440,10 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
             lastValue = value;
             yield value;
           }
-          toolCalls.push({ name, args: toolArgs, result: lastValue, status: "OK" });
+          toolCalls.push({ id: toolCallId, name, args: toolArgs, result: lastValue, status: "OK" });
           endToolSpan(toolSpan, lastValue);
         } catch (error) {
-          toolCalls.push({ name, args: toolArgs, status: "ERROR" });
+          toolCalls.push({ id: toolCallId, name, args: toolArgs, status: "ERROR" });
           endToolSpan(toolSpan, void 0, error);
           throw error;
         }
@@ -2525,11 +3456,17 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
       const run = async () => {
         try {
           const awaitedResult = await result;
-          toolCalls.push({ name, args: toolArgs, result: awaitedResult, status: "OK" });
+          toolCalls.push({
+            id: toolCallId,
+            name,
+            args: toolArgs,
+            result: awaitedResult,
+            status: "OK"
+          });
           endToolSpan(toolSpan, awaitedResult);
           return awaitedResult;
         } catch (error) {
-          toolCalls.push({ name, args: toolArgs, status: "ERROR" });
+          toolCalls.push({ id: toolCallId, name, args: toolArgs, status: "ERROR" });
           endToolSpan(toolSpan, void 0, error);
           throw error;
         }
@@ -2915,15 +3852,44 @@ function extractNestedTokens(usage, key) {
 
 // src/index.ts
 function eventMetadata(options) {
-  var _a;
   const result = {};
-  result["raindrop.eventId"] = (_a = options.eventId) != null ? _a : randomUUID();
+  if (options.eventId) {
+    result["raindrop.eventId"] = options.eventId;
+  } else {
+    result["raindrop.eventId"] = randomUUID();
+    result["raindrop.internal.eventIdGenerated"] = "true";
+  }
   if (options.userId) result["raindrop.userId"] = options.userId;
   if (options.convoId) result["raindrop.convoId"] = options.convoId;
   if (options.eventName) result["raindrop.eventName"] = options.eventName;
   if (options.properties) result["raindrop.properties"] = JSON.stringify(options.properties);
   return result;
 }
+function deriveChatTurnMessageId(request) {
+  const messages = Array.isArray(request.messages) ? request.messages : [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if ((message == null ? void 0 : message.role) === "user" && typeof message.id === "string" && message.id.length > 0) {
+      return message.id;
+    }
+  }
+  if (typeof request.messageId === "string" && request.messageId.length > 0) {
+    return request.messageId;
+  }
+  return void 0;
+}
+function eventMetadataFromChatRequest(options) {
+  var _a, _b;
+  const { request, ...rest } = options;
+  const convoId = (_a = rest.convoId) != null ? _a : typeof request.id === "string" && request.id.length > 0 ? request.id : void 0;
+  const turnMessageId = deriveChatTurnMessageId(request);
+  const eventId = (_b = rest.eventId) != null ? _b : turnMessageId ? convoId ? `chat:${convoId}:${turnMessageId}` : `chat:${turnMessageId}` : void 0;
+  return eventMetadata({
+    ...rest,
+    ...convoId ? { convoId } : {},
+    ...eventId ? { eventId } : {}
+  });
+}
 function envDebugEnabled() {
   var _a;
   if (typeof process === "undefined") return false;
@@ -2968,6 +3934,16 @@ function createRaindropAISDK(opts) {
         traceShipper
       });
     },
+    createTelemetryIntegration(context) {
+      return new RaindropTelemetryIntegration({
+        traceShipper,
+        eventShipper,
+        sendTraces: tracesEnabled,
+        sendEvents: eventsEnabled,
+        debug: envDebug,
+        context
+      });
+    },
     events: {
       async patch(eventId, patch) {
         await eventShipper.patch(eventId, patch);
@@ -3001,4 +3977,4 @@ function createRaindropAISDK(opts) {
   };
 }
 
-export { _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, getContextManager, withCurrent };
+export { RaindropTelemetryIntegration, _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, withCurrent };