@raindrop-ai/ai-sdk 0.0.28 → 0.0.30

package/dist/index.workers.js

@@ -4,7 +4,7 @@ var async_hooks = require('async_hooks');
 
 // src/index.workers.ts
 
-// ../core/dist/chunk-LMIWKHOH.js
+// ../core/dist/chunk-VUNUOE2X.js
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -227,6 +227,114 @@ function buildExportTraceServiceRequest(spans, serviceName = "raindrop.core", se
     ]
   };
 }
+var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
+var WORKSHOP_ENV_VAR = "RAINDROP_WORKSHOP";
+var DEFAULT_LOCAL_WORKSHOP_URL = "http://localhost:5899/v1/";
+function readEnvVar(name) {
+  var _a;
+  try {
+    const env = (_a = globalThis == null ? void 0 : globalThis.process) == null ? void 0 : _a.env;
+    if (env && typeof env[name] === "string" && env[name].length > 0) {
+      return env[name];
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function readWorkshopEnv() {
+  const raw = readEnvVar(WORKSHOP_ENV_VAR);
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  if (/^https?:\/\//i.test(trimmed)) return { url: trimmed };
+  if (/^(1|true|yes|on)$/i.test(trimmed)) return "enable";
+  if (/^(0|false|no|off)$/i.test(trimmed)) return "disable";
+  return void 0;
+}
+function isLocalDevHost(hostname) {
+  if (!hostname) return false;
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "::1") {
+    return true;
+  }
+  if (hostname.endsWith(".localhost")) return true;
+  return false;
+}
+function readRuntimeHostname() {
+  try {
+    const loc = globalThis == null ? void 0 : globalThis.location;
+    if (loc && typeof loc.hostname === "string" && loc.hostname.length > 0) {
+      return loc.hostname;
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function shouldAutoEnableLocalWorkshop() {
+  if (isLocalDevHost(readRuntimeHostname())) return true;
+  if (readEnvVar("NODE_ENV") === "development") return true;
+  return false;
+}
+function resolveLocalDebuggerBaseUrl(baseUrl) {
+  var _a, _b, _c;
+  if (baseUrl === null) return null;
+  if (typeof baseUrl === "string" && baseUrl.length > 0) {
+    return (_a = formatEndpoint(baseUrl)) != null ? _a : null;
+  }
+  const explicitUrlEnv = readEnvVar(LOCAL_DEBUGGER_ENV_VAR);
+  if (explicitUrlEnv) return (_b = formatEndpoint(explicitUrlEnv)) != null ? _b : null;
+  const workshopEnv = readWorkshopEnv();
+  if (workshopEnv === "disable") return null;
+  if (workshopEnv === "enable") return DEFAULT_LOCAL_WORKSHOP_URL;
+  if (workshopEnv && "url" in workshopEnv) return (_c = formatEndpoint(workshopEnv.url)) != null ? _c : null;
+  if (shouldAutoEnableLocalWorkshop()) return DEFAULT_LOCAL_WORKSHOP_URL;
+  return null;
+}
+function localDebuggerEnabled(baseUrl) {
+  return resolveLocalDebuggerBaseUrl(baseUrl) !== null;
+}
+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 mirrorPartialEventToLocalDebugger(event, options = {}) {
+  var _a;
+  const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
+  if (!baseUrl) return;
+  const headers = options.writeKey ? { Authorization: `Bearer ${options.writeKey}` } : {};
+  void postJson(`${baseUrl}events/track_partial`, event, headers, {
+    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: event.type,
+      timestamp: (_a = event.timestamp) != null ? _a : Date.now()
+    },
+    {},
+    {
+      maxAttempts: 1,
+      debug: (_b = options.debug) != null ? _b : false,
+      sdkName: options.sdkName
+    }
+  ).catch(() => {
+  });
+}
 function mergePatches(target, source) {
   var _a, _b, _c, _d;
   const out = { ...target, ...source };
@@ -244,7 +352,7 @@ var EventShipper = class {
     this.sticky = /* @__PURE__ */ new Map();
     this.timers = /* @__PURE__ */ new Map();
     this.inFlight = /* @__PURE__ */ new Set();
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     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;
@@ -253,11 +361,15 @@ var EventShipper = class {
     this.sdkName = (_d = opts.sdkName) != null ? _d : "core";
     this.prefix = `[raindrop-ai/${this.sdkName}]`;
     this.defaultEventName = (_e = opts.defaultEventName) != null ? _e : "ai_generation";
+    this.localDebuggerUrl = (_f = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _f : void 0;
+    if (this.debug && this.localDebuggerUrl) {
+      console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
+    }
     const isNode = typeof process !== "undefined" && typeof process.version === "string";
     this.context = {
       library: {
-        name: (_f = opts.libraryName) != null ? _f : "@raindrop-ai/core",
-        version: (_g = opts.libraryVersion) != null ? _g : "0.0.0"
+        name: (_g = opts.libraryName) != null ? _g : "@raindrop-ai/core",
+        version: (_h = opts.libraryVersion) != null ? _h : "0.0.0"
       },
       metadata: {
         jsRuntime: isNode ? "node" : "web",
@@ -343,6 +455,7 @@ var EventShipper = class {
         }
       }
     ];
+    if (!this.writeKey) return;
     const url = `${this.baseUrl}signals/track`;
     try {
       await postJson(url, body, this.authHeaders(), {
@@ -373,6 +486,7 @@ var EventShipper = class {
         traits: (_a = user.traits) != null ? _a : {}
       };
     });
+    if (!this.writeKey) return;
     if (body.length === 0) return;
     const url = `${this.baseUrl}users/identify`;
     try {
@@ -449,6 +563,18 @@ var EventShipper = class {
         endpoint: url
       });
     }
+    if (this.localDebuggerUrl) {
+      mirrorPartialEventToLocalDebugger(payload, {
+        baseUrl: this.localDebuggerUrl,
+        writeKey: this.writeKey,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+    }
+    if (!this.writeKey) {
+      if (!isPending) this.sticky.delete(eventId);
+      return;
+    }
     const p = postJson(url, payload, this.authHeaders(), {
       maxAttempts: 3,
       debug: this.debug,
@@ -473,101 +599,94 @@ var EventShipper = class {
     }
   }
 };
-var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
-var WORKSHOP_ENV_VAR = "RAINDROP_WORKSHOP";
-var DEFAULT_LOCAL_WORKSHOP_URL = "http://localhost:5899/v1/";
-function readEnvVar(name) {
-  var _a;
-  try {
-    const env = (_a = globalThis == null ? void 0 : globalThis.process) == null ? void 0 : _a.env;
-    if (env && typeof env[name] === "string" && env[name].length > 0) {
-      return env[name];
+var DEFAULT_SECRET_KEY_NAMES = [
+  "apikey",
+  "apisecret",
+  "apitoken",
+  "secretaccesskey",
+  "sessiontoken",
+  "privatekey",
+  "privatekeyid",
+  "clientsecret",
+  "accesstoken",
+  "refreshtoken",
+  "oauthtoken",
+  "bearertoken",
+  "authorization",
+  "password",
+  "passphrase"
+];
+var REDACTED_PLACEHOLDER = "[REDACTED]";
+function normalizeKeyName(name) {
+  return name.toLowerCase().replace(/[-_.]/g, "");
+}
+function redactSecretsInObject(value, options) {
+  var _a, _b;
+  const normalizedSecretSet = buildSecretSet((_a = options == null ? void 0 : options.secretKeyNames) != null ? _a : DEFAULT_SECRET_KEY_NAMES);
+  const placeholder = (_b = options == null ? void 0 : options.placeholder) != null ? _b : REDACTED_PLACEHOLDER;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node) => {
+    if (node === null || typeof node !== "object") return node;
+    if (seen.has(node)) return "[CIRCULAR]";
+    seen.add(node);
+    if (Array.isArray(node)) {
+      return node.map((item) => walk(item));
     }
+    const out = {};
+    for (const [k, v] of Object.entries(node)) {
+      if (normalizedSecretSet.has(normalizeKeyName(k))) {
+        out[k] = placeholder;
+      } else {
+        out[k] = walk(v);
+      }
+    }
+    return out;
+  };
+  return walk(value);
+}
+function buildSecretSet(names) {
+  const set = /* @__PURE__ */ new Set();
+  for (const name of names) set.add(normalizeKeyName(name));
+  return set;
+}
+var DEFAULT_REDACT_ATTRIBUTE_KEYS = [
+  "ai.request.providerOptions",
+  "ai.response.providerMetadata"
+];
+function defaultTransformSpan(span) {
+  const attrs = span.attributes;
+  if (!attrs || attrs.length === 0) return span;
+  let nextAttrs;
+  for (let i = 0; i < attrs.length; i++) {
+    const attr = attrs[i];
+    const redacted = redactJsonAttributeValue(attr.key, attr.value);
+    if (redacted === void 0) continue;
+    if (!nextAttrs) nextAttrs = attrs.slice();
+    nextAttrs[i] = { key: attr.key, value: redacted };
+  }
+  if (!nextAttrs) return span;
+  return { ...span, attributes: nextAttrs };
+}
+var REDACT_JSON_ATTRIBUTE_KEYS = new Set(DEFAULT_REDACT_ATTRIBUTE_KEYS);
+function redactJsonAttributeValue(key, value) {
+  if (!REDACT_JSON_ATTRIBUTE_KEYS.has(key)) return void 0;
+  const json = value.stringValue;
+  if (typeof json !== "string" || json.length === 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
   } catch (e) {
+    return void 0;
   }
-  return void 0;
-}
-function readWorkshopEnv() {
-  const raw = readEnvVar(WORKSHOP_ENV_VAR);
-  if (raw === void 0) return void 0;
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return void 0;
-  if (/^https?:\/\//i.test(trimmed)) return { url: trimmed };
-  if (/^(1|true|yes|on)$/i.test(trimmed)) return "enable";
-  if (/^(0|false|no|off)$/i.test(trimmed)) return "disable";
-  return void 0;
-}
-function isLocalDevHost(hostname) {
-  if (!hostname) return false;
-  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "::1") {
-    return true;
-  }
-  if (hostname.endsWith(".localhost")) return true;
-  return false;
-}
-function readRuntimeHostname() {
+  const scrubbed = redactSecretsInObject(parsed);
+  let scrubbedJson;
   try {
-    const loc = globalThis == null ? void 0 : globalThis.location;
-    if (loc && typeof loc.hostname === "string" && loc.hostname.length > 0) {
-      return loc.hostname;
-    }
+    scrubbedJson = JSON.stringify(scrubbed);
   } catch (e) {
+    return void 0;
   }
-  return void 0;
-}
-function shouldAutoEnableLocalWorkshop() {
-  if (isLocalDevHost(readRuntimeHostname())) return true;
-  if (readEnvVar("NODE_ENV") === "development") return true;
-  return false;
-}
-function resolveLocalDebuggerBaseUrl(baseUrl) {
-  var _a, _b, _c;
-  if (baseUrl === null) return null;
-  if (typeof baseUrl === "string" && baseUrl.length > 0) {
-    return (_a = formatEndpoint(baseUrl)) != null ? _a : null;
-  }
-  const explicitUrlEnv = readEnvVar(LOCAL_DEBUGGER_ENV_VAR);
-  if (explicitUrlEnv) return (_b = formatEndpoint(explicitUrlEnv)) != null ? _b : null;
-  const workshopEnv = readWorkshopEnv();
-  if (workshopEnv === "disable") return null;
-  if (workshopEnv === "enable") return DEFAULT_LOCAL_WORKSHOP_URL;
-  if (workshopEnv && "url" in workshopEnv) return (_c = formatEndpoint(workshopEnv.url)) != null ? _c : null;
-  if (shouldAutoEnableLocalWorkshop()) return DEFAULT_LOCAL_WORKSHOP_URL;
-  return null;
-}
-function localDebuggerEnabled(baseUrl) {
-  return resolveLocalDebuggerBaseUrl(baseUrl) !== null;
-}
-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: event.type,
-      timestamp: (_a = event.timestamp) != null ? _a : Date.now()
-    },
-    {},
-    {
-      maxAttempts: 1,
-      debug: (_b = options.debug) != null ? _b : false,
-      sdkName: options.sdkName
-    }
-  ).catch(() => {
-  });
+  if (scrubbedJson === json) return void 0;
+  return { stringValue: scrubbedJson };
 }
 var TraceShipper = class {
   constructor(opts) {
@@ -590,6 +709,42 @@ var TraceShipper = class {
     if (this.debug && this.localDebuggerUrl) {
       console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
     }
+    this.transformSpanHook = opts.transformSpan;
+    this.disableDefaultRedaction = opts.disableDefaultRedaction === true;
+  }
+  /**
+   * Apply the user `transformSpan` hook (if any) followed by the default
+   * redactor (unless disabled). Returns either the (possibly new) span to
+   * ship, or `null` to drop the span entirely.
+   *
+   * Ordering: user hook runs first so callers can rewrite the span freely
+   * (rename attrs, add new ones, scrub things the default doesn't know
+   * about). The default redactor then runs on whatever the user produced,
+   * acting as the always-on floor for documented BYOK secrets. If the user
+   * sets `disableDefaultRedaction: true`, the floor is skipped.
+   *
+   * Fail-closed: if the user hook throws, the span is dropped — a buggy
+   * hook can never accidentally ship raw, un-redacted spans.
+   */
+  redactSpan(span) {
+    let current = span;
+    if (this.transformSpanHook) {
+      try {
+        const result = this.transformSpanHook(current);
+        if (result === null) return null;
+        if (result !== void 0) current = result;
+      } catch (err) {
+        if (this.debug) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.warn(`${this.prefix} transformSpan hook threw: ${msg}`);
+        }
+        return null;
+      }
+    }
+    if (!this.disableDefaultRedaction) {
+      current = defaultTransformSpan(current);
+    }
+    return current;
   }
   isDebugEnabled() {
     return this.debug;
@@ -607,8 +762,8 @@ var TraceShipper = class {
     ];
     if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
     const span = { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
-    if (this.localDebuggerUrl) {
-      const openSpan = buildOtlpSpan({
+    this.mirrorToLocalDebugger(
+      buildOtlpSpan({
         ids: span.ids,
         name: span.name,
         startTimeUnixNano: span.startTimeUnixNano,
@@ -616,16 +771,21 @@ var TraceShipper = class {
         // 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;
   }
+  mirrorToLocalDebugger(span) {
+    if (!this.localDebuggerUrl) return;
+    const redacted = this.redactSpan(span);
+    if (redacted === null) return;
+    const body = buildExportTraceServiceRequest([redacted], this.serviceName, this.serviceVersion);
+    mirrorTraceExportToLocalDebugger(body, {
+      baseUrl: this.localDebuggerUrl,
+      debug: false,
+      sdkName: this.sdkName
+    });
+  }
   endSpan(span, extra) {
     var _a, _b;
     if (span.endTimeUnixNano) return;
@@ -647,14 +807,7 @@ 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
-      });
-    }
+    this.mirrorToLocalDebugger(otlp);
   }
   createSpan(args) {
     var _a;
@@ -672,14 +825,7 @@ 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
-      });
-    }
+    this.mirrorToLocalDebugger(otlp);
   }
   enqueue(span) {
     if (!this.enabled) return;
@@ -691,10 +837,12 @@ var TraceShipper = class {
         )}`
       );
     }
+    const redacted = this.redactSpan(span);
+    if (redacted === null) return;
     if (this.queue.length >= this.maxQueueSize) {
       this.queue.shift();
     }
-    this.queue.push(span);
+    this.queue.push(redacted);
     if (this.queue.length >= this.maxBatchSize) {
       void this.flush().catch(() => {
       });
@@ -716,6 +864,7 @@ var TraceShipper = class {
     }
     while (this.queue.length > 0) {
       const batch = this.queue.splice(0, this.maxBatchSize);
+      if (!this.writeKey) continue;
       const body = buildExportTraceServiceRequest(batch, this.serviceName, this.serviceVersion);
       const url = `${this.baseUrl}traces`;
       if (this.debug) {
@@ -875,7 +1024,7 @@ globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = async_hooks.AsyncLocalStorage;
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.0.28"};
+  version: "0.0.30"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -1591,13 +1740,76 @@ function readRaindropCallMetadataFromArgs(args) {
   return meta;
 }
 
+// src/internal/parent-tool-context.ts
+var SyncFallbackStorage2 = 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();
+    }
+  }
+  // `enterWith` is intentionally absent on the sync fallback — the
+  // event-driven enter/clear pattern only makes sense when the runtime
+  // can propagate state across awaits, which the sync stack cannot.
+};
+var _storage2 = null;
+function getStorage2() {
+  if (_storage2) return _storage2;
+  const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+  _storage2 = Ctor ? new Ctor() : new SyncFallbackStorage2();
+  return _storage2;
+}
+function _resetParentToolContextStorage() {
+  _storage2 = null;
+}
+function getCurrentParentToolContext() {
+  return getStorage2().getStore();
+}
+function enterParentToolContext(ctx) {
+  var _a;
+  const storage = getStorage2();
+  (_a = storage.enterWith) == null ? void 0 : _a.call(storage, ctx);
+}
+function clearParentToolContext() {
+  var _a;
+  const storage = getStorage2();
+  (_a = storage.enterWith) == null ? void 0 : _a.call(storage, void 0);
+}
+function runWithParentToolContext(ctx, fn) {
+  return getStorage2().run(ctx, fn);
+}
+
 // src/internal/raindrop-telemetry-integration.ts
 var RaindropTelemetryIntegration = class {
   constructor(opts) {
     this.callStates = /* @__PURE__ */ new Map();
+    /**
+     * Per-tool-call snapshot of the parent-tool ALS context taken right
+     * before `enterParentToolContext` overwrites it in `toolExecutionStart`.
+     * Kept at the integration level (rather than on `CallState`) so the
+     * snapshot survives even when the parent generation has no tracked
+     * `CallState` — e.g. the AI SDK dispatches a tool callback for a
+     * `callId` we never registered via `onStart`. Without this, the
+     * unconditional ALS enter in `toolExecutionStart` would leave
+     * `toolExecutionEnd` no way to restore the prior context, so it would
+     * clear and wipe whatever the outer scope had set.
+     *
+     * Keyed by `toolCallId` because that's the only identifier guaranteed
+     * to round-trip between `toolExecutionStart` and `toolExecutionEnd`
+     * (the `event.callId` can be the same for parallel sibling tools).
+     */
+    this.priorParentContexts = /* @__PURE__ */ new Map();
     // ── onStart ─────────────────────────────────────────────────────────────
     this.onStart = (event) => {
-      var _a, _b, _c, _d;
+      var _a, _b, _c, _d, _e;
       if (event.isEnabled === false) return;
       const isEmbed = event.operationId === "ai.embed" || event.operationId === "ai.embedMany";
       const recordInputs = event.recordInputs !== false;
@@ -1616,6 +1828,47 @@ var RaindropTelemetryIntegration = class {
         event.operationId,
         functionId
       );
+      const parentToolContext = !isEmbed && this.subagentWrapping ? getCurrentParentToolContext() : void 0;
+      const metadataSubagentName = !isEmbed && this.subagentWrapping && parentToolContext === void 0 ? typeof (metadata == null ? void 0 : metadata["ash.subagent.name"]) === "string" ? metadata["ash.subagent.name"] : void 0 : void 0;
+      const subagentName = (_e = parentToolContext == null ? void 0 : parentToolContext.toolName) != null ? _e : metadataSubagentName;
+      let subagentToolCallSpan;
+      let rootParentOverride;
+      if (subagentName && this.sendTraces) {
+        const parentAttrs = parentToolContext ? [
+          attrString("raindrop.parent.callId", parentToolContext.parentCallId),
+          attrString("raindrop.parent.toolCallId", parentToolContext.toolCallId),
+          attrString("raindrop.parent.toolName", parentToolContext.toolName)
+        ] : [];
+        subagentToolCallSpan = this.traceShipper.startSpan({
+          name: subagentName,
+          parent: inheritedParent,
+          eventId,
+          operationId: "ai.toolCall",
+          attributes: [
+            attrString("operation.name", "ai.toolCall"),
+            attrString("resource.name", subagentName),
+            attrString("raindrop.span.kind", "tool_call"),
+            attrString("ai.toolCall.name", subagentName),
+            attrString("raindrop.subagent.name", subagentName),
+            attrString("raindrop.agent.role", "subagent"),
+            ...parentAttrs
+          ]
+        });
+        const subagentParentRef = this.spanParentRef(subagentToolCallSpan);
+        const markerSpan = this.traceShipper.startSpan({
+          name: "agent.subagent",
+          parent: subagentParentRef,
+          eventId,
+          operationId: "agent.subagent",
+          attributes: [
+            attrString("operation.name", "agent.subagent"),
+            attrString("raindrop.span.kind", "llm_call"),
+            attrString("raindrop.subagent.name", subagentName)
+          ]
+        });
+        this.traceShipper.endSpan(markerSpan);
+        rootParentOverride = subagentParentRef;
+      }
       let rootSpan;
       if (this.sendTraces) {
         const promptAttrs = !isEmbed && recordInputs ? [
@@ -1636,7 +1889,7 @@ var RaindropTelemetryIntegration = class {
         ] : [attrString("ai.value", safeJsonWithUint8(event.value))] : [];
         rootSpan = this.traceShipper.startSpan({
           name: event.operationId,
-          parent: inheritedParent,
+          parent: rootParentOverride != null ? rootParentOverride : inheritedParent,
           eventId,
           operationId: event.operationId,
           attributes: [
@@ -1664,18 +1917,21 @@ var RaindropTelemetryIntegration = class {
         operationId: event.operationId,
         eventId,
         rootSpan,
-        rootParent: rootSpan ? this.spanParentRef(rootSpan) : inheritedParent,
+        rootParent: rootSpan ? this.spanParentRef(rootSpan) : rootParentOverride != null ? rootParentOverride : inheritedParent,
         stepSpan: void 0,
         stepParent: void 0,
         toolSpans: /* @__PURE__ */ new Map(),
         embedSpans: /* @__PURE__ */ new Map(),
+        parentContextToolCallIds: /* @__PURE__ */ new Set(),
         recordInputs,
         recordOutputs,
         functionId,
         metadata,
         accumulatedText: "",
         inputText: isEmbed ? void 0 : this.extractInputText(event),
-        toolCallCount: 0
+        toolCallCount: 0,
+        subagentName,
+        subagentToolCallSpan
       });
     };
     // ── onStepStart ─────────────────────────────────────────────────────────
@@ -1899,6 +2155,9 @@ var RaindropTelemetryIntegration = class {
       } else {
         this.finishGenerate(event, state);
       }
+      if (state.subagentToolCallSpan) {
+        this.traceShipper.endSpan(state.subagentToolCallSpan);
+      }
       this.cleanup(event.callId);
     };
     // ── onError ─────────────────────────────────────────────────────────────
@@ -1916,6 +2175,10 @@ var RaindropTelemetryIntegration = class {
         this.traceShipper.endSpan(embedSpan, { error: actualError });
       }
       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, { error: actualError });
       }
@@ -1923,6 +2186,9 @@ var RaindropTelemetryIntegration = class {
       if (state.rootSpan) {
         this.traceShipper.endSpan(state.rootSpan, { error: actualError });
       }
+      if (state.subagentToolCallSpan) {
+        this.traceShipper.endSpan(state.subagentToolCallSpan, { error: actualError });
+      }
       this.cleanup(event.callId);
     };
     // ── executeTool ─────────────────────────────────────────────────────────
@@ -1947,6 +2213,7 @@ var RaindropTelemetryIntegration = class {
     this.eventShipper = opts.eventShipper;
     this.sendTraces = opts.sendTraces !== false;
     this.sendEvents = opts.sendEvents !== false;
+    this.subagentWrapping = opts.subagentWrapping !== false;
     this.debug = opts.debug === true;
     this.defaultContext = opts.context;
   }
@@ -2028,9 +2295,20 @@ var RaindropTelemetryIntegration = class {
   // (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 { toolCall } = event;
+    const priorParent = getCurrentParentToolContext();
+    this.priorParentContexts.set(
+      toolCall.toolCallId,
+      priorParent != null ? priorParent : null
+    );
+    enterParentToolContext({
+      parentCallId: event.callId,
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName
+    });
     const state = this.getState(event.callId);
+    state == null ? void 0 : state.parentContextToolCallIds.add(toolCall.toolCallId);
     if (!(state == null ? void 0 : state.stepParent)) return;
-    const { toolCall } = event;
     const { operationName, resourceName } = opName(
       "ai.toolCall",
       state.functionId
@@ -2054,6 +2332,17 @@ var RaindropTelemetryIntegration = class {
     this.emitLive(state, "tool_start", toolCall.toolName, { args: toolCall.input });
   }
   toolExecutionEnd(event) {
+    var _a;
+    const toolCallId = (_a = event.toolCall) == null ? void 0 : _a.toolCallId;
+    if (toolCallId && this.priorParentContexts.has(toolCallId)) {
+      const prior = this.priorParentContexts.get(toolCallId);
+      this.priorParentContexts.delete(toolCallId);
+      if (prior) {
+        enterParentToolContext(prior);
+      } else {
+        clearParentToolContext();
+      }
+    }
     const state = this.getState(event.callId);
     if (!state) return;
     const toolSpan = state.toolSpans.get(event.toolCall.toolCallId);
@@ -2117,7 +2406,8 @@ var RaindropTelemetryIntegration = class {
       );
       this.traceShipper.endSpan(state.rootSpan, { attributes: outputAttrs });
     }
-    if (this.sendEvents) {
+    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) {
@@ -4275,16 +4565,20 @@ function envDebugEnabled() {
   return flag === "1" || flag === "true";
 }
 function createRaindropAISDK(opts) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   const writeKey = opts.writeKey;
   const eventsRequested = ((_a = opts.events) == null ? void 0 : _a.enabled) !== false;
   const tracesRequested = ((_b = opts.traces) == null ? void 0 : _b.enabled) !== false;
-  const eventsEnabled = eventsRequested && !!writeKey;
-  const tracesEnabled = tracesRequested && !!writeKey;
   const envDebug = envDebugEnabled();
-  if (!writeKey && (eventsRequested || tracesRequested)) {
+  const localWorkshopInput = opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl;
+  const resolvedLocalDebuggerUrl = resolveLocalDebuggerBaseUrl(localWorkshopInput);
+  const localDebuggerUrl = localWorkshopInput === null ? null : resolvedLocalDebuggerUrl != null ? resolvedLocalDebuggerUrl : void 0;
+  const hasDestination = !!writeKey || !!resolvedLocalDebuggerUrl;
+  const eventsEnabled = eventsRequested && hasDestination;
+  const tracesEnabled = tracesRequested && hasDestination;
+  if (!hasDestination && (eventsRequested || tracesRequested)) {
     console.warn(
-      "[raindrop-ai/ai-sdk] writeKey not provided; telemetry shipping is disabled"
+      "[raindrop-ai/ai-sdk] writeKey not provided and no local Workshop reachable; telemetry shipping is disabled"
     );
   }
   const eventShipper = new EventShipper2({
@@ -4292,9 +4586,9 @@ function createRaindropAISDK(opts) {
     endpoint: opts.endpoint,
     enabled: eventsEnabled,
     debug: ((_c = opts.events) == null ? void 0 : _c.debug) === true || envDebug,
-    partialFlushMs: (_d = opts.events) == null ? void 0 : _d.partialFlushMs
+    partialFlushMs: (_d = opts.events) == null ? void 0 : _d.partialFlushMs,
+    localDebuggerUrl
   });
-  const localDebuggerUrl = opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl;
   const traceShipper = new TraceShipper2({
     writeKey,
     endpoint: opts.endpoint,
@@ -4304,7 +4598,9 @@ function createRaindropAISDK(opts) {
     flushIntervalMs: (_g = opts.traces) == null ? void 0 : _g.flushIntervalMs,
     maxBatchSize: (_h = opts.traces) == null ? void 0 : _h.maxBatchSize,
     maxQueueSize: (_i = opts.traces) == null ? void 0 : _i.maxQueueSize,
-    localDebuggerUrl
+    localDebuggerUrl,
+    transformSpan: (_j = opts.traces) == null ? void 0 : _j.transformSpan,
+    disableDefaultRedaction: (_k = opts.traces) == null ? void 0 : _k.disableDefaultRedaction
   });
   return {
     wrap(aiSDK, options) {
@@ -4314,12 +4610,30 @@ function createRaindropAISDK(opts) {
         traceShipper
       });
     },
-    createTelemetryIntegration(context) {
+    createTelemetryIntegration(contextOrOptions) {
+      const FLAT_CONTEXT_KEYS = [
+        "userId",
+        "eventId",
+        "eventName",
+        "convoId",
+        "properties"
+      ];
+      let context;
+      let subagentWrapping;
+      if (contextOrOptions === void 0) ; else if ("context" in contextOrOptions) {
+        context = contextOrOptions.context;
+        subagentWrapping = contextOrOptions.subagentWrapping;
+      } else if ("subagentWrapping" in contextOrOptions && !FLAT_CONTEXT_KEYS.some((k) => k in contextOrOptions)) {
+        subagentWrapping = contextOrOptions.subagentWrapping;
+      } else {
+        context = contextOrOptions;
+      }
       return new RaindropTelemetryIntegration({
         traceShipper,
         eventShipper,
         sendTraces: tracesEnabled,
         sendEvents: eventsEnabled,
+        subagentWrapping,
         debug: envDebug,
         context
       });
@@ -4432,15 +4746,26 @@ if (!globalThis.RAINDROP_ASYNC_LOCAL_STORAGE) {
   globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = async_hooks.AsyncLocalStorage;
 }
 
+exports.DEFAULT_REDACT_ATTRIBUTE_KEYS = DEFAULT_REDACT_ATTRIBUTE_KEYS;
+exports.DEFAULT_SECRET_KEY_NAMES = DEFAULT_SECRET_KEY_NAMES;
+exports.REDACTED_PLACEHOLDER = REDACTED_PLACEHOLDER;
 exports.RaindropTelemetryIntegration = RaindropTelemetryIntegration;
+exports._resetParentToolContextStorage = _resetParentToolContextStorage;
 exports._resetRaindropCallMetadataStorage = _resetRaindropCallMetadataStorage;
 exports._resetWarnedMissingUserId = _resetWarnedMissingUserId;
+exports.clearParentToolContext = clearParentToolContext;
 exports.createRaindropAISDK = createRaindropAISDK;
 exports.currentSpan = currentSpan;
+exports.defaultTransformSpan = defaultTransformSpan;
+exports.enterParentToolContext = enterParentToolContext;
 exports.eventMetadata = eventMetadata;
 exports.eventMetadataFromChatRequest = eventMetadataFromChatRequest;
 exports.getContextManager = getContextManager;
+exports.getCurrentParentToolContext = getCurrentParentToolContext;
 exports.getCurrentRaindropCallMetadata = getCurrentRaindropCallMetadata;
 exports.readRaindropCallMetadataFromArgs = readRaindropCallMetadataFromArgs;
+exports.redactJsonAttributeValue = redactJsonAttributeValue;
+exports.redactSecretsInObject = redactSecretsInObject;
+exports.runWithParentToolContext = runWithParentToolContext;
 exports.runWithRaindropCallMetadata = runWithRaindropCallMetadata;
 exports.withCurrent = withCurrent;