@raindrop-ai/ai-sdk 0.0.31 → 0.0.33

package/dist/index.node.js

@@ -1024,7 +1024,7 @@ globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = async_hooks.AsyncLocalStorage;
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.0.31"};
+  version: "0.0.33"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -1807,6 +1807,25 @@ var RaindropTelemetryIntegration = class {
      * (the `event.callId` can be the same for parallel sibling tools).
      */
     this.priorParentContexts = /* @__PURE__ */ new Map();
+    // ── lifecycle ─────────────────────────────────────────────────────────────
+    //
+    // The shippers buffer spans/events and flush on a timer, so a short-lived
+    // script (e.g. a single `generateText` then `process.exit`) can exit before
+    // anything ships. Expose `flush`/`shutdown` on the integration itself so the
+    // value returned by `raindrop()` is self-sufficient — callers can keep the
+    // reference they pass to `registerTelemetry` and `await rd.flush()` before
+    // exiting, without also constructing a separate client.
+    /** Flush any buffered events and trace spans to their destinations. */
+    this.flush = async () => {
+      await Promise.all([this.eventShipper.flush(), this.traceShipper.flush()]);
+    };
+    /** Flush and stop the background flush timers. */
+    this.shutdown = async () => {
+      await Promise.all([
+        this.eventShipper.shutdown(),
+        this.traceShipper.shutdown()
+      ]);
+    };
     // ── onStart ─────────────────────────────────────────────────────────────
     this.onStart = (event) => {
       var _a, _b, _c, _d, _e;
@@ -2091,6 +2110,7 @@ var RaindropTelemetryIntegration = class {
           attrInt("gen_ai.usage.output_tokens", usage.outputTokens)
         );
       }
+      this.emitProviderExecutedToolSpans(event, state);
       this.traceShipper.endSpan(state.stepSpan, { attributes: outputAttrs });
       state.stepSpan = void 0;
       state.stepParent = void 0;
@@ -2199,8 +2219,56 @@ var RaindropTelemetryIntegration = class {
       if (state.subagentToolCallSpan) {
         this.traceShipper.endSpan(state.subagentToolCallSpan, { error: actualError });
       }
+      const isEmbed = state.operationId === "ai.embed" || state.operationId === "ai.embedMany";
+      if (!isEmbed) {
+        this.finalizeGenerateEvent(state, state.accumulatedText || void 0, void 0);
+      }
       this.cleanup(event.callId);
     };
+    // ── onAbort ─────────────────────────────────────────────────────────────
+    //
+    // Dispatched by the v7 canary line (post-beta.116) when a `streamText` call
+    // is cancelled via its `AbortSignal`. On abort the SDK fires neither `onEnd`
+    // nor `onError`, so without this every open span would leak and the event
+    // would hang forever in its `isPending` state. We close every open span with
+    // an `ai.response.aborted` marker (no error status — an abort is not a model
+    // failure) and flush the partial event.
+    this.onAbort = (event) => {
+      const callId = event == null ? void 0 : event.callId;
+      if (!callId) return;
+      const state = this.getState(callId);
+      if (!state) return;
+      const abortedAttr = attrString("ai.response.aborted", "true");
+      if (state.stepSpan) {
+        this.traceShipper.endSpan(state.stepSpan, { attributes: [abortedAttr] });
+        state.stepSpan = void 0;
+        state.stepParent = void 0;
+      }
+      for (const embedSpan of state.embedSpans.values()) {
+        this.traceShipper.endSpan(embedSpan, { attributes: [abortedAttr] });
+      }
+      state.embedSpans.clear();
+      for (const toolCallId of state.parentContextToolCallIds) {
+        this.priorParentContexts.delete(toolCallId);
+      }
+      state.parentContextToolCallIds.clear();
+      for (const toolSpan of state.toolSpans.values()) {
+        this.traceShipper.endSpan(toolSpan, { attributes: [abortedAttr] });
+      }
+      state.toolSpans.clear();
+      if (state.rootSpan) {
+        this.traceShipper.endSpan(state.rootSpan, {
+          attributes: [abortedAttr, attrInt("ai.toolCall.count", state.toolCallCount)]
+        });
+      }
+      if (state.subagentToolCallSpan) {
+        this.traceShipper.endSpan(state.subagentToolCallSpan, {
+          attributes: [abortedAttr]
+        });
+      }
+      this.finalizeGenerateEvent(state, state.accumulatedText || void 0, void 0);
+      this.cleanup(callId);
+    };
     // ── executeTool ─────────────────────────────────────────────────────────
     this.executeTool = async ({
       callId,
@@ -2358,17 +2426,86 @@ var RaindropTelemetryIntegration = class {
     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))] : [];
+    const outcome = "toolOutput" in event ? event.toolOutput.type === "tool-result" ? { success: true, output: event.toolOutput.output } : { success: false, error: event.toolOutput.error } : event.success ? { success: true, output: event.output } : { success: false, error: event.error };
+    if (outcome.success) {
+      const outputAttrs = state.recordOutputs ? [attrString("ai.toolCall.result", safeJsonWithUint8(outcome.output))] : [];
       this.traceShipper.endSpan(toolSpan, { attributes: outputAttrs });
     } else {
-      this.traceShipper.endSpan(toolSpan, { error: event.error });
+      this.traceShipper.endSpan(toolSpan, { error: outcome.error });
     }
     this.emitLive(state, "tool_result", event.toolCall.toolName);
     state.toolSpans.delete(event.toolCall.toolCallId);
   }
