opencode-tracekit 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,5 +1,8 @@
+import { TraceKitPlugin } from "./src/opencode_plugin.js";
 import { createTraceKitPlugin } from "./src/tracekit_plugin.js";
 export { createTraceKitPlugin };
-export default createTraceKitPlugin;
-export type { TraceKitConfig, TraceKitPlugin } from "./src/tracekit_plugin.js";
+export { TraceKitPlugin };
+export default TraceKitPlugin;
+export { createOpenCodeTraceKit } from "./src/opencode_plugin.js";
+export type { TraceKitConfig, TraceKitPlugin as TraceKitCorePlugin } from "./src/tracekit_plugin.js";
 export type { TraceRecord } from "./src/trace_record.js";

package/dist/index.js

@@ -1,3 +1,6 @@
+import { TraceKitPlugin } from "./src/opencode_plugin.js";
 import { createTraceKitPlugin } from "./src/tracekit_plugin.js";
 export { createTraceKitPlugin };
-export default createTraceKitPlugin;
+export { TraceKitPlugin };
+export default TraceKitPlugin;
+export { createOpenCodeTraceKit } from "./src/opencode_plugin.js";

package/dist/src/opencode_plugin.d.ts

@@ -0,0 +1,83 @@
+import { type TraceKitConfig } from "./tracekit_plugin.js";
+interface OpenCodePluginContext {
+    workingDirectory?: string;
+}
+interface OpenCodeToolBeforeInput {
+    sessionID?: string;
+    sessionId?: string;
+    tool?: string;
+    callID?: string;
+    callId?: string;
+    id?: string;
+    [key: string]: unknown;
+}
+interface OpenCodeToolBeforeOutput {
+    args?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface OpenCodeToolAfterInput {
+    sessionID?: string;
+    sessionId?: string;
+    tool?: string;
+    callID?: string;
+    callId?: string;
+    id?: string;
+    [key: string]: unknown;
+}
+interface OpenCodeToolAfterOutput {
+    result?: unknown;
+    error?: unknown;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+    };
+    [key: string]: unknown;
+}
+interface OpenCodeExecContext {
+    sessionID?: string;
+    sessionId?: string;
+}
+interface OpenCodeToolDefinition {
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (args: Record<string, unknown>, execCtx: OpenCodeExecContext) => Promise<Record<string, unknown>>;
+}
+export declare function TraceKitPlugin(ctx: OpenCodePluginContext): Promise<{
+    "session.created": (input: {
+        sessionID?: string;
+        sessionId?: string;
+        parentID?: string;
+    }) => Promise<void>;
+    "session.idle": (input: {
+        sessionID?: string;
+        sessionId?: string;
+    }) => Promise<void>;
+    "tool.execute.before": (input: OpenCodeToolBeforeInput, output: OpenCodeToolBeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: OpenCodeToolAfterInput, output: OpenCodeToolAfterOutput) => Promise<void>;
+    "shutdown.before": () => Promise<void>;
+    tool: {
+        "trace.emit": OpenCodeToolDefinition;
+        "trace.counter": OpenCodeToolDefinition;
+        "trace.span": OpenCodeToolDefinition;
+    };
+}>;
+export declare function createOpenCodeTraceKit(config?: TraceKitConfig): (ctx: OpenCodePluginContext) => Promise<{
+    "session.created": (input: {
+        sessionID?: string;
+        sessionId?: string;
+        parentID?: string;
+    }) => Promise<void>;
+    "session.idle": (input: {
+        sessionID?: string;
+        sessionId?: string;
+    }) => Promise<void>;
+    "tool.execute.before": (input: OpenCodeToolBeforeInput, output: OpenCodeToolBeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: OpenCodeToolAfterInput, output: OpenCodeToolAfterOutput) => Promise<void>;
+    "shutdown.before": () => Promise<void>;
+    tool: {
+        "trace.emit": OpenCodeToolDefinition;
+        "trace.counter": OpenCodeToolDefinition;
+        "trace.span": OpenCodeToolDefinition;
+    };
+}>;
+export {};

package/dist/src/opencode_plugin.js

