raindrop-ai 0.1.1 → 0.1.2

package/dist/index.js

@@ -5771,7 +5771,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../core/dist/chunk-OLYXZCOK.js
+// ../core/dist/chunk-U5HUTMR5.js
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_RETRY_DELAY_MS = 3e4;
 function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -5779,6 +5781,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");
@@ -5795,12 +5837,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, opName, opts) {
   const prefix = opts.sdkName ? `[raindrop-ai/${opts.sdkName}]` : "[raindrop-ai/core]";
@@ -5835,7 +5877,9 @@ async function withRetry(operation, opName, opts) {
   throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 async function postJson(url, body, headers, opts) {
-  const opName = `POST ${url}`;
+  var _a;
+  const opName = `POST ${redactUrlForLog(url)}`;
+  const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
   await withRetry(
     async () => {
       const resp = await fetch(url, {
@@ -5844,7 +5888,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(() => "");
@@ -5861,6 +5906,108 @@ async function postJson(url, body, headers, opts) {
     opts
   );
 }
+var DEFAULT_MAX_TEXT_FIELD_CHARS = 1e6;
+var TRUNCATION_MARKER = "...[truncated by raindrop]";
+var BOUNDED_CLONE_MAX_DEPTH = 12;
+var BOUNDED_CLONE_SLACK = 256;
+var currentDefaultMaxTextFieldChars = DEFAULT_MAX_TEXT_FIELD_CHARS;
+function setDefaultMaxTextFieldChars(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    currentDefaultMaxTextFieldChars = Math.floor(value);
+  }
+}
+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);
+}
+function boundedClone(obj, charBudget) {
+  let budget = charBudget;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node, depth) => {
+    if (budget <= 0) return TRUNCATION_MARKER;
+    if (typeof node === "string") {
+      if (node.length > budget) {
+        const taken = node.slice(0, Math.max(0, budget)) + TRUNCATION_MARKER;
+        budget = 0;
+        return taken;
+      }
+      budget -= Math.max(node.length, 1);
+      return node;
+    }
+    if (node === null || typeof node === "number" || typeof node === "boolean") {
+      budget -= 8;
+      return node;
+    }
+    if (typeof node !== "object") {
+      budget -= 8;
+      return node;
+    }
+    if (seen.has(node)) return "[CIRCULAR]";
+    if (depth >= BOUNDED_CLONE_MAX_DEPTH) {
+      budget -= 16;
+      return `<max depth>`;
+    }
+    seen.add(node);
+    if (Array.isArray(node)) {
+      const out2 = [];
+      for (const v of node) {
+        if (budget <= 0) {
+          out2.push(TRUNCATION_MARKER);
+          break;
+        }
+        out2.push(walk(v, depth + 1));
+      }
+      return out2;
+    }
+    if (typeof node.toJSON === "function") {
+      budget -= 16;
+      return node;
+    }
+    const out = {};
+    for (const k in node) {
+      if (!Object.prototype.hasOwnProperty.call(node, k)) continue;
+      if (budget <= 0) {
+        out["..."] = TRUNCATION_MARKER;
+        break;
+      }
+      const key = walk(k, depth + 1);
+      out[key] = walk(node[k], depth + 1);
+    }
+    return out;
+  };
+  return walk(obj, 0);
+}
+function stringifyBounded(value, limit) {
+  const max = limit != null ? limit : currentDefaultMaxTextFieldChars;
+  if (typeof value === "string") {
+    return capText(value, max);
+  }
+  const pruned = boundedClone(value, max + TRUNCATION_MARKER.length + BOUNDED_CLONE_SLACK);
+  let json;
+  try {
+    json = JSON.stringify(pruned);
+  } catch (e) {
+    json = void 0;
+  }
+  if (json === void 0) {
+    return capText(String(value), max);
+  }
+  return json.length <= max ? json : truncateToLimit(json, max);
+}
 var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
 var WORKSHOP_ENV_VAR = "RAINDROP_WORKSHOP";
 var DEFAULT_LOCAL_WORKSHOP_URL = "http://localhost:5899/v1/";
@@ -5969,6 +6116,13 @@ function sendLocalDebuggerLiveEvent(event, options = {}) {
   ).catch(() => {
   });
 }
+var SHUTDOWN_DEADLINE_MS = 1e4;
+var POST_SHUTDOWN_TIMEOUT_MS = 5e3;
+var DEFAULT_REDACT_ATTRIBUTE_KEYS = [
+  "ai.request.providerOptions",
+  "ai.response.providerMetadata"
+];
+var REDACT_JSON_ATTRIBUTE_KEYS = new Set(DEFAULT_REDACT_ATTRIBUTE_KEYS);
 
 // ../core/dist/index.node.js
 var import_async_hooks = require("async_hooks");
@@ -10082,7 +10236,7 @@ var SignalEventSchema = external_exports.object({
 // package.json
 var package_default = {
   name: "raindrop-ai",
-  version: "0.1.1",
+  version: "0.1.2",
   main: "dist/index.js",
   module: "dist/index.mjs",
   types: "dist/index.d.ts",
@@ -10326,12 +10480,12 @@ function parseRetryAfter2(headers) {
 function getRetryDelayMs2(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 withRetry2(operation, opName, opts) {
   let lastError = void 0;
@@ -10363,7 +10517,9 @@ async function withRetry2(operation, opName, opts) {
   throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 async function postJson2(url, body, headers, opts) {
-  const opName = `POST ${url}`;
+  var _a;
+  const opName = `POST ${redactUrlForLog(url)}`;
+  const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
   await withRetry2(
     async () => {
       const resp = await fetch(url, {
@@ -10372,7 +10528,8 @@ async function postJson2(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(() => "");
@@ -10520,16 +10677,19 @@ function getActiveTraceContext() {
 
 // src/tracing/direct/shipper.ts
 function serializeAssociationValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  const jsonValue = JSON.stringify(value);
-  return jsonValue === void 0 ? String(value) : jsonValue;
+  return stringifyBounded(value);
 }
 var DirectTraceShipper = class {
   constructor(opts) {
     this.queue = [];
     this.inFlight = /* @__PURE__ */ new Set();
+    /**
+     * Set once `shutdown()` begins and never cleared. Sends issued after the
+     * drain window (stragglers, or flush work the deadline abandoned
+     * mid-drain) run as a single short attempt instead of regaining the full
+     * retry schedule.
+     */
+    this.hasShutdown = false;
     var _a, _b, _c, _d, _e, _f;
     this.writeKey = opts.writeKey;
     this.baseUrl = (_a = formatEndpoint2(opts.endpoint)) != null ? _a : "https://api.raindrop.ai/v1/";
@@ -10654,14 +10814,19 @@ var DirectTraceShipper = class {
         if (this.debug) console.log(`[raindrop] direct: dropped ${batch.length} cloud spans (local-only)`);
         continue;
       }
+      const opts = this.requestOpts();
+      if (!opts) {
+        rateLimitedLog(
+          "js-sdk.direct.shutdown_deadline",
+          () => console.warn(
+            `[raindrop] direct: shutdown flush deadline exceeded; dropping ${batch.length} spans`
+          )
+        );
+        continue;
+      }
       const body = buildExportTraceServiceRequest2(batch);
       const url = `${this.baseUrl}traces`;
-      const p = postJson2(
-        url,
-        body,
-        { Authorization: `Bearer ${this.writeKey}` },
-        { maxAttempts: 3, debug: this.debug }
-      );
+      const p = postJson2(url, body, { Authorization: `Bearer ${this.writeKey}` }, opts);
       this.inFlight.add(p);
       try {
         try {
@@ -10678,14 +10843,48 @@ var DirectTraceShipper = class {
       }
     }
   }
+  /**
+   * Retry/timeout options for one batch POST, honoring the shutdown budget:
+   * outside shutdown, the normal 3-attempt schedule; during shutdown, a
+   * single attempt clamped to the remaining window; `null` once the window
+   * is exhausted (caller drops the batch). After shutdown() returns,
+   * stragglers run as a single short attempt.
+   */
+  requestOpts() {
+    if (this.shutdownDeadlineAt !== void 0) {
+      const remainingMs = this.shutdownDeadlineAt - Date.now();
+      if (remainingMs <= 0) return null;
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
+      };
+    }
+    if (this.hasShutdown) {
+      return { maxAttempts: 1, debug: this.debug, timeoutMs: POST_SHUTDOWN_TIMEOUT_MS };
+    }
+    return { maxAttempts: 3, debug: this.debug };
+  }
   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 && this.debug) {
+        console.warn("[raindrop] direct: shutdown deadline exceeded; abandoning in-flight spans");
+      }
+    } finally {
+      this.shutdownDeadlineAt = void 0;
     }
-    await this.flush();
-    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
-    })));
   }
 };
 
@@ -10701,7 +10900,7 @@ function getPropertiesFromContext(context5) {
     ...context5.properties || {}
   };
   if (context5.attachments && context5.attachments.length > 0) {
-    properties.attachments = JSON.stringify(context5.attachments);
+    properties.attachments = stringifyBounded(context5.attachments);
   }
   return properties;
 }
@@ -10719,11 +10918,7 @@ function serializeAssociationProperties(properties) {
   );
 }
 function serializeSpanValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  const jsonValue = JSON.stringify(value);
-  return jsonValue === void 0 ? String(value) : jsonValue;
+  return stringifyBounded(value);
 }
 function getLocalDebuggerMetadata(context5) {
   return {
@@ -11002,7 +11197,7 @@ var LiveInteraction = class {
         error = err instanceof Error ? err.message : String(err);
         const endTimeMs2 = Date.now();
         const durationMs2 = endTimeMs2 - startTimeMs;
-        const inputStr2 = params.inputParameters ? JSON.stringify(params.inputParameters) : void 0;
+        const inputStr2 = params.inputParameters ? stringifyBounded(params.inputParameters) : void 0;
         this.directShipper.sendToolSpan({
           name: toolName,
           spanId: spanIdB64,
@@ -11031,8 +11226,8 @@ var LiveInteraction = class {
       }
       const endTimeMs = Date.now();
       const durationMs = endTimeMs - startTimeMs;
-      const inputStr = params.inputParameters ? JSON.stringify(params.inputParameters) : void 0;
-      const outputStr = result !== void 0 ? typeof result === "string" ? result : JSON.stringify(result) : void 0;
+      const inputStr = params.inputParameters ? stringifyBounded(params.inputParameters) : void 0;
+      const outputStr = result !== void 0 ? stringifyBounded(result) : void 0;
       this.directShipper.sendToolSpan({
         name: toolName,
         spanId: spanIdB64,
@@ -11269,8 +11464,8 @@ var LiveInteraction = class {
       const traceIdB64 = this.ensureTraceId(activeContext.traceIdB64);
       const { parentSpanIdB64 } = activeContext;
       const spanIdB64 = base64Encode2(randomBytes2(8));
-      const inputStr = input !== void 0 ? typeof input === "string" ? input : JSON.stringify(input) : void 0;
-      const outputStr = output !== void 0 ? typeof output === "string" ? output : JSON.stringify(output) : void 0;
+      const inputStr = input !== void 0 ? stringifyBounded(input) : void 0;
+      const outputStr = output !== void 0 ? stringifyBounded(output) : void 0;
       this.directShipper.sendToolSpan({
         name,
         spanId: spanIdB64,
@@ -11317,12 +11512,10 @@ var LiveInteraction = class {
     span.setAttribute("traceloop.span.kind", "tool");
     setAssociationProperties(span, properties);
     if (input !== void 0) {
-      const inputStr = typeof input === "string" ? input : JSON.stringify(input);
-      span.setAttribute("traceloop.entity.input", inputStr);
+      span.setAttribute("traceloop.entity.input", stringifyBounded(input));
     }
     if (output !== void 0) {
-      const outputStr = typeof output === "string" ? output : JSON.stringify(output);
-      span.setAttribute("traceloop.entity.output", outputStr);
+      span.setAttribute("traceloop.entity.output", stringifyBounded(output));
     }
     if (durationMs !== void 0) {
       span.setAttribute("traceloop.entity.duration_ms", durationMs);
@@ -11410,8 +11603,8 @@ var LiveTracer = class {
     if (this.directShipper) {
       const { traceIdB64, parentSpanIdB64 } = getActiveTraceContext();
       const spanIdB64 = base64Encode2(randomBytes2(8));
-      const inputStr = input !== void 0 ? typeof input === "string" ? input : JSON.stringify(input) : void 0;
-      const outputStr = output !== void 0 ? typeof output === "string" ? output : JSON.stringify(output) : void 0;
+      const inputStr = input !== void 0 ? stringifyBounded(input) : void 0;
+      const outputStr = output !== void 0 ? stringifyBounded(output) : void 0;
       this.directShipper.sendToolSpan({
         name,
         spanId: spanIdB64,
@@ -11455,12 +11648,10 @@ var LiveTracer = class {
     });
     span.setAttribute("traceloop.span.kind", "tool");
     if (input !== void 0) {
-      const inputStr = typeof input === "string" ? input : JSON.stringify(input);
-      span.setAttribute("traceloop.entity.input", inputStr);
+      span.setAttribute("traceloop.entity.input", stringifyBounded(input));
     }
     if (output !== void 0) {
-      const outputStr = typeof output === "string" ? output : JSON.stringify(output);
-      span.setAttribute("traceloop.entity.output", outputStr);
+      span.setAttribute("traceloop.entity.output", stringifyBounded(output));
     }
     if (durationMs !== void 0) {
       span.setAttribute("traceloop.entity.duration_ms", durationMs);
@@ -11892,6 +12083,7 @@ function getCurrentTraceId() {
   return (_a = import_api4.trace.getSpan(import_api4.context.active())) == null ? void 0 : _a.spanContext().traceId;
 }
 var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
+  process.env.TRACELOOP_TELEMETRY = "false";
   const {
     logLevel,
     useExternalOtel,
@@ -12192,7 +12384,6 @@ var PartialClientAiTrack = ClientAiTrack.extend({
 var AttachmentTypeSchema = import_zod.z.enum(["code", "text", "image", "iframe"]);
 
 // src/index.ts
-process.env.TRACELOOP_TELEMETRY = "false";
 var MAX_INGEST_SIZE_BYTES = 1 * 1024 * 1024;
 var SELF_DIAGNOSTICS_TOOL_NAME_DEFAULT = "__raindrop_report";
 var SELF_DIAGNOSTICS_SOURCE_DEFAULT = "agent_reporting_tool";
@@ -12317,12 +12508,12 @@ function parseRetryAfter3(headers) {
 }
 function getRetryDelayMs3(attemptNumber, previousError) {
   if (previousError && typeof previousError.retryAfterMs === "number") {
-    return Math.max(0, previousError.retryAfterMs);
+    return Math.min(Math.max(0, previousError.retryAfterMs), 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 withRetry3(operation, opName, maxAttempts, debugLogs = false) {
   var _a;
@@ -12361,7 +12552,16 @@ var Raindrop = class {
     this.partialEventBuffer = /* @__PURE__ */ new Map();
     this.partialEventTimeouts = /* @__PURE__ */ new Map();
     this.inFlightRequests = /* @__PURE__ */ new Set();
+    /**
+     * Set once `close()` begins and never cleared. Sends issued after the
+     * drain window (stragglers, or flush work the deadline abandoned
+     * mid-drain) run as a single short attempt instead of regaining the full
+     * retry schedule.
+     */
+    this.hasShutdown = false;
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    setDefaultMaxTextFieldChars(config.maxTextFieldChars);
+    this.maxTextFieldChars = resolveMaxTextFieldChars(config.maxTextFieldChars);
     this.writeKey = (_a = config.writeKey) != null ? _a : "";
     this.localDebuggerUrlOpt = config.localWorkshopUrl === false ? null : config.localWorkshopUrl;
     this.apiUrl = (_b = this.formatEndpoint(config.endpoint)) != null ? _b : `https://api.raindrop.ai/v1/`;
@@ -12584,14 +12784,16 @@ var Raindrop = class {
         eventId,
         userId,
         model,
-        input,
-        output,
+        input: rawInput,
+        output: rawOutput,
         convoId,
         attachments,
         properties,
         timestamp,
         ...rest
       } = e;
+      const input = capText(rawInput, this.maxTextFieldChars);
+      const output = capText(rawOutput, this.maxTextFieldChars);
       const customEventId = eventId != null ? eventId : crypto.randomUUID();
       const parsedAttachments = AttachmentSchema.array().safeParse(attachments != null ? attachments : []);
       if (!parsedAttachments.success) {
@@ -12798,20 +13000,51 @@ var Raindrop = class {
       void fetch(`${localUrl}${endpoint}`, {
         method: "POST",
         headers,
-        body: JSON.stringify(body)
+        body: JSON.stringify(body),
+        // Bounded like the cloud paths: a black-holed Workshop URL must not
+        // pin connections indefinitely (fire-and-forget still holds sockets).
+        signal: AbortSignal.timeout(DEFAULT_REQUEST_TIMEOUT_MS)
       }).catch(() => {
       });
     } catch (e) {
     }
   }
+  /**
+   * Attempts/timeout budget for one POST, honoring the close() deadline.
+   * Returns `null` when the shutdown budget is exhausted — the caller must
+   * drop the payload instead of issuing a request that could outlive
+   * process exit. Checked fresh on every send so a deadline that expires
+   * mid-drain takes effect immediately.
+   */
+  requestBudget() {
+    if (this.shutdownDeadlineAt !== void 0) {
+      const remainingMs = this.shutdownDeadlineAt - Date.now();
+      if (remainingMs <= 0) return null;
+      return { maxAttempts: 1, timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs) };
+    }
+    if (this.hasShutdown) {
+      return { maxAttempts: 1, timeoutMs: POST_SHUTDOWN_TIMEOUT_MS };
+    }
+    return { maxAttempts: 3, timeoutMs: DEFAULT_REQUEST_TIMEOUT_MS };
+  }
+  warnShutdownDrop(what) {
+    rateLimitedLog(
+      "js-sdk.shutdown_deadline",
+      () => console.warn(`[raindrop] shutdown flush deadline exceeded; dropping ${what}`)
+    );
+  }
   async sendBatchToApi(events, endpoint) {
-    var _a;
     const body = events.map(({ type, ...event }) => event);
     this.mirrorBatchToLocalDebugger(endpoint, body);
     if (this.localOnly) {
       return;
     }
-    const opName = `POST ${endpoint}`;
+    const opName = `POST ${redactUrlForLog(this.apiUrl + endpoint)}`;
+    const budget = this.requestBudget();
+    if (!budget) {
+      this.warnShutdownDrop(`${events.length} event(s) for ${endpoint}`);
+      return;
+    }
     try {
       const response = await withRetry3(
         async () => {
@@ -12821,7 +13054,11 @@ var Raindrop = class {
               "Content-Type": "application/json",
               Authorization: `Bearer ${this.writeKey}`
             },
-            body: JSON.stringify(body)
+            body: JSON.stringify(body),
+            // Bounded: a dead or black-holed endpoint must never pin this
+            // request (and the flush/close paths awaiting it) until the OS
+            // gives up.
+            signal: AbortSignal.timeout(budget.timeoutMs)
           });
           if (!resp.ok) {
             const text = await resp.text().catch(() => "");
@@ -12835,7 +13072,7 @@ var Raindrop = class {
           return resp;
         },
         opName,
-        3,
+        budget.maxAttempts,
         this.debugLogs
       );
       if (this.debugLogs) {
@@ -12844,9 +13081,18 @@ var Raindrop = class {
       return response;
     } catch (error) {
       if (error == null ? void 0 : error.response) {
-        console.error(`[raindrop] Error in response (${opName}): ` + error.response.data);
+        rateLimitedLog(
+          `js-sdk.batch_failed.${endpoint}`,
+          () => console.error(`[raindrop] Error in response (${opName}): ` + error.response.data)
+        );
       } else {
-        console.error(`[raindrop] Error (${opName}): ` + ((_a = error == null ? void 0 : error.message) != null ? _a : String(error)));
+        rateLimitedLog(
+          `js-sdk.batch_failed.${endpoint}`,
+          () => {
+            var _a;
+            return console.error(`[raindrop] Error (${opName}): ` + ((_a = error == null ? void 0 : error.message) != null ? _a : String(error)));
+          }
+        );
       }
     }
   }
@@ -12903,6 +13149,12 @@ var Raindrop = class {
       console.warn("[raindrop] trackAiPartial requires an eventId.");
       return Promise.resolve();
     }
+    if (typeof rest.input === "string") {
+      rest.input = capText(rest.input, this.maxTextFieldChars);
+    }
+    if (typeof rest.output === "string") {
+      rest.output = capText(rest.output, this.maxTextFieldChars);
+    }
     const existingEvent = this.partialEventBuffer.get(eventId) || {};
     const mergedEvent = this.deepMergeObjects(
       { ...existingEvent },
@@ -12933,7 +13185,7 @@ var Raindrop = class {
     this.partialEventTimeouts.set(eventId, newTimeout);
     if (this.debugLogs) {
       console.log(
-        `[raindrop] Updated partial event buffer for eventId: ${eventId}. Timeout reset (20s). Event: ${JSON.stringify(mergedEvent)}`
+        `[raindrop] Updated partial event buffer for eventId: ${eventId}. Timeout reset (2s). Event: ${stringifyBounded(mergedEvent, 2e3)}`
       );
     }
     return Promise.resolve();
@@ -12949,9 +13201,12 @@ var Raindrop = class {
     try {
       await flushPromise;
     } catch (error) {
-      console.error(
-        `[raindrop] Failed to flush partial event ${eventId}:`,
-        error instanceof Error ? error : String(error)
+      rateLimitedLog(
+        "js-sdk.partial_flush_failed",
+        () => console.error(
+          `[raindrop] Failed to flush partial event ${eventId}:`,
+          error instanceof Error ? error : String(error)
+        )
       );
     } finally {
       this.inFlightRequests.delete(flushPromise);
@@ -13019,7 +13274,7 @@ var Raindrop = class {
     const parsed = PartialClientAiTrack.partial().safeParse(eventToSend);
     if (!parsed.success) {
       console.warn(
-        `[raindrop] Invalid accumulated data for partial eventId ${eventId}. Event not sent. Errors: ${this.formatZodError(parsed.error)} Data: ${JSON.stringify(eventToSend)}`
+        `[raindrop] Invalid accumulated data for partial eventId ${eventId}. Event not sent. Errors: ${this.formatZodError(parsed.error)} Data: ${stringifyBounded(eventToSend, 2e3)}`
       );
       return;
     }
@@ -13043,7 +13298,6 @@ var Raindrop = class {
    * @param event - The event data conforming to ClientAiTrack schema.
    */
   async sendPartialEvent(event) {
-    var _a;
     const endpoint = "events/track_partial";
     const opName = `POST ${endpoint}`;
     mirrorPartialEventToLocalDebugger(event, {
@@ -13055,6 +13309,11 @@ var Raindrop = class {
     if (this.localOnly) {
       return;
     }
+    const budget = this.requestBudget();
+    if (!budget) {
+      this.warnShutdownDrop(`partial event ${event.event_id}`);
+      return;
+    }
     try {
       const response = await withRetry3(
         async () => {
@@ -13064,8 +13323,10 @@ var Raindrop = class {
               "Content-Type": "application/json",
               Authorization: `Bearer ${this.writeKey}`
             },
-            body: JSON.stringify(event)
+            body: JSON.stringify(event),
             // Send the single event object
+            // Bounded: see sendBatchToApi.
+            signal: AbortSignal.timeout(budget.timeoutMs)
           });
           if (!resp.ok) {
             const errorBody = await resp.text().catch(() => "");
@@ -13079,7 +13340,7 @@ var Raindrop = class {
           return resp;
         },
         opName,
-        3,
+        budget.maxAttempts,
         this.debugLogs
       );
       if (this.debugLogs) {
@@ -13089,8 +13350,14 @@ var Raindrop = class {
       }
       return response;
     } catch (error) {
-      console.error(
-        `[raindrop] Failed to send partial event ${event.event_id} to ${endpoint}: ${(_a = error == null ? void 0 : error.message) != null ? _a : String(error)}`
+      rateLimitedLog(
+        "js-sdk.partial_failed",
+        () => {
+          var _a;
+          return console.error(
+            `[raindrop] Failed to send partial event ${event.event_id} to ${endpoint}: ${(_a = error == null ? void 0 : error.message) != null ? _a : String(error)}`
+          );
+        }
       );
       throw error;
     }
@@ -13109,7 +13376,21 @@ var Raindrop = class {
     }
   }
   async close() {
-    await this._tracing.close();
+    this.hasShutdown = true;
+    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
+    try {
+      await this.closeWithinDeadline();
+    } finally {
+      this.shutdownDeadlineAt = void 0;
+    }
+  }
+  async closeWithinDeadline() {
+    const remainingMs = () => {
+      var _a;
+      return Math.max(0, ((_a = this.shutdownDeadlineAt) != null ? _a : Date.now()) - Date.now());
+    };
+    const tracingSettled = await raceWithTimeout(this._tracing.close(), remainingMs());
+    if (!tracingSettled) this.warnShutdownDrop("in-flight trace flush");
     try {
       await this.flush();
     } catch (error) {
@@ -13138,7 +13419,12 @@ var Raindrop = class {
         );
       }
       try {
-        await Promise.all(Array.from(this.inFlightRequests));
+        const settled = await raceWithTimeout(
+          Promise.allSettled(Array.from(this.inFlightRequests)).then(() => {
+          }),
+          remainingMs()
+        );
+        if (!settled) this.warnShutdownDrop("in-flight partial event request(s)");
       } catch (e) {
         console.error(`[raindrop] Error waiting for in-flight requests:`, e);
       }