@raindrop-ai/cursor 0.0.1

package/dist/index.js

@@ -0,0 +1,3009 @@
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir, userInfo } from "os";
+import { dirname, join } from "path";
+import { z } from "zod";
+var signalSchema = z.object({
+  description: z.string(),
+  sentiment: z.enum(["POSITIVE", "NEGATIVE"]).optional()
+});
+var diagnosticsSchema = z.object({
+  signals: z.record(z.string(), signalSchema).optional(),
+  guidance: z.string().optional(),
+  toolName: z.string().optional()
+});
+var configFileSchema = z.object({
+  write_key: z.string().optional().catch(void 0),
+  api_url: z.string().optional().catch(void 0),
+  project_id: z.string().optional().catch(void 0),
+  user_id: z.string().optional().catch(void 0),
+  debug: z.boolean().optional().catch(void 0),
+  enabled: z.boolean().optional().catch(void 0),
+  event_name: z.string().optional().catch(void 0),
+  custom_properties: z.record(z.string(), z.unknown()).optional().catch(void 0),
+  self_diagnostics: diagnosticsSchema.optional().catch(void 0)
+});
+var mapperConfigSchema = z.object({
+  userId: z.string(),
+  convoId: z.string().optional(),
+  debug: z.boolean(),
+  eventName: z.string(),
+  customProperties: z.record(z.string(), z.unknown())
+});
+var configSchema = mapperConfigSchema.extend({
+  writeKey: z.string(),
+  endpoint: z.string(),
+  projectId: z.string().optional(),
+  enabled: z.boolean(),
+  selfDiagnostics: diagnosticsSchema.optional()
+});
+function hookFlushDeadlineMs() {
+  const value = Number(process.env.RAINDROP_HOOK_FLUSH_DEADLINE_MS);
+  return Number.isFinite(value) && value > 0 ? value : 8e3;
+}
+function getConfigPath() {
+  return join(homedir(), ".config", "raindrop", "config.json");
+}
+function parseJson(raw) {
+  try {
+    return raw ? JSON.parse(raw) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function loadConfig() {
+  let file = {};
+  try {
+    file = configFileSchema.parse(parseJson(readFileSync(getConfigPath(), "utf8")));
+  } catch {
+  }
+  let username = "unknown";
+  try {
+    username = userInfo().username;
+  } catch {
+  }
+  const properties = z.record(z.string(), z.unknown()).safeParse(parseJson(process.env.RAINDROP_PROPERTIES));
+  const diagnostics = diagnosticsSchema.safeParse(parseJson(process.env.RAINDROP_SELF_DIAGNOSTICS));
+  const enabled = process.env.RAINDROP_ENABLED;
+  return configSchema.parse({
+    writeKey: process.env.RAINDROP_WRITE_KEY ?? file.write_key ?? "",
+    endpoint: process.env.RAINDROP_API_URL ?? file.api_url ?? "https://api.raindrop.ai/v1",
+    projectId: process.env.RAINDROP_PROJECT_ID ?? file.project_id,
+    userId: process.env.RAINDROP_USER_ID ?? file.user_id ?? username,
+    convoId: process.env.RAINDROP_CONVO_ID?.trim() || void 0,
+    eventName: process.env.RAINDROP_EVENT_NAME ?? file.event_name ?? "ai_generation",
+    debug: process.env.RAINDROP_DEBUG === "true" || (file.debug ?? false),
+    enabled: enabled ? enabled.toLowerCase() !== "false" && enabled !== "0" : file.enabled ?? true,
+    customProperties: { ...file.custom_properties, ...properties.success ? properties.data : {} },
+    selfDiagnostics: diagnostics.success ? diagnostics.data : file.self_diagnostics
+  });
+}
+function updateConfig(patch) {
+  const path = getConfigPath();
+  const existing = existsSync(path) ? z.record(z.string(), z.unknown()).parse(JSON.parse(readFileSync(path, "utf8"))) : {};
+  const next = { ...existing };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) delete next[key];
+    else next[key] = value;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(next, null, 2) + "\n", { mode: 384 });
+}
+
+// ../core/dist/chunk-BYBMRLZM.js
+var EVAL_CORRELATION_ID_ATTRIBUTE = "raindrop.eval_correlation_id";
+var PROBE_SCOPE = { correlationId: "" };
+var EvalScopeStorage = class {
+  constructor() {
+    this._als = null;
+    this._probed = false;
+  }
+  maybeAdoptAsyncLocalStorage() {
+    if (this._probed) return;
+    this._probed = true;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (!Ctor) return;
+      const als = new Ctor();
+      als.run(PROBE_SCOPE, () => {
+      });
+      this._als = als;
+    } catch (e) {
+      this._als = null;
+    }
+  }
+  run(scope, callback) {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return this._als.run(scope, callback);
+    const previous = this._syncScope;
+    this._syncScope = scope;
+    try {
+      return callback();
+    } finally {
+      this._syncScope = previous;
+    }
+  }
+  current() {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return this._als.getStore();
+    return this._syncScope;
+  }
+};
+var EVAL_SCOPE_STORAGE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.evalScopeStorage");
+function evalScopeStorage() {
+  const holder = globalThis;
+  let storage = holder[EVAL_SCOPE_STORAGE_KEY];
+  if (!storage) {
+    storage = new EvalScopeStorage();
+    holder[EVAL_SCOPE_STORAGE_KEY] = storage;
+  }
+  return storage;
+}
+function currentEvalScope() {
+  try {
+    return evalScopeStorage().current();
+  } catch (e) {
+    return void 0;
+  }
+}
+function evalScopeAttributes() {
+  const scope = currentEvalScope();
+  if (!scope) return {};
+  return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
+}
+
+// ../core/dist/chunk-T53LQAH7.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 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 base64ToHex(value) {
+  if (!value) return "";
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(value, "base64").toString("hex");
+  }
+  const atobFn = globalThis.atob;
+  if (typeof atobFn !== "function") return "";
+  try {
+    const binary = atobFn(value);
+    let hex = "";
+    for (let i = 0; i < binary.length; i++) {
+      hex += (binary.charCodeAt(i) & 255).toString(16).padStart(2, "0");
+    }
+    return hex;
+  } catch (e) {
+    return "";
+  }
+}
+var HANDOFF_ATTRIBUTE_SUFFIXES = {
+  mode: "raindrop.handoff.mode",
+  childEventId: "raindrop.handoff.childEventId",
+  parentEventId: "raindrop.handoff.parentEventId",
+  parentSpanId: "raindrop.handoff.parentSpanId",
+  name: "raindrop.handoff.name",
+  terminal: "raindrop.handoff.terminal",
+  agentRole: "raindrop.agent.role"
+};
+var AI_SDK_METADATA_PREFIX = "ai.telemetry.metadata.";
+var HANDOFF_TERMINAL_CANCELLED = "cancelled";
+var HANDOFF_TERMINAL_PROPERTY_KEY = HANDOFF_ATTRIBUTE_SUFFIXES.terminal;
+function cancelledTerminalMetadata() {
+  return { [HANDOFF_ATTRIBUTE_SUFFIXES.terminal]: HANDOFF_TERMINAL_CANCELLED };
+}
+function cancelledTerminalAttributes() {
+  const bare = cancelledTerminalMetadata();
+  return { ...bare, ...withMetadataPrefix(bare) };
+}
+function withMetadataPrefix(metadata) {
+  const out = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    out[key.startsWith(AI_SDK_METADATA_PREFIX) ? key : `${AI_SDK_METADATA_PREFIX}${key}`] = value;
+  }
+  return out;
+}
+var TRACEPARENT_HEADER = "traceparent";
+var BAGGAGE_HEADER = "baggage";
+var HANDOFF_HEADER = "x-raindrop-handoff";
+var UNRESOLVED_CARRIER_WARNING = `[raindrop] resume: headers were supplied but no hand-off carrier was found on them (searched ${HANDOFF_HEADER}, ${TRACEPARENT_HEADER}, ${BAGGAGE_HEADER}). This run reports as an UNLINKED event, and the launcher that dispatched it will stay on "queued" forever because nothing ever references its child. Passing headers means a parent handed off, so no carrier on them is almost certainly a defect: a gateway or proxy stripping ${HANDOFF_HEADER}, a middleware overwriting ${BAGGAGE_HEADER}, a request forwarded without its headers, or a hand-built carrier whose field names do not match. Send every header the launcher's dispatch returned. Logged once per process; pass no headers for a directly-invoked sub-agent to silence it.`;
+function runWithTracingSuppressed(fn) {
+  const hook = globalThis.RAINDROP_SUPPRESS_TRACING;
+  if (typeof hook !== "function") return fn();
+  let started = false;
+  try {
+    return hook(() => {
+      started = true;
+      return fn();
+    });
+  } catch (err) {
+    if (started) throw err;
+    return fn();
+  }
+}
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_RETRY_DELAY_MS = 3e4;
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatEndpoint(endpoint) {
+  if (!endpoint) return void 0;
+  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
+}
+function redactUrlForLog(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch (e) {
+    return "<unparseable-url>";
+  }
+}
+var RATE_LIMITED_LOG_INTERVAL_MS = 3e4;
+var rateLimitedLogLast = /* @__PURE__ */ new Map();
+function rateLimitedLog(key, log) {
+  const now = Date.now();
+  const last = rateLimitedLogLast.get(key);
+  if (last !== void 0 && now - last < RATE_LIMITED_LOG_INTERVAL_MS) {
+    return false;
+  }
+  rateLimitedLogLast.set(key, now);
+  log();
+  return true;
+}
+async function raceWithTimeout(promise, timeoutMs) {
+  let timer;
+  const settledInTime = await Promise.race([
+    promise.then(
+      () => true,
+      () => true
+    ),
+    new Promise((resolve) => {
+      var _a;
+      timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+      (_a = timer.unref) == null ? void 0 : _a.call(timer);
+    })
+  ]);
+  if (timer) clearTimeout(timer);
+  return settledInTime;
+}
+function parseRetryAfter(headers) {
+  var _a;
+  const value = (_a = headers.get("Retry-After")) != null ? _a : headers.get("retry-after");
+  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.min(Math.max(0, v), MAX_RETRY_DELAY_MS);
+  }
+  if (attemptNumber <= 1) return 0;
+  const base = 500;
+  const factor = Math.pow(2, attemptNumber - 2);
+  return 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;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function postJson(url, body, headers, opts) {
+  var _a;
+  const opName = `POST ${redactUrlForLog(url)}`;
+  const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
+  await withRetry(
+    async () => {
+      const resp = await runWithTracingSuppressed(
+        () => fetch(url, {
+          method: "POST",
+          redirect: headers["X-Raindrop-Replay-Id"] !== void 0 ? "error" : "follow",
+          headers: {
+            "Content-Type": "application/json",
+            ...headers
+          },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(timeoutMs)
+        })
+      );
+      if (!resp.ok) {
+        const text2 = await resp.text().catch(() => "");
+        const err = new Error(
+          `HTTP ${resp.status} ${resp.statusText}${text2 ? `: ${text2}` : ""}`
+        );
+        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 DEFAULT_MAX_TEXT_FIELD_CHARS = 1e6;
+var TRUNCATION_MARKER = "...[truncated by raindrop]";
+var BOUNDED_CLONE_MAX_DEPTH = 12;
+var BOUNDED_CLONE_SLACK = 256;
+var currentDefaultMaxTextFieldChars = DEFAULT_MAX_TEXT_FIELD_CHARS;
+function resolveMaxTextFieldChars(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  return currentDefaultMaxTextFieldChars;
+}
+function truncateToLimit(text2, limit) {
+  if (limit > TRUNCATION_MARKER.length) {
+    return text2.slice(0, limit - TRUNCATION_MARKER.length) + TRUNCATION_MARKER;
+  }
+  return text2.slice(0, Math.max(0, limit));
+}
+function capText(value, limit) {
+  if (typeof value !== "string") return value;
+  const max = limit != null ? limit : currentDefaultMaxTextFieldChars;
+  if (value.length <= max) return value;
+  return truncateToLimit(value, max);
+}
+function boundedClone(obj, charBudget) {
+  let budget = charBudget;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node, depth) => {
+    if (budget <= 0) return TRUNCATION_MARKER;
+    if (typeof node === "string") {
+      if (node.length > budget) {
+        const taken = node.slice(0, Math.max(0, budget)) + TRUNCATION_MARKER;
+        budget = 0;
+        return taken;
+      }
+      budget -= Math.max(node.length, 1);
+      return node;
+    }
+    if (node === null || typeof node === "number" || typeof node === "boolean") {
+      budget -= 8;
+      return node;
+    }
+    if (typeof node !== "object") {
+      budget -= 8;
+      return node;
+    }
+    if (seen.has(node)) return "[CIRCULAR]";
+    if (depth >= BOUNDED_CLONE_MAX_DEPTH) {
+      budget -= 16;
+      return `<max depth>`;
+    }
+    seen.add(node);
+    if (Array.isArray(node)) {
+      const out2 = [];
+      for (const v of node) {
+        if (budget <= 0) {
+          out2.push(TRUNCATION_MARKER);
+          break;
+        }
+        out2.push(walk(v, depth + 1));
+      }
+      return out2;
+    }
+    if (typeof node.toJSON === "function") {
+      budget -= 16;
+      return node;
+    }
+    const out = {};
+    for (const k in node) {
+      if (!Object.prototype.hasOwnProperty.call(node, k)) continue;
+      if (budget <= 0) {
+        out["..."] = TRUNCATION_MARKER;
+        break;
+      }
+      const key = walk(k, depth + 1);
+      out[key] = walk(node[k], depth + 1);
+    }
+    return out;
+  };
+  return walk(obj, 0);
+}
+function stringifyBounded(value, limit) {
+  const max = limit != null ? limit : currentDefaultMaxTextFieldChars;
+  if (typeof value === "string") {
+    return capText(value, max);
+  }
+  const pruned = boundedClone(value, max + TRUNCATION_MARKER.length + BOUNDED_CLONE_SLACK);
+  let json;
+  try {
+    json = JSON.stringify(pruned);
+  } catch (e) {
+    json = void 0;
+  }
+  if (json === void 0) {
+    return capText(String(value), max);
+  }
+  return json.length <= max ? json : truncateToLimit(json, max);
+}
+var 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 attrBool(key, value) {
+  if (value === void 0) return void 0;
+  return { key, value: { boolValue: 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
+          }
+        ]
+      }
+    ]
+  };
+}
+var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
+function state() {
+  const holder = globalThis;
+  let current = holder[STATE_KEY];
+  if (!current) {
+    let storage = null;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (Ctor) storage = new Ctor();
+    } catch (e) {
+      storage = null;
+    }
+    current = {
+      storage,
+      syncDestination: void 0,
+      spanDestinations: /* @__PURE__ */ new WeakMap()
+    };
+    holder[STATE_KEY] = current;
+  }
+  return current;
+}
+function currentReplayTraceDestination() {
+  var _a, _b;
+  const routing = state();
+  return (_b = (_a = routing.storage) == null ? void 0 : _a.getStore()) != null ? _b : routing.syncDestination;
+}
+function rememberReplayTraceDestination(span) {
+  const destination = currentReplayTraceDestination();
+  if (destination) state().spanDestinations.set(span, destination);
+}
+function copyReplayTraceDestination(source, target) {
+  const destination = state().spanDestinations.get(source);
+  if (destination) state().spanDestinations.set(target, destination);
+}
+function replayTraceDestinationFor(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return void 0;
+  }
+  return state().spanDestinations.get(value);
+}
+function recordReplayExportedSpan(destination, spanId, traceId) {
+  var _a, _b;
+  if (!destination || !spanId || !traceId) return;
+  (_a = destination.exportedSpanIds) == null ? void 0 : _a.add(spanId);
+  (_b = destination.exportedTraceIds) == null ? void 0 : _b.add(traceId);
+}
+function replayTraceUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
+}
+var LOCAL_DEBUGGER_ENV_VAR = "RAINDROP_LOCAL_DEBUGGER";
+var WORKSHOP_ENV_VAR = "RAINDROP_WORKSHOP";
+var DEFAULT_LOCAL_WORKSHOP_URL = "http://localhost:5899/v1/";
+function readEnvVar(name) {
+  var _a;
+  try {
+    const env = (_a = globalThis == null ? void 0 : globalThis.process) == null ? void 0 : _a.env;
+    if (env && typeof env[name] === "string" && env[name].length > 0) {
+      return env[name];
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function readWorkshopEnv() {
+  const raw = readEnvVar(WORKSHOP_ENV_VAR);
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  if (/^https?:\/\//i.test(trimmed)) return { url: trimmed };
+  if (/^(1|true|yes|on)$/i.test(trimmed)) return "enable";
+  if (/^(0|false|no|off)$/i.test(trimmed)) return "disable";
+  return void 0;
+}
+function isLocalDevHost(hostname) {
+  if (!hostname) return false;
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "::1") {
+    return true;
+  }
+  if (hostname.endsWith(".localhost")) return true;
+  return false;
+}
+function readRuntimeHostname() {
+  try {
+    const loc = globalThis == null ? void 0 : globalThis.location;
+    if (loc && typeof loc.hostname === "string" && loc.hostname.length > 0) {
+      return loc.hostname;
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function shouldAutoEnableLocalWorkshop() {
+  if (isLocalDevHost(readRuntimeHostname())) return true;
+  if (readEnvVar("NODE_ENV") === "development") return true;
+  return false;
+}
+function resolveLocalDebuggerBaseUrl(baseUrl) {
+  var _a, _b, _c;
+  if (baseUrl === null) return null;
+  if (typeof baseUrl === "string" && baseUrl.length > 0) {
+    return (_a = formatEndpoint(baseUrl)) != null ? _a : null;
+  }
+  const explicitUrlEnv = readEnvVar(LOCAL_DEBUGGER_ENV_VAR);
+  if (explicitUrlEnv) return (_b = formatEndpoint(explicitUrlEnv)) != null ? _b : null;
+  const workshopEnv = readWorkshopEnv();
+  if (workshopEnv === "disable") return null;
+  if (workshopEnv === "enable") return DEFAULT_LOCAL_WORKSHOP_URL;
+  if (workshopEnv && "url" in workshopEnv) return (_c = formatEndpoint(workshopEnv.url)) != null ? _c : null;
+  if (shouldAutoEnableLocalWorkshop()) return DEFAULT_LOCAL_WORKSHOP_URL;
+  return null;
+}
+var LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS = 2e3;
+function mirrorTraceExportToLocalDebugger(body, options = {}) {
+  var _a;
+  const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
+  if (!baseUrl) return Promise.resolve();
+  return postJson(`${baseUrl}traces`, body, {}, {
+    maxAttempts: 1,
+    debug: (_a = options.debug) != null ? _a : false,
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
+  }).catch(() => {
+  });
+}
+function mirrorPartialEventToLocalDebugger(event, options = {}) {
+  var _a;
+  const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
+  if (!baseUrl) return Promise.resolve();
+  const headers = options.writeKey ? { Authorization: `Bearer ${options.writeKey}` } : {};
+  return postJson(`${baseUrl}events/track_partial`, event, headers, {
+    maxAttempts: 1,
+    debug: (_a = options.debug) != null ? _a : false,
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
+  }).catch(() => {
+  });
+}
+var PROJECT_ID_HEADER = "X-Raindrop-Project-Id";
+var PROJECT_ID_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+function isValidProjectIdSlug(value) {
+  return PROJECT_ID_SLUG_PATTERN.test(value);
+}
+function normalizeProjectId(raw, opts) {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  if (!isValidProjectIdSlug(trimmed) && opts.debug) {
+    console.warn(
+      `${opts.prefix} projectId "${trimmed}" does not match slug ${PROJECT_ID_SLUG_PATTERN.source}; sending anyway \u2014 backend may reject with HTTP 400`
+    );
+  }
+  return trimmed;
+}
+function projectIdHeaders(projectId) {
+  return projectId ? { [PROJECT_ID_HEADER]: projectId } : {};
+}
+var SHUTDOWN_DEADLINE_MS = 1e4;
+var POST_SHUTDOWN_TIMEOUT_MS = 5e3;
+function mergePatches(target, source) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const out = { ...target, ...source };
+  if (target.properties || source.properties) {
+    out.properties = { ...(_a = target.properties) != null ? _a : {}, ...(_b = source.properties) != null ? _b : {} };
+  }
+  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.promptTokens = source.usage.promptTokens;
+    }
+    if (((_e = source.usage) == null ? void 0 : _e.completionTokens) !== void 0) {
+      out.usage.completionTokens = source.usage.completionTokens;
+    }
+  }
+  if (source.error === void 0) {
+    out.error = target.error;
+  }
+  if (target.featureFlags || source.featureFlags) {
+    out.featureFlags = { ...(_f = target.featureFlags) != null ? _f : {}, ...(_g = source.featureFlags) != null ? _g : {} };
+  }
+  if (target.attachments || source.attachments) {
+    out.attachments = [...(_h = target.attachments) != null ? _h : [], ...(_i = source.attachments) != null ? _i : []];
+  }
+  return out;
+}
+function isErrorLike(value) {
+  return value !== null && typeof value === "object";
+}
+function eventTelemetryProperties(patch) {
+  var _a, _b;
+  const properties = {};
+  if (((_a = patch.usage) == null ? void 0 : _a.promptTokens) !== void 0 && Number.isFinite(patch.usage.promptTokens)) {
+    properties["ai.usage.prompt_tokens"] = patch.usage.promptTokens;
+  }
+  if (((_b = patch.usage) == null ? void 0 : _b.completionTokens) !== void 0 && Number.isFinite(patch.usage.completionTokens)) {
+    properties["ai.usage.completion_tokens"] = patch.usage.completionTokens;
+  }
+  if (patch.error !== void 0 && patch.error !== null) {
+    const constructorName = patch.error instanceof Error && patch.error.constructor !== Error ? patch.error.constructor.name : void 0;
+    const errorType = patch.error instanceof Error ? patch.error.name && patch.error.name !== "Error" ? patch.error.name : constructorName || patch.error.name || "Error" : isErrorLike(patch.error) && typeof patch.error.name === "string" && patch.error.name.length > 0 ? patch.error.name : "Error";
+    const errorMessage = patch.error instanceof Error ? patch.error.message : isErrorLike(patch.error) && typeof patch.error.message === "string" ? patch.error.message : String(patch.error);
+    properties["error.type"] = errorType;
+    properties["error.message"] = errorMessage;
+  }
+  return properties;
+}
+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();
+    this.hasShutdown = false;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
+    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    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";
+    this.maxTextFieldCharsOpt = opts.maxTextFieldChars;
+    this.localDebuggerUrl = (_f = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _f : void 0;
+    if (this.debug && this.localDebuggerUrl) {
+      console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
+    }
+    this.projectId = normalizeProjectId(opts.projectId, {
+      debug: this.debug,
+      prefix: this.prefix
+    });
+    const isNode = typeof process !== "undefined" && typeof process.version === "string";
+    this.context = {
+      library: {
+        name: (_g = opts.libraryName) != null ? _g : "@raindrop-ai/core",
+        version: (_h = opts.libraryVersion) != null ? _h : "0.0.0"
+      },
+      metadata: {
+        jsRuntime: isNode ? "node" : "web",
+        ...isNode ? { nodeVersion: process.version } : {}
+      }
+    };
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  authHeaders() {
+    return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
+  }
+  requestHeaders() {
+    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.
+   */
+  requestOpts() {
+    if (this.shutdownDeadlineAt !== void 0) {
+      const remainingMs = this.shutdownDeadlineAt - Date.now();
+      if (remainingMs <= 0) return null;
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        sdkName: this.sdkName,
+        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
+      };
+    }
+    if (this.hasShutdown) {
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        sdkName: this.sdkName,
+        timeoutMs: POST_SHUTDOWN_TIMEOUT_MS
+      };
+    }
+    return { maxAttempts: 3, debug: this.debug, sdkName: this.sdkName };
+  }
+  async patch(eventId, patch) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    if (!this.enabled) return;
+    if (!eventId || !eventId.trim()) return;
+    const capturedSticky = this.sticky.get(eventId);
+    const eventAlreadyKnown = capturedSticky !== void 0 || this.buffers.has(eventId);
+    const destination = currentReplayTraceDestination();
+    const cloudReplay = destination !== void 0 && destination.kind !== "workshop";
+    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;
+    }
+    const maxChars = resolveMaxTextFieldChars(this.maxTextFieldCharsOpt);
+    if (typeof patch.input === "string" && patch.input.length > maxChars) {
+      patch = { ...patch, input: capText(patch.input, maxChars) };
+    }
+    if (typeof patch.output === "string" && patch.output.length > maxChars) {
+      patch = { ...patch, output: capText(patch.output, maxChars) };
+    }
+    if (this.debug) {
+      console.log(`${this.prefix} queue patch`, {
+        eventId,
+        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() {
+    this.hasShutdown = true;
+    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
+    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");
+    } finally {
+      this.shutdownDeadlineAt = void 0;
+    }
+  }
+  async trackSignal(signal) {
+    var _a, _b;
+    if (!this.enabled) return;
+    const destination = currentReplayTraceDestination();
+    if (destination && destination.kind !== "workshop") 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 } : {}
+        }
+      }
+    ];
+    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}`)
+      );
+    }
+  }
+  async identify(users) {
+    if (!this.enabled) return;
+    const destination = currentReplayTraceDestination();
+    if (destination && destination.kind !== "workshop") 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 (!this.writeKey) return;
+    if (body.length === 0) return;
+    const url = `${this.baseUrl}users/identify`;
+    const opts = this.requestOpts();
+    if (!opts) {
+      this.warnShutdownDrop("identify");
+      return;
+    }
+    try {
+      await postJson(url, body, this.requestHeaders(), opts);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      rateLimitedLog(
+        `${this.prefix}.send_identify_failed`,
+        () => console.warn(`${this.prefix} failed to send identify (dropping): ${msg}`)
+      );
+    }
+  }
+  warnShutdownDrop(what) {
+    rateLimitedLog(
+      `${this.prefix}.shutdown_deadline`,
+      () => console.warn(`${this.prefix} shutdown flush deadline exceeded; dropping ${what}`)
+    );
+  }
+  async flushOne(eventId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    if (!this.enabled) return;
+    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 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`);
+      }
+      this.sticky.delete(eventId);
+      return;
+    }
+    const { wizardSession, ...restProperties } = (_g = accumulated.properties) != null ? _g : {};
+    let telemetryProperties = {};
+    try {
+      telemetryProperties = eventTelemetryProperties(accumulated);
+    } catch (e) {
+    }
+    const convoId = (_h = accumulated.convoId) != null ? _h : sticky.convoId;
+    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.error !== void 0 && accumulated.error !== null ? void 0 : accumulated.output,
+        model: accumulated.model,
+        convo_id: convoId
+      },
+      properties: {
+        ...restProperties,
+        ...telemetryProperties,
+        ...wizardSession ? { "raindrop.wizardSession": wizardSession } : {},
+        $context: this.context
+      },
+      ...accumulated.featureFlags && Object.keys(accumulated.featureFlags).length > 0 ? { feature_flags: accumulated.featureFlags } : {},
+      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 mirror = this.localDebuggerUrl ? mirrorPartialEventToLocalDebugger(payload, {
+      baseUrl: this.localDebuggerUrl,
+      writeKey: this.writeKey,
+      debug: this.debug,
+      sdkName: this.sdkName
+    }) : void 0;
+    if (!this.writeKey) {
+      if (!isPending) this.sticky.delete(eventId);
+      if (mirror) await mirror;
+      return;
+    }
+    const opts = this.requestOpts();
+    if (!opts) {
+      this.warnShutdownDrop(`track_partial ${eventId}`);
+      if (!isPending) this.sticky.delete(eventId);
+      if (mirror) await mirror;
+      return;
+    }
+    const p = postJson(url, payload, this.requestHeaders(), opts);
+    const combined = mirror ? Promise.all([mirror, p]).then(() => void 0) : p;
+    this.inFlight.add(combined);
+    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}`)
+        );
+      }
+    } finally {
+      this.inFlight.delete(combined);
+    }
+    if (!isPending) {
+      this.sticky.delete(eventId);
+    }
+  }
+};
+var MODEL_USAGE_ATTRIBUTES = {
+  usageSource: "raindrop.usage.source",
+  providerName: "gen_ai.provider.name",
+  requestModel: "gen_ai.request.model",
+  responseModel: "gen_ai.response.model",
+  inputTokens: "gen_ai.usage.input_tokens",
+  outputTokens: "gen_ai.usage.output_tokens",
+  reasoningTokens: "gen_ai.usage.reasoning_tokens",
+  cacheReadInputTokens: "gen_ai.usage.cache_read_input_tokens",
+  cacheWriteInputTokens: "gen_ai.usage.cache_write_input_tokens",
+  providerReportedCost: "gen_ai.usage.provider_reported_cost",
+  nonCachedInputTokens: "raindrop.usage.input_tokens.non_cached",
+  nonReasoningOutputTokens: "raindrop.usage.output_tokens.non_reasoning",
+  totalOutputTokens: "raindrop.usage.output_tokens.total",
+  reasoningOutputTokens: "raindrop.usage.output_tokens.reasoning",
+  cacheReadTokens: "raindrop.usage.input_tokens.cache_read",
+  cacheWriteTokens: "raindrop.usage.input_tokens.cache_write"
+};
+var MODEL_PROVIDER_NAMES = [
+  ["google.vertex.anthropic", "google-vertex"],
+  ["google.vertex_ai", "google-vertex"],
+  ["google.vertex", "google-vertex"],
+  ["gcp.vertex_ai", "google-vertex"],
+  ["gcp.gemini", "google"],
+  ["google_vertexai", "google-vertex"],
+  ["vertex.anthropic", "google-vertex"],
+  ["amazon-bedrock", "amazon-bedrock"],
+  ["aws.bedrock", "amazon-bedrock"],
+  ["bedrock", "amazon-bedrock"],
+  ["anthropic", "anthropic"],
+  ["openai", "openai"],
+  ["google", "google"],
+  ["az.ai.openai", "azure"],
+  ["azure", "azure"],
+  ["openrouter", "openrouter"]
+];
+function canonicalModelProvider(provider) {
+  var _a;
+  const normalizedProvider = provider.trim().toLowerCase();
+  if (normalizedProvider === "gateway") return "vercel";
+  const match = MODEL_PROVIDER_NAMES.find(
+    ([family]) => normalizedProvider === family || normalizedProvider.startsWith(`${family}.`)
+  );
+  return (_a = match == null ? void 0 : match[1]) != null ? _a : normalizedProvider;
+}
+var STRING_ALIASES = {
+  [MODEL_USAGE_ATTRIBUTES.requestModel]: ["ai.model.id", "ai.model"]
+};
+var NUMBER_ALIASES = {
+  [MODEL_USAGE_ATTRIBUTES.inputTokens]: [
+    "gen_ai.usage.prompt_tokens",
+    "ai.usage.prompt_tokens",
+    "ai.usage.promptTokens",
+    "ai.usage.input_tokens",
+    "ai.usage.inputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.outputTokens]: [
+    "gen_ai.usage.completion_tokens",
+    "ai.usage.completion_tokens",
+    "ai.usage.completionTokens",
+    "ai.usage.output_tokens",
+    "ai.usage.outputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.reasoningTokens]: [
+    "gen_ai.usage.reasoning.output_tokens",
+    "ai.usage.reasoningTokens",
+    "ai.usage.thoughts_tokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.cacheReadInputTokens]: [
+    "gen_ai.usage.cache_read_tokens",
+    "gen_ai.usage.cache_read.input_tokens",
+    "ai.usage.cachedInputTokens",
+    "ai.usage.cached_tokens",
+    "ai.usage.cache_read_tokens",
+    "ai.usage.cache_read_input_tokens",
+    "ai.usage.cacheReadInputTokens"
+  ],
+  [MODEL_USAGE_ATTRIBUTES.cacheWriteInputTokens]: [
+    "gen_ai.usage.cache_creation_input_tokens",
+    "gen_ai.usage.cache_creation.input_tokens",
+    "ai.usage.cacheWriteInputTokens",
+    "ai.usage.cache_creation_input_tokens",
+    "ai.usage.cacheCreationInputTokens"
+  ]
+};
+function hasAttribute(attributes, key) {
+  return attributes.some((attribute) => attribute.key === key);
+}
+function findStringAttribute(attributes, keys) {
+  return attributes.find(
+    (attribute) => keys.includes(attribute.key) && typeof attribute.value.stringValue === "string" && attribute.value.stringValue.length > 0
+  );
+}
+function findNumberAttribute(attributes, keys) {
+  return attributes.find((attribute) => {
+    if (!keys.includes(attribute.key)) return false;
+    if (typeof attribute.value.doubleValue === "number" && Number.isSafeInteger(attribute.value.doubleValue) && attribute.value.doubleValue >= 0) {
+      return true;
+    }
+    const intValue = attribute.value.intValue;
+    return integerValue(intValue) !== void 0;
+  });
+}
+function integerValue(value) {
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+  }
+  if (typeof value !== "string") return void 0;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function appendAlias(attributes, target, source) {
+  if (!source || hasAttribute(attributes, target)) return attributes;
+  return [...attributes, { key: target, value: { ...source.value } }];
+}
+function appendProviderAlias(attributes) {
+  if (hasAttribute(attributes, MODEL_USAGE_ATTRIBUTES.providerName)) return attributes;
+  const source = findStringAttribute(attributes, ["gen_ai.system", "ai.model.provider"]);
+  if (!(source == null ? void 0 : source.value.stringValue)) return attributes;
+  const attribute = attrString(
+    MODEL_USAGE_ATTRIBUTES.providerName,
+    canonicalModelProvider(source.value.stringValue)
+  );
+  return attribute ? [...attributes, attribute] : attributes;
+}
+function normalizeModelUsageSpan(span) {
+  const original = span.attributes;
+  if (!original || original.length === 0) return span;
+  const responseModel = findStringAttribute(original, [
+    MODEL_USAGE_ATTRIBUTES.responseModel,
+    "ai.response.model"
+  ]);
+  if (!responseModel) return span;
+  let attributes = appendAlias(original, MODEL_USAGE_ATTRIBUTES.responseModel, responseModel);
+  attributes = appendProviderAlias(attributes);
+  for (const [target, aliases] of Object.entries(STRING_ALIASES)) {
+    attributes = appendAlias(attributes, target, findStringAttribute(attributes, aliases));
+  }
+  for (const [target, aliases] of Object.entries(NUMBER_ALIASES)) {
+    attributes = appendAlias(attributes, target, findNumberAttribute(attributes, aliases));
+  }
+  return attributes === original ? span : { ...span, attributes };
+}
+var DEFAULT_SECRET_KEY_NAMES = [
+  "apikey",
+  "apisecret",
+  "apitoken",
+  "secretaccesskey",
+  "sessiontoken",
+  "privatekey",
+  "privatekeyid",
+  "clientsecret",
+  "accesstoken",
+  "refreshtoken",
+  "oauthtoken",
+  "bearertoken",
+  "authorization",
+  "password",
+  "passphrase"
+];
+var REDACTED_PLACEHOLDER = "[REDACTED]";
+function normalizeKeyName(name) {
+  return name.toLowerCase().replace(/[-_.]/g, "");
+}
+function redactSecretsInObject(value, options) {
+  var _a, _b;
+  const normalizedSecretSet = buildSecretSet((_a = options == null ? void 0 : options.secretKeyNames) != null ? _a : DEFAULT_SECRET_KEY_NAMES);
+  const placeholder = (_b = options == null ? void 0 : options.placeholder) != null ? _b : REDACTED_PLACEHOLDER;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node) => {
+    if (node === null || typeof node !== "object") return node;
+    if (seen.has(node)) return "[CIRCULAR]";
+    seen.add(node);
+    if (Array.isArray(node)) {
+      return node.map((item) => walk(item));
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(node)) {
+      if (normalizedSecretSet.has(normalizeKeyName(k))) {
+        out[k] = placeholder;
+      } else {
+        out[k] = walk(v);
+      }
+    }
+    return out;
+  };
+  return walk(value);
+}
+function buildSecretSet(names) {
+  const set = /* @__PURE__ */ new Set();
+  for (const name of names) set.add(normalizeKeyName(name));
+  return set;
+}
+var DEFAULT_REDACT_ATTRIBUTE_KEYS = [
+  "ai.request.providerOptions",
+  "ai.response.providerMetadata"
+];
+function defaultTransformSpan(span) {
+  const attrs = span.attributes;
+  if (!attrs || attrs.length === 0) return span;
+  let nextAttrs;
+  for (let i = 0; i < attrs.length; i++) {
+    const attr = attrs[i];
+    const redacted = redactJsonAttributeValue(attr.key, attr.value);
+    if (redacted === void 0) continue;
+    if (!nextAttrs) nextAttrs = attrs.slice();
+    nextAttrs[i] = { key: attr.key, value: redacted };
+  }
+  if (!nextAttrs) return span;
+  return { ...span, attributes: nextAttrs };
+}
+var REDACT_JSON_ATTRIBUTE_KEYS = new Set(DEFAULT_REDACT_ATTRIBUTE_KEYS);
+function redactJsonAttributeValue(key, value) {
+  if (!REDACT_JSON_ATTRIBUTE_KEYS.has(key)) return void 0;
+  const json = value.stringValue;
+  if (typeof json !== "string" || json.length === 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (e) {
+    return void 0;
+  }
+  const scrubbed = redactSecretsInObject(parsed);
+  let scrubbedJson;
+  try {
+    scrubbedJson = JSON.stringify(scrubbed);
+  } catch (e) {
+    return void 0;
+  }
+  if (scrubbedJson === json) return void 0;
+  return { stringValue: scrubbedJson };
+}
+function identityAttrs(args) {
+  return [
+    attrString("ai.telemetry.metadata.raindrop.ai.userId", args.userId),
+    attrString("ai.telemetry.metadata.raindrop.convoId", args.convoId),
+    attrString("ai.telemetry.metadata.raindrop.eventName", args.eventName)
+  ];
+}
+function applyOtelSpanAttributeLimit(limit) {
+  var _a, _b;
+  try {
+    const raw = (_b = (_a = globalThis == null ? void 0 : globalThis.process) == null ? void 0 : _a.env) == null ? void 0 : _b.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+    if (!raw) return limit;
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return Math.min(limit, parsed);
+    }
+  } catch (e) {
+  }
+  return limit;
+}
+var TraceShipper = class {
+  constructor(opts) {
+    this.queue = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    this.hasShutdown = false;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
+    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    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";
+    this.localDebuggerUrl = (_i = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _i : void 0;
+    if (this.debug && this.localDebuggerUrl) {
+      console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
+    }
+    this.projectId = normalizeProjectId(opts.projectId, {
+      debug: this.debug,
+      prefix: this.prefix
+    });
+    this.transformSpanHook = opts.transformSpan;
+    this.disableDefaultRedaction = opts.disableDefaultRedaction === true;
+    this.maxTextFieldCharsOpt = opts.maxTextFieldChars;
+  }
+  /**
+   * Cap every string attribute value on the span. O(#attributes) length
+   * checks; only oversized values pay a slice. Runs AFTER the redaction
+   * pipeline so the default secret-scrub still sees parseable JSON in
+   * `ai.request.providerOptions` / `ai.response.providerMetadata` (capping
+   * first could cut a JSON blob mid-way, fail the parse, and ship secrets
+   * in the surviving prefix).
+   *
+   * A stricter `OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT` env var is honored
+   * for span content, matching the Python SDK and the OTel SDK convention.
+   */
+  capSpanAttributes(span) {
+    var _a;
+    const maxChars = applyOtelSpanAttributeLimit(
+      resolveMaxTextFieldChars(this.maxTextFieldCharsOpt)
+    );
+    const attrs = span.attributes;
+    if (!attrs || attrs.length === 0) return span;
+    let nextAttrs;
+    for (let i = 0; i < attrs.length; i++) {
+      const attr = attrs[i];
+      const value = (_a = attr.value) == null ? void 0 : _a.stringValue;
+      if (typeof value !== "string" || value.length <= maxChars) continue;
+      if (!nextAttrs) nextAttrs = attrs.slice();
+      nextAttrs[i] = {
+        key: attr.key,
+        value: { ...attr.value, stringValue: capText(value, maxChars) }
+      };
+    }
+    if (!nextAttrs) return span;
+    return { ...span, attributes: nextAttrs };
+  }
+  /**
+   * Apply the user `transformSpan` hook (if any) followed by the default
+   * redactor (unless disabled). Returns either the (possibly new) span to
+   * ship, or `null` to drop the span entirely.
+   *
+   * Ordering: user hook runs first so callers can rewrite the span freely
+   * (rename attrs, add new ones, scrub things the default doesn't know
+   * about). The default redactor then runs on whatever the user produced,
+   * acting as the always-on floor for documented BYOK secrets. If the user
+   * sets `disableDefaultRedaction: true`, the floor is skipped.
+   *
+   * Fail-closed: if the user hook throws, the span is dropped — a buggy
+   * hook can never accidentally ship raw, un-redacted spans.
+   */
+  redactSpan(span) {
+    let current = span;
+    if (this.transformSpanHook) {
+      try {
+        const result = this.transformSpanHook(current);
+        if (result === null) return null;
+        if (result !== void 0) {
+          copyReplayTraceDestination(current, result);
+          current = result;
+        }
+      } catch (err) {
+        if (this.debug) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.warn(`${this.prefix} transformSpan hook threw: ${msg}`);
+        }
+        return null;
+      }
+    }
+    try {
+      const normalized = normalizeModelUsageSpan(current);
+      copyReplayTraceDestination(current, normalized);
+      current = normalized;
+    } catch (e) {
+    }
+    if (!this.disableDefaultRedaction) {
+      const redacted = defaultTransformSpan(current);
+      copyReplayTraceDestination(current, redacted);
+      current = redacted;
+    }
+    const capped = this.capSpanAttributes(current);
+    copyReplayTraceDestination(current, capped);
+    return capped;
+  }
+  isDebugEnabled() {
+    return this.debug;
+  }
+  authHeaders() {
+    return this.writeKey ? { Authorization: `Bearer ${this.writeKey}` } : {};
+  }
+  requestHeaders() {
+    return { ...this.authHeaders(), ...projectIdHeaders(this.projectId) };
+  }
+  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),
+      ...identityAttrs(args),
+      attrString("ai.operationId", args.operationId),
+      ...Object.entries(evalScopeAttributes()).map(([key, value]) => attrString(key, value))
+    ];
+    if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
+    const span = {
+      ids,
+      name: args.name,
+      startTimeUnixNano: started,
+      attributes: attrs
+    };
+    rememberReplayTraceDestination(span);
+    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 }
+    });
+    copyReplayTraceDestination(span, openSpan);
+    this.mirrorToLocalDebugger(openSpan);
+    return span;
+  }
+  mirrorToLocalDebugger(span, completed = false) {
+    const destination = replayTraceDestinationFor(span);
+    if (destination && destination.kind !== "workshop") return;
+    const localDebuggerUrl = (destination == null ? void 0 : destination.kind) === "workshop" ? destination.url : this.localDebuggerUrl;
+    if (!localDebuggerUrl) return;
+    const redacted = this.redactSpan(span);
+    if (redacted === null) return;
+    if (completed && (destination == null ? void 0 : destination.kind) === "workshop") {
+      recordReplayExportedSpan(
+        destination,
+        base64ToHex(redacted.spanId),
+        base64ToHex(redacted.traceId)
+      );
+    }
+    const body = buildExportTraceServiceRequest([redacted], this.serviceName, this.serviceVersion);
+    const p = mirrorTraceExportToLocalDebugger(body, {
+      baseUrl: localDebuggerUrl,
+      debug: false,
+      sdkName: this.sdkName
+    });
+    this.inFlight.add(p);
+    void p.finally(() => {
+      this.inFlight.delete(p);
+    });
+  }
+  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
+    });
+    copyReplayTraceDestination(span, otlp);
+    this.enqueue(otlp);
+    this.mirrorToLocalDebugger(otlp, true);
+  }
+  createSpan(args) {
+    var _a;
+    const ids = createSpanIds(args.parent);
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
+      ...identityAttrs(args),
+      ...Object.entries(evalScopeAttributes()).map(([key, value]) => attrString(key, value))
+    ];
+    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
+    });
+    rememberReplayTraceDestination(otlp);
+    this.enqueue(otlp);
+    this.mirrorToLocalDebugger(otlp, true);
+  }
+  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
+        )}`
+      );
+    }
+    const redacted = this.redactSpan(span);
+    if (redacted === null) return;
+    const destination = replayTraceDestinationFor(redacted);
+    recordReplayExportedSpan(
+      destination,
+      base64ToHex(redacted.spanId),
+      base64ToHex(redacted.traceId)
+    );
+    if ((destination == null ? void 0 : destination.kind) === "workshop") return;
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+    }
+    this.queue.push(redacted);
+    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() {
+    var _a;
+    if (!this.enabled) {
+      await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+      })));
+      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 groups = /* @__PURE__ */ new Map();
+      for (const span of batch) {
+        const destination = replayTraceDestinationFor(span);
+        const spans = groups.get(destination);
+        if (spans) spans.push(span);
+        else groups.set(destination, [span]);
+      }
+      for (const [destination, spans] of groups) {
+        if (!destination && !this.writeKey) continue;
+        if ((destination == null ? void 0 : destination.kind) === "workshop") continue;
+        const opts = this.requestOpts();
+        if (!opts) {
+          rateLimitedLog(
+            `${this.prefix}.shutdown_deadline`,
+            () => console.warn(
+              `${this.prefix} shutdown flush deadline exceeded; dropping ${spans.length} spans`
+            )
+          );
+          continue;
+        }
+        const body = buildExportTraceServiceRequest(spans, this.serviceName, this.serviceVersion);
+        const url = destination ? replayTraceUrl(destination.url) : `${this.baseUrl}traces`;
+        const headers = destination ? {
+          Authorization: `Bearer ${destination.apiKey}`,
+          "X-Raindrop-Replay-Id": destination.replayId,
+          "X-Raindrop-Project-Id": (_a = destination.projectId) != null ? _a : "default"
+        } : this.requestHeaders();
+        if (this.debug) {
+          console.log(`${this.prefix} sending traces batch`, {
+            spans: spans.length,
+            endpoint: url
+          });
+        }
+        const p = postJson(url, body, headers, opts);
+        this.inFlight.add(p);
+        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}`)
+            );
+          }
+        } finally {
+          this.inFlight.delete(p);
+        }
+      }
+    }
+  }
+  /** See EventShipper.requestOpts — same shutdown-budget semantics. */
+  requestOpts() {
+    if (this.shutdownDeadlineAt !== void 0) {
+      const remainingMs = this.shutdownDeadlineAt - Date.now();
+      if (remainingMs <= 0) return null;
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        sdkName: this.sdkName,
+        timeoutMs: Math.min(DEFAULT_REQUEST_TIMEOUT_MS, remainingMs)
+      };
+    }
+    if (this.hasShutdown) {
+      return {
+        maxAttempts: 1,
+        debug: this.debug,
+        sdkName: this.sdkName,
+        timeoutMs: POST_SHUTDOWN_TIMEOUT_MS
+      };
+    }
+    return { maxAttempts: 3, debug: this.debug, sdkName: this.sdkName };
+  }
+  async shutdown() {
+    this.hasShutdown = true;
+    this.shutdownDeadlineAt = Date.now() + SHUTDOWN_DEADLINE_MS;
+    try {
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = void 0;
+      }
+      const drain = async () => {
+        await this.flush();
+        await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+        })));
+      };
+      const settled = await raceWithTimeout(drain(), SHUTDOWN_DEADLINE_MS);
+      if (!settled) {
+        rateLimitedLog(
+          `${this.prefix}.shutdown_deadline`,
+          () => console.warn(
+            `${this.prefix} shutdown flush deadline exceeded; abandoning in-flight spans`
+          )
+        );
+      }
+    } finally {
+      this.shutdownDeadlineAt = void 0;
+    }
+  }
+};
+
+// ../core/dist/index.node.js
+import { AsyncLocalStorage } from "async_hooks";
+globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = AsyncLocalStorage;
+var SUPPRESS_TRACING_KEY = /* @__PURE__ */ Symbol.for(
+  "OpenTelemetry SDK Context Key SUPPRESS_TRACING"
+);
+function findOtelContextManager() {
+  var _a;
+  for (const sym of Object.getOwnPropertySymbols(globalThis)) {
+    if (!((_a = sym.description) == null ? void 0 : _a.startsWith("opentelemetry.js.api."))) continue;
+    const api = globalThis[sym];
+    const cm = api == null ? void 0 : api.context;
+    if (cm && typeof cm.with === "function" && typeof cm.active === "function") {
+      return cm;
+    }
+  }
+  return void 0;
+}
+function installTracingSuppressionHook() {
+  if (typeof globalThis.RAINDROP_SUPPRESS_TRACING === "function") return;
+  const hook = (fn) => {
+    const cm = findOtelContextManager();
+    if (!cm) return fn();
+    return cm.with(cm.active().setValue(SUPPRESS_TRACING_KEY, true), fn);
+  };
+  globalThis.RAINDROP_SUPPRESS_TRACING = hook;
+}
+installTracingSuppressionHook();
+
+// package.json
+var package_default = {
+  name: "@raindrop-ai/cursor",
+  version: "0.0.1",
+  description: "Raindrop observability for Cursor agents via hooks",
+  license: "MIT",
+  type: "module",
+  main: "dist/index.cjs",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    "raindrop-cursor": "dist/cli.js"
+  },
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    }
+  },
+  sideEffects: false,
+  files: [
+    "dist/**",
+    "README.md",
+    ".cursor-plugin/**",
+    "hooks/**",
+    ".mcp.json"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    build: "tsup",
+    postbuild: "chmod +x ./dist/cli.js && node ./scripts/sync-plugin-version.mjs",
+    prepack: "node ./scripts/sync-plugin-version.mjs",
+    dev: "tsup --watch",
+    clean: "rm -rf dist",
+    test: "vitest run",
+    lint: "eslint src tests --ext .ts && tsc --noEmit",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    zod: "4.3.6"
+  },
+  devDependencies: {
+    "@raindrop-ai/core": "workspace:*",
+    "@types/node": "20.19.39",
+    msw: "2.13.0",
+    tsup: "8.5.1",
+    typescript: "5.9.3",
+    vitest: "2.1.9"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/package-info.ts
+var PACKAGE_NAME = "@raindrop-ai/cursor";
+var PACKAGE_VERSION = package_default.version;
+
+// src/shipper.ts
+var EventShipper2 = class extends EventShipper {
+  constructor(opts) {
+    super({
+      ...opts,
+      sdkName: opts.sdkName ?? "cursor",
+      libraryName: opts.libraryName ?? PACKAGE_NAME,
+      libraryVersion: opts.libraryVersion ?? PACKAGE_VERSION
+    });
+  }
+};
+var TraceShipper2 = class extends TraceShipper {
+  constructor(opts) {
+    super({
+      ...opts,
+      sdkName: opts.sdkName ?? "cursor",
+      serviceName: opts.serviceName ?? "raindrop.cursor",
+      serviceVersion: opts.serviceVersion ?? PACKAGE_VERSION
+    });
+  }
+  enqueue(span) {
+    const attrs = span.attributes ?? [];
+    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/event-mapper.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { z as z4 } from "zod";
+
+// src/setup.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+import { createInterface } from "readline";
+import { Writable } from "stream";
+import { z as z2 } from "zod";
+var HOOK_EVENTS = [
+  "sessionStart",
+  "beforeSubmitPrompt",
+  "postToolUse",
+  "postToolUseFailure",
+  "afterAgentResponse",
+  "afterAgentThought",
+  "stop",
+  "preCompact",
+  "sessionEnd"
+];
+var scopeSchema = z2.enum(["user", "project"]);
+var hookSchema = z2.object({ command: z2.string().optional() }).passthrough();
+var hooksFileSchema = z2.object({
+  version: z2.number().optional(),
+  hooks: z2.record(z2.string(), z2.array(hookSchema)).default({})
+}).passthrough();
+var setupSchema = z2.object({
+  scope: scopeSchema.optional(),
+  writeKey: z2.string().optional(),
+  userId: z2.string().optional(),
+  projectId: z2.string().optional(),
+  localOnly: z2.boolean().optional()
+});
+var persistedProjectSchema = z2.object({ project_id: z2.string().optional() });
+function getCursorHooksPath(scope, cwd = process.cwd()) {
+  return join2(scope === "project" ? cwd : homedir2(), ".cursor", "hooks.json");
+}
+function hookCommand(scope) {
+  return scope === "project" ? `npx -y @raindrop-ai/cursor@${PACKAGE_VERSION} hook` : "raindrop-cursor hook";
+}
+function isRaindropHook(command) {
+  return command !== void 0 && /(?:^|\s)(?:raindrop-cursor|@raindrop-ai\/cursor(?:@[\w.^~+-]+)?)\s+hook(?:\s|$)/.test(command);
+}
+function readHooks(path) {
+  return existsSync2(path) ? hooksFileSchema.parse(JSON.parse(readFileSync2(path, "utf8"))) : { version: 1, hooks: {} };
+}
+function writeJson(path, value) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(value, null, 2) + "\n");
+}
+function isCursorMcpServer(value) {
+  const server = z2.object({ command: z2.string(), args: z2.array(z2.string()).optional() }).safeParse(value);
+  return server.success && (server.data.command === "raindrop-cursor" || server.data.command === "npx" && server.data.args?.some((arg) => /^@raindrop-ai\/cursor(?:@[\w.^~+-]+)?$/.test(arg)) === true);
+}
+function prompt(question, secret = false) {
+  const output = secret ? new Writable({
+    write(_chunk, _encoding, callback) {
+      callback();
+    }
+  }) : process.stdout;
+  if (secret) process.stdout.write(question);
+  const rl = createInterface({
+    input: process.stdin,
+    output,
+    terminal: secret && process.stdin.isTTY === true && typeof process.stdin.setRawMode === "function"
+  });
+  return new Promise((resolve) => {
+    rl.question(secret ? "" : question, (answer) => {
+      rl.close();
+      if (secret) process.stdout.write("\n");
+      resolve(answer.trim());
+    });
+  });
+}
+function projectChoice(value) {
+  const trimmed = value?.trim();
+  if (trimmed === void 0) return void 0;
+  return trimmed === "" || trimmed.toLowerCase() === "default" ? { action: "default" } : { action: "slug", value: trimmed };
+}
+function persistedProjectId() {
+  try {
+    const parsed = persistedProjectSchema.safeParse(JSON.parse(readFileSync2(getConfigPath(), "utf8")));
+    if (!parsed.success) return void 0;
+    const choice = projectChoice(parsed.data.project_id);
+    return choice?.action === "slug" ? choice.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveWriteKey(writeKey, localOnly) {
+  const resolved = writeKey ?? process.env.RAINDROP_WRITE_KEY ?? "";
+  if (resolved || localOnly || process.stdin.isTTY !== true) return resolved;
+  const entered = await prompt("Enter your Raindrop write key: ", true);
+  if (entered) return entered;
+  console.error("\n  Error: write key is required. Get it from https://app.raindrop.ai\n");
+  process.exit(1);
+}
+async function resolveProjectSlug(projectId) {
+  return projectChoice(projectId) ?? projectChoice(process.env.RAINDROP_PROJECT_ID) ?? (process.stdin.isTTY === true ? projectChoice(
+    await prompt("Enter Raindrop project slug (blank for default Production): ")
+  ) ?? { action: "keep" } : { action: "keep" });
+}
+async function runSetup(args = {}) {
+  args = setupSchema.parse(args);
+  const scope = args.scope ?? "user";
+  const writeKey = await resolveWriteKey(args.writeKey, args.localOnly === true);
+  const project = await resolveProjectSlug(args.projectId);
+  const path = getCursorHooksPath(scope);
+  const settings = readHooks(path);
+  for (const [event, hooks] of Object.entries(settings.hooks)) {
+    settings.hooks[event] = hooks.filter((hook) => !isRaindropHook(hook.command));
+    if (settings.hooks[event].length === 0) delete settings.hooks[event];
+  }
+  for (const event of HOOK_EVENTS) {
+    settings.hooks[event] = [
+      ...settings.hooks[event] ?? [],
+      { command: hookCommand(scope), timeout: 10 }
+    ];
+  }
+  settings.version ??= 1;
+  writeJson(path, settings);
+  const existingProject = persistedProjectId();
+  const projectSlug = project.action === "slug" ? project.value : void 0;
+  if (writeKey || args.userId || project.action !== "keep") {
+    updateConfig({
+      ...writeKey ? { write_key: writeKey } : {},
+      ...args.userId ? { user_id: args.userId } : {},
+      ...project.action === "slug" ? { project_id: project.value } : {},
+      ...project.action === "default" ? { project_id: void 0 } : {}
+    });
+  }
+  const mcpPath = join2(dirname2(path), "mcp.json");
+  const mcpSchema = z2.object({
+    mcpServers: z2.record(z2.string(), z2.unknown()).default({})
+  }).passthrough();
+  const mcp = existsSync2(mcpPath) ? mcpSchema.parse(JSON.parse(readFileSync2(mcpPath, "utf8"))) : { mcpServers: {} };
+  const serverName = mcp.mcpServers["raindrop-diagnostics"] && !isCursorMcpServer(mcp.mcpServers["raindrop-diagnostics"]) ? "raindrop-cursor-diagnostics" : "raindrop-diagnostics";
+  mcp.mcpServers[serverName] ??= scope === "project" ? { command: "npx", args: ["-y", `@raindrop-ai/cursor@${PACKAGE_VERSION}`, "mcp-serve"] } : { command: "raindrop-cursor", args: ["mcp-serve"] };
+  writeJson(mcpPath, mcp);
+  const namedProject = projectSlug ?? (project.action === "keep" ? existingProject : void 0);
+  console.log(`Installed Cursor hooks in ${path}.`);
+  if (namedProject !== void 0) {
+    console.log(`Telemetry will use project ${namedProject}.`);
+  } else {
+    console.log("Telemetry uses the org default project.");
+  }
+  if (!writeKey) {
+    console.log("Set RAINDROP_WRITE_KEY to ship to Raindrop, or start the local debugger.");
+  }
+  if (scope === "project") {
+    console.log("Cloud agents need RAINDROP_WRITE_KEY in their runtime environment secrets.");
+  }
+}
+function runUninstall(scope = "user") {
+  const path = getCursorHooksPath(scope);
+  if (existsSync2(path)) {
+    const settings = readHooks(path);
+    for (const [event, hooks] of Object.entries(settings.hooks)) {
+      settings.hooks[event] = hooks.filter((hook) => !isRaindropHook(hook.command));
+      if (settings.hooks[event].length === 0) delete settings.hooks[event];
+    }
+    writeJson(path, settings);
+  }
+  const mcpPath = join2(dirname2(path), "mcp.json");
+  if (existsSync2(mcpPath)) {
+    const mcp = z2.object({ mcpServers: z2.record(z2.string(), z2.unknown()).default({}) }).passthrough().parse(JSON.parse(readFileSync2(mcpPath, "utf8")));
+    for (const name of ["raindrop-diagnostics", "raindrop-cursor-diagnostics"]) {
+      if (isCursorMcpServer(mcp.mcpServers[name])) delete mcp.mcpServers[name];
+    }
+    writeJson(mcpPath, mcp);
+  }
+  console.log("Removed Raindrop Cursor hooks.");
+}
+
+// src/state.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3, lstatSync as lstatSync2, mkdirSync as mkdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+import { setTimeout as setTimeout2 } from "timers/promises";
+import { z as z3 } from "zod";
+
+// src/storage.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  mkdirSync as mkdirSync3,
+  openSync,
+  readFileSync as readFileSync3,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { basename, join as join3 } from "path";
+function hasPrivateAccess(stat, forbiddenMode) {
+  const uid = process.getuid?.();
+  return uid === void 0 || stat.uid === uid && (stat.mode & forbiddenMode) === 0;
+}
+function stateDirectory() {
+  const home = homedir3();
+  const homeStat = statSync(home);
+  if (!homeStat.isDirectory() || !hasPrivateAccess(homeStat, 18))
+    throw new Error("Unsafe Cursor state parent directory");
+  const directory = join3(home, ".raindrop-cursor");
+  try {
+    mkdirSync3(directory, { mode: 448 });
+  } catch {
+  }
+  const stat = lstatSync(directory);
+  if (!stat.isDirectory() || !hasPrivateAccess(stat, 63))
+    throw new Error("Unsafe Cursor state directory");
+  return directory;
+}
+function statePath(name) {
+  if (basename(name) !== name || name === "." || name === "..")
+    throw new Error("Invalid Cursor state filename");
+  return join3(stateDirectory(), name);
+}
+function checkFile(stat) {
+  if (!stat.isFile() || stat.nlink !== 1 || !hasPrivateAccess(stat, 63))
+    throw new Error("Unsafe Cursor state file");
+}
+function readStateFile(name) {
+  const path = statePath(name);
+  checkFile(lstatSync(path));
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const stat = fstatSync(fd);
+    checkFile(stat);
+    return { contents: readFileSync3(fd, "utf8"), mtimeMs: stat.mtimeMs };
+  } finally {
+    closeSync(fd);
+  }
+}
+function writeStateFile(name, contents) {
+  const path = statePath(name);
+  const temporary = `${path}.${randomUUID2()}`;
+  const fd = openSync(temporary, "wx", 384);
+  try {
+    try {
+      writeFileSync3(fd, contents, "utf8");
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(temporary, path);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+function removeStateFile(name) {
+  rmSync(statePath(name), { force: true });
+}
+
+// src/state.ts
+var contextSchema = z3.object({ traceIdB64: z3.string(), spanIdB64: z3.string() });
+var usageSchema = z3.object({
+  prompt_tokens: z3.number().optional(),
+  completion_tokens: z3.number().optional(),
+  cache_read_tokens: z3.number().optional(),
+  cache_write_tokens: z3.number().optional()
+});
+var turnSchema = z3.object({
+  eventId: z3.string(),
+  root: contextSchema,
+  startedAt: z3.number(),
+  model: z3.string().optional(),
+  displayModel: z3.string().optional(),
+  finished: z3.boolean().default(false),
+  usage: usageSchema.default({})
+});
+var sessionSchema = z3.object({
+  model: z3.string().optional(),
+  model_id: z3.string().optional(),
+  cursor_version: z3.string().optional(),
+  workspace_roots: z3.array(z3.string()).optional(),
+  user_email: z3.string().optional(),
+  composer_mode: z3.string().optional(),
+  is_background_agent: z3.boolean().optional(),
+  currentGeneration: z3.string().optional(),
+  turns: z3.record(z3.string(), turnSchema).default({}),
+  totals: usageSchema.default({})
+});
+function stateKey(id) {
+  return createHash("sha256").update(id).digest("hex");
+}
+function eventTraceId(session, eventId) {
+  for (const turn of Object.values(session.turns)) {
+    if (turn.eventId === eventId) return turn.root.traceIdB64;
+  }
+  return void 0;
+}
+function readSession(id) {
+  try {
+    return sessionSchema.parse(JSON.parse(readStateFile(`session_${stateKey(id)}`).contents));
+  } catch {
+    return { turns: {}, totals: {} };
+  }
+}
+function saveSession(id, state2) {
+  writeStateFile(`session_${stateKey(id)}`, JSON.stringify(state2));
+  const turn = state2.currentGeneration ? state2.turns[state2.currentGeneration] : void 0;
+  if (turn) writeStateFile(`event_${stateKey(id)}`, turn.eventId);
+}
+function deleteSession(id) {
+  removeStateFile(`session_${stateKey(id)}`);
+  removeStateFile(`event_${stateKey(id)}`);
+}
+async function withSessionLock(id, work) {
+  const path = join4(stateDirectory(), `lock_${stateKey(id)}`);
+  const deadline = Date.now() + hookFlushDeadlineMs();
+  const staleMs = Math.max(3e4, hookFlushDeadlineMs() + 5e3);
+  const marker = join4(path, String(process.pid));
+  for (; ; ) {
+    try {
+      mkdirSync4(path, { mode: 448 });
+      writeFileSync4(marker, "");
+      break;
+    } catch {
+      try {
+        if (Date.now() - lstatSync2(path).mtimeMs > staleMs)
+          rmSync2(path, { recursive: true, force: true });
+      } catch {
+      }
+      if (Date.now() >= deadline) return void 0;
+      await setTimeout2(10);
+    }
+  }
+  const release = () => {
+    try {
+      if (existsSync3(marker)) rmSync2(path, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  process.once("exit", release);
+  try {
+    return await work();
+  } finally {
+    process.removeListener("exit", release);
+    release();
+  }
+}
+
+// src/event-mapper.ts
+var text = z4.string().optional().catch(void 0);
+var number = z4.number().finite().nonnegative().optional().catch(void 0);
+var bool = z4.boolean().optional().catch(void 0);
+var hookPayloadSchema = z4.object({
+  hook_event_name: z4.enum(HOOK_EVENTS),
+  conversation_id: text,
+  session_id: text,
+  generation_id: text,
+  model: text,
+  model_id: text,
+  model_params: z4.unknown().optional(),
+  cursor_version: text,
+  workspace_roots: z4.array(z4.string()).optional().catch(void 0),
+  user_email: text,
+  is_background_agent: bool,
+  composer_mode: text,
+  prompt: text,
+  attachments: z4.unknown().optional(),
+  tool_name: text,
+  tool_input: z4.unknown().optional(),
+  tool_output: z4.unknown().optional(),
+  tool_use_id: text,
+  cwd: text,
+  agent_message: text,
+  duration: number,
+  error_message: text,
+  failure_type: text,
+  is_interrupt: bool,
+  status: text,
+  duration_ms: number,
+  message_count: number,
+  text,
+  input_tokens: number,
+  output_tokens: number,
+  cache_read_tokens: number,
+  cache_write_tokens: number,
+  loop_count: number,
+  trigger: text,
+  context_usage_percent: number,
+  context_tokens: number,
+  context_window_size: number,
+  is_first_compaction: bool,
+  reason: text,
+  final_status: text
+});
+var MAX_ATTR_LENGTH = 32768;
+function safeStringify(value) {
+  return value === void 0 ? void 0 : stringifyBounded(value, MAX_ATTR_LENGTH);
+}
+function stringAttr(key, value) {
+  return attrString(key, value === void 0 ? void 0 : capText(value, MAX_ATTR_LENGTH));
+}
+function inferModelProvider(modelId) {
+  const id = (modelId ?? "").toLowerCase();
+  if (id.includes("claude")) return "anthropic";
+  if (id.includes("gpt-") || /(?:^|-)o[134]/.test(id)) return "openai";
+  if (id.includes("gemini")) return "google";
+  if (id.includes("grok")) return "xai";
+  return "cursor";
+}
+function usageFrom(payload) {
+  return {
+    ...payload.input_tokens !== void 0 ? { prompt_tokens: payload.input_tokens } : {},
+    ...payload.output_tokens !== void 0 ? { completion_tokens: payload.output_tokens } : {},
+    ...payload.cache_read_tokens !== void 0 ? { cache_read_tokens: payload.cache_read_tokens } : {},
+    ...payload.cache_write_tokens !== void 0 ? { cache_write_tokens: payload.cache_write_tokens } : {}
+  };
+}
+function usageProperties(prefix, usage) {
+  return Object.fromEntries(
+    Object.entries(usage).map(([key, value]) => [`${prefix}.${key}`, value])
+  );
+}
+function sessionUsageProperties(usage) {
+  return {
+    ...usageProperties("ai.usage.session_total", usage),
+    ...usage.cache_write_tokens === void 0 ? {} : { "ai.usage.session_total.cache_creation_tokens": usage.cache_write_tokens }
+  };
+}
+function timing(duration, startedAt = Date.now()) {
+  const endMs = Date.now();
+  const elapsed = Math.min(endMs, Math.max(0, duration ?? endMs - startedAt));
+  return {
+    startTimeUnixNano: `${Math.trunc(endMs - elapsed)}000000`,
+    endTimeUnixNano: `${endMs}000000`
+  };
+}
+function finishTurn(turn, totals, traceShipper, patch, status) {
+  for (const key of [
+    "prompt_tokens",
+    "completion_tokens",
+    "cache_read_tokens",
+    "cache_write_tokens"
+  ]) {
+    const value = turn.usage[key];
+    if (value !== void 0) totals[key] = (totals[key] ?? 0) + value;
+  }
+  const provider = canonicalModelProvider(inferModelProvider(turn.model));
+  traceShipper.createSpan({
+    name: turn.model ?? "cursor",
+    eventId: turn.eventId,
+    parent: turn.root,
+    userId: patch.userId,
+    convoId: patch.convoId,
+    eventName: patch.eventName,
+    ...timing(void 0, turn.startedAt),
+    attributes: [
+      attrString("ai.operationId", "generateText"),
+      stringAttr("gen_ai.request.model", turn.model),
+      stringAttr("gen_ai.response.model", turn.model),
+      attrString("gen_ai.system", provider),
+      attrString("gen_ai.provider.name", provider),
+      ...Object.entries(turn.usage).map(([key, value]) => attrInt(`gen_ai.usage.${key}`, value)),
+      ...status === "cancelled" ? Object.entries(cancelledTerminalAttributes()).map(
+        ([key, value]) => attrString(key, value)
+      ) : []
+    ],
+    ...status === "error" || status === "aborted" ? { status: { code: 2, message: status } } : {}
+  });
+  turn.finished = true;
+}
+function conversationIdForHook(payload) {
+  return payload.conversation_id || payload.session_id;
+}
+function emitHookSpan(traceShipper, payload, eventId, parent, ids) {
+  const event = payload.hook_event_name;
+  if (event === "afterAgentThought") {
+    traceShipper.createSpan({
+      name: "ai.thinking",
+      eventId,
+      parent,
+      ...ids,
+      ...timing(payload.duration_ms),
+      attributes: [
+        attrString("ai.operationId", "ai.thinking"),
+        stringAttr("ai.thinking.text", payload.text),
+        attrInt("traceloop.entity.duration_ms", payload.duration_ms)
+      ]
+    });
+    return;
+  }
+  if (event !== "postToolUse" && event !== "postToolUseFailure") return;
+  const failed = event === "postToolUseFailure";
+  const error = capText(payload.error_message ?? "Tool execution failed", MAX_ATTR_LENGTH);
+  const toolAttrs = [
+    stringAttr("ai.toolCall.name", payload.tool_name),
+    stringAttr("ai.toolCall.id", payload.tool_use_id),
+    attrString("ai.toolCall.args", safeStringify(payload.tool_input))
+  ];
+  traceShipper.createSpan({
+    name: "ai.toolCall",
+    eventId,
+    parent,
+    ...ids,
+    ...timing(payload.duration),
+    attributes: [
+      attrString("ai.operationId", "ai.toolCall"),
+      ...toolAttrs,
+      attrString("ai.toolCall.result", safeStringify(payload.tool_output)),
+      attrInt("traceloop.entity.duration_ms", payload.duration),
+      stringAttr("cwd", payload.cwd),
+      ...failed ? [
+        stringAttr("cursor.tool.failure_type", payload.failure_type),
+        attrBool("cursor.tool.is_interrupt", payload.is_interrupt)
+      ] : []
+    ],
+    ...failed ? { status: { code: 2, message: error } } : {}
+  });
+  if (failed && payload.failure_type === "permission_denied") {
+    traceShipper.createSpan({
+      name: "ai.permissionDenied",
+      eventId,
+      parent,
+      ...ids,
+      ...timing(payload.duration),
+      attributes: [
+        attrString("ai.operationId", "ai.permissionDenied"),
+        ...toolAttrs,
+        attrString("ai.permissionDenied.reason", error)
+      ],
+      status: { code: 2, message: error }
+    });
+  }
+}
+function updateSession(session, payload, applySessionModel) {
+  if (applySessionModel) {
+    if (payload.model !== void 0 && payload.model !== session.model && !payload.model_id) {
+      session.model_id = void 0;
+    }
+    if (payload.model !== void 0) session.model = capText(payload.model, MAX_ATTR_LENGTH);
+    if (payload.model_id !== void 0)
+      session.model_id = capText(payload.model_id, MAX_ATTR_LENGTH);
+  }
+  if (payload.cursor_version !== void 0)
+    session.cursor_version = capText(payload.cursor_version, MAX_ATTR_LENGTH);
+  if (payload.workspace_roots !== void 0)
+    session.workspace_roots = payload.workspace_roots.slice(0, 100).map((root) => capText(root, MAX_ATTR_LENGTH));
+  if (payload.user_email) session.user_email = capText(payload.user_email, MAX_ATTR_LENGTH);
+  if (payload.composer_mode !== void 0)
+    session.composer_mode = capText(payload.composer_mode, MAX_ATTR_LENGTH);
+  if (payload.is_background_agent !== void 0)
+    session.is_background_agent = payload.is_background_agent;
+}
+function mapPayload(payload, config, traceShipper, conversationId) {
+  const session = readSession(conversationId);
+  const event = payload.hook_event_name;
+  const generationKey = event === "sessionEnd" && session.currentGeneration ? session.currentGeneration : payload.generation_id ? stateKey(payload.generation_id) : session.currentGeneration ?? stateKey("unknown-generation");
+  let turn = session.turns[generationKey];
+  if (!turn && event === "sessionEnd") {
+    deleteSession(conversationId);
+    return;
+  }
+  const modelChanged = payload.model_id === void 0 && payload.model !== void 0 && capText(payload.model, MAX_ATTR_LENGTH) !== (turn ? turn.displayModel : session.model);
+  const explicitModel = payload.model_id ?? (modelChanged ? payload.model : void 0);
+  const model = explicitModel ?? turn?.model ?? session.model_id ?? payload.model ?? session.model;
+  const displayModel = payload.model !== void 0 ? capText(payload.model, MAX_ATTR_LENGTH) : model === session.model_id ? session.model : void 0;
+  const isNew = !turn;
+  const applySessionModel = event === "sessionStart" || isNew || event === "beforeSubmitPrompt" || generationKey === session.currentGeneration;
+  updateSession(session, payload, applySessionModel);
+  if (event === "sessionStart") {
+    saveSession(conversationId, session);
+    return;
+  }
+  const userId = session.user_email ?? config.userId;
+  const convoId = config.convoId ?? conversationId;
+  const properties = {
+    ...z4.record(z4.string(), z4.unknown()).parse(boundedClone(config.customProperties, MAX_ATTR_LENGTH)),
+    sdk: PACKAGE_NAME,
+    sdk_version: PACKAGE_VERSION,
+    cursor_conversation_id: capText(conversationId, MAX_ATTR_LENGTH),
+    cursor_generation_id: event !== "sessionEnd" && payload.generation_id ? capText(payload.generation_id, MAX_ATTR_LENGTH) : void 0,
+    cursor_version: session.cursor_version,
+    workspace_roots: boundedClone(session.workspace_roots, MAX_ATTR_LENGTH),
+    composer_mode: session.composer_mode,
+    is_background_agent: session.is_background_agent,
+    ...payload.model_params !== void 0 ? { model_params: boundedClone(payload.model_params, MAX_ATTR_LENGTH) } : {},
+    ...session.model !== void 0 && session.model_id !== void 0 && session.model !== session.model_id ? { cursor: { model: session.model, model_id: session.model_id } } : {}
+  };
+  if (!turn) {
+    const eventId = `cursor_${randomUUID3()}`;
+    const root = traceShipper.startSpan({
+      name: model ?? "cursor",
+      eventId,
+      userId,
+      convoId,
+      eventName: config.eventName,
+      attributes: [
+        attrString("ai.operationId", "generateText"),
+        stringAttr("session.model", model),
+        stringAttr("cursor.conversation_id", conversationId),
+        stringAttr("cursor.generation_id", payload.generation_id),
+        attrBool("cursor.is_background_agent", session.is_background_agent)
+      ]
+    });
+    traceShipper.endSpan(root);
+    turn = {
+      eventId,
+      root: { traceIdB64: root.ids.traceIdB64, spanIdB64: root.ids.spanIdB64 },
+      startedAt: Date.now(),
+      model,
+      displayModel,
+      finished: false,
+      usage: {}
+    };
+    session.turns[generationKey] = turn;
+  }
+  if (event !== "sessionEnd") {
+    if (explicitModel !== void 0) turn.model = model;
+    if (payload.model !== void 0 && displayModel !== void 0)
+      turn.displayModel = displayModel;
+  }
+  if (isNew || event === "beforeSubmitPrompt") session.currentGeneration = generationKey;
+  const patch = {
+    eventName: config.eventName,
+    userId,
+    convoId,
+    model: turn.model,
+    isPending: !turn.finished,
+    properties
+  };
+  const extraPatches = [];
+  let includeParentPatch = true;
+  switch (event) {
+    case "beforeSubmitPrompt":
+      if (payload.prompt !== void 0) patch.input = capText(payload.prompt);
+      if (payload.attachments !== void 0)
+        properties.attachments = boundedClone(payload.attachments, MAX_ATTR_LENGTH);
+      break;
+    case "postToolUse":
+    case "postToolUseFailure":
+    case "afterAgentThought":
+      emitHookSpan(traceShipper, payload, turn.eventId, turn.root, {
+        userId,
+        convoId,
+        eventName: config.eventName
+      });
+      break;
+    case "afterAgentResponse":
+      if (payload.text !== void 0) patch.output = capText(payload.text);
+      if (!turn.finished) turn.usage = { ...turn.usage, ...usageFrom(payload) };
+      break;
+    case "stop":
+      properties.status = payload.status;
+      properties.loop_count = payload.loop_count;
+      if (!turn.finished) {
+        turn.usage = { ...turn.usage, ...usageFrom(payload) };
+        finishTurn(turn, session.totals, traceShipper, patch, payload.status);
+      }
+      patch.isPending = false;
+      Object.assign(
+        properties,
+        usageProperties("ai.usage", turn.usage),
+        sessionUsageProperties(session.totals)
+      );
+      break;
+    case "preCompact":
+      Object.assign(properties, {
+        compaction_trigger: payload.trigger,
+        context_tokens: payload.context_tokens,
+        context_window_size: payload.context_window_size,
+        context_usage_percent: payload.context_usage_percent,
+        is_first_compaction: payload.is_first_compaction,
+        message_count: payload.message_count
+      });
+      break;
+    case "sessionEnd": {
+      includeParentPatch = false;
+      patch.isPending = false;
+      Object.assign(properties, {
+        session_end_reason: payload.reason,
+        session_duration_ms: payload.duration_ms,
+        final_status: payload.final_status,
+        error_message: payload.error_message
+      });
+      for (const parentTurn of Object.values(session.turns)) {
+        if (!parentTurn.finished || parentTurn === turn) {
+          const terminalPatch = {
+            ...patch,
+            model: parentTurn.model,
+            properties: { ...properties }
+          };
+          if (!parentTurn.finished) {
+            finishTurn(parentTurn, session.totals, traceShipper, terminalPatch, "cancelled");
+            terminalPatch.properties = {
+              ...terminalPatch.properties,
+              ...usageProperties("ai.usage", parentTurn.usage),
+              status: "cancelled",
+              [HANDOFF_TERMINAL_PROPERTY_KEY]: "cancelled"
+            };
+          }
+          extraPatches.push({ eventId: parentTurn.eventId, patch: terminalPatch });
+        }
+      }
+      const finalPatch = extraPatches.find(({ eventId }) => eventId === turn.eventId);
+      if (finalPatch) {
+        finalPatch.patch.properties = {
+          ...finalPatch.patch.properties,
+          ...sessionUsageProperties(session.totals)
+        };
+      }
+      break;
+    }
+  }
+  if (event === "sessionEnd") {
+    deleteSession(conversationId);
+  } else {
+    const completed = Object.entries(session.turns).filter(
+      ([key, value]) => key !== session.currentGeneration && value.finished
+    );
+    for (const [key] of completed.slice(0, Math.max(0, completed.length - 100)))
+      delete session.turns[key];
+    saveSession(conversationId, session);
+  }
+  patch.properties = properties;
+  const mapped = includeParentPatch ? [{ eventId: turn.eventId, patch }] : [];
+  mapped.push(...extraPatches);
+  for (const item of mapped) {
+    const props = z4.record(z4.string(), z4.unknown()).parse(boundedClone(item.patch.properties ?? {}, DEFAULT_MAX_TEXT_FIELD_CHARS));
+    const traceId = eventTraceId(session, item.eventId);
+    if (traceId) props.trace_id = base64ToHex(traceId);
+    item.patch.properties = props;
+  }
+  return mapped.length ? mapped : void 0;
+}
+async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
+  try {
+    const parsed = hookPayloadSchema.safeParse(payload);
+    if (!parsed.success) return;
+    const conversationId = conversationIdForHook(parsed.data);
+    if (!conversationId) return;
+    await withSessionLock(conversationId, async () => {
+      const mapped = mapPayload(parsed.data, config, traceShipper, conversationId);
+      if (mapped?.length) {
+        for (const item of mapped) await eventShipper.patch(item.eventId, item.patch);
+        await eventShipper.flush();
+      }
+    });
+  } catch (error) {
+    if (config.debug) console.error(`[${PACKAGE_NAME}] hook mapping failed`, error);
+  }
+}
+
+// src/local-debugger.ts
+import { z as z5 } from "zod";
+var DEFAULT_PORT = 5899;
+var DEFAULT_URL = `http://localhost:${DEFAULT_PORT}/v1/`;
+var HEALTH_TIMEOUT_MS = 300;
+var CACHE_TTL_MS = 5e3;
+var debuggerCacheSchema = z5.object({ url: z5.literal(DEFAULT_URL).nullable(), ts: z5.number() });
+function readCache() {
+  try {
+    const data = debuggerCacheSchema.parse(JSON.parse(readStateFile("debugger_cache").contents));
+    const age = Date.now() - data.ts;
+    if (age < 0 || age > CACHE_TTL_MS) return void 0;
+    return data;
+  } catch {
+    return void 0;
+  }
+}
+function writeCache(url) {
+  try {
+    writeStateFile("debugger_cache", JSON.stringify({ url, ts: Date.now() }));
+  } catch {
+  }
+}
+async function healthPing(baseUrl) {
+  const healthUrl = baseUrl.replace(/\/v1\/$/, "/health");
+  try {
+    const signal = AbortSignal.timeout(HEALTH_TIMEOUT_MS);
+    const resp = await runWithTracingSuppressed(
+      () => fetch(healthUrl, { signal, redirect: "error" })
+    );
+    if (resp.ok) {
+      const body = z5.object({ ok: z5.boolean() }).safeParse(await resp.json());
+      if (body.success && body.data.ok) return baseUrl;
+    }
+  } catch {
+  }
+  return null;
+}
+var _debuggerResultSchema = z5.object({ url: z5.string().nullable(), autoDetected: z5.boolean() });
+async function detectLocalDebugger(debug, skipAutoDetect = false) {
+  if (/^(0|false|no|off)$/i.test(process.env[LOCAL_DEBUGGER_ENV_VAR]?.trim() ?? "")) {
+    return { url: null, autoDetected: false };
+  }
+  const envUrl = resolveLocalDebuggerBaseUrl();
+  if (envUrl) {
+    if (debug) {
+      console.log(
+        `[raindrop-ai/cursor] Local debugger configured via ${LOCAL_DEBUGGER_ENV_VAR}: ${envUrl}`
+      );
+    }
+    return { url: envUrl, autoDetected: false };
+  }
+  if (skipAutoDetect || process.env.CI?.trim()) {
+    return { url: null, autoDetected: false };
+  }
+  const cached = readCache();
+  if (cached) {
+    if (debug) {
+      console.log(`[raindrop-ai/cursor] Local debugger cache hit: ${cached.url ?? "not running"}`);
+    }
+    return { url: cached.url, autoDetected: cached.url !== null };
+  }
+  if (debug) {
+    console.log(`[raindrop-ai/cursor] Probing local debugger at localhost:${DEFAULT_PORT}...`);
+  }
+  const detected = await healthPing(DEFAULT_URL);
+  writeCache(detected);
+  if (detected && debug) {
+    console.log(`[raindrop-ai/cursor] Local debugger auto-detected at ${detected}`);
+  }
+  return { url: detected, autoDetected: detected !== null };
+}
+
+// src/mcp-serve.ts
+import { readdirSync } from "fs";
+import { createInterface as createInterface2 } from "readline";
+import { z as z6 } from "zod";
+var DEFAULT_SIGNALS = {
+  missing_context: {
+    description: "You cannot complete the task because critical information, credentials, or access is missing and the user cannot provide it. Do NOT report this for normal clarifying questions. only when you are blocked.",
+    sentiment: "NEGATIVE"
+  },
+  repeatedly_broken_tool: {
+    description: "A tool has failed or not returned the expected response on multiple distinct attempts in this conversation, preventing task completion. A single tool error is NOT enough. the tool must be persistently broken or aberrantly behaving across retries.",
+    sentiment: "NEGATIVE"
+  },
+  capability_gap: {
+    description: "The task requires a tool, permission, or capability that you do not have. For example, the user asks you to perform an action but no suitable tool exists, or you lack the necessary access. Do NOT report this if you simply need more information from the user. only when the gap is in your own capabilities.",
+    sentiment: "NEGATIVE"
+  },
+  complete_task_failure: {
+    description: "You were unable to accomplish what the user asked despite making genuine attempts. This is NOT a refusal or policy block. you tried and failed to deliver the result.",
+    sentiment: "NEGATIVE"
+  }
+};
+var NOTEWORTHY_KEY = "noteworthy";
+var NOTEWORTHY_DEFAULT_DESCRIPTION = "Only when no specific category applies: flag that this turn is noteworthy for developer review.";
+function normalizeSignals(custom) {
+  let base;
+  if (!custom || Object.keys(custom).length === 0) {
+    base = { ...DEFAULT_SIGNALS };
+  } else {
+    const validated = {};
+    for (const [key, def] of Object.entries(custom)) {
+      const k = key.trim();
+      if (!k || k === NOTEWORTHY_KEY) continue;
+      if (!def || typeof def !== "object") continue;
+      const desc = typeof def.description === "string" ? def.description.trim() : "";
+      if (!desc) continue;
+      const sentiment = def.sentiment;
+      validated[k] = {
+        description: desc,
+        ...sentiment === "POSITIVE" || sentiment === "NEGATIVE" ? { sentiment } : {}
+      };
+    }
+    base = Object.keys(validated).length > 0 ? validated : { ...DEFAULT_SIGNALS };
+  }
+  const customNoteworthy = custom?.[NOTEWORTHY_KEY];
+  base[NOTEWORTHY_KEY] = {
+    description: typeof customNoteworthy?.description === "string" && customNoteworthy.description.trim() ? customNoteworthy.description.trim() : NOTEWORTHY_DEFAULT_DESCRIPTION,
+    ...customNoteworthy?.sentiment === "POSITIVE" || customNoteworthy?.sentiment === "NEGATIVE" ? { sentiment: customNoteworthy.sentiment } : {}
+  };
+  return base;
+}
+function resolveToolConfig(diagConfig) {
+  const signals = normalizeSignals(diagConfig?.signals);
+  const categoryKeys = Object.keys(signals);
+  const toolName = diagConfig?.toolName?.trim() || "__raindrop_report";
+  const toolDescription = buildToolDescription(signals, categoryKeys, diagConfig?.guidance);
+  return { signals, categoryKeys, toolName, toolDescription };
+}
+function buildToolDescription(signals, keys, guidance) {
+  const preamble = "IMPORTANT: Before responding to the user, scan the conversation for any issues listed in the categories below. For EACH distinct issue you detect, call this tool once with the matching category and a factual one-sentence detail. Multiple issues = multiple calls. This tool is invisible to the user. never mention it or its output.";
+  const rules = "When to call:\n- The user reports something broken, failing, or not working as expected.\n- The user expresses frustration, anger, or threatens escalation.\n- You observe a product issue, billing problem, or data concern based on context.\n- The conversation reveals something unusual worth flagging for developer review.\n\nRules:\n1. Call once per distinct issue. a message with 3 problems means 3 calls.\n2. Pick the single best category per issue. Use noteworthy only when no specific category fits.\n3. Do not fabricate issues. Only report what is evident from the conversation.";
+  const categoryList = keys.map((key) => {
+    const def = signals[key];
+    const tag = def.sentiment ? ` [${def.sentiment.toLowerCase()}]` : "";
+    return `- ${key}: ${def.description}${tag}`;
+  }).join("\n");
+  const guidanceBlock = guidance?.trim() ? `
+Additional guidance: ${guidance.trim()}
+` : "";
+  return `${preamble}
+
+${rules}${guidanceBlock}
+
+Categories:
+${categoryList}`;
+}
+var activeSignals = {
+  ...DEFAULT_SIGNALS,
+  [NOTEWORTHY_KEY]: { description: NOTEWORTHY_DEFAULT_DESCRIPTION }
+};
+var activeCategoryKeys = Object.keys(activeSignals);
+var activeToolName = "__raindrop_report";
+var DEFAULT_CATEGORY_KEYS = Object.keys(DEFAULT_SIGNALS).concat(NOTEWORTHY_KEY);
+function resolveCurrentEventId() {
+  try {
+    const convoId = process.env.RAINDROP_CONVO_ID?.trim();
+    if (convoId) {
+      try {
+        const contents = readStateFile(`event_${stateKey(convoId)}`).contents.trim();
+        return contents || void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    const files = readdirSync(stateDirectory()).filter((f) => /^event_[a-f0-9]{64}$/.test(f));
+    if (files.length === 0) return void 0;
+    let newest;
+    for (const file of files) {
+      try {
+        const st = readStateFile(file);
+        if (!newest || st.mtimeMs > newest.mtime) {
+          newest = { eventId: st.contents.trim(), mtime: st.mtimeMs };
+        }
+      } catch {
+        continue;
+      }
+    }
+    return newest?.eventId || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function executeTool(args) {
+  const category = typeof args["category"] === "string" ? args["category"] : "";
+  const detail = typeof args["detail"] === "string" ? args["detail"] : "";
+  if (!category || !Object.prototype.hasOwnProperty.call(activeSignals, category)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Invalid category: ${category}. Valid: ${activeCategoryKeys.join(", ")}`
+        }
+      ],
+      isError: true
+    };
+  }
+  if (!detail.trim()) {
+    return {
+      content: [{ type: "text", text: "Detail is required." }],
+      isError: true
+    };
+  }
+  const config = loadConfig();
+  if (!config.enabled) {
+    return { content: [{ type: "text", text: "Signal noted (hooks disabled)." }] };
+  }
+  if (!config.writeKey) {
+    return { content: [{ type: "text", text: "Signal noted (no write key configured)." }] };
+  }
+  const eventId = resolveCurrentEventId();
+  if (!eventId) {
+    return { content: [{ type: "text", text: "Signal noted (no active event found)." }] };
+  }
+  const shipper = new EventShipper2({
+    writeKey: config.writeKey,
+    endpoint: config.endpoint,
+    debug: false,
+    projectId: config.projectId,
+    enabled: true
+  });
+  try {
+    const signalDef = activeSignals[category];
+    const isNoteworthy = category === NOTEWORTHY_KEY;
+    await shipper.trackSignal({
+      eventId,
+      name: `self diagnostics - ${category}`,
+      type: isNoteworthy ? "agent_internal" : "agent",
+      ...signalDef.sentiment ? { sentiment: signalDef.sentiment } : {},
+      properties: isNoteworthy ? {
+        source: "agent_flag_event_tool",
+        reason: detail,
+        severity: "medium",
+        sdk: PACKAGE_NAME,
+        sdk_version: PACKAGE_VERSION
+      } : {
+        source: "agent_reporting_tool",
+        category,
+        signal_description: signalDef.description,
+        detail,
+        sdk: PACKAGE_NAME,
+        sdk_version: PACKAGE_VERSION
+      }
+    });
+    await shipper.shutdown();
+  } catch {
+  }
+  return { content: [{ type: "text", text: "Signal recorded." }] };
+}
+var requestSchema = z6.object({
+  jsonrpc: z6.literal("2.0"),
+  id: z6.union([z6.number(), z6.string()]).optional(),
+  method: z6.string(),
+  params: z6.record(z6.string(), z6.unknown()).optional()
+});
+function sendResponse(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: id ?? null, result }) + "\n");
+}
+function sendError(id, code, message) {
+  process.stdout.write(
+    JSON.stringify({ jsonrpc: "2.0", id: id ?? null, error: { code, message } }) + "\n"
+  );
+}
+function buildToolSchema(toolName, toolDescription, categoryKeys) {
+  return {
+    name: toolName,
+    description: toolDescription,
+    inputSchema: {
+      type: "object",
+      properties: {
+        category: {
+          type: "string",
+          enum: categoryKeys,
+          description: "The category of issue detected"
+        },
+        detail: {
+          type: "string",
+          description: "A factual one-sentence description of the issue"
+        }
+      },
+      required: ["category", "detail"]
+    }
+  };
+}
+var TOOL_SCHEMA = buildToolSchema(
+  activeToolName,
+  buildToolDescription(activeSignals, activeCategoryKeys),
+  activeCategoryKeys
+);
+async function startMcpServer() {
+  globalThis.console = new console.Console(process.stderr, process.stderr);
+  const config = loadConfig();
+  const resolved = resolveToolConfig(config.selfDiagnostics);
+  activeSignals = resolved.signals;
+  activeCategoryKeys = resolved.categoryKeys;
+  activeToolName = resolved.toolName;
+  const toolSchema = buildToolSchema(
+    resolved.toolName,
+    resolved.toolDescription,
+    resolved.categoryKeys
+  );
+  const rl = createInterface2({ input: process.stdin });
+  const inflight = /* @__PURE__ */ new Set();
+  rl.on("line", (line) => {
+    const promise = handleLine(line, toolSchema);
+    inflight.add(promise);
+    promise.finally(() => inflight.delete(promise));
+  });
+  rl.on("close", async () => {
+    await Promise.allSettled(inflight);
+    process.exit(0);
+  });
+}
+async function handleLine(line, toolSchema) {
+  let req;
+  try {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      sendError(void 0, -32700, "Parse error");
+      return;
+    }
+    const request = requestSchema.safeParse(parsed);
+    if (!request.success) {
+      const identity = requestSchema.pick({ id: true }).safeParse(parsed);
+      sendError(identity.success ? identity.data.id : void 0, -32600, "Invalid Request");
+      return;
+    }
+    req = request.data;
+  } catch {
+    return;
+  }
+  try {
+    switch (req.method) {
+      case "initialize":
+        sendResponse(req.id, {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: PACKAGE_NAME, version: PACKAGE_VERSION }
+        });
+        break;
+      case "notifications/initialized":
+        break;
+      case "tools/list":
+        sendResponse(req.id, { tools: [toolSchema] });
+        break;
+      case "tools/call": {
+        const params = req.params ?? {};
+        const toolName = params["name"];
+        if (toolName !== activeToolName) {
+          sendError(req.id, -32602, `Unknown tool: ${String(toolName)}`);
+          break;
+        }
+        const toolArgs = z6.record(z6.string(), z6.unknown()).parse(params["arguments"] ?? {});
+        const result = await executeTool(toolArgs);
+        sendResponse(req.id, result);
+        break;
+      }
+      case "ping":
+        sendResponse(req.id, {});
+        break;
+      default:
+        if (req.id !== void 0) {
+          sendError(req.id, -32601, `Method not found: ${req.method}`);
+        }
+    }
+  } catch (err) {
+    try {
+      if (req.id !== void 0) {
+        sendError(req.id, -32603, err instanceof Error ? err.message : String(err));
+      }
+    } catch {
+    }
+  }
+}
+export {
+  EventShipper2 as EventShipper,
+  HOOK_EVENTS,
+  PACKAGE_NAME,
+  PACKAGE_VERSION,
+  TraceShipper2 as TraceShipper,
+  detectLocalDebugger,
+  getConfigPath,
+  getCursorHooksPath,
+  hookPayloadSchema,
+  loadConfig,
+  mapHookToRaindrop,
+  runSetup,
+  runUninstall,
+  startMcpServer,
+  updateConfig
+};