@raindrop-ai/ai-sdk 0.0.25 → 0.0.26

package/README.md

@@ -117,7 +117,7 @@ await raindrop.flush();
 
 ### AI SDK v7+ native telemetry (opt-in)
 
-On AI SDK v7+, you can use the native `TelemetryIntegration` callback interface instead of Proxy wrapping. This avoids Proxy overhead and works with all AI SDK entry points (including `ToolLoopAgent`).
+On AI SDK v7+, you can use the native `Telemetry` callback interface (formerly `TelemetryIntegration` before beta.111) instead of Proxy wrapping. This avoids Proxy overhead and works with all AI SDK entry points (including `ToolLoopAgent`).
 
 ```ts
 // Option A: wrap() with nativeTelemetry flag
@@ -127,15 +127,41 @@ const { generateText } = raindrop.wrap(ai, {
 });
 
 // Option B: direct registration (no wrap needed)
-import { registerTelemetryIntegration } from "ai";
+//   - registerTelemetry         on AI SDK v7 beta.111+
+//   - registerTelemetryIntegration on older v7 betas
+import { registerTelemetry } from "ai";
 
-registerTelemetryIntegration(
+registerTelemetry(
   raindrop.createTelemetryIntegration({ userId: "user_123" })
 );
 ```
 
 Setting `nativeTelemetry: true` on pre-v7 throws a clear error. The Proxy path remains the default and supports features not yet available on the native path (`buildEvent`, output attachment extraction).
 
