@raindrop-ai/ai-sdk 0.0.17 → 0.0.18

package/dist/{chunk-IPXCP2EO.mjs → chunk-4RNTOVBH.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.18"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -1168,6 +1171,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 +1325,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 +1364,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);
   });
@@ -1311,6 +1453,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 +1523,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"];
@@ -1619,6 +1809,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 +1866,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 +1920,7 @@ function setupOperation(params) {
   return {
     eventId,
     ctx,
+    canKeepEventPending: hasCallTimeEventId ? callTimeCtx.eventIdGenerated !== true : hasWrapTimeEventId,
     telemetry,
     rootSpan,
     wrappedArgs,
@@ -1746,6 +1943,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 +1970,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 +1999,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 +2016,7 @@ function createFinalize(params) {
         model: finalModel,
         properties: patch.properties,
         attachments: patch.attachments,
-        isPending: false
+        isPending: keepEventPending
       }).catch((err) => {
         if (debug) {
           console.warn(
@@ -1812,6 +2027,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,
@@ -2119,6 +2417,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 +2447,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 +2455,8 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
               )
             ] : []
           ],
-          error
+          error,
+          endTimeUnixNano: spanEndTimeUnixNano
         });
       }
       if (sendEvents) {
@@ -2313,6 +2624,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 +2654,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 +2662,8 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
               )
             ] : []
           ],
-          error
+          error,
+          endTimeUnixNano: spanEndTimeUnixNano
         });
       }
       if (sendEvents) {
@@ -2509,10 +2833,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 +2849,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 +3245,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;
@@ -3001,4 +3360,4 @@ function createRaindropAISDK(opts) {
   };
 }
 
-export { _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, getContextManager, withCurrent };
+export { _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, withCurrent };

package/dist/index.d.mts

@@ -81,6 +81,34 @@ type EventMetadataOptions = {
  * ```
  */
 declare function eventMetadata(options: EventMetadataOptions): Record<string, string>;
+type AISDKChatRequestMessageLike = {
+    id?: string;
+    role?: string;
+    [key: string]: unknown;
+};
+type AISDKChatRequestLike = {
+    id?: string;
+    messageId?: string;
+    trigger?: string;
+    messages?: AISDKChatRequestMessageLike[];
+    [key: string]: unknown;
+};
+/**
+ * Creates stable Raindrop metadata from an AI SDK UI chat request body.
+ *
+ * This is useful for `useChat` applications that require multiple server round-trips
+ * for a single user turn, e.g. when the model triggers client-side tools.
+ *
+ * The helper derives:
+ * - `convoId` from the AI SDK chat request `id`
+ * - `eventId` from the latest user message id in `messages`
+ *
+ * Reusing the same derived `eventId` across tool handoff round-trips allows the
+ * wrapper to patch one logical event instead of creating a new event per POST.
+ */
+declare function eventMetadataFromChatRequest(options: EventMetadataOptions & {
+    request: AISDKChatRequestLike;
+}): Record<string, string>;
 type AgentCallMetadata = ReturnType<typeof eventMetadata>;
 type NormalizeUnknownAgentOptions<T> = T extends {
     options: infer CallOptions;
@@ -282,4 +310,4 @@ type RaindropAISDKClient = {
 };
 declare function createRaindropAISDK(opts: RaindropAISDKOptions): RaindropAISDKClient;
 
-export { type AISDKMessage, type AgentCallMetadata, type AgentWithMetadata, type Attachment, type BuildEventPatch, ContextManager, type ContextSpan, type EventBuilder, type EventMetadataOptions, type IdentifyInput, type RaindropAISDKClient, type RaindropAISDKContext, type RaindropAISDKOptions, type SelfDiagnosticsOptions, type SelfDiagnosticsSignalDefinition, type SelfDiagnosticsSignalDefinitions, type WrapAISDKOptions, type WrappedAI, type WrappedAISDK, _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, getContextManager, withCurrent };
+export { type AISDKChatRequestLike, type AISDKChatRequestMessageLike, type AISDKMessage, type AgentCallMetadata, type AgentWithMetadata, type Attachment, type BuildEventPatch, ContextManager, type ContextSpan, type EventBuilder, type EventMetadataOptions, type IdentifyInput, type RaindropAISDKClient, type RaindropAISDKContext, type RaindropAISDKOptions, type SelfDiagnosticsOptions, type SelfDiagnosticsSignalDefinition, type SelfDiagnosticsSignalDefinitions, type WrapAISDKOptions, type WrappedAI, type WrappedAISDK, _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, withCurrent };