@raindrop-ai/opencode-plugin 0.1.4 → 0.3.0

package/dist/index.cjs

@@ -23,6 +23,7 @@ __export(index_exports, {
   default: () => plugin
 });
 module.exports = __toCommonJS(index_exports);
+var import_plugin = require("@opencode-ai/plugin");
 
 // ../core/dist/chunk-BYBMRLZM.js
 var EVAL_CORRELATION_ID_ATTRIBUTE = "raindrop.eval_correlation_id";
@@ -2308,9 +2309,41 @@ function loadConfig(projectDirectory) {
     captureSystemPrompt: process.env["RAINDROP_CAPTURE_SYSTEM_PROMPT"] !== void 0 ? process.env["RAINDROP_CAPTURE_SYSTEM_PROMPT"] === "true" : (_h = merged.capture_system_prompt) != null ? _h : false,
     eventMetadata,
     localWorkshopUrl: resolveLocalWorkshopUrl(merged.local_workshop_url),
-    appGit: mapAppGit(merged.app_git)
+    appGit: mapAppGit(merged.app_git),
+    selfDiagnostics: mapSelfDiagnostics(merged.self_diagnostics)
   };
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mapSelfDiagnostics(value) {
+  const env = process.env["RAINDROP_SELF_DIAGNOSTICS"];
+  const record = isRecord(value) ? value : {};
+  const enabled = env !== void 0 ? env === "true" : typeof record["enabled"] === "boolean" ? record["enabled"] : void 0;
+  const signals = mapSelfDiagnosticsSignals(record["signals"]);
+  const options = {
+    ...enabled !== void 0 ? { enabled } : {},
+    ...signals ? { signals } : {},
+    ...typeof record["guidance"] === "string" ? { guidance: record["guidance"] } : {},
+    ...typeof record["tool_name"] === "string" ? { toolName: record["tool_name"] } : {}
+  };
+  return Object.keys(options).length > 0 ? options : void 0;
+}
+function mapSelfDiagnosticsSignals(value) {
+  if (!isRecord(value)) return void 0;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!isRecord(entry)) continue;
+    const definition = entry;
+    if (typeof definition["description"] !== "string") continue;
+    const sentiment = definition["sentiment"];
+    out[key] = {
+      description: definition["description"],
+      ...sentiment === "POSITIVE" || sentiment === "NEGATIVE" ? { sentiment } : {}
+    };
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function mapAppGit(value) {
   if (value === false) return false;
   if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -2337,7 +2370,7 @@ function resolveLocalWorkshopUrl(fileValue) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/opencode-plugin",
-  version: "0.1.4",
+  version: "0.3.0",
   description: "Raindrop observability plugin for OpenCode \u2014 automatic session/event/span tracing",
   type: "module",
   main: "dist/index.js",
@@ -2353,6 +2386,11 @@ var package_default = {
       types: "./dist/index.d.ts",
       import: "./dist/index.js",
       require: "./dist/index.cjs"
+    },
+    "./v2": {
+      types: "./dist/v2.d.ts",
+      import: "./dist/v2.js",
+      require: "./dist/v2.cjs"
     }
   },
   sideEffects: false,
