@raindrop-ai/ai-sdk 0.0.16 → 0.0.18

package/README.md

@@ -9,7 +9,7 @@ Standalone Vercel AI SDK integration for Raindrop:
 ## Install
 
 ```bash
-yarn add @raindrop-ai/ai-sdk
+pnpm add @raindrop-ai/ai-sdk
 ```
 
 ## Usage
@@ -121,15 +121,15 @@ packages/ai-sdk/
 
 ```bash
 # Run all version tests (requires OPENAI_API_KEY and RAINDROP_WRITE_KEY in .env)
-yarn test
+pnpm test
 
 # Run specific version
-yarn test:v4
-yarn test:v5
-yarn test:v6
+pnpm test:v4
+pnpm test:v5
+pnpm test:v6
 
 # Quick smoke test (real LLM calls, single version)
-yarn smoke:min
+pnpm smoke:min
 ```
 
 ### Test Coverage

package/dist/{chunk-MYJCN2H7.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.16"};
+  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,
@@ -1933,7 +2231,7 @@ function wrapAISDK(aiSDK, deps) {
     "generateObject",
     "streamObject"
   ]);
-  const agentClasses = /* @__PURE__ */ new Set(["ToolLoopAgent"]);
+  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 autoAttachmentEnabled = deps.options.autoAttachment !== false;
@@ -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;
         }
@@ -2693,10 +3023,16 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                 if (firstChunkMs === void 0) firstChunkMs = Date.now();
                 if (isRecord(value)) {
                   const type = value["type"];
-                  if (type === "text-delta" && typeof value["textDelta"] === "string")
-                    activeText += value["textDelta"];
-                  if (type === "finish" && typeof value["finishReason"] === "string")
-                    finishReason = value["finishReason"];
+                  if (type === "text-delta") {
+                    let textDelta;
+                    if (typeof value["delta"] === "string") {
+                      textDelta = value["delta"];
+                    } else if (typeof value["textDelta"] === "string") {
+                      textDelta = value["textDelta"];
+                    }
+                    if (typeof textDelta === "string") activeText += textDelta;
+                  }
+                  if (type === "finish") finishReason = extractFinishReason(value);
                   if (type === "tool-call") toolCallsLocal.push(value);
                   if ("response" in value && isRecord(value["response"])) {
                     const response = value["response"];
@@ -2909,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;
@@ -2995,4 +3360,4 @@ function createRaindropAISDK(opts) {
   };
 }
 
-export { _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, getContextManager, withCurrent };
+export { _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, withCurrent };