+  // ── provider-executed tool calls ─────────────────────────────────────────
+  //
+  // Provider-executed (server-side) tools — e.g. Anthropic's hosted
+  // `web_search` (`anthropic.web_search_20250305`) — are run by the provider,
+  // not by the AI SDK. They therefore never flow through the client
+  // `onToolExecutionStart`/`onToolExecutionEnd` callbacks that emit our
+  // `ai.toolCall` spans; the SDK only surfaces them as `tool-call` /
+  // `tool-result` content parts on the step (carrying `providerExecuted: true`).
+  // Without this, such calls are invisible in every trace backend.
+  //
+  // At step finish we synthesize the same `ai.toolCall` span shape we emit for
+  // client tools (name `ai.toolCall`, `operationId: "ai.toolCall"`, attrs
+  // `ai.toolCall.name`/`id`/`args`/`result`), parented under the step span, so
+  // downstream ingestion maps them to a tool span with no special-casing.
+  //
+  // Client-executed tools are excluded (`providerExecuted` falsy) — they were
+  // already spanned during execution, so this never double-emits.
+  emitProviderExecutedToolSpans(event, state) {
+    if (!state.stepParent) return;
+    const content = Array.isArray(event.content) ? event.content : [];
+    const providerToolCalls = content.filter(
+      (part) => (part == null ? void 0 : part.type) === "tool-call" && part.providerExecuted === true
+    );
+    if (providerToolCalls.length === 0) return;
+    const resultsByCallId = /* @__PURE__ */ new Map();
+    for (const part of content) {
+      if (((part == null ? void 0 : part.type) === "tool-result" || (part == null ? void 0 : part.type) === "tool-error") && typeof part.toolCallId === "string") {
+        resultsByCallId.set(part.toolCallId, part);
+      }
+    }
+    for (const call of providerToolCalls) {
+      const { operationName, resourceName } = opName(
+        "ai.toolCall",
+        state.functionId
+      );
+      const inputAttrs = state.recordInputs ? [attrString("ai.toolCall.args", safeJsonWithUint8(call.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", call.toolName),
+          attrString("ai.toolCall.id", call.toolCallId),
+          attrString("ai.toolCall.providerExecuted", "true"),
+          ...inputAttrs
+        ]
+      });
+      state.toolCallCount += 1;
+      this.emitLive(state, "tool_start", call.toolName, { args: call.input });
+      const resultPart = resultsByCallId.get(call.toolCallId);
+      if ((resultPart == null ? void 0 : resultPart.type) === "tool-error") {
+        this.traceShipper.endSpan(toolSpan, { error: resultPart.error });
+      } else {
+        const outputAttrs = state.recordOutputs && resultPart && "output" in resultPart ? [
+          attrString(
+            "ai.toolCall.result",
+            safeJsonWithUint8(resultPart.output)
+          )
+        ] : [];
+        this.traceShipper.endSpan(toolSpan, { attributes: outputAttrs });
+      }
+      this.emitLive(state, "tool_result", call.toolName);
+    }
+  }
   finishGenerate(event, state) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    var _a, _b, _c, _d, _e, _f;
     if (state.rootSpan) {
       const outputAttrs = [];
       if (state.recordOutputs) {
@@ -2416,38 +2553,47 @@ var RaindropTelemetryIntegration = class {
       );
       this.traceShipper.endSpan(state.rootSpan, { attributes: outputAttrs });
     }
+    this.finalizeGenerateEvent(
+      state,
+      (_e = event.text) != null ? _e : state.accumulatedText || void 0,
+      (_f = event.response) == null ? void 0 : _f.modelId
+    );
+  }
+  /**
+   * Patch the Raindrop event for a completed, aborted, or errored text
+   * generation so it leaves the `isPending` state. Shared by `onFinish`/`onEnd`,
+   * `onAbort`, and `onError`.
+   */
+  finalizeGenerateEvent(state, output, model) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const suppressSubagentEvent = state.subagentName !== void 0 && state.subagentToolCallSpan !== void 0;
-    if (this.sendEvents && !suppressSubagentEvent) {
-      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}`
-            );
-          }
-        });
+    if (!this.sendEvents || suppressSubagentEvent) return;
+    const callMeta = this.extractRaindropMetadata(state.metadata);
+    const userId = (_b = callMeta.userId) != null ? _b : (_a = this.defaultContext) == null ? void 0 : _a.userId;
+    if (!userId) return;
+    const eventName = (_e = (_d = callMeta.eventName) != null ? _d : (_c = this.defaultContext) == null ? void 0 : _c.eventName) != null ? _e : state.operationId;
+    const input = state.inputText;
+    const properties = {
+      ...(_f = this.defaultContext) == null ? void 0 : _f.properties,
+      ...callMeta.properties
+    };
+    const convoId = (_h = callMeta.convoId) != null ? _h : (_g = this.defaultContext) == null ? void 0 : _g.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;
@@ -2472,22 +2618,9 @@ var RaindropTelemetryIntegration = class {
   }
 };
 
-// src/internal/traces.ts
-var TraceShipper2 = class extends TraceShipper {
-  constructor(opts) {
-    var _a, _b, _c;
-    super({
-      ...opts,
-      sdkName: (_a = opts.sdkName) != null ? _a : "ai-sdk",
-      serviceName: (_b = opts.serviceName) != null ? _b : "raindrop.ai-sdk",
-      serviceVersion: (_c = opts.serviceVersion) != null ? _c : libraryVersion
-    });
-  }
-};
-
-// src/internal/wrap/wrapAISDK.ts
-var AGENT_REPORTING_TOOL_NAME_DEFAULT = "__raindrop_report";
-var AGENT_REPORTING_SIGNALS_DEFAULT = {
+// src/internal/self-diagnostics.ts
+var SELF_DIAGNOSTICS_TOOL_NAME_DEFAULT = "__raindrop_report";
+var SELF_DIAGNOSTICS_SIGNALS_DEFAULT = {
   missing_context: {
     description: "You cannot complete the task because critical information, credentials, or access is missing and the user cannot provide it. Do NOT report this for normal clarifying questions \u2014 only when you are blocked.",
     sentiment: "NEGATIVE"
@@ -2505,7 +2638,194 @@ var AGENT_REPORTING_SIGNALS_DEFAULT = {
     sentiment: "NEGATIVE"
   }
 };
-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 SELF_DIAGNOSTICS_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.";
+function normalizeString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function normalizeSelfDiagnosticsSignals(signals) {
+  if (!signals) return SELF_DIAGNOSTICS_SIGNALS_DEFAULT;
+  const normalizedEntries = Object.entries(signals).map(([key, value]) => {
+    var _a;
+    const signalKey = key.trim();
+    if (!signalKey || !value || typeof value !== "object") return void 0;
+    const description = (_a = value.description) == null ? void 0 : _a.trim();
+    if (!description) return void 0;
+    const sentiment = value.sentiment;
+    return [
+      signalKey,
+      {
+        description,
+        ...sentiment === "POSITIVE" || sentiment === "NEGATIVE" ? { sentiment } : {}
+      }
+    ];
+  }).filter(
+    (entry) => entry !== void 0
+  );
+  if (normalizedEntries.length === 0) return SELF_DIAGNOSTICS_SIGNALS_DEFAULT;
+  return Object.fromEntries(normalizedEntries);
+}
+function resolveSelfDiagnosticsConfig(options) {
+  var _a, _b;
+  const signalDefinitions = normalizeSelfDiagnosticsSignals(options.signals);
+  const signalKeys = Object.keys(signalDefinitions);
+  const signalDescriptions = {};
+  const signalSentiments = {};
+  for (const signalKey of signalKeys) {
+    const definition = signalDefinitions[signalKey];
+    if (!definition) continue;
+    signalDescriptions[signalKey] = definition.description;
+    signalSentiments[signalKey] = definition.sentiment;
+  }
+  const customGuidance = ((_a = options.guidance) == null ? void 0 : _a.trim()) || "";
+  const toolName = ((_b = options.toolName) == null ? void 0 : _b.trim()) || SELF_DIAGNOSTICS_TOOL_NAME_DEFAULT;
+  const signalList = signalKeys.map((signalKey) => {
+    const sentiment = signalSentiments[signalKey];
+    const sentimentTag = sentiment ? ` [${sentiment.toLowerCase()}]` : "";
+    return `- ${signalKey}: ${signalDescriptions[signalKey]}${sentimentTag}`;
+  }).join("\n");
+  const guidanceBlock = customGuidance ? `
+Additional guidance: ${customGuidance}
+` : "";
+  const toolDescription = `${SELF_DIAGNOSTICS_TOOL_PREAMBLE}
+
+When to call:
+- You are blocked from completing the task due to missing information or access that the user cannot provide.
+- A tool is persistently failing across multiple attempts, not just a single transient error.
+- The task requires a tool, permission, or capability you do not have.
+- You genuinely cannot deliver what the user asked for despite trying.
+
+When NOT to call:
+- Normal clarifying questions or back-and-forth with the user.
+- A single tool error that you can recover from or retry.
+- You successfully completed the task, even if it was difficult.
+- Policy refusals or content filtering \u2014 those are working as intended.
+
+Rules:
+1. Pick the single best category.
+2. Do not fabricate issues. Only report what is evident from the conversation.
+3. Err on the side of NOT calling this tool. When in doubt, help the user instead.
+${guidanceBlock}
+Categories:
+` + signalList;
+  return {
+    toolName,
+    toolDescription,
+    signalKeys,
+    signalKeySet: new Set(signalKeys),
+    signalDescriptions,
+    signalSentiments
+  };
+}
+function normalizeSelfDiagnosticsConfig(options) {
+  if (!(options == null ? void 0 : options.enabled)) return void 0;
+  return resolveSelfDiagnosticsConfig(options);
+}
+function asVercelSchema(inputSchema) {
+  const validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
+  const schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
+  return {
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: inputSchema,
+    validate: (value) => ({ success: true, value })
+  };
+}
+function resolveStandaloneEventId(options) {
+  var _a, _b, _c, _d, _e, _f;
+  return (_f = (_d = (_b = normalizeString((_a = options.getEventId) == null ? void 0 : _a.call(options))) != null ? _b : normalizeString(options.eventId)) != null ? _d : normalizeString((_c = getContextManager().getParentSpanIds()) == null ? void 0 : _c.eventId)) != null ? _f : normalizeString((_e = getCurrentRaindropCallMetadata()) == null ? void 0 : _e.eventId);
+}
+function createSelfDiagnosticsToolDefinition(args) {
+  const { config, eventShipper, getEventId, aiSDKVersion, debug } = args;
+  const inputJsonSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      category: {
+        type: "string",
+        enum: config.signalKeys,
+        description: "The single best-matching category from the list above."
+      },
+      detail: {
+        type: "string",
+        description: "One sentence of factual context: what happened and why it matters. Do not include PII or secrets."
+      }
+    },
+    required: ["category", "detail"]
+  };
+  const inputSchema = asVercelSchema(inputJsonSchema);
+  const execute = async (rawInput) => {
+    var _a, _b;
+    const fallbackCategory = (_a = config.signalKeys[0]) != null ? _a : "unknown";
+    const categoryCandidate = normalizeString(rawInput == null ? void 0 : rawInput.category);
+    const category = categoryCandidate && config.signalKeySet.has(categoryCandidate) ? categoryCandidate : fallbackCategory;
+    const detail = normalizeString(rawInput == null ? void 0 : rawInput.detail);
+    const eventId = getEventId();
+    if (!eventId) {
+      const message = "self diagnostics signal skipped: missing eventId. Pass eventId or getEventId when creating the tool.";
+      if (args.onMissingEventId === "throw") {
+        throw new Error(`[raindrop-ai/ai-sdk] ${message}`);
+      }
+      if (((_b = args.onMissingEventId) != null ? _b : "warn") === "warn") {
+        console.warn(`[raindrop-ai/ai-sdk] ${message}`);
+      }
+      return { acknowledged: false, category, reason: "missing_event_id" };
+    }
+    void eventShipper.trackSignal({
+      eventId,
+      name: `self diagnostics - ${category}`,
+      type: "agent",
+      sentiment: config.signalSentiments[category],
+      properties: {
+        source: "agent_reporting_tool",
+        category,
+        signal_description: config.signalDescriptions[category],
+        ...aiSDKVersion ? { ai_sdk_version: aiSDKVersion } : {},
+        ...detail ? { detail } : {}
+      }
+    }).catch((error) => {
+      if (debug) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[raindrop-ai/ai-sdk] selfDiagnostics signal dispatch failed: ${message}`);
+      }
+    });
+    return { acknowledged: true, category };
+  };
+  return {
+    name: config.toolName,
+    description: config.toolDescription,
+    parameters: inputSchema,
+    inputSchema,
+    execute
+  };
+}
+function createStandaloneSelfDiagnosticsTool(args) {
+  const config = resolveSelfDiagnosticsConfig(args.options);
+  return createSelfDiagnosticsToolDefinition({
+    config,
+    eventShipper: args.eventShipper,
+    getEventId: () => resolveStandaloneEventId(args.options),
+    onMissingEventId: args.options.onMissingEventId,
+    debug: args.debug
+  });
+}
+
+// src/internal/traces.ts
+var TraceShipper2 = class extends TraceShipper {
+  constructor(opts) {
+    var _a, _b, _c;
+    super({
+      ...opts,
+      sdkName: (_a = opts.sdkName) != null ? _a : "ai-sdk",
+      serviceName: (_b = opts.serviceName) != null ? _b : "raindrop.ai-sdk",
+      serviceVersion: (_c = opts.serviceVersion) != null ? _c : libraryVersion
+    });
+  }
+};
+
+// src/internal/wrap/wrapAISDK.ts
 var pendingStoresByShipper = /* @__PURE__ */ new WeakMap();
 var PendingToolSpanStore = class _PendingToolSpanStore {
   constructor() {
@@ -2609,85 +2929,6 @@ function mergeContexts(wrapTime, callTime) {
   }
   return result;
 }
-function normalizeSelfDiagnosticsSignals(signals) {
-  if (!signals) return AGENT_REPORTING_SIGNALS_DEFAULT;
-  const normalizedEntries = Object.entries(signals).map(([key, value]) => {
-    var _a;
-    const signalKey = key.trim();
-    if (!signalKey || !value || typeof value !== "object") return void 0;
-    const description = (_a = value.description) == null ? void 0 : _a.trim();
-    if (!description) return void 0;
-    const sentiment = value.sentiment;
-    return [
-      signalKey,
-      {
-        description,
-        ...sentiment === "POSITIVE" || sentiment === "NEGATIVE" ? { sentiment } : {}
-      }
-    ];
-  }).filter(
-    (entry) => entry !== void 0
-  );
-  if (normalizedEntries.length === 0) return AGENT_REPORTING_SIGNALS_DEFAULT;
-  return Object.fromEntries(normalizedEntries);
-}
-function normalizeSelfDiagnosticsConfig(options) {
-  var _a, _b;
-  if (!(options == null ? void 0 : options.enabled)) return void 0;
-  const signalDefinitions = normalizeSelfDiagnosticsSignals(options.signals);
-  const signalKeys = Object.keys(signalDefinitions);
-  const signalDescriptions = {};
-  const signalSentiments = {};
-  for (const signalKey of signalKeys) {
-    const def = signalDefinitions[signalKey];
-    if (!def) continue;
-    signalDescriptions[signalKey] = def.description;
-    signalSentiments[signalKey] = def.sentiment;
-  }
-  const customGuidanceText = ((_a = options.guidance) == null ? void 0 : _a.trim()) || "";
-  const toolName = ((_b = options.toolName) == null ? void 0 : _b.trim()) || AGENT_REPORTING_TOOL_NAME_DEFAULT;
-  const signalList = signalKeys.map((signalKey) => {
-    const sentiment = signalSentiments[signalKey];
-    const sentimentTag = sentiment ? ` [${sentiment.toLowerCase()}]` : "";
-    return `- ${signalKey}: ${signalDescriptions[signalKey]}${sentimentTag}`;
-  }).join("\n");
-  const guidanceBlock = customGuidanceText ? `
-Additional guidance: ${customGuidanceText}
-` : "";
-  const toolDescription = `${AGENT_REPORTING_TOOL_PREAMBLE}
-
-When to call:
-- You are blocked from completing the task due to missing information or access that the user cannot provide.
-- A tool is persistently failing across multiple attempts, not just a single transient error.
-- The task requires a tool, permission, or capability you do not have.
-- You genuinely cannot deliver what the user asked for despite trying.
-
-When NOT to call:
-- Normal clarifying questions or back-and-forth with the user.
-- A single tool error that you can recover from or retry.
-- You successfully completed the task, even if it was difficult.
-- Policy refusals or content filtering \u2014 those are working as intended.
-
-Rules:
-1. Pick the single best category.
-2. Do not fabricate issues. Only report what is evident from the conversation.
-3. Err on the side of NOT calling this tool. When in doubt, help the user instead.
-${guidanceBlock}
-Categories:
-${signalList}`;
-  return {
-    toolName,
-    toolDescription,
-    signalKeys,
-    signalKeySet: new Set(signalKeys),
-    signalDescriptions,
-    signalSentiments
-  };
-}
-function resolveJsonSchemaFactory(aiSDK) {
-  if (!isRecord(aiSDK) || !isFunction(aiSDK["jsonSchema"])) return void 0;
-  return aiSDK["jsonSchema"];
-}
 function detectAISDKVersion(aiSDK) {
   if (!isRecord(aiSDK)) return "unknown";
   if (isFunction(aiSDK["jsonSchema"])) return "6";
@@ -2706,80 +2947,16 @@ function resolveRegisterTelemetry(aiSDK) {
   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");
-  const schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
-  return {
-    [schemaSymbol]: true,
-    [validatorSymbol]: true,
-    _type: void 0,
-    jsonSchema: jsonSchemaObj,
-    validate: (value) => ({ success: true, value })
-  };
-}
 function createSelfDiagnosticsTool(ctx) {
   const config = ctx.selfDiagnostics;
   if (!config) return void 0;
-  const schema = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      category: {
-        type: "string",
-        enum: config.signalKeys,
-        description: "The single best-matching category from the list above."
-      },
-      detail: {
-        type: "string",
-        description: "One sentence of factual context: what happened and why it matters. Do not include PII or secrets."
-      }
-    },
-    required: ["category", "detail"]
-  };
-  const parameters = asVercelSchema(schema);
-  let inputSchema = parameters;
-  if (ctx.jsonSchemaFactory) {
-    try {
-      inputSchema = ctx.jsonSchemaFactory(schema);
-    } catch (e) {
-      inputSchema = parameters;
-    }
-  }
-  const execute = async (rawInput) => {
-    var _a;
-    const input = isRecord(rawInput) ? rawInput : void 0;
-    const fallbackCategory = (_a = config.signalKeys[0]) != null ? _a : "unknown";
-    const categoryCandidate = typeof (input == null ? void 0 : input["category"]) === "string" ? input["category"].trim() : void 0;
-    const category = categoryCandidate && config.signalKeySet.has(categoryCandidate) ? categoryCandidate : fallbackCategory;
-    const detail = typeof (input == null ? void 0 : input["detail"]) === "string" ? input["detail"].trim() : "";
-    const signalDescription = config.signalDescriptions[category];
-    const signalSentiment = config.signalSentiments[category];
-    void ctx.eventShipper.trackSignal({
-      eventId: ctx.eventId,
-      name: `self diagnostics - ${category}`,
-      type: "agent",
-      sentiment: signalSentiment,
-      properties: {
-        source: "agent_reporting_tool",
-        category,
-        signal_description: signalDescription,
-        ai_sdk_version: ctx.aiSDKVersion,
-        ...detail ? { detail } : {}
-      }
-    }).catch((err) => {
-      if (ctx.debug) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.warn(`[raindrop-ai/ai-sdk] selfDiagnostics signal dispatch failed: ${msg}`);
-      }
-    });
-    return { acknowledged: true, category };
-  };
-  return {
-    description: config.toolDescription,
-    execute,
-    parameters,
-    inputSchema
-  };
+  return createSelfDiagnosticsToolDefinition({
+    config,
+    eventShipper: ctx.eventShipper,
+    getEventId: () => ctx.eventId,
+    aiSDKVersion: ctx.aiSDKVersion,
+    debug: ctx.debug
+  });
 }
 function getCurrentParentSpanContextSync() {
   return getContextManager().getParentSpanIds();
@@ -3006,7 +3183,6 @@ function setupOperation(params) {
     eventShipper,
     traceShipper,
     rootParentForChildren,
-    jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
     selfDiagnostics: operationSelfDiagnostics,
     aiSDKVersion: detectAISDKVersion(aiSDK)
   };
@@ -3355,7 +3531,6 @@ function wrapAISDK(aiSDK, deps) {
       );
     }
     const selfDiagnostics2 = normalizeSelfDiagnosticsConfig(deps.options.selfDiagnostics);
