@raindrop-ai/ai-sdk 0.0.32 → 0.0.34

package/dist/index.browser.js

@@ -1,6 +1,6 @@
 'use strict';
 
-// ../core/dist/chunk-VUNUOE2X.js
+// ../core/dist/chunk-U5HUTMR5.js
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -55,6 +55,8 @@ function base64Encode(bytes) {
   }
   return out;
 }
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_RETRY_DELAY_MS = 3e4;
 function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -62,6 +64,46 @@ function formatEndpoint(endpoint) {
   if (!endpoint) return void 0;
   return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
 }
+function redactUrlForLog(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch (e) {
+    return "<unparseable-url>";
+  }
+}
+var RATE_LIMITED_LOG_INTERVAL_MS = 3e4;
+var rateLimitedLogLast = /* @__PURE__ */ new Map();
+function rateLimitedLog(key, log) {
+  const now = Date.now();
+  const last = rateLimitedLogLast.get(key);
+  if (last !== void 0 && now - last < RATE_LIMITED_LOG_INTERVAL_MS) {
+    return false;
+  }
+  rateLimitedLogLast.set(key, now);
+  log();
+  return true;
+}
+async function raceWithTimeout(promise, timeoutMs) {
+  let timer;
+  const settledInTime = await Promise.race([
+    promise.then(
+      () => true,
+      () => true
+    ),
+    new Promise((resolve) => {
+      var _a;
+      timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+      (_a = timer.unref) == null ? void 0 : _a.call(timer);
+    })
+  ]);
+  if (timer) clearTimeout(timer);
+  return settledInTime;
+}
 function parseRetryAfter(headers) {
   var _a;
   const value = (_a = headers.get("Retry-After")) != null ? _a : headers.get("retry-after");
@@ -78,12 +120,12 @@ function parseRetryAfter(headers) {
 function getRetryDelayMs(attemptNumber, previousError) {
   if (previousError && typeof previousError === "object" && previousError !== null && "retryAfterMs" in previousError) {
     const v = previousError.retryAfterMs;
-    if (typeof v === "number") return Math.max(0, v);
+    if (typeof v === "number") return Math.min(Math.max(0, v), MAX_RETRY_DELAY_MS);
   }
   if (attemptNumber <= 1) return 0;
   const base = 500;
   const factor = Math.pow(2, attemptNumber - 2);
-  return base * factor;
+  return Math.min(base * factor, MAX_RETRY_DELAY_MS);
 }
 async function withRetry(operation, opName2, opts) {
   const prefix = opts.sdkName ? `[raindrop-ai/${opts.sdkName}]` : "[raindrop-ai/core]";
@@ -118,7 +160,9 @@ async function withRetry(operation, opName2, opts) {
   throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 async function postJson(url, body, headers, opts) {
-  const opName2 = `POST ${url}`;
+  var _a;
+  const opName2 = `POST ${redactUrlForLog(url)}`;
+  const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
   await withRetry(
     async () => {
       const resp = await fetch(url, {
@@ -127,7 +171,8 @@ async function postJson(url, body, headers, opts) {
           "Content-Type": "application/json",
           ...headers
         },
-        body: JSON.stringify(body)
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(timeoutMs)
       });
       if (!resp.ok) {
         const text = await resp.text().catch(() => "");
@@ -144,6 +189,27 @@ async function postJson(url, body, headers, opts) {
     opts
   );
 }
+var DEFAULT_MAX_TEXT_FIELD_CHARS = 1e6;
+var TRUNCATION_MARKER = "...[truncated by raindrop]";
+var currentDefaultMaxTextFieldChars = DEFAULT_MAX_TEXT_FIELD_CHARS;
+function resolveMaxTextFieldChars(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  return currentDefaultMaxTextFieldChars;
+}
+function truncateToLimit(text, limit) {
+  if (limit > TRUNCATION_MARKER.length) {
+    return text.slice(0, limit - TRUNCATION_MARKER.length) + TRUNCATION_MARKER;
+  }
+  return text.slice(0, Math.max(0, limit));
+}
+function capText(value, limit) {
+  if (typeof value !== "string") return value;
+  const max = limit != null ? limit : currentDefaultMaxTextFieldChars;
+  if (value.length <= max) return value;
+  return truncateToLimit(value, max);
+}
 var SpanStatusCode = {
   UNSET: 0,
   ERROR: 2
@@ -331,6 +397,8 @@ function sendLocalDebuggerLiveEvent(event, options = {}) {
   ).catch(() => {
   });
 }
+var SHUTDOWN_DEADLINE_MS = 1e4;
+var POST_SHUTDOWN_TIMEOUT_MS = 5e3;
 function mergePatches(target, source) {
   var _a, _b, _c, _d;
   const out = { ...target, ...source };
@@ -348,6 +416,7 @@ var EventShipper = class {
     this.sticky = /* @__PURE__ */ new Map();
     this.timers = /* @__PURE__ */ new Map();
     this.inFlight = /* @__PURE__ */ new Set();
+    this.hasShutdown = false;
     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/";
@@ -357,6 +426,7 @@ 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.maxTextFieldCharsOpt = opts.maxTextFieldChars;
     this.localDebuggerUrl = (_f = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _f : void 0;
     if (this.debug && this.localDebuggerUrl) {
       console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
@@ -379,10 +449,52 @@ var EventShipper = class {
   authHeaders() {
     return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
   }
+  /**
+   * Build the retry/timeout options for one POST, honoring the shutdown
+   * deadline. Returns `null` when the shutdown drain window is exhausted —
+   * the caller must drop the payload (with a rate-limited warning) instead
+   * of issuing a request that could outlive process exit.
+   *
+   * Checked fresh on EVERY send, so a shutdown that begins while the flush
+   * path is mid-drain takes effect immediately: no further retries, and the
+   * per-attempt timeout is clamped to the remaining window. After
+   * `shutdown()` returns (deadline cleared, `hasShutdown` still set),
+   * sends — late callers, or flush work the deadline abandoned mid-drain —
+   * run as a single short attempt rather than regaining the full retry
+   * schedule.
+   */
+  requestOpts() {
+    if (this.shutdownDeadlineAt !== void 0) {
+      const remainingMs = this.shutdownDeadlineAt - Date.now();
+      if (remainingMs <= 0) return null;
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        sdkName: this.sdkName,
+        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
+      };
+    }
+    if (this.hasShutdown) {
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        sdkName: this.sdkName,
+        timeoutMs: POST_SHUTDOWN_TIMEOUT_MS
+      };
+    }
+    return { maxAttempts: 3, debug: this.debug, sdkName: this.sdkName };
+  }
   async patch(eventId, patch) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     if (!this.enabled) return;
     if (!eventId || !eventId.trim()) return;
+    const maxChars = resolveMaxTextFieldChars(this.maxTextFieldCharsOpt);
+    if (typeof patch.input === "string" && patch.input.length > maxChars) {
+      patch = { ...patch, input: capText(patch.input, maxChars) };
+    }
+    if (typeof patch.output === "string" && patch.output.length > maxChars) {
+      patch = { ...patch, output: capText(patch.output, maxChars) };
+    }
     if (this.debug) {
       console.log(`${this.prefix} queue patch`, {
         eventId,
@@ -429,9 +541,16 @@ var EventShipper = class {
     })));
   }
   async shutdown() {
-    for (const t of this.timers.values()) clearTimeout(t);
-    this.timers.clear();
-    await this.flush();
+    this.hasShutdown = true;
+    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
+    try {
+      for (const t of this.timers.values()) clearTimeout(t);
+      this.timers.clear();
+      const settled = await raceWithTimeout(this.flush(), SHUTDOWN_DEADLINE_MS);
+      if (!settled) this.warnShutdownDrop("in-flight request(s) at shutdown");
+    } finally {
+      this.shutdownDeadlineAt = void 0;
+    }
   }
   async trackSignal(signal) {
     var _a, _b;
@@ -453,15 +572,19 @@ var EventShipper = class {
     ];
     if (!this.writeKey) return;
     const url = `${this.baseUrl}signals/track`;
+    const opts = this.requestOpts();
+    if (!opts) {
+      this.warnShutdownDrop("signal");
+      return;
+    }
     try {
-      await postJson(url, body, this.authHeaders(), {
-        maxAttempts: 3,
-        debug: this.debug,
-        sdkName: this.sdkName
-      });
+      await postJson(url, body, this.authHeaders(), opts);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      console.warn(`${this.prefix} failed to send signal (dropping): ${msg}`);
+      rateLimitedLog(
+        `${this.prefix}.send_signal_failed`,
+        () => console.warn(`${this.prefix} failed to send signal (dropping): ${msg}`)
+      );
     }
   }
   async identify(users) {
@@ -485,17 +608,27 @@ var EventShipper = class {
     if (!this.writeKey) return;
     if (body.length === 0) return;
     const url = `${this.baseUrl}users/identify`;
+    const opts = this.requestOpts();
+    if (!opts) {
+      this.warnShutdownDrop("identify");
+      return;
+    }
     try {
-      await postJson(url, body, this.authHeaders(), {
-        maxAttempts: 3,
-        debug: this.debug,
-        sdkName: this.sdkName
-      });
+      await postJson(url, body, this.authHeaders(), opts);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      console.warn(`${this.prefix} failed to send identify (dropping): ${msg}`);
+      rateLimitedLog(
+        `${this.prefix}.send_identify_failed`,
+        () => console.warn(`${this.prefix} failed to send identify (dropping): ${msg}`)
+      );
     }
   }
+  warnShutdownDrop(what) {
+    rateLimitedLog(
+      `${this.prefix}.shutdown_deadline`,
+      () => console.warn(`${this.prefix} shutdown flush deadline exceeded; dropping ${what}`)
+    );
+  }
   async flushOne(eventId) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
     if (!this.enabled) return;
@@ -571,11 +704,13 @@ var EventShipper = class {
       if (!isPending) this.sticky.delete(eventId);
       return;
     }
-    const p = postJson(url, payload, this.authHeaders(), {
-      maxAttempts: 3,
-      debug: this.debug,
-      sdkName: this.sdkName
-    });
+    const opts = this.requestOpts();
+    if (!opts) {
+      this.warnShutdownDrop(`track_partial ${eventId}`);
+      if (!isPending) this.sticky.delete(eventId);
+      return;
+    }
+    const p = postJson(url, payload, this.authHeaders(), opts);
     this.inFlight.add(p);
     try {
       try {
@@ -585,7 +720,10 @@ var EventShipper = class {
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        console.warn(`${this.prefix} failed to send track_partial (dropping): ${msg}`);
+        rateLimitedLog(
+          `${this.prefix}.send_track_partial_failed`,
+          () => console.warn(`${this.prefix} failed to send track_partial (dropping): ${msg}`)
+        );
       }
     } finally {
       this.inFlight.delete(p);
@@ -684,10 +822,24 @@ function redactJsonAttributeValue(key, value) {
   if (scrubbedJson === json) return void 0;
   return { stringValue: scrubbedJson };
 }
+function applyOtelSpanAttributeLimit(limit) {
+  var _a, _b;
+  try {
+    const raw = (_b = (_a = globalThis == null ? void 0 : globalThis.process) == null ? void 0 : _a.env) == null ? void 0 : _b.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+    if (!raw) return limit;
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return Math.min(limit, parsed);
+    }
+  } catch (e) {
+  }
+  return limit;
+}
 var TraceShipper = class {
   constructor(opts) {
     this.queue = [];
     this.inFlight = /* @__PURE__ */ new Set();
+    this.hasShutdown = false;
     var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
     this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
@@ -707,6 +859,39 @@ var TraceShipper = class {
     }
     this.transformSpanHook = opts.transformSpan;
     this.disableDefaultRedaction = opts.disableDefaultRedaction === true;
+    this.maxTextFieldCharsOpt = opts.maxTextFieldChars;
+  }
+  /**
+   * Cap every string attribute value on the span. O(#attributes) length
+   * checks; only oversized values pay a slice. Runs AFTER the redaction
+   * pipeline so the default secret-scrub still sees parseable JSON in
+   * `ai.request.providerOptions` / `ai.response.providerMetadata` (capping
+   * first could cut a JSON blob mid-way, fail the parse, and ship secrets
+   * in the surviving prefix).
+   *
+   * A stricter `OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT` env var is honored
+   * for span content, matching the Python SDK and the OTel SDK convention.
+   */
+  capSpanAttributes(span) {
+    var _a;
+    const maxChars = applyOtelSpanAttributeLimit(
+      resolveMaxTextFieldChars(this.maxTextFieldCharsOpt)
+    );
+    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 value = (_a = attr.value) == null ? void 0 : _a.stringValue;
+      if (typeof value !== "string" || value.length <= maxChars) continue;
+      if (!nextAttrs) nextAttrs = attrs.slice();
+      nextAttrs[i] = {
+        key: attr.key,
+        value: { ...attr.value, stringValue: capText(value, maxChars) }
+      };
+    }
+    if (!nextAttrs) return span;
+    return { ...span, attributes: nextAttrs };
   }
   /**
    * Apply the user `transformSpan` hook (if any) followed by the default
@@ -740,7 +925,7 @@ var TraceShipper = class {
     if (!this.disableDefaultRedaction) {
       current = defaultTransformSpan(current);
     }
-    return current;
+    return this.capSpanAttributes(current);
   }
   isDebugEnabled() {
     return this.debug;
@@ -861,6 +1046,16 @@ var TraceShipper = class {
     while (this.queue.length > 0) {
       const batch = this.queue.splice(0, this.maxBatchSize);
       if (!this.writeKey) continue;
+      const opts = this.requestOpts();
+      if (!opts) {
+        rateLimitedLog(
+          `${this.prefix}.shutdown_deadline`,
+          () => console.warn(
+            `${this.prefix} shutdown flush deadline exceeded; dropping ${batch.length} spans`
+          )
+        );
+        continue;
+      }
       const body = buildExportTraceServiceRequest(batch, this.serviceName, this.serviceVersion);
       const url = `${this.baseUrl}traces`;
       if (this.debug) {
@@ -869,11 +1064,7 @@ var TraceShipper = class {
           endpoint: url
         });
       }
-      const p = postJson(url, body, this.authHeaders(), {
-        maxAttempts: 3,
-        debug: this.debug,
-        sdkName: this.sdkName
-      });
+      const p = postJson(url, body, this.authHeaders(), opts);
       this.inFlight.add(p);
       try {
         try {
@@ -881,21 +1072,61 @@ var TraceShipper = class {
           if (this.debug) console.log(`${this.prefix} sent ${batch.length} spans`);
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          console.warn(`${this.prefix} failed to send ${batch.length} spans: ${msg}`);
+          rateLimitedLog(
+            `${this.prefix}.send_spans_failed`,
+            () => console.warn(`${this.prefix} failed to send ${batch.length} spans: ${msg}`)
+          );
         }
       } finally {
         this.inFlight.delete(p);
       }
     }
   }
+  /** See EventShipper.requestOpts — same shutdown-budget semantics. */
+  requestOpts() {
+    if (this.shutdownDeadlineAt !== void 0) {
+      const remainingMs = this.shutdownDeadlineAt - Date.now();
+      if (remainingMs <= 0) return null;
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        sdkName: this.sdkName,
+        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
+      };
+    }
+    if (this.hasShutdown) {
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        sdkName: this.sdkName,
+        timeoutMs: POST_SHUTDOWN_TIMEOUT_MS
+      };
+    }
+    return { maxAttempts: 3, debug: this.debug, sdkName: this.sdkName };
+  }
   async shutdown() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = void 0;
+    this.hasShutdown = true;
+    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
+    try {
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = void 0;
+      }
+      const drain = async () => {
+        await this.flush();
+        await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+        })));
+      };
+      const settled = await raceWithTimeout(drain(), SHUTDOWN_DEADLINE_MS);
+      if (!settled) {
+        rateLimitedLog(
+          `${this.prefix}.shutdown_deadline`,
+          () => console.warn(`${this.prefix} shutdown flush deadline exceeded; abandoning in-flight spans`)
+        );
+      }
+    } finally {
+      this.shutdownDeadlineAt = void 0;
     }
-    await this.flush();
-    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
-    })));
   }
 };
 var NOOP_SPAN = {
@@ -1019,7 +1250,7 @@ async function* asyncGeneratorWithCurrent(span, gen) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/ai-sdk",
-  version: "0.0.32"};
+  version: "0.0.34"};
 
 // src/internal/version.ts
 var libraryName = package_default.name;
