@raindrop-ai/opencode-plugin 0.0.1

package/dist/index.cjs

@@ -0,0 +1,913 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => plugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+function loadConfig(projectDirectory) {
+  var _a, _b, _c, _d, _e, _f;
+  let merged = {};
+  const configPaths = [
+    (0, import_node_path.join)((0, import_node_os.homedir)(), ".config", "opencode", "raindrop.json"),
+    (0, import_node_path.join)(projectDirectory, ".opencode", "raindrop.json")
+  ];
+  for (const configPath of configPaths) {
+    try {
+      if ((0, import_node_fs.existsSync)(configPath)) {
+        const content = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+        const parsed = JSON.parse(content);
+        merged = { ...merged, ...parsed };
+      }
+    } catch (e) {
+    }
+  }
+  return {
+    writeKey: (_b = (_a = process.env["RAINDROP_WRITE_KEY"]) != null ? _a : merged.write_key) != null ? _b : "",
+    endpoint: (_d = (_c = process.env["RAINDROP_API_URL"]) != null ? _c : merged.api_url) != null ? _d : "https://api.raindrop.ai",
+    eventName: (_e = merged.event_name) != null ? _e : "opencode_session",
+    userId: merged.user_id,
+    debug: process.env["RAINDROP_DEBUG"] === "true" ? true : (_f = merged.debug) != null ? _f : false
+  };
+}
+
+// src/shipper.ts
+function getCryptoObj() {
+  return globalThis.crypto;
+}
+function randomBytes(length) {
+  const c = getCryptoObj();
+  const out = new Uint8Array(length);
+  if (c == null ? void 0 : c.getRandomValues) {
+    c.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 buf = globalThis.Buffer;
+  if (buf) return buf.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;
+}
+var SERVICE_NAME = "raindrop.opencode-plugin";
+var PLUGIN_VERSION = "0.1.0";
+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 String(Date.now() * 1e6);
+}
+function attrString(key, value) {
+  if (value === void 0) return void 0;
+  return { key, value: { stringValue: value } };
+}
+function attrInt(key, value) {
+  if (value === void 0) return void 0;
+  if (!Number.isFinite(value)) return void 0;
+  return { key, value: { intValue: String(Math.trunc(value)) } };
+}
+function buildOtlpSpan(args) {
+  const attrs = args.attributes.filter((x) => x !== void 0);
+  const span = {
+    traceId: args.ids.traceIdB64,
+    spanId: args.ids.spanIdB64,
+    name: args.name,
+    startTimeUnixNano: args.startTimeUnixNano,
+    endTimeUnixNano: args.endTimeUnixNano
+  };
+  if (args.ids.parentSpanIdB64) span.parentSpanId = args.ids.parentSpanIdB64;
+  if (attrs.length) span.attributes = attrs;
+  if (args.status) span.status = args.status;
+  return span;
+}
+function buildExportTraceServiceRequest(spans) {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [{ key: "service.name", value: { stringValue: SERVICE_NAME } }]
+        },
+        scopeSpans: [
+          {
+            scope: { name: SERVICE_NAME, version: PLUGIN_VERSION },
+            spans
+          }
+        ]
+      }
+    ]
+  };
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatEndpoint(endpoint) {
+  if (!endpoint) return void 0;
+  return endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
+}
+function parseRetryAfter(headers) {
+  var _a;
+  const value = (_a = headers.get("Retry-After")) != null ? _a : headers.get("retry-after");
+  if (!value) return void 0;
+  const asNumber = Number(value);
+  if (!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 !== null && typeof previousError === "object" && "retryAfterMs" in previousError) {
+    const v = previousError.retryAfterMs;
+    if (typeof v === "number") return Math.max(0, v);
+  }
+  if (attemptNumber <= 1) return 0;
+  return 500 * Math.pow(2, attemptNumber - 2);
+}
+async function withRetry(operation, opName, opts) {
+  let lastError = void 0;
+  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+    if (attempt > 1) {
+      const delay = getRetryDelayMs(attempt, lastError);
+      if (opts.debug) {
+        console.warn(
+          `[raindrop-ai/opencode-plugin] ${opName} retry ${attempt}/${opts.maxAttempts} in ${delay}ms`
+        );
+      }
+      if (delay > 0) await wait(delay);
+    } else if (opts.debug) {
+      console.log(
+        `[raindrop-ai/opencode-plugin] ${opName} attempt ${attempt}/${opts.maxAttempts}`
+      );
+    }
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      if (opts.debug) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(
+          `[raindrop-ai/opencode-plugin] ${opName} attempt ${attempt} failed: ${msg}${attempt === opts.maxAttempts ? " (no more retries)" : ""}`
+        );
+      }
+      if (attempt === opts.maxAttempts) break;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function postJson(url, body, headers, opts) {
+  await withRetry(
+    async () => {
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers },
+        body: JSON.stringify(body)
+      });
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        const err = new Error(
+          `HTTP ${resp.status} ${resp.statusText}${text ? `: ${text}` : ""}`
+        );
+        const retryAfterMs = parseRetryAfter(resp.headers);
+        if (typeof retryAfterMs === "number") err.retryAfterMs = retryAfterMs;
+        throw err;
+      }
+    },
+    `POST ${url}`,
+    opts
+  );
+}
+function mergePatches(target, source) {
+  var _a, _b, _c, _d;
+  const out = { ...target, ...source };
+  if (target.properties || source.properties) {
+    out.properties = { ...(_a = target.properties) != null ? _a : {}, ...(_b = source.properties) != null ? _b : {} };
+  }
+  if (target.attachments || source.attachments) {
+    out.attachments = [...(_c = target.attachments) != null ? _c : [], ...(_d = source.attachments) != null ? _d : []];
+  }
+  return out;
+}
+var EventShipper = class {
+  constructor(opts) {
+    this.buffers = /* @__PURE__ */ new Map();
+    this.sticky = /* @__PURE__ */ new Map();
+    this.timers = /* @__PURE__ */ new Map();
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b;
+    this.writeKey = opts.writeKey;
+    this.baseUrl = (_a = formatEndpoint(opts.endpoint)) != null ? _a : "https://api.raindrop.ai/v1/";
+    this.debug = opts.debug;
+    this.partialFlushMs = (_b = opts.partialFlushMs) != null ? _b : 1e3;
+  }
+  async patch(eventId, patch) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    if (!eventId) return;
+    if (this.debug) {
+      console.log("[raindrop-ai/opencode-plugin] queue patch", {
+        eventId,
+        userId: patch.userId,
+        hasInput: typeof patch.input === "string" && patch.input.length > 0,
+        hasOutput: typeof patch.output === "string" && patch.output.length > 0,
+        isPending: patch.isPending
+      });
+    }
+    const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
+    const existing = (_b = this.buffers.get(eventId)) != null ? _b : {};
+    const merged = mergePatches(existing, patch);
+    merged.isPending = (_e = (_d = (_c = patch.isPending) != null ? _c : existing.isPending) != null ? _d : sticky.isPending) != null ? _e : true;
+    this.buffers.set(eventId, merged);
+    this.sticky.set(eventId, {
+      userId: (_f = merged.userId) != null ? _f : sticky.userId,
+      convoId: (_g = merged.convoId) != null ? _g : sticky.convoId,
+      eventName: (_h = merged.eventName) != null ? _h : sticky.eventName,
+      isPending: (_i = merged.isPending) != null ? _i : 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() {
+    const ids = [...this.buffers.keys()];
+    await Promise.all(ids.map((id) => this.flushOne(id)));
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+  async shutdown() {
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+    await this.flush();
+  }
+  async flushOne(eventId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const timer = this.timers.get(eventId);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(eventId);
+    }
+    const accumulated = this.buffers.get(eventId);
+    this.buffers.delete(eventId);
+    if (!accumulated) return;
+    const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
+    const eventName = (_c = (_b = accumulated.eventName) != null ? _b : sticky.eventName) != null ? _c : "opencode_session";
+    const userId = (_d = accumulated.userId) != null ? _d : sticky.userId;
+    if (!userId) {
+      if (this.debug) {
+        console.warn(
+          `[raindrop-ai/opencode-plugin] skipping track_partial for ${eventId}: missing userId`
+        );
+      }
+      return;
+    }
+    const payload = {
+      event_id: eventId,
+      user_id: userId,
+      event: eventName,
+      timestamp: (_e = accumulated.timestamp) != null ? _e : (/* @__PURE__ */ new Date()).toISOString(),
+      ai_data: {
+        input: accumulated.input,
+        output: accumulated.output,
+        model: accumulated.model,
+        convo_id: (_f = accumulated.convoId) != null ? _f : sticky.convoId
+      },
+      properties: {
+        ...(_g = accumulated.properties) != null ? _g : {},
+        $context: {
+          library: { name: "@raindrop-ai/opencode-plugin", version: PLUGIN_VERSION },
+          metadata: { jsRuntime: "node" }
+        }
+      },
+      attachments: accumulated.attachments,
+      is_pending: ((_i = (_h = accumulated.isPending) != null ? _h : sticky.isPending) != null ? _i : true) !== false
+    };
+    const url = `${this.baseUrl}events/track_partial`;
+    if (this.debug) {
+      console.log("[raindrop-ai/opencode-plugin] sending track_partial", {
+        eventId,
+        eventName,
+        userId,
+        isPending: payload["is_pending"],
+        inputPreview: typeof accumulated.input === "string" ? accumulated.input.slice(0, 120) : void 0,
+        outputPreview: typeof accumulated.output === "string" ? accumulated.output.slice(0, 120) : void 0,
+        endpoint: url
+      });
+    }
+    const p = postJson(
+      url,
+      payload,
+      { Authorization: `Bearer ${this.writeKey}` },
+      { maxAttempts: 3, debug: this.debug }
+    );
+    this.inFlight.add(p);
+    try {
+      try {
+        await p;
+        if (this.debug) {
+          console.log(`[raindrop-ai/opencode-plugin] sent track_partial ${eventId} (${eventName})`);
+        }
+      } catch (err) {
+        if (this.debug) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.warn(
+            `[raindrop-ai/opencode-plugin] failed to send track_partial (dropping): ${msg}`
+          );
+        }
+      }
+    } finally {
+      this.inFlight.delete(p);
+    }
+    if (!payload["is_pending"]) this.sticky.delete(eventId);
+  }
+};
+var TraceShipper = class {
+  constructor(opts) {
+    this.queue = [];
+    this.inFlight = /* @__PURE__ */ new Set();
+    var _a, _b;
+    this.writeKey = opts.writeKey;
+    this.baseUrl = (_a = formatEndpoint(opts.endpoint)) != null ? _a : "https://api.raindrop.ai/v1/";
+    this.debug = opts.debug;
+    this.flushIntervalMs = (_b = opts.flushIntervalMs) != null ? _b : 1e3;
+    this.maxBatchSize = 50;
+    this.maxQueueSize = 5e3;
+  }
+  startSpan(args) {
+    var _a;
+    const ids = createSpanIds(args.parent);
+    const started = nowUnixNanoString();
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId)
+    ];
+    if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
+    return { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
+  }
+  endSpan(span, extra) {
+    var _a;
+    if (span.endTimeUnixNano) return;
+    span.endTimeUnixNano = nowUnixNanoString();
+    if ((_a = extra == null ? void 0 : extra.attributes) == null ? void 0 : _a.length) span.attributes.push(...extra.attributes);
+    let status;
+    if ((extra == null ? void 0 : extra.error) !== void 0) {
+      const message = extra.error instanceof Error ? extra.error.message : String(extra.error);
+      status = { code: SpanStatusCode.ERROR, message };
+    }
+    const otlp = buildOtlpSpan({
+      ids: span.ids,
+      name: span.name,
+      startTimeUnixNano: span.startTimeUnixNano,
+      endTimeUnixNano: span.endTimeUnixNano,
+      attributes: span.attributes,
+      status
+    });
+    this.enqueue(otlp);
+  }
+  enqueue(span) {
+    if (this.queue.length >= this.maxQueueSize) this.queue.shift();
+    this.queue.push(span);
+    if (this.queue.length >= this.maxBatchSize) {
+      void this.flush().catch(() => {
+      });
+      return;
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = void 0;
+        void this.flush().catch(() => {
+        });
+      }, this.flushIntervalMs);
+    }
+  }
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    while (this.queue.length > 0) {
+      const batch = this.queue.splice(0, this.maxBatchSize);
+      const body = buildExportTraceServiceRequest(batch);
+      const url = `${this.baseUrl}traces`;
+      if (this.debug) {
+        console.log("[raindrop-ai/opencode-plugin] sending traces batch", {
+          spans: batch.length,
+          endpoint: url
+        });
+      }
+      const p = postJson(
+        url,
+        body,
+        { Authorization: `Bearer ${this.writeKey}` },
+        { maxAttempts: 3, debug: this.debug }
+      );
+      this.inFlight.add(p);
+      try {
+        try {
+          await p;
+          if (this.debug) {
+            console.log(`[raindrop-ai/opencode-plugin] sent ${batch.length} spans`);
+          }
+        } catch (err) {
+          if (this.debug) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(
+              `[raindrop-ai/opencode-plugin] failed to send spans (dropping): ${msg}`
+            );
+          }
+        }
+      } finally {
+        this.inFlight.delete(p);
+      }
+    }
+  }
+  async shutdown() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    await this.flush();
+    await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+    })));
+  }
+};
+
+// src/tracing.ts
+var sessions = /* @__PURE__ */ new Map();
+function getHostname() {
+  var _a, _b;
+  try {
+    const bunGlobal = globalThis;
+    if ((_a = bunGlobal.Bun) == null ? void 0 : _a.hostname) return bunGlobal.Bun.hostname;
+    return require("os").hostname();
+  } catch (e) {
+    return (_b = process.env["HOSTNAME"]) != null ? _b : "unknown";
+  }
+}
+function getProjectName(worktree) {
+  var _a;
+  const parts = worktree.split("/").filter(Boolean);
+  return (_a = parts[parts.length - 1]) != null ? _a : "unknown";
+}
+function createHooks(client, config, worktree, directory, eventShipper, traceShipper) {
+  function log(msg, data) {
+    var _a, _b;
+    (_b = (_a = client.app.log({
+      body: {
+        service: "raindrop-opencode",
+        level: config.debug ? "info" : "debug",
+        message: msg,
+        ...data !== void 0 ? { extra: data } : {}
+      }
+    })) == null ? void 0 : _a.catch) == null ? void 0 : _b.call(_a, () => {
+    });
+  }
+  log("Raindrop tracing hooks registered");
+  return {
+    // ------------------------------------------------------------------
+    // event — session lifecycle + streaming parts
+    // ------------------------------------------------------------------
+    event: async ({
+      event
+    }) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+      try {
+        const props = event.properties;
+        const info = props["info"];
+        const sessionID = props["sessionID"] || (info == null ? void 0 : info["id"]) || props["id"];
+        if (event.type === "session.created") {
+          if (!sessionID) {
+            log("session.created: no session ID, skipping");
+            return;
+          }
+          const userId = (_a = config.userId) != null ? _a : sessionID;
+          const hostname = getHostname();
+          const os = process.platform;
+          const rootSpan = traceShipper.startSpan({
+            name: `OpenCode: ${getProjectName(worktree)}`,
+            eventId: sessionID,
+            attributes: [
+              attrString("workspace", worktree),
+              attrString("directory", directory),
+              attrString("hostname", hostname),
+              attrString("os", os)
+            ]
+          });
+          const state = {
+            eventId: sessionID,
+            rootSpan,
+            turnNumber: 0,
+            toolCount: 0,
+            startTime: Date.now(),
+            currentInput: "",
+            currentOutput: "",
+            outputParts: /* @__PURE__ */ new Map(),
+            reasoningParts: /* @__PURE__ */ new Map(),
+            toolCalls: /* @__PURE__ */ new Map(),
+            toolStartTimes: /* @__PURE__ */ new Map(),
+            toolSpans: /* @__PURE__ */ new Map(),
+            toolCallMessageIds: /* @__PURE__ */ new Map(),
+            processedMessages: /* @__PURE__ */ new Set(),
+            attachments: []
+          };
+          sessions.set(sessionID, state);
+          await eventShipper.patch(sessionID, {
+            isPending: true,
+            userId,
+            convoId: sessionID,
+            eventName: config.eventName,
+            properties: {
+              workspace: worktree,
+              directory,
+              hostname,
+              os,
+              turn_count: 0,
+              tool_count: 0
+            }
+          });
+          log("Session created", { sessionID, userId });
+        } else if (event.type === "message.part.updated") {
+          const part = props["part"];
+          if (!part) return;
+          const partSessionID = part["sessionID"];
+          const messageId = part["messageID"];
+          if (!partSessionID || !messageId) return;
+          const state = sessions.get(partSessionID);
+          if (!state) return;
+          if (part["type"] === "text" && typeof part["text"] === "string") {
+            state.outputParts.set(messageId, part["text"]);
+          } else if (part["type"] === "tool" && messageId) {
+            const callID = part["callID"];
+            const tool = part["tool"];
+            const partState = part["state"];
+            const input = partState == null ? void 0 : partState["input"];
+            if (callID && tool && input) {
+              let calls = state.toolCalls.get(messageId);
+              if (!calls) {
+                calls = [];
+                state.toolCalls.set(messageId, calls);
+              }
+              const existingIdx = calls.findIndex((c) => c.callId === callID);
+              const entry = { callId: callID, name: tool, args: JSON.stringify(input) };
+              if (existingIdx >= 0) calls[existingIdx] = entry;
+              else calls.push(entry);
+              state.toolCallMessageIds.set(callID, messageId);
+            }
+          } else if (part["type"] === "reasoning" && typeof part["text"] === "string") {
+            state.reasoningParts.set(messageId, part["text"]);
+          } else {
+            log(`message.part.updated: skipping part type=${String(part["type"])}`);
+          }
+        } else if (event.type === "message.updated") {
+          const msgInfo = props["info"];
+          if (!msgInfo) return;
+          const role = msgInfo["role"];
+          if (role !== "assistant") return;
+          const msgSessionID = msgInfo["sessionID"];
+          const messageId = msgInfo["id"];
+          const time = msgInfo["time"];
+          if (!msgSessionID || !messageId || !(time == null ? void 0 : time["completed"])) return;
+          const state = sessions.get(msgSessionID);
+          if (!state || !state.currentTurnSpan) return;
+          if (state.processedMessages.has(messageId)) return;
+          state.processedMessages.add(messageId);
+          const tokens = msgInfo["tokens"];
+          const inputTokens = (tokens == null ? void 0 : tokens["input"]) || 0;
+          const outputTokens = (tokens == null ? void 0 : tokens["output"]) || 0;
+          const reasoningTokens = (tokens == null ? void 0 : tokens["reasoning"]) || 0;
+          const providerID = msgInfo["providerID"] || "unknown";
+          const modelID = msgInfo["modelID"] || "unknown";
+          const modelName = `${providerID}/${modelID}`;
+          state.model = modelName;
+          const outputText = (_b = state.outputParts.get(messageId)) != null ? _b : "";
+          state.currentOutput = outputText;
+          const llmAttrs = [
+            attrString("gen_ai.system", providerID),
+            attrString("gen_ai.request.model", modelID),
+            attrInt("gen_ai.usage.input_tokens", inputTokens),
+            attrInt("gen_ai.usage.output_tokens", outputTokens)
+          ];
+          if (reasoningTokens > 0) {
+            llmAttrs.push(attrInt("gen_ai.usage.reasoning_tokens", reasoningTokens));
+          }
+          const llmSpan = traceShipper.startSpan({
+            name: modelName,
+            parent: state.currentTurnSpan.ids,
+            eventId: state.eventId,
+            attributes: llmAttrs
+          });
+          if (typeof time["created"] === "number") {
+            llmSpan.startTimeUnixNano = String(time["created"] * 1e6);
+          }
+          const msgError = msgInfo["error"];
+          const errorForSpan = msgError ? `${(_e = (_d = (_c = msgError.data) == null ? void 0 : _c.message) != null ? _d : msgError.name) != null ? _e : "Error"}
+
+type: ${(_f = msgError.name) != null ? _f : "UnknownError"}` : void 0;
+          traceShipper.endSpan(llmSpan, { error: errorForSpan });
+          await eventShipper.patch(state.eventId, {
+            model: modelName,
+            output: outputText || void 0
+          });
+          log("LLM span created", {
+            messageId,
+            modelName,
+            inputTokens,
+            outputTokens,
+            reasoningTokens
+          });
+        } else if (event.type === "session.idle") {
+          if (!sessionID) return;
+          const state = sessions.get(String(sessionID));
+          if (!state) return;
+          if (state.currentTurnSpan) {
+            traceShipper.endSpan(state.currentTurnSpan);
+            state.currentTurnSpan = void 0;
+          }
+          await eventShipper.patch(state.eventId, {
+            output: state.currentOutput || void 0,
+            properties: {
+              turn_count: state.turnNumber,
+              tool_count: state.toolCount
+            }
+          });
+          log("Session idle \u2014 turn span closed", { sessionID });
+        } else if (event.type === "session.deleted") {
+          if (!sessionID) return;
+          const state = sessions.get(String(sessionID));
+          if (!state) return;
+          if (state.currentTurnSpan) {
+            traceShipper.endSpan(state.currentTurnSpan);
+            state.currentTurnSpan = void 0;
+          }
+          traceShipper.endSpan(state.rootSpan);
+          await eventShipper.finish(state.eventId, {
+            output: state.currentOutput || void 0,
+            model: state.model,
+            properties: {
+              turn_count: state.turnNumber,
+              tool_count: state.toolCount
+            }
+          });
+          await Promise.all([eventShipper.flush(), traceShipper.flush()]);
+          sessions.delete(String(sessionID));
+          log("Session deleted \u2014 flushed", { sessionID });
+        } else if (event.type === "session.error") {
+          const errorSessionID = props["sessionID"] || sessionID;
+          if (!errorSessionID) return;
+          const state = sessions.get(String(errorSessionID));
+          if (!state) return;
+          const errorObj = props["error"];
+          const errorName = (_g = errorObj == null ? void 0 : errorObj.name) != null ? _g : "UnknownError";
+          const errorMessage = (_i = (_h = errorObj == null ? void 0 : errorObj.data) == null ? void 0 : _h.message) != null ? _i : errorName;
+          const errorStr = `${errorMessage}
+
+type: ${errorName}`;
+          if (state.currentTurnSpan) {
+            traceShipper.endSpan(state.currentTurnSpan, { error: errorStr });
+            state.currentTurnSpan = void 0;
+          }
+          traceShipper.endSpan(state.rootSpan, { error: errorStr });
+          await eventShipper.finish(state.eventId, {
+            properties: {
+              error: errorStr,
+              turn_count: state.turnNumber,
+              tool_count: state.toolCount
+            }
+          });
+          await Promise.all([eventShipper.flush(), traceShipper.flush()]);
+          sessions.delete(String(errorSessionID));
+          log("Session error handled", { errorSessionID, errorName });
+        } else {
+          log(`unhandled event: ${event.type}`);
+        }
+      } catch (err) {
+        (_k = (_j = client.app.log({
+          body: {
+            service: "raindrop-opencode",
+            level: "error",
+            message: `Error in event hook: ${err instanceof Error ? err.message : String(err)}`
+          }
+        })) == null ? void 0 : _j.catch) == null ? void 0 : _k.call(_j, () => {
+        });
+      }
+    },
+    // ------------------------------------------------------------------
+    // chat.message — user sent a message; start a new turn span
+    // ------------------------------------------------------------------
+    "chat.message": async (messageInput, output) => {
+      var _a;
+      try {
+        const { sessionID } = messageInput;
+        const state = sessions.get(sessionID);
+        if (!state) return;
+        if (state.currentTurnSpan) {
+          traceShipper.endSpan(state.currentTurnSpan);
+          state.currentTurnSpan = void 0;
+        }
+        state.turnNumber++;
+        state.currentOutput = "";
+        const parts = (_a = output == null ? void 0 : output.parts) != null ? _a : [];
+        const textParts = [];
+        const newAttachments = [];
+        for (const part of parts) {
+          if (part["type"] === "text" && typeof part["text"] === "string") {
+            textParts.push(part["text"]);
+          } else if (part["type"] === "file") {
+            const mimeType = part["mediaType"];
+            const filename = part["filename"];
+            const url = part["url"];
+            if (url && (mimeType == null ? void 0 : mimeType.startsWith("image/"))) {
+              newAttachments.push({ type: "image", role: "input", name: filename, value: url });
+            }
+          }
+        }
+        const userText = textParts.join("\n");
+        state.currentInput = userText;
+        if (newAttachments.length > 0) state.attachments.push(...newAttachments);
+        state.currentTurnSpan = traceShipper.startSpan({
+          name: `Turn ${state.turnNumber}`,
+          parent: state.rootSpan.ids,
+          eventId: state.eventId,
+          attributes: [attrInt("turn.number", state.turnNumber)]
+        });
+        await eventShipper.patch(state.eventId, {
+          input: userText || void 0,
+          attachments: newAttachments.length > 0 ? newAttachments : void 0,
+          properties: { turn_count: state.turnNumber }
+        });
+        log("Chat message \u2014 new turn started", {
+          sessionID,
+          turnNumber: state.turnNumber,
+          inputLength: userText.length,
+          attachments: newAttachments.length
+        });
+      } catch (err) {
+        log("Error in chat.message hook", { error: String(err) });
+      }
+    },
+    // ------------------------------------------------------------------
+    // tool.execute.before — record start time and open tool span
+    // ------------------------------------------------------------------
+    "tool.execute.before": async (toolInput, _output) => {
+      try {
+        const { tool, sessionID, callID } = toolInput;
+        const state = sessions.get(sessionID);
+        if (!state || !state.currentTurnSpan) return;
+        state.toolStartTimes.set(callID, Date.now());
+        const toolSpan = traceShipper.startSpan({
+          name: tool,
+          parent: state.currentTurnSpan.ids,
+          eventId: state.eventId,
+          attributes: [attrString("tool.name", tool)]
+        });
+        state.toolSpans.set(callID, toolSpan);
+        log("Tool execute before", { tool, sessionID, callID });
+      } catch (err) {
+        log("Error in tool.execute.before hook", { error: String(err) });
+      }
+    },
+    // ------------------------------------------------------------------
+    // tool.execute.after — finalize tool span
+    // ------------------------------------------------------------------
+    "tool.execute.after": async (toolInput, result) => {
+      var _a;
+      try {
+        const { tool, sessionID, callID } = toolInput;
+        const state = sessions.get(sessionID);
+        if (!state) return;
+        state.toolCount++;
+        state.toolStartTimes.delete(callID);
+        state.toolCallMessageIds.delete(callID);
+        const toolSpan = state.toolSpans.get(callID);
+        state.toolSpans.delete(callID);
+        if (toolSpan) {
+          const outputPreview = typeof result.output === "string" ? result.output.slice(0, 200) : JSON.stringify((_a = result.output) != null ? _a : "").slice(0, 200);
+          traceShipper.endSpan(toolSpan, {
+            attributes: [
+              attrString("tool.title", result.title),
+              attrString("tool.output_preview", outputPreview)
+            ]
+          });
+        }
+        await eventShipper.patch(state.eventId, {
+          properties: { tool_count: state.toolCount }
+        });
+        log("Tool execute after", { tool, sessionID, callID });
+      } catch (err) {
+        log("Error in tool.execute.after hook", { error: String(err) });
+      }
+    }
+  };
+}
+
+// src/index.ts
+async function plugin(input) {
+  var _a;
+  const { client } = input;
+  const config = loadConfig(input.directory);
+  function appLog(level, message) {
+    var _a2, _b;
+    (_b = (_a2 = client.app.log({
+      body: {
+        service: "raindrop-opencode",
+        level,
+        message
+      }
+    })) == null ? void 0 : _a2.catch) == null ? void 0 : _b.call(_a2, () => {
+    });
+  }
+  if (!config.writeKey) {
+    appLog(
+      "warn",
+      "RAINDROP_WRITE_KEY not set \u2014 Raindrop tracing disabled. Set it in your environment or in ~/.config/opencode/raindrop.json."
+    );
+    return { hooks: {} };
+  }
+  if (config.debug) {
+    appLog("info", `Raindrop tracing enabled (endpoint: ${config.endpoint})`);
+  }
+  const eventShipper = new EventShipper({
+    writeKey: config.writeKey,
+    endpoint: config.endpoint,
+    debug: config.debug
+  });
+  const traceShipper = new TraceShipper({
+    writeKey: config.writeKey,
+    endpoint: config.endpoint,
+    debug: config.debug
+  });
+  const worktree = (_a = input.worktree) != null ? _a : input.directory;
+  const hooks = createHooks(
+    client,
+    config,
+    worktree,
+    input.directory,
+    eventShipper,
+    traceShipper
+  );
+  return { hooks };
+}