-    const jsonSchemaFactory = selfDiagnostics2 ? resolveJsonSchemaFactory(aiSDK) : void 0;
     const metadataAwareOps = /* @__PURE__ */ new Set([
       "generateText",
       "streamText",
@@ -3387,14 +3562,9 @@ function wrapAISDK(aiSDK, deps) {
             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"
             };
@@ -3596,7 +3766,6 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
       eventShipper: deps.eventShipper,
       traceShipper: deps.traceShipper,
       rootParentForChildren,
-      jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
       selfDiagnostics,
       aiSDKVersion: detectAISDKVersion(aiSDK)
     };
@@ -3804,7 +3973,6 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
       eventShipper: deps.eventShipper,
       traceShipper: deps.traceShipper,
       rootParentForChildren,
-      jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
       selfDiagnostics,
       aiSDKVersion: detectAISDKVersion(aiSDK)
     };
@@ -4620,6 +4788,14 @@ function createRaindropAISDK(opts) {
         traceShipper
       });
     },
+    createSelfDiagnosticsTool(options = {}) {
+      var _a2;
+      return createStandaloneSelfDiagnosticsTool({
+        options,
+        eventShipper,
+        debug: ((_a2 = opts.events) == null ? void 0 : _a2.debug) === true || envDebug
+      });
+    },
     createTelemetryIntegration(contextOrOptions) {
       const FLAT_CONTEXT_KEYS = [
         "userId",
@@ -4750,6 +4926,13 @@ function createRaindropAISDK(opts) {
     }
   };
 }
+function raindrop(options = {}) {
+  var _a;
+  const { context, subagentWrapping, writeKey, ...rest } = options;
+  const resolvedWriteKey = writeKey != null ? writeKey : typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a.RAINDROP_WRITE_KEY : void 0;
+  const client = createRaindropAISDK({ ...rest, writeKey: resolvedWriteKey });
+  return client.createTelemetryIntegration({ context, subagentWrapping });
+}
 
 // src/index.node.ts
 globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = async_hooks.AsyncLocalStorage;
@@ -4771,6 +4954,7 @@ exports.eventMetadataFromChatRequest = eventMetadataFromChatRequest;
 exports.getContextManager = getContextManager;
 exports.getCurrentParentToolContext = getCurrentParentToolContext;
 exports.getCurrentRaindropCallMetadata = getCurrentRaindropCallMetadata;
+exports.raindrop = raindrop;
 exports.readRaindropCallMetadataFromArgs = readRaindropCallMetadataFromArgs;
 exports.redactJsonAttributeValue = redactJsonAttributeValue;
 exports.redactSecretsInObject = redactSecretsInObject;