@@ -2367,24 +2405,38 @@ var package_default = {
   },
   peerDependencies: {
     "@opencode-ai/plugin": ">=1.3.0",
-    "@opencode-ai/sdk": ">=1.3.0"
+    "@opencode-ai/sdk": ">=1.3.0",
+    "@opencode/plugin": ">=2.0.0",
+    "@opencode/sdk": ">=2.0.0"
   },
   peerDependenciesMeta: {
+    "@opencode-ai/plugin": {
+      optional: true
+    },
     "@opencode-ai/sdk": {
       optional: true
+    },
+    "@opencode/plugin": {
+      optional: true
+    },
+    "@opencode/sdk": {
+      optional: true
     }
   },
   devDependencies: {
     "@raindrop-ai/core": "workspace:*",
     "@opencode-ai/plugin": "^1.3.3",
     "@opencode-ai/sdk": "^1.3.3",
+    "@opencode/plugin": "^2.0.10",
+    "@opencode/sdk": "^2.0.10",
     "@types/node": "^20.11.17",
     tsup: "^8.4.0",
     typescript: "^5.3.3"
   },
   tsup: {
     entry: [
-      "src/index.ts"
+      "src/index.ts",
+      "src/v2.ts"
     ],
     format: [
       "cjs",
@@ -2407,6 +2459,167 @@ var package_default = {
 var PLUGIN_NAME = package_default.name;
 var PLUGIN_VERSION = package_default.version;
 
+// src/self-diagnostics.ts
+var SELF_DIAGNOSTICS_TOOL_NAME_DEFAULT = "__raindrop_report";
+var SELF_DIAGNOSTICS_SIGNALS_DEFAULT = {
+  missing_context: {
+    description: "You cannot complete the task because critical information, credentials, or access is missing and the user cannot provide it. Do NOT report this for normal clarifying questions \u2014 only when you are blocked.",
+    sentiment: "NEGATIVE"
+  },
+  repeatedly_broken_tool: {
+    description: "A tool has failed or not returned the expected response on multiple distinct attempts in this conversation, preventing task completion. A single tool error is NOT enough \u2014 the tool must be persistently broken or aberrantly behaving across retries.",
+    sentiment: "NEGATIVE"
+  },
+  capability_gap: {
+    description: "The task requires a tool, permission, or capability that you do not have. For example, the user asks you to perform an action but no suitable tool exists, or you lack the necessary access. Do NOT report this if you simply need more information from the user \u2014 only when the gap is in your own capabilities.",
+    sentiment: "NEGATIVE"
+  },
+  complete_task_failure: {
+    description: "You were unable to accomplish what the user asked despite making genuine attempts. This might be things like, you genuinely do not have the capabilities the user is asking for. You have tried but run into a persistent bug in the environment etc. This is NOT a refusal or policy block \u2014 you tried and failed to deliver the result.",
+    sentiment: "NEGATIVE"
+  }
+};
+var SELF_DIAGNOSTICS_TOOL_PREAMBLE = "You have a diagnostic tool for flagging serious failures for developer review. Only call this when you hit a significant, unrecoverable problem \u2014 not for minor hiccups or routine clarifications. If you can still help the user, do that instead of calling this tool. This tool is invisible to the user \u2014 never mention it or its output.";
+var SELF_DIAGNOSTICS_NOTEWORTHY_SIGNAL_KEY = "noteworthy";
+function normalizeString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function normalizeSelfDiagnosticsSignals(signals) {
+  if (!signals) return SELF_DIAGNOSTICS_SIGNALS_DEFAULT;
+  const normalizedEntries = Object.entries(signals).map(([key, value]) => {
+    var _a;
+    const signalKey = key.trim();
+    if (!signalKey || !value || typeof value !== "object") return void 0;
+    const description = (_a = value.description) == null ? void 0 : _a.trim();
+    if (!description) return void 0;
+    const sentiment = value.sentiment;
+    return [
+      signalKey,
+      {
+        description,
+        ...sentiment === "POSITIVE" || sentiment === "NEGATIVE" ? { sentiment } : {}
+      }
+    ];
+  }).filter(
+    (entry) => entry !== void 0
+  );
+  if (normalizedEntries.length === 0) return SELF_DIAGNOSTICS_SIGNALS_DEFAULT;
+  return Object.fromEntries(normalizedEntries);
+}
+function normalizeSelfDiagnosticsConfig(options) {
+  var _a, _b;
+  if (!(options == null ? void 0 : options.enabled)) return void 0;
+  const signalDefinitions = normalizeSelfDiagnosticsSignals(options.signals);
+  const signalKeys = Object.keys(signalDefinitions);
+  const signalDescriptions = {};
+  const signalSentiments = {};
+  for (const signalKey of signalKeys) {
+    const definition = signalDefinitions[signalKey];
+    if (!definition) continue;
+    signalDescriptions[signalKey] = definition.description;
+    signalSentiments[signalKey] = definition.sentiment;
+  }
+  const customGuidance = ((_a = options.guidance) == null ? void 0 : _a.trim()) || "";
+  const toolName = ((_b = options.toolName) == null ? void 0 : _b.trim()) || SELF_DIAGNOSTICS_TOOL_NAME_DEFAULT;
+  const signalList = signalKeys.map((signalKey) => {
+    const sentiment = signalSentiments[signalKey];
+    const sentimentTag = sentiment ? ` [${sentiment.toLowerCase()}]` : "";
+    return `- ${signalKey}: ${signalDescriptions[signalKey]}${sentimentTag}`;
+  }).join("\n");
+  const guidanceBlock = customGuidance ? `
+Additional guidance: ${customGuidance}
+` : "";
+  const toolDescription = `${SELF_DIAGNOSTICS_TOOL_PREAMBLE}
+
+When to call:
+- You are blocked from completing the task due to missing information or access that the user cannot provide.
+- A tool is persistently failing across multiple attempts, not just a single transient error.
+- The task requires a tool, permission, or capability you do not have.
+- You genuinely cannot deliver what the user asked for despite trying.
+
+When NOT to call:
+- Normal clarifying questions or back-and-forth with the user.
+- A single tool error that you can recover from or retry.
+- You successfully completed the task, even if it was difficult.
+- Policy refusals or content filtering \u2014 those are working as intended.
+
+Rules:
+1. Pick the single best category.
+2. Do not fabricate issues. Only report what is evident from the conversation.
+3. Err on the side of NOT calling this tool. When in doubt, help the user instead.
+${guidanceBlock}
+Categories:
+` + signalList;
+  return {
+    toolName,
+    toolDescription,
+    signalKeys,
+    signalKeySet: new Set(signalKeys),
+    signalDescriptions,
+    signalSentiments
+  };
+}
+var SELF_DIAGNOSTICS_ACK = '{"acknowledged":true}';
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function trackSelfDiagnosticsSignal(toolInput, config, eventShipper, eventId, debug) {
+  var _a, _b;
+  try {
+    const input = isRecord2(toolInput) ? toolInput : void 0;
+    const fallbackCategory = (_a = config.signalKeys[0]) != null ? _a : "unknown";
+    const categoryCandidate = normalizeString(input == null ? void 0 : input["category"]);
+    const category = categoryCandidate && config.signalKeySet.has(categoryCandidate) ? categoryCandidate : fallbackCategory;
+    const detail = (_b = normalizeString(input == null ? void 0 : input["detail"])) != null ? _b : "";
+    if (!eventId) {
+      if (debug) {
+        console.warn(
+          "[raindrop-ai/opencode-plugin] self diagnostics signal skipped: no open event for this session."
+        );
+      }
+      return;
+    }
+    if (category === SELF_DIAGNOSTICS_NOTEWORTHY_SIGNAL_KEY) {
+      await eventShipper.trackSignal({
+        eventId,
+        name: "self diagnostics - noteworthy",
+        type: "agent_internal",
+        properties: {
+          source: "agent_flag_event_tool",
+          reason: detail,
+          severity: "medium",
+          sdk: "opencode-plugin",
+          sdk_version: PLUGIN_VERSION
+        }
+      });
+      return;
+    }
+    await eventShipper.trackSignal({
+      eventId,
+      name: `self diagnostics - ${category}`,
+      type: "agent",
+      sentiment: config.signalSentiments[category],
+      properties: {
+        source: "agent_reporting_tool",
+        category,
+        signal_description: config.signalDescriptions[category],
+        sdk: "opencode-plugin",
+        sdk_version: PLUGIN_VERSION,
+        ...detail ? { detail } : {}
+      }
+    });
+  } catch (err) {
+    if (debug) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(
+        `[raindrop-ai/opencode-plugin] selfDiagnostics signal dispatch failed: ${message}`
+      );
+    }
+  }
+}
+
 // src/shipper.ts
 var EventShipper3 = class extends EventShipper2 {
   constructor(opts) {
@@ -2678,7 +2891,7 @@ function markTaskCallFinished(sessionID, callID) {
   running.delete(callID);
   if (running.size === 0) runningTaskCallsBySession.delete(sessionID);
 }
-function endPendingToolSpanWithError(state2, callID, tool, toolCallArgs, errorMessage, traceShipper) {
+function endPendingToolSpanWithError(state2, callID, tool2, toolCallArgs, errorMessage, traceShipper) {
   const startInfo = state2.toolSpanStarts.get(callID);
   if (!startInfo) return false;
   state2.toolSpanStarts.delete(callID);
@@ -2700,7 +2913,7 @@ function endPendingToolSpanWithError(state2, callID, tool, toolCallArgs, errorMe
       startTimeUnixNano: startInfo.startTimeUnixNano,
       attributes: [
         attrString("ai.operationId", "ai.toolCall"),
-        attrString("ai.toolCall.name", tool),
+        attrString("ai.toolCall.name", tool2),
         attrString("ai.toolCall.id", callID)
       ]
     });
@@ -2737,7 +2950,7 @@ function getHostname() {
     return h;
   }
 }
-function createHooks(config, worktree, directory, eventShipper, traceShipper) {
+function createTracing(config, worktree, directory, eventShipper, traceShipper) {
   function log(msg, data) {
     if (!config.debug) return;
     const prefix = `[raindrop-ai/opencode-plugin] [info] ${msg}`;
@@ -2763,7 +2976,7 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
     callKey,
     log
   });
-  return {
+  const hooks = {
     // ------------------------------------------------------------------
     // event — session lifecycle + streaming parts
     // ------------------------------------------------------------------
@@ -2808,14 +3021,14 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
           if (partObj["type"] === "text" && typeof partObj["text"] === "string") {
             state2.outputParts.set(messageId, capText2(partObj["text"]));
           } else if (partObj["type"] === "tool" && messageId) {
-            const tool = partObj["tool"];
+            const tool2 = partObj["tool"];
             const callID = partObj["callID"];
             const partState = partObj["state"];
             if (callID == null || callID === "")
               throw new Error("message.part.updated: part.callID is required for tool part");
             if (partState == null || typeof partState !== "object")
               throw new Error("message.part.updated: part.state is required for tool part");
-            if (tool === "task") {
+            if (tool2 === "task") {
               const metadata = partState["metadata"];
               const childSessionId = metadata != null && typeof metadata === "object" ? metadata["sessionId"] : void 0;
               if (childSessionId != null && childSessionId !== "") {
@@ -2840,11 +3053,11 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
               if (endPendingToolSpanWithError(
                 state2,
                 callID,
-                tool,
+                tool2,
                 toolCallArgs,
                 errorMessage,
                 traceShipper
-              ) && tool === "task") {
+              ) && tool2 === "task") {
                 markTaskCallFinished(partSessionID, callID);
               }
             }
@@ -3221,20 +3434,20 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
     "tool.execute.before": async (toolInput, _output) => {
       var _a, _b, _c;
       try {
-        const { tool, sessionID, callID } = toolInput;
+        const { tool: tool2, sessionID, callID } = toolInput;
         const state2 = sessions.get(sessionID);
         if (!state2 || !state2.currentEventId) return;
         const spanParent = state2.parentId && state2.parentTaskSpanIds ? state2.parentTaskSpanIds : (_a = state2.currentRootSpan) == null ? void 0 : _a.ids;
         if (!spanParent) return;
         const startTimeUnixNano = nowUnixNanoString();
-        if (tool === "task") {
+        if (tool2 === "task") {
           const liveTaskSpan = traceShipper.startSpan({
             name: "ai.toolCall",
             parent: spanParent,
             eventId: state2.currentEventId,
             attributes: [
               attrString("ai.operationId", "ai.toolCall"),
-              attrString("ai.toolCall.name", tool),
+              attrString("ai.toolCall.name", tool2),
               attrString("ai.toolCall.id", callID)
             ]
           });
@@ -3259,7 +3472,7 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
             startTimeUnixNano,
             parent: spanParent,
             eventId: state2.currentEventId,
-            name: tool,
+            name: tool2,
             liveSpan: liveTaskSpan
           });
         } else {
@@ -3267,7 +3480,7 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
             startTimeUnixNano,
             parent: spanParent,
             eventId: state2.currentEventId,
-            name: tool
+            name: tool2
           });
         }
       } catch (err) {
@@ -3282,7 +3495,7 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
     // ------------------------------------------------------------------
     "tool.execute.after": async (toolInput, result) => {
       try {
-        const { tool, sessionID, callID, args } = toolInput;
+        const { tool: tool2, sessionID, callID, args } = toolInput;
         const state2 = sessions.get(sessionID);
         if (!state2 || !state2.currentEventId) return;
         if (args === void 0 || args === null)
@@ -3292,7 +3505,7 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
         state2.toolSpanStarts.delete(callID);
         const resultMetadata = result.metadata;
         const childSessionId = resultMetadata == null ? void 0 : resultMetadata["sessionId"];
-        if (tool === "task" && childSessionId) {
+        if (tool2 === "task" && childSessionId) {
           mapChildSessionToParent.set(childSessionId, { parentId: sessionID });
           attachChildSessionToParentTask(childSessionId, sessionID, callID, "tool.execute.after");
         }
@@ -3317,7 +3530,7 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
               endTimeUnixNano,
               attributes: [
                 attrString("ai.operationId", "ai.toolCall"),
-                attrString("ai.toolCall.name", tool),
+                attrString("ai.toolCall.name", tool2),
                 attrString("ai.toolCall.id", callID),
                 attrString("ai.toolCall.args", toolCallArgs),
                 attrString("ai.toolCall.result", toolResult)
@@ -3325,7 +3538,7 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
             });
           }
         }
-        if (tool === "task") {
+        if (tool2 === "task") {
           markTaskCallFinished(sessionID, callID);
         }
       } catch (err) {
@@ -3378,16 +3591,24 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
       }
     }
   };
+  return {
+    hooks,
+    currentEventId(sessionID) {
+      var _a;
+      return (_a = sessions.get(sessionID)) == null ? void 0 : _a.currentEventId;
+    }
+  };
 }
 
 // src/index.ts
-function createRaindropHandle(eventShipper, traceShipper, appGitContext) {
+function createRaindropHandle(eventShipper, traceShipper, appGitContext, currentEventId) {
   return {
     users: {
       async identify(users) {
         await eventShipper.identify(users);
       }
     },
+    currentEventId,
     async flush() {
       await Promise.all([eventShipper.flush(), traceShipper.flush()]);
     },
@@ -3404,7 +3625,7 @@ function createRaindropHandle(eventShipper, traceShipper, appGitContext) {
   };
 }
 async function plugin(input, opts = {}) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const config = loadConfig(input.directory);
   function appLog(level, message) {
     console.log(`[raindrop-ai/opencode-plugin] [${level}] ${message}`);
@@ -3448,12 +3669,53 @@ async function plugin(input, opts = {}) {
     appGitContext
   });
   const worktree = (_c = input.worktree) != null ? _c : input.directory;
-  const hooks = createHooks(
+  const tracing = createTracing(
     config,
     worktree,
     input.directory,
     eventShipper,
     traceShipper
   );
-  return { ...hooks, raindrop: createRaindropHandle(eventShipper, traceShipper, appGitContext) };
+  const hooks = tracing.hooks;
+  const selfDiagnostics = normalizeSelfDiagnosticsConfig(
+    (_d = opts.selfDiagnostics) != null ? _d : config.selfDiagnostics
+  );
+  if (selfDiagnostics && !config.writeKey.trim()) {
+    appLog(
+      "warn",
+      `selfDiagnostics enabled but RAINDROP_WRITE_KEY is not set \u2014 the ${selfDiagnostics.toolName} tool is not registered (signals require the cloud destination).`
+    );
+  }
+  const [firstSignalKey, ...restSignalKeys] = config.writeKey.trim() && selfDiagnostics ? selfDiagnostics.signalKeys : [];
+  if (selfDiagnostics && firstSignalKey !== void 0) {
+    const cfg = selfDiagnostics;
+    hooks.tool = {
+      [cfg.toolName]: (0, import_plugin.tool)({
+        description: cfg.toolDescription,
+        args: {
+          category: import_plugin.tool.schema.enum([firstSignalKey, ...restSignalKeys]),
+          detail: import_plugin.tool.schema.string()
+        },
+        async execute(args, ctx) {
+          await trackSelfDiagnosticsSignal(
+            args,
+            cfg,
+            eventShipper,
+            tracing.currentEventId(ctx.sessionID),
+            config.debug
+          );
+          return SELF_DIAGNOSTICS_ACK;
+        }
+      })
+    };
+  }
+  return {
+    ...hooks,
+    raindrop: createRaindropHandle(
+      eventShipper,
+      traceShipper,
+      appGitContext,
+      tracing.currentEventId
+    )
+  };
 }

package/dist/index.d.cts

@@ -1,85 +1,12 @@
+import { I as IdentifyInput, A as AppGitOptions, S as SelfDiagnosticsOptions } from './self-diagnostics-NiAq-SZ8.cjs';
+export { a as SelfDiagnosticsSignalDefinition, b as SelfDiagnosticsSignalDefinitions } from './self-diagnostics-NiAq-SZ8.cjs';
 import { Hooks, PluginInput } from '@opencode-ai/plugin';
 
-/** Kept structural so public integration declarations do not depend on private schemas. */
-type AppGitOptions = {
-    commitSha?: string | null;
-    commitDirty?: boolean | null;
-    branch?: string | null;
-    detectBranch?: boolean;
-    sourceDirectory?: string;
-    autoDetect?: boolean;
-};
-type IdentifyInput = {
-    userId: string;
-    traits?: Record<string, unknown>;
-};
-
-/**
- * Run telemetry egress with OpenTelemetry tracing suppressed.
- *
- * Why this exists
- * ---------------
- * Raindrop integrations ship spans/events over HTTP with the global `fetch`
- * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
- * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
- * every Eve agent installs — that instrumentation wraps *our own* telemetry
- * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
- * very exporter that issued the request, so they get shipped right back to
- * Raindrop and Workshop as standalone "runs" (and, because each export issues
- * another fetch, they feed back on themselves). The result is a run list
- * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
- * `.../live` entries that drown out the real agent turns — especially with
- * sub-agents, where every sandbox runs its own instrumentation.
- *
- * The OTel-blessed fix is to mark the active context as "tracing suppressed"
- * around the request; instrumentations check `isTracingSuppressed` and return
- * a no-op span instead of recording one. We do this through a hook stashed on
- * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
- *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
- *     hard-depends on them, and the hook is simply absent when they (and thus
- *     any instrumentation to suppress) are not installed; and
- *   - the browser bundle never pulls in `node:module`, mirroring how core
- *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
- *
- * When no hook is present the callback runs unchanged, so suppression is a
- * best-effort no-op rather than a hard requirement.
- */
-/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
-type SuppressTracingHook = <T>(fn: () => T) => T;
-declare global {
-    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
-}
-
-type ParentSpanContext = {
-    traceIdB64: string;
-    spanIdB64: string;
-    eventId: string;
-};
-interface ContextSpan {
-    readonly traceIdB64: string;
-    readonly spanIdB64: string;
-    readonly eventId: string;
-    log?(data: Record<string, unknown>): void;
-}
-interface AsyncLocalStorageLike<T> {
-    getStore(): T | undefined;
-    run<R>(store: T, callback: () => R): R;
-    enterWith?(store: T): void;
-}
-declare abstract class ContextManager {
-    abstract getParentSpanIds(): ParentSpanContext | undefined;
-    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
-    abstract getCurrentSpan(): ContextSpan | undefined;
-    abstract isReady(): boolean;
-}
-declare global {
-    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
-    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
-}
-
 interface RaindropOpencodeOptions {
     /** Application Git identity override. false disables enrichment. */
     appGit?: AppGitOptions | false;
+    /** Built-in self-diagnostics: injects a `__raindrop_report` tool when enabled. */
+    selfDiagnostics?: SelfDiagnosticsOptions;
 }
 /**
  * The Raindrop control handle exposed alongside the OpenCode hooks.
@@ -101,6 +28,8 @@ interface RaindropOpencodeHandle {
          */
         identify(users: IdentifyInput | IdentifyInput[]): Promise<void>;
     };
+    /** Raindrop eventId of the turn currently open for this OpenCode session, if any. */
+    currentEventId(sessionID: string): string | undefined;
     /** Drain the buffered event + trace shippers. */
     flush(): Promise<void>;
     /** Flush and tear down the shippers (also wired into session teardown). */
@@ -129,4 +58,4 @@ type RaindropOpencodeHooks = Hooks & {
  */
 declare function plugin(input: PluginInput, opts?: RaindropOpencodeOptions): Promise<RaindropOpencodeHooks>;
 
-export { type IdentifyInput, type RaindropOpencodeHandle, type RaindropOpencodeHooks, type RaindropOpencodeOptions, plugin as default };
+export { IdentifyInput, type RaindropOpencodeHandle, type RaindropOpencodeHooks, type RaindropOpencodeOptions, SelfDiagnosticsOptions, plugin as default };