@raindrop-ai/claude-code 0.0.17 → 0.0.19

package/dist/index.js

@@ -1,4 +1,4 @@
-// ../core/dist/chunk-SK6EJEO7.js
+// ../core/dist/chunk-5PSWD267.js
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -42,6 +42,34 @@ function base64Encode(bytes) {
   }
   return out;
 }
+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 HANDOFF_TERMINAL_PROPERTY_KEY = HANDOFF_ATTRIBUTE_SUFFIXES.terminal;
+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) {
@@ -152,15 +180,17 @@ async function postJson(url, body, headers, opts) {
   const timeoutMs = (_a = opts.timeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
   await withRetry(
     async () => {
-      const resp = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...headers
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(timeoutMs)
-      });
+      const resp = await runWithTracingSuppressed(
+        () => fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...headers
+          },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(timeoutMs)
+        })
+      );
       if (!resp.ok) {
         const text = await resp.text().catch(() => "");
         const err = new Error(
@@ -316,26 +346,29 @@ function resolveLocalDebuggerBaseUrl(baseUrl) {
   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;
-  void postJson(`${baseUrl}traces`, body, {}, {
+  if (!baseUrl) return Promise.resolve();
+  return postJson(`${baseUrl}traces`, body, {}, {
     maxAttempts: 1,
     debug: (_a = options.debug) != null ? _a : false,
-    sdkName: options.sdkName
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
   }).catch(() => {
   });
 }
 function mirrorPartialEventToLocalDebugger(event, options = {}) {
   var _a;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
-  if (!baseUrl) return;
+  if (!baseUrl) return Promise.resolve();
   const headers = options.writeKey ? { Authorization: `Bearer ${options.writeKey}` } : {};
-  void postJson(`${baseUrl}events/track_partial`, event, headers, {
+  return postJson(`${baseUrl}events/track_partial`, event, headers, {
     maxAttempts: 1,
     debug: (_a = options.debug) != null ? _a : false,
-    sdkName: options.sdkName
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
   }).catch(() => {
   });
 }
@@ -361,16 +394,52 @@ function projectIdHeaders(projectId) {
 var SHUTDOWN_DEADLINE_MS = 1e4;
 var POST_SHUTDOWN_TIMEOUT_MS = 5e3;
 function mergePatches(target, source) {
-  var _a, _b, _c, _d;
+  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 = [...(_c = target.attachments) != null ? _c : [], ...(_d = source.attachments) != null ? _d : []];
+    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();
@@ -619,6 +688,11 @@ var EventShipper = class {
       return;
     }
     const { wizardSession, ...restProperties } = (_e = accumulated.properties) != null ? _e : {};
+    let telemetryProperties = {};
+    try {
+      telemetryProperties = eventTelemetryProperties(accumulated);
+    } catch (e) {
+    }
     const convoId = (_f = accumulated.convoId) != null ? _f : sticky.convoId;
     const isPending = (_h = (_g = accumulated.isPending) != null ? _g : sticky.isPending) != null ? _h : true;
     const payload = {
@@ -628,15 +702,17 @@ var EventShipper = class {
       timestamp: (_i = accumulated.timestamp) != null ? _i : (/* @__PURE__ */ new Date()).toISOString(),
       ai_data: {
         input: accumulated.input,
-        output: accumulated.output,
+        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
     };
@@ -660,29 +736,30 @@ var EventShipper = class {
         endpoint: url
       });
     }
-    if (this.localDebuggerUrl) {
-      mirrorPartialEventToLocalDebugger(payload, {
-        baseUrl: this.localDebuggerUrl,
-        writeKey: this.writeKey,
-        debug: this.debug,
-        sdkName: this.sdkName
-      });
-    }
+    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);
-    this.inFlight.add(p);
+    const combined = mirror ? Promise.all([mirror, p]).then(() => void 0) : p;
+    this.inFlight.add(combined);
     try {
       try {
-        await p;
+        await combined;
         if (this.debug) {
           console.log(`${this.prefix} sent track_partial ${eventId} (${eventName})`);
         }
@@ -694,13 +771,156 @@ var EventShipper = class {
         );
       }
     } finally {
-      this.inFlight.delete(p);
+      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",
@@ -790,6 +1010,13 @@ function redactJsonAttributeValue(key, value) {
   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 {
@@ -894,6 +1121,10 @@ var TraceShipper = class {
         return null;
       }
     }
+    try {
+      current = normalizeModelUsageSpan(current);
+    } catch (e) {
+    }
     if (!this.disableDefaultRedaction) {
       current = defaultTransformSpan(current);
     }
@@ -914,6 +1145,7 @@ var TraceShipper = class {
     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)
     ];
     if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
@@ -936,11 +1168,15 @@ var TraceShipper = class {
     const redacted = this.redactSpan(span);
     if (redacted === null) return;
     const body = buildExportTraceServiceRequest([redacted], this.serviceName, this.serviceVersion);
-    mirrorTraceExportToLocalDebugger(body, {
+    const p = mirrorTraceExportToLocalDebugger(body, {
       baseUrl: this.localDebuggerUrl,
       debug: false,
       sdkName: this.sdkName
     });
+    this.inFlight.add(p);
+    void p.finally(() => {
+      this.inFlight.delete(p);
+    });
   }
   endSpan(span, extra) {
     var _a, _b;
@@ -969,7 +1205,8 @@ var TraceShipper = class {
     var _a;
     const ids = createSpanIds(args.parent);
     const attrs = [
-      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId)
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
+      ...identityAttrs(args)
     ];
     if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
     const otlp = buildOtlpSpan({
@@ -1013,7 +1250,11 @@ var TraceShipper = class {
     }
   }
   async flush() {
-    if (!this.enabled) return;
+    if (!this.enabled) {
+      await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+      })));
+      return;
+    }
     if (this.timer) {
       clearTimeout(this.timer);
       this.timer = void 0;
@@ -1108,10 +1349,107 @@ var TraceShipper = class {
 // ../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/claude-code",
+  version: "0.0.19",
+  description: "Raindrop observability for Claude Code CLI \u2014 automatic session, tool call, and prompt tracing via hooks",
+  license: "MIT",
+  homepage: "https://www.raindrop.ai/docs/integrations/claude-code/",
+  bugs: {
+    url: "https://www.raindrop.ai/docs/support/"
+  },
+  type: "module",
+  main: "dist/index.cjs",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    "raindrop-claude-code": "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",
+    ".claude-plugin/**",
+    "hooks/**",
+    ".mcp.json"
+  ],
+  keywords: [
+    "raindrop",
+    "claude-code",
+    "claude",
+    "anthropic",
+    "observability",
+    "tracing",
+    "hooks",
+    "cli"
+  ],
+  engines: {
+    node: ">=18"
+  },
+  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: "pnpm build && cd tests && pnpm test",
+    "test:watch": "cd tests && pnpm test:watch"
+  },
+  devDependencies: {
+    "@raindrop-ai/core": "workspace:*",
+    "@types/node": "^20.11.17",
+    msw: "^2.12.7",
+    tsup: "^8.4.0",
+    typescript: "^5.3.3",
+    vitest: "^2.1.0"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
 
 // src/package-info.ts
 var PACKAGE_NAME = "@raindrop-ai/claude-code";
-var PACKAGE_VERSION = "0.0.13";
+var PACKAGE_VERSION = package_default.version;
 
 // src/shipper.ts
 var EventShipper2 = class extends EventShipper {
@@ -2161,7 +2499,6 @@ import { join as join3 } from "path";
 var DEFAULT_PORT = 5899;
 var DEFAULT_URL = `http://localhost:${DEFAULT_PORT}/v1/`;
 var HEALTH_TIMEOUT_MS = 300;
-var MIRROR_TIMEOUT_MS = 2e3;
 var CACHE_DIR = join3(tmpdir2(), "raindrop-claude-code");
 var CACHE_FILE = join3(CACHE_DIR, "debugger_cache");
 var CACHE_TTL_MS = 5e3;
@@ -2186,7 +2523,9 @@ async function healthPing(baseUrl) {
   const healthUrl = baseUrl.replace(/\/v1\/$/, "/health");
   try {
     const signal = AbortSignal.timeout(HEALTH_TIMEOUT_MS);
-    const resp = await fetch(healthUrl, { signal });
+    const resp = await runWithTracingSuppressed(
+      () => fetch(healthUrl, { signal })
+    );
     if (resp.ok) {
       const body = await resp.json();
       if (body.ok) return baseUrl;
@@ -2221,18 +2560,22 @@ async function detectLocalDebugger(debug) {
   }
   return { url: detected, autoDetected: detected !== null };
 }
-function mirrorEventToLocalDebugger(baseUrl, payload, debug) {
+async function mirrorEventToLocalDebugger(baseUrl, payload, debug) {
   const url = `${baseUrl}events/track_partial`;
   if (debug) {
     console.log(`[raindrop-ai/claude-code] Mirroring event to local debugger: ${url}`);
   }
-  void fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(payload),
-    signal: AbortSignal.timeout(MIRROR_TIMEOUT_MS)
-  }).catch(() => {
-  });
+  try {
+    await runWithTracingSuppressed(
+      () => fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS)
+      })
+    );
+  } catch (e) {
+  }
 }
 
 // src/mcp-serve.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raindrop-ai/claude-code",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Raindrop observability for Claude Code CLI — automatic session, tool call, and prompt tracing via hooks",
   "license": "MIT",
   "homepage": "https://www.raindrop.ai/docs/integrations/claude-code/",
@@ -53,14 +53,14 @@
     "tsup": "^8.4.0",
     "typescript": "^5.3.3",
     "vitest": "^2.1.0",
-    "@raindrop-ai/core": "0.0.4"
+    "@raindrop-ai/core": "0.2.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "tsup",
-    "postbuild": "chmod +x ./dist/cli.js",
+    "postbuild": "chmod +x ./dist/cli.js && node ./scripts/sync-plugin-version.mjs",
     "dev": "tsup --watch",
     "clean": "rm -rf dist",
     "test": "pnpm build && cd tests && pnpm test",