@raindrop-ai/opencode-plugin 0.2.0 → 0.3.1

package/README.md

@@ -33,6 +33,61 @@ rejected at the ingest size limit. Hook error logs are rate-limited to one
 line per failure family per 30s so a persistent error can't flood the host's
 output.
 
+## Tool catalog capture (`ai.prompt.tools`)
+
+OpenCode's step events carry no tool list, so the plugin cannot see the exact
+tools each model request was given. Instead it records the host's tool catalog
+for the step's model:
+
+- **v1 plugin (`@raindrop-ai/opencode-plugin`)**: on the first step of a
+  session for a given provider/model, the plugin calls
+  `client.tool.list({ query: { provider, model } })` (OpenCode's experimental
+  `/experimental/tool` endpoint) once, caches the answer per session and
+  model, and stamps it as `ai.prompt.tools` on every step span. The lookup is
+  deduplicated while in flight, bounded by a 2s timeout, and never surfaces
+  errors to OpenCode: when it fails, the attribute is simply absent.
+- **v2 plugin (`@raindrop-ai/opencode-plugin/v2`)**: the v2 host has no
+  per-model catalog endpoint; the plugin reads the registered tool list
+  (`ctx.tool.list()`, after every plugin's `tool.transform`) with the same
+  caching, timeout and no-throw rules.
+
+Because this is OpenCode's catalog for that model, not the exact per-request
+set, catalog-derived spans also carry `ai.prompt.tools.source = "opencode.tool.list"`.
+An explicit override (below) is exact and carries no `source`. Each element of
+`ai.prompt.tools` is a JSON document
+`{"type":"function","name":…,"description"?:…,"inputSchema"?:<JSON Schema>}`;
+a tool whose schema is not plain JSON Schema is recorded without `inputSchema`
+rather than with an invented one. The plugin has no separate content switch
+(prompts and responses are always recorded; only the system prompt is opt-in),
+so the catalog is recorded whenever tracing is on. Absent attribute = catalog
+unknown; `[]` = no tools.
+
+### `tools` override
+
+Overrides the tool catalog recorded as `ai.prompt.tools` on every model span.
+Use when the integration cannot see the tools the model was given. The
+override replaces the catalog entirely (`tools: []` records an empty catalog)
+and skips the catalog lookup.
+
+`raindrop.json` (user- or project-level):
+
+```json
+{
+  "tools": [
+    {
+      "name": "get_weather",
+      "description": "Get the current weather",
+      "parameters": { "type": "object", "properties": { "city": { "type": "string" } }, "required": ["city"] }
+    }
+  ]
+}
+```
+
+Programmatic options (v1 `plugin(input, { tools })`, v2 `raindrop({ tools })`)
+take precedence over the config file. Any recognized declaration shape is
+accepted (OpenAI `{type:"function",function:{…}}`, Anthropic `input_schema`,
+plain `{name, description, parameters}`, …).
+
 ## Correlating per-message feedback signals
 
 Each Raindrop event uses a client-generated `event_id` that isn't predictable
@@ -75,6 +130,45 @@ The v2 entry exposes the plugin object plus a `raindrop` handle
 same as the v1 entry. `@opencode/plugin` and `@opencode/sdk` are optional peer
 dependencies — v1 users install neither.
 
+## Self-diagnostics
+
+The plugin can inject a `__raindrop_report` tool that lets the agent flag
+serious, unrecoverable problems for developer review. When the agent calls it,
+a `self diagnostics - <category>` signal is posted to `signals/track`, attached
+to the session's currently-open turn event. The tool is invisible to the end
+user — its output is a bare acknowledgement and the model is instructed never
+to mention it.
+
+Enable it via `raindrop.json` (`~/.config/opencode/raindrop.json` or
+`.opencode/raindrop.json`), or set `RAINDROP_SELF_DIAGNOSTICS=true` to override
+just the `enabled` flag:
+
+```json
+{
+  "self_diagnostics": { "enabled": true }
+}
+```
+
+For the v2 host API, pass the option directly:
+
+```ts
+import raindrop from "@raindrop-ai/opencode-plugin/v2";
+
+export default raindrop({ selfDiagnostics: { enabled: true } });
+```
+
+Optional `signals` (custom category → `{ description, sentiment? }` map),
+`guidance` (extra instructions appended to the tool prompt), and `tool_name` /
+`toolName` overrides are supported. The built-in categories are:
+
+- `missing_context` — blocked on information or access the user cannot provide
+- `repeatedly_broken_tool` — a tool failed across multiple distinct attempts
+- `capability_gap` — the task needs a tool/permission/capability the agent lacks
+- `complete_task_failure` — the agent genuinely could not deliver what was asked
+
+Signals only ship to the cloud destination, so the tool is not registered in
+local-only mode (no `RAINDROP_WRITE_KEY`).
+
 ## Notes
 
 - `@opencode-ai/plugin` is required for the default (v1) export; `@opencode/plugin` for `/v2`.

package/dist/{chunk-4DAI6CYK.js → chunk-ZG47FVK7.js}

@@ -60,7 +60,7 @@ function evalScopeAttributes() {
   return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
 }
 
-// ../core/dist/chunk-WJOR6M7H.js
+// ../core/dist/chunk-I6TVJQEC.js
 var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
 function state() {
   const holder = globalThis;
@@ -2069,6 +2069,151 @@ var TraceShipper = class {
     }
   }
 };
