@raindrop-ai/ai-sdk 0.0.19 → 0.0.21

package/dist/{chunk-CNLUX2MV.mjs → chunk-BTNDCDA3.mjs}

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'async_hooks';
 
-// ../core/dist/chunk-H6VSZSLN.js
+// ../core/dist/chunk-4UCYIEH4.js
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -145,6 +145,7 @@ async function postJson(url, body, headers, opts) {
   );
 }
 var SpanStatusCode = {
+  UNSET: 0,
   ERROR: 2
 };
 function createSpanIds(parent) {
@@ -465,11 +466,66 @@ var EventShipper = class {
     }
   }
 };
+var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
+function resolveLocalDebuggerBaseUrl(baseUrl) {
+  var _a, _b, _c;
+  const resolved = (_b = baseUrl != null ? baseUrl : typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a[LOCAL_DEBUGGER_ENV_VAR] : void 0) != null ? _b : null;
+  return resolved ? (_c = formatEndpoint(resolved)) != null ? _c : null : null;
+}
+function localDebuggerEnabled(baseUrl) {
+  return resolveLocalDebuggerBaseUrl(baseUrl) !== null;
+}
+function normalizeLocalDebuggerLiveEventType(type) {
+  switch (type) {
+    case "text-delta":
+      return "text_delta";
+    case "reasoning":
+    case "reasoning-delta":
+      return "reasoning_delta";
+    case "tool-call":
+      return "tool_start";
+    case "tool-result":
+      return "tool_result";
+    default:
+      return type;
+  }
+}
+function mirrorTraceExportToLocalDebugger(body, options = {}) {
+  var _a;
+  const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
+  if (!baseUrl) return;
+  void postJson(`${baseUrl}traces`, body, {}, {
+    maxAttempts: 1,
+    debug: (_a = options.debug) != null ? _a : false,
+    sdkName: options.sdkName
+  }).catch(() => {
+  });
+}
+function sendLocalDebuggerLiveEvent(event, options = {}) {
+  var _a, _b;
+  const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
+  if (!baseUrl) return;
+  void postJson(
+    `${baseUrl}live`,
+    {
+      ...event,
+      type: normalizeLocalDebuggerLiveEventType(event.type),
+      timestamp: (_a = event.timestamp) != null ? _a : Date.now()
+    },
+    {},
+    {
+      maxAttempts: 1,
+      debug: (_b = options.debug) != null ? _b : false,
+      sdkName: options.sdkName
+    }
+  ).catch(() => {
+  });
+}
 var TraceShipper = class {
   constructor(opts) {
     this.queue = [];
     this.inFlight = /* @__PURE__ */ new Set();
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
     this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
     this.enabled = opts.enabled !== false;
@@ -482,6 +538,13 @@ var TraceShipper = class {
     this.prefix = `[raindrop-ai/${this.sdkName}]`;
     this.serviceName = (_g = opts.serviceName) != null ? _g : "raindrop.core";
     this.serviceVersion = (_h = opts.serviceVersion) != null ? _h : "0.0.0";
+    const localDebugger = typeof process !== "undefined" ? (_i = process.env) == null ? void 0 : _i.RAINDROP_LOCAL_DEBUGGER : void 0;
+    if (localDebugger) {
+      this.localDebuggerUrl = (_j = resolveLocalDebuggerBaseUrl(localDebugger)) != null ? _j : void 0;
+      if (this.debug) {
+        console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
+      }
+    }
   }
   isDebugEnabled() {
     return this.debug;
@@ -498,7 +561,25 @@ var TraceShipper = class {
       attrString("ai.operationId", args.operationId)
     ];
     if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
-    return { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
+    const span = { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
+    if (this.localDebuggerUrl) {
+      const openSpan = buildOtlpSpan({
+        ids: span.ids,
+        name: span.name,
+        startTimeUnixNano: span.startTimeUnixNano,
+        endTimeUnixNano: span.startTimeUnixNano,
+        // placeholder — will be updated on endSpan
+        attributes: span.attributes,
+        status: { code: SpanStatusCode.UNSET }
+      });
+      const body = buildExportTraceServiceRequest([openSpan], this.serviceName, this.serviceVersion);
+      mirrorTraceExportToLocalDebugger(body, {
+        baseUrl: this.localDebuggerUrl,
+        debug: false,
+        sdkName: this.sdkName
+      });
+    }
+    return span;
   }
   endSpan(span, extra) {
     var _a, _b;
@@ -521,6 +602,14 @@ var TraceShipper = class {
       status
     });
     this.enqueue(otlp);
+    if (this.localDebuggerUrl) {
+      const body = buildExportTraceServiceRequest([otlp], this.serviceName, this.serviceVersion);
+      mirrorTraceExportToLocalDebugger(body, {
+        baseUrl: this.localDebuggerUrl,
+        debug: false,
+        sdkName: this.sdkName
+      });
+    }
   }
   createSpan(args) {
     var _a;
@@ -538,6 +627,14 @@ var TraceShipper = class {
       status: args.status
     });
     this.enqueue(otlp);
+    if (this.localDebuggerUrl) {
+      const body = buildExportTraceServiceRequest([otlp], this.serviceName, this.serviceVersion);
+      mirrorTraceExportToLocalDebugger(body, {
+        baseUrl: this.localDebuggerUrl,
+        debug: false,
+        sdkName: this.sdkName
+      });
+    }
   }
   enqueue(span) {
     if (!this.enabled) return;
@@ -1351,6 +1448,561 @@ 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, _d;
+      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 inherited = getContextManager().getParentSpanIds();
+      const eventIdGenerated = (metadata == null ? void 0 : metadata["raindrop.internal.eventIdGenerated"]) === "true" || (metadata == null ? void 0 : metadata["raindrop.internal.eventIdGenerated"]) === true;
+      const explicitEventId = callMeta.eventId && !eventIdGenerated ? callMeta.eventId : void 0;
+      const eventId = (_d = (_c = (_b = explicitEventId != null ? explicitEventId : (_a = this.defaultContext) == null ? void 0 : _a.eventId) != null ? _b : inherited == null ? void 0 : inherited.eventId) != null ? _c : callMeta.eventId) != null ? _d : randomUUID();
+      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),
+            // Filter out raindrop.eventId from metadata attrs since TraceShipper
+            // already sets it via the eventId arg. Without this, eventMetadata()'s
+            // auto-generated ID would duplicate and override the resolved one.
+            ...attrsFromTelemetryMetadata(
+              metadata ? Object.fromEntries(
+                Object.entries(metadata).filter(
+                  ([k]) => k !== "raindrop.eventId" && k !== "raindrop.internal.eventIdGenerated"
+                )
+              ) : void 0
+            ),
+            ...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);
+      this.emitLive(state, "tool_start", toolCall.toolName, { args: toolCall.input });
+    };
+    // ── 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 });
+      }
+      this.emitLive(state, "tool_result", event.toolCall.toolName);
+      state.toolSpans.delete(event.toolCall.toolCallId);
+    };
+    // ── onChunk (streaming) ─────────────────────────────────────────────────
+    this.onChunk = (event) => {
+      var _a, _b, _c, _d, _e;
+      const callId = (_b = event.callId) != null ? _b : (_a = event.chunk) == null ? void 0 : _a.callId;
+      if (!callId) return;
+      const state = this.getState(callId);
+      if (!state) return;
+      const 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;
+          this.emitLive(state, "text_delta", delta);
+        }
+      } else if (chunk.type === "reasoning" || chunk.type === "reasoning-delta") {
+        const text = (_e = (_d = chunk.textDelta) != null ? _d : chunk.text) != null ? _e : chunk.delta;
+        if (typeof text === "string") {
+          this.emitLive(state, "reasoning_delta", text);
+        }
+      }
+    };
+    // ── 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 };
+  }
+  emitLive(state, type, content, extra) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!localDebuggerEnabled() || !state.rootSpan) return;
+    const callMeta = this.extractRaindropMetadata(state.metadata);
+    sendLocalDebuggerLiveEvent({
+      traceId: state.rootSpan.ids.traceIdB64,
+      type,
+      content,
+      metadata: {
+        userId: (_b = callMeta.userId) != null ? _b : (_a = this.defaultContext) == null ? void 0 : _a.userId,
+        convoId: (_d = callMeta.convoId) != null ? _d : (_c = this.defaultContext) == null ? void 0 : _c.convoId,
+        eventName: (_f = callMeta.eventName) != null ? _f : (_e = this.defaultContext) == null ? void 0 : _e.eventName,
+        eventId: state.eventId,
+        ...extra
+      }
+    });
+  }
+  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/wrap/wrapAISDK.ts
 var AGENT_REPORTING_TOOL_NAME_DEFAULT = "__raindrop_report";
 var AGENT_REPORTING_SIGNALS_DEFAULT = {
@@ -1560,6 +2212,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");
@@ -1732,6 +2387,36 @@ function shouldKeepEventPending(params) {
   if (params.error != null || !params.canKeepEventPending) return false;
   return params.finishReason === "tool-calls" || params.finishReason === "tool_calls";
 }
+function normalizePromptAttr(arg) {
+  if (!isRecord(arg)) return arg;
+  const system = arg["system"];
+  const prompt = arg["prompt"];
+  const messages = arg["messages"];
+  if (Array.isArray(messages)) {
+    if (system) {
+      const sysContent = typeof system === "string" ? system : JSON.stringify(system);
+      return [{ role: "system", content: sysContent }, ...messages];
+    }
+    return messages;
+  }
+  if (typeof prompt === "string") {
+    const msgs = [];
+    if (system) {
+      msgs.push({ role: "system", content: typeof system === "string" ? system : JSON.stringify(system) });
+    }
+    msgs.push({ role: "user", content: prompt });
+    return msgs;
+  }
+  return { system, prompt, messages };
+}
+function getLocalDebuggerMetadata(ctx) {
+  return {
+    eventId: ctx.eventId,
+    ...ctx.eventName ? { eventName: ctx.eventName } : {},
+    ...ctx.userId ? { userId: ctx.userId } : {},
+    ...ctx.convoId ? { convoId: ctx.convoId } : {}
+  };
+}
 async function safeFinalize(finalize, debug, result, error) {
   try {
     await finalize(result, error);
@@ -1804,17 +2489,17 @@ function setupOperation(params) {
       attrString("ai.telemetry.functionId", telemetry == null ? void 0 : telemetry.functionId),
       attrString("ai.model.provider", modelInfoFromArgs.provider),
       attrString("ai.model.id", modelInfoFromArgs.modelId),
+      attrString("ai.telemetry.metadata.raindrop.eventId", eventId),
+      attrString("ai.telemetry.metadata.raindrop.eventName", mergedCtx.eventName),
+      attrString("ai.telemetry.metadata.raindrop.userId", mergedCtx.userId),
+      attrString("ai.telemetry.metadata.raindrop.convoId", mergedCtx.convoId),
       ...attrsFromTelemetryMetadata(telemetry == null ? void 0 : telemetry.metadata),
       ...attrsFromHeaders(isRecord(arg) ? arg["headers"] : void 0),
       ...attrsFromSettings(arg),
       ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
         attrString(
           "ai.prompt",
-          safeJsonWithUint8({
-            system: isRecord(arg) ? arg["system"] : void 0,
-            prompt: isRecord(arg) ? arg["prompt"] : void 0,
-            messages: isRecord(arg) ? arg["messages"] : void 0
-          })
+          safeJsonWithUint8(normalizePromptAttr(arg))
         )
       ]
     ]
@@ -1823,6 +2508,7 @@ function setupOperation(params) {
   const operationSelfDiagnostics = isObjectOperation(operation) ? void 0 : selfDiagnostics;
   const wrapCtx = {
     eventId,
+    context: mergedCtx,
     telemetry,
     sendTraces,
     debug,
@@ -2142,8 +2828,100 @@ 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;
+            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 perCallEventIdExplicit = (_a2 = callMeta.eventId) != null ? _a2 : wrapTimeCtx.eventId;
+            const perCallEventId = perCallEventIdExplicit != null ? perCallEventIdExplicit : randomUUID();
+            const perCallEventIdGenerated = !perCallEventIdExplicit;
+            const perCallCtx = {
+              eventId: perCallEventId,
+              context: wrapTimeCtx,
+              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,
+              ...perCallEventIdGenerated ? { "raindrop.internal.eventIdGenerated": "true" } : {}
+            };
+            callArgs[0] = {
+              ...arg,
+              tools,
+              experimental_telemetry: {
+                ...existingTelemetry,
+                metadata: mergedMetadata
+              }
+            };
+            return original.call(aiSDK, ...callArgs);
+          };
+        }
+      });
+    }
+    return aiSDK;
+  }
   const instrumentedOps = /* @__PURE__ */ new Set([
     "generateText",
     "streamText",
@@ -2151,8 +2929,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;
@@ -2260,7 +3038,7 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
     if (!mergedCtx.userId) warnMissingUserIdOnce();
     const inherited = await getCurrentParentSpanContext();
     const eventId = (_c = (_b2 = (_a2 = callTimeCtx.eventId) != null ? _a2 : mergedCtx.eventId) != null ? _b2 : inherited == null ? void 0 : inherited.eventId) != null ? _c : randomUUID();
-    const ctx = { ...mergedCtx};
+    const ctx = { ...mergedCtx, eventId };
     const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
     const outerOperationId = `ai.${operation}`;
     const { operationName, resourceName } = opName(outerOperationId, telemetry == null ? void 0 : telemetry.functionId);
@@ -2276,17 +3054,17 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
         attrString("ai.telemetry.functionId", telemetry == null ? void 0 : telemetry.functionId),
         attrString("ai.model.provider", modelInfoFromArgs.provider),
         attrString("ai.model.id", modelInfoFromArgs.modelId),
+        attrString("ai.telemetry.metadata.raindrop.eventId", eventId),
+        attrString("ai.telemetry.metadata.raindrop.eventName", ctx.eventName),
+        attrString("ai.telemetry.metadata.raindrop.userId", ctx.userId),
+        attrString("ai.telemetry.metadata.raindrop.convoId", ctx.convoId),
         ...attrsFromTelemetryMetadata(telemetry == null ? void 0 : telemetry.metadata),
         ...attrsFromHeaders(mergedArgs["headers"]),
         ...attrsFromSettings(mergedArgs),
         ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
           attrString(
             "ai.prompt",
-            safeJsonWithUint8({
-              system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"],
-              prompt: mergedArgs["prompt"],
-              messages: mergedArgs["messages"]
-            })
+            safeJsonWithUint8(normalizePromptAttr({ system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"], prompt: mergedArgs["prompt"], messages: mergedArgs["messages"] }))
           )
         ]
       ]
@@ -2294,6 +3072,7 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
     const rootParentForChildren = rootSpan ? { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64 } : inheritedParent;
     const wrapCtx = {
       eventId,
+      context: ctx,
       telemetry,
       sendTraces,
       debug,
@@ -2467,7 +3246,7 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
     if (!mergedCtx.userId) warnMissingUserIdOnce();
     const inherited = await getCurrentParentSpanContext();
     const eventId = (_c = (_b2 = (_a2 = callTimeCtx.eventId) != null ? _a2 : mergedCtx.eventId) != null ? _b2 : inherited == null ? void 0 : inherited.eventId) != null ? _c : randomUUID();
-    const ctx = { ...mergedCtx};
+    const ctx = { ...mergedCtx, eventId };
     const inheritedParent = inherited && inherited.eventId === eventId ? { traceIdB64: inherited.traceIdB64, spanIdB64: inherited.spanIdB64 } : void 0;
     const outerOperationId = `ai.${operation}`;
     const { operationName, resourceName } = opName(outerOperationId, telemetry == null ? void 0 : telemetry.functionId);
@@ -2483,17 +3262,17 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
         attrString("ai.telemetry.functionId", telemetry == null ? void 0 : telemetry.functionId),
         attrString("ai.model.provider", modelInfoFromArgs.provider),
         attrString("ai.model.id", modelInfoFromArgs.modelId),
+        attrString("ai.telemetry.metadata.raindrop.eventId", eventId),
+        attrString("ai.telemetry.metadata.raindrop.eventName", ctx.eventName),
+        attrString("ai.telemetry.metadata.raindrop.userId", ctx.userId),
+        attrString("ai.telemetry.metadata.raindrop.convoId", ctx.convoId),
         ...attrsFromTelemetryMetadata(telemetry == null ? void 0 : telemetry.metadata),
         ...attrsFromHeaders(mergedArgs["headers"]),
         ...attrsFromSettings(mergedArgs),
         ...(telemetry == null ? void 0 : telemetry.recordInputs) === false ? [] : [
           attrString(
             "ai.prompt",
-            safeJsonWithUint8({
-              system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"],
-              prompt: mergedArgs["prompt"],
-              messages: mergedArgs["messages"]
-            })
+            safeJsonWithUint8(normalizePromptAttr({ system: (_d = mergedArgs["system"]) != null ? _d : mergedArgs["instructions"], prompt: mergedArgs["prompt"], messages: mergedArgs["messages"] }))
           )
         ]
       ]
@@ -2501,6 +3280,7 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
     const rootParentForChildren = rootSpan ? { traceIdB64: rootSpan.ids.traceIdB64, spanIdB64: rootSpan.ids.spanIdB64 } : inheritedParent;
     const wrapCtx = {
       eventId,
+      context: ctx,
       telemetry,
       sendTraces,
       debug,
@@ -2724,6 +3504,21 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
       });
     }
   };
