@raindrop-ai/claude-code 0.0.18 → 0.0.19

package/dist/index.cjs

@@ -43,7 +43,7 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../core/dist/chunk-WKRW55KX.js
+// ../core/dist/chunk-5PSWD267.js
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -87,6 +87,20 @@ 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();
@@ -377,26 +391,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(() => {
   });
 }
@@ -422,16 +439,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();
@@ -680,6 +733,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 = {
@@ -689,15 +747,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
     };
@@ -721,29 +781,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})`);
         }
@@ -755,13 +816,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",
@@ -851,6 +1055,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 {
@@ -955,6 +1166,10 @@ var TraceShipper = class {
         return null;
       }
     }
+    try {
+      current = normalizeModelUsageSpan(current);
+    } catch (e) {
+    }
     if (!this.disableDefaultRedaction) {
       current = defaultTransformSpan(current);
     }
@@ -975,6 +1190,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);
@@ -997,11 +1213,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;
@@ -1030,7 +1250,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({
@@ -1074,7 +1295,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;
@@ -1195,9 +1420,81 @@ function installTracingSuppressionHook() {
 }
 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 {
@@ -2247,7 +2544,6 @@ var import_node_path3 = require("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 = (0, import_node_path3.join)((0, import_node_os3.tmpdir)(), "raindrop-claude-code");
 var CACHE_FILE = (0, import_node_path3.join)(CACHE_DIR, "debugger_cache");
 var CACHE_TTL_MS = 5e3;
@@ -2309,20 +2605,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 runWithTracingSuppressed(
-    () => 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/dist/index.d.cts

@@ -45,6 +45,10 @@ type IdentifyInput = {
     userId: string;
     traits?: Record<string, unknown>;
 };
+type EventUsage = {
+    promptTokens?: number;
+    completionTokens?: number;
+};
 type Patch = {
     eventName?: string;
     userId?: string;
@@ -52,7 +56,10 @@ type Patch = {
     input?: string;
     output?: string;
     model?: string;
+    usage?: EventUsage;
+    error?: unknown;
     properties?: Record<string, unknown>;
+    featureFlags?: Record<string, string>;
     attachments?: Attachment[];
     isPending?: boolean;
     timestamp?: string;
@@ -149,12 +156,7 @@ declare class EventShipper$1 {
      */
     private requestOpts;
     patch(eventId: string, patch: Patch): Promise<void>;
-    finish(eventId: string, patch: {
-        output?: string;
-        model?: string;
-        properties?: Record<string, unknown>;
-        userId?: string;
-    }): Promise<void>;
+    finish(eventId: string, patch: Pick<Patch, "output" | "model" | "usage" | "error" | "properties" | "featureFlags" | "userId">): Promise<void>;
     flush(): Promise<void>;
     shutdown(): Promise<void>;
     trackSignal(signal: SignalInput): Promise<void>;
@@ -327,6 +329,9 @@ declare class TraceShipper$1 {
             spanIdB64: string;
         };
         eventId: string;
+        userId?: string;
+        convoId?: string;
+        eventName?: string;
         operationId?: string;
         attributes?: Array<OtlpKeyValue | undefined>;
         startTimeUnixNano?: string;
@@ -345,6 +350,9 @@ declare class TraceShipper$1 {
             spanIdB64: string;
         };
         eventId: string;
+        userId?: string;
+        convoId?: string;
+        eventName?: string;
         startTimeUnixNano: string;
         endTimeUnixNano: string;
         attributes?: Array<OtlpKeyValue | undefined>;
@@ -525,7 +533,7 @@ declare function mapHookToRaindrop(payload: HookPayload, config: MapperConfig, e
 declare function extractAppendSystemPrompt(args: string[]): string | undefined;
 
 declare const PACKAGE_NAME = "@raindrop-ai/claude-code";
-declare const PACKAGE_VERSION = "0.0.13";
+declare const PACKAGE_VERSION: string;
 
 /** A tool call extracted from an assistant message content block. */
 interface LLMToolCall {
@@ -619,9 +627,11 @@ interface LocalDebuggerResult {
 declare function detectLocalDebugger(debug: boolean): Promise<LocalDebuggerResult>;
 /**
  * Mirror an event payload to the local debugger's track_partial endpoint.
- * Fire-and-forget — errors are silently swallowed.
+ * Must be awaited: Claude Code hooks call process.exit as soon as handleHook
+ * returns, so a fire-and-forget fetch is killed before it leaves the socket.
+ * Errors are swallowed — observability must never fail the hook.
  */
-declare function mirrorEventToLocalDebugger(baseUrl: string, payload: Record<string, unknown>, debug: boolean): void;
+declare function mirrorEventToLocalDebugger(baseUrl: string, payload: Record<string, unknown>, debug: boolean): Promise<void>;
 
 interface ResolvedSignal {
     description: string;