@raindrop-ai/pi-agent 0.0.2

package/dist/index.js

@@ -0,0 +1,498 @@
+import {
+  EventShipper,
+  TraceShipper,
+  attrInt,
+  attrString,
+  extractAssistantText,
+  extractModelName,
+  extractTokenUsage,
+  extractToolCallIds,
+  extractUserText,
+  formatToolSpanName,
+  getHostname,
+  getUsername,
+  libraryVersion,
+  randomUUID,
+  safeStringify,
+  truncate
+} from "./chunk-LZIGXU2D.js";
+
+// src/internal/subscriber.ts
+function createSubscriber(agent, eventShipper, traceShipper, defaultOptions, options, debug) {
+  var _a, _b, _c, _d, _e;
+  const userId = (_a = options.userId) != null ? _a : defaultOptions.userId;
+  const convoId = (_b = options.convoId) != null ? _b : defaultOptions.convoId;
+  const eventName = (_c = options.eventName) != null ? _c : defaultOptions.eventName;
+  const properties = {
+    ...(_d = defaultOptions.properties) != null ? _d : {},
+    ...(_e = options.properties) != null ? _e : {}
+  };
+  let currentRun;
+  function log(msg) {
+    if (debug) console.log(`[raindrop-ai/pi-agent] ${msg}`);
+  }
+  function handleAgentStart() {
+    try {
+      if (currentRun) {
+        if (traceShipper) {
+          for (const [, span] of currentRun.toolSpans) {
+            traceShipper.endSpan(span);
+          }
+        }
+        if (currentRun.currentTurnSpan && traceShipper) {
+          traceShipper.endSpan(currentRun.currentTurnSpan);
+        }
+        if (currentRun.rootSpan && traceShipper) {
+          traceShipper.endSpan(currentRun.rootSpan, {
+            error: "Previous run was not finalized"
+          });
+        }
+        if (eventShipper) {
+          eventShipper.finish(currentRun.eventId, {
+            userId: userId != null ? userId : "anonymous",
+            properties: { sdk_version: libraryVersion, incomplete: true }
+          }).catch(() => {
+          });
+        }
+        currentRun = void 0;
+      }
+      const eventId = randomUUID();
+      const rootSpan = traceShipper ? traceShipper.startSpan({
+        name: "ai.event",
+        eventId,
+        attributes: [
+          attrString("hostname", getHostname()),
+          attrString("os", process.platform),
+          attrString("username", getUsername())
+        ]
+      }) : void 0;
+      currentRun = {
+        eventId,
+        rootSpan,
+        currentInput: "",
+        outputParts: [],
+        toolSpans: /* @__PURE__ */ new Map(),
+        toolArgs: /* @__PURE__ */ new Map(),
+        toolCallToLlmSpan: /* @__PURE__ */ new Map(),
+        lastModel: "",
+        turnNumber: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCacheReadTokens: 0
+      };
+      if (eventShipper) {
+        eventShipper.patch(eventId, {
+          isPending: true,
+          userId: userId != null ? userId : "anonymous",
+          convoId,
+          eventName,
+          properties: {
+            ...properties,
+            sdk_version: libraryVersion,
+            hostname: getHostname(),
+            os: process.platform
+          }
+        }).catch(() => {
+        });
+      }
+    } catch (err) {
+      log(`Error in agent_start handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleMessageEnd(message) {
+    try {
+      if (!currentRun) return;
+      const userText = extractUserText(message);
+      if (userText !== void 0) {
+        currentRun.currentInput = userText;
+        if (eventShipper) {
+          eventShipper.patch(currentRun.eventId, { input: userText }).catch(() => {
+          });
+        }
+        return;
+      }
+      if (!("role" in message) || message.role !== "assistant") return;
+      const model = extractModelName(message);
+      const usage = extractTokenUsage(message);
+      const assistantText = extractAssistantText(message);
+      if (model) currentRun.lastModel = model;
+      if (usage) {
+        currentRun.totalInputTokens += usage.input;
+        currentRun.totalOutputTokens += usage.output;
+        if (usage.cacheRead) currentRun.totalCacheReadTokens += usage.cacheRead;
+      }
+      if (!traceShipper || !currentRun.currentTurnSpan) return;
+      const rawProvider = "provider" in message && typeof message.provider === "string" ? message.provider : void 0;
+      const rawModelId = typeof message.model === "string" ? message.model : void 0;
+      const stopReason = "stopReason" in message && typeof message.stopReason === "string" ? message.stopReason : void 0;
+      const llmAttrs = [
+        attrString("ai.operationId", "generateText")
+      ];
+      if (rawProvider) {
+        llmAttrs.push(attrString("gen_ai.system", rawProvider));
+      }
+      if (rawModelId) {
+        llmAttrs.push(
+          attrString("gen_ai.response.model", rawModelId),
+          attrString("gen_ai.request.model", rawModelId)
+        );
+      }
+      if (usage) {
+        llmAttrs.push(
+          attrInt("gen_ai.usage.input_tokens", usage.input),
+          attrInt("gen_ai.usage.output_tokens", usage.output)
+        );
+        if (usage.cacheRead) {
+          llmAttrs.push(attrInt("gen_ai.usage.cache_read_tokens", usage.cacheRead));
+        }
+      }
+      if (assistantText) {
+        llmAttrs.push(attrString("ai.response.text", truncate(assistantText)));
+      }
+      if (currentRun.currentInput) {
+        llmAttrs.push(attrString("ai.prompt", truncate(currentRun.currentInput)));
+      }
+      if (stopReason) {
+        llmAttrs.push(attrString("ai.stop_reason", stopReason));
+      }
+      const llmSpan = traceShipper.startSpan({
+        name: model != null ? model : "llm",
+        parent: currentRun.currentTurnSpan.ids,
+        eventId: currentRun.eventId,
+        attributes: llmAttrs
+      });
+      const errorForSpan = stopReason === "error" || stopReason === "aborted" ? "errorMessage" in message && typeof message.errorMessage === "string" ? message.errorMessage : `Assistant ${stopReason}` : void 0;
+      traceShipper.endSpan(llmSpan, errorForSpan ? { error: errorForSpan } : void 0);
+      const toolCallIds = extractToolCallIds(message);
+      for (const tcId of toolCallIds) {
+        currentRun.toolCallToLlmSpan.set(tcId, llmSpan);
+      }
+    } catch (err) {
+      log(`Error in message_end handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleMessageUpdate(event) {
+    try {
+      if (!currentRun) return;
+      const ame = event.assistantMessageEvent;
+      if (ame.type === "text_delta" && "delta" in ame && typeof ame.delta === "string") {
+        currentRun.outputParts.push(ame.delta);
+      }
+    } catch (err) {
+      log(`Error in message_update handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleTurnStart() {
+    try {
+      if (!currentRun) return;
+      currentRun.outputParts = [];
+      if (!traceShipper || !currentRun.rootSpan) return;
+      if (currentRun.currentTurnSpan) {
+        traceShipper.endSpan(currentRun.currentTurnSpan);
+      }
+      currentRun.turnNumber += 1;
+      currentRun.currentTurnSpan = traceShipper.startSpan({
+        name: `Turn ${currentRun.turnNumber}`,
+        parent: currentRun.rootSpan.ids,
+        eventId: currentRun.eventId,
+        attributes: [
+          attrString("ai.operationId", "ai.turn"),
+          attrInt("ai.turn_number", currentRun.turnNumber)
+        ]
+      });
+    } catch (err) {
+      log(`Error in turn_start handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleTurnEnd() {
+    try {
+      if (!currentRun || !traceShipper || !currentRun.currentTurnSpan) return;
+      traceShipper.endSpan(currentRun.currentTurnSpan);
+      currentRun.currentTurnSpan = void 0;
+    } catch (err) {
+      log(`Error in turn_end handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleToolExecutionStart(toolCallId, toolName, args) {
+    var _a2;
+    try {
+      if (!currentRun) return;
+      currentRun.toolArgs.set(toolCallId, args);
+      if (!traceShipper) return;
+      const parentLlmSpan = currentRun.toolCallToLlmSpan.get(toolCallId);
+      const parentSpan = (_a2 = parentLlmSpan != null ? parentLlmSpan : currentRun.currentTurnSpan) != null ? _a2 : currentRun.rootSpan;
+      if (!parentSpan) return;
+      const toolSpan = traceShipper.startSpan({
+        name: formatToolSpanName(toolName, args),
+        parent: parentSpan.ids,
+        eventId: currentRun.eventId,
+        attributes: [
+          attrString("ai.operationId", "ai.toolCall"),
+          attrString("ai.toolCall.name", toolName),
+          attrString("ai.toolCall.id", toolCallId)
+        ]
+      });
+      currentRun.toolSpans.set(toolCallId, toolSpan);
+    } catch (err) {
+      log(`Error in tool_execution_start handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleToolExecutionEnd(toolCallId, toolName, result, isError) {
+    try {
+      if (!currentRun) return;
+      const toolSpan = currentRun.toolSpans.get(toolCallId);
+      currentRun.toolSpans.delete(toolCallId);
+      currentRun.toolCallToLlmSpan.delete(toolCallId);
+      const args = currentRun.toolArgs.get(toolCallId);
+      currentRun.toolArgs.delete(toolCallId);
+      if (!traceShipper || !toolSpan) return;
+      const endAttrs = [];
+      const argsStr = truncate(safeStringify(args));
+      if (argsStr) endAttrs.push(attrString("ai.toolCall.args", argsStr));
+      const resultStr = truncate(safeStringify(result));
+      if (resultStr) endAttrs.push(attrString("ai.toolCall.result", resultStr));
+      traceShipper.endSpan(toolSpan, {
+        attributes: endAttrs,
+        ...isError ? { error: `Tool "${toolName}" failed` } : {}
+      });
+    } catch (err) {
+      log(`Error in tool_execution_end handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function handleAgentEnd() {
+    try {
+      if (!currentRun) return;
+      const run = currentRun;
+      currentRun = void 0;
+      if (traceShipper) {
+        for (const [, span] of run.toolSpans) {
+          traceShipper.endSpan(span);
+        }
+      }
+      run.toolSpans.clear();
+      run.toolCallToLlmSpan.clear();
+      if (run.currentTurnSpan && traceShipper) {
+        traceShipper.endSpan(run.currentTurnSpan);
+        run.currentTurnSpan = void 0;
+      }
+      const outputText = run.outputParts.join("");
+      if (traceShipper && run.rootSpan) {
+        const rootAttrs = [
+          attrString("ai.operationId", "generateText")
+        ];
+        if (run.lastModel) {
+          run.rootSpan.name = run.lastModel;
+          rootAttrs.push(attrString("gen_ai.response.model", run.lastModel));
+        }
+        if (run.currentInput) {
+          rootAttrs.push(attrString("ai.prompt", truncate(run.currentInput)));
+        }
+        if (outputText) {
+          rootAttrs.push(attrString("ai.response.text", truncate(outputText)));
+        }
+        if (run.totalInputTokens > 0) {
+          rootAttrs.push(attrInt("gen_ai.usage.input_tokens", run.totalInputTokens));
+        }
+        if (run.totalOutputTokens > 0) {
+          rootAttrs.push(attrInt("gen_ai.usage.output_tokens", run.totalOutputTokens));
+        }
+        if (run.totalCacheReadTokens > 0) {
+          rootAttrs.push(attrInt("gen_ai.usage.cache_read_tokens", run.totalCacheReadTokens));
+        }
+        rootAttrs.push(attrInt("ai.total_turns", run.turnNumber));
+        traceShipper.endSpan(run.rootSpan, { attributes: rootAttrs });
+      }
+      if (eventShipper) {
+        eventShipper.finish(run.eventId, {
+          userId: userId != null ? userId : "anonymous",
+          model: run.lastModel || void 0,
+          output: outputText || void 0,
+          properties: {
+            ...properties,
+            sdk_version: libraryVersion,
+            ...run.totalInputTokens > 0 ? { "ai.usage.prompt_tokens": run.totalInputTokens } : {},
+            ...run.totalOutputTokens > 0 ? { "ai.usage.completion_tokens": run.totalOutputTokens } : {},
+            ...run.totalCacheReadTokens > 0 ? { "ai.usage.cache_read_tokens": run.totalCacheReadTokens } : {}
+          }
+        }).catch(() => {
+        });
+      }
+      Promise.all([
+        eventShipper == null ? void 0 : eventShipper.flush(),
+        traceShipper == null ? void 0 : traceShipper.flush()
+      ]).catch(() => {
+      });
+    } catch (err) {
+      log(`Error in agent_end handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const unsubscribe = agent.subscribe((event) => {
+    try {
+      switch (event.type) {
+        case "agent_start":
+          handleAgentStart();
+          break;
+        case "message_end":
+          handleMessageEnd(event.message);
+          break;
+        case "message_update":
+          handleMessageUpdate(event);
+          break;
+        case "turn_start":
+          handleTurnStart();
+          break;
+        case "turn_end":
+          handleTurnEnd();
+          break;
+        case "tool_execution_start":
+          handleToolExecutionStart(event.toolCallId, event.toolName, event.args);
+          break;
+        case "tool_execution_end":
+          handleToolExecutionEnd(
+            event.toolCallId,
+            event.toolName,
+            event.result,
+            event.isError
+          );
+          break;
+        case "agent_end":
+          handleAgentEnd();
+          break;
+      }
+    } catch (err) {
+      log(`Unhandled error in event handler: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  });
+  return unsubscribe;
+}
+
+// src/index.ts
+function envDebugEnabled() {
+  var _a;
+  if (typeof process === "undefined") return false;
+  const flag = (_a = process.env) == null ? void 0 : _a.RAINDROP_AI_DEBUG;
+  return flag === "1" || flag === "true";
+}
+function createRaindropPiAgent(opts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const hasWriteKey = typeof opts.writeKey === "string" && opts.writeKey.trim().length > 0;
+  const eventsEnabled = ((_a = opts.events) == null ? void 0 : _a.enabled) !== false;
+  const tracesEnabled = ((_b = opts.traces) == null ? void 0 : _b.enabled) !== false;
+  if (!hasWriteKey && !opts.endpoint) {
+    console.warn(
+      "[raindrop-ai/pi-agent] writeKey not provided; telemetry shipping is disabled"
+    );
+  }
+  const envDebug = envDebugEnabled();
+  const debug = ((_c = opts.events) == null ? void 0 : _c.debug) === true || ((_d = opts.traces) == null ? void 0 : _d.debug) === true || envDebug;
+  const eventShipper = eventsEnabled && (hasWriteKey || opts.endpoint) ? new EventShipper({
+    writeKey: opts.writeKey,
+    endpoint: opts.endpoint,
+    enabled: true,
+    debug: ((_e = opts.events) == null ? void 0 : _e.debug) === true || envDebug,
+    partialFlushMs: (_f = opts.events) == null ? void 0 : _f.partialFlushMs
+  }) : null;
+  const traceShipper = tracesEnabled && (hasWriteKey || opts.endpoint) ? new TraceShipper({
+    writeKey: opts.writeKey,
+    endpoint: opts.endpoint,
+    enabled: true,
+    debug: ((_g = opts.traces) == null ? void 0 : _g.debug) === true || envDebug,
+    debugSpans: ((_h = opts.traces) == null ? void 0 : _h.debugSpans) === true || envDebug,
+    flushIntervalMs: (_i = opts.traces) == null ? void 0 : _i.flushIntervalMs,
+    maxBatchSize: (_j = opts.traces) == null ? void 0 : _j.maxBatchSize,
+    maxQueueSize: (_k = opts.traces) == null ? void 0 : _k.maxQueueSize
+  }) : null;
+  const defaultOptions = {
+    userId: opts.userId,
+    convoId: opts.convoId,
+    eventName: opts.eventName,
+    properties: opts.properties
+  };
+  return {
+    subscribe(agent, options) {
+      return createSubscriber(
+        agent,
+        eventShipper,
+        traceShipper,
+        defaultOptions,
+        options != null ? options : {},
+        debug
+      );
+    },
+    events: {
+      async patch(eventId, data) {
+        if (!eventShipper) return;
+        await eventShipper.patch(eventId, data);
+      },
+      async addAttachments(eventId, attachments) {
+        if (!eventShipper) return;
+        await eventShipper.patch(eventId, { attachments });
+      },
+      async setProperties(eventId, properties) {
+        if (!eventShipper) return;
+        await eventShipper.patch(eventId, { properties });
+      },
+      async finish(eventId) {
+        if (!eventShipper) return;
+        await eventShipper.finish(eventId, {});
+      }
+    },
+    users: {
+      async identify(params) {
+        var _a2;
+        if (!eventShipper) return;
+        await eventShipper.identify([
+          { userId: params.userId, traits: (_a2 = params.traits) != null ? _a2 : {} }
+        ]);
+      }
+    },
+    signals: {
+      async track(params) {
+        if (!eventShipper) return;
+        if (!params.name || !params.name.trim()) {
+          console.warn("[raindrop-ai/pi-agent] signal name is required");
+          return;
+        }
+        const {
+          eventId,
+          name,
+          type,
+          sentiment,
+          timestamp,
+          attachmentId,
+          comment,
+          after,
+          ...otherProperties
+        } = params;
+        await eventShipper.trackSignal({
+          eventId: eventId != null ? eventId : "",
+          name,
+          type,
+          sentiment,
+          timestamp,
+          attachmentId,
+          comment,
+          after,
+          properties: otherProperties
+        });
+      }
+    },
+    async flush() {
+      var _a2, _b2;
+      await Promise.all([
+        (_a2 = eventShipper == null ? void 0 : eventShipper.flush()) != null ? _a2 : Promise.resolve(),
+        (_b2 = traceShipper == null ? void 0 : traceShipper.flush()) != null ? _b2 : Promise.resolve()
+      ]);
+    },
+    async shutdown() {
+      var _a2, _b2;
+      await Promise.all([
+        (_a2 = eventShipper == null ? void 0 : eventShipper.shutdown()) != null ? _a2 : Promise.resolve(),
+        (_b2 = traceShipper == null ? void 0 : traceShipper.shutdown()) != null ? _b2 : Promise.resolve()
+      ]);
+    }
+  };
+}
+export {
+  createRaindropPiAgent
+};

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@raindrop-ai/pi-agent",
+  "version": "0.0.2",
+  "description": "Raindrop observability for Pi Agent — automatic tracing via subscriber or pi-coding-agent extension",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raindrop-ai/raindrop-js.git",
+    "directory": "packages/pi-agent"
+  },
+  "homepage": "https://github.com/raindrop-ai/raindrop-js/tree/main/packages/pi-agent#readme",
+  "bugs": {
+    "url": "https://github.com/raindrop-ai/raindrop-js/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "raindrop",
+    "pi-agent",
+    "observability",
+    "tracing"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./extension": {
+      "types": "./dist/extension.d.ts",
+      "import": "./dist/extension.js",
+      "require": "./dist/extension.cjs"
+    }
+  },
+  "pi": {
+    "extensions": [
+      "./dist/extension.js"
+    ]
+  },
+  "sideEffects": false,
+  "files": [
+    "dist/**",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-agent-core": ">=0.60.0",
+    "@mariozechner/pi-coding-agent": ">=0.65.2"
+  },
+  "peerDependenciesMeta": {
+    "@mariozechner/pi-coding-agent": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@raindrop-ai/core": "workspace:*",
+    "@mariozechner/pi-agent-core": "^0.66.0",
+    "@mariozechner/pi-coding-agent": "^0.66.0",
+    "@types/node": "^20.11.17",
+    "msw": "^2.12.7",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.9"
+  },
+  "tsup": {
+    "entry": [
+      "src/index.ts",
+      "src/extension.ts"
+    ],
+    "format": [
+      "cjs",
+      "esm"
+    ],
+    "dts": {
+      "resolve": true
+    },
+    "clean": true,
+    "noExternal": [
+      "@raindrop-ai/core"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}