@raindrop-ai/pi-agent 0.0.2

package/dist/index.cjs

@@ -0,0 +1,1405 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createRaindropPiAgent: () => createRaindropPiAgent
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../core/dist/chunk-4UCYIEH4.js
+function getCrypto() {
+  const c = globalThis.crypto;
+  return c;
+}
+function randomBytes(length) {
+  const cryptoObj = getCrypto();
+  const out = new Uint8Array(length);
+  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+    cryptoObj.getRandomValues(out);
+    return out;
+  }
+  for (let i = 0; i < out.length; i++) out[i] = Math.floor(Math.random() * 256);
+  return out;
+}
+function randomUUID() {
+  const cryptoObj = getCrypto();
+  if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
+    return cryptoObj.randomUUID();
+  }
+  const b = randomBytes(16);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const hex = [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function base64Encode(bytes) {
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
+  }
+  const btoaFn = globalThis.btoa;
+  if (typeof btoaFn === "function") return btoaFn(binary);
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let out = "";
+  let i = 0;
+  while (i < binary.length) {
+    const c1 = binary.charCodeAt(i++) & 255;
+    const c2 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
+    const c3 = i < binary.length ? binary.charCodeAt(i++) & 255 : NaN;
+    const e1 = c1 >> 2;
+    const e2 = (c1 & 3) << 4 | (Number.isNaN(c2) ? 0 : c2 >> 4);
+    const e3 = Number.isNaN(c2) ? 64 : (c2 & 15) << 2 | (Number.isNaN(c3) ? 0 : c3 >> 6);
+    const e4 = Number.isNaN(c3) ? 64 : c3 & 63;
+    out += alphabet.charAt(e1);
+    out += alphabet.charAt(e2);
+    out += e3 === 64 ? "=" : alphabet.charAt(e3);
+    out += e4 === 64 ? "=" : alphabet.charAt(e4);
+  }
+  return out;
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatEndpoint(endpoint) {
+  if (!endpoint) return void 0;
+  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
+}
+function parseRetryAfter(headers) {
+  var _a;
+  const value = (_a = headers.get("Retry-After")) != null ? _a : headers.get("retry-after");
+  if (!value) return void 0;
+  const asNumber = Number(value);
+  if (value.trim() !== "" && !Number.isNaN(asNumber)) return asNumber * 1e3;
+  const asDate = new Date(value).getTime();
+  if (!Number.isNaN(asDate)) {
+    const delta = asDate - Date.now();
+    return delta > 0 ? delta : 0;
+  }
+  return void 0;
+}
+function getRetryDelayMs(attemptNumber, previousError) {
+  if (previousError && typeof previousError === "object" && previousError !== null && "retryAfterMs" in previousError) {
+    const v = previousError.retryAfterMs;
+    if (typeof v === "number") return Math.max(0, v);
+  }
+  if (attemptNumber <= 1) return 0;
+  const base = 500;
+  const factor = Math.pow(2, attemptNumber - 2);
+  return base * factor;
+}
+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;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function postJson(url, body, headers, opts) {
+  const opName = `POST ${url}`;
+  await withRetry(
+    async () => {
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify(body)
+      });
+      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;
+      }
+    },
+    opName,
+    opts
+  );
+}
+var SpanStatusCode = {
+  UNSET: 0,
+  OK: 1,
+  ERROR: 2
+};
+function createSpanIds(parent) {
+  const traceId = parent ? parent.traceIdB64 : base64Encode(randomBytes(16));
+  const spanId = base64Encode(randomBytes(8));
+  return {
+    traceIdB64: traceId,
+    spanIdB64: spanId,
+    parentSpanIdB64: parent ? parent.spanIdB64 : void 0
+  };
+}
+function nowUnixNanoString() {
+  return Date.now().toString() + "000000";
+}
+function attrString(key, value) {
+  if (value === void 0) return void 0;
+  return { key, value: { stringValue: value } };
+}
+function attrInt(key, value) {
+  if (value === void 0) return void 0;
+  if (!Number.isFinite(value)) return void 0;
+  return { key, value: { intValue: String(Math.trunc(value)) } };
+}
+function buildOtlpSpan(args) {
+  const attrs = args.attributes.filter((x) => x !== void 0);
+  const span = {
+    traceId: args.ids.traceIdB64,
+    spanId: args.ids.spanIdB64,
+    name: args.name,
+    startTimeUnixNano: args.startTimeUnixNano,
+    endTimeUnixNano: args.endTimeUnixNano
+  };
+  if (args.ids.parentSpanIdB64) span.parentSpanId = args.ids.parentSpanIdB64;
+  if (attrs.length) span.attributes = attrs;
+  if (args.status) span.status = args.status;
+  return span;
+}
+function buildExportTraceServiceRequest(spans, serviceName = "raindrop.core", serviceVersion = "0.0.0") {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [{ key: "service.name", value: { stringValue: serviceName } }]
+        },
+        scopeSpans: [
+          {
+            scope: { name: serviceName, version: serviceVersion },
+            spans
+          }
+        ]
+      }
+    ]
+  };
+}
+function mergePatches(target, source) {
+  var _a, _b, _c, _d;
+  const out = { ...target, ...source };
+  if (target.properties || source.properties) {
+    out.properties = { ...(_a = target.properties) != null ? _a : {}, ...(_b = source.properties) != null ? _b : {} };
+  }
+  if (target.attachments || source.attachments) {
+    out.attachments = [...(_c = target.attachments) != null ? _c : [], ...(_d = source.attachments) != null ? _d : []];
+  }
+  return out;
+}
+var EventShipper = class {
+  constructor(opts) {
+    this.buffers = /* @__PURE__ */ new Map();
+    this.sticky = /* @__PURE__ */ new Map();
+    this.timers = /* @__PURE__ */ new Map();
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
+    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    this.enabled = opts.enabled !== false;
+    this.debug = opts.debug;
+    this.partialFlushMs = (_c = opts.partialFlushMs) != null ? _c : 1e3;
+    this.sdkName = (_d = opts.sdkName) != null ? _d : "core";
+    this.prefix = `[raindrop-ai/${this.sdkName}]`;
+    this.defaultEventName = (_e = opts.defaultEventName) != null ? _e : "ai_generation";
+    const isNode = typeof process !== "undefined" && typeof process.version === "string";
+    this.context = {
+      library: {
+        name: (_f = opts.libraryName) != null ? _f : "@raindrop-ai/core",
+        version: (_g = opts.libraryVersion) != null ? _g : "0.0.0"
+      },
+      metadata: {
+        jsRuntime: isNode ? "node" : "web",
+        ...isNode ? { nodeVersion: process.version } : {}
+      }
+    };
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  authHeaders() {
+    return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
+  }
+  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;
+    if (this.debug) {
+      console.log(`${this.prefix} queue patch`, {
+        eventId,
+        userId: patch.userId,
+        convoId: patch.convoId,
+        eventName: patch.eventName,
+        hasInput: typeof patch.input === "string" && patch.input.length > 0,
+        hasOutput: typeof patch.output === "string" && patch.output.length > 0,
+        attachments: (_b = (_a = patch.attachments) == null ? void 0 : _a.length) != null ? _b : 0,
+        isPending: patch.isPending
+      });
+    }
+    const sticky = (_c = this.sticky.get(eventId)) != null ? _c : {};
+    const existing = (_d = this.buffers.get(eventId)) != null ? _d : {};
+    const merged = mergePatches(existing, patch);
+    merged.isPending = (_g = (_f = (_e = patch.isPending) != null ? _e : existing.isPending) != null ? _f : sticky.isPending) != null ? _g : true;
+    this.buffers.set(eventId, merged);
+    this.sticky.set(eventId, {
+      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
+    });
+    const t = this.timers.get(eventId);
+    if (t) clearTimeout(t);
+    if (merged.isPending === false) {
+      await this.flushOne(eventId);
+      return;
+    }
+    const timeout = setTimeout(() => {
+      void this.flushOne(eventId).catch(() => {
+      });
+    }, this.partialFlushMs);
+    this.timers.set(eventId, timeout);
+  }
+  async finish(eventId, patch) {
+    await this.patch(eventId, { ...patch, isPending: false });
+  }
+  async flush() {
+    if (!this.enabled) return;
+    const ids = [...this.buffers.keys()];
+    await Promise.all(ids.map((id) => this.flushOne(id)));
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+  async shutdown() {
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+    await this.flush();
+  }
+  async trackSignal(signal) {
+    var _a, _b;
+    if (!this.enabled) return;
+    const body = [
+      {
+        event_id: signal.eventId,
+        signal_name: signal.name,
+        signal_type: (_a = signal.type) != null ? _a : "default",
+        timestamp: signal.timestamp,
+        sentiment: signal.sentiment,
+        attachment_id: signal.attachmentId,
+        properties: {
+          ...(_b = signal.properties) != null ? _b : {},
+          ...signal.comment ? { comment: signal.comment } : {},
+          ...signal.after ? { after: signal.after } : {}
+        }
+      }
+    ];
+    const url = `${this.baseUrl}signals/track`;
+    try {
+      await postJson(url, body, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`${this.prefix} failed to send signal (dropping): ${msg}`);
+    }
+  }
+  async identify(users) {
+    if (!this.enabled) return;
+    const list = Array.isArray(users) ? users : [users];
+    const body = list.filter((user) => {
+      if (!(user == null ? void 0 : user.userId) || !user.userId.trim()) {
+        if (this.debug) {
+          console.warn(`${this.prefix} skipping identify: missing userId`);
+        }
+        return false;
+      }
+      return true;
+    }).map((user) => {
+      var _a;
+      return {
+        user_id: user.userId,
+        traits: (_a = user.traits) != null ? _a : {}
+      };
+    });
+    if (body.length === 0) return;
+    const url = `${this.baseUrl}users/identify`;
+    try {
+      await postJson(url, body, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`${this.prefix} failed to send identify (dropping): ${msg}`);
+    }
+  }
+  async flushOne(eventId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    if (!this.enabled) return;
+    const timer = this.timers.get(eventId);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(eventId);
+    }
+    const accumulated = this.buffers.get(eventId);
+    this.buffers.delete(eventId);
+    if (!accumulated) return;
+    const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
+    const eventName = (_c = (_b = accumulated.eventName) != null ? _b : sticky.eventName) != null ? _c : this.defaultEventName;
+    const userId = (_d = accumulated.userId) != null ? _d : sticky.userId;
+    if (!userId) {
+      if (this.debug) {
+        console.warn(`${this.prefix} skipping track_partial for ${eventId}: missing userId`);
+      }
+      this.sticky.delete(eventId);
+      return;
+    }
+    const { wizardSession, ...restProperties } = (_e = accumulated.properties) != null ? _e : {};
+    const convoId = (_f = accumulated.convoId) != null ? _f : sticky.convoId;
+    const isPending = (_h = (_g = accumulated.isPending) != null ? _g : sticky.isPending) != null ? _h : true;
+    const payload = {
+      event_id: eventId,
+      user_id: userId,
+      event: eventName,
+      timestamp: (_i = accumulated.timestamp) != null ? _i : (/* @__PURE__ */ new Date()).toISOString(),
+      ai_data: {
+        input: accumulated.input,
+        output: accumulated.output,
+        model: accumulated.model,
+        convo_id: convoId
+      },
+      properties: {
+        ...restProperties,
+        ...wizardSession ? { "raindrop.wizardSession": wizardSession } : {},
+        $context: this.context
+      },
+      attachments: accumulated.attachments,
+      is_pending: isPending
+    };
+    const url = `${this.baseUrl}events/track_partial`;
+    if (this.debug) {
+      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) => ({
+          type: a.type,
+          role: a.role,
+          name: a.name,
+          valuePreview: a.value.slice(0, 60)
+        }))) != null ? _m : [],
+        endpoint: url
+      });
+    }
+    const p = postJson(url, payload, this.authHeaders(), {
+      maxAttempts: 3,
+      debug: this.debug,
+      sdkName: this.sdkName
+    });
+    this.inFlight.add(p);
+    try {
+      try {
+        await p;
+        if (this.debug) {
+          console.log(`${this.prefix} sent track_partial ${eventId} (${eventName})`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`${this.prefix} failed to send track_partial (dropping): ${msg}`);
+      }
+    } finally {
+      this.inFlight.delete(p);
+    }
+    if (!isPending) {
+      this.sticky.delete(eventId);
+    }
+  }
+};
+var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
+function resolveLocalDebuggerBaseUrl(baseUrl) {
+  var _a, _b, _c;
+  const resolved = (_b = baseUrl != null ? baseUrl : typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a[LOCAL_DEBUGGER_ENV_VAR] : void 0) != null ? _b : null;
+  return resolved ? (_c = formatEndpoint(resolved)) != null ? _c : null : null;
+}
+function mirrorTraceExportToLocalDebugger(body, options = {}) {
+  var _a;
+  const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
+  if (!baseUrl) return;
+  void postJson(`${baseUrl}traces`, body, {}, {
+    maxAttempts: 1,
+    debug: (_a = options.debug) != null ? _a : false,
+    sdkName: options.sdkName
+  }).catch(() => {
+  });
+}
+var TraceShipper = class {
+  constructor(opts) {
+    this.queue = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
+    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    this.enabled = opts.enabled !== false;
+    this.debug = opts.debug;
+    this.debugSpans = opts.debugSpans === true;
+    this.flushIntervalMs = (_c = opts.flushIntervalMs) != null ? _c : 1e3;
+    this.maxBatchSize = (_d = opts.maxBatchSize) != null ? _d : 50;
+    this.maxQueueSize = (_e = opts.maxQueueSize) != null ? _e : 5e3;
+    this.sdkName = (_f = opts.sdkName) != null ? _f : "core";
+    this.prefix = `[raindrop-ai/${this.sdkName}]`;
+    this.serviceName = (_g = opts.serviceName) != null ? _g : "raindrop.core";
+    this.serviceVersion = (_h = opts.serviceVersion) != null ? _h : "0.0.0";
+    const localDebugger = typeof process !== "undefined" ? (_i = process.env) == null ? void 0 : _i.RAINDROP_LOCAL_DEBUGGER : void 0;
+    if (localDebugger) {
+      this.localDebuggerUrl = (_j = resolveLocalDebuggerBaseUrl(localDebugger)) != null ? _j : void 0;
+      if (this.debug) {
+        console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
+      }
+    }
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  authHeaders() {
+    return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
+  }
+  startSpan(args) {
+    var _a, _b;
+    const ids = createSpanIds(args.parent);
+    const started = (_a = args.startTimeUnixNano) != null ? _a : nowUnixNanoString();
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
+      attrString("ai.operationId", args.operationId)
+    ];
+    if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
+    const span = { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
+    if (this.localDebuggerUrl) {
+      const openSpan = buildOtlpSpan({
+        ids: span.ids,
+        name: span.name,
+        startTimeUnixNano: span.startTimeUnixNano,
+        endTimeUnixNano: span.startTimeUnixNano,
+        // placeholder — will be updated on endSpan
+        attributes: span.attributes,
+        status: { code: SpanStatusCode.UNSET }
+      });
+      const body = buildExportTraceServiceRequest([openSpan], this.serviceName, this.serviceVersion);
+      mirrorTraceExportToLocalDebugger(body, {
+        baseUrl: this.localDebuggerUrl,
+        debug: false,
+        sdkName: this.sdkName
+      });
+    }
+    return span;
+  }
+  endSpan(span, extra) {
+    var _a, _b;
+    if (span.endTimeUnixNano) return;
+    span.endTimeUnixNano = (_a = extra == null ? void 0 : extra.endTimeUnixNano) != null ? _a : nowUnixNanoString();
+    if ((_b = extra == null ? void 0 : extra.attributes) == null ? void 0 : _b.length) {
+      span.attributes.push(...extra.attributes);
+    }
+    let status = extra == null ? void 0 : extra.status;
+    if (!status && (extra == null ? void 0 : extra.error) !== void 0) {
+      const message = extra.error instanceof Error ? extra.error.message : String(extra.error);
+      status = { code: SpanStatusCode.ERROR, message };
+    }
+    const otlp = buildOtlpSpan({
+      ids: span.ids,
+      name: span.name,
+      startTimeUnixNano: span.startTimeUnixNano,
+      endTimeUnixNano: span.endTimeUnixNano,
+      attributes: span.attributes,
+      status
+    });
+    this.enqueue(otlp);
+    if (this.localDebuggerUrl) {
+      const body = buildExportTraceServiceRequest([otlp], this.serviceName, this.serviceVersion);
+      mirrorTraceExportToLocalDebugger(body, {
+        baseUrl: this.localDebuggerUrl,
+        debug: false,
+        sdkName: this.sdkName
+      });
+    }
+  }
+  createSpan(args) {
+    var _a;
+    const ids = createSpanIds(args.parent);
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId)
+    ];
+    if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
+    const otlp = buildOtlpSpan({
+      ids,
+      name: args.name,
+      startTimeUnixNano: args.startTimeUnixNano,
+      endTimeUnixNano: args.endTimeUnixNano,
+      attributes: attrs,
+      status: args.status
+    });
+    this.enqueue(otlp);
+    if (this.localDebuggerUrl) {
+      const body = buildExportTraceServiceRequest([otlp], this.serviceName, this.serviceVersion);
+      mirrorTraceExportToLocalDebugger(body, {
+        baseUrl: this.localDebuggerUrl,
+        debug: false,
+        sdkName: this.sdkName
+      });
+    }
+  }
+  enqueue(span) {
+    if (!this.enabled) return;
+    if (this.debugSpans) {
+      const short = (s) => s ? s.slice(-8) : "none";
+      console.log(
+        `${this.prefix}[span] name=${span.name} trace=${short(span.traceId)} span=${short(span.spanId)} parent=${short(
+          span.parentSpanId
+        )}`
+      );
+    }
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+    }
+    this.queue.push(span);
+    if (this.queue.length >= this.maxBatchSize) {
+      void this.flush().catch(() => {
+      });
+      return;
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = void 0;
+        void this.flush().catch(() => {
+        });
+      }, this.flushIntervalMs);
+    }
+  }
+  async flush() {
+    if (!this.enabled) return;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    while (this.queue.length > 0) {
+      const batch = this.queue.splice(0, this.maxBatchSize);
+      const body = buildExportTraceServiceRequest(batch, this.serviceName, this.serviceVersion);
+      const url = `${this.baseUrl}traces`;
+      if (this.debug) {
+        console.log(`${this.prefix} sending traces batch`, {
+          spans: batch.length,
+          endpoint: url
+        });
+      }
+      const p = postJson(url, body, this.authHeaders(), {
+        maxAttempts: 3,
+        debug: this.debug,
+        sdkName: this.sdkName
+      });
+      this.inFlight.add(p);
+      try {
+        try {
+          await p;
+          if (this.debug) console.log(`${this.prefix} sent ${batch.length} spans`);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.warn(`${this.prefix} failed to send ${batch.length} spans: ${msg}`);
+        }
+      } finally {
+        this.inFlight.delete(p);
+      }
+    }
+  }
+  async shutdown() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    await this.flush();
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+};
+
+// ../core/dist/index.node.js
+var import_async_hooks = require("async_hooks");
+globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = import_async_hooks.AsyncLocalStorage;
+
+// package.json
+var package_default = {
+  name: "@raindrop-ai/pi-agent",
+  version: "0.0.2",
+  description: "Raindrop observability for Pi Agent \u2014 automatic tracing via subscriber or pi-coding-agent extension",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/raindrop-ai/raindrop-js.git",
+    directory: "packages/pi-agent"
+  },
+  homepage: "https://github.com/raindrop-ai/raindrop-js/tree/main/packages/pi-agent#readme",
+  bugs: {
+    url: "https://github.com/raindrop-ai/raindrop-js/issues"
+  },
+  keywords: [
+    "pi-package",
+    "raindrop",
+    "pi-agent",
+    "observability",
+    "tracing"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./extension": {
+      types: "./dist/extension.d.ts",
+      import: "./dist/extension.js",
+      require: "./dist/extension.cjs"
+    }
+  },
+  pi: {
+    extensions: [
+      "./dist/extension.js"
+    ]
+  },
+  sideEffects: false,
+  files: [
+    "dist/**",
+    "README.md"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    clean: "rm -rf dist",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  peerDependencies: {
+    "@mariozechner/pi-agent-core": ">=0.60.0",
+    "@mariozechner/pi-coding-agent": ">=0.65.2"
+  },
+  peerDependenciesMeta: {
+    "@mariozechner/pi-coding-agent": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@raindrop-ai/core": "workspace:*",
+    "@mariozechner/pi-agent-core": "^0.66.0",
+    "@mariozechner/pi-coding-agent": "^0.66.0",
+    "@types/node": "^20.11.17",
+    msw: "^2.12.7",
+    tsup: "^8.5.1",
+    typescript: "^5.7.3",
+    vitest: "^2.1.9"
+  },
+  tsup: {
+    entry: [
+      "src/index.ts",
+      "src/extension.ts"
+    ],
+    format: [
+      "cjs",
+      "esm"
+    ],
+    dts: {
+      resolve: true
+    },
+    clean: true,
+    noExternal: [
+      "@raindrop-ai/core"
+    ]
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/version.ts
+var libraryName = package_default.name;
+var libraryVersion = package_default.version;
+
+// src/internal/shipper.ts
+var EventShipper2 = class extends EventShipper {
+  constructor(opts) {
+    var _a, _b, _c, _d;
+    super({
+      ...opts,
+      sdkName: (_a = opts.sdkName) != null ? _a : "pi-agent",
+      libraryName: (_b = opts.libraryName) != null ? _b : libraryName,
+      libraryVersion: (_c = opts.libraryVersion) != null ? _c : libraryVersion,
+      defaultEventName: (_d = opts.defaultEventName) != null ? _d : "pi_agent_prompt"
+    });
+  }
+};
+var TraceShipper2 = class extends TraceShipper {
+  constructor(opts) {
+    var _a, _b, _c;
+    super({
+      ...opts,
+      sdkName: (_a = opts.sdkName) != null ? _a : "pi-agent",
+      serviceName: (_b = opts.serviceName) != null ? _b : "raindrop.pi-agent",
+      serviceVersion: (_c = opts.serviceVersion) != null ? _c : libraryVersion
+    });
+  }
+  enqueue(span) {
+    var _a;
+    const attrs = (_a = span.attributes) != null ? _a : [];
+    attrs.unshift(
+      { key: "span.id", value: { stringValue: span.spanId } },
+      ...span.parentSpanId ? [{ key: "span.parent.id", value: { stringValue: span.parentSpanId } }] : []
+    );
+    span.attributes = attrs;
+    super.enqueue(span);
+  }
+};
+
+// src/internal/helpers.ts
+var import_node_os = require("os");
+function extractUserText(message) {
+  if (!("role" in message) || message.role !== "user") return void 0;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  const textParts = [];
+  for (const block of content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      textParts.push(block.text);
+    }
+  }
+  return textParts.length > 0 ? textParts.join("\n") : void 0;
+}
+function extractModelName(message) {
+  if (!("role" in message) || message.role !== "assistant") return void 0;
+  const provider = "provider" in message ? message.provider : void 0;
+  const model = typeof message.model === "string" ? message.model : void 0;
+  if (provider && model) return `${provider}/${model}`;
+  return model;
+}
+function extractTokenUsage(message) {
+  if (!("role" in message) || message.role !== "assistant") return void 0;
+  const usage = message.usage;
+  if (!usage || typeof usage.input !== "number" || typeof usage.output !== "number") {
+    return void 0;
+  }
+  return {
+    input: usage.input,
+    output: usage.output,
+    ...typeof usage.cacheRead === "number" && usage.cacheRead > 0 ? { cacheRead: usage.cacheRead } : {}
+  };
+}
+function extractAssistantText(message) {
+  if (!("role" in message) || message.role !== "assistant") return void 0;
+  if (!Array.isArray(message.content)) return void 0;
+  const textParts = [];
+  for (const block of message.content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      textParts.push(block.text);
+    }
+  }
+  return textParts.length > 0 ? textParts.join("\n") : void 0;
+}
+function extractToolCallIds(message) {
+  if (!("role" in message) || message.role !== "assistant") return [];
+  if (!Array.isArray(message.content)) return [];
+  const ids = [];
+  for (const block of message.content) {
+    if (block.type === "toolCall" && typeof block.id === "string") {
+      ids.push(block.id);
+    }
+  }
+  return ids;
+}
+function formatToolSpanName(toolName, args) {
+  if (!args || typeof args !== "object") return toolName;
+  try {
+    const obj = args;
+    const firstValue = Object.values(obj)[0];
+    if (typeof firstValue === "string" && firstValue.length > 0) {
+      const preview = firstValue.length > 40 ? firstValue.slice(0, 37) + "..." : firstValue;
+      return `${toolName}: ${preview}`;
+    }
+  } catch (e) {
+  }
+  return toolName;
+}
+function safeStringify(value) {
+  if (value === void 0 || value === null) return void 0;
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    try {
+      return String(value);
+    } catch (e2) {
+      return "[unserializable]";
+    }
+  }
+}
+var MAX_ATTR_LENGTH = 32768;
+function truncate(value) {
+  if (value === void 0) return void 0;
+  if (value.length <= MAX_ATTR_LENGTH) return value;
+  const suffix = "\n...[truncated]";
+  return value.slice(0, MAX_ATTR_LENGTH - suffix.length) + suffix;
+}
+var _hostname;
+function getHostname() {
+  var _a;
+  if (_hostname) return _hostname;
+  try {
+    _hostname = (0, import_node_os.hostname)();
+  } catch (e) {
+    _hostname = (_a = process.env.HOSTNAME) != null ? _a : "unknown";
+  }
+  return _hostname;
+}
+var _username;
+function getUsername() {
+  var _a, _b;
+  if (_username) return _username;
+  try {
+    _username = (0, import_node_os.userInfo)().username;
+  } catch (e) {
+    _username = (_b = (_a = process.env.USER) != null ? _a : process.env.USERNAME) != null ? _b : "unknown";
+  }
+  return _username;
+}
+
+// src/internal/subscriber.ts
+function createSubscriber(agent, eventShipper, traceShipper, defaultOptions, options, debug) {
+  var _a, _b, _c, _d, _e;
+  const userId = (_a = options.userId) != null ? _a : defaultOptions.userId;
+  const convoId = (_b = options.convoId) != null ? _b : defaultOptions.convoId;
+  const eventName = (_c = options.eventName) != null ? _c : defaultOptions.eventName;
+  const properties = {
+    ...(_d = defaultOptions.properties) != null ? _d : {},
+    ...(_e = options.properties) != null ? _e : {}
+  };
+  let currentRun;
+  function log(msg) {
+    if (debug) console.log(`[raindrop-ai/pi-agent] ${msg}`);
+  }
+  function handleAgentStart() {
+    try {
+      if (currentRun) {
+        if (traceShipper) {
+          for (const [, span] of currentRun.toolSpans) {
+            traceShipper.endSpan(span);
+          }
+        }
+        if (currentRun.currentTurnSpan && traceShipper) {
+          traceShipper.endSpan(currentRun.currentTurnSpan);
+        }
+        if (currentRun.rootSpan && traceShipper) {
+          traceShipper.endSpan(currentRun.rootSpan, {
+            error: "Previous run was not finalized"
+          });
+        }
+        if (eventShipper) {
+          eventShipper.finish(currentRun.eventId, {
+            userId: userId != null ? userId : "anonymous",
+            properties: { sdk_version: libraryVersion, incomplete: true }
+          }).catch(() => {
+          });
+        }
+        currentRun = void 0;
+      }
+      const eventId = randomUUID();
+      const rootSpan = traceShipper ? traceShipper.startSpan({
+        name: "ai.event",
+        eventId,
+        attributes: [
+          attrString("hostname", getHostname()),
+          attrString("os", process.platform),
+          attrString("username", getUsername())
+        ]
+      }) : void 0;
+      currentRun = {
+        eventId,
+        rootSpan,
+        currentInput: "",
+        outputParts: [],
+        toolSpans: /* @__PURE__ */ new Map(),
+        toolArgs: /* @__PURE__ */ new Map(),
+        toolCallToLlmSpan: /* @__PURE__ */ new Map(),
+        lastModel: "",
+        turnNumber: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCacheReadTokens: 0
+      };
+      if (eventShipper) {
+        eventShipper.patch(eventId, {
+          isPending: true,
+          userId: userId != null ? userId : "anonymous",
+          convoId,
+          eventName,
+          properties: {
+            ...properties,
+            sdk_version: libraryVersion,
+            hostname: getHostname(),
+            os: process.platform
+          }
+        }).catch(() => {
+        });
+      }
+    } catch (err) {
+      log(`Error in agent_start handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleMessageEnd(message) {
+    try {
+      if (!currentRun) return;
+      const userText = extractUserText(message);
+      if (userText !== void 0) {
+        currentRun.currentInput = userText;
+        if (eventShipper) {
+          eventShipper.patch(currentRun.eventId, { input: userText }).catch(() => {
+          });
+        }
+        return;
+      }
+      if (!("role" in message) || message.role !== "assistant") return;
+      const model = extractModelName(message);
+      const usage = extractTokenUsage(message);
+      const assistantText = extractAssistantText(message);
+      if (model) currentRun.lastModel = model;
+      if (usage) {
+        currentRun.totalInputTokens += usage.input;
+        currentRun.totalOutputTokens += usage.output;
+        if (usage.cacheRead) currentRun.totalCacheReadTokens += usage.cacheRead;
+      }
+      if (!traceShipper || !currentRun.currentTurnSpan) return;
+      const rawProvider = "provider" in message && typeof message.provider === "string" ? message.provider : void 0;
+      const rawModelId = typeof message.model === "string" ? message.model : void 0;
+      const stopReason = "stopReason" in message && typeof message.stopReason === "string" ? message.stopReason : void 0;
+      const llmAttrs = [
+        attrString("ai.operationId", "generateText")
+      ];
+      if (rawProvider) {
+        llmAttrs.push(attrString("gen_ai.system", rawProvider));
+      }
+      if (rawModelId) {
+        llmAttrs.push(
+          attrString("gen_ai.response.model", rawModelId),
+          attrString("gen_ai.request.model", rawModelId)
+        );
+      }
+      if (usage) {
+        llmAttrs.push(
+          attrInt("gen_ai.usage.input_tokens", usage.input),
+          attrInt("gen_ai.usage.output_tokens", usage.output)
+        );
+        if (usage.cacheRead) {
+          llmAttrs.push(attrInt("gen_ai.usage.cache_read_tokens", usage.cacheRead));
+        }
+      }
+      if (assistantText) {
+        llmAttrs.push(attrString("ai.response.text", truncate(assistantText)));
+      }
+      if (currentRun.currentInput) {
+        llmAttrs.push(attrString("ai.prompt", truncate(currentRun.currentInput)));
+      }
+      if (stopReason) {
+        llmAttrs.push(attrString("ai.stop_reason", stopReason));
+      }
+      const llmSpan = traceShipper.startSpan({
+        name: model != null ? model : "llm",
+        parent: currentRun.currentTurnSpan.ids,
+        eventId: currentRun.eventId,
+        attributes: llmAttrs
+      });
+      const errorForSpan = stopReason === "error" || stopReason === "aborted" ? "errorMessage" in message && typeof message.errorMessage === "string" ? message.errorMessage : `Assistant ${stopReason}` : void 0;
+      traceShipper.endSpan(llmSpan, errorForSpan ? { error: errorForSpan } : void 0);
+      const toolCallIds = extractToolCallIds(message);
+      for (const tcId of toolCallIds) {
+        currentRun.toolCallToLlmSpan.set(tcId, llmSpan);
+      }
+    } catch (err) {
+      log(`Error in message_end handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleMessageUpdate(event) {
+    try {
+      if (!currentRun) return;
+      const ame = event.assistantMessageEvent;
+      if (ame.type === "text_delta" && "delta" in ame && typeof ame.delta === "string") {
+        currentRun.outputParts.push(ame.delta);
+      }
+    } catch (err) {
+      log(`Error in message_update handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleTurnStart() {
+    try {
+      if (!currentRun) return;
+      currentRun.outputParts = [];
+      if (!traceShipper || !currentRun.rootSpan) return;
+      if (currentRun.currentTurnSpan) {
+        traceShipper.endSpan(currentRun.currentTurnSpan);
+      }
+      currentRun.turnNumber += 1;
+      currentRun.currentTurnSpan = traceShipper.startSpan({
+        name: `Turn ${currentRun.turnNumber}`,
+        parent: currentRun.rootSpan.ids,
+        eventId: currentRun.eventId,
+        attributes: [
+          attrString("ai.operationId", "ai.turn"),
+          attrInt("ai.turn_number", currentRun.turnNumber)
+        ]
+      });
+    } catch (err) {
+      log(`Error in turn_start handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleTurnEnd() {
+    try {
+      if (!currentRun || !traceShipper || !currentRun.currentTurnSpan) return;
+      traceShipper.endSpan(currentRun.currentTurnSpan);
+      currentRun.currentTurnSpan = void 0;
+    } catch (err) {
+      log(`Error in turn_end handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleToolExecutionStart(toolCallId, toolName, args) {
+    var _a2;
+    try {
+      if (!currentRun) return;
+      currentRun.toolArgs.set(toolCallId, args);
+      if (!traceShipper) return;
+      const parentLlmSpan = currentRun.toolCallToLlmSpan.get(toolCallId);
+      const parentSpan = (_a2 = parentLlmSpan != null ? parentLlmSpan : currentRun.currentTurnSpan) != null ? _a2 : currentRun.rootSpan;
+      if (!parentSpan) return;
+      const toolSpan = traceShipper.startSpan({
+        name: formatToolSpanName(toolName, args),
+        parent: parentSpan.ids,
+        eventId: currentRun.eventId,
+        attributes: [
+          attrString("ai.operationId", "ai.toolCall"),
+          attrString("ai.toolCall.name", toolName),
+          attrString("ai.toolCall.id", toolCallId)
+        ]
+      });
+      currentRun.toolSpans.set(toolCallId, toolSpan);
+    } catch (err) {
+      log(`Error in tool_execution_start handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleToolExecutionEnd(toolCallId, toolName, result, isError) {
+    try {
+      if (!currentRun) return;
+      const toolSpan = currentRun.toolSpans.get(toolCallId);
+      currentRun.toolSpans.delete(toolCallId);
+      currentRun.toolCallToLlmSpan.delete(toolCallId);
+      const args = currentRun.toolArgs.get(toolCallId);
+      currentRun.toolArgs.delete(toolCallId);
+      if (!traceShipper || !toolSpan) return;
+      const endAttrs = [];
+      const argsStr = truncate(safeStringify(args));
+      if (argsStr) endAttrs.push(attrString("ai.toolCall.args", argsStr));
+      const resultStr = truncate(safeStringify(result));
+      if (resultStr) endAttrs.push(attrString("ai.toolCall.result", resultStr));
+      traceShipper.endSpan(toolSpan, {
+        attributes: endAttrs,
+        ...isError ? { error: `Tool "${toolName}" failed` } : {}
+      });
+    } catch (err) {
+      log(`Error in tool_execution_end handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleAgentEnd() {
+    try {
+      if (!currentRun) return;
+      const run = currentRun;
+      currentRun = void 0;
+      if (traceShipper) {
+        for (const [, span] of run.toolSpans) {
+          traceShipper.endSpan(span);
+        }
+      }
+      run.toolSpans.clear();
+      run.toolCallToLlmSpan.clear();
+      if (run.currentTurnSpan && traceShipper) {
+        traceShipper.endSpan(run.currentTurnSpan);
+        run.currentTurnSpan = void 0;
+      }
+      const outputText = run.outputParts.join("");
+      if (traceShipper && run.rootSpan) {
+        const rootAttrs = [
+          attrString("ai.operationId", "generateText")
+        ];
+        if (run.lastModel) {
+          run.rootSpan.name = run.lastModel;
+          rootAttrs.push(attrString("gen_ai.response.model", run.lastModel));
+        }
+        if (run.currentInput) {
+          rootAttrs.push(attrString("ai.prompt", truncate(run.currentInput)));
+        }
+        if (outputText) {
+          rootAttrs.push(attrString("ai.response.text", truncate(outputText)));
+        }
+        if (run.totalInputTokens > 0) {
+          rootAttrs.push(attrInt("gen_ai.usage.input_tokens", run.totalInputTokens));
+        }
+        if (run.totalOutputTokens > 0) {
+          rootAttrs.push(attrInt("gen_ai.usage.output_tokens", run.totalOutputTokens));
+        }
+        if (run.totalCacheReadTokens > 0) {
+          rootAttrs.push(attrInt("gen_ai.usage.cache_read_tokens", run.totalCacheReadTokens));
+        }
+        rootAttrs.push(attrInt("ai.total_turns", run.turnNumber));
+        traceShipper.endSpan(run.rootSpan, { attributes: rootAttrs });
+      }
+      if (eventShipper) {
+        eventShipper.finish(run.eventId, {
+          userId: userId != null ? userId : "anonymous",
+          model: run.lastModel || void 0,
+          output: outputText || void 0,
+          properties: {
+            ...properties,
+            sdk_version: libraryVersion,
+            ...run.totalInputTokens > 0 ? { "ai.usage.prompt_tokens": run.totalInputTokens } : {},
+            ...run.totalOutputTokens > 0 ? { "ai.usage.completion_tokens": run.totalOutputTokens } : {},
+            ...run.totalCacheReadTokens > 0 ? { "ai.usage.cache_read_tokens": run.totalCacheReadTokens } : {}
+          }
+        }).catch(() => {
+        });
+      }
+      Promise.all([
+        eventShipper == null ? void 0 : eventShipper.flush(),
+        traceShipper == null ? void 0 : traceShipper.flush()
+      ]).catch(() => {
+      });
+    } catch (err) {
+      log(`Error in agent_end handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const unsubscribe = agent.subscribe((event) => {
+    try {
+      switch (event.type) {
+        case "agent_start":
+          handleAgentStart();
+          break;
+        case "message_end":
+          handleMessageEnd(event.message);
+          break;
+        case "message_update":
+          handleMessageUpdate(event);
+          break;
+        case "turn_start":
+          handleTurnStart();
+          break;
+        case "turn_end":
+          handleTurnEnd();
+          break;
+        case "tool_execution_start":
+          handleToolExecutionStart(event.toolCallId, event.toolName, event.args);
+          break;
+        case "tool_execution_end":
+          handleToolExecutionEnd(
+            event.toolCallId,
+            event.toolName,
+            event.result,
+            event.isError
+          );
+          break;
+        case "agent_end":
+          handleAgentEnd();
+          break;
+      }
+    } catch (err) {
+      log(`Unhandled error in event handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  });
+  return unsubscribe;
+}
+
+// src/index.ts
+function envDebugEnabled() {
+  var _a;
+  if (typeof process === "undefined") return false;
+  const flag = (_a = process.env) == null ? void 0 : _a.RAINDROP_AI_DEBUG;
+  return flag === "1" || flag === "true";
+}
+function createRaindropPiAgent(opts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const hasWriteKey = typeof opts.writeKey === "string" && opts.writeKey.trim().length > 0;
+  const eventsEnabled = ((_a = opts.events) == null ? void 0 : _a.enabled) !== false;
+  const tracesEnabled = ((_b = opts.traces) == null ? void 0 : _b.enabled) !== false;
+  if (!hasWriteKey && !opts.endpoint) {
+    console.warn(
+      "[raindrop-ai/pi-agent] writeKey not provided; telemetry shipping is disabled"
+    );
+  }
+  const envDebug = envDebugEnabled();
+  const debug = ((_c = opts.events) == null ? void 0 : _c.debug) === true || ((_d = opts.traces) == null ? void 0 : _d.debug) === true || envDebug;
+  const eventShipper = eventsEnabled && (hasWriteKey || opts.endpoint) ? new EventShipper2({
+    writeKey: opts.writeKey,
+    endpoint: opts.endpoint,
+    enabled: true,
+    debug: ((_e = opts.events) == null ? void 0 : _e.debug) === true || envDebug,
+    partialFlushMs: (_f = opts.events) == null ? void 0 : _f.partialFlushMs
+  }) : null;
+  const traceShipper = tracesEnabled && (hasWriteKey || opts.endpoint) ? new TraceShipper2({
+    writeKey: opts.writeKey,
+    endpoint: opts.endpoint,
+    enabled: true,
+    debug: ((_g = opts.traces) == null ? void 0 : _g.debug) === true || envDebug,
+    debugSpans: ((_h = opts.traces) == null ? void 0 : _h.debugSpans) === true || envDebug,
+    flushIntervalMs: (_i = opts.traces) == null ? void 0 : _i.flushIntervalMs,
+    maxBatchSize: (_j = opts.traces) == null ? void 0 : _j.maxBatchSize,
+    maxQueueSize: (_k = opts.traces) == null ? void 0 : _k.maxQueueSize
+  }) : null;
+  const defaultOptions = {
+    userId: opts.userId,
+    convoId: opts.convoId,
+    eventName: opts.eventName,
+    properties: opts.properties
+  };
+  return {
+    subscribe(agent, options) {
+      return createSubscriber(
+        agent,
+        eventShipper,
+        traceShipper,
+        defaultOptions,
+        options != null ? options : {},
+        debug
+      );
+    },
+    events: {
+      async patch(eventId, data) {
+        if (!eventShipper) return;
+        await eventShipper.patch(eventId, data);
+      },
+      async addAttachments(eventId, attachments) {
+        if (!eventShipper) return;
+        await eventShipper.patch(eventId, { attachments });
+      },
+      async setProperties(eventId, properties) {
+        if (!eventShipper) return;
+        await eventShipper.patch(eventId, { properties });
+      },
+      async finish(eventId) {
+        if (!eventShipper) return;
+        await eventShipper.finish(eventId, {});
+      }
+    },
+    users: {
+      async identify(params) {
+        var _a2;
+        if (!eventShipper) return;
+        await eventShipper.identify([
+          { userId: params.userId, traits: (_a2 = params.traits) != null ? _a2 : {} }
+        ]);
+      }
+    },
+    signals: {
+      async track(params) {
+        if (!eventShipper) return;
+        if (!params.name || !params.name.trim()) {
+          console.warn("[raindrop-ai/pi-agent] signal name is required");
+          return;
+        }
+        const {
+          eventId,
+          name,
+          type,
+          sentiment,
+          timestamp,
+          attachmentId,
+          comment,
+          after,
+          ...otherProperties
+        } = params;
+        await eventShipper.trackSignal({
+          eventId: eventId != null ? eventId : "",
+          name,
+          type,
+          sentiment,
+          timestamp,
+          attachmentId,
+          comment,
+          after,
+          properties: otherProperties
+        });
+      }
+    },
+    async flush() {
+      var _a2, _b2;
+      await Promise.all([
+        (_a2 = eventShipper == null ? void 0 : eventShipper.flush()) != null ? _a2 : Promise.resolve(),
+        (_b2 = traceShipper == null ? void 0 : traceShipper.flush()) != null ? _b2 : Promise.resolve()
+      ]);
+    },
+    async shutdown() {
+      var _a2, _b2;
+      await Promise.all([
+        (_a2 = eventShipper == null ? void 0 : eventShipper.shutdown()) != null ? _a2 : Promise.resolve(),
+        (_b2 = traceShipper == null ? void 0 : traceShipper.shutdown()) != null ? _b2 : Promise.resolve()
+      ]);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRaindropPiAgent
+});