@raindrop-ai/ai-sdk 0.0.30 → 0.0.32

package/dist/index.workers.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.30"};
+  version: "0.0.32"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -2091,6 +2091,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;
@@ -2145,6 +2146,10 @@ var RaindropTelemetryIntegration = class {
       this.traceShipper.endSpan(embedSpan, { attributes: outputAttrs });
       state.embedSpans.delete(event.embedCallId);
     };
+    // v7 canary.159 renamed `onEmbedFinish` -> `onEmbedEnd`. Both names forward
+    // to the same implementation; the installed SDK only wires up whichever it
+    // knows about, so there is no double dispatch.
+    this.onEmbedEnd = (event) => this.onEmbedFinish(event);
     // ── onFinish ────────────────────────────────────────────────────────────
     this.onFinish = (event) => {
       const state = this.getState(event.callId);
@@ -2160,6 +2165,12 @@ var RaindropTelemetryIntegration = class {
       }
       this.cleanup(event.callId);
     };
+    // v7 < canary.159 dispatched `onFinish` as the operation finalizer; canary.159
+    // renamed it to `onEnd` (the same change renamed onEmbedFinish -> onEmbedEnd
+    // and onRerankFinish -> onRerankEnd). The event shape is unchanged, so this
+    // is a thin alias to one implementation. The installed SDK wires up whichever
+    // name it knows about, so old and new names never double dispatch.
+    this.onEnd = (event) => this.onFinish(event);
     // ── onError ─────────────────────────────────────────────────────────────
     this.onError = (error) => {
       var _a;
@@ -2357,6 +2368,74 @@ var RaindropTelemetryIntegration = class {
     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;
     if (state.rootSpan) {
@@ -2462,22 +2541,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"
@@ -2495,7 +2561,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() {
@@ -2599,85 +2852,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";
@@ -2696,80 +2870,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();
@@ -2996,7 +3106,6 @@ function setupOperation(params) {
     eventShipper,
     traceShipper,
     rootParentForChildren,
-    jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
     selfDiagnostics: operationSelfDiagnostics,
     aiSDKVersion: detectAISDKVersion(aiSDK)
   };
@@ -3345,7 +3454,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",
@@ -3377,14 +3485,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"
             };
@@ -3586,7 +3689,6 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
       eventShipper: deps.eventShipper,
       traceShipper: deps.traceShipper,
       rootParentForChildren,
-      jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
       selfDiagnostics,
       aiSDKVersion: detectAISDKVersion(aiSDK)
     };
@@ -3794,7 +3896,6 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
       eventShipper: deps.eventShipper,
       traceShipper: deps.traceShipper,
       rootParentForChildren,
-      jsonSchemaFactory: resolveJsonSchemaFactory(aiSDK),
       selfDiagnostics,
       aiSDKVersion: detectAISDKVersion(aiSDK)
     };
@@ -4610,6 +4711,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",

package/dist/index.workers.mjs

@@ -1,4 +1,4 @@
-export { DEFAULT_REDACT_ATTRIBUTE_KEYS, DEFAULT_SECRET_KEY_NAMES, REDACTED_PLACEHOLDER, RaindropTelemetryIntegration, _resetParentToolContextStorage, _resetRaindropCallMetadataStorage, _resetWarnedMissingUserId, clearParentToolContext, createRaindropAISDK, currentSpan, defaultTransformSpan, enterParentToolContext, eventMetadata, eventMetadataFromChatRequest, getContextManager, getCurrentParentToolContext, getCurrentRaindropCallMetadata, readRaindropCallMetadataFromArgs, redactJsonAttributeValue, redactSecretsInObject, runWithParentToolContext, runWithRaindropCallMetadata, withCurrent } from './chunk-LM3XO4KR.mjs';
+export { DEFAULT_REDACT_ATTRIBUTE_KEYS, DEFAULT_SECRET_KEY_NAMES, REDACTED_PLACEHOLDER, RaindropTelemetryIntegration, _resetParentToolContextStorage, _resetRaindropCallMetadataStorage, _resetWarnedMissingUserId, clearParentToolContext, createRaindropAISDK, currentSpan, defaultTransformSpan, enterParentToolContext, eventMetadata, eventMetadataFromChatRequest, getContextManager, getCurrentParentToolContext, getCurrentRaindropCallMetadata, readRaindropCallMetadataFromArgs, redactJsonAttributeValue, redactSecretsInObject, runWithParentToolContext, runWithRaindropCallMetadata, withCurrent } from './chunk-YDMJ6ABM.mjs';
 import { AsyncLocalStorage } from 'async_hooks';
 
 if (!globalThis.RAINDROP_ASYNC_LOCAL_STORAGE) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raindrop-ai/ai-sdk",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "Standalone Vercel AI SDK integration for Raindrop (events + OTLP/HTTP JSON traces, no OTEL runtime)",
   "main": "dist/index.node.js",
   "module": "dist/index.node.mjs",
@@ -42,7 +42,7 @@
     "tsup": "^8.4.0",
     "tsx": "^4.20.3",
     "typescript": "^5.3.3",
-    "@raindrop-ai/core": "0.0.1"
+    "@raindrop-ai/core": "0.0.2"
   },
   "peerDependencies": {
     "ai": ">=4 <8"