@raindrop-ai/openai-managed-agents 0.0.4 → 0.0.5

package/dist/index.js

@@ -25,7 +25,36 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../core/dist/chunk-BYBMRLZM.js
+// ../core/dist/chunk-ZCB62SIO.js
+var __create = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var EVAL_CORRELATION_ID_ATTRIBUTE = "raindrop.eval_correlation_id";
 var PROBE_SCOPE = { correlationId: "" };
 var EvalScopeStorage = class {
@@ -87,21 +116,246 @@ function evalScopeAttributes() {
   return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
 }
 
-// ../core/dist/chunk-QH6U6QYP.js
+// ../core/dist/chunk-AX36JKJL.js
+var require_NameRedactor = __commonJS({
+  "../redact-pii/dist/built-ins/NameRedactor.js"(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.NameRedactor = void 0;
+    var greetingRegex = /(^|\.\s+)(dear|hi|hello|greetings|hey|hey there)/gi;
+    var closingRegex = /(thx|thanks|thank you|regards|best|[a-z]{1,30}ly|[a-z]{1,30} regards|all the best|happy [a-z]{1,30}ing|take care|have a [a-z]{1,30} (weekend|night|day))/gi;
+    var greetingOrClosing = new RegExp("(((" + greetingRegex.source + ")|(" + closingRegex.source + "\\s*[,.!]*))[\\s-]*)", "gi");
+    var genericName = new RegExp("( ?(([A-Z][a-z]{1,30})|([A-Z]\\.))){1,10}([,.]|[,.]?$)", "my");
+    var NameRedactor = class {
+      constructor(replaceWith = "PERSON_NAME") {
+        this.replaceWith = replaceWith;
+      }
+      redact(textToRedact) {
+        var _a;
+        greetingOrClosing.lastIndex = 0;
+        genericName.lastIndex = 0;
+        const pieces = [];
+        let copiedThrough = 0;
+        let changed = false;
+        let greetingOrClosingMatch = greetingOrClosing.exec(textToRedact);
+        while (greetingOrClosingMatch !== null) {
+          genericName.lastIndex = greetingOrClosing.lastIndex;
+          const genericNameMatch = genericName.exec(textToRedact);
+          if (genericNameMatch !== null && genericNameMatch.index === greetingOrClosing.lastIndex) {
+            const suffix = (_a = genericNameMatch[5]) !== null && _a !== void 0 ? _a : "";
+            const end = genericNameMatch.index + genericNameMatch[0].length;
+            pieces.push(textToRedact.slice(copiedThrough, genericNameMatch.index), this.replaceWith, suffix);
+            copiedThrough = end;
+            changed = true;
+            greetingOrClosing.lastIndex = end - suffix.length;
+          }
+          greetingOrClosingMatch = greetingOrClosing.exec(textToRedact);
+        }
+        if (!changed)
+          return textToRedact;
+        pieces.push(textToRedact.slice(copiedThrough));
+        return pieces.join("");
+      }
+    };
+    exports2.NameRedactor = NameRedactor;
+  }
+});
+var require_simple_regexp_patterns = __commonJS({
+  "../redact-pii/dist/built-ins/simple-regexp-patterns.js"(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.url = exports2.digits = exports2.credentials = exports2.password = exports2.username = exports2.emailAddress = exports2.usSocialSecurityNumber = exports2.ipAddress = exports2.phoneNumber = exports2.zipcode = exports2.streetAddress = exports2.creditCardNumber = void 0;
+    var aptRegex = /(apt|bldg|dept|fl|hngr|lot|pier|rm|ste|slip|trlr|unit|#)\.? *[a-z0-9-]+\b/gi;
+    var poBoxRegex = /P\.? ?O\.? *Box +\d+/gi;
+    var roadRegex = /(street|st|road|rd|avenue|ave|drive|dr|loop|court|ct|circle|cir|lane|ln|boulevard|blvd|way)\.?\b/gi;
+    exports2.creditCardNumber = /\d{4}[ -]?\d{4}[ -]?\d{4}[ -]?\d{4}|\d{4}[ -]?\d{6}[ -]?\d{4}\d?/g;
+    exports2.streetAddress = new RegExp("(\\d{1,10}\\s*(\\w{1,30} ){1,2}" + roadRegex.source + "(\\s+" + aptRegex.source + ")?)|(" + poBoxRegex.source + ")", "gi");
+    exports2.zipcode = /\b\d{5}\b(-\d{4})?\b/g;
+    exports2.phoneNumber = /(\(?\+?[0-9]{1,2}\)?[-. ]?)?(\(?[0-9]{3}\)?|[0-9]{3})[-. ]?([0-9]{3}[-. ]?[0-9]{4}|\b[A-Z0-9]{7}\b)/g;
+    exports2.ipAddress = /(\d{1,3}(\.\d{1,3}){3}|[0-9A-F]{4}(:[0-9A-F]{4}){5}(::|(:0000)+))/gi;
+    exports2.usSocialSecurityNumber = /\b\d{3}[ -.]\d{2}[ -.]\d{4}\b/g;
+    exports2.emailAddress = /([a-z0-9_\-.+]{1,64})@\w+(\.\w+)*/gi;
+    exports2.username = /(user( ?name)?|login): \S+/gi;
+    exports2.password = /(pass(word|phrase)?|secret): \S+/gi;
+    exports2.credentials = /(login( cred(ential)?s| info(rmation)?)?|cred(ential)?s) ?:\s*\S+\s+\/?\s*\S+/gi;
+    exports2.digits = /\b\d{4,}\b/g;
+    exports2.url = /([^\s:/?#]{1,64}):\/\/([^/?#\s]*)([^?#\s]*)(\?([^#\s]*))?(#([^\s]*))?/g;
+  }
+});
+var require_utils = __commonJS({
+  "../redact-pii/dist/utils.js"(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.snakeCase = exports2.isSyncRedactor = exports2.isSimpleRegexpCustomRedactorConfig = void 0;
+    function isSimpleRegexpCustomRedactorConfig(redactor2) {
+      return typeof redactor2.regexpPattern !== "undefined";
+    }
+    exports2.isSimpleRegexpCustomRedactorConfig = isSimpleRegexpCustomRedactorConfig;
+    function isSyncRedactor(redactor2) {
+      return typeof redactor2.redact === "function";
+    }
+    exports2.isSyncRedactor = isSyncRedactor;
+    function snakeCase(input = "") {
+      var _a;
+      const words = (_a = input.match(/[A-Z]{2,}(?=[A-Z][a-z]|[0-9]|\b)|[A-Z]?[a-z]+|[A-Z]+|[0-9]+/g)) !== null && _a !== void 0 ? _a : [];
+      return words.map((word) => word.toLowerCase()).join("_");
+    }
+    exports2.snakeCase = snakeCase;
+  }
+});
+var require_SimpleRegexpRedactor = __commonJS({
+  "../redact-pii/dist/built-ins/SimpleRegexpRedactor.js"(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SimpleRegexpRedactor = void 0;
+    var utils_1 = require_utils();
+    var SimpleRegexpRedactor = class {
+      constructor({ replaceWith = (0, utils_1.snakeCase)().toUpperCase(), regexpPattern: regexpMatcher }) {
+        this.replaceWith = replaceWith;
+        this.regexpMatcher = regexpMatcher;
+      }
+      redact(textToRedact) {
+        return textToRedact.replace(this.regexpMatcher, this.replaceWith);
+      }
+    };
+    exports2.SimpleRegexpRedactor = SimpleRegexpRedactor;
+  }
+});
+var require_composition = __commonJS({
+  "../redact-pii/dist/composition.js"(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.composeChildRedactors = void 0;
+    var NameRedactor_1 = require_NameRedactor();
+    var simpleRegexpBuiltIns = require_simple_regexp_patterns();
+    var SimpleRegexpRedactor_1 = require_SimpleRegexpRedactor();
+    var utils_1 = require_utils();
+    function normalizeCustomRedactorConfig(redactorConfig) {
+      return (0, utils_1.isSimpleRegexpCustomRedactorConfig)(redactorConfig) ? new SimpleRegexpRedactor_1.SimpleRegexpRedactor({
+        regexpPattern: redactorConfig.regexpPattern,
+        replaceWith: redactorConfig.replaceWith
+      }) : redactorConfig;
+    }
+    function composeChildRedactors(opts = {}) {
+      var _a, _b, _c, _d;
+      const childRedactors = [];
+      if (opts.customRedactors && opts.customRedactors.before) {
+        opts.customRedactors.before.map(normalizeCustomRedactorConfig).forEach((redactor2) => childRedactors.push(redactor2));
+      }
+      for (const regexpName of Object.keys(simpleRegexpBuiltIns)) {
+        if (!opts.builtInRedactors || !opts.builtInRedactors[regexpName] || opts.builtInRedactors[regexpName].enabled !== false) {
+          childRedactors.push(new SimpleRegexpRedactor_1.SimpleRegexpRedactor({
+            regexpPattern: simpleRegexpBuiltIns[regexpName],
+            replaceWith: ((_b = (_a = opts.builtInRedactors) === null || _a === void 0 ? void 0 : _a[regexpName]) === null || _b === void 0 ? void 0 : _b.replaceWith) || opts.globalReplaceWith || (0, utils_1.snakeCase)(regexpName).toUpperCase()
+          }));
+        }
+      }
+      if (!opts.builtInRedactors || !opts.builtInRedactors.names || opts.builtInRedactors.names.enabled !== false) {
+        childRedactors.push(new NameRedactor_1.NameRedactor(((_d = (_c = opts.builtInRedactors) === null || _c === void 0 ? void 0 : _c.names) === null || _d === void 0 ? void 0 : _d.replaceWith) || opts.globalReplaceWith));
+      }
+      if (opts.customRedactors && opts.customRedactors.after) {
+        opts.customRedactors.after.map(normalizeCustomRedactorConfig).forEach((redactor2) => childRedactors.push(redactor2));
+      }
+      return childRedactors;
+    }
+    exports2.composeChildRedactors = composeChildRedactors;
+  }
+});
+var require_AsyncCompositeRedactor = __commonJS({
+  "../redact-pii/dist/AsyncCompositeRedactor.js"(exports2) {
+    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve2) {
+          resolve2(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve2, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AsyncCompositeRedactor = void 0;
+    var composition_1 = require_composition();
+    var utils_1 = require_utils();
+    var AsyncCompositeRedactor = class {
+      constructor(opts) {
+        this.childRedactors = [];
+        this.redactAsync = (textToRedact) => __awaiter(this, void 0, void 0, function* () {
+          for (const redactor2 of this.childRedactors) {
+            if ((0, utils_1.isSyncRedactor)(redactor2)) {
+              textToRedact = redactor2.redact(textToRedact);
+            } else {
+              textToRedact = yield redactor2.redactAsync(textToRedact);
+            }
+          }
+          return textToRedact;
+        });
+        this.childRedactors = (0, composition_1.composeChildRedactors)(opts);
+      }
+    };
+    exports2.AsyncCompositeRedactor = AsyncCompositeRedactor;
+  }
+});
+var require_SyncCompositeRedactor = __commonJS({
+  "../redact-pii/dist/SyncCompositeRedactor.js"(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SyncCompositeRedactor = void 0;
+    var composition_1 = require_composition();
+    var SyncCompositeRedactor = class {
+      constructor(opts) {
+        this.childRedactors = [];
+        this.redact = (textToRedact) => {
+          for (const redactor2 of this.childRedactors) {
+            textToRedact = redactor2.redact(textToRedact);
+          }
+          return textToRedact;
+        };
+        this.childRedactors = (0, composition_1.composeChildRedactors)(opts);
+      }
+    };
+    exports2.SyncCompositeRedactor = SyncCompositeRedactor;
+  }
+});
+var require_dist = __commonJS({
+  "../redact-pii/dist/index.js"(exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SyncRedactor = exports2.AsyncRedactor = void 0;
+    var AsyncCompositeRedactor_1 = require_AsyncCompositeRedactor();
+    Object.defineProperty(exports2, "AsyncRedactor", { enumerable: true, get: function() {
+      return AsyncCompositeRedactor_1.AsyncCompositeRedactor;
+    } });
+    var SyncCompositeRedactor_1 = require_SyncCompositeRedactor();
+    Object.defineProperty(exports2, "SyncRedactor", { enumerable: true, get: function() {
+      return SyncCompositeRedactor_1.SyncCompositeRedactor;
+    } });
+  }
+});
 var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
 function state() {
   const holder = globalThis;
   let current = holder[STATE_KEY];
   if (!current) {
-    let storage = null;
+    let storage2 = null;
     try {
       const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
-      if (Ctor) storage = new Ctor();
+      if (Ctor) storage2 = new Ctor();
     } catch (e) {
-      storage = null;
+      storage2 = null;
     }
     current = {
-      storage,
+      storage: storage2,
       syncDestination: void 0,
       spanDestinations: /* @__PURE__ */ new WeakMap()
     };
@@ -249,12 +503,12 @@ var NO_AMBIENT_ROUTING_BIND_WARNING = "[raindrop] This runtime's AsyncLocalStora
 var ROUTING_STORAGE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.routingContextStorage");
 function routingStorage() {
   const holder = globalThis;
-  let storage = holder[ROUTING_STORAGE_KEY];
-  if (!storage) {
-    storage = new ContextStackStorage(NO_AMBIENT_ROUTING_BIND_WARNING);
-    holder[ROUTING_STORAGE_KEY] = storage;
+  let storage2 = holder[ROUTING_STORAGE_KEY];
+  if (!storage2) {
+    storage2 = new ContextStackStorage(NO_AMBIENT_ROUTING_BIND_WARNING);
+    holder[ROUTING_STORAGE_KEY] = storage2;
   }
-  return storage;
+  return storage2;
 }
 function currentRoutingBinding() {
   const bound = routingStorage().current();
@@ -540,6 +794,14 @@ function appGitPropertiesFromAttributes(attributes) {
   }
   return properties;
 }
+function normalizeFeatureFlags(input) {
+  if (Array.isArray(input)) {
+    return Object.fromEntries(input.map((name) => [name, "true"]));
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([k, v]) => [k, String(v)])
+  );
+}
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -641,11 +903,91 @@ function runWithTracingSuppressed(fn) {
     return fn();
   }
 }
+var MAX_QUOTED_ITEMS = 3;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function itemLabel(item) {
+  if (typeof item.event_id === "string" && item.event_id) return `event ${item.event_id}`;
+  if (typeof item.index === "number") return `item ${item.index}`;
+  return "item";
+}
+function describeRejected(item) {
+  const issues = Array.isArray(item.issues) ? item.issues : [];
+  const text = issues.filter(isRecord).map((issue) => {
+    const path = typeof issue.path === "string" && issue.path ? `${issue.path}: ` : "";
+    return `${path}${typeof issue.message === "string" ? issue.message : "invalid"}`;
+  }).join("; ");
+  return `${itemLabel(item)} (${text || "invalid"})`;
+}
+function describeWarning(item) {
+  if (typeof item.message === "string" && item.message) return `${itemLabel(item)}: ${item.message}`;
+  const fields = Array.isArray(item.fields) ? item.fields.filter((f) => typeof f === "string") : [];
+  return `${itemLabel(item)}: ignored ${fields.join(", ") || "input"}`;
+}
+function summarize(items, describe) {
+  const quoted = items.slice(0, MAX_QUOTED_ITEMS).map(describe).join(" | ");
+  const more = items.length > MAX_QUOTED_ITEMS ? ` (+${items.length - MAX_QUOTED_ITEMS} more)` : "";
+  return `${quoted}${more}`;
+}
+function reportIngestResponse(bodyText, prefix, opName) {
+  if (!bodyText) return;
+  let body;
+  try {
+    body = JSON.parse(bodyText);
+  } catch (e) {
+    return;
+  }
+  if (!isRecord(body)) return;
+  const rejected = Array.isArray(body.rejected) ? body.rejected.filter(isRecord) : [];
+  if (rejected.length > 0) {
+    rateLimitedLog(
+      `${prefix}.ingest_rejected`,
+      () => console.warn(
+        `${prefix} ${opName}: ingest rejected ${rejected.length} item(s), which were not stored: ${summarize(rejected, describeRejected)}`
+      )
+    );
+  }
+  const warnings = Array.isArray(body.warnings) ? body.warnings.filter(isRecord) : [];
+  if (warnings.length > 0) {
+    rateLimitedLog(
+      `${prefix}.ingest_warnings`,
+      () => console.warn(
+        `${prefix} ${opName}: ingest accepted ${warnings.length} item(s) with changes: ${summarize(warnings, describeWarning)}`
+      )
+    );
+  }
+}
+var DEFAULT_FLUSH_TIMEOUT_MS = 1e4;
 var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 var MAX_RETRY_DELAY_MS = 3e4;
 function wait(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+function waitUnlessAborted(ms, signal) {
+  if (!signal) return wait(ms);
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve2) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve2();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+function eitherSignal(a, b) {
+  if (!b) return a;
+  const any = AbortSignal.any;
+  if (typeof any === "function") return any([a, b]);
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  if (a.aborted || b.aborted) abort();
+  a.addEventListener("abort", abort, { once: true });
+  b.addEventListener("abort", abort, { once: true });
+  return controller.signal;
+}
 function formatEndpoint(endpoint) {
   if (!endpoint) return void 0;
   return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
@@ -690,6 +1032,26 @@ async function raceWithTimeout(promise, timeoutMs) {
   if (timer) clearTimeout(timer);
   return settledInTime;
 }
+var InFlightCutOff = class {
+  constructor() {
+    this.controller = new AbortController();
+  }
+  get signal() {
+    return this.controller.signal;
+  }
+  cut() {
+    this.controller.abort();
+    this.controller = new AbortController();
+  }
+};
+async function awaitEarlierSends(earlier, deadlineAt, cutOff, isRunning) {
+  if (earlier.length === 0) return { settled: true, stillRunning: 0 };
+  const settled = await raceWithTimeout(Promise.allSettled(earlier), deadlineAt - Date.now());
+  if (settled) return { settled, stillRunning: 0 };
+  const stillRunning = earlier.filter(isRunning).length;
+  if (stillRunning > 0) cutOff.cut();
+  return { settled: stillRunning === 0, stillRunning };
+}
 function parseRetryAfter(headers) {
   var _a;
   const value = (_a = headers.get("Retry-After")) != null ? _a : headers.get("retry-after");
@@ -713,45 +1075,80 @@ function getRetryDelayMs(attemptNumber, previousError) {
   const factor = Math.pow(2, attemptNumber - 2);
   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]";
-  let lastError = void 0;
-  for (let attemptNumber = 1; attemptNumber <= opts.maxAttempts; attemptNumber++) {
-    if (attemptNumber > 1) {
-      const delay = getRetryDelayMs(attemptNumber, lastError);
-      if (opts.debug) {
-        console.warn(
-          `${prefix} ${opName} retry ${attemptNumber}/${opts.maxAttempts} in ${delay}ms`
-        );
-      }
-      if (delay > 0) await wait(delay);
-    } else if (opts.debug) {
-      console.log(`${prefix} ${opName} attempt ${attemptNumber}/${opts.maxAttempts}`);
-    }
-    try {
-      return await operation();
-    } catch (err) {
-      lastError = err;
-      if (opts.debug) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.warn(
-          `${prefix} ${opName} attempt ${attemptNumber} failed: ${msg}${attemptNumber === opts.maxAttempts ? " (no more retries)" : ""}`
-        );
-      }
-      if (lastError && typeof lastError === "object" && "retryable" in lastError && !lastError.retryable)
-        break;
-      if (attemptNumber === opts.maxAttempts) break;
-    }
+var sendPausedUntil = /* @__PURE__ */ new Map();
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch (e) {
+    return url;
+  }
+}
+function noteSendPause(url, status, retryAfterMs) {
+  var _a;
+  if (status !== 429 && status !== 503 || typeof retryAfterMs !== "number") return;
+  const until = Date.now() + Math.min(Math.max(0, retryAfterMs), MAX_RETRY_DELAY_MS);
+  const origin = originOf(url);
+  sendPausedUntil.set(origin, Math.max((_a = sendPausedUntil.get(origin)) != null ? _a : 0, until));
+}
+function pausedUntil(url) {
+  const until = sendPausedUntil.get(originOf(url));
+  if (until === void 0) return void 0;
+  if (until <= Date.now()) {
+    sendPausedUntil.delete(originOf(url));
+    return void 0;
   }
-  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  return Math.min(until, Date.now() + MAX_RETRY_DELAY_MS);
+}
+function prefixFor(opts) {
+  return opts.sdkName ? `[raindrop-ai/${opts.sdkName}]` : "[raindrop-ai/core]";
 }
 async function postJson(url, body, headers, opts) {
+  var _a;
+  const outcome = await sendJson(url, body, headers, { ...opts, deadlineAt: void 0 });
+  if (outcome.status === "delivered") return;
+  throw (_a = outcome.error) != null ? _a : new Error(`${redactUrlForLog(url)}: not sent (${outcome.status})`);
+}
+async function sendJson(url, body, headers, opts) {
   var _a;
   const opName = `POST ${redactUrlForLog(url)}`;
+  const prefix = prefixFor(opts);
   const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
-  await withRetry(
-    async () => {
-      const resp = await runWithTracingSuppressed(
+  const deadlineAt = opts.deadlineAt;
+  const remaining = () => deadlineAt === void 0 ? Infinity : deadlineAt - Date.now();
+  let lastError;
+  const cutOff = opts.cutOff;
+  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+    if (cutOff == null ? void 0 : cutOff.aborted) return { status: "deferred", error: lastError };
+    if (attempt > 1) {
+      const delay = getRetryDelayMs(attempt, lastError);
+      if (delay >= remaining()) {
+        return { status: "deferred", retryAtMs: Date.now() + delay, error: lastError };
+      }
+      if (opts.debug) {
+        console.warn(`${prefix} ${opName} retry ${attempt}/${opts.maxAttempts} in ${delay}ms`);
+      }
+      if (delay > 0) await waitUnlessAborted(delay, cutOff);
+      if (cutOff == null ? void 0 : cutOff.aborted) return { status: "deferred", error: lastError };
+    } else if (opts.debug) {
+      console.log(`${prefix} ${opName} attempt ${attempt}/${opts.maxAttempts}`);
+    }
+    const pauseEnd = pausedUntil(url);
+    if (pauseEnd !== void 0) {
+      if (deadlineAt !== void 0 && pauseEnd >= deadlineAt) {
+        return { status: "deferred", retryAtMs: pauseEnd, error: lastError };
+      }
+      await waitUnlessAborted(Math.max(0, pauseEnd - Date.now()), cutOff);
+      if (cutOff == null ? void 0 : cutOff.aborted) return { status: "deferred", retryAtMs: pauseEnd, error: lastError };
+    }
+    const left = remaining();
+    if (left <= 0) return { status: "deferred", error: lastError };
+    const attemptTimeoutMs = Math.min(timeoutMs, left);
+    const clampedByDeadline = attemptTimeoutMs < timeoutMs;
+    const timeoutSignal = AbortSignal.timeout(attemptTimeoutMs);
+    const signal = eitherSignal(timeoutSignal, cutOff);
+    let resp;
+    try {
+      resp = await runWithTracingSuppressed(
         () => fetch(url, {
           method: "POST",
           redirect: headers["X-Raindrop-Replay-Id"] !== void 0 ? "error" : "follow",
@@ -760,24 +1157,98 @@ async function postJson(url, body, headers, opts) {
             ...headers
           },
           body: JSON.stringify(body),
-          signal: AbortSignal.timeout(timeoutMs)
+          signal
         })
       );
-      if (!resp.ok) {
-        const text = await resp.text().catch(() => "");
-        const err = new Error(
-          `HTTP ${resp.status} ${resp.statusText}${text ? `: ${text}` : ""}`
-        );
-        const retryAfterMs = parseRetryAfter(resp.headers);
-        if (typeof retryAfterMs === "number") err.retryAfterMs = retryAfterMs;
-        err.retryable = resp.status === 429 || resp.status >= 500;
-        throw err;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if ((cutOff == null ? void 0 : cutOff.aborted) || timeoutSignal.aborted && clampedByDeadline) {
+        return { status: "cut_off", error };
       }
-    },
-    opName,
-    opts
+      lastError = error;
+      logAttemptFailure(opts, prefix, opName, attempt, error);
+      continue;
+    }
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      const error = new Error(
+        `HTTP ${resp.status} ${resp.statusText}${text ? `: ${text}` : ""}`
+      );
+      const retryAfterMs = parseRetryAfter(resp.headers);
+      if (typeof retryAfterMs === "number") error.retryAfterMs = retryAfterMs;
+      noteSendPause(url, resp.status, retryAfterMs);
+      error.retryable = resp.status === 408 || resp.status === 429 || resp.status >= 500;
+      if (!error.retryable) return { status: "rejected", error };
+      lastError = error;
+      logAttemptFailure(opts, prefix, opName, attempt, error);
+      continue;
+    }
+    try {
+      reportIngestResponse(await resp.text(), prefix, opName);
+    } catch (e) {
+    }
+    return { status: "delivered" };
+  }
+  return { status: "failed", error: lastError != null ? lastError : new Error(`${opName}: no attempts`) };
+}
+function logAttemptFailure(opts, prefix, opName, attempt, error) {
+  if (!opts.debug) return;
+  console.warn(
+    `${prefix} ${opName} attempt ${attempt} failed: ${error.message}${attempt === opts.maxAttempts ? " (no more retries)" : ""}`
+  );
+}
+function asCompat(result) {
+  return result;
+}
+var DELIVERED = Object.freeze({
+  delivered: true,
+  timedOut: false,
+  dropped: 0,
+  queued: 0,
+  inFlight: 0
+});
+function fateOf(outcome, shuttingDown) {
+  switch (outcome.status) {
+    case "delivered":
+    case "rejected":
+      return "delivered";
+    case "deferred":
+      return shuttingDown ? "dropped" : "queued";
+    default:
+      return "dropped";
+  }
+}
+function summarize2(fates, inFlight, timedOut) {
+  const dropped = fates.filter((fate) => fate === "dropped").length;
+  const queued = fates.filter((fate) => fate === "queued").length;
+  return {
+    delivered: dropped === 0 && queued === 0 && inFlight === 0,
+    timedOut: timedOut || queued > 0 || inFlight > 0,
+    dropped,
+    queued,
+    inFlight
+  };
+}
+function combineResults(...results) {
+  return results.reduce(
+    (acc, r) => ({
+      delivered: acc.delivered && r.delivered,
+      timedOut: acc.timedOut || r.timedOut,
+      dropped: acc.dropped + r.dropped,
+      queued: acc.queued + r.queued,
+      inFlight: acc.inFlight + r.inFlight
+    }),
+    { ...DELIVERED }
   );
 }
+function describeUndelivered(what, result) {
+  const parts = [
+    result.dropped > 0 ? `${result.dropped} dropped` : "",
+    result.queued > 0 ? `${result.queued} still queued` : "",
+    result.inFlight > 0 ? `${result.inFlight} still sending` : ""
+  ].filter(Boolean);
+  return `${what} returned before everything was delivered: ${parts.join(", ")}`;
+}
 var DEFAULT_MAX_TEXT_FIELD_CHARS = 1e6;
 var TRUNCATION_MARKER = "...[truncated by raindrop]";
 var BOUNDED_CLONE_MAX_DEPTH = 12;
@@ -1044,7 +1515,245 @@ function normalizeProjectId(raw, opts) {
 function projectIdHeaders(projectId) {
   return projectId ? { [PROJECT_ID_HEADER]: projectId } : {};
 }
-var SHUTDOWN_DEADLINE_MS = 1e4;
+var import_redact_pii = __toESM(require_dist(), 1);
+var DEFAULT_PII_REDACTION_OPTIONS = {
+  builtInRedactors: {
+    credentials: { replaceWith: "<REDACTED CREDENTIALS>" },
+    creditCardNumber: { replaceWith: "<REDACTED CREDIT CARD NUMBER>" },
+    // Any run of 4+ digits: too broad.
+    digits: { enabled: false },
+    emailAddress: { replaceWith: "<REDACTED EMAIL>" },
+    ipAddress: { enabled: false },
+    names: { enabled: false },
+    // Matches (pass(word|phrase)|secret): \S+
+    password: { replaceWith: "<REDACTED SECRET>" },
+    phoneNumber: { replaceWith: "<REDACTED PHONE NUMBER>" },
+    streetAddress: { replaceWith: "<REDACTED ADDRESS>" },
+    url: { enabled: false },
+    username: { enabled: false },
+    usSocialSecurityNumber: { replaceWith: "<REDACTED SOCIAL SECURITY NUMBER>" },
+    zipcode: { enabled: false }
+  }
+};
+var redactor;
+function redactPiiText(text) {
+  redactor != null ? redactor : redactor = new import_redact_pii.SyncRedactor(DEFAULT_PII_REDACTION_OPTIONS);
+  return redactor.redact(text);
+}
+var KINDS = ["event", "signal", "identify"];
+var DEFAULT_PII_FIELDS = {
+  event: ["ai_data.input", "ai_data.output"],
+  signal: [],
+  identify: []
+};
+var PROTECTED_LOCATIONS = new Set(
+  [
+    ["event_id"],
+    ["user_id"],
+    ["ai_data", "convo_id"],
+    ["event"],
+    ["timestamp"],
+    ["is_pending"],
+    ["signal_name"],
+    ["signal_type"]
+  ].map((keys) => JSON.stringify(keys))
+);
+var SIGNAL_PATH_ALIASES = {
+  comment: "properties.comment",
+  after: "properties.after"
+};
+function parsePiiFieldPath(path) {
+  if (typeof path !== "string") return null;
+  const segments = [];
+  let i = 0;
+  const n = path.length;
+  let expectSeparator = false;
+  while (i < n) {
+    const ch = path[i];
+    if (ch === "[") {
+      const close = path.indexOf("]", i);
+      if (path[i + 1] === '"') {
+        let j2 = i + 2;
+        let key = "";
+        while (j2 < n && path[j2] !== '"') {
+          if (path[j2] === "\\" && j2 + 1 < n) {
+            key += path[j2 + 1];
+            j2 += 2;
+          } else {
+            key += path[j2];
+            j2 += 1;
+          }
+        }
+        if (j2 >= n || path[j2 + 1] !== "]" || key === "") return null;
+        segments.push({ kind: "key", key });
+        i = j2 + 2;
+      } else {
+        if (close === -1) return null;
+        const inner = path.slice(i + 1, close);
+        if (inner === "") segments.push({ kind: "every" });
+        else if (/^(0|[1-9]\d*)$/.test(inner))
+          segments.push({ kind: "index", index: Number(inner) });
+        else return null;
+        i = close + 1;
+      }
+      expectSeparator = true;
+      continue;
+    }
+    if (ch === ".") {
+      if (!expectSeparator) return null;
+      i += 1;
+      expectSeparator = false;
+      if (i >= n || path[i] === ".") return null;
+      continue;
+    }
+    if (expectSeparator) return null;
+    let j = i;
+    while (j < n && path[j] !== "." && path[j] !== "[") j += 1;
+    const token = path.slice(i, j);
+    if (token === "*") segments.push({ kind: "any_key" });
+    else if (token === "" || /[\]*"\s]/.test(token)) return null;
+    else segments.push({ kind: "key", key: token });
+    i = j;
+    expectSeparator = true;
+  }
+  return segments.length > 0 && expectSeparator ? segments : null;
+}
+function mergePiiFieldMaps(...maps) {
+  const out = { event: [], signal: [], identify: [] };
+  for (const kind of KINDS) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const map of maps) {
+      const paths = map == null ? void 0 : map[kind];
+      if (!Array.isArray(paths)) continue;
+      for (const path of paths) {
+        if (typeof path !== "string" || seen.has(path)) continue;
+        seen.add(path);
+        out[kind].push(path);
+      }
+    }
+  }
+  return out;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isProtected(location) {
+  return PROTECTED_LOCATIONS.has(JSON.stringify(location));
+}
+function redactAll(value, location) {
+  if (location !== null && isProtected(location)) return value;
+  if (typeof value === "string") return redactPiiText(value);
+  if (Array.isArray(value)) return value.map((item) => redactAll(item, null));
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = redactAll(child, location === null ? null : [...location, key]);
+    }
+    return out;
+  }
+  return value;
+}
+function applyPath(value, segments, location) {
+  if (segments.length === 0) return redactAll(value, location);
+  const [head, ...rest] = segments;
+  if (head.kind === "key" || head.kind === "any_key") {
+    if (!isPlainObject(value)) return value;
+    const keys = head.kind === "key" ? [head.key] : Object.keys(value);
+    let out2;
+    for (const key of keys) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+      const child = value[key];
+      const next = applyPath(child, rest, location === null ? null : [...location, key]);
+      if (next !== child) {
+        out2 != null ? out2 : out2 = { ...value };
+        out2[key] = next;
+      }
+    }
+    return out2 != null ? out2 : value;
+  }
+  if (!Array.isArray(value)) return value;
+  const indices = head.kind === "index" ? head.index < value.length ? [head.index] : [] : value.keys();
+  let out;
+  for (const index of indices) {
+    const child = value[index];
+    const next = applyPath(child, rest, null);
+    if (next !== child) {
+      out != null ? out : out = [...value];
+      out[index] = next;
+    }
+  }
+  return out != null ? out : value;
+}
+var PiiFieldRedactor = class {
+  constructor(options = {}) {
+    var _a;
+    this.startupMap = options.startupFieldMap;
+    this.prefix = (_a = options.logPrefix) != null ? _a : "[raindrop-ai/core]";
+  }
+  /** Replace the server-provided layer (CONTRACT 11.2). Additive: it can only add fields. */
+  setServerFieldMap(map) {
+    this.serverMap = map;
+    this.compiled = void 0;
+  }
+  /** The paths in effect for a kind, defaults first. */
+  effectivePaths(kind) {
+    return mergePiiFieldMaps(DEFAULT_PII_FIELDS, this.startupMap, this.serverMap)[kind];
+  }
+  compile() {
+    if (this.compiled) return this.compiled;
+    const out = { event: [], signal: [], identify: [] };
+    for (const kind of KINDS) {
+      for (const path of this.effectivePaths(kind)) {
+        const variants = [path];
+        if (kind === "signal" && SIGNAL_PATH_ALIASES[path])
+          variants.push(SIGNAL_PATH_ALIASES[path]);
+        for (const variant of variants) {
+          const segments = parsePiiFieldPath(variant);
+          if (segments) {
+            out[kind].push(segments);
+          } else {
+            rateLimitedLog(
+              `${this.prefix}.pii_field_path_invalid`,
+              () => console.warn(
+                `${this.prefix} redactPiiFields: ignoring invalid ${kind} path ${JSON.stringify(variant)}`
+              )
+            );
+          }
+        }
+      }
+    }
+    this.compiled = out;
+    return out;
+  }
+  /** The payload with every selected field redacted (a copy where changed). */
+  redact(kind, payload) {
+    let out = payload;
+    for (const segments of this.compile()[kind]) out = applyPath(out, segments, []);
+    return out;
+  }
+};
+function detectRuntime() {
+  if (typeof process === "object" && process && typeof process.env === "object" && process.env && typeof process.version === "string") {
+    return "node";
+  }
+  if (typeof window === "object") return "browser";
+  if (typeof WebSocketPair !== "undefined") return "cloudflare-worker";
+  if (typeof EdgeRuntime === "string") return "vercel-edge";
+  if (typeof WorkerGlobalScope !== "undefined" && typeof importScripts === "function") {
+    return "web-worker";
+  }
+  return "unknown";
+}
+var PLACEHOLDER_USER_IDS = /* @__PURE__ */ new Set(["null", "undefined"]);
+function isMissingUserId(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  return trimmed === "" || PLACEHOLDER_USER_IDS.has(trimmed);
+}
+var MAX_DEFERRED_SENDS = 1e3;
 var POST_SHUTDOWN_TIMEOUT_MS = 5e3;
 function appGitOwnerId(prefix) {
   try {
@@ -1053,18 +1762,52 @@ function appGitOwnerId(prefix) {
     return `${prefix}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
   }
 }
+function earliestIsoTimestamp(...values) {
+  let earliest;
+  for (const value of values) {
+    if (value === void 0) continue;
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) continue;
+    if (earliest === void 0 || date < earliest) earliest = date;
+  }
+  return earliest == null ? void 0 : earliest.toISOString();
+}
+function isPlainObject2(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var UNSAFE_MERGE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function deepMergeProperties(target, source) {
+  const out = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0 || UNSAFE_MERGE_KEYS.has(key)) continue;
+    const existing = out[key];
+    out[key] = isPlainObject2(existing) && isPlainObject2(value) ? deepMergeProperties(existing, value) : value;
+  }
+  return out;
+}
 function mergePatches(target, source) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  const out = { ...target, ...source };
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const defined2 = Object.fromEntries(
+    Object.entries(source).filter(([, value]) => value !== void 0)
+  );
+  const out = { ...target, ...defined2 };
   if (target.properties || source.properties) {
-    out.properties = { ...(_a = target.properties) != null ? _a : {}, ...(_b = source.properties) != null ? _b : {} };
+    out.properties = deepMergeProperties((_a = target.properties) != null ? _a : {}, (_b = source.properties) != null ? _b : {});
+  }
+  if (target.callerProperties || source.callerProperties) {
+    out.callerProperties = deepMergeProperties(
+      (_c = target.callerProperties) != null ? _c : {},
+      (_d = source.callerProperties) != null ? _d : {}
+    );
   }
   if (target.usage || source.usage) {
-    out.usage = { ...(_c = target.usage) != null ? _c : {} };
-    if (((_d = source.usage) == null ? void 0 : _d.promptTokens) !== void 0) {
+    out.usage = { ...(_e = target.usage) != null ? _e : {} };
+    if (((_f = source.usage) == null ? void 0 : _f.promptTokens) !== void 0) {
       out.usage.promptTokens = source.usage.promptTokens;
     }
-    if (((_e = source.usage) == null ? void 0 : _e.completionTokens) !== void 0) {
+    if (((_g = source.usage) == null ? void 0 : _g.completionTokens) !== void 0) {
       out.usage.completionTokens = source.usage.completionTokens;
     }
   }
@@ -1072,10 +1815,10 @@ function mergePatches(target, source) {
     out.error = target.error;
   }
   if (target.featureFlags || source.featureFlags) {
-    out.featureFlags = { ...(_f = target.featureFlags) != null ? _f : {}, ...(_g = source.featureFlags) != null ? _g : {} };
+    out.featureFlags = { ...(_h = target.featureFlags) != null ? _h : {}, ...(_i = source.featureFlags) != null ? _i : {} };
   }
   if (target.attachments || source.attachments) {
-    out.attachments = [...(_h = target.attachments) != null ? _h : [], ...(_i = source.attachments) != null ? _i : []];
+    out.attachments = [...(_j = target.attachments) != null ? _j : [], ...(_k = source.attachments) != null ? _k : []];
   }
   return out;
 }
@@ -1100,6 +1843,15 @@ function eventTelemetryProperties(patch) {
   }
   return properties;
 }
+var FINISHED_EVENT_MEMORY = 1e4;
+var MANUAL_UPDATES = /* @__PURE__ */ new WeakSet();
+function markManualUpdate(patch) {
+  try {
+    MANUAL_UPDATES.add(patch);
+  } catch (e) {
+  }
+  return patch;
+}
 var EventShipper = class {
   constructor(opts) {
     this.appGitOwner = appGitOwnerId("event");
@@ -1107,6 +1859,12 @@ var EventShipper = class {
     this.sticky = /* @__PURE__ */ new Map();
     this.timers = /* @__PURE__ */ new Map();
     this.inFlight = /* @__PURE__ */ new Set();
+    this.background = /* @__PURE__ */ new Set();
+    this.backgroundDrops = 0;
+    this.cutOff = new InFlightCutOff();
+    this.finishedEventIds = /* @__PURE__ */ new Set();
+    this.sendChains = /* @__PURE__ */ new Map();
+    this.deferredSends = /* @__PURE__ */ new Set();
     this.hasShutdown = false;
     var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     this.appGitContext = (_a = opts.appGitContext) != null ? _a : createAppGitContext(opts.appGit);
@@ -1120,6 +1878,7 @@ var EventShipper = class {
     this.prefix = `[raindrop-ai/${this.sdkName}]`;
     this.defaultEventName = (_f = opts.defaultEventName) != null ? _f : "ai_generation";
     this.maxTextFieldCharsOpt = opts.maxTextFieldChars;
+    this.flushTimeoutMs = resolveFlushTimeoutMs(opts.flushTimeoutMs);
     this.localDebuggerUrl = (_g = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _g : void 0;
     if (this.debug && this.localDebuggerUrl) {
       console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
@@ -1128,15 +1887,29 @@ var EventShipper = class {
       debug: this.debug,
       prefix: this.prefix
     });
-    const isNode = typeof process !== "undefined" && typeof process.version === "string";
+    this.redactPii = opts.redactPii === true;
+    this.piiFields = new PiiFieldRedactor({
+      startupFieldMap: opts.redactPiiFields,
+      logPrefix: this.prefix
+    });
+    if (opts.redactPiiFields && !this.redactPii) {
+      rateLimitedLog(
+        `${this.prefix}.pii_fields_without_redaction`,
+        () => console.warn(
+          `${this.prefix} redactPiiFields is set but redactPii is off; nothing is redacted. Set redactPii: true to use it.`
+        )
+      );
+    }
+    this.wizardSession = opts.wizardSession || void 0;
+    const runtime = detectRuntime();
     this.context = {
       library: {
         name: (_h = opts.libraryName) != null ? _h : "@raindrop-ai/core",
         version: (_i = opts.libraryVersion) != null ? _i : "0.0.0"
       },
       metadata: {
-        jsRuntime: isNode ? "node" : "web",
-        ...isNode ? { nodeVersion: process.version } : {}
+        jsRuntime: runtime,
+        ...runtime === "node" ? { nodeVersion: process.version } : {}
       }
     };
   }
@@ -1153,28 +1926,21 @@ var EventShipper = class {
     return { ...this.authHeaders(), ...projectIdHeaders(this.projectId) };
   }
   /**
-   * 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.
+   * Retry/timeout options for one POST. While `shutdown()` drains, sends retry
+   * within its window (deadline = the shutdown deadline); a flush passes its
+   * own deadline. `null` when the shutdown window is spent: the caller drops
+   * the payload with a warning. After `shutdown()` returns, late sends get a
+   * single short attempt rather than the full retry schedule.
    */
-  requestOpts() {
+  requestOpts(deadlineAt) {
     if (this.shutdownDeadlineAt !== void 0) {
-      const remainingMs = this.shutdownDeadlineAt - Date.now();
-      if (remainingMs <= 0) return null;
+      if (this.shutdownDeadlineAt - Date.now() <= 0) return null;
       return {
-        maxAttempts: 1,
+        maxAttempts: 3,
         debug: this.debug,
         sdkName: this.sdkName,
-        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
+        deadlineAt: Math.min(this.shutdownDeadlineAt, deadlineAt != null ? deadlineAt : Infinity),
+        cutOff: this.cutOff.signal
       };
     }
     if (this.hasShutdown) {
@@ -1182,15 +1948,94 @@ var EventShipper = class {
         maxAttempts: 1,
         debug: this.debug,
         sdkName: this.sdkName,
-        timeoutMs: POST_SHUTDOWN_TIMEOUT_MS
+        timeoutMs: POST_SHUTDOWN_TIMEOUT_MS,
+        cutOff: this.cutOff.signal
       };
     }
-    return { maxAttempts: 3, debug: this.debug, sdkName: this.sdkName };
+    return {
+      maxAttempts: 3,
+      debug: this.debug,
+      sdkName: this.sdkName,
+      deadlineAt,
+      cutOff: this.cutOff.signal
+    };
+  }
+  shuttingDown() {
+    return this.shutdownDeadlineAt !== void 0 || this.hasShutdown;
   }
   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;
+    await this.patchWithFate(eventId, patch);
+  }
+  /**
+   * Queue an update without waiting for any network send: for integrations,
+   * whose captured call must return as soon as the update is queued (rule C9,
+   * hot path). A finishing update starts its send in the background; `flush()`
+   * and `shutdown()` wait for it within their deadline and count it in their
+   * result. Never throws or rejects.
+   */
+  enqueue(eventId, patch) {
+    let op;
+    try {
+      op = this.patchWithFate(eventId, patch).catch((err) => {
+        this.warnBackgroundFailure(eventId, err);
+        return "dropped";
+      }).then((fate) => {
+        if (fate === "dropped") this.backgroundDrops += 1;
+        return fate;
+      });
+    } catch (err) {
+      this.warnBackgroundFailure(eventId, err);
+      return;
+    }
+    this.background.add(op);
+    void op.finally(() => this.background.delete(op));
+  }
+  /** `finish()` without waiting for the send; see `enqueue`. */
+  enqueueFinish(eventId, patch = {}) {
+    this.enqueue(eventId, { ...patch, isPending: false });
+  }
+  /**
+   * Caller properties win over everything the integration derived (W6). A
+   * clash is intended by the caller, so it is only logged in debug mode.
+   */
+  withCallerProperties(eventId, derived, caller) {
+    if (!caller || Object.keys(caller).length === 0) return derived;
+    if (this.debug) {
+      try {
+        const keys = overriddenKeys(derived, caller);
+        if (keys.length > 0) {
+          console.log(
+            `${this.prefix} event ${eventId}: caller properties override the integration's value for ${keys.map((k) => `"${k}"`).join(", ")}`
+          );
+        }
+      } catch (e) {
+      }
+    }
+    return deepMergeProperties(derived, caller);
+  }
+  warnBackgroundFailure(eventId, err) {
+    rateLimitedLog(
+      `${this.prefix}.background_update`,
+      () => console.warn(`${this.prefix} update for event ${eventId} failed:`, err)
+    );
+  }
+  /**
+   * Id of the last event an integration finished in this process (manual
+   * events API finishes excluded): what integrations expose as `lastEventId`
+   * (wrapper profile W10).
+   */
+  get lastFinishedEventId() {
+    return this.lastFinished;
+  }
+  async patchWithFate(eventId, patch) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    const manual = MANUAL_UPDATES.has(patch);
+    if (!this.enabled) return void 0;
+    if (!eventId || !eventId.trim()) return void 0;
+    if (patch.userId !== void 0 && isMissingUserId(patch.userId)) {
+      const { userId: _placeholder, ...rest } = patch;
+      patch = rest;
+    }
     const capturedSticky = this.sticky.get(eventId);
     const eventAlreadyKnown = capturedSticky !== void 0 || this.buffers.has(eventId);
     const destination = currentReplayTraceDestination();
@@ -1198,7 +2043,7 @@ var EventShipper = class {
     if ((capturedSticky == null ? void 0 : capturedSticky.replayOnly) === true || !eventAlreadyKnown && cloudReplay) {
       if (patch.isPending === false) this.sticky.delete(eventId);
       else this.sticky.set(eventId, { ...capturedSticky, replayOnly: true });
-      return;
+      return void 0;
     }
     const maxChars = resolveMaxTextFieldChars(this.maxTextFieldCharsOpt);
     if (typeof patch.input === "string" && patch.input.length > maxChars) {
@@ -1221,11 +2066,12 @@ var EventShipper = class {
     }
     const sticky = (_c = this.sticky.get(eventId)) != null ? _c : {};
     const existing = (_d = this.buffers.get(eventId)) != null ? _d : {};
+    const explicitProperties = patch.callerProperties !== void 0 ? { ...patch.properties, ...patch.callerProperties } : patch.properties;
     patch = {
       ...patch,
       properties: withAppGitProperties(
         patch.properties,
-        this.appGitContext.forOperation(eventId, patch.properties, this.appGitOwner)
+        this.appGitContext.forOperation(eventId, explicitProperties, this.appGitOwner)
       )
     };
     const merged = mergePatches(existing, patch);
@@ -1235,47 +2081,165 @@ var EventShipper = class {
       userId: (_h = merged.userId) != null ? _h : sticky.userId,
       convoId: (_i = merged.convoId) != null ? _i : sticky.convoId,
       eventName: (_j = merged.eventName) != null ? _j : sticky.eventName,
-      isPending: (_k = merged.isPending) != null ? _k : sticky.isPending
+      isPending: (_k = merged.isPending) != null ? _k : sticky.isPending,
+      startedAt: (_l = earliestIsoTimestamp(sticky.startedAt, patch.timestamp)) != null ? _l : (/* @__PURE__ */ new Date()).toISOString(),
+      resumed: sticky.resumed,
+      hasContent: sticky.hasContent === true || patchHasContent(patch),
+      callerProperties: patch.callerProperties !== void 0 ? deepMergeProperties((_m = sticky.callerProperties) != null ? _m : {}, patch.callerProperties) : sticky.callerProperties
     });
     const t = this.timers.get(eventId);
     if (t) clearTimeout(t);
     if (merged.isPending === false) {
-      await this.flushOne(eventId);
+      if (!manual) this.lastFinished = eventId;
+      this.noteFinish(eventId);
+      this.noteEmptyFinish(eventId);
+      const fate = await this.flushOne(eventId);
       if (this.appGitContext.releaseOperation) this.appGitContext.releaseOperation(eventId, this.appGitOwner);
       else this.appGitContext.finishOperation(eventId);
-      return;
+      return fate;
     }
     const timeout = setTimeout(() => {
       void this.flushOne(eventId).catch(() => {
       });
     }, this.partialFlushMs);
     this.timers.set(eventId, timeout);
+    return void 0;
+  }
+  /**
+   * A second finish for an event is still sent (ingest finalizes once and
+   * treats it as an update, CONTRACT §10.2), but it usually means several
+   * calls share one event id by mistake, so it is warned about.
+   */
+  noteFinish(eventId) {
+    if (this.finishedEventIds.has(eventId)) {
+      rateLimitedLog(
+        `${this.prefix}.repeated_finish`,
+        () => console.warn(
+          `${this.prefix} event ${eventId} was already finished in this process; sending the update anyway (ingest finalizes an event once). Use a separate event id per interaction, or keep the event pending until its last call.`
+        )
+      );
+      return;
+    }
+    this.finishedEventIds.add(eventId);
+    if (this.finishedEventIds.size > FINISHED_EVENT_MEMORY) {
+      const oldest = this.finishedEventIds.values().next().value;
+      if (oldest !== void 0) this.finishedEventIds.delete(oldest);
+    }
+  }
+  /**
+   * An event finished with no input, output or attachments is almost always a
+   * caller bug (CONTRACT §14.2, rule C5); it is sent anyway and warned about.
+   * Not for a resumed event: its content may have been sent by another process.
+   */
+  noteEmptyFinish(eventId) {
+    const sticky = this.sticky.get(eventId);
+    if ((sticky == null ? void 0 : sticky.resumed) === true || (sticky == null ? void 0 : sticky.hasContent) === true) return;
+    rateLimitedLog(
+      `${this.prefix}.empty_finish`,
+      () => console.warn(
+        `${this.prefix} event ${eventId} finished with no input, output or attachments; sending it anyway. Pass the interaction's input at begin or its output at finish.`
+      )
+    );
+  }
+  /**
+   * Continue an event that was begun elsewhere (another process, a queue
+   * worker, a later request) using only its id. No request is sent; later
+   * `patch` / `finish` calls for this id are sent even without a `userId`,
+   * and ingest keeps the user, conversation and start time it already has.
+   * Pass `userId` / `convoId` / `eventName` if you have them.
+   */
+  resume(eventId, options = {}) {
+    var _a, _b, _c;
+    if (!this.enabled) return;
+    if (!eventId || !eventId.trim()) return;
+    const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
+    this.sticky.set(eventId, {
+      ...sticky,
+      userId: isMissingUserId(options.userId) ? sticky.userId : options.userId,
+      convoId: (_b = options.convoId) != null ? _b : sticky.convoId,
+      eventName: (_c = options.eventName) != null ? _c : sticky.eventName,
+      resumed: true
+    });
   }
   async finish(eventId, patch) {
-    await this.patch(eventId, { ...patch, isPending: false });
+    const update = { ...patch, isPending: false };
+    if (MANUAL_UPDATES.has(patch)) MANUAL_UPDATES.add(update);
+    await this.patch(eventId, update);
   }
+  /**
+   * Send everything buffered, open (pending) events included, within
+   * `flushTimeoutMs` (CONTRACT 1.2.1). Resolves, never rejects, to whether it
+   * all reached ingest; when it didn't, it also warns. At the deadline,
+   * payloads not yet sent stay queued for a later send and a request cut off
+   * mid-flight is dropped. Sends already running when it was called are
+   * waited for up to the deadline and then cut off.
+   */
   async flush() {
-    if (!this.enabled) return;
+    const result = await this.drainAll(Date.now() + this.flushTimeoutMs);
+    if (!result.delivered && this.shutdownDeadlineAt === void 0) {
+      rateLimitedLog(
+        `${this.prefix}.flush_undelivered`,
+        () => console.warn(`${this.prefix} ${describeUndelivered("flush()", result)}`)
+      );
+    }
+    return asCompat(result);
+  }
+  async drainAll(deadlineAt) {
+    if (!this.enabled) return { ...DELIVERED };
+    const deferred = [...this.deferredSends];
+    this.deferredSends.clear();
+    for (const entry of deferred) if (entry.timer) clearTimeout(entry.timer);
     const ids = [...this.buffers.keys()];
-    await Promise.all(ids.map((id) => this.flushOne(id)));
-    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
-    })));
+    const fates = await Promise.all([
+      ...ids.map((id) => this.flushOne(id, deadlineAt)),
+      ...deferred.map((entry) => entry.send(deadlineAt))
+    ]);
+    const background = [...this.background];
+    if (background.length > 0) {
+      await raceWithTimeout(Promise.all(background), deadlineAt - Date.now());
+    }
+    for (; this.backgroundDrops > 0; this.backgroundDrops -= 1) fates.push("dropped");
+    const running = [...this.inFlight];
+    const { settled, stillRunning } = await awaitEarlierSends(
+      running,
+      deadlineAt,
+      this.cutOff,
+      (p) => this.inFlight.has(p)
+    );
+    const unresolved = background.filter((op) => this.background.has(op)).length;
+    return summarize2(
+      fates.filter((fate) => fate !== void 0),
+      Math.max(stillRunning, unresolved),
+      !settled || unresolved > 0
+    );
   }
+  /**
+   * Flush within `flushTimeoutMs` and stop. Sends retry while the window
+   * allows; whatever is left at the deadline is dropped with a warning, so a
+   * dead network can never wedge process exit. Resolves, never rejects.
+   */
   async shutdown() {
     this.hasShutdown = true;
-    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
+    const deadlineAt = Date.now() + this.flushTimeoutMs;
+    this.shutdownDeadlineAt = deadlineAt;
+    let result = { ...DELIVERED };
     try {
       for (const t of this.timers.values()) clearTimeout(t);
       this.timers.clear();
       for (const [eventId, sticky] of this.sticky) {
         if (sticky.replayOnly) this.sticky.delete(eventId);
       }
-      const settled = await raceWithTimeout(this.flush(), SHUTDOWN_DEADLINE_MS);
-      if (!settled) this.warnShutdownDrop("in-flight request(s) at shutdown");
+      result = await this.drainAll(deadlineAt);
+      if (!result.delivered) {
+        this.warnShutdownDrop(
+          `${result.dropped + result.queued + result.inFlight} payload(s) not delivered`
+        );
+      }
     } finally {
       this.shutdownDeadlineAt = void 0;
       if (this.ownsAppGitContext) this.appGitContext.dispose();
     }
+    return asCompat(result);
   }
   async trackSignal(signal) {
     var _a, _b;
@@ -1296,23 +2260,9 @@ var EventShipper = class {
           ...signal.after ? { after: signal.after } : {}
         }
       }
-    ];
+    ].map((item) => this.redactFields("signal", item));
     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.requestHeaders(), opts);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      rateLimitedLog(
-        `${this.prefix}.send_signal_failed`,
-        () => console.warn(`${this.prefix} failed to send signal (dropping): ${msg}`)
-      );
-    }
+    await this.sendDirect("signal", `${this.baseUrl}signals/track`, body);
   }
   async identify(users) {
     if (!this.enabled) return;
@@ -1327,30 +2277,80 @@ var EventShipper = class {
         return false;
       }
       return true;
-    }).map((user) => {
-      var _a;
-      return {
-        user_id: user.userId,
-        traits: (_a = user.traits) != null ? _a : {}
-      };
-    });
+    }).map(
+      (user) => {
+        var _a;
+        return this.redactFields("identify", {
+          user_id: user.userId,
+          traits: (_a = user.traits) != null ? _a : {}
+        });
+      }
+    );
     if (!this.writeKey) return;
     if (body.length === 0) return;