@@ -1038,6 +1269,133 @@ var EventShipper2 = class extends EventShipper {
   }
 };
 
+// src/internal/truncation.ts
+var TRUNCATION_MARKER2 = "...[truncated by raindrop]";
+var DEFAULT_MAX_TEXT_FIELD_CHARS2 = 1e6;
+var MAX_DEPTH = 12;
+var configuredMaxTextFieldChars;
+function setMaxTextFieldChars(limit) {
+  if (limit === void 0) return;
+  if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) {
+    configuredMaxTextFieldChars = Math.floor(limit);
+  } else {
+    console.warn(`[raindrop-ai] maxTextFieldChars=${String(limit)} ignored; must be > 0`);
+  }
+}
+function otelEnvLimit() {
+  var _a;
+  if (typeof process === "undefined") return void 0;
+  const raw = (_a = process.env) == null ? void 0 : _a.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+  if (!raw) return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function effectiveMaxTextFieldChars() {
+  const base = configuredMaxTextFieldChars != null ? configuredMaxTextFieldChars : DEFAULT_MAX_TEXT_FIELD_CHARS2;
+  const env = otelEnvLimit();
+  return env !== void 0 && env < base ? env : base;
+}
+function truncateToLimit2(text, limit) {
+  if (limit > TRUNCATION_MARKER2.length) {
+    return text.slice(0, limit - TRUNCATION_MARKER2.length) + TRUNCATION_MARKER2;
+  }
+  return text.slice(0, limit);
+}
+function capText2(value, limit) {
+  if (typeof value !== "string") return value;
+  const max = limit != null ? limit : effectiveMaxTextFieldChars();
+  if (value.length <= max) return value;
+  return truncateToLimit2(value, max);
+}
+function boundedClone2(value, budget, depth) {
+  var _a, _b;
+  if (budget.remaining <= 0) return TRUNCATION_MARKER2;
+  if (typeof value === "string") {
+    if (value.length > budget.remaining) {
+      const taken = value.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      return taken;
+    }
+    budget.remaining -= Math.max(value.length, 1);
+    return value;
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    budget.remaining -= 8;
+    return value;
+  }
+  if (typeof value !== "object") {
+    budget.remaining -= 1;
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    const maxBytes = Math.max(0, Math.ceil(budget.remaining * 3 / 4));
+    if (value.byteLength > maxBytes) {
+      const taken = base64Encode(value.subarray(0, maxBytes)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      return taken;
+    }
+    const encoded = base64Encode(value);
+    budget.remaining -= Math.max(encoded.length, 1);
+    return encoded;
+  }
+  if (depth >= MAX_DEPTH) {
+    budget.remaining -= 16;
+    const name = (_b = (_a = value.constructor) == null ? void 0 : _a.name) != null ? _b : "object";
+    return `<max depth: ${name}>`;
+  }
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function") {
+    budget.remaining -= 2;
+    return boundedClone2(toJSON.call(value), budget, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    budget.remaining -= 2;
+    const out2 = [];
+    for (const item of value) {
+      if (budget.remaining <= 0) {
+        out2.push(TRUNCATION_MARKER2);
+        break;
+      }
+      out2.push(boundedClone2(item, budget, depth + 1));
+    }
+    return out2;
+  }
+  budget.remaining -= 2;
+  const out = {};
+  for (const key in value) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+    if (budget.remaining <= 0) {
+      out["..."] = TRUNCATION_MARKER2;
+      break;
+    }
+    let cappedKey = key;
+    if (key.length > budget.remaining) {
+      cappedKey = key.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      out[cappedKey] = TRUNCATION_MARKER2;
+      break;
+    }
+    budget.remaining -= Math.max(key.length, 1);
+    out[cappedKey] = boundedClone2(value[key], budget, depth + 1);
+  }
+  return out;
+}
+function boundedStringify(value, limit) {
+  const max = limit != null ? limit : effectiveMaxTextFieldChars();
+  try {
+    if (typeof value === "string") {
+      const text2 = JSON.stringify(capText2(value, max));
+      return text2.length <= max ? text2 : truncateToLimit2(text2, max);
+    }
+    const pruned = boundedClone2(value, { remaining: max + TRUNCATION_MARKER2.length + 256 }, 0);
+    const text = JSON.stringify(pruned);
+    if (text === void 0) return void 0;
+    return text.length <= max ? text : truncateToLimit2(text, max);
+  } catch (e) {
+    return void 0;
+  }
+}
+
 // src/internal/wrap/helpers.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -1062,21 +1420,10 @@ function isModuleNamespace(obj) {
   }
 }
 function safeJson(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (e) {
-    return void 0;
-  }
+  return boundedStringify(value);
 }
 function safeJsonWithUint8(value) {
-  try {
-    return JSON.stringify(value, (_key, v) => {
-      if (v instanceof Uint8Array) return base64Encode(v);
-      return v;
-    });
-  } catch (e) {
-    return void 0;
-  }
+  return boundedStringify(value);
 }
 function extractModelInfo(model) {
   if (typeof model === "string") {
@@ -1802,6 +2149,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;
@@ -1953,7 +2319,10 @@ var RaindropTelemetryIntegration = class {
           inputAttrs.push(
             attrStringArray(
               "ai.prompt.tools",
-              event.stepTools.map((t) => JSON.stringify(t))
+              event.stepTools.map((t) => {
+                var _a;
+                return (_a = safeJsonWithUint8(t)) != null ? _a : "";
+              })
             )
           );
         }
@@ -1961,7 +2330,7 @@ var RaindropTelemetryIntegration = class {
           inputAttrs.push(
             attrString(
               "ai.prompt.toolChoice",
-              JSON.stringify(event.stepToolChoice)
+              safeJsonWithUint8(event.stepToolChoice)
             )
           );
         }
@@ -2017,7 +2386,9 @@ var RaindropTelemetryIntegration = class {
       if (chunk.type === "text-delta") {
         const delta = (_c = chunk.textDelta) != null ? _c : chunk.delta;
         if (typeof delta === "string") {
-          state.accumulatedText += delta;
+          if (state.accumulatedText.length <= effectiveMaxTextFieldChars()) {
+            state.accumulatedText += delta;
+          }
           this.emitLive(state, "text_delta", delta);
         }
       } else if (chunk.type === "reasoning" || chunk.type === "reasoning-delta") {
@@ -2036,7 +2407,7 @@ var RaindropTelemetryIntegration = class {
       if (state.recordOutputs) {
         outputAttrs.push(
           attrString("ai.response.finishReason", event.finishReason),
-          attrString("ai.response.text", (_a = event.text) != null ? _a : void 0),
+          attrString("ai.response.text", capText2((_a = event.text) != null ? _a : void 0)),
           attrString("ai.response.id", (_b = event.response) == null ? void 0 : _b.id),
           attrString("ai.response.model", (_c = event.response) == null ? void 0 : _c.modelId),
           attrString(
@@ -2052,7 +2423,7 @@ var RaindropTelemetryIntegration = class {
           outputAttrs.push(
             attrString(
               "ai.response.toolCalls",
-              JSON.stringify(
+              safeJsonWithUint8(
                 event.toolCalls.map((tc) => ({
                   toolCallId: tc.toolCallId,
                   toolName: tc.toolName,
@@ -2065,7 +2436,7 @@ var RaindropTelemetryIntegration = class {
         if (((_g = event.reasoning) == null ? void 0 : _g.length) > 0) {
           const reasoningText = event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n");
           if (reasoningText) {
-            outputAttrs.push(attrString("ai.response.reasoning", reasoningText));
+            outputAttrs.push(attrString("ai.response.reasoning", capText2(reasoningText)));
           }
         }
       }
@@ -2195,8 +2566,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,
@@ -2354,11 +2773,12 @@ 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);
@@ -2432,13 +2852,13 @@ var RaindropTelemetryIntegration = class {
     }
   }
   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) {
         outputAttrs.push(
           attrString("ai.response.finishReason", event.finishReason),
-          attrString("ai.response.text", (_a = event.text) != null ? _a : void 0),
+          attrString("ai.response.text", capText2((_a = event.text) != null ? _a : void 0)),
           attrString(
             "ai.response.providerMetadata",
             event.providerMetadata ? safeJsonWithUint8(event.providerMetadata) : void 0
@@ -2448,7 +2868,7 @@ var RaindropTelemetryIntegration = class {
           outputAttrs.push(
             attrString(
               "ai.response.toolCalls",
-              JSON.stringify(
+              safeJsonWithUint8(
                 event.toolCalls.map((tc) => ({
                   toolCallId: tc.toolCallId,
                   toolName: tc.toolName,
@@ -2461,7 +2881,7 @@ var RaindropTelemetryIntegration = class {
         if (((_c = event.reasoning) == null ? void 0 : _c.length) > 0) {
           const reasoningText = event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n");
           if (reasoningText) {
-            outputAttrs.push(attrString("ai.response.reasoning", reasoningText));
+            outputAttrs.push(attrString("ai.response.reasoning", capText2(reasoningText)));
           }
         }
       }
@@ -2480,38 +2900,48 @@ 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 cappedOutput = capText2(output);
+    const input = capText2(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: cappedOutput,
+      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;
@@ -2974,13 +3404,14 @@ function shouldKeepEventPending(params) {
   return params.finishReason === "tool-calls" || params.finishReason === "tool_calls";
 }
 function normalizePromptAttr(arg) {
+  var _a, _b;
   if (!isRecord(arg)) return arg;
   const system = arg["system"];
   const prompt = arg["prompt"];
   const messages = arg["messages"];
   if (Array.isArray(messages)) {
     if (system) {
-      const sysContent = typeof system === "string" ? system : JSON.stringify(system);
+      const sysContent = typeof system === "string" ? system : (_a = safeJsonWithUint8(system)) != null ? _a : String(system);
       return [{ role: "system", content: sysContent }, ...messages];
     }
     return messages;
@@ -2988,7 +3419,10 @@ function normalizePromptAttr(arg) {
   if (typeof prompt === "string") {
     const msgs = [];
     if (system) {
-      msgs.push({ role: "system", content: typeof system === "string" ? system : JSON.stringify(system) });
+      msgs.push({
+        role: "system",
+        content: typeof system === "string" ? system : (_b = safeJsonWithUint8(system)) != null ? _b : String(system)
+      });
     }
     msgs.push({ role: "user", content: prompt });
     return msgs;
@@ -3157,7 +3591,8 @@ function createFinalize(params) {
     };
     const built = await maybeBuildEvent(options.buildEvent, allMessages);
     const patch = mergeBuildEventPatch(defaultPatch, built);
-    const output = patch.output;
+    const output = capText2(patch.output);
+    const input = capText2(patch.input);
     const finalModel = (_c = patch.model) != null ? _c : model;
     if (setup.rootSpan) {
       const spanEndTimeUnixNano = nowUnixNanoString();
@@ -3201,7 +3636,7 @@ function createFinalize(params) {
         eventName: patch.eventName,
         userId: setup.ctx.userId,
         convoId: setup.ctx.convoId,
-        input: patch.input,
+        input,
         output,
         model: finalModel,
         properties: patch.properties,
@@ -3716,7 +4151,8 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
       };
       const built = await maybeBuildEvent(deps.options.buildEvent, allMessages);
       const patch = mergeBuildEventPatch(defaultPatch, built);
-      const output = patch.output;
+      const output = capText2(patch.output);
+      const input = capText2(patch.input);
       const finalModel = (_c2 = patch.model) != null ? _c2 : model;
       if (rootSpan) {
         const spanEndTimeUnixNano = nowUnixNanoString();
@@ -3774,7 +4210,7 @@ function wrapAgentGenerate(generate, instance, agentSettings, className, aiSDK,
           eventName: patch.eventName,
           userId: ctx.userId,
           convoId: ctx.convoId,
-          input: patch.input,
+          input,
           output,
           model: finalModel,
           properties: patch.properties,
@@ -3923,7 +4359,8 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
       };
       const built = await maybeBuildEvent(deps.options.buildEvent, allMessages);
       const patch = mergeBuildEventPatch(defaultPatch, built);
-      const output = patch.output;
+      const output = capText2(patch.output);
+      const input = capText2(patch.input);
       const finalModel = (_c2 = patch.model) != null ? _c2 : model;
       if (rootSpan) {
         const spanEndTimeUnixNano = nowUnixNanoString();
@@ -3981,7 +4418,7 @@ function wrapAgentStream(stream, instance, agentSettings, className, aiSDK, deps
           eventName: patch.eventName,
           userId: ctx.userId,
           convoId: ctx.convoId,
-          input: patch.input,
+          input,
           output,
           model: finalModel,
           properties: patch.properties,
@@ -4321,7 +4758,7 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
               attributes: [
                 ...((_a = ctx.telemetry) == null ? void 0 : _a.recordOutputs) === false ? [] : [
                   attrString("ai.response.finishReason", finishReason),
-                  attrString("ai.response.text", activeText.length ? activeText : void 0),
+                  attrString("ai.response.text", activeText.length ? capText2(activeText) : void 0),
                   attrString(
                     "ai.response.toolCalls",
                     safeJsonWithUint8(toolCallsLocal.length ? toolCallsLocal : void 0)
@@ -4374,7 +4811,9 @@ function wrapModel(args, aiSDK, outerOperationId, ctx) {
                     } else if (typeof value["textDelta"] === "string") {
                       textDelta = value["textDelta"];
                     }
-                    if (typeof textDelta === "string") activeText += textDelta;
+                    if (typeof textDelta === "string" && activeText.length <= effectiveMaxTextFieldChars()) {
+                      activeText += textDelta;
+                    }
                   }
                   if (type === "finish") finishReason = extractFinishReason(value);
                   if (type === "tool-call") toolCallsLocal.push(value);
@@ -4647,8 +5086,8 @@ function eventMetadataFromChatRequest(options) {
   });
 }
 function stringify(v) {
-  if (typeof v === "string") return v;
-  return JSON.stringify(v);
+  if (typeof v === "string") return capText2(v);
+  return boundedStringify(v);
 }
 function userAttrsToOtlp(attrs) {
   if (!attrs) return [];
@@ -4666,6 +5105,7 @@ function createRaindropAISDK(opts) {
   const eventsRequested = ((_a = opts.events) == null ? void 0 : _a.enabled) !== false;
   const tracesRequested = ((_b = opts.traces) == null ? void 0 : _b.enabled) !== false;
   const envDebug = envDebugEnabled();
+  setMaxTextFieldChars(opts.maxTextFieldChars);
   const localWorkshopInput = opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl;
   const resolvedLocalDebuggerUrl = resolveLocalDebuggerBaseUrl(localWorkshopInput);
   const localDebuggerUrl = localWorkshopInput === null ? null : resolvedLocalDebuggerUrl != null ? resolvedLocalDebuggerUrl : void 0;
@@ -4844,14 +5284,25 @@ 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 });
+}
 
+exports.DEFAULT_MAX_TEXT_FIELD_CHARS = DEFAULT_MAX_TEXT_FIELD_CHARS2;
 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.TRUNCATION_MARKER = TRUNCATION_MARKER2;
 exports._resetParentToolContextStorage = _resetParentToolContextStorage;
 exports._resetRaindropCallMetadataStorage = _resetRaindropCallMetadataStorage;
 exports._resetWarnedMissingUserId = _resetWarnedMissingUserId;
+exports.boundedStringify = boundedStringify;
+exports.capText = capText2;
 exports.clearParentToolContext = clearParentToolContext;
 exports.createRaindropAISDK = createRaindropAISDK;
 exports.currentSpan = currentSpan;
@@ -4862,6 +5313,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;