@@ -0,0 +1,122 @@
+import { createTraceKitPlugin } from "./tracekit_plugin.js";
+export async function TraceKitPlugin(ctx) {
+    return createOpenCodeTraceKit()(ctx);
+}
+function toRuntime(execCtx) {
+    return {
+        sessionId: String(execCtx.sessionID ?? execCtx.sessionId ?? "unknown-session"),
+        ts: Date.now(),
+    };
+}
+export function createOpenCodeTraceKit(config = {}) {
+    return async (ctx) => {
+        const workingDirectory = ctx.workingDirectory ?? process.cwd();
+        const core = createTraceKitPlugin({
+            outPath: `${workingDirectory}/trace.ndjson`,
+            ...config,
+        });
+        return {
+            "session.created": async (input) => {
+                core.hooks.onSessionStart({
+                    sessionId: String(input.sessionID ?? input.sessionId ?? "unknown-session"),
+                    parentSessionId: input.parentID ? String(input.parentID) : undefined,
+                });
+            },
+            "session.idle": async (input) => {
+                core.hooks.onSessionEnd({
+                    sessionId: String(input.sessionID ?? input.sessionId ?? "unknown-session"),
+                });
+            },
+            "tool.execute.before": async (input, output) => {
+                core.hooks.onToolStart({
+                    sessionId: String(input.sessionID ?? input.sessionId ?? "unknown-session"),
+                    toolName: String(input.tool ?? "unknown-tool"),
+                    toolCallId: String(input.callID ?? input.callId ?? input.id ?? `${Date.now()}`),
+                    input: output.args ?? {},
+                });
+            },
+            "tool.execute.after": async (input, output) => {
+                core.hooks.onToolEnd({
+                    sessionId: String(input.sessionID ?? input.sessionId ?? "unknown-session"),
+                    toolName: String(input.tool ?? "unknown-tool"),
+                    toolCallId: String(input.callID ?? input.callId ?? input.id ?? `${Date.now()}`),
+                    output: output.result,
+                    error: output.error,
+                    usage: {
+                        promptTokens: output.usage?.prompt_tokens,
+                        completionTokens: output.usage?.completion_tokens,
+                    },
+                });
+            },
+            "shutdown.before": async () => {
+                await core.shutdown();
+            },
+            tool: {
+                "trace.emit": defineTool({
+                    description: "Emit a tracepoint for current session",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            level: { type: "string", enum: ["info", "warn", "error"] },
+                            attrs: { type: "object", additionalProperties: true },
+                            links: { type: "array", items: { type: "object", additionalProperties: true } },
+                        },
+                        required: ["name"],
+                    },
+                    execute: async (args, execCtx) => {
+                        const runtime = toRuntime(execCtx);
+                        const emit = core.tools.find((t) => t.name === "trace.emit");
+                        if (!emit)
+                            return { ok: false, reason: "trace.emit tool missing" };
+                        return emit.handler(args, runtime);
+                    },
+                }),
+                "trace.counter": defineTool({
+                    description: "Emit a counter metric for current session",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            value: { type: "number" },
+                            attrs: { type: "object", additionalProperties: true },
+                        },
+                        required: ["name", "value"],
+                    },
+                    execute: async (args, execCtx) => {
+                        const runtime = toRuntime(execCtx);
+                        const counter = core.tools.find((t) => t.name === "trace.counter");
+                        if (!counter)
+                            return { ok: false, reason: "trace.counter tool missing" };
+                        return counter.handler(args, runtime);
+                    },
+                }),
+                "trace.span": defineTool({
+                    description: "Create a manual span for phase tracking",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            op: { type: "string", enum: ["start", "end"] },
+                            spanId: { type: "string" },
+                            name: { type: "string" },
+                            kind: { type: "string", enum: ["manual", "message", "model", "tool", "skill"] },
+                            status: { type: "string", enum: ["ok", "error", "unknown"] },
+                            attrs: { type: "object", additionalProperties: true },
+                        },
+                        required: ["op"],
+                    },
+                    execute: async (args, execCtx) => {
+                        const runtime = toRuntime(execCtx);
+                        const span = core.tools.find((t) => t.name === "trace.span");
+                        if (!span)
+                            return { ok: false, reason: "trace.span tool missing" };
+                        return span.handler(args, runtime);
+                    },
+                }),
+            },
+        };
+    };
+}
+function defineTool(toolDef) {
+    return toolDef;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-tracekit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Tracepoint and tracing plugin for OpenCode (agent/skill/tool spans, emit/export/analyze).",
   "license": "MIT",
   "type": "module",