@raindrop-ai/opencode-plugin 0.1.4 → 0.2.0

package/dist/index.cjs

@@ -2337,7 +2337,7 @@ function resolveLocalWorkshopUrl(fileValue) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/opencode-plugin",
-  version: "0.1.4",
+  version: "0.2.0",
   description: "Raindrop observability plugin for OpenCode \u2014 automatic session/event/span tracing",
   type: "module",
   main: "dist/index.js",
@@ -2353,6 +2353,11 @@ var package_default = {
       types: "./dist/index.d.ts",
       import: "./dist/index.js",
       require: "./dist/index.cjs"
+    },
+    "./v2": {
+      types: "./dist/v2.d.ts",
+      import: "./dist/v2.js",
+      require: "./dist/v2.cjs"
     }
   },
   sideEffects: false,
@@ -2367,24 +2372,38 @@ var package_default = {
   },
   peerDependencies: {
     "@opencode-ai/plugin": ">=1.3.0",
-    "@opencode-ai/sdk": ">=1.3.0"
+    "@opencode-ai/sdk": ">=1.3.0",
+    "@opencode/plugin": ">=2.0.0",
+    "@opencode/sdk": ">=2.0.0"
   },
   peerDependenciesMeta: {
+    "@opencode-ai/plugin": {
+      optional: true
+    },
     "@opencode-ai/sdk": {
       optional: true
+    },
+    "@opencode/plugin": {
+      optional: true
+    },
+    "@opencode/sdk": {
+      optional: true
     }
   },
   devDependencies: {
     "@raindrop-ai/core": "workspace:*",
     "@opencode-ai/plugin": "^1.3.3",
     "@opencode-ai/sdk": "^1.3.3",
+    "@opencode/plugin": "^2.0.10",
+    "@opencode/sdk": "^2.0.10",
     "@types/node": "^20.11.17",
     tsup: "^8.4.0",
     typescript: "^5.3.3"
   },
   tsup: {
     entry: [
-      "src/index.ts"
+      "src/index.ts",
+      "src/v2.ts"
     ],
     format: [
       "cjs",

package/dist/index.d-vgBcEZbX.d.cts

@@ -0,0 +1,89 @@
+/** Kept structural so public integration declarations do not depend on private schemas. */
+type AppGitOptions = {
+    commitSha?: string | null;
+    commitDirty?: boolean | null;
+    branch?: string | null;
+    detectBranch?: boolean;
+    sourceDirectory?: string;
+    autoDetect?: boolean;
+};
+type IdentifyInput = {
+    userId: string;
+    traits?: Record<string, unknown>;
+};
+type SignalInput = {
+    eventId: string;
+    name: string;
+    type?: "default" | "feedback" | "edit" | "standard" | "agent" | "agent_internal";
+    sentiment?: "POSITIVE" | "NEGATIVE";
+    timestamp?: string;
+    properties?: Record<string, unknown>;
+    attachmentId?: string;
+    comment?: string;
+    after?: string;
+};
+
+/**
+ * Run telemetry egress with OpenTelemetry tracing suppressed.
+ *
+ * Why this exists
+ * ---------------
+ * Raindrop integrations ship spans/events over HTTP with the global `fetch`
+ * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
+ * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
+ * every Eve agent installs — that instrumentation wraps *our own* telemetry
+ * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
+ * very exporter that issued the request, so they get shipped right back to
+ * Raindrop and Workshop as standalone "runs" (and, because each export issues
+ * another fetch, they feed back on themselves). The result is a run list
+ * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
+ * `.../live` entries that drown out the real agent turns — especially with
+ * sub-agents, where every sandbox runs its own instrumentation.
+ *
+ * The OTel-blessed fix is to mark the active context as "tracing suppressed"
+ * around the request; instrumentations check `isTracingSuppressed` and return
+ * a no-op span instead of recording one. We do this through a hook stashed on
+ * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
+ *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
+ *     hard-depends on them, and the hook is simply absent when they (and thus
+ *     any instrumentation to suppress) are not installed; and
+ *   - the browser bundle never pulls in `node:module`, mirroring how core
+ *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
+ *
+ * When no hook is present the callback runs unchanged, so suppression is a
+ * best-effort no-op rather than a hard requirement.
+ */
+/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
+type SuppressTracingHook = <T>(fn: () => T) => T;
+declare global {
+    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+}
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+
+export type { AppGitOptions as A, IdentifyInput as I, SignalInput as S };

package/dist/index.d-vgBcEZbX.d.ts

@@ -0,0 +1,89 @@
+/** Kept structural so public integration declarations do not depend on private schemas. */
+type AppGitOptions = {
+    commitSha?: string | null;
+    commitDirty?: boolean | null;
+    branch?: string | null;
+    detectBranch?: boolean;
+    sourceDirectory?: string;
+    autoDetect?: boolean;
+};
+type IdentifyInput = {
+    userId: string;
+    traits?: Record<string, unknown>;
+};
+type SignalInput = {
+    eventId: string;
+    name: string;
+    type?: "default" | "feedback" | "edit" | "standard" | "agent" | "agent_internal";
+    sentiment?: "POSITIVE" | "NEGATIVE";
+    timestamp?: string;
+    properties?: Record<string, unknown>;
+    attachmentId?: string;
+    comment?: string;
+    after?: string;
+};
+
+/**
+ * Run telemetry egress with OpenTelemetry tracing suppressed.
+ *
+ * Why this exists
+ * ---------------
+ * Raindrop integrations ship spans/events over HTTP with the global `fetch`
+ * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
+ * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
+ * every Eve agent installs — that instrumentation wraps *our own* telemetry
+ * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
+ * very exporter that issued the request, so they get shipped right back to
+ * Raindrop and Workshop as standalone "runs" (and, because each export issues
+ * another fetch, they feed back on themselves). The result is a run list
+ * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
+ * `.../live` entries that drown out the real agent turns — especially with
+ * sub-agents, where every sandbox runs its own instrumentation.
+ *
+ * The OTel-blessed fix is to mark the active context as "tracing suppressed"
+ * around the request; instrumentations check `isTracingSuppressed` and return
+ * a no-op span instead of recording one. We do this through a hook stashed on
+ * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
+ *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
+ *     hard-depends on them, and the hook is simply absent when they (and thus
+ *     any instrumentation to suppress) are not installed; and
+ *   - the browser bundle never pulls in `node:module`, mirroring how core
+ *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
+ *
+ * When no hook is present the callback runs unchanged, so suppression is a
+ * best-effort no-op rather than a hard requirement.
+ */
+/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
+type SuppressTracingHook = <T>(fn: () => T) => T;
+declare global {
+    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+}
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+
+export type { AppGitOptions as A, IdentifyInput as I, SignalInput as S };

package/dist/index.d.cts

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

package/dist/index.d.ts

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