-    const url = `${this.baseUrl}users/identify`;
-    const opts = this.requestOpts();
+    await this.sendDirect("identify", `${this.baseUrl}users/identify`, body);
+  }
+  /**
+   * Send a signal or identify body. Tracked so `flush()` waits for it. A send
+   * a flush deadline deferred is kept and retried later (outside shutdown).
+   */
+  async sendDirect(kind, url, body, deadlineAt) {
+    const opts = this.requestOpts(deadlineAt);
     if (!opts) {
-      this.warnShutdownDrop("identify");
-      return;
+      this.warnShutdownDrop(kind);
+      return "dropped";
     }
+    const sending = sendJson(url, body, this.requestHeaders(), opts);
+    const tracked = sending.then(() => void 0);
+    this.inFlight.add(tracked);
+    let outcome;
     try {
-      await postJson(url, body, this.requestHeaders(), opts);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      outcome = await sending;
+    } finally {
+      this.inFlight.delete(tracked);
+    }
+    const fate = fateOf(outcome, this.shuttingDown());
+    if (fate === "queued") {
+      this.deferSend(
+        (later) => this.sendDirect(kind, url, body, later),
+        outcome.status === "deferred" ? outcome.retryAtMs : void 0
+      );
+    } else if (fate === "dropped") {
+      this.warnSendDropped(kind, outcome);
+    }
+    return fate;
+  }
+  deferSend(send, retryAtMs) {
+    var _a, _b;
+    if (this.deferredSends.size >= MAX_DEFERRED_SENDS) {
       rateLimitedLog(
-        `${this.prefix}.send_identify_failed`,
-        () => console.warn(`${this.prefix} failed to send identify (dropping): ${msg}`)
+        `${this.prefix}.deferred_full`,
+        () => console.warn(`${this.prefix} too many sends waiting for a retry; dropping one`)
       );
+      return;
     }
+    const entry = { send };
+    const delay = Math.max(this.partialFlushMs, (retryAtMs != null ? retryAtMs : 0) - Date.now());
+    entry.timer = setTimeout(() => {
+      if (!this.deferredSends.delete(entry)) return;
+      void send().catch(() => {
+      });
+    }, delay);
+    (_b = (_a = entry.timer).unref) == null ? void 0 : _b.call(_a);
+    this.deferredSends.add(entry);
+  }
+  warnSendDropped(what, outcome) {
+    var _a, _b;
+    if (outcome.status === "delivered" || outcome.status === "rejected") return;
+    const reason = outcome.status === "cut_off" ? "cut off at the flush deadline (not resent: it may have reached ingest)" : outcome.status === "deferred" ? "not sent before the shutdown deadline" : (_b = (_a = outcome.error) == null ? void 0 : _a.message) != null ? _b : outcome.status;
+    rateLimitedLog(
+      `${this.prefix}.send_${what}_dropped`,
+      () => console.warn(`${this.prefix} failed to send ${what} (dropping): ${reason}`)
+    );
+  }
+  /** The payload with its PII fields redacted when `redactPii` is on (CONTRACT 11.2). */
+  redactFields(kind, payload) {
+    return this.redactPii ? this.piiFields.redact(kind, payload) : payload;
   }
   warnShutdownDrop(what) {
     rateLimitedLog(
@@ -1358,9 +2358,8 @@ var EventShipper = class {
       () => 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;
+  async flushOne(eventId, deadlineAt) {
+    if (!this.enabled) return void 0;
     const timer = this.timers.get(eventId);
     if (timer) {
       clearTimeout(timer);
@@ -1368,30 +2367,91 @@ var EventShipper = class {
     }
     const accumulated = this.buffers.get(eventId);
     this.buffers.delete(eventId);
-    if (!accumulated) return;
+    if (!accumulated) return void 0;
+    const previous = this.sendChains.get(eventId);
+    let release = () => {
+    };
+    const current = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    this.sendChains.set(eventId, current);
+    try {
+      if (previous) {
+        const ready = deadlineAt === void 0 ? (await previous, true) : await raceWithTimeout(previous, deadlineAt - Date.now());
+        if (!ready) {
+          return this.requeue(eventId, accumulated, void 0);
+        }
+      }
+      return await this.sendAccumulated(eventId, accumulated, deadlineAt);
+    } finally {
+      release();
+      if (this.sendChains.get(eventId) === current) this.sendChains.delete(eventId);
+    }
+  }
+  /**
+   * Put an unsent update back under any newer one and send it later
+   * (CONTRACT 1.2.1). During shutdown it is dropped instead.
+   */
+  requeue(eventId, accumulated, retryAtMs) {
+    var _a, _b;
+    if (this.shuttingDown()) {
+      this.warnShutdownDrop(`track_partial ${eventId}`);
+      if (accumulated.isPending === false) this.sticky.delete(eventId);
+      return "dropped";
+    }
+    const newer = this.buffers.get(eventId);
+    const merged = newer ? mergePatches(accumulated, newer) : accumulated;
+    merged.isPending = (_a = newer == null ? void 0 : newer.isPending) != null ? _a : accumulated.isPending;
+    this.buffers.set(eventId, merged);
+    const existing = this.timers.get(eventId);
+    if (existing) clearTimeout(existing);
+    const delay = Math.max(this.partialFlushMs, (retryAtMs != null ? retryAtMs : 0) - Date.now());
+    const timeout = setTimeout(() => {
+      void this.flushOne(eventId).catch(() => {
+      });
+    }, delay);
+    (_b = timeout.unref) == null ? void 0 : _b.call(timeout);
+    this.timers.set(eventId, timeout);
+    return "queued";
+  }
+  async sendAccumulated(eventId, accumulated, deadlineAt) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
     const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
     const isPending = (_c = (_b = accumulated.isPending) != null ? _b : sticky.isPending) != null ? _c : true;
-    const eventName = (_e = (_d = accumulated.eventName) != null ? _d : sticky.eventName) != null ? _e : this.defaultEventName;
-    const userId = (_f = accumulated.userId) != null ? _f : sticky.userId;
-    if (!userId) {
-      if (this.debug) {
-        console.warn(`${this.prefix} skipping track_partial for ${eventId}: missing userId`);
-      }
+    const knownEventName = (_d = accumulated.eventName) != null ? _d : sticky.eventName;
+    const eventName = knownEventName != null ? knownEventName : sticky.resumed ? void 0 : this.defaultEventName;
+    const userId = (_e = accumulated.userId) != null ? _e : sticky.userId;
+    if (!userId && !sticky.resumed) {
+      rateLimitedLog(
+        `${this.prefix}.track_partial_missing_user`,
+        () => console.warn(
+          `${this.prefix} skipping track_partial for ${eventId}: missing userId (pass userId, or call resume(eventId) to continue an event begun elsewhere)`
+        )
+      );
       this.sticky.delete(eventId);
-      return;
+      return void 0;
     }
-    const { wizardSession, ...restProperties } = (_g = accumulated.properties) != null ? _g : {};
+    if (!userId) {
+      rateLimitedLog(
+        `${this.prefix}.track_partial_resumed_without_user`,
+        () => console.warn(
+          `${this.prefix} sending track_partial for ${eventId} without a userId; ingest will use the user stored for this event (pass userId to resume() to set it explicitly)`
+        )
+      );
+    }
+    const { wizardSession, ...restProperties } = (_f = accumulated.properties) != null ? _f : {};
     let telemetryProperties = {};
     try {
       telemetryProperties = eventTelemetryProperties(accumulated);
     } catch (e) {
     }
-    const convoId = (_h = accumulated.convoId) != null ? _h : sticky.convoId;
-    const payload = {
+    const convoId = (_g = accumulated.convoId) != null ? _g : sticky.convoId;
+    const sessionTag = wizardSession != null ? wizardSession : this.wizardSession;
+    const unredacted = {
       event_id: eventId,
-      user_id: userId,
-      event: eventName,
-      timestamp: (_i = accumulated.timestamp) != null ? _i : (/* @__PURE__ */ new Date()).toISOString(),
+      ...userId ? { user_id: userId } : {},
+      ...eventName ? { event: eventName } : {},
+      timestamp: (_i = (_h = sticky.startedAt) != null ? _h : accumulated.timestamp) != null ? _i : (/* @__PURE__ */ new Date()).toISOString(),
       ai_data: {
         input: accumulated.input,
         output: accumulated.error !== void 0 && accumulated.error !== null ? void 0 : accumulated.output,
@@ -1399,32 +2459,38 @@ var EventShipper = class {
         convo_id: convoId
       },
       properties: {
-        ...restProperties,
-        ...telemetryProperties,
-        ...wizardSession ? { "raindrop.wizardSession": wizardSession } : {},
+        ...this.withCallerProperties(
+          eventId,
+          { ...restProperties, ...telemetryProperties },
+          (_j = sticky.callerProperties) != null ? _j : accumulated.callerProperties
+        ),
+        ...sessionTag ? { "raindrop.wizardSession": sessionTag } : {},
         $context: this.context
       },
       ...accumulated.featureFlags && Object.keys(accumulated.featureFlags).length > 0 ? { feature_flags: accumulated.featureFlags } : {},
       attachments: accumulated.attachments,
       is_pending: isPending
     };
+    const payload = this.redactFields("event", unredacted);
     const url = `${this.baseUrl}events/track_partial`;
     if (this.debug) {
+      const sent = payload;
+      const preview = (v, n) => typeof v === "string" ? v.slice(0, n) : void 0;
       console.log(`${this.prefix} sending track_partial`, {
         eventId,
         eventName,
         userId,
         convoId,
         isPending,
-        inputPreview: typeof accumulated.input === "string" ? accumulated.input.slice(0, 120) : void 0,
-        outputPreview: typeof accumulated.output === "string" ? accumulated.output.slice(0, 120) : void 0,
-        attachments: (_k = (_j = accumulated.attachments) == null ? void 0 : _j.length) != null ? _k : 0,
-        attachmentKinds: (_m = (_l = accumulated.attachments) == null ? void 0 : _l.map((a) => ({
+        inputPreview: preview((_k = sent.ai_data) == null ? void 0 : _k.input, 120),
+        outputPreview: preview((_l = sent.ai_data) == null ? void 0 : _l.output, 120),
+        attachments: (_n = (_m = sent.attachments) == null ? void 0 : _m.length) != null ? _n : 0,
+        attachmentKinds: (_p = (_o = sent.attachments) == null ? void 0 : _o.map((a) => ({
           type: a.type,
           role: a.role,
           name: a.name,
-          valuePreview: a.value.slice(0, 60)
-        }))) != null ? _m : [],
+          valuePreview: preview(a.value, 60)
+        }))) != null ? _p : [],
         endpoint: url
       });
     }
@@ -1437,39 +2503,94 @@ var EventShipper = class {
     if (!this.writeKey) {
       if (!isPending) this.sticky.delete(eventId);
       if (mirror) await mirror;
-      return;
+      return void 0;
     }
-    const opts = this.requestOpts();
+    const opts = this.requestOpts(deadlineAt);
     if (!opts) {
       this.warnShutdownDrop(`track_partial ${eventId}`);
       if (!isPending) this.sticky.delete(eventId);
       if (mirror) await mirror;
-      return;
+      return "dropped";
     }
-    const p = postJson(url, payload, this.requestHeaders(), opts);
-    const combined = mirror ? Promise.all([mirror, p]).then(() => void 0) : p;
+    const sending = sendJson(url, payload, this.requestHeaders(), opts);
+    const combined = Promise.all([mirror, sending.then(() => void 0)]).then(() => void 0);
     this.inFlight.add(combined);
+    let outcome;
     try {
-      try {
-        await combined;
-        if (this.debug) {
-          console.log(`${this.prefix} sent track_partial ${eventId} (${eventName})`);
-        }
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        rateLimitedLog(
-          `${this.prefix}.send_track_partial_failed`,
-          () => console.warn(`${this.prefix} failed to send track_partial (dropping): ${msg}`)
-        );
-      }
+      outcome = await sending;
+      if (mirror) await mirror.catch(() => {
+      });
     } finally {
       this.inFlight.delete(combined);
     }
+    const fate = fateOf(outcome, this.shuttingDown());
+    if (fate === "queued") {
+      return this.requeue(
+        eventId,
+        accumulated,
+        outcome.status === "deferred" ? outcome.retryAtMs : void 0
+      );
+    }
+    if (fate === "dropped") this.warnSendDropped("track_partial", outcome);
+    else if (this.debug && outcome.status === "delivered") {
+      console.log(`${this.prefix} sent track_partial ${eventId} (${eventName})`);
+    }
     if (!isPending) {
       this.sticky.delete(eventId);
     }
+    return fate;
   }
 };
+function overriddenKeys(derived, caller) {
+  const keys = [];
+  for (const [key, value] of Object.entries(caller)) {
+    if (value === void 0 || !(key in derived)) continue;
+    const existing = derived[key];
+    if (isPlainObject2(existing) && isPlainObject2(value)) {
+      if (overriddenKeys(existing, value).length > 0) keys.push(key);
+    } else if (JSON.stringify(existing) !== JSON.stringify(value)) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+function patchHasContent(patch) {
+  var _a, _b;
+  return typeof patch.input === "string" && patch.input.length > 0 || typeof patch.output === "string" && patch.output.length > 0 || ((_b = (_a = patch.attachments) == null ? void 0 : _a.length) != null ? _b : 0) > 0;
+}
+function resolveFlushTimeoutMs(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_FLUSH_TIMEOUT_MS;
+}
+function createEventsApi(shipper) {
+  return {
+    async patch(eventId, patch) {
+      await (shipper == null ? void 0 : shipper.patch(eventId, markManualUpdate(asCallerPatch(patch))));
+    },
+    async finish(eventId, patch = {}) {
+      await (shipper == null ? void 0 : shipper.finish(eventId, markManualUpdate(asCallerPatch(patch))));
+    },
+    async addAttachments(eventId, attachments) {
+      await (shipper == null ? void 0 : shipper.patch(eventId, markManualUpdate({ attachments })));
+    },
+    async setProperties(eventId, properties) {
+      await (shipper == null ? void 0 : shipper.patch(eventId, markManualUpdate({ properties, callerProperties: properties })));
+    },
+    async setFeatureFlags(eventId, featureFlags) {
+      await (shipper == null ? void 0 : shipper.patch(eventId, markManualUpdate({ featureFlags: normalizeFeatureFlags(featureFlags) })));
+    },
+    resume(eventId, options) {
+      shipper == null ? void 0 : shipper.resume(eventId, options);
+    }
+  };
+}
+function asCallerPatch(patch) {
+  var _a;
+  if (!patch.properties) return patch;
+  return {
+    ...patch,
+    callerProperties: { ...patch.properties, ...(_a = patch.callerProperties) != null ? _a : {} }
+  };
+}
 var MODEL_USAGE_ATTRIBUTES = {
   usageSource: "raindrop.usage.source",
   providerName: "gen_ai.provider.name",
@@ -1529,6 +2650,21 @@ function buildRawModelUsageAttributes(usage) {
     attrDouble(MODEL_USAGE_ATTRIBUTES.providerReportedCost, providerReportedCost)
   ].filter((attribute) => attribute !== void 0);
 }
+var KNOWN_MODEL_PROVIDERS = /* @__PURE__ */ new Set([
+  ...MODEL_PROVIDER_NAMES.map(([, family]) => family),
+  "vercel",
+  // Further vendors Dawn's pricing resolves (apps/dawn/lib/spend).
+  "deepseek",
+  "fireworks-ai",
+  "groq",
+  "inception",
+  "mistral",
+  "moonshotai",
+  "perplexity",
+  "togetherai",
+  "xai",
+  "zai"
+]);
 var STRING_ALIASES = {
   [MODEL_USAGE_ATTRIBUTES.requestModel]: ["ai.model.id", "ai.model"]
 };
@@ -1781,6 +2917,7 @@ var TraceShipper = class {
     this.appGitAdded = /* @__PURE__ */ new WeakMap();
     this.queue = [];
     this.inFlight = /* @__PURE__ */ new Set();
+    this.cutOff = new InFlightCutOff();
     this.hasShutdown = false;
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     this.appGitContext = (_a = opts.appGitContext) != null ? _a : createAppGitContext(opts.appGit);
@@ -1793,6 +2930,7 @@ var TraceShipper = class {
     this.flushIntervalMs = (_d = opts.flushIntervalMs) != null ? _d : 1e3;
     this.maxBatchSize = (_e = opts.maxBatchSize) != null ? _e : 50;
     this.maxQueueSize = (_f = opts.maxQueueSize) != null ? _f : 5e3;
+    this.flushTimeoutMs = resolveFlushTimeoutMs(opts.flushTimeoutMs);
     this.sdkName = (_g = opts.sdkName) != null ? _g : "core";
     this.prefix = `[raindrop-ai/${this.sdkName}]`;
     this.serviceName = (_h = opts.serviceName) != null ? _h : "raindrop.core";
@@ -2071,25 +3209,51 @@ var TraceShipper = class {
     }
     this.queue.push(redacted);
     if (this.queue.length >= this.maxBatchSize) {
-      void this.flush().catch(() => {
+      void this.drain().catch(() => {
       });
       return;
     }
-    if (!this.timer) {
-      this.timer = setTimeout(() => {
-        this.timer = void 0;
-        void this.flush().catch(() => {
-        });
-      }, this.flushIntervalMs);
-    }
+    this.scheduleDrain(this.flushIntervalMs);
+  }
+  scheduleDrain(delayMs) {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.drain().catch(() => {
+      });
+    }, delayMs);
   }
+  /**
+   * Send every queued span within `flushTimeoutMs` (CONTRACT 1.2.1). Resolves,
+   * never rejects, to whether they all reached ingest, and warns when they
+   * didn't. Spans not yet sent at the deadline stay queued.
+   */
   async flush() {
-    var _a;
-    if (!this.enabled) {
-      await Promise.all([...this.inFlight].map((p) => p.catch(() => {
-      })));
-      return;
+    const result = await this.drainWithin(Date.now() + this.flushTimeoutMs);
+    if (!result.delivered && this.shutdownDeadlineAt === void 0) {
+      rateLimitedLog(
+        `${this.prefix}.flush_undelivered`,
+        () => console.warn(`${this.prefix} ${describeUndelivered("flush()", result)}`)
+      );
     }
+    return asCompat(result);
+  }
+  async drainWithin(deadlineAt) {
+    const fates = this.enabled ? await this.drain(deadlineAt) : [];
+    const running = [...this.inFlight];
+    const { settled, stillRunning } = await awaitEarlierSends(
+      running,
+      deadlineAt,
+      this.cutOff,
+      (p) => this.inFlight.has(p)
+    );
+    return summarize2(fates, stillRunning, !settled);
+  }
+  /** Send queued batches; with a deadline, a deferred batch goes back on the queue. */
+  async drain(deadlineAt) {
+    var _a;
+    const fates = [];
+    if (!this.enabled) return fates;
     if (this.timer) {
       clearTimeout(this.timer);
       this.timer = void 0;
@@ -2103,10 +3267,12 @@ var TraceShipper = class {
         if (spans) spans.push(span);
         else groups.set(destination, [span]);
       }
+      const requeue = [];
+      let retryAtMs;
       for (const [destination, spans] of groups) {
         if (!destination && !this.writeKey) continue;
         if ((destination == null ? void 0 : destination.kind) === "workshop") continue;
-        const opts = this.requestOpts();
+        const opts = this.requestOpts(deadlineAt);
         if (!opts) {
           rateLimitedLog(
             `${this.prefix}.shutdown_deadline`,
@@ -2114,6 +3280,7 @@ var TraceShipper = class {
               `${this.prefix} shutdown flush deadline exceeded; dropping ${spans.length} spans`
             )
           );
+          fates.push("dropped");
           continue;
         }
         const body = buildExportTraceServiceRequest(spans, this.serviceName, this.serviceVersion);
@@ -2129,35 +3296,56 @@ var TraceShipper = class {
             endpoint: url
           });
         }
-        const p = postJson(url, body, headers, opts);
-        this.inFlight.add(p);
+        const sending = sendJson(url, body, headers, opts);
+        const tracked = sending.then(() => void 0);
+        this.inFlight.add(tracked);
+        let outcome;
         try {
-          try {
-            await p;
-            if (this.debug) console.log(`${this.prefix} sent ${spans.length} spans`);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            rateLimitedLog(
-              `${this.prefix}.send_spans_failed`,
-              () => console.warn(`${this.prefix} failed to send ${spans.length} spans: ${msg}`)
-            );
-          }
+          outcome = await sending;
         } finally {
-          this.inFlight.delete(p);
+          this.inFlight.delete(tracked);
+        }
+        const fate = fateOf(outcome, this.shutdownDeadlineAt !== void 0 || this.hasShutdown);
+        fates.push(fate);
+        if (fate === "queued") {
+          requeue.push(...spans);
+          if (outcome.status === "deferred" && outcome.retryAtMs !== void 0) {
+            retryAtMs = Math.max(retryAtMs != null ? retryAtMs : 0, outcome.retryAtMs);
+          }
+        } else if (fate === "dropped") {
+          const reason = outcome.status === "cut_off" ? "cut off at the flush deadline (not resent: it may have reached ingest)" : outcome.status === "deferred" ? "not sent before the shutdown deadline" : "error" in outcome && outcome.error ? outcome.error.message : outcome.status;
+          rateLimitedLog(
+            `${this.prefix}.send_spans_failed`,
+            () => console.warn(`${this.prefix} failed to send ${spans.length} spans: ${reason}`)
+          );
+        } else if (this.debug) {
+          console.log(`${this.prefix} sent ${spans.length} spans`);
         }
       }
+      if (requeue.length > 0) {
+        this.queue.unshift(...requeue);
+        if (this.queue.length > this.maxQueueSize) {
+          this.queue.splice(this.maxQueueSize);
+        }
+        this.scheduleDrain(Math.max(this.flushIntervalMs, (retryAtMs != null ? retryAtMs : 0) - Date.now()));
+        break;
+      }
     }
+    return fates;
   }
-  /** See EventShipper.requestOpts — same shutdown-budget semantics. */
-  requestOpts() {
+  /** See EventShipper.requestOpts — same deadline semantics. */
+  requestOpts(deadlineAt) {
+    const opts = this.scheduleFor(deadlineAt);
+    return opts && { ...opts, cutOff: this.cutOff.signal };
+  }
+  scheduleFor(deadlineAt) {
     if (this.shutdownDeadlineAt !== void 0) {
-      const remainingMs = this.shutdownDeadlineAt - Date.now();
-      if (remainingMs <= 0) return null;
+      if (this.shutdownDeadlineAt - Date.now() <= 0) return null;
       return {
-        maxAttempts: 1,
+        maxAttempts: 3,
         debug: this.debug,
         sdkName: this.sdkName,
-        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
+        deadlineAt: Math.min(this.shutdownDeadlineAt, deadlineAt != null ? deadlineAt : Infinity)
       };
     }
     if (this.hasShutdown) {
@@ -2168,27 +3356,28 @@ var TraceShipper = class {
         timeoutMs: POST_SHUTDOWN_TIMEOUT_MS
       };
     }
-    return { maxAttempts: 3, debug: this.debug, sdkName: this.sdkName };
+    return { maxAttempts: 3, debug: this.debug, sdkName: this.sdkName, deadlineAt };
   }
+  /**
+   * Flush within `flushTimeoutMs` and stop; spans left at the deadline are
+   * dropped with a warning. Resolves, never rejects.
+   */
   async shutdown() {
     this.hasShutdown = true;
-    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
+    const deadlineAt = Date.now() + this.flushTimeoutMs;
+    this.shutdownDeadlineAt = deadlineAt;
+    let result = { ...DELIVERED };
     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) {
+      result = await this.drainWithin(deadlineAt);
+      if (!result.delivered) {
         rateLimitedLog(
           `${this.prefix}.shutdown_deadline`,
           () => console.warn(
-            `${this.prefix} shutdown flush deadline exceeded; abandoning in-flight spans`
+            `${this.prefix} shutdown flush deadline exceeded; ${describeUndelivered("shutdown()", result)}`
           )
         );
       }
@@ -2196,10 +3385,74 @@ var TraceShipper = class {
       this.shutdownDeadlineAt = void 0;
       if (this.ownsAppGitContext) this.appGitContext.dispose();
     }
+    return asCompat(result);
   }
 };
+function eventShipperOptions(client, extras = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  return {
+    ...extras,
+    writeKey: (_a = extras.writeKey) != null ? _a : client.writeKey,
+    endpoint: (_b = extras.endpoint) != null ? _b : client.endpoint,
+    projectId: (_c = extras.projectId) != null ? _c : client.projectId,
+    debug: (_e = (_d = extras.debug) != null ? _d : client.debug) != null ? _e : false,
+    maxTextFieldChars: (_f = extras.maxTextFieldChars) != null ? _f : client.maxTextFieldChars,
+    flushTimeoutMs: (_g = extras.flushTimeoutMs) != null ? _g : client.flushTimeoutMs,
+    redactPii: (_h = extras.redactPii) != null ? _h : client.redactPii,
+    redactPiiFields: (_i = extras.redactPiiFields) != null ? _i : client.redactPiiFields
+  };
+}
+function traceShipperOptions(client, extras = {}) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  return {
+    ...extras,
+    writeKey: (_a = extras.writeKey) != null ? _a : client.writeKey,
+    endpoint: (_b = extras.endpoint) != null ? _b : client.endpoint,
+    projectId: (_c = extras.projectId) != null ? _c : client.projectId,
+    debug: (_e = (_d = extras.debug) != null ? _d : client.debug) != null ? _e : false,
+    maxTextFieldChars: (_f = extras.maxTextFieldChars) != null ? _f : client.maxTextFieldChars,
+    flushTimeoutMs: (_g = extras.flushTimeoutMs) != null ? _g : client.flushTimeoutMs
+  };
+}
+function createShippers(client, setup = {}) {
+  return {
+    eventShipper: new EventShipper(eventShipperOptions(client, { ...setup.common, ...setup.event })),
+    traceShipper: new TraceShipper(traceShipperOptions(client, { ...setup.common, ...setup.trace }))
+  };
+}
+function isFlushResult(value) {
+  return typeof value === "object" && value !== null && "delivered" in value && typeof value.delivered === "boolean" && "dropped" in value && typeof value.dropped === "number" && "queued" in value && typeof value.queued === "number" && "inFlight" in value && typeof value.inFlight === "number" && "timedOut" in value && typeof value.timedOut === "boolean";
+}
+var UNDELIVERED = Object.freeze({
+  delivered: false,
+  timedOut: false,
+  dropped: 0,
+  queued: 0,
+  inFlight: 0
+});
+async function settle(call, what) {
+  try {
+    const result = await call();
+    return isFlushResult(result) ? result : DELIVERED;
+  } catch (error) {
+    console.warn(`[raindrop-ai] ${what} failed: ${error instanceof Error ? error.message : String(error)}`);
+    return UNDELIVERED;
+  }
+}
+async function flushShippers(...shippers) {
+  const results = await Promise.all(
+    shippers.flatMap((s) => s ? [settle(() => s.flush(), "flush()")] : [])
+  );
+  return asCompat(combineResults(...results));
+}
+async function shutdownShippers(...shippers) {
+  const results = await Promise.all(
+    shippers.flatMap((s) => s ? [settle(() => s.shutdown(), "shutdown()")] : [])
+  );
+  return asCompat(combineResults(...results));
+}
 var PROMPT_TOOLS_ATTRIBUTE = "ai.prompt.tools";
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var JSON_SCHEMA_KEYS = [
@@ -2217,17 +3470,17 @@ var JSON_SCHEMA_KEYS = [
   "required"
 ];
 function isJsonSchema(value) {
-  if (!isRecord(value)) return false;
+  if (!isRecord3(value)) return false;
   if (typeof value["~standard"] === "object") return false;
-  if (isRecord(value._def) || isRecord(value._zod)) return false;
+  if (isRecord3(value._def) || isRecord3(value._zod)) return false;
   if (Object.keys(value).length === 0) return true;
   return JSON_SCHEMA_KEYS.some((key) => key in value);
 }
 function toJsonSchema(value, options) {
   if (value === void 0 || value === null) return void 0;
   if (isJsonSchema(value)) return value;
-  if (isRecord(value) && isJsonSchema(value.jsonSchema)) return value.jsonSchema;
-  if (isRecord(value) && isJsonSchema(value.json)) return value.json;
+  if (isRecord3(value) && isJsonSchema(value.jsonSchema)) return value.jsonSchema;
+  if (isRecord3(value) && isJsonSchema(value.json)) return value.json;
   if (options == null ? void 0 : options.schema) {
     try {
       return options.schema(value);
@@ -2250,23 +3503,23 @@ function functionTool(name, description, schema, options) {
 }
 function normalizeToolDeclaration(tool, options, fallbackName) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-  if (!isRecord(tool)) return void 0;
+  if (!isRecord3(tool)) return void 0;
   if (tool.type === "provider-defined" || tool.type === "provider") {
     const name2 = (_b = (_a = pickString(tool.name)) != null ? _a : pickString(tool.id)) != null ? _b : fallbackName;
     if (name2 === void 0) return void 0;
     const declaration = { type: "provider-defined", name: name2 };
     const id = pickString(tool.id);
     if (id !== void 0) declaration.id = id;
-    if (isRecord(tool.args)) declaration.args = tool.args;
+    if (isRecord3(tool.args)) declaration.args = tool.args;
     return declaration;
   }
-  if (isRecord(tool.toolSpec)) {
+  if (isRecord3(tool.toolSpec)) {
     const spec = tool.toolSpec;
     const name2 = (_c = pickString(spec.name)) != null ? _c : fallbackName;
     if (name2 === void 0) return void 0;
     return functionTool(name2, spec.description, spec.inputSchema, options);
   }
-  if (isRecord(tool.function)) {
+  if (isRecord3(tool.function)) {
     const fn = tool.function;
     const name2 = (_d = pickString(fn.name)) != null ? _d : fallbackName;
     if (name2 === void 0) return void 0;
@@ -2292,7 +3545,7 @@ function isGeminiToolGroup(tool) {
   if (Array.isArray(tool.functionDeclarations)) return true;
   const keys = Object.keys(tool);
   if (keys.length === 0 || NOT_A_GEMINI_GROUP_KEYS.some((key) => key in tool)) return false;
-  return keys.every((key) => isRecord(tool[key]));
+  return keys.every((key) => isRecord3(tool[key]));
 }
 function expandGeminiTool(tool, options) {
   const declarations = [];
@@ -2302,7 +3555,7 @@ function expandGeminiTool(tool, options) {
         const normalized = normalizeToolDeclaration(declaration, options);
         if (normalized) declarations.push(normalized);
       }
-    } else if (isRecord(value)) {
+    } else if (isRecord3(value)) {
       declarations.push({ type: "provider-defined", id: key, name: key, args: value });
     }
   }
@@ -2312,14 +3565,14 @@ function normalizeToolDeclarations(tools, options) {
   if (tools === void 0 || tools === null) return void 0;
   if (Array.isArray(tools)) {
     return tools.flatMap((tool) => {
-      if (isRecord(tool) && isGeminiToolGroup(tool)) {
+      if (isRecord3(tool) && isGeminiToolGroup(tool)) {
         return expandGeminiTool(tool, options);
       }
       const declaration = normalizeToolDeclaration(tool, options);
       return declaration ? [declaration] : [];
     });
   }
-  if (!isRecord(tools)) return void 0;
+  if (!isRecord3(tools)) return void 0;
   return Object.entries(tools).flatMap(([key, tool]) => {
     const declaration = normalizeToolDeclaration(tool, options, key);
     return declaration ? [declaration] : [];
@@ -2465,39 +3718,6 @@ var resolveLocal = (sourceDirectory, detectBranch, completed) => {
 function createAppGitContext2(options, runtime = {}) {
   return new AppGitContext(options, { ...runtime, resolveLocal });
 }
-function hasDestination(options) {
-  var _a;
-  if (options.enabled === false) return false;
-  return Boolean(((_a = options.writeKey) == null ? void 0 : _a.trim()) || resolveLocalDebuggerBaseUrl(options.localDebuggerUrl));
-}
-var EventShipper2 = class extends EventShipper {
-  constructor(options) {
-    var _a;
-    const ownsAppGitContext = options.appGitContext === void 0;
-    const appGitContext = (_a = options.appGitContext) != null ? _a : createAppGitContext2(options.appGit, { allowDiscovery: hasDestination(options) });
-    try {
-      super({ ...options, appGitContext });
-    } catch (error) {
-      if (ownsAppGitContext) appGitContext.dispose();
-      throw error;
-    }
-    if (ownsAppGitContext) this.ownAppGitContextForShutdown();
-  }
-};
-var TraceShipper2 = class extends TraceShipper {
-  constructor(options) {
-    var _a;
-    const ownsAppGitContext = options.appGitContext === void 0;
-    const appGitContext = (_a = options.appGitContext) != null ? _a : createAppGitContext2(options.appGit, { allowDiscovery: hasDestination(options) });
-    try {
-      super({ ...options, appGitContext });
-    } catch (error) {
-      if (ownsAppGitContext) appGitContext.dispose();
-      throw error;
-    }
-    this.ownsAppGitContext = ownsAppGitContext;
-  }
-};
 globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = import_async_hooks.AsyncLocalStorage;
 var SUPPRESS_TRACING_KEY = /* @__PURE__ */ Symbol.for(
   "OpenTelemetry SDK Context Key SUPPRESS_TRACING"
@@ -2635,6 +3855,8 @@ var RaindropManagedAgentsHandler = class {
       eventName: (_e = context.eventName) != null ? _e : "ai_generation",
       input: void 0,
       model: void 0,
+      // Caller-supplied properties win over the derived keys below (W6).
+      callerProperties: context.properties,
       properties: {
         ...context.properties,
         "ai.provider": "openai",
@@ -2955,7 +4177,7 @@ function isRecord2(value) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/openai-managed-agents",
-  version: "0.0.4",
+  version: "0.0.5",
   description: "Raindrop tracing for the OpenAI Agents API",
   main: "dist/index.js",
   module: "dist/index.mjs",
@@ -3123,7 +4345,7 @@ function wrapManagedAgents(client, handler, context) {
 
 // src/index.ts
 function createRaindropOpenAIManagedAgents(opts = {}) {
-  var _a, _b;
+  var _a;
   const enabled = Boolean((_a = opts.writeKey) == null ? void 0 : _a.trim());
   if (!enabled)
     console.warn(
@@ -3132,44 +4354,33 @@ function createRaindropOpenAIManagedAgents(opts = {}) {
   const appGitContext = createAppGitContext2(enabled ? opts.appGit : false, {
     allowLocalGit: false
   });
-  const shipperOptions = {
-    writeKey: opts.writeKey,
-    endpoint: opts.endpoint,
-    projectId: opts.projectId,
-    enabled,
-    debug: (_b = opts.debug) != null ? _b : false,
-    sdkName: "openai-managed-agents",
-    libraryName,
-    libraryVersion,
-    appGitContext,
-    maxTextFieldChars: opts.maxTextFieldChars,
-    localDebuggerUrl: opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl
-  };
-  const events = new EventShipper2(shipperOptions);
-  const traces = new TraceShipper2({
-    ...shipperOptions,
-    serviceName: "raindrop.openai-managed-agents",
-    serviceVersion: libraryVersion
+  const { eventShipper: events, traceShipper: traces } = createShippers(opts, {
+    common: {
+      enabled,
+      sdkName: "openai-managed-agents",
+      appGitContext,
+      localDebuggerUrl: opts.localWorkshopUrl === false ? null : opts.localWorkshopUrl
+    },
+    event: { libraryName, libraryVersion },
+    trace: { serviceName: "raindrop.openai-managed-agents", serviceVersion: libraryVersion }
   });
   const handler = new RaindropManagedAgentsHandler(events, traces, opts);
   return {
     handler,
     wrap: (client, context) => wrapManagedAgents(client, handler, context),
-    events: {
-      patch: (id, patch) => events.patch(id, patch),
-      finish: (id, patch) => events.finish(id, patch),
-      addAttachments: (id, attachments) => events.patch(id, { attachments }),
-      setProperties: (id, properties) => events.patch(id, { properties })
+    get lastEventId() {
+      return events == null ? void 0 : events.lastFinishedEventId;
     },
+    events: createEventsApi(events),
     users: { identify: (users) => events.identify(users) },
     signals: { track: (signal) => events.trackSignal(signal) },
-    async flush() {
-      await Promise.all([events.flush(), traces.flush()]);
+    flush() {
+      return flushShippers(events, traces);
     },
     async shutdown() {
       try {
         handler.shutdown();
-        await Promise.all([events.shutdown(), traces.shutdown()]);
+        return await shutdownShippers(events, traces);
       } finally {
         appGitContext.dispose();
       }