+var PROMPT_TOOLS_ATTRIBUTE = "ai.prompt.tools";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var JSON_SCHEMA_KEYS = [
+  "type",
+  "properties",
+  "$schema",
+  "$ref",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "enum",
+  "const",
+  "items",
+  "additionalProperties",
+  "required"
+];
+function isJsonSchema(value) {
+  if (!isRecord(value)) return false;
+  if (typeof value["~standard"] === "object") return false;
+  if (isRecord(value._def) || isRecord(value._zod)) return false;
+  if (Object.keys(value).length === 0) return true;
+  return JSON_SCHEMA_KEYS.some((key) => key in value);
+}
+function toJsonSchema(value, options) {
+  if (value === void 0 || value === null) return void 0;
+  if (isJsonSchema(value)) return value;
+  if (isRecord(value) && isJsonSchema(value.jsonSchema)) return value.jsonSchema;
+  if (isRecord(value) && isJsonSchema(value.json)) return value.json;
+  if (options == null ? void 0 : options.schema) {
+    try {
+      return options.schema(value);
+    } catch (e) {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function pickString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function functionTool(name, description, schema, options) {
+  const tool = { type: "function", name };
+  const desc = pickString(description);
+  if (desc !== void 0) tool.description = desc;
+  const inputSchema = toJsonSchema(schema, options);
+  if (inputSchema !== void 0) tool.inputSchema = inputSchema;
+  return tool;
+}
+function normalizeToolDeclaration(tool, options, fallbackName) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (!isRecord(tool)) return void 0;
+  if (tool.type === "provider-defined" || tool.type === "provider") {
+    const name2 = (_b = (_a = pickString(tool.name)) != null ? _a : pickString(tool.id)) != null ? _b : fallbackName;
+    if (name2 === void 0) return void 0;
+    const declaration = { type: "provider-defined", name: name2 };
+    const id = pickString(tool.id);
+    if (id !== void 0) declaration.id = id;
+    if (isRecord(tool.args)) declaration.args = tool.args;
+    return declaration;
+  }
+  if (isRecord(tool.toolSpec)) {
+    const spec = tool.toolSpec;
+    const name2 = (_c = pickString(spec.name)) != null ? _c : fallbackName;
+    if (name2 === void 0) return void 0;
+    return functionTool(name2, spec.description, spec.inputSchema, options);
+  }
+  if (isRecord(tool.function)) {
+    const fn = tool.function;
+    const name2 = (_d = pickString(fn.name)) != null ? _d : fallbackName;
+    if (name2 === void 0) return void 0;
+    return functionTool(name2, fn.description, (_e = fn.parameters) != null ? _e : fn.input_schema, options);
+  }
+  const name = (_g = (_f = pickString(tool.name)) != null ? _f : pickString(tool.id)) != null ? _g : fallbackName;
+  if (name === void 0) return void 0;
+  const type = pickString(tool.type);
+  if (type !== void 0 && type !== "function" && type !== "dynamic" && type !== "custom") {
+    if (!("input_schema" in tool) && !("inputSchema" in tool) && !("parameters" in tool)) {
+      return { type: "provider-defined", id: type, name };
+    }
+  }
+  return functionTool(
+    name,
+    tool.description,
+    (_j = (_i = (_h = tool.inputSchema) != null ? _h : tool.input_schema) != null ? _i : tool.parameters) != null ? _j : tool.schema,
+    options
+  );
+}
+var NOT_A_GEMINI_GROUP_KEYS = ["name", "id", "type", "function", "toolSpec", "cachePoint"];
+function isGeminiToolGroup(tool) {
+  if (Array.isArray(tool.functionDeclarations)) return true;
+  const keys = Object.keys(tool);
+  if (keys.length === 0 || NOT_A_GEMINI_GROUP_KEYS.some((key) => key in tool)) return false;
+  return keys.every((key) => isRecord(tool[key]));
+}
+function expandGeminiTool(tool, options) {
+  const declarations = [];
+  for (const [key, value] of Object.entries(tool)) {
+    if (key === "functionDeclarations" && Array.isArray(value)) {
+      for (const declaration of value) {
+        const normalized = normalizeToolDeclaration(declaration, options);
+        if (normalized) declarations.push(normalized);
+      }
+    } else if (isRecord(value)) {
+      declarations.push({ type: "provider-defined", id: key, name: key, args: value });
+    }
+  }
+  return declarations;
+}
+function normalizeToolDeclarations(tools, options) {
+  if (tools === void 0 || tools === null) return void 0;
+  if (Array.isArray(tools)) {
+    return tools.flatMap((tool) => {
+      if (isRecord(tool) && isGeminiToolGroup(tool)) {
+        return expandGeminiTool(tool, options);
+      }
+      const declaration = normalizeToolDeclaration(tool, options);
+      return declaration ? [declaration] : [];
+    });
+  }
+  if (!isRecord(tools)) return void 0;
+  return Object.entries(tools).flatMap(([key, tool]) => {
+    const declaration = normalizeToolDeclaration(tool, options, key);
+    return declaration ? [declaration] : [];
+  });
+}
+function promptToolsAttribute(tools) {
+  const values = promptToolsAttributeValue(tools);
+  if (values === void 0) return void 0;
+  return {
+    key: PROMPT_TOOLS_ATTRIBUTE,
+    value: { arrayValue: { values: values.map((stringValue) => ({ stringValue })) } }
+  };
+}
+function promptToolsAttributeValue(tools) {
+  if (tools === void 0) return void 0;
+  return tools.map((tool) => {
+    try {
+      return JSON.stringify(tool);
+    } catch (e) {
+      return JSON.stringify({ type: tool.type, name: tool.name });
+    }
+  });
+}
 
 // ../core/dist/index.node.js
 import { AsyncLocalStorage } from "async_hooks";
@@ -2282,8 +2427,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),
+    tools: Array.isArray(merged.tools) ? merged.tools : void 0
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mapSelfDiagnostics(value) {
+  const env = process.env["RAINDROP_SELF_DIAGNOSTICS"];
+  const record = isRecord2(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 (!isRecord2(value)) return void 0;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!isRecord2(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;
@@ -2311,7 +2489,7 @@ function resolveLocalWorkshopUrl(fileValue) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/opencode-plugin",
-  version: "0.2.0",
+  version: "0.3.1",
   description: "Raindrop observability plugin for OpenCode \u2014 automatic session/event/span tracing",
   type: "module",
   main: "dist/index.js",
@@ -2400,6 +2578,185 @@ 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 selfDiagnosticsInputJsonSchema(config) {
+  return {
+    type: "object",
+    properties: {
+      category: {
+        type: "string",
+        enum: config.signalKeys,
+        description: "The single best-matching category from the list above."
+      },
+      detail: {
+        type: "string",
+        description: "One sentence of factual context: what happened and why it matters. Do not include PII or secrets."
+      }
+    },
+    required: ["category", "detail"],
+    additionalProperties: false
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function trackSelfDiagnosticsSignal(toolInput, config, eventShipper, eventId, debug) {
+  var _a, _b;
+  try {
+    const input = isRecord3(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) {
@@ -2435,6 +2792,100 @@ var TraceShipper3 = class extends TraceShipper2 {
   }
 };
 
+// src/tool-catalog.ts
+var PROMPT_TOOLS_SOURCE_ATTRIBUTE = "ai.prompt.tools.source";
+var OPENCODE_TOOL_LIST_SOURCE = "opencode.tool.list";
+var TOOL_CATALOG_TIMEOUT_MS = 2e3;
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function catalogItems(raw) {
+  var _a;
+  const list = Array.isArray(raw) ? raw : isRecord4(raw) && Array.isArray(raw.data) ? raw.data : void 0;
+  if (!list) return void 0;
+  const items = [];
+  for (const item of list) {
+    if (!isRecord4(item)) continue;
+    const name = typeof item.id === "string" ? item.id : typeof item.name === "string" ? item.name : void 0;
+    if (!name) continue;
+    const schema = (_a = item.parameters) != null ? _a : item.input;
+    items.push({
+      type: "function",
+      name,
+      ...typeof item.description === "string" ? { description: item.description } : {},
+      ...isJsonSchema(schema) ? { inputSchema: schema } : {}
+    });
+  }
+  return items;
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => resolve2(void 0), ms);
+    if (typeof timer === "object" && "unref" in timer) timer.unref();
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve2(void 0);
+      }
+    );
+  });
+}
+function createToolCatalog(options = {}) {
+  var _a, _b;
+  const override = options.override !== void 0 ? { tools: (_a = normalizeToolDeclarations(options.override)) != null ? _a : [] } : void 0;
+  const timeoutMs = (_b = options.timeoutMs) != null ? _b : TOOL_CATALOG_TIMEOUT_MS;
+  const cache = /* @__PURE__ */ new Map();
+  async function lookup(query) {
+    const fetch2 = options.fetch;
+    if (!fetch2) return void 0;
+    let raw;
+    try {
+      raw = await withTimeout(Promise.resolve().then(() => fetch2(query)), timeoutMs);
+    } catch (error) {
+      if (options.debug) console.log(`[raindrop-ai/opencode-plugin] tool catalog lookup failed: ${String(error)}`);
+      return void 0;
+    }
+    const tools = normalizeToolDeclarations(catalogItems(raw));
+    if (!tools) {
+      if (options.debug) console.log("[raindrop-ai/opencode-plugin] tool catalog lookup returned no tool list");
+      return void 0;
+    }
+    return { tools, source: OPENCODE_TOOL_LIST_SOURCE };
+  }
+  return {
+    resolve(sessionID, query) {
+      if (override) return Promise.resolve(override);
+      if (!options.fetch) return Promise.resolve(void 0);
+      let perSession = cache.get(sessionID);
+      if (!perSession) {
+        perSession = /* @__PURE__ */ new Map();
+        cache.set(sessionID, perSession);
+      }
+      const key = `${query.provider}\0${query.model}`;
+      let pending = perSession.get(key);
+      if (!pending) {
+        pending = lookup(query).catch(() => void 0);
+        perSession.set(key, pending);
+      }
+      return pending;
+    },
+    forget(sessionID) {
+      cache.delete(sessionID);
+    }
+  };
+}
+function promptToolsAttributes(resolved) {
+  if (!resolved) return [];
+  return [
+    promptToolsAttribute(resolved.tools),
+    resolved.source !== void 0 ? attrString(PROMPT_TOOLS_SOURCE_ATTRIBUTE, resolved.source) : void 0
+  ];
+}
+
 // src/bounded.ts
 var TRUNCATION_MARKER2 = "...[truncated by raindrop]";
 var MAX_TEXT_FIELD_CHARS = 1e6;
@@ -2565,8 +3016,14 @@ export {
   loadConfig,
   PLUGIN_NAME,
   PLUGIN_VERSION,
+  normalizeSelfDiagnosticsConfig,
+  SELF_DIAGNOSTICS_ACK,
+  selfDiagnosticsInputJsonSchema,
+  trackSelfDiagnosticsSignal,
   EventShipper3 as EventShipper,
   TraceShipper3 as TraceShipper,
+  createToolCatalog,
+  promptToolsAttributes,
   capText2 as capText,
   boundedStringify,
   buildLlmGenAiAttributes