@raindrop-ai/opencode-plugin 0.1.3 → 0.2.0

package/dist/v2.js

@@ -0,0 +1,761 @@
+import {
+  EventShipper,
+  PLUGIN_NAME,
+  PLUGIN_VERSION,
+  TraceShipper,
+  attrString,
+  boundedStringify,
+  buildLlmGenAiAttributes,
+  capText,
+  createAppGitContext,
+  generateId,
+  loadConfig,
+  resolveLocalDebuggerBaseUrl
+} from "./chunk-4DAI6CYK.js";
+
+// src/v2.ts
+import { Plugin } from "@opencode/plugin";
+
+// src/tracing-v2.ts
+import { hostname as osHostname } from "os";
+var ERROR_LOG_INTERVAL_MS = 3e4;
+var lastErrorLogAt = /* @__PURE__ */ new Map();
+function rateLimitedErrorLog(key, message) {
+  const now = Date.now();
+  const last = lastErrorLogAt.get(key);
+  if (last !== void 0 && now - last < ERROR_LOG_INTERVAL_MS) return;
+  lastErrorLogAt.set(key, now);
+  console.log(message);
+}
+function unwrapQuotes(s) {
+  if (s.length < 2) return s;
+  const first = s[0];
+  const last = s[s.length - 1];
+  if ((first === '"' || first === "'") && first === last) return s.slice(1, -1);
+  return s;
+}
+function buildPromptMessages(systemPrompt, userInput) {
+  const messages = [];
+  if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
+  messages.push({ role: "user", content: unwrapQuotes(userInput) });
+  return JSON.stringify(messages);
+}
+function getHostname() {
+  var _a;
+  try {
+    const bunGlobal = globalThis;
+    if ((_a = bunGlobal.Bun) == null ? void 0 : _a.hostname) return bunGlobal.Bun.hostname;
+    return osHostname();
+  } catch (e) {
+    const h = process.env["HOSTNAME"];
+    if (h === void 0 || h === "") throw new Error("HOSTNAME env is not set");
+    return h;
+  }
+}
+function msToNs(ms) {
+  return `${String(Math.floor(ms))}000000`;
+}
+var IMAGE_NAME_RE = /\.(png|jpe?g|gif|webp|bmp|avif|svg)$/i;
+function isImageAttachment(file) {
+  var _a;
+  if (file.uri.startsWith("data:image/")) return true;
+  return IMAGE_NAME_RE.test((_a = file.name) != null ? _a : "") || IMAGE_NAME_RE.test(file.uri);
+}
+function errorString(error) {
+  return `${error.message}
+
+type: ${error.type}`;
+}
+function createV2Tracing(config, eventShipper, traceShipper, sessionLookup) {
+  const sessions = /* @__PURE__ */ new Map();
+  const admittedPrompts = /* @__PURE__ */ new Map();
+  const subagentLinks = /* @__PURE__ */ new Map();
+  const hostname = getHostname();
+  const os = process.platform;
+  function getOrCreateState(sessionID) {
+    let state = sessions.get(sessionID);
+    if (!state) {
+      state = {
+        sessionId: sessionID,
+        input: "",
+        outputParts: /* @__PURE__ */ new Map(),
+        reasoningParts: /* @__PURE__ */ new Map(),
+        turnOutputParts: [],
+        turnOutputTokens: 0,
+        turnInputTokens: 0,
+        stepSpans: /* @__PURE__ */ new Map(),
+        toolStarts: /* @__PURE__ */ new Map(),
+        toolNames: /* @__PURE__ */ new Map()
+      };
+      sessions.set(sessionID, state);
+    }
+    return state;
+  }
+  function unlinkedSubagentParent(parent) {
+    var _a, _b;
+    const running = [...parent.toolStarts.values()].at(-1);
+    return (_b = running == null ? void 0 : running.span.ids) != null ? _b : (_a = parent.rootSpan) == null ? void 0 : _a.ids;
+  }
+  function systemPromptAttrs(state) {
+    if (!state.systemPrompt) return [];
+    return [
+      attrString("gen_ai.prompt.0.role", "system"),
+      attrString("gen_ai.prompt.0.content", state.systemPrompt)
+    ];
+  }
+  async function finalizeTurn(state, error) {
+    var _a, _b, _c;
+    for (const step of state.stepSpans.values()) {
+      traceShipper.endSpan(step.span);
+    }
+    state.stepSpans.clear();
+    if (state.compactionSpan) {
+      traceShipper.endSpan(state.compactionSpan);
+      state.compactionSpan = void 0;
+    }
+    for (const start of state.toolStarts.values()) {
+      traceShipper.endSpan(start.span);
+    }
+    state.toolStarts.clear();
+    state.outputParts.clear();
+    state.reasoningParts.clear();
+    state.toolNames.clear();
+    if (state.rootSpan) {
+      const attrs = [];
+      if (state.parentId) {
+        attrs.push(
+          attrString("is_subagent", "true"),
+          attrString("parent_session_id", state.parentId)
+        );
+      }
+      attrs.push(attrString("message_id", state.lastAssistantMessageId));
+      traceShipper.endSpan(state.rootSpan, {
+        attributes: attrs,
+        error
+      });
+      state.rootSpan = void 0;
+    }
+    const eventId = state.eventId;
+    state.eventId = void 0;
+    if (eventId && !state.parentId) {
+      const turnOutput = capText(state.turnOutputParts.join("\n\n"));
+      await eventShipper.finish(eventId, {
+        userId: (_b = (_a = state.eventMetadata) == null ? void 0 : _a.userId) != null ? _b : state.sessionId,
+        model: (_c = state.lastModel) == null ? void 0 : _c.modelID,
+        output: turnOutput.length > 0 ? turnOutput : void 0,
+        usage: {
+          promptTokens: state.turnInputTokens,
+          completionTokens: state.turnOutputTokens
+        },
+        error: error ? { message: error } : void 0,
+        properties: {
+          plugin_version: PLUGIN_VERSION,
+          opencode_version: "v2",
+          ...state.lastModel ? { "ai.provider": state.lastModel.providerID } : {},
+          ...state.lastAssistantMessageId ? { message_id: state.lastAssistantMessageId } : {}
+        }
+      });
+    }
+    await Promise.all([eventShipper.flush(), traceShipper.flush()]);
+  }
+  return {
+    currentEventId(sessionID) {
+      var _a;
+      return (_a = sessions.get(sessionID)) == null ? void 0 : _a.eventId;
+    },
+    // ------------------------------------------------------------------
+    // prompt hook — record the admitted prompt; the turn opens on delivery
+    // ------------------------------------------------------------------
+    onPrompt(input, directory) {
+      var _a, _b, _c;
+      try {
+        const textParts = [];
+        const attachments = [];
+        const prompt = input.prompt;
+        if (typeof prompt.text === "string" && prompt.text.length > 0) {
+          textParts.push(prompt.text);
+        }
+        for (const file of (_a = prompt.files) != null ? _a : []) {
+          if (isImageAttachment(file)) {
+            attachments.push({
+              type: "image",
+              role: "input",
+              name: file.name,
+              value: file.uri
+            });
+          }
+        }
+        const baseMeta = { ...config.eventMetadata };
+        const promptMeta = {};
+        const meta = input.metadata;
+        if (meta != null && typeof meta === "object") {
+          if (typeof meta["userId"] === "string") promptMeta.userId = meta["userId"];
+          if (typeof meta["eventName"] === "string") promptMeta.eventName = meta["eventName"];
+          if (meta["properties"] != null && typeof meta["properties"] === "object")
+            promptMeta.properties = meta["properties"];
+        }
+        admittedPrompts.set(input.messageID, {
+          sessionID: input.sessionID,
+          directory,
+          text: capText(textParts.join("\n")),
+          attachments,
+          eventMetadata: {
+            ...baseMeta,
+            ...promptMeta,
+            properties: baseMeta.properties || promptMeta.properties ? { ...(_b = baseMeta.properties) != null ? _b : {}, ...(_c = promptMeta.properties) != null ? _c : {} } : void 0
+          }
+        });
+      } catch (err) {
+        rateLimitedErrorLog(
+          "prompt",
+          `[raindrop-ai/opencode-plugin] [error] Error in prompt hook: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    },
+    onContext(input) {
+      onContextImpl(input);
+    },
+    onEvent(event) {
+      return onEventImpl(event);
+    }
+  };
+  async function startTurn(prompt, deliveredAt) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const sessionID = prompt.sessionID;
+    const directory = prompt.directory;
+    const state = getOrCreateState(sessionID);
+    const link = subagentLinks.get(sessionID);
+    subagentLinks.delete(sessionID);
+    if (link) state.parentId = link.parentSessionId;
+    if (state.parentId === void 0 && sessionLookup) {
+      try {
+        const info = await sessionLookup(sessionID);
+        if (info == null ? void 0 : info.parentID) state.parentId = info.parentID;
+      } catch (e) {
+      }
+    }
+    if (state.eventId || state.rootSpan) {
+      await finalizeTurn(state);
+    }
+    state.eventMetadata = prompt.eventMetadata;
+    const userText = prompt.text;
+    const newAttachments = prompt.attachments;
+    state.input = userText;
+    state.turnOutputParts = [];
+    state.turnOutputTokens = 0;
+    state.turnInputTokens = 0;
+    state.lastModel = void 0;
+    state.lastAssistantMessageId = void 0;
+    state.outputParts.clear();
+    state.reasoningParts.clear();
+    state.toolNames.clear();
+    if (state.parentId) {
+      const parent = sessions.get(state.parentId);
+      const eventId = (_a = link == null ? void 0 : link.eventId) != null ? _a : parent == null ? void 0 : parent.eventId;
+      const parentSpan = (_b = link == null ? void 0 : link.toolSpan) != null ? _b : parent ? unlinkedSubagentParent(parent) : void 0;
+      if (!eventId || !parentSpan) return;
+      state.eventId = eventId;
+      state.rootSpan = traceShipper.startSpan({
+        name: "Subagent",
+        parent: parentSpan,
+        eventId: state.eventId,
+        startTimeUnixNano: msToNs(deliveredAt),
+        operationId: "ai.subagent",
+        attributes: [
+          attrString("workspace", directory),
+          attrString("directory", directory),
+          attrString("hostname", hostname),
+          attrString("os", os),
+          attrString("is_subagent", "true"),
+          attrString("parent_session_id", state.parentId)
+        ]
+      });
+      return;
+    }
+    state.eventId = generateId();
+    state.rootSpan = traceShipper.startSpan({
+      name: "ai.event",
+      eventId: state.eventId,
+      startTimeUnixNano: msToNs(deliveredAt),
+      operationId: "ai.event",
+      attributes: [
+        attrString("workspace", directory),
+        attrString("directory", directory),
+        attrString("hostname", hostname),
+        attrString("os", os)
+      ]
+    });
+    await eventShipper.patch(state.eventId, {
+      isPending: true,
+      userId: (_d = (_c = state.eventMetadata) == null ? void 0 : _c.userId) != null ? _d : state.sessionId,
+      convoId: state.sessionId,
+      eventName: (_f = (_e = state.eventMetadata) == null ? void 0 : _e.eventName) != null ? _f : config.eventName,
+      input: userText,
+      ...newAttachments.length > 0 ? { attachments: newAttachments } : {},
+      properties: {
+        workspace: directory,
+        directory,
+        hostname,
+        os,
+        plugin_version: PLUGIN_VERSION,
+        opencode_version: "v2",
+        ...(_g = state.eventMetadata) == null ? void 0 : _g.properties
+      }
+    });
+  }
+  function onContextImpl(input) {
+    try {
+      if (!config.captureSystemPrompt) return;
+      const state = getOrCreateState(input.sessionID);
+      const MAX_SYSTEM_PROMPT_LENGTH = 32768;
+      const TRUNCATION_MARKER = "\n...[truncated]";
+      const joined = input.system.map((part) => part.text).join("\n\n");
+      state.systemPrompt = joined.length > MAX_SYSTEM_PROMPT_LENGTH ? joined.slice(0, MAX_SYSTEM_PROMPT_LENGTH - TRUNCATION_MARKER.length) + TRUNCATION_MARKER : joined;
+    } catch (err) {
+      rateLimitedErrorLog(
+        "context",
+        `[raindrop-ai/opencode-plugin] [error] Error in context hook: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  async function onEventImpl(event) {
+    var _a, _b, _c, _d, _e;
+    switch (event.type) {
+      case "session.created": {
+        const data = event.data;
+        const state = getOrCreateState(data.sessionID);
+        state.parentId = data.parentID;
+        break;
+      }
+      case "session.inbox.delivered": {
+        const prompt = admittedPrompts.get(event.data.inboxID);
+        if (!prompt) return;
+        admittedPrompts.delete(event.data.inboxID);
+        await startTurn(prompt, event.created);
+        break;
+      }
+      case "session.inbox.cancelled": {
+        admittedPrompts.delete(event.data.inboxID);
+        break;
+      }
+      case "session.step.started": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        if (!state || !state.eventId) return;
+        const parent = (_a = state.rootSpan) == null ? void 0 : _a.ids;
+        if (!parent) return;
+        const span = traceShipper.startSpan({
+          name: `${data.model.providerID}/${data.model.id}`,
+          parent,
+          eventId: state.eventId,
+          startTimeUnixNano: msToNs(data.started),
+          attributes: [
+            attrString("ai.operationId", "generateText"),
+            attrString("ai.prompt", unwrapQuotes(state.input)),
+            attrString(
+              "ai.prompt.messages",
+              buildPromptMessages(state.systemPrompt, state.input)
+            )
+          ]
+        });
+        state.stepSpans.set(data.assistantMessageID, {
+          span,
+          providerID: data.model.providerID,
+          modelID: data.model.id
+        });
+        break;
+      }
+      case "session.step.ended": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        const step = state == null ? void 0 : state.stepSpans.get(data.assistantMessageID);
+        if (!state || !step) return;
+        state.stepSpans.delete(data.assistantMessageID);
+        const text = state.outputParts.get(data.assistantMessageID);
+        if (text !== void 0 && text.trim().length > 0) {
+          state.turnOutputParts.push(text);
+        }
+        state.turnOutputTokens += data.tokens.output;
+        state.turnInputTokens = data.tokens.input;
+        state.lastModel = { providerID: step.providerID, modelID: step.modelID };
+        state.lastAssistantMessageId = data.assistantMessageID;
+        const attrs = [
+          attrString("ai.response.text", text !== void 0 ? capText(text) : void 0),
+          ...systemPromptAttrs(state),
+          ...buildLlmGenAiAttributes({
+            providerID: step.providerID,
+            modelID: step.modelID,
+            tokens: data.tokens
+          })
+        ];
+        const reasoning = state.reasoningParts.get(data.assistantMessageID);
+        if (reasoning !== void 0) {
+          attrs.push(attrString("ai.reasoning.text", reasoning));
+        }
+        traceShipper.endSpan(step.span, { attributes: attrs });
+        break;
+      }
+      case "session.step.failed": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        const step = state == null ? void 0 : state.stepSpans.get(data.assistantMessageID);
+        if (!state || !step) return;
+        state.stepSpans.delete(data.assistantMessageID);
+        traceShipper.endSpan(step.span, { error: errorString(data.error) });
+        break;
+      }
+      case "session.text.ended": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        if (!state) return;
+        const prev = (_b = state.outputParts.get(data.assistantMessageID)) != null ? _b : "";
+        state.outputParts.set(data.assistantMessageID, capText(prev + data.text));
+        break;
+      }
+      case "session.reasoning.ended": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        if (!state) return;
+        const prev = (_c = state.reasoningParts.get(data.assistantMessageID)) != null ? _c : "";
+        state.reasoningParts.set(data.assistantMessageID, capText(prev + data.text));
+        break;
+      }
+      case "session.tool.input.started": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        if (!state) return;
+        state.toolNames.set(data.id, data.name);
+        break;
+      }
+      case "session.tool.called": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        if (!state || !state.eventId) return;
+        const parent = (_d = state.rootSpan) == null ? void 0 : _d.ids;
+        if (!parent) return;
+        const name = (_e = state.toolNames.get(data.id)) != null ? _e : "tool";
+        const span = traceShipper.startSpan({
+          name: "ai.toolCall",
+          parent,
+          eventId: state.eventId,
+          startTimeUnixNano: msToNs(event.created),
+          attributes: [
+            attrString("ai.operationId", "ai.toolCall"),
+            attrString("ai.toolCall.name", name),
+            attrString("ai.toolCall.id", data.id)
+          ]
+        });
+        state.toolStarts.set(data.id, {
+          span,
+          name,
+          input: boundedStringify(data.input)
+        });
+        break;
+      }
+      case "session.tool.progress": {
+        const data = event.data;
+        const childSessionId = data.metadata["sessionID"];
+        if (typeof childSessionId !== "string") return;
+        const state = sessions.get(data.sessionID);
+        const start = state == null ? void 0 : state.toolStarts.get(data.id);
+        if (!(state == null ? void 0 : state.eventId) || !start) return;
+        subagentLinks.set(childSessionId, {
+          parentSessionId: data.sessionID,
+          toolSpan: start.span.ids,
+          eventId: state.eventId
+        });
+        break;
+      }
+      case "session.tool.success": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        const start = state == null ? void 0 : state.toolStarts.get(data.id);
+        if (!state || !start) return;
+        state.toolStarts.delete(data.id);
+        traceShipper.endSpan(start.span, {
+          attributes: [
+            attrString("ai.toolCall.args", start.input),
+            attrString("ai.toolCall.result", boundedStringify(data.content))
+          ]
+        });
+        break;
+      }
+      case "session.tool.failed": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        const start = state == null ? void 0 : state.toolStarts.get(data.id);
+        if (!state || !start) return;
+        state.toolStarts.delete(data.id);
+        traceShipper.endSpan(start.span, {
+          attributes: [
+            attrString("ai.toolCall.args", start.input),
+            attrString("error.message", data.error.message),
+            ...data.content !== void 0 ? [attrString("ai.toolCall.result", boundedStringify(data.content))] : []
+          ],
+          error: errorString(data.error)
+        });
+        break;
+      }
+      case "session.compaction.started": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        if (!state || !state.eventId || !state.rootSpan) return;
+        state.compactionSpan = traceShipper.startSpan({
+          name: "ai.compaction",
+          parent: state.rootSpan.ids,
+          eventId: state.eventId,
+          attributes: [
+            attrString("ai.operationId", "ai.compaction"),
+            attrString("ai.compaction.reason", data.reason)
+          ]
+        });
+        break;
+      }
+      case "session.compaction.ended": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        if (!state || !state.compactionSpan) return;
+        const span = state.compactionSpan;
+        state.compactionSpan = void 0;
+        const attrs = [
+          attrString("ai.response.text", capText(data.text))
+        ];
+        if (data.model && data.tokens) {
+          attrs.push(
+            ...buildLlmGenAiAttributes({
+              providerID: data.model.providerID,
+              modelID: data.model.id,
+              tokens: data.tokens
+            })
+          );
+        }
+        if (data.cost !== void 0) {
+          attrs.push(attrString("ai.compaction.cost", String(data.cost)));
+        }
+        traceShipper.endSpan(span, { attributes: attrs });
+        break;
+      }
+      case "session.compaction.failed": {
+        const data = event.data;
+        const state = sessions.get(data.sessionID);
+        if (!state || !state.compactionSpan) return;
+        traceShipper.endSpan(state.compactionSpan, {
+          error: errorString(data.error)
+        });
+        state.compactionSpan = void 0;
+        break;
+      }
+      case "session.execution.succeeded": {
+        const state = sessions.get(event.data.sessionID);
+        if (!state) return;
+        await finalizeTurn(state);
+        break;
+      }
+      case "session.execution.interrupted": {
+        const state = sessions.get(event.data.sessionID);
+        if (!state) return;
+        await finalizeTurn(state);
+        break;
+      }
+      case "session.execution.failed": {
+        const state = sessions.get(event.data.sessionID);
+        if (!state) return;
+        await finalizeTurn(state, errorString(event.data.error));
+        break;
+      }
+      case "session.deleted": {
+        for (const [messageID, prompt] of admittedPrompts) {
+          if (prompt.sessionID === event.data.sessionID) admittedPrompts.delete(messageID);
+        }
+        subagentLinks.delete(event.data.sessionID);
+        const state = sessions.get(event.data.sessionID);
+        if (!state) return;
+        if (state.eventId || state.rootSpan) {
+          try {
+            await finalizeTurn(state);
+          } catch (e) {
+          }
+        }
+        sessions.delete(event.data.sessionID);
+        break;
+      }
+    }
+  }
+}
+
+// src/v2.ts
+var RESUBSCRIBE_DELAY_MS = 1e3;
+function appLog(level, message) {
+  console.log(`[raindrop-ai/opencode-plugin] [${level}] ${message}`);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function firstInstance(s) {
+  for (const instance of s.instances) return instance;
+  return void 0;
+}
+async function disposeAll(disposables) {
+  for (const disposable of [...disposables].reverse()) {
+    try {
+      await disposable.dispose();
+    } catch (e) {
+    }
+  }
+  disposables.length = 0;
+}
+function raindrop(opts = {}) {
+  let shared;
+  async function shutdownShared() {
+    const s = shared;
+    if (!s) return;
+    shared = void 0;
+    for (const instance of s.instances) await disposeAll(instance.disposables);
+    s.instances.clear();
+    s.abort.abort();
+    try {
+      await Promise.all([s.eventShipper.shutdown(), s.traceShipper.shutdown()]);
+    } finally {
+      try {
+        s.appGitContext.dispose();
+      } catch (e) {
+      }
+    }
+  }
+  async function removeInstance(s, instance) {
+    await disposeAll(instance.disposables);
+    s.instances.delete(instance);
+    if (shared === s && s.instances.size === 0) await shutdownShared();
+  }
+  async function runEventLoop(s) {
+    while (!s.abort.signal.aborted) {
+      const instance = firstInstance(s);
+      if (!instance) return;
+      try {
+        for await (const event of instance.ctx.event.subscribe({ signal: s.abort.signal })) {
+          try {
+            await s.runtime.onEvent(event);
+          } catch (err) {
+            rateLimitedErrorLog(
+              "event",
+              `[raindrop-ai/opencode-plugin] [error] Error in event dispatch: ${errorMessage(err)}`
+            );
+          }
+        }
+      } catch (err) {
+        if (s.abort.signal.aborted) return;
+        rateLimitedErrorLog(
+          "subscribe",
+          `[raindrop-ai/opencode-plugin] [error] Event subscription ended, resubscribing: ${errorMessage(err)}`
+        );
+      }
+      if (s.abort.signal.aborted) return;
+      await new Promise((resolve) => setTimeout(resolve, RESUBSCRIBE_DELAY_MS).unref());
+    }
+  }
+  function createShared(ctx) {
+    var _a, _b, _c;
+    const config = loadConfig((_a = opts.directory) != null ? _a : ctx.location.directory);
+    const resolvedLocalUrl = resolveLocalDebuggerBaseUrl(config.localWorkshopUrl);
+    const hasLocalDestination = resolvedLocalUrl !== null;
+    if (!config.writeKey && !hasLocalDestination) {
+      appLog(
+        "warn",
+        "RAINDROP_WRITE_KEY not set and no local Workshop daemon detected \u2014 Raindrop tracing disabled. Set RAINDROP_WRITE_KEY for cloud, or RAINDROP_LOCAL_WORKSHOP_URL / RAINDROP_LOCAL_DEBUGGER for local-only mode."
+      );
+      return void 0;
+    }
+    if (config.debug) {
+      const destinations = [
+        config.writeKey ? `cloud (${config.endpoint})` : null,
+        resolvedLocalUrl ? `local Workshop (${resolvedLocalUrl})` : null
+      ].filter(Boolean);
+      appLog("info", `Raindrop tracing enabled \u2014 destinations: ${destinations.join(", ")}`);
+    }
+    const configuredAppGit = (_b = opts.appGit) != null ? _b : config.appGit;
+    const appGitContext = createAppGitContext(
+      ((_c = config.writeKey) == null ? void 0 : _c.trim()) || hasLocalDestination ? configuredAppGit : false,
+      { allowLocalGit: false }
+    );
+    const shipperOptions = {
+      writeKey: config.writeKey,
+      endpoint: config.endpoint,
+      debug: config.debug,
+      projectId: config.projectId,
+      localDebuggerUrl: config.localWorkshopUrl,
+      appGitContext
+    };
+    const eventShipper = new EventShipper(shipperOptions);
+    const traceShipper = new TraceShipper(shipperOptions);
+    const s = {
+      eventShipper,
+      traceShipper,
+      appGitContext,
+      abort: new AbortController(),
+      instances: /* @__PURE__ */ new Set(),
+      runtime: createV2Tracing(config, eventShipper, traceShipper, async (sessionID) => {
+        const instance = firstInstance(s);
+        if (!instance) return void 0;
+        const info = await instance.ctx.session.get({ sessionID });
+        return { parentID: info.parentID };
+      })
+    };
+    return s;
+  }
+  const handle = {
+    users: {
+      async identify(users) {
+        await (shared == null ? void 0 : shared.eventShipper.identify(users));
+      }
+    },
+    signals: {
+      async track(signal) {
+        await (shared == null ? void 0 : shared.eventShipper.trackSignal(signal));
+      }
+    },
+    currentEventId(sessionID) {
+      return shared == null ? void 0 : shared.runtime.currentEventId(sessionID);
+    },
+    async flush() {
+      const s = shared;
+      if (!s) return;
+      await Promise.all([s.eventShipper.flush(), s.traceShipper.flush()]);
+    },
+    async shutdown() {
+      await shutdownShared();
+    }
+  };
+  const plugin = Plugin.define({
+    id: "raindrop",
+    async setup(ctx) {
+      appLog("info", `Loading ${PLUGIN_NAME} v${PLUGIN_VERSION} (v2)`);
+      let s;
+      const instance = { ctx, disposables: [] };
+      try {
+        s = shared != null ? shared : createShared(ctx);
+        if (!s) return;
+        const isFirst = shared === void 0;
+        shared = s;
+        s.instances.add(instance);
+        const runtime = s.runtime;
+        const directory = ctx.location.directory;
+        instance.disposables.push(await ctx.session.hook("prompt", (e) => runtime.onPrompt(e, directory)));
+        instance.disposables.push(await ctx.session.hook("context", (e) => runtime.onContext(e)));
+        if (isFirst) void runEventLoop(s);
+        const owner = s;
+        return async () => {
+          await removeInstance(owner, instance);
+        };
+      } catch (err) {
+        rateLimitedErrorLog("setup", `[raindrop-ai/opencode-plugin] [error] Setup failed: ${errorMessage(err)}`);
+        if (s) await removeInstance(s, instance);
+        return () => {
+        };
+      }
+    }
+  });
+  return Object.assign(plugin, { raindrop: handle });
+}
+export {
+  raindrop as default
+};