+  const sendToolLiveEvent = (parent, type, metadata) => {
+    if (!localDebuggerEnabled() || !parent) return;
+    sendLocalDebuggerLiveEvent({
+      traceId: parent.traceIdB64,
+      type,
+      content: name,
+      metadata: {
+        ...getLocalDebuggerMetadata({
+          ...ctx.context,
+          eventId: ctx.eventId
+        }),
+        ...metadata
+      }
+    });
+  };
   const createContextSpan = (span) => ({
     traceIdB64: span.ids.traceIdB64,
     spanIdB64: span.ids.spanIdB64,
@@ -2739,6 +3534,7 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
         const parentCtx = await getCurrentParentSpanContext();
         const parent = parentCtx && parentCtx.eventId === ctx.eventId ? { traceIdB64: parentCtx.traceIdB64, spanIdB64: parentCtx.spanIdB64 } : ctx.rootParentForChildren;
         const toolSpan = createToolSpan(toolCallId, toolArgs, parent);
+        sendToolLiveEvent(parent, "tool_start", { args: toolArgs });
         try {
           let lastValue;
           const iterator = result[Symbol.asyncIterator]();
@@ -2754,9 +3550,13 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
           }
           toolCalls.push({ id: toolCallId, name, args: toolArgs, result: lastValue, status: "OK" });
           endToolSpan(toolSpan, lastValue);
+          sendToolLiveEvent(parent, "tool_result", { result: lastValue });
         } catch (error) {
           toolCalls.push({ id: toolCallId, name, args: toolArgs, status: "ERROR" });
           endToolSpan(toolSpan, void 0, error);
+          sendToolLiveEvent(parent, "tool_result", {
+            error: error instanceof Error ? error.message : String(error)
+          });
           throw error;
         }
       })();
