@raindrop-ai/opencode-plugin 0.3.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

package/dist/{chunk-FCORH4YS.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";
@@ -2283,15 +2428,16 @@ function loadConfig(projectDirectory) {
     eventMetadata,
     localWorkshopUrl: resolveLocalWorkshopUrl(merged.local_workshop_url),
     appGit: mapAppGit(merged.app_git),
-    selfDiagnostics: mapSelfDiagnostics(merged.self_diagnostics)
+    selfDiagnostics: mapSelfDiagnostics(merged.self_diagnostics),
+    tools: Array.isArray(merged.tools) ? merged.tools : void 0
   };
 }
-function isRecord(value) {
+function isRecord2(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 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 = {
@@ -2303,10 +2449,10 @@ function mapSelfDiagnostics(value) {
   return Object.keys(options).length > 0 ? options : void 0;
 }
 function mapSelfDiagnosticsSignals(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   const out = {};
   for (const [key, entry] of Object.entries(value)) {
-    if (!isRecord(entry)) continue;
+    if (!isRecord2(entry)) continue;
     const definition = entry;
     if (typeof definition["description"] !== "string") continue;
     const sentiment = definition["sentiment"];
@@ -2343,7 +2489,7 @@ function resolveLocalWorkshopUrl(fileValue) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/opencode-plugin",
-  version: "0.3.0",
+  version: "0.3.1",
   description: "Raindrop observability plugin for OpenCode \u2014 automatic session/event/span tracing",
   type: "module",
   main: "dist/index.js",
@@ -2553,13 +2699,13 @@ function selfDiagnosticsInputJsonSchema(config) {
     additionalProperties: false
   };
 }
-function isRecord2(value) {
+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 = isRecord2(toolInput) ? toolInput : void 0;
+    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;
@@ -2646,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;
@@ -2782,6 +3022,8 @@ export {
   trackSelfDiagnosticsSignal,
   EventShipper3 as EventShipper,
   TraceShipper3 as TraceShipper,
+  createToolCatalog,
+  promptToolsAttributes,
   capText2 as capText,
   boundedStringify,
   buildLlmGenAiAttributes