@raindrop-ai/opencode-plugin 0.0.1 → 0.0.3

package/dist/index.js

@@ -28,7 +28,7 @@ function loadConfig(projectDirectory) {
   }
   return {
     writeKey: (_b = (_a = process.env["RAINDROP_WRITE_KEY"]) != null ? _a : merged.write_key) != null ? _b : "",
-    endpoint: (_d = (_c = process.env["RAINDROP_API_URL"]) != null ? _c : merged.api_url) != null ? _d : "https://api.raindrop.ai",
+    endpoint: (_d = (_c = process.env["RAINDROP_API_URL"]) != null ? _c : merged.api_url) != null ? _d : "https://api.raindrop.ai/v1",
     eventName: (_e = merged.event_name) != null ? _e : "opencode_session",
     userId: merged.user_id,
     debug: process.env["RAINDROP_DEBUG"] === "true" ? true : (_f = merged.debug) != null ? _f : false
@@ -77,10 +77,11 @@ function base64Encode(bytes) {
 var SERVICE_NAME = "raindrop.opencode-plugin";
 var PLUGIN_VERSION = "0.1.0";
 var SpanStatusCode = {
-  UNSET: 0,
-  OK: 1,
   ERROR: 2
 };
+function generateId() {
+  return base64Encode(randomBytes(12)).replace(/[+/=]/g, "").slice(0, 16);
+}
 function createSpanIds(parent) {
   const traceId = parent ? parent.traceIdB64 : base64Encode(randomBytes(16));
   const spanId = base64Encode(randomBytes(8));
@@ -103,7 +104,11 @@ function attrInt(key, value) {
   return { key, value: { intValue: String(Math.trunc(value)) } };
 }
 function buildOtlpSpan(args) {
-  const attrs = args.attributes.filter((x) => x !== void 0);
+  const attrs = [
+    attrString("span.id", args.ids.spanIdB64),
+    attrString("span.parent.id", args.ids.parentSpanIdB64),
+    ...args.attributes
+  ].filter((x) => x !== void 0);
   const span = {
     traceId: args.ids.traceIdB64,
     spanId: args.ids.spanIdB64,
@@ -173,9 +178,7 @@ async function withRetry(operation, opName, opts) {
       }
       if (delay > 0) await wait(delay);
     } else if (opts.debug) {
-      console.log(
-        `[raindrop-ai/opencode-plugin] ${opName} attempt ${attempt}/${opts.maxAttempts}`
-      );
+      console.log(`[raindrop-ai/opencode-plugin] ${opName} attempt ${attempt}/${opts.maxAttempts}`);
     }
     try {
       return await operation();
@@ -409,6 +412,27 @@ var TraceShipper = class {
     });
     this.enqueue(otlp);
   }
+  /**
+   * Create and enqueue a span with both start and end times (atomic insert).
+   * Used for tool spans and any span whose full duration is known at write time.
+   */
+  createSpan(args) {
+    var _a;
+    const ids = createSpanIds(args.parent);
+    const attrs = [
+      attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId)
+    ];
+    if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
+    const otlp = buildOtlpSpan({
+      ids,
+      name: args.name,
+      startTimeUnixNano: args.startTimeUnixNano,
+      endTimeUnixNano: args.endTimeUnixNano,
+      attributes: attrs,
+      status: args.status
+    });
+    this.enqueue(otlp);
+  }
   enqueue(span) {
     if (this.queue.length >= this.maxQueueSize) this.queue.shift();
     this.queue.push(span);
@@ -434,10 +458,12 @@ var TraceShipper = class {
       const batch = this.queue.splice(0, this.maxBatchSize);
       const body = buildExportTraceServiceRequest(batch);
       const url = `${this.baseUrl}traces`;
+      const spanNames = batch.map((span) => span.name);
       if (this.debug) {
         console.log("[raindrop-ai/opencode-plugin] sending traces batch", {
           spans: batch.length,
-          endpoint: url
+          endpoint: url,
+          spanNames
         });
       }
       const p = postJson(
@@ -451,14 +477,14 @@ var TraceShipper = class {
         try {
           await p;
           if (this.debug) {
-            console.log(`[raindrop-ai/opencode-plugin] sent ${batch.length} spans`);
+            console.log(`[raindrop-ai/opencode-plugin] sent ${batch.length} spans`, {
+              spanNames
+            });
           }
         } catch (err) {
           if (this.debug) {
             const msg = err instanceof Error ? err.message : String(err);
-            console.warn(
-              `[raindrop-ai/opencode-plugin] failed to send spans (dropping): ${msg}`
-            );
+            console.warn(`[raindrop-ai/opencode-plugin] failed to send spans (dropping): ${msg}`);
           }
         }
       } finally {
@@ -477,281 +503,458 @@ var TraceShipper = class {
   }
 };
 
+// src/tracing-linkage-helpers.ts
+function createSessionParentMapHelpers({
+  sessions: sessions2,
+  taskContexts: taskContexts2,
+  runningTaskCallsBySession: runningTaskCallsBySession2,
+  mapChildSessionToParent: mapChildSessionToParent2,
+  pendingChildSessionsByCallKey: pendingChildSessionsByCallKey2,
+  callKey: callKey2,
+  log
+}) {
+  function applyChildSessionParentToState(childSessionId) {
+    const parentInfo = mapChildSessionToParent2.get(childSessionId);
+    const state = sessions2.get(childSessionId);
+    if (!parentInfo || !state) return;
+    state.parentId = parentInfo.parentId;
+    state.parentTaskSpanIds = parentInfo.parentTaskSpanIds;
+    state.parentEventContext = parentInfo.eventContext;
+  }
+  function queuePendingChildByCallKey(key, childSessionId) {
+    var _a;
+    const pending = (_a = pendingChildSessionsByCallKey2.get(key)) != null ? _a : /* @__PURE__ */ new Set();
+    pending.add(childSessionId);
+    pendingChildSessionsByCallKey2.set(key, pending);
+  }
+  function attachChildSessionToParentTask(childSessionId, parentId, parentCallId, source) {
+    const key = callKey2(parentId, parentCallId);
+    const ctx = taskContexts2.get(key);
+    if (!ctx) {
+      queuePendingChildByCallKey(key, childSessionId);
+      return false;
+    }
+    const parentInfo = {
+      parentId,
+      parentTaskSpanIds: ctx.ids,
+      eventContext: ctx.eventContext
+    };
+    mapChildSessionToParent2.set(childSessionId, parentInfo);
+    applyChildSessionParentToState(childSessionId);
+    return true;
+  }
+  function resolvePendingChildrenForCall(parentId, parentCallId, source) {
+    const key = callKey2(parentId, parentCallId);
+    const pending = pendingChildSessionsByCallKey2.get(key);
+    if (pending && pending.size > 0) {
+      for (const childSessionId of [...pending]) {
+        if (attachChildSessionToParentTask(childSessionId, parentId, parentCallId, source)) {
+          pending.delete(childSessionId);
+        }
+      }
+      if (pending.size === 0) pendingChildSessionsByCallKey2.delete(key);
+    }
+  }
+  function cleanupSessionParentMap(sessionId) {
+    mapChildSessionToParent2.delete(sessionId);
+    runningTaskCallsBySession2.delete(sessionId);
+    for (const [key, pending] of pendingChildSessionsByCallKey2.entries()) {
+      pending.delete(sessionId);
+      if (pending.size === 0) pendingChildSessionsByCallKey2.delete(key);
+    }
+    for (const key of [...taskContexts2.keys()]) {
+      if (key.startsWith(`${sessionId}:`)) taskContexts2.delete(key);
+    }
+    for (const [childSessionId, parentInfo] of [...mapChildSessionToParent2.entries()]) {
+      if (parentInfo.parentId === sessionId) {
+        mapChildSessionToParent2.delete(childSessionId);
+      }
+    }
+  }
+  return {
+    applyChildSessionParentToState,
+    attachChildSessionToParentTask,
+    cleanupSessionParentMap,
+    resolvePendingChildrenForCall
+  };
+}
+
 // src/tracing.ts
 var sessions = /* @__PURE__ */ new Map();
+var taskContexts = /* @__PURE__ */ new Map();
+var runningTaskCallsBySession = /* @__PURE__ */ new Map();
+var mapChildSessionToParent = /* @__PURE__ */ new Map();
+var pendingChildSessionsByCallKey = /* @__PURE__ */ new Map();
+function createSessionState(sessionId) {
+  return {
+    sessionId,
+    turnNumber: 0,
+    toolCount: 0,
+    currentInput: "",
+    outputParts: /* @__PURE__ */ new Map(),
+    reasoningParts: /* @__PURE__ */ new Map(),
+    toolSpanStarts: /* @__PURE__ */ new Map(),
+    processedMessages: /* @__PURE__ */ new Set()
+  };
+}
+function callKey(sessionId, callId) {
+  return `${sessionId}:${callId}`;
+}
 function getHostname() {
-  var _a, _b;
+  var _a;
   try {
     const bunGlobal = globalThis;
     if ((_a = bunGlobal.Bun) == null ? void 0 : _a.hostname) return bunGlobal.Bun.hostname;
     return __require("os").hostname();
   } catch (e) {
-    return (_b = process.env["HOSTNAME"]) != null ? _b : "unknown";
+    const h = process.env["HOSTNAME"];
+    if (h === void 0 || h === "") throw new Error("HOSTNAME env is not set");
+    return h;
   }
 }
-function getProjectName(worktree) {
-  var _a;
-  const parts = worktree.split("/").filter(Boolean);
-  return (_a = parts[parts.length - 1]) != null ? _a : "unknown";
-}
-function createHooks(client, config, worktree, directory, eventShipper, traceShipper) {
+function createHooks(config, worktree, directory, eventShipper, traceShipper) {
   function log(msg, data) {
-    var _a, _b;
-    (_b = (_a = client.app.log({
-      body: {
-        service: "raindrop-opencode",
-        level: config.debug ? "info" : "debug",
-        message: msg,
-        ...data !== void 0 ? { extra: data } : {}
-      }
-    })) == null ? void 0 : _a.catch) == null ? void 0 : _b.call(_a, () => {
-    });
+    const level = config.debug ? "info" : "debug";
+    const prefix = `[raindrop-ai/opencode-plugin] [${level}] ${msg}`;
+    if (data !== void 0) {
+      console.log(prefix, data);
+      return;
+    }
+    console.log(prefix);
   }
-  log("Raindrop tracing hooks registered");
+  const hostname = getHostname();
+  const os = process.platform;
+  const {
+    applyChildSessionParentToState,
+    attachChildSessionToParentTask,
+    cleanupSessionParentMap,
+    resolvePendingChildrenForCall
+  } = createSessionParentMapHelpers({
+    sessions,
+    taskContexts,
+    runningTaskCallsBySession,
+    mapChildSessionToParent,
+    pendingChildSessionsByCallKey,
+    callKey,
+    log
+  });
   return {
     // ------------------------------------------------------------------
     // event — session lifecycle + streaming parts
     // ------------------------------------------------------------------
-    event: async ({
-      event
-    }) => {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    event: async ({ event }) => {
+      var _a, _b, _c, _d, _e;
       try {
         const props = event.properties;
         const info = props["info"];
-        const sessionID = props["sessionID"] || (info == null ? void 0 : info["id"]) || props["id"];
+        const sessionID = (_b = (_a = props["sessionID"]) != null ? _a : info == null ? void 0 : info["id"]) != null ? _b : props["id"];
+        const sessionEventTypes = ["session.created", "session.idle", "session.deleted", "session.error"];
+        if (sessionEventTypes.includes(event.type) && (sessionID === void 0 || sessionID === "")) {
+          throw new Error(`event ${event.type}: missing sessionID in properties`);
+        }
         if (event.type === "session.created") {
-          if (!sessionID) {
-            log("session.created: no session ID, skipping");
-            return;
+          if (info == null || typeof info !== "object")
+            throw new Error("session.created: props.info is required");
+          const parentID = info["parentID"];
+          let state = sessions.get(sessionID);
+          if (!state) {
+            state = createSessionState(sessionID);
+            sessions.set(sessionID, state);
           }
-          const userId = (_a = config.userId) != null ? _a : sessionID;
-          const hostname = getHostname();
-          const os = process.platform;
-          const rootSpan = traceShipper.startSpan({
-            name: `OpenCode: ${getProjectName(worktree)}`,
-            eventId: sessionID,
-            attributes: [
-              attrString("workspace", worktree),
-              attrString("directory", directory),
-              attrString("hostname", hostname),
-              attrString("os", os)
-            ]
-          });
-          const state = {
-            eventId: sessionID,
-            rootSpan,
-            turnNumber: 0,
-            toolCount: 0,
-            startTime: Date.now(),
-            currentInput: "",
-            currentOutput: "",
-            outputParts: /* @__PURE__ */ new Map(),
-            reasoningParts: /* @__PURE__ */ new Map(),
-            toolCalls: /* @__PURE__ */ new Map(),
-            toolStartTimes: /* @__PURE__ */ new Map(),
-            toolSpans: /* @__PURE__ */ new Map(),
-            toolCallMessageIds: /* @__PURE__ */ new Map(),
-            processedMessages: /* @__PURE__ */ new Set(),
-            attachments: []
-          };
-          sessions.set(sessionID, state);
-          await eventShipper.patch(sessionID, {
-            isPending: true,
-            userId,
-            convoId: sessionID,
-            eventName: config.eventName,
-            properties: {
-              workspace: worktree,
-              directory,
-              hostname,
-              os,
-              turn_count: 0,
-              tool_count: 0
-            }
-          });
-          log("Session created", { sessionID, userId });
+          state.parentId = parentID;
+          if (state.parentId) mapChildSessionToParent.set(sessionID, { parentId: state.parentId });
         } else if (event.type === "message.part.updated") {
           const part = props["part"];
-          if (!part) return;
-          const partSessionID = part["sessionID"];
-          const messageId = part["messageID"];
-          if (!partSessionID || !messageId) return;
+          if (part == null || typeof part !== "object")
+            throw new Error("message.part.updated: props.part is required");
+          const partObj = part;
+          const partSessionID = partObj["sessionID"];
+          const messageId = partObj["messageID"];
+          if (partSessionID == null || partSessionID === "")
+            throw new Error("message.part.updated: part.sessionID is required");
+          if (messageId == null || messageId === "")
+            throw new Error("message.part.updated: part.messageID is required");
           const state = sessions.get(partSessionID);
           if (!state) return;
-          if (part["type"] === "text" && typeof part["text"] === "string") {
-            state.outputParts.set(messageId, part["text"]);
-          } else if (part["type"] === "tool" && messageId) {
-            const callID = part["callID"];
-            const tool = part["tool"];
-            const partState = part["state"];
-            const input = partState == null ? void 0 : partState["input"];
-            if (callID && tool && input) {
-              let calls = state.toolCalls.get(messageId);
-              if (!calls) {
-                calls = [];
-                state.toolCalls.set(messageId, calls);
+          if (partObj["type"] === "text" && typeof partObj["text"] === "string") {
+            state.outputParts.set(messageId, partObj["text"]);
+          } else if (partObj["type"] === "tool" && messageId) {
+            const tool = partObj["tool"];
+            if (tool === "task") {
+              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");
+              const metadata = partState["metadata"];
+              const childSessionId = metadata != null && typeof metadata === "object" ? metadata["sessionId"] : void 0;
+              if (childSessionId != null && childSessionId !== "") {
+                mapChildSessionToParent.set(childSessionId, {
+                  parentId: partSessionID
+                });
+                attachChildSessionToParentTask(
+                  childSessionId,
+                  partSessionID,
+                  callID,
+                  "part.metadata"
+                );
               }
-              const existingIdx = calls.findIndex((c) => c.callId === callID);
-              const entry = { callId: callID, name: tool, args: JSON.stringify(input) };
-              if (existingIdx >= 0) calls[existingIdx] = entry;
-              else calls.push(entry);
-              state.toolCallMessageIds.set(callID, messageId);
             }
-          } else if (part["type"] === "reasoning" && typeof part["text"] === "string") {
-            state.reasoningParts.set(messageId, part["text"]);
-          } else {
-            log(`message.part.updated: skipping part type=${String(part["type"])}`);
+          } else if (partObj["type"] === "reasoning" && typeof partObj["text"] === "string") {
+            state.reasoningParts.set(messageId, partObj["text"]);
           }
         } else if (event.type === "message.updated") {
           const msgInfo = props["info"];
-          if (!msgInfo) return;
-          const role = msgInfo["role"];
+          if (msgInfo == null || typeof msgInfo !== "object")
+            throw new Error("message.updated: props.info is required");
+          const info2 = msgInfo;
+          const role = info2["role"];
           if (role !== "assistant") return;
-          const msgSessionID = msgInfo["sessionID"];
-          const messageId = msgInfo["id"];
-          const time = msgInfo["time"];
-          if (!msgSessionID || !messageId || !(time == null ? void 0 : time["completed"])) return;
+          const msgSessionID = info2["sessionID"];
+          const messageId = info2["id"];
+          const time = info2["time"];
+          if (msgSessionID == null || msgSessionID === "")
+            throw new Error("message.updated: info.sessionID is required");
+          if (messageId == null || messageId === "")
+            throw new Error("message.updated: info.id is required");
+          if (time == null || typeof time !== "object")
+            throw new Error("message.updated: info.time is required");
+          const timeObj = time;
+          if (timeObj["completed"] == null) return;
           const state = sessions.get(msgSessionID);
-          if (!state || !state.currentTurnSpan) return;
+          if (!state || !state.currentEventId || !state.currentRootSpan) return;
           if (state.processedMessages.has(messageId)) return;
           state.processedMessages.add(messageId);
-          const tokens = msgInfo["tokens"];
-          const inputTokens = (tokens == null ? void 0 : tokens["input"]) || 0;
-          const outputTokens = (tokens == null ? void 0 : tokens["output"]) || 0;
-          const reasoningTokens = (tokens == null ? void 0 : tokens["reasoning"]) || 0;
-          const providerID = msgInfo["providerID"] || "unknown";
-          const modelID = msgInfo["modelID"] || "unknown";
+          const tokens = info2["tokens"];
+          if (tokens == null || typeof tokens !== "object")
+            throw new Error("message.updated: info.tokens is required");
+          const tokensObj = tokens;
+          const inputTokens = tokensObj["input"];
+          const outputTokens = tokensObj["output"];
+          const reasoningTokens = tokensObj["reasoning"];
+          if (typeof inputTokens !== "number" || typeof outputTokens !== "number")
+            throw new Error("message.updated: tokens.input and tokens.output must be numbers");
+          const providerID = info2["providerID"];
+          const modelID = info2["modelID"];
+          if (typeof providerID !== "string" || providerID === "" || typeof modelID !== "string" || modelID === "")
+            throw new Error(
+              "message.updated: providerID and modelID are required non-empty strings"
+            );
           const modelName = `${providerID}/${modelID}`;
-          state.model = modelName;
-          const outputText = (_b = state.outputParts.get(messageId)) != null ? _b : "";
-          state.currentOutput = outputText;
-          const llmAttrs = [
-            attrString("gen_ai.system", providerID),
-            attrString("gen_ai.request.model", modelID),
-            attrInt("gen_ai.usage.input_tokens", inputTokens),
-            attrInt("gen_ai.usage.output_tokens", outputTokens)
-          ];
-          if (reasoningTokens > 0) {
-            llmAttrs.push(attrInt("gen_ai.usage.reasoning_tokens", reasoningTokens));
-          }
-          const llmSpan = traceShipper.startSpan({
-            name: modelName,
-            parent: state.currentTurnSpan.ids,
-            eventId: state.eventId,
-            attributes: llmAttrs
-          });
-          if (typeof time["created"] === "number") {
-            llmSpan.startTimeUnixNano = String(time["created"] * 1e6);
+          const finishReason = info2["finish"];
+          const outputText = state.outputParts.get(messageId);
+          const reasoningText = state.reasoningParts.get(messageId);
+          const isToolCallsCompletion = finishReason === "tool-calls";
+          const hasIntermediateReasoning = reasoningText !== void 0 && reasoningText.trim().length > 0;
+          if (outputText === void 0 && !(isToolCallsCompletion && hasIntermediateReasoning))
+            return;
+          if (isToolCallsCompletion && !hasIntermediateReasoning) {
+            await traceShipper.flush();
+            return;
           }
-          const msgError = msgInfo["error"];
-          const errorForSpan = msgError ? `${(_e = (_d = (_c = msgError.data) == null ? void 0 : _c.message) != null ? _d : msgError.name) != null ? _e : "Error"}
+          const msgError = info2["error"];
+          const errorForSpan = msgError ? (() => {
+            var _a2, _b2;
+            const msg = (_b2 = (_a2 = msgError.data) == null ? void 0 : _a2.message) != null ? _b2 : msgError.name;
+            const name = msgError.name;
+            if (msg == null && name == null)
+              throw new Error("message.updated: error object must have name or data.message");
+            return `${msg != null ? msg : name}
 
-type: ${(_f = msgError.name) != null ? _f : "UnknownError"}` : void 0;
-          traceShipper.endSpan(llmSpan, { error: errorForSpan });
-          await eventShipper.patch(state.eventId, {
-            model: modelName,
-            output: outputText || void 0
-          });
-          log("LLM span created", {
-            messageId,
-            modelName,
-            inputTokens,
-            outputTokens,
-            reasoningTokens
-          });
+type: ${name != null ? name : "UnknownError"}`;
+          })() : void 0;
+          if (isToolCallsCompletion) {
+            if (reasoningText === void 0)
+              throw new Error("message.updated: reasoningParts missing for tool-call continuation");
+            const llmAttrs = [
+              attrString("ai.operationId", "generateText"),
+              attrString("ai.response.text", reasoningText),
+              attrString("gen_ai.system", providerID),
+              attrString("gen_ai.request.model", modelID),
+              attrInt("gen_ai.usage.input_tokens", inputTokens),
+              attrInt("gen_ai.usage.output_tokens", outputTokens)
+            ];
+            if (reasoningTokens != null && typeof reasoningTokens === "number" && reasoningTokens > 0) {
+              llmAttrs.push(attrInt("gen_ai.usage.reasoning_tokens", reasoningTokens));
+            }
+            const llmParent = state.parentId && state.parentTaskSpanIds ? state.parentTaskSpanIds : state.currentRootSpan.ids;
+            const llmSpan = traceShipper.startSpan({
+              name: modelName,
+              parent: llmParent,
+              eventId: state.currentEventId,
+              attributes: llmAttrs
+            });
+            if (typeof timeObj["created"] === "number") {
+              llmSpan.startTimeUnixNano = String(timeObj["created"] * 1e6);
+            }
+            traceShipper.endSpan(llmSpan, { error: errorForSpan });
+            await traceShipper.flush();
+            return;
+          }
+          if (outputText === void 0) return;
+          const rootSpan = state.currentRootSpan;
+          if (state.parentId) {
+            const llmAttrs = [
+              attrString("ai.operationId", "generateText"),
+              attrString("ai.prompt", state.currentInput),
+              attrString("ai.response.text", outputText),
+              attrString("gen_ai.system", providerID),
+              attrString("gen_ai.request.model", modelID),
+              attrInt("gen_ai.usage.input_tokens", inputTokens),
+              attrInt("gen_ai.usage.output_tokens", outputTokens)
+            ];
+            if (reasoningTokens != null && typeof reasoningTokens === "number" && reasoningTokens > 0) {
+              llmAttrs.push(attrInt("gen_ai.usage.reasoning_tokens", reasoningTokens));
+            }
+            if (!state.parentTaskSpanIds) {
+              traceShipper.endSpan(rootSpan, {
+                error: "Missing strict parent task for child session"
+              });
+              state.currentRootSpan = void 0;
+              state.currentEventId = void 0;
+              await traceShipper.flush();
+              return;
+            }
+            const finalLlmSpan = traceShipper.startSpan({
+              name: modelName,
+              parent: state.parentTaskSpanIds,
+              eventId: state.currentEventId,
+              attributes: llmAttrs
+            });
+            if (typeof timeObj["created"] === "number") {
+              finalLlmSpan.startTimeUnixNano = String(timeObj["created"] * 1e6);
+            }
+            traceShipper.endSpan(finalLlmSpan, { error: errorForSpan });
+            traceShipper.endSpan(rootSpan, {
+              attributes: [
+                attrString("is_subagent", "true"),
+                attrString("parent_session_id", state.parentId)
+              ],
+              error: errorForSpan
+            });
+          } else {
+            rootSpan.name = modelName;
+            const rootAttrs = [
+              attrString("ai.operationId", "generateText"),
+              attrString("ai.prompt", state.currentInput),
+              attrString("ai.response.text", outputText),
+              attrString("gen_ai.system", providerID),
+              attrString("gen_ai.request.model", modelID),
+              attrInt("gen_ai.usage.input_tokens", inputTokens),
+              attrInt("gen_ai.usage.output_tokens", outputTokens)
+            ];
+            if (reasoningTokens != null && typeof reasoningTokens === "number" && reasoningTokens > 0) {
+              rootAttrs.push(attrInt("gen_ai.usage.reasoning_tokens", reasoningTokens));
+            }
+            traceShipper.endSpan(rootSpan, {
+              attributes: rootAttrs,
+              error: errorForSpan
+            });
+          }
+          state.currentRootSpan = void 0;
+          const hasAssistantResponse = outputText.trim().length > 0;
+          if (!hasAssistantResponse) {
+            await traceShipper.flush();
+            state.currentEventId = void 0;
+            return;
+          }
+          if (!state.parentId) {
+            await eventShipper.finish(state.currentEventId, {
+              userId: state.sessionId,
+              model: modelName,
+              output: outputText,
+              properties: {
+                turn_count: state.turnNumber,
+                tool_count: state.toolCount
+              }
+            });
+          }
+          await traceShipper.flush();
+          state.currentEventId = void 0;
         } else if (event.type === "session.idle") {
           if (!sessionID) return;
           const state = sessions.get(String(sessionID));
           if (!state) return;
-          if (state.currentTurnSpan) {
-            traceShipper.endSpan(state.currentTurnSpan);
-            state.currentTurnSpan = void 0;
+          if (state.currentRootSpan) {
+            traceShipper.endSpan(state.currentRootSpan);
+            state.currentRootSpan = void 0;
+          }
+          if (state.currentEventId) {
+            state.currentEventId = void 0;
+          }
+          await traceShipper.flush();
+          if (state.parentId) {
+            cleanupSessionParentMap(String(sessionID));
+            sessions.delete(String(sessionID));
+          } else {
           }
-          await eventShipper.patch(state.eventId, {
-            output: state.currentOutput || void 0,
-            properties: {
-              turn_count: state.turnNumber,
-              tool_count: state.toolCount
-            }
-          });
-          log("Session idle \u2014 turn span closed", { sessionID });
         } else if (event.type === "session.deleted") {
           if (!sessionID) return;
           const state = sessions.get(String(sessionID));
           if (!state) return;
-          if (state.currentTurnSpan) {
-            traceShipper.endSpan(state.currentTurnSpan);
-            state.currentTurnSpan = void 0;
+          if (state.currentRootSpan) {
+            traceShipper.endSpan(state.currentRootSpan);
+            state.currentRootSpan = void 0;
           }
-          traceShipper.endSpan(state.rootSpan);
-          await eventShipper.finish(state.eventId, {
-            output: state.currentOutput || void 0,
-            model: state.model,
-            properties: {
-              turn_count: state.turnNumber,
-              tool_count: state.toolCount
-            }
-          });
+          if (state.currentEventId) {
+            state.currentEventId = void 0;
+          }
+          cleanupSessionParentMap(String(sessionID));
           await Promise.all([eventShipper.flush(), traceShipper.flush()]);
           sessions.delete(String(sessionID));
-          log("Session deleted \u2014 flushed", { sessionID });
         } else if (event.type === "session.error") {
-          const errorSessionID = props["sessionID"] || sessionID;
-          if (!errorSessionID) return;
+          const errorSessionID = (_c = props["sessionID"]) != null ? _c : sessionID;
+          if (errorSessionID === void 0 || errorSessionID === "")
+            throw new Error("session.error: missing sessionID");
           const state = sessions.get(String(errorSessionID));
           if (!state) return;
           const errorObj = props["error"];
-          const errorName = (_g = errorObj == null ? void 0 : errorObj.name) != null ? _g : "UnknownError";
-          const errorMessage = (_i = (_h = errorObj == null ? void 0 : errorObj.data) == null ? void 0 : _h.message) != null ? _i : errorName;
-          const errorStr = `${errorMessage}
+          if (errorObj == null) throw new Error("session.error: missing error object");
+          const errorName = errorObj.name;
+          const errorMessage = (_e = (_d = errorObj.data) == null ? void 0 : _d.message) != null ? _e : errorObj.name;
+          if (errorName == null && errorMessage == null)
+            throw new Error("session.error: error object must have name or data.message");
+          const errorStr = `${errorMessage != null ? errorMessage : errorName}
 
-type: ${errorName}`;
-          if (state.currentTurnSpan) {
-            traceShipper.endSpan(state.currentTurnSpan, { error: errorStr });
-            state.currentTurnSpan = void 0;
+type: ${errorName != null ? errorName : "UnknownError"}`;
+          if (state.currentRootSpan) {
+            traceShipper.endSpan(state.currentRootSpan, { error: errorStr });
+            state.currentRootSpan = void 0;
           }
-          traceShipper.endSpan(state.rootSpan, { error: errorStr });
-          await eventShipper.finish(state.eventId, {
-            properties: {
-              error: errorStr,
-              turn_count: state.turnNumber,
-              tool_count: state.toolCount
-            }
-          });
+          if (state.currentEventId) {
+            state.currentEventId = void 0;
+          }
+          cleanupSessionParentMap(String(errorSessionID));
           await Promise.all([eventShipper.flush(), traceShipper.flush()]);
           sessions.delete(String(errorSessionID));
-          log("Session error handled", { errorSessionID, errorName });
-        } else {
-          log(`unhandled event: ${event.type}`);
         }
       } catch (err) {
-        (_k = (_j = client.app.log({
-          body: {
-            service: "raindrop-opencode",
-            level: "error",
-            message: `Error in event hook: ${err instanceof Error ? err.message : String(err)}`
-          }
-        })) == null ? void 0 : _j.catch) == null ? void 0 : _k.call(_j, () => {
-        });
+        console.log(
+          `[raindrop-ai/opencode-plugin] [error] Error in event hook: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
     },
     // ------------------------------------------------------------------
-    // chat.message — user sent a message; start a new turn span
+    // chat.message — user sent a message; start a new turn with a fresh event ID
     // ------------------------------------------------------------------
     "chat.message": async (messageInput, output) => {
-      var _a;
       try {
         const { sessionID } = messageInput;
-        const state = sessions.get(sessionID);
-        if (!state) return;
-        if (state.currentTurnSpan) {
-          traceShipper.endSpan(state.currentTurnSpan);
-          state.currentTurnSpan = void 0;
+        let state = sessions.get(sessionID);
+        if (!state) {
+          state = createSessionState(sessionID);
+          sessions.set(sessionID, state);
+        }
+        applyChildSessionParentToState(sessionID);
+        if (state.currentRootSpan) {
+          traceShipper.endSpan(state.currentRootSpan);
+          state.currentRootSpan = void 0;
         }
         state.turnNumber++;
-        state.currentOutput = "";
-        const parts = (_a = output == null ? void 0 : output.parts) != null ? _a : [];
+        if (output == null) throw new Error("chat.message: output is required");
+        const parts = output.parts;
+        if (parts == null) throw new Error("chat.message: output.parts is required");
         const textParts = [];
         const newAttachments = [];
         for (const part of parts) {
@@ -762,84 +965,192 @@ type: ${errorName}`;
             const filename = part["filename"];
             const url = part["url"];
             if (url && (mimeType == null ? void 0 : mimeType.startsWith("image/"))) {
+              if (filename === void 0 || filename === "")
+                throw new Error("chat.message: file part must have filename");
               newAttachments.push({ type: "image", role: "input", name: filename, value: url });
             }
           }
         }
         const userText = textParts.join("\n");
         state.currentInput = userText;
-        if (newAttachments.length > 0) state.attachments.push(...newAttachments);
-        state.currentTurnSpan = traceShipper.startSpan({
-          name: `Turn ${state.turnNumber}`,
-          parent: state.rootSpan.ids,
-          eventId: state.eventId,
-          attributes: [attrInt("turn.number", state.turnNumber)]
-        });
-        await eventShipper.patch(state.eventId, {
-          input: userText || void 0,
-          attachments: newAttachments.length > 0 ? newAttachments : void 0,
-          properties: { turn_count: state.turnNumber }
+        if (state.parentId) {
+          if (!state.parentTaskSpanIds || !state.parentEventContext) {
+            return;
+          }
+          state.currentEventId = state.parentEventContext.eventId;
+          state.currentRootSpan = traceShipper.startSpan({
+            name: "Subagent",
+            parent: state.parentTaskSpanIds,
+            eventId: state.currentEventId,
+            attributes: [
+              attrString("workspace", worktree),
+              attrString("directory", directory),
+              attrString("hostname", hostname),
+              attrString("os", os),
+              attrString("is_subagent", "true"),
+              attrString("parent_session_id", state.parentId)
+            ]
+          });
+          return;
+        }
+        state.currentEventId = generateId();
+        state.currentRootSpan = traceShipper.startSpan({
+          name: "ai.event",
+          eventId: state.currentEventId,
+          attributes: [
+            attrString("workspace", worktree),
+            attrString("directory", directory),
+            attrString("hostname", hostname),
+            attrString("os", os)
+          ]
         });
-        log("Chat message \u2014 new turn started", {
-          sessionID,
-          turnNumber: state.turnNumber,
-          inputLength: userText.length,
-          attachments: newAttachments.length
+        await eventShipper.patch(state.currentEventId, {
+          isPending: true,
+          userId: state.sessionId,
+          convoId: state.sessionId,
+          eventName: config.eventName,
+          input: userText,
+          ...newAttachments.length > 0 ? { attachments: newAttachments } : {},
+          properties: {
+            workspace: worktree,
+            directory,
+            hostname,
+            os,
+            turn_count: state.turnNumber,
+            tool_count: state.toolCount
+          }
         });
       } catch (err) {
-        log("Error in chat.message hook", { error: String(err) });
       }
     },
     // ------------------------------------------------------------------
-    // tool.execute.before — record start time and open tool span
+    // tool.execute.before — record start time only (span created atomically in after)
+    // For child sessions, tool spans are parented directly to the parent task span.
     // ------------------------------------------------------------------
     "tool.execute.before": async (toolInput, _output) => {
+      var _a;
       try {
         const { tool, sessionID, callID } = toolInput;
         const state = sessions.get(sessionID);
-        if (!state || !state.currentTurnSpan) return;
-        state.toolStartTimes.set(callID, Date.now());
-        const toolSpan = traceShipper.startSpan({
-          name: tool,
-          parent: state.currentTurnSpan.ids,
-          eventId: state.eventId,
-          attributes: [attrString("tool.name", tool)]
-        });
-        state.toolSpans.set(callID, toolSpan);
-        log("Tool execute before", { tool, sessionID, callID });
+        if (!state || !state.currentEventId) return;
+        const spanParent = state.parentId && state.parentTaskSpanIds ? state.parentTaskSpanIds : (_a = state.currentRootSpan) == null ? void 0 : _a.ids;
+        if (!spanParent) return;
+        const startTimeUnixNano = nowUnixNanoString();
+        if (tool === "task") {
+          const liveTaskSpan = traceShipper.startSpan({
+            name: "ai.toolCall",
+            parent: spanParent,
+            eventId: state.currentEventId,
+            attributes: [
+              attrString("ai.operationId", "ai.toolCall"),
+              attrString("ai.toolCall.name", tool),
+              attrString("ai.toolCall.id", callID)
+            ]
+          });
+          liveTaskSpan.startTimeUnixNano = startTimeUnixNano;
+          const ctx = {
+            ids: liveTaskSpan.ids,
+            eventContext: {
+              eventId: state.currentEventId,
+              userId: state.sessionId,
+              convoId: state.sessionId
+            }
+          };
+          taskContexts.set(callKey(sessionID, callID), ctx);
+          let running = runningTaskCallsBySession.get(sessionID);
+          if (running == null) {
+            running = /* @__PURE__ */ new Set();
+            runningTaskCallsBySession.set(sessionID, running);
+          }
+          running.add(callID);
+          resolvePendingChildrenForCall(sessionID, callID, "tool.execute.before");
+          state.toolSpanStarts.set(callID, {
+            startTimeUnixNano,
+            parent: spanParent,
+            eventId: state.currentEventId,
+            name: tool,
+            liveSpan: liveTaskSpan
+          });
+        } else {
+          state.toolSpanStarts.set(callID, {
+            startTimeUnixNano,
+            parent: spanParent,
+            eventId: state.currentEventId,
+            name: tool
+          });
+        }
       } catch (err) {
-        log("Error in tool.execute.before hook", { error: String(err) });
       }
     },
     // ------------------------------------------------------------------
-    // tool.execute.after — finalize tool span
+    // tool.execute.after — create tool span atomically with both start and end times
     // ------------------------------------------------------------------
     "tool.execute.after": async (toolInput, result) => {
-      var _a;
       try {
-        const { tool, sessionID, callID } = toolInput;
+        const { tool, sessionID, callID, args } = toolInput;
         const state = sessions.get(sessionID);
-        if (!state) return;
+        if (!state || !state.currentEventId) return;
         state.toolCount++;
-        state.toolStartTimes.delete(callID);
-        state.toolCallMessageIds.delete(callID);
-        const toolSpan = state.toolSpans.get(callID);
-        state.toolSpans.delete(callID);
-        if (toolSpan) {
-          const outputPreview = typeof result.output === "string" ? result.output.slice(0, 200) : JSON.stringify((_a = result.output) != null ? _a : "").slice(0, 200);
-          traceShipper.endSpan(toolSpan, {
-            attributes: [
-              attrString("tool.title", result.title),
-              attrString("tool.output_preview", outputPreview)
-            ]
+        if (args === void 0 || args === null)
+          throw new Error("tool.execute.after: args is required");
+        const toolCallArgs = typeof args === "string" ? args : JSON.stringify(args);
+        const startInfo = state.toolSpanStarts.get(callID);
+        state.toolSpanStarts.delete(callID);
+        const resultMetadata = result.metadata;
+        const childSessionId = resultMetadata == null ? void 0 : resultMetadata["sessionId"];
+        if (tool === "task" && childSessionId) {
+          mapChildSessionToParent.set(childSessionId, { parentId: sessionID });
+          attachChildSessionToParentTask(childSessionId, sessionID, callID, "tool.execute.after");
+        }
+        if (startInfo) {
+          const endTimeUnixNano = nowUnixNanoString();
+          if (!("output" in result) || result.output === void 0)
+            throw new Error("tool.execute.after: result.output is required");
+          let toolResult;
+          try {
+            toolResult = JSON.stringify(result.output);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`tool.execute.after: result.output must be JSON-serializable: ${msg}`);
+          }
+          if (startInfo.liveSpan) {
+            traceShipper.endSpan(startInfo.liveSpan, {
+              attributes: [
+                attrString("ai.toolCall.args", toolCallArgs),
+                attrString("ai.toolCall.result", toolResult)
+              ]
+            });
+          } else {
+            traceShipper.createSpan({
+              name: "ai.toolCall",
+              parent: startInfo.parent,
+              eventId: startInfo.eventId,
+              startTimeUnixNano: startInfo.startTimeUnixNano,
+              endTimeUnixNano,
+              attributes: [
+                attrString("ai.operationId", "ai.toolCall"),
+                attrString("ai.toolCall.name", tool),
+                attrString("ai.toolCall.id", callID),
+                attrString("ai.toolCall.args", toolCallArgs),
+                attrString("ai.toolCall.result", toolResult)
+              ]
+            });
+          }
+        }
+        if (tool === "task") {
+          const running = runningTaskCallsBySession.get(sessionID);
+          if (running) {
+            running.delete(callID);
+            if (running.size === 0) runningTaskCallsBySession.delete(sessionID);
+          }
+        }
+        if (!state.parentId) {
+          await eventShipper.patch(state.currentEventId, {
+            userId: state.sessionId,
+            properties: { tool_count: state.toolCount }
           });
         }
-        await eventShipper.patch(state.eventId, {
-          properties: { tool_count: state.toolCount }
-        });
-        log("Tool execute after", { tool, sessionID, callID });
       } catch (err) {
-        log("Error in tool.execute.after hook", { error: String(err) });
       }
     }
   };
@@ -848,25 +1159,16 @@ type: ${errorName}`;
 // src/index.ts
 async function plugin(input) {
   var _a;
-  const { client } = input;
   const config = loadConfig(input.directory);
   function appLog(level, message) {
-    var _a2, _b;
-    (_b = (_a2 = client.app.log({
-      body: {
-        service: "raindrop-opencode",
-        level,
-        message
-      }
-    })) == null ? void 0 : _a2.catch) == null ? void 0 : _b.call(_a2, () => {
-    });
+    console.log(`[raindrop-ai/opencode-plugin] [${level}] ${message}`);
   }
   if (!config.writeKey) {
     appLog(
       "warn",
       "RAINDROP_WRITE_KEY not set \u2014 Raindrop tracing disabled. Set it in your environment or in ~/.config/opencode/raindrop.json."
     );
-    return { hooks: {} };
+    return {};
   }
   if (config.debug) {
     appLog("info", `Raindrop tracing enabled (endpoint: ${config.endpoint})`);
@@ -883,14 +1185,13 @@ async function plugin(input) {
   });
   const worktree = (_a = input.worktree) != null ? _a : input.directory;
   const hooks = createHooks(
-    client,
     config,
     worktree,
     input.directory,
     eventShipper,
     traceShipper
   );
-  return { hooks };
+  return hooks;
 }
 export {
   plugin as default