@ramarivera/coding-agent-langfuse 0.1.18 → 0.1.19

package/dist/backfill.js

@@ -5,7 +5,11 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSy
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 const allAgents = ["claude", "codex", "grok", "opencode", "pi"];
-const importIdentityVersion = "v9-codex-conversation-events";
+const importIdentityVersion = "v8-cached-input-token-split";
+const importIdentityVersions = {
+    codex: "v9-codex-conversation-events",
+    opencode: "v10-opencode-message-parts",
+};
 const defaultEndpoint = "https://langfuse.ai.roxasroot.net/otel/v1/traces";
 const deadRemoteEndpoint = "http://langfuse.ai.roxasroot.net:14318/v1/traces";
 const defaultStatePath = join(homedir(), ".local/state/coding-agent-langfuse/backfill-v6.json");
@@ -635,6 +639,7 @@ function opencodeEvents(homeDir, rowLimit) {
         return [];
     let sessions = [];
     let messages = [];
+    let parts = [];
     try {
         sessions = sqliteJsonByRowid(db, "session", "id, directory, time_created, time_updated, title, version, slug, project_id", undefined, rowLimit, 5_000);
         messages = sqliteJsonByRowid(db, "message", [
@@ -656,12 +661,31 @@ function opencodeEvents(homeDir, rowLimit) {
             "json_extract(data, '$.mode') as mode",
             "json_extract(data, '$.error') as error",
         ].join(", "), undefined, rowLimit, 5_000);
+        parts = sqliteJsonByRowid(db, "part", [
+            "id",
+            "message_id",
+            "session_id",
+            "time_created",
+            "time_updated",
+            "json_extract(data, '$.type') as type",
+            "json_extract(data, '$') as data",
+        ].join(", "), undefined, rowLimit, 5_000);
     }
     catch (error) {
         console.error(`Skipping OpenCode history from ${db}: ${error instanceof Error ? error.message : String(error)}`);
         return [];
     }
     const sessionsById = new Map(sessions.map((row) => [asString(row.id), row]));
+    const partsByMessageId = new Map();
+    for (const part of parts) {
+        const messageId = asString(part.message_id);
+        if (!messageId)
+            continue;
+        partsByMessageId.set(messageId, [
+            ...(partsByMessageId.get(messageId) ?? []),
+            part,
+        ]);
+    }
     const events = [];
     for (const session of sessions) {
         const sessionId = asString(session.id);
@@ -682,15 +706,21 @@ function opencodeEvents(homeDir, rowLimit) {
     for (const message of messages) {
         const sessionId = asString(message.session_id);
         const session = sessionsById.get(sessionId);
+        const messageId = asString(message.id) ?? stableId(JSON.stringify(message));
+        const role = asString(message.role);
+        const messageParts = [...(partsByMessageId.get(messageId) ?? [])].sort((a, b) => getTimestampMs(a.time_created) - getTimestampMs(b.time_created));
+        const textOutput = opencodeTextFromParts(messageParts);
+        const textInput = role === "user" ? textOutput : undefined;
+        const output = role === "assistant" ? textOutput : undefined;
         const tokens = normalizeUsage(parseMaybeJson(message.tokens));
         const usage = tokens ?? normalizeUsage(parseMaybeJson(message.usage));
         events.push({
             agent: "opencode",
             sourcePath: db,
             sessionId: sessionId ?? stableId(db),
-            recordId: asString(message.id) ?? stableId(JSON.stringify(message)),
-            name: `opencode ${asString(message.role) ?? "message"}`,
-            role: asString(message.role),
+            recordId: messageId,
+            name: `opencode ${role ?? "message"}`,
+            role,
             model: asString(message.model_id) ?? asString(message.nested_model_id),
             provider: asString(message.provider_id) ??
                 asString(message.nested_provider_id),
@@ -699,12 +729,86 @@ function opencodeEvents(homeDir, rowLimit) {
             startMs: getTimestampMs(message.time_created),
             endMs: getTimestampMs(message.time_updated),
             parentRecordId: asString(message.parent_id) ?? "session",
+            input: textInput,
+            output,
             usage,
             metadata: pick(message, ["agent", "mode", "error"]),
         });
+        for (const part of messageParts) {
+            const data = asRecord(parseMaybeJson(part.data));
+            const type = asString(part.type) ?? asString(data.type);
+            const partId = asString(part.id) ?? stableId(JSON.stringify(part));
+            const partStartMs = getTimestampMs(part.time_created, getTimestampMs(message.time_created));
+            if (type === "reasoning") {
+                events.push({
+                    agent: "opencode",
+                    sourcePath: db,
+                    sessionId: sessionId ?? stableId(db),
+                    recordId: `reasoning-${partId}`,
+                    name: "opencode reasoning",
+                    model: asString(message.model_id) ?? asString(message.nested_model_id),
+                    provider: asString(message.provider_id) ??
+                        asString(message.nested_provider_id),
+                    cwd: asString(message.cwd) ??
+                        asString(asRecord(session).directory),
+                    startMs: partStartMs,
+                    endMs: getTimestampMs(part.time_updated, partStartMs + 1),
+                    parentRecordId: messageId,
+                    output: extractText(data.text),
+                    metadata: {
+                        has_encrypted_content: getPath(data, ["metadata", "openai", "reasoningEncryptedContent"]) !== undefined,
+                    },
+                });
+            }
+            if (type === "tool") {
+                const state = asRecord(data.state);
+                const callId = asString(data.callID) ?? asString(data.call_id) ?? partId;
+                events.push({
+                    agent: "opencode",
+                    sourcePath: db,
+                    sessionId: sessionId ?? stableId(db),
+                    recordId: `tool-${callId}`,
+                    name: `opencode tool ${asString(data.tool) ?? "call"}`,
+                    model: asString(message.model_id) ?? asString(message.nested_model_id),
+                    provider: asString(message.provider_id) ??
+                        asString(message.nested_provider_id),
+                    cwd: asString(message.cwd) ??
+                        asString(asRecord(session).directory),
+                    startMs: partStartMs,
+                    endMs: getTimestampMs(part.time_updated, partStartMs + 1),
+                    parentRecordId: messageId,
+                    input: state.input,
+                    output: state.output,
+                    metadata: {
+                        status: asString(state.status),
+                        title: asString(state.title),
+                    },
+                });
+            }
+        }
     }
     return events;
 }
+function opencodeTextFromParts(parts) {
+    const text = parts
+        .map((part) => {
+        const data = asRecord(parseMaybeJson(part.data));
+        const type = asString(part.type) ?? asString(data.type);
+        if (type === "text")
+            return extractText(data.text, 8000);
+        if (type === "file") {
+            const filename = asString(data.filename);
+            const url = asString(data.url);
+            if (filename && url)
+                return `${filename}\n${url}`;
+            return filename ?? url;
+        }
+        return undefined;
+    })
+        .filter((value) => Boolean(value))
+        .join("\n");
+    return text ? text.slice(0, 8000) : undefined;
+}
 function sqliteJson(db, sql) {
     const output = execFileSync("sqlite3", ["-readonly", "-json", db, sql], {
         encoding: "utf8",
@@ -851,11 +955,14 @@ function parseMaybeJson(value) {
 function stableId(input) {
     return createHash("sha256").update(input).digest("hex").slice(0, 32);
 }
+function importIdentity(event) {
+    return importIdentityVersions[event.agent] ?? importIdentityVersion;
+}
 function fingerprint(event) {
-    return `${importIdentityVersion}:${event.agent}:${event.sessionId}:${event.recordId}`;
+    return `${importIdentity(event)}:${event.agent}:${event.sessionId}:${event.recordId}`;
 }
 function traceFingerprint(event) {
-    return `${importIdentityVersion}:${event.agent}:${event.sessionId}`;
+    return `${importIdentity(event)}:${event.agent}:${event.sessionId}`;
 }
 function traceId(event) {
     return stableId(traceFingerprint(event));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ramarivera/coding-agent-langfuse",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Universal coding-agent Langfuse backfiller and live OTLP helpers",
   "type": "module",
   "license": "MIT",