+#### Per-call routing on AI SDK v7 beta.94+
+
+`eventMetadata()` keeps working on every published v7 beta:
+
+```ts
+const result = await generateText({
+  model,
+  prompt,
+  experimental_telemetry: {
+    isEnabled: true,
+    metadata: eventMetadata({
+      userId: "u_42",
+      eventName: "chat-turn",
+      eventId: "evt_abc",
+      convoId: "conv_xyz",
+    }),
+  },
+});
+```
+
+AI SDK v7 beta.94 (vercel/ai #14503) removed the `metadata` field from `TelemetryOptions`, and integration callbacks no longer receive it via `event.metadata`. Going through `wrap({ nativeTelemetry: true })` still routes per-call `userId` / `eventName` / `eventId` / `convoId` / `properties` correctly: the wrapper extracts them from the call's `experimental_telemetry.metadata` (or `telemetry.metadata`) before delegating, and exposes them to the integration via an `AsyncLocalStorage` slot.
+
+If you are bypassing `wrap()` and registering an integration manually, use the helpers exported from this package (`runWithRaindropCallMetadata`, `readRaindropCallMetadataFromArgs`, `getCurrentRaindropCallMetadata`) to plumb per-call metadata through your own call sites.
+
 If `userId` is missing from both `wrap()` context and `eventMetadata()`, the SDK logs a warning (once) and skips sending events.
 
 ## Runtime support
@@ -188,7 +214,7 @@ This package is tested against multiple Vercel AI SDK versions:
 | v4.x    | ✅ Supported | Proxy |
 | v5.x    | ✅ Supported | Proxy |
 | v6.x    | ✅ Supported | Proxy |
-| v7.x (beta) | ✅ Supported | Proxy (default) or native `TelemetryIntegration` (opt-in) |
+| v7.x (beta) | ✅ Supported | Proxy (default) or native `Telemetry` (opt-in, formerly `TelemetryIntegration` pre-beta.111). Verified against beta.116. |
 
 ### Version Differences Handled
 

package/dist/{chunk-AUFHKHNR.mjs → chunk-76JSTQY3.mjs}

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'async_hooks';
 
-// ../core/dist/chunk-4UCYIEH4.js
+// ../core/dist/chunk-Y7SM66SW.js
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -478,21 +478,6 @@ function resolveLocalDebuggerBaseUrl(baseUrl) {
 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);
@@ -512,7 +497,7 @@ function sendLocalDebuggerLiveEvent(event, options = {}) {
     `${baseUrl}live`,
     {
       ...event,
-      type: normalizeLocalDebuggerLiveEventType(event.type),
+      type: event.type,
       timestamp: (_a = event.timestamp) != null ? _a : Date.now()
     },
     {},
@@ -1451,6 +1436,77 @@ function attrsFromGenAiRequest(options) {
   ];
 }
 
+// src/internal/call-metadata.ts
+var SyncFallbackStorage = class {
+  constructor() {
+    this._stack = [];
+  }
+  getStore() {
+    return this._stack[this._stack.length - 1];
+  }
+  run(store, callback) {
+    this._stack.push(store);
+    try {
+      return callback();
+    } finally {
+      this._stack.pop();
+    }
+  }
+};
+var _storage = null;
+function getStorage() {
+  if (_storage) return _storage;
+  const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+  _storage = Ctor ? new Ctor() : new SyncFallbackStorage();
+  return _storage;
+}
+function _resetRaindropCallMetadataStorage() {
+  _storage = null;
+}
+function getCurrentRaindropCallMetadata() {
+  return getStorage().getStore();
+}
+function runWithRaindropCallMetadata(metadata, fn) {
+  return getStorage().run(metadata, fn);
+}
+function readRaindropCallMetadataFromArgs(args) {
+  var _a;
+  if (args.length === 0) return void 0;
+  const first = args[0];
+  if (!isRecord(first)) return void 0;
+  const topLevel = isRecord(first["metadata"]) ? first["metadata"] : void 0;
+  const stable = isRecord(first["telemetry"]) ? first["telemetry"]["metadata"] : void 0;
+  const stableMetadata = isRecord(stable) ? stable : void 0;
+  const exp = extractExperimentalTelemetry(first);
+  const expMetadata = (exp == null ? void 0 : exp.metadata) && typeof exp.metadata === "object" ? exp.metadata : void 0;
+  const raw = (_a = topLevel != null ? topLevel : stableMetadata) != null ? _a : expMetadata;
+  if (!raw) return void 0;
+  const meta = { rawMetadata: raw };
+  const userId = raw["raindrop.userId"];
+  if (typeof userId === "string" && userId) meta.userId = userId;
+  const eventId = raw["raindrop.eventId"];
+  if (typeof eventId === "string" && eventId) meta.eventId = eventId;
+  const eventIdGenerated = raw["raindrop.internal.eventIdGenerated"];
+  if (eventIdGenerated === true || eventIdGenerated === "true" || eventIdGenerated === "1") {
+    meta.eventIdGenerated = true;
+  }
+  const convoId = raw["raindrop.convoId"];
+  if (typeof convoId === "string" && convoId) meta.convoId = convoId;
+  const eventName = raw["raindrop.eventName"];
+  if (typeof eventName === "string" && eventName) meta.eventName = eventName;
+  const properties = raw["raindrop.properties"];
+  if (typeof properties === "string") {
+    try {
+      const parsed = JSON.parse(properties);
+      if (parsed && typeof parsed === "object") meta.properties = parsed;
+    } catch (e) {
+    }
+  } else if (properties && typeof properties === "object") {
+    meta.properties = properties;
+  }
+  return meta;
+}
+
 // src/internal/raindrop-telemetry-integration.ts
 var RaindropTelemetryIntegration = class {
   constructor(opts) {
@@ -1458,15 +1514,17 @@ var RaindropTelemetryIntegration = class {
     // ── onStart ─────────────────────────────────────────────────────────────
     this.onStart = (event) => {
       var _a, _b, _c, _d;
-      if (event.isEnabled !== true) return;
+      if (event.isEnabled === false) 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 eventMetadata2 = event.metadata;
+      const callContextMetadata = getCurrentRaindropCallMetadata();
+      const metadata = eventMetadata2 != null ? eventMetadata2 : callContextMetadata == null ? void 0 : callContextMetadata.rawMetadata;
       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 eventIdGenerated = (metadata == null ? void 0 : metadata["raindrop.internal.eventIdGenerated"]) === "true" || (metadata == null ? void 0 : metadata["raindrop.internal.eventIdGenerated"]) === true || (callContextMetadata == null ? void 0 : callContextMetadata.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;
@@ -1592,48 +1650,25 @@ var RaindropTelemetryIntegration = class {
       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 });
+    this.onToolExecutionStart = (event) => this.toolExecutionStart(event);
+    this.onToolExecutionEnd = (event) => this.toolExecutionEnd(event);
+    // Older v7 betas (< beta.111) emit these names. Kept as thin aliases so
+    // applications pinned to those betas continue to work.
+    this.onToolCallStart = (event) => this.toolExecutionStart(event);
+    this.onToolCallFinish = (event) => this.toolExecutionEnd(event);
+    // ── language-model call (v7 beta.111+) ─────────────────────────────────
+    //
+    // `onLanguageModelCallStart` / `onLanguageModelCallEnd` are scoped to the
+    // model invocation only and exclude later client-side tool execution.
+    // Raindrop already spans at the operation + step level, so these are
+    // intentional no-ops — declared so the dispatcher's `mergeCallbacks` sees
+    // them and so we don't accidentally rely on them later.
+    //
+    // Defined as no-ops rather than omitted so adding logic here later is a
+    // strictly additive change.
+    this.onLanguageModelCallStart = (_event) => {
     };
-    // ── 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);
+    this.onLanguageModelCallEnd = (_event) => {
     };
     // ── onChunk (streaming) ─────────────────────────────────────────────────
     this.onChunk = (event) => {
@@ -1902,6 +1937,53 @@ var RaindropTelemetryIntegration = class {
     }
     return void 0;
   }
+  // ── tool execution start / end ──────────────────────────────────────────
+  //
+  // v7 < beta.111 dispatched `onToolCallStart` / `onToolCallFinish`.
+  // v7 >= beta.111 renamed them to `onToolExecutionStart` / `onToolExecutionEnd`
+  // (see https://github.com/vercel/ai/pull/14589). Event shape is identical.
+  // Both names are exposed and forward to a single implementation.
+  toolExecutionStart(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 });
+  }
+  toolExecutionEnd(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);
+  }
   finishGenerate(event, state) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
     if (state.rootSpan) {
@@ -2216,7 +2298,16 @@ function detectAISDKVersion(aiSDK) {
   return "4";
 }
 function hasStructuredTelemetryEvents(aiSDK) {
-  return isRecord(aiSDK) && isFunction(aiSDK["registerTelemetryIntegration"]) && isFunction(aiSDK["experimental_streamModelCall"]);
+  if (!isRecord(aiSDK)) return false;
+  const hasRegister = isFunction(aiSDK["registerTelemetry"]) || isFunction(aiSDK["registerTelemetryIntegration"]);
+  const hasV7Marker = isFunction(aiSDK["experimental_streamLanguageModelCall"]) || isFunction(aiSDK["experimental_streamModelCall"]);
+  return hasRegister && hasV7Marker;
+}
+function resolveRegisterTelemetry(aiSDK) {
+  var _a;
+  if (!isRecord(aiSDK)) return void 0;
+  const fn = (_a = aiSDK["registerTelemetry"]) != null ? _a : aiSDK["registerTelemetryIntegration"];
+  return isFunction(fn) ? fn : void 0;
 }
 function asVercelSchema(jsonSchemaObj) {
   const validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
@@ -2857,31 +2948,44 @@ function wrapAISDK(aiSDK, deps) {
         properties: wrapTimeCtx.properties
       }
     });
-    const registerFn = aiSDK["registerTelemetryIntegration"];
-    if (isFunction(registerFn)) {
+    const registerFn = resolveRegisterTelemetry(aiSDK);
+    if (registerFn) {
       registerFn(integration);
     }
     if (debug) {
-      console.log("[raindrop-ai/ai-sdk] nativeTelemetry: registered RaindropTelemetryIntegration (no Proxy)");
+      console.log(
+        "[raindrop-ai/ai-sdk] nativeTelemetry: registered RaindropTelemetryIntegration (Proxy installed for per-call metadata propagation)"
+      );
     }
     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 jsonSchemaFactory = selfDiagnostics2 ? resolveJsonSchemaFactory(aiSDK) : void 0;
+    const metadataAwareOps = /* @__PURE__ */ new Set([
+      "generateText",
+      "streamText",
+      "generateObject",
+      "streamObject",
+      "embed",
+      "embedMany",
+      "rerank"
+    ]);
+    const selfDiagnosticsOps = /* @__PURE__ */ new Set(["generateText", "streamText"]);
+    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" || !metadataAwareOps.has(prop) || !isFunction(original)) {
+          return original;
+        }
+        const propName = prop;
+        return (...callArgs) => {
+          var _a2, _b2, _c2;
+          const arg = callArgs[0];
+          const callMetadata = readRaindropCallMetadataFromArgs(callArgs);
+          const callOriginal = () => original.call(aiSDK, ...callArgs);
+          if (selfDiagnostics2 && selfDiagnosticsOps.has(propName) && isRecord(arg)) {
             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 perCallEventIdExplicit = (_b2 = (_a2 = callMetadata == null ? void 0 : callMetadata.eventId) != null ? _a2 : callMeta.eventId) != null ? _b2 : wrapTimeCtx.eventId;
             const perCallEventId = perCallEventIdExplicit != null ? perCallEventIdExplicit : randomUUID();
             const perCallEventIdGenerated = !perCallEventIdExplicit;
             const perCallCtx = {
@@ -2918,12 +3022,25 @@ function wrapAISDK(aiSDK, deps) {
                 metadata: mergedMetadata
               }
             };
-            return original.call(aiSDK, ...callArgs);
-          };
-        }
-      });
-    }
-    return aiSDK;
+            const mergedAlsMetadata = {
+              ...callMetadata != null ? callMetadata : {},
+              eventId: perCallEventId,
+              eventIdGenerated: perCallEventIdGenerated || (callMetadata == null ? void 0 : callMetadata.eventIdGenerated),
+              rawMetadata: {
+                ...(_c2 = callMetadata == null ? void 0 : callMetadata.rawMetadata) != null ? _c2 : {},
+                "raindrop.eventId": perCallEventId,
+                ...perCallEventIdGenerated ? { "raindrop.internal.eventIdGenerated": "true" } : {}
+              }
+            };
+            return runWithRaindropCallMetadata(mergedAlsMetadata, callOriginal);
+          }
+          if (callMetadata) {
+            return runWithRaindropCallMetadata(callMetadata, callOriginal);
+          }
+          return callOriginal();
+        };
+      }
+    });
   }
   const instrumentedOps = /* @__PURE__ */ new Set([
     "generateText",
@@ -4007,7 +4124,7 @@ function extractNestedTokens(usage, key) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.0.25"};
+  version: "0.0.26"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -4244,4 +4361,4 @@ function createRaindropAISDK(opts) {
   };
 }
 
-export { RaindropTelemetryIntegration, _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, withCurrent };
+export { RaindropTelemetryIntegration, _resetRaindropCallMetadataStorage, _resetWarnedMissingUserId, createRaindropAISDK, currentSpan, eventMetadata, eventMetadataFromChatRequest, getContextManager, getCurrentRaindropCallMetadata, readRaindropCallMetadataFromArgs, runWithRaindropCallMetadata, withCurrent };

package/dist/{index-sxjvhkYW.d.mts → index-7aDHuHHR.d.mts}

@@ -224,22 +224,16 @@ declare class TraceShipper extends TraceShipper$1 {
     constructor(opts: ConstructorParameters<typeof TraceShipper$1>[0]);
 }
 
-/**
- * Raindrop TelemetryIntegration for AI SDK v7+
- *
- * Implements the AI SDK's TelemetryIntegration interface to capture traces and
- * events natively, replacing the Proxy-based wrapping used for v4-v6.
- *
- * Modeled after the upstream OpenTelemetryIntegration but uses Raindrop's
- * TraceShipper (OTLP/HTTP) + EventShipper instead of the OTel Tracer API.
- */
-
 type Listener<T> = (event: T) => PromiseLike<void> | void;
 interface TelemetryIntegration {
     onStart?: Listener<any>;
     onStepStart?: Listener<any>;
+    onToolExecutionStart?: Listener<any>;
+    onToolExecutionEnd?: Listener<any>;
     onToolCallStart?: Listener<any>;
     onToolCallFinish?: Listener<any>;
+    onLanguageModelCallStart?: Listener<any>;
+    onLanguageModelCallEnd?: Listener<any>;
     onChunk?: Listener<any>;
     onStepFinish?: Listener<any>;
     onEmbedStart?: Listener<any>;
@@ -287,8 +281,14 @@ declare class RaindropTelemetryIntegration implements TelemetryIntegration {
     private extractInputText;
     onStart: (event: any) => void;
     onStepStart: (event: any) => void;
+    private toolExecutionStart;
+    private toolExecutionEnd;
+    onToolExecutionStart: (event: any) => void;
+    onToolExecutionEnd: (event: any) => void;
     onToolCallStart: (event: any) => void;
     onToolCallFinish: (event: any) => void;
+    onLanguageModelCallStart: (_event: any) => void;
+    onLanguageModelCallEnd: (_event: any) => void;
     onChunk: (event: any) => void;
     onStepFinish: (event: any) => void;
     onEmbedStart: (event: any) => void;
@@ -309,6 +309,65 @@ type IdentifyInput = {
     traits?: Record<string, unknown>;
 };
 
+type RaindropCallMetadata = {
+    userId?: string;
+    eventId?: string;
+    /** True when the eventId was auto-generated by `eventMetadata()` rather than user-provided. */
+    eventIdGenerated?: boolean;
+    convoId?: string;
+    eventName?: string;
+    properties?: Record<string, unknown>;
+    /**
+     * Raw `metadata` record, preserved so the integration can write the
+     * full set of `raindrop.*` keys onto root spans (the trace shipper
+     * relies on this to surface metadata in the dashboard span attributes).
+     */
+    rawMetadata?: Record<string, unknown>;
+};
+declare global {
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => {
+        getStore(): T | undefined;
+        run<R>(store: T, callback: () => R): R;
+        enterWith?(store: T): void;
+    }) | undefined;
+}
+/** Test helper — allow tests to drop a stale fallback storage between runs. */
+declare function _resetRaindropCallMetadataStorage(): void;
+/**
+ * Returns the active per-call Raindrop metadata, or `undefined` if no
+ * call is currently in scope. Safe to call from any telemetry callback.
+ */
+declare function getCurrentRaindropCallMetadata(): RaindropCallMetadata | undefined;
+/**
+ * Runs `fn` with `metadata` bound as the active per-call Raindrop metadata.
+ * Visible to nested async work via `AsyncLocalStorage` when available.
+ */
+declare function runWithRaindropCallMetadata<R>(metadata: RaindropCallMetadata, fn: () => R): R;
+/**
+ * Inspect the first argument to an AI SDK function call (the call
+ * options object) and pull out any Raindrop metadata routed via one of:
+ *
+ *   1. top-level `metadata` — convention inherited from the v4-v6 Proxy
+ *      path (`extractRaindropCallOptions` in `wrap/wrapAISDK.ts`). Some
+ *      callers route `eventMetadata()` here to bypass framework-specific
+ *      `experimental_telemetry` typings;
+ *   2. `telemetry.metadata` — the v7 beta.111+ stable name (anticipated;
+ *      the v7 dispatcher does not currently forward `metadata`, but the
+ *      shape is what users will pass once it lands);
+ *   3. `experimental_telemetry.metadata` — the documented and currently
+ *      working channel for v6 + every published v7 beta.
+ *
+ * Priority is `(1) > (2) > (3)` to stay consistent with the v4-v6 path's
+ * `extractRaindropCallOptions`. If you ever change this order, the
+ * self-diagnostics injection in `wrapAISDK.ts` (which mutates the v3
+ * source only) becomes a re-read hazard — see the comment by
+ * `mergedAlsMetadata` in that file.
+ *
+ * Returns `undefined` when there is no Raindrop metadata to propagate,
+ * so callers can skip the ALS push entirely.
+ */
+declare function readRaindropCallMetadataFromArgs(args: readonly unknown[]): RaindropCallMetadata | undefined;
+
 declare function _resetWarnedMissingUserId(): void;
 
 /**
@@ -688,4 +747,4 @@ type RaindropAISDKClient = {
 };
 declare function createRaindropAISDK(opts: RaindropAISDKOptions): RaindropAISDKClient;
 
-export { type AISDKChatRequestLike as A, type BuildEventPatch as B, ContextManager as C, type EndSpanArgs as E, type IdentifyInput as I, type RaindropAISDKClient as R, type SelfDiagnosticsOptions as S, type TraceSpan as T, type WrapAISDKOptions as W, _resetWarnedMissingUserId as _, type AISDKChatRequestMessageLike as a, type AISDKMessage as b, type AgentCallMetadata as c, type AgentWithMetadata as d, type Attachment as e, type ContextSpan as f, type CreateSpanArgs as g, type EventBuilder as h, type EventMetadataOptions as i, type RaindropAISDKContext as j, type RaindropAISDKOptions as k, RaindropTelemetryIntegration as l, type RaindropTelemetryIntegrationOptions as m, type SelfDiagnosticsSignalDefinition as n, type SelfDiagnosticsSignalDefinitions as o, type StartSpanArgs as p, type WrappedAI as q, type WrappedAISDK as r, createRaindropAISDK as s, currentSpan as t, eventMetadata as u, eventMetadataFromChatRequest as v, getContextManager as w, withCurrent as x };
+export { type AISDKChatRequestLike as A, type BuildEventPatch as B, ContextManager as C, readRaindropCallMetadataFromArgs as D, type EndSpanArgs as E, runWithRaindropCallMetadata as F, withCurrent as G, type IdentifyInput as I, type RaindropAISDKClient as R, type SelfDiagnosticsOptions as S, type TraceSpan as T, type WrapAISDKOptions as W, _resetRaindropCallMetadataStorage as _, type AISDKChatRequestMessageLike as a, type AISDKMessage as b, type AgentCallMetadata as c, type AgentWithMetadata as d, type Attachment as e, type ContextSpan as f, type CreateSpanArgs as g, type EventBuilder as h, type EventMetadataOptions as i, type RaindropAISDKContext as j, type RaindropAISDKOptions as k, type RaindropCallMetadata as l, RaindropTelemetryIntegration as m, type RaindropTelemetryIntegrationOptions as n, type SelfDiagnosticsSignalDefinition as o, type SelfDiagnosticsSignalDefinitions as p, type StartSpanArgs as q, type WrappedAI as r, type WrappedAISDK as s, _resetWarnedMissingUserId as t, createRaindropAISDK as u, currentSpan as v, eventMetadata as w, eventMetadataFromChatRequest as x, getContextManager as y, getCurrentRaindropCallMetadata as z };