@@ -2765,6 +3565,7 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
       const parentCtx = await getCurrentParentSpanContext();
       const parent = parentCtx && parentCtx.eventId === ctx.eventId ? { traceIdB64: parentCtx.traceIdB64, spanIdB64: parentCtx.spanIdB64 } : ctx.rootParentForChildren;
       const toolSpan = createToolSpan(toolCallId, toolArgs, parent);
+      sendToolLiveEvent(parent, "tool_start", { args: toolArgs });
       const run = async () => {
         try {
           const awaitedResult = await result;
@@ -2776,10 +3577,14 @@ function wrapToolExecute(name, tool, ctx, toolCalls) {
             status: "OK"
           });
           endToolSpan(toolSpan, awaitedResult);
+          sendToolLiveEvent(parent, "tool_result", { result: awaitedResult });
           return awaitedResult;
         } catch (error) {
           toolCalls.push({ id: toolCallId, name, args: toolArgs, status: "ERROR" });
           endToolSpan(toolSpan, void 0, error);
+          sendToolLiveEvent(parent, "tool_result", {
+            error: error instanceof Error ? error.message : String(error)
+          });
           throw error;
         }
       };
@@ -2819,6 +3624,7 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
       const original = Reflect.get(target, prop, receiver);
       if (prop === "doGenerate" && isFunction(original)) {
         return async (...callArgs) => {
+          var _a, _b;
           const options = callArgs[0];
           const parentCtx = await getCurrentParentSpanContext();
           const parent = parentCtx && parentCtx.eventId === ctx.eventId ? { traceIdB64: parentCtx.traceIdB64, spanIdB64: parentCtx.spanIdB64 } : ctx.rootParentForChildren;
@@ -2826,6 +3632,22 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
           try {
             const result = await original.apply(target, callArgs);
             if (span) endDoGenerateSpan(span, result, modelInfo, ctx);
+            if (localDebuggerEnabled() && ctx.rootParentForChildren && isRecord(result)) {
+              const traceId = ctx.rootParentForChildren.traceIdB64;
+              const liveMeta = getLocalDebuggerMetadata({ ...ctx.context, eventId: ctx.eventId });
+              const content = result["content"];
+              if (Array.isArray(content)) {
+                for (const part of content) {
+                  if (isRecord(part)) {
+                    if ((part["type"] === "reasoning" || part["type"] === "thinking") && typeof ((_a = part["text"]) != null ? _a : part["thinking"]) === "string") {
+                      sendLocalDebuggerLiveEvent({ traceId, type: "reasoning_delta", content: (_b = part["text"]) != null ? _b : part["thinking"], metadata: liveMeta });
+                    } else if (part["type"] === "text" && typeof part["text"] === "string") {
+                      sendLocalDebuggerLiveEvent({ traceId, type: "text_delta", content: part["text"], metadata: liveMeta });
+                    }
+                  }
+                }
+              }
+            }
             return result;
           } catch (error) {
             if (span)
@@ -2965,6 +3787,23 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                   }
                   if ("usage" in value) usage = value["usage"];
                   if ("providerMetadata" in value) providerMetadata = value["providerMetadata"];
+                  if (localDebuggerEnabled() && ctx.rootParentForChildren) {
+                    const traceId = ctx.rootParentForChildren.traceIdB64;
+                    const liveMeta = getLocalDebuggerMetadata({ ...ctx.context, eventId: ctx.eventId });
+                    if (type === "text-delta") {
+                      const text = typeof value["delta"] === "string" ? value["delta"] : typeof value["textDelta"] === "string" ? value["textDelta"] : typeof value["text"] === "string" ? value["text"] : void 0;
+                      if (typeof text === "string" && text) sendLocalDebuggerLiveEvent({ traceId, type: "text_delta", content: text, metadata: liveMeta });
+                    } else if (type === "reasoning" || type === "reasoning-delta") {
+                      const text = typeof value["delta"] === "string" ? value["delta"] : typeof value["text"] === "string" ? value["text"] : typeof value["thinking"] === "string" ? value["thinking"] : void 0;
+                      if (typeof text === "string" && text) sendLocalDebuggerLiveEvent({ traceId, type: "reasoning_delta", content: text, metadata: liveMeta });
+                    } else if (type === "tool-call") {
+                      const toolName = typeof value["toolName"] === "string" ? value["toolName"] : "tool";
+                      sendLocalDebuggerLiveEvent({ traceId, type: "tool_start", content: toolName, metadata: { ...liveMeta, args: value["args"] } });
+                    } else if (type === "tool-result") {
+                      const toolName = typeof value["toolName"] === "string" ? value["toolName"] : "tool";
+                      sendLocalDebuggerLiveEvent({ traceId, type: "tool_result", content: toolName, metadata: { ...liveMeta, result: value["result"] } });
+                    }
+                  }
                 }
                 controller.enqueue(value);
               } catch (error) {
@@ -3165,7 +4004,7 @@ function extractNestedTokens(usage, key) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.0.19"};
+  version: "0.0.21"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -3281,6 +4120,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);
@@ -3314,4 +4163,4 @@ function createRaindropAISDK(opts) {
   };
 }
 
-export { _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, withCurrent };
+export { RaindropTelemetryIntegration, _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, withCurrent };