@ramarivera/coding-agent-langfuse 0.1.0 → 0.1.4

package/dist/backfill.js

@@ -0,0 +1,1000 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const allAgents = ["claude", "codex", "grok", "opencode", "pi"];
+const importIdentityVersion = "v6-session-traces-with-generations-and-costs";
+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/langfuse-backfill/state.json");
+function usage() {
+    return `Usage: node --experimental-strip-types backfill.ts [options]
+
+Options:
+  --endpoint URL          OTLP HTTP traces endpoint (default: ${defaultEndpoint})
+  --agents LIST           Comma-separated agents: claude,codex,grok,opencode,pi
+  --state PATH            Dedupe state file (default: ${defaultStatePath})
+  --home PATH             Home directory to scan (default: current user home)
+  --since ISO_OR_MS       Only import events at or after this timestamp
+  --until ISO_OR_MS       Only import events before or at this timestamp
+  --limit N               Stop after N unsent events
+  --batch-size N          OTLP spans per POST (default: 50)
+  --dry-run               Discover and dedupe without sending or mutating state
+  --help                  Show this help
+`;
+}
+function parseArgs(argv) {
+    let endpoint = normalizeEndpoint(process.env.LANGFUSE_BACKFILL_ENDPOINT ?? defaultEndpoint);
+    let statePath = process.env.LANGFUSE_BACKFILL_STATE ?? defaultStatePath;
+    let homeDir = process.env.HOME ?? homedir();
+    let dryRun = false;
+    let limit;
+    let sinceMs;
+    let untilMs;
+    let batchSize = 50;
+    const agents = new Set(allAgents);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const next = () => {
+            const value = argv[++i];
+            if (!value)
+                throw new Error(`Missing value for ${arg}`);
+            return value;
+        };
+        if (arg === "--help" || arg === "-h") {
+            console.log(usage());
+            process.exit(0);
+        }
+        if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "--endpoint") {
+            endpoint = normalizeEndpoint(next());
+        }
+        else if (arg === "--state") {
+            statePath = next();
+        }
+        else if (arg === "--home") {
+            homeDir = next();
+        }
+        else if (arg === "--agents") {
+            agents.clear();
+            for (const item of next().split(",")) {
+                const agent = item.trim();
+                if (!allAgents.includes(agent)) {
+                    throw new Error(`Unknown agent '${item}'`);
+                }
+                agents.add(agent);
+            }
+        }
+        else if (arg === "--limit") {
+            limit = Number.parseInt(next(), 10);
+        }
+        else if (arg === "--batch-size") {
+            batchSize = Number.parseInt(next(), 10);
+        }
+        else if (arg === "--since") {
+            sinceMs = parseTime(next());
+        }
+        else if (arg === "--until") {
+            untilMs = parseTime(next());
+        }
+        else {
+            throw new Error(`Unknown argument '${arg}'`);
+        }
+    }
+    if (!Number.isFinite(batchSize) || batchSize < 1) {
+        throw new Error("--batch-size must be a positive integer");
+    }
+    if (limit !== undefined && (!Number.isFinite(limit) || limit < 1)) {
+        throw new Error("--limit must be a positive integer");
+    }
+    return {
+        agents,
+        endpoint,
+        statePath,
+        homeDir,
+        dryRun,
+        limit,
+        sinceMs,
+        untilMs,
+        batchSize,
+    };
+}
+function normalizeEndpoint(endpoint) {
+    if (endpoint !== deadRemoteEndpoint)
+        return endpoint;
+    console.warn(`${deadRemoteEndpoint} is not reachable from remote hosts; using ${defaultEndpoint} instead.`);
+    return defaultEndpoint;
+}
+function parseTime(value) {
+    if (/^\d+$/.test(value))
+        return Number.parseInt(value, 10);
+    const ms = Date.parse(value);
+    if (!Number.isFinite(ms))
+        throw new Error(`Invalid timestamp '${value}'`);
+    return ms;
+}
+function loadState(path) {
+    if (!existsSync(path))
+        return { version: 1, sent: {} };
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return { version: 1, sent: parsed.sent ?? {} };
+}
+function saveState(path, state) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+}
+function listFiles(root, predicate) {
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(current);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const path = join(current, entry);
+            let stat;
+            try {
+                stat = statSync(path);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory())
+                stack.push(path);
+            else if (stat.isFile() && predicate(path))
+                out.push(path);
+        }
+    }
+    return out.sort();
+}
+function parseJsonl(path) {
+    return readFileSync(path, "utf8")
+        .split(/\r?\n/)
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line));
+}
+function asRecord(value) {
+    return value && typeof value === "object"
+        ? value
+        : {};
+}
+function getPath(value, keys) {
+    let current = value;
+    for (const key of keys) {
+        current = asRecord(current)[key];
+    }
+    return current;
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function getTimestampMs(value, fallback = Date.now()) {
+    const fromNumber = asNumber(value);
+    if (fromNumber !== undefined) {
+        return fromNumber > 10_000_000_000 ? fromNumber : fromNumber * 1000;
+    }
+    const fromString = asString(value);
+    if (!fromString)
+        return fallback;
+    const parsed = Date.parse(fromString);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function extractText(value, maxLength = 4000) {
+    if (typeof value === "string")
+        return value.slice(0, maxLength);
+    if (Array.isArray(value)) {
+        const text = value
+            .map((item) => {
+            const record = asRecord(item);
+            return asString(record.text) ?? asString(record.content) ?? "";
+        })
+            .filter(Boolean)
+            .join("\n");
+        return text ? text.slice(0, maxLength) : undefined;
+    }
+    return undefined;
+}
+function normalizeUsage(value) {
+    const record = asRecord(value);
+    const nestedCost = asRecord(record.cost);
+    const cache = asRecord(record.cache);
+    const inputDetails = asRecord(record.input_tokens_details);
+    const outputDetails = asRecord(record.output_tokens_details);
+    const usage = {
+        input: asNumber(record.input) ??
+            asNumber(record.input_tokens) ??
+            asNumber(record.prompt_tokens),
+        output: asNumber(record.output) ??
+            asNumber(record.output_tokens) ??
+            asNumber(record.completion_tokens),
+        reasoning: asNumber(record.reasoning) ??
+            asNumber(record.reasoning_tokens) ??
+            asNumber(outputDetails.reasoning_tokens),
+        cacheRead: asNumber(record.cacheRead) ??
+            asNumber(record.cache_read_input_tokens) ??
+            asNumber(record.cached_tokens) ??
+            asNumber(inputDetails.cached_tokens) ??
+            asNumber(cache.read),
+        cacheWrite: asNumber(record.cacheWrite) ??
+            asNumber(record.cache_creation_input_tokens) ??
+            asNumber(cache.write),
+        total: asNumber(record.totalTokens) ?? asNumber(record.total_tokens) ??
+            asNumber(record.total),
+        cost: asNumber(nestedCost.total) ??
+            asNumber(record.totalCostUSD) ??
+            asNumber(record.costUSD) ??
+            asNumber(record.total_cost) ??
+            asNumber(record.cost),
+    };
+    if (usage.total === undefined) {
+        const total = (usage.input ?? 0) +
+            (usage.output ?? 0) +
+            (usage.reasoning ?? 0) +
+            (usage.cacheRead ?? 0) +
+            (usage.cacheWrite ?? 0);
+        if (total > 0)
+            usage.total = total;
+    }
+    return Object.values(usage).some((item) => item !== undefined)
+        ? usage
+        : undefined;
+}
+function normalizeModelName(model) {
+    if (!model)
+        return undefined;
+    if (model === "gpt-5.4-mini")
+        return undefined;
+    if (model.startsWith("kimi-for-coding"))
+        return "kimi-for-coding";
+    return model;
+}
+function usageDetails(usage) {
+    if (!usage)
+        return undefined;
+    const details = {};
+    if (usage.input !== undefined)
+        details.input = usage.input;
+    if (usage.output !== undefined)
+        details.output = usage.output;
+    if (usage.reasoning !== undefined)
+        details.output_reasoning = usage.reasoning;
+    if (usage.cacheRead !== undefined)
+        details.input_cached_tokens = usage.cacheRead;
+    if (usage.cacheWrite !== undefined)
+        details.input_cache_creation = usage.cacheWrite;
+    if (usage.total !== undefined)
+        details.total = usage.total;
+    return Object.keys(details).length > 0 ? details : undefined;
+}
+function pricingForModel(model) {
+    if (!model)
+        return undefined;
+    const normalized = normalizeModelName(model) ?? model;
+    if (normalized === "kimi-for-coding") {
+        return { input: 0.95, output: 4.0, cacheRead: 0.16, cacheWrite: 0 };
+    }
+    if (normalized.includes("accounts/fireworks/routers/kimi-k2p6-turbo")) {
+        return { input: 2.0, output: 8.0, cacheRead: 0.30, cacheWrite: 0 };
+    }
+    if (normalized.includes("accounts/fireworks/models/deepseek-v4-pro")) {
+        return { input: 1.74, output: 3.48, cacheRead: 0.15, cacheWrite: 0 };
+    }
+    if (normalized.includes("DeepSeek-V4-Pro")) {
+        return { input: 2.1, output: 4.4, cacheRead: 0.2, cacheWrite: 0 };
+    }
+    if (normalized.includes("Kimi-K2.6")) {
+        return { input: 1.2, output: 4.5, cacheRead: 0.2, cacheWrite: 0 };
+    }
+    if (normalized.includes("MiniMax-M2.7")) {
+        return { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 };
+    }
+    return undefined;
+}
+function costDetails(usage, model) {
+    if (!usage)
+        return undefined;
+    if (usage.cost !== undefined && usage.cost > 0) {
+        return { total: usage.cost, source: "recorded" };
+    }
+    const rates = pricingForModel(model);
+    if (!rates)
+        return undefined;
+    const input = ((usage.input ?? 0) * rates.input) / 1_000_000;
+    const output = (((usage.output ?? 0) + (usage.reasoning ?? 0)) * rates.output) /
+        1_000_000;
+    const cache_read = ((usage.cacheRead ?? 0) * rates.cacheRead) / 1_000_000;
+    const cache_write = ((usage.cacheWrite ?? 0) * rates.cacheWrite) / 1_000_000;
+    const total = input + output + cache_read + cache_write;
+    if (total <= 0)
+        return undefined;
+    return { input, output, cache_read, cache_write, total, source: "estimated" };
+}
+function isGenerationEvent(event) {
+    return event.usage !== undefined && event.role !== "user";
+}
+function codexEvents(homeDir) {
+    const files = listFiles(join(homeDir, ".codex/sessions"), (path) => path.endsWith(".jsonl"));
+    return files.flatMap((path) => {
+        const rows = parseJsonl(path).map(asRecord);
+        const meta = rows.find((row) => row.type === "session_meta");
+        const payload = asRecord(meta?.payload);
+        const sessionId = asString(payload.id) ?? stableId(path);
+        const sessionTime = getTimestampMs(payload.timestamp ?? rows[0]?.timestamp);
+        const cwd = asString(payload.cwd);
+        const model = asString(payload.model) ??
+            asString(getPath(payload, ["model"]));
+        let currentModel = model;
+        let currentCwd = cwd;
+        const events = [
+            {
+                agent: "codex",
+                sourcePath: path,
+                sessionId,
+                recordId: "session",
+                name: "codex session",
+                cwd,
+                model,
+                provider: asString(payload.model_provider),
+                startMs: sessionTime,
+                metadata: pick(payload, [
+                    "originator",
+                    "cli_version",
+                    "source",
+                    "thread_source",
+                ]),
+            },
+        ];
+        for (const [index, row] of rows.entries()) {
+            const rowPayload = asRecord(row.payload);
+            const type = asString(row.type);
+            const itemType = asString(rowPayload.type);
+            const timestamp = getTimestampMs(row.timestamp, sessionTime + index);
+            if (type === "turn_context") {
+                currentModel = asString(rowPayload.model) ?? currentModel;
+                currentCwd = asString(rowPayload.cwd) ?? currentCwd;
+                events.push({
+                    agent: "codex",
+                    sourcePath: path,
+                    sessionId,
+                    recordId: `turn-${asString(rowPayload.turn_id) ?? index}`,
+                    name: "codex turn",
+                    cwd: currentCwd,
+                    model: currentModel,
+                    startMs: timestamp,
+                    parentRecordId: "session",
+                    metadata: pick(rowPayload, ["turn_id", "approval_policy"]),
+                });
+            }
+            if (type === "response_item" && itemType === "message") {
+                events.push({
+                    agent: "codex",
+                    sourcePath: path,
+                    sessionId,
+                    recordId: `message-${asString(rowPayload.id) ?? index}`,
+                    name: `codex ${asString(rowPayload.role) ?? "message"}`,
+                    role: asString(rowPayload.role),
+                    model: currentModel,
+                    cwd: currentCwd,
+                    startMs: timestamp,
+                    parentRecordId: "session",
+                    output: extractText(rowPayload.content),
+                    usage: normalizeUsage(rowPayload.usage),
+                });
+            }
+            if (type === "response_item" && itemType === "function_call") {
+                events.push({
+                    agent: "codex",
+                    sourcePath: path,
+                    sessionId,
+                    recordId: `tool-${asString(rowPayload.call_id) ?? index}`,
+                    name: `codex tool ${asString(rowPayload.name) ?? "call"}`,
+                    model: currentModel,
+                    cwd: currentCwd,
+                    startMs: timestamp,
+                    parentRecordId: "session",
+                    input: rowPayload.arguments,
+                    metadata: pick(rowPayload, ["name", "call_id"]),
+                });
+            }
+            if (type === "event_msg" && rowPayload.type === "token_count") {
+                const info = asRecord(rowPayload.info);
+                const usage = normalizeUsage(asRecord(info.last_token_usage)) ??
+                    normalizeUsage(asRecord(info.total_token_usage));
+                events.push({
+                    agent: "codex",
+                    sourcePath: path,
+                    sessionId,
+                    recordId: `token-count-${index}`,
+                    name: "codex token usage",
+                    model: asString(info.model) ?? currentModel,
+                    cwd: currentCwd,
+                    startMs: timestamp,
+                    parentRecordId: "session",
+                    usage,
+                    metadata: pick(info, ["model_context_window"]),
+                });
+            }
+        }
+        return events;
+    });
+}
+function claudeEvents(homeDir) {
+    const roots = [
+        join(homeDir, ".config/claude/projects"),
+        join(homeDir, ".claude/projects"),
+    ];
+    const files = roots.flatMap((root) => listFiles(root, (path) => path.endsWith(".jsonl")));
+    return genericJsonlEvents("claude", files, "claude session");
+}
+function piEvents(homeDir) {
+    const files = [
+        ...listFiles(join(homeDir, ".pi/agent/sessions"), (path) => path.endsWith(".jsonl")),
+        ...listFiles(join(homeDir, ".pi/agent"), (path) => path.endsWith("run-history.jsonl")),
+    ];
+    return files.flatMap((path) => {
+        const rows = parseJsonl(path).map(asRecord);
+        const session = rows.find((row) => row.type === "session");
+        const sessionId = asString(session?.id) ?? stableId(path);
+        const startMs = getTimestampMs(session?.timestamp ?? rows[0]?.timestamp);
+        const cwd = asString(session?.cwd);
+        const events = [
+            {
+                agent: "pi",
+                sourcePath: path,
+                sessionId,
+                recordId: "session",
+                name: "pi session",
+                cwd,
+                startMs,
+                metadata: pick(session ?? {}, ["version"]),
+            },
+        ];
+        for (const [index, row] of rows.entries()) {
+            if (row.type !== "message")
+                continue;
+            const message = asRecord(row.message);
+            const usage = normalizeUsage(message.usage);
+            events.push({
+                agent: "pi",
+                sourcePath: path,
+                sessionId,
+                recordId: asString(row.id) ?? `message-${index}`,
+                name: `pi ${asString(message.role) ?? "message"}`,
+                role: asString(message.role),
+                model: asString(message.model) ?? asString(row.model),
+                provider: asString(message.provider),
+                cwd,
+                startMs: getTimestampMs(row.timestamp ?? message.timestamp, startMs + index),
+                endMs: getTimestampMs(message.completed, startMs + index + 1),
+                parentRecordId: asString(row.parentId) ?? "session",
+                input: message.role === "user"
+                    ? extractText(message.content)
+                    : undefined,
+                output: message.role === "assistant"
+                    ? extractText(message.content)
+                    : undefined,
+                usage,
+            });
+            for (const tool of toolCallsFromContent(message.content)) {
+                events.push({
+                    agent: "pi",
+                    sourcePath: path,
+                    sessionId,
+                    recordId: tool.id,
+                    name: `pi tool ${tool.name}`,
+                    cwd,
+                    model: asString(message.model),
+                    startMs: getTimestampMs(row.timestamp, startMs + index),
+                    parentRecordId: asString(row.id),
+                    input: tool.arguments,
+                });
+            }
+        }
+        return events;
+    });
+}
+function grokEvents(homeDir) {
+    const files = listFiles(join(homeDir, ".grok/sessions"), (path) => path.endsWith(".jsonl"));
+    return genericJsonlEvents("grok", files, "grok session");
+}
+function opencodeEvents(homeDir, rowLimit) {
+    const db = join(homeDir, ".local/share/opencode/opencode.db");
+    if (!existsSync(db))
+        return [];
+    let sessions = [];
+    let messages = [];
+    try {
+        const limitClause = rowLimit === undefined
+            ? ""
+            : ` limit ${Math.max(rowLimit, 1)}`;
+        sessions = sqliteJson(db, `select * from session order by time_created${limitClause};`);
+        messages = sqliteJson(db, `select * from message where length(data) <= 1000000 order by time_created${limitClause};`);
+    }
+    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 events = [];
+    for (const session of sessions) {
+        const sessionId = asString(session.id);
+        if (!sessionId)
+            continue;
+        events.push({
+            agent: "opencode",
+            sourcePath: db,
+            sessionId,
+            recordId: "session",
+            name: "opencode session",
+            cwd: asString(session.directory),
+            startMs: getTimestampMs(session.time_created),
+            endMs: getTimestampMs(session.time_updated),
+            metadata: pick(session, ["title", "version", "slug", "project_id"]),
+        });
+    }
+    for (const message of messages) {
+        const sessionId = asString(message.session_id);
+        const session = sessionsById.get(sessionId);
+        const data = parseMaybeJson(message.data);
+        const dataRecord = asRecord(data);
+        const tokens = normalizeUsage(dataRecord.tokens);
+        const usage = tokens
+            ? { ...tokens, cost: asNumber(dataRecord.cost) ?? tokens.cost }
+            : normalizeUsage(dataRecord.usage);
+        events.push({
+            agent: "opencode",
+            sourcePath: db,
+            sessionId: sessionId ?? stableId(db),
+            recordId: asString(message.id) ?? stableId(JSON.stringify(message)),
+            name: `opencode ${asString(dataRecord.role) ?? "message"}`,
+            role: asString(dataRecord.role),
+            model: asString(dataRecord.modelID) ??
+                asString(getPath(dataRecord, ["model", "modelID"])),
+            provider: asString(dataRecord.providerID) ??
+                asString(getPath(dataRecord, ["model", "providerID"])),
+            cwd: asString(getPath(dataRecord, ["path", "cwd"])) ??
+                asString(asRecord(session).directory),
+            startMs: getTimestampMs(message.time_created),
+            endMs: getTimestampMs(message.time_updated),
+            parentRecordId: asString(dataRecord.parentID) ?? "session",
+            usage,
+            metadata: pick(dataRecord, ["agent", "mode", "error"]),
+        });
+    }
+    return events;
+}
+function sqliteJson(db, sql) {
+    const output = execFileSync("sqlite3", ["-readonly", "-json", db, sql], {
+        encoding: "utf8",
+        maxBuffer: 128 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    return JSON.parse(output || "[]");
+}
+function genericJsonlEvents(agent, files, sessionName) {
+    return files.flatMap((path) => {
+        const rows = parseJsonl(path).map(asRecord);
+        const first = rows[0] ?? {};
+        const sessionId = asString(first.sessionId) ??
+            asString(first.session_id) ??
+            asString(first.id) ??
+            stableId(path);
+        const startMs = getTimestampMs(first.timestamp ?? first.time_created);
+        const cwd = asString(first.cwd);
+        const events = [
+            {
+                agent,
+                sourcePath: path,
+                sessionId,
+                recordId: "session",
+                name: sessionName,
+                cwd,
+                startMs,
+            },
+        ];
+        for (const [index, row] of rows.entries()) {
+            const message = asRecord(row.message);
+            const role = asString(message.role) ?? asString(row.type);
+            const timestamp = getTimestampMs(row.timestamp ?? row.time_created, startMs + index);
+            const usage = normalizeUsage(message.usage ?? row.usage);
+            events.push({
+                agent,
+                sourcePath: path,
+                sessionId: asString(row.sessionId) ?? asString(row.session_id) ??
+                    sessionId,
+                recordId: asString(row.uuid) ??
+                    asString(row.id) ??
+                    asString(row.toolUseID) ??
+                    `row-${index}`,
+                name: `${agent} ${role ?? "event"}`,
+                role,
+                model: asString(getPath(message, ["model"])) ?? asString(row.model),
+                cwd: asString(row.cwd) ?? cwd,
+                startMs: timestamp,
+                parentRecordId: asString(row.parentUuid) ?? asString(row.parentId) ??
+                    "session",
+                input: role === "user"
+                    ? extractText(message.content ?? row.content)
+                    : undefined,
+                output: role === "assistant"
+                    ? extractText(message.content ?? row.content)
+                    : undefined,
+                usage,
+                metadata: pick(row, [
+                    "type",
+                    "entrypoint",
+                    "version",
+                    "gitBranch",
+                    "error",
+                ]),
+            });
+            for (const tool of toolCallsFromContent(message.content)) {
+                events.push({
+                    agent,
+                    sourcePath: path,
+                    sessionId,
+                    recordId: tool.id,
+                    name: `${agent} tool ${tool.name}`,
+                    cwd,
+                    startMs: timestamp,
+                    parentRecordId: asString(row.uuid) ?? asString(row.id),
+                    input: tool.arguments,
+                });
+            }
+        }
+        return events;
+    });
+}
+function toolCallsFromContent(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((item, index) => {
+        const record = asRecord(item);
+        const type = asString(record.type);
+        if (type !== "toolCall" && type !== "tool_use")
+            return [];
+        return [
+            {
+                id: asString(record.id) ?? asString(record.tool_use_id) ??
+                    `tool-${index}`,
+                name: asString(record.name) ?? "call",
+                arguments: record.arguments ?? record.input,
+            },
+        ];
+    });
+}
+function pick(source, keys) {
+    const out = {};
+    for (const key of keys) {
+        if (source[key] !== undefined)
+            out[key] = source[key];
+    }
+    return out;
+}
+function parseMaybeJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function stableId(input) {
+    return createHash("sha256").update(input).digest("hex").slice(0, 32);
+}
+function fingerprint(event) {
+    return `${importIdentityVersion}:${event.agent}:${event.sourcePath}:${event.sessionId}:${event.recordId}`;
+}
+function traceFingerprint(event) {
+    return `${importIdentityVersion}:${event.agent}:${event.sourcePath}:${event.sessionId}`;
+}
+function traceId(event) {
+    return stableId(traceFingerprint(event));
+}
+function spanId(event) {
+    return stableId(fingerprint(event)).slice(0, 16);
+}
+function rootSpanId(event) {
+    return stableId(`${traceFingerprint(event)}:root`).slice(0, 16);
+}
+function ns(ms) {
+    return `${BigInt(Math.trunc(ms)) * 1000000n}`;
+}
+function attr(key, value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "number" && Number.isFinite(value)) {
+        if (Number.isInteger(value))
+            return { key, value: { intValue: value } };
+        return { key, value: { doubleValue: value } };
+    }
+    if (typeof value === "boolean")
+        return { key, value: { boolValue: value } };
+    if (typeof value === "string")
+        return { key, value: { stringValue: value } };
+    return { key, value: { stringValue: JSON.stringify(value).slice(0, 8000) } };
+}
+function toOtlp(events) {
+    const spansByTrace = new Map();
+    for (const event of events) {
+        const id = traceId(event);
+        spansByTrace.set(id, [...(spansByTrace.get(id) ?? []), event]);
+    }
+    const spans = [...spansByTrace.values()].flatMap((traceEventsForSession) => {
+        const first = traceEventsForSession[0];
+        if (!first)
+            return [];
+        const sortedEvents = [...traceEventsForSession].sort((a, b) => a.startMs - b.startMs);
+        const traceStartMs = sortedEvents[0]?.startMs ?? Date.now();
+        const traceEndMs = Math.max(...sortedEvents.map((event) => event.endMs ?? event.startMs + 1), traceStartMs + 1);
+        const firstInputEvent = sortedEvents.find((event) => event.input !== undefined);
+        const lastOutputEvent = [...sortedEvents]
+            .reverse()
+            .find((event) => event.output !== undefined);
+        const rootAttributes = [
+            attr("service.name", `agent.${first.agent}`),
+            attr("deployment.environment", "local"),
+            attr("langfuse.environment", "local"),
+            attr("langfuse.internal.as_root", true),
+            attr("langfuse.trace.name", `${first.agent} session`),
+            attr("langfuse.session.id", first.sessionId),
+            attr("session.id", first.sessionId),
+            attr("langfuse.observation.type", "span"),
+            attr("agent.name", first.agent),
+            attr("agent.session_id", first.sessionId),
+            attr("agent.record_id", "session-root"),
+            attr("agent.event_count", sortedEvents.length),
+            attr("langfuse.trace.metadata.agent", first.agent),
+            attr("langfuse.trace.metadata.source_path", first.sourcePath),
+            attr("langfuse.trace.metadata.cwd", first.cwd),
+            attr("langfuse.trace.input", firstInputEvent?.input),
+            attr("langfuse.trace.output", lastOutputEvent?.output),
+            attr("langfuse.observation.metadata.agent", first.agent),
+            attr("langfuse.observation.metadata.record_id", "session-root"),
+            attr("source.path", first.sourcePath),
+            attr("cwd", first.cwd),
+        ].filter((item) => Boolean(item));
+        const rootSpan = {
+            traceId: traceId(first),
+            spanId: rootSpanId(first),
+            name: `${first.agent} session`,
+            kind: 1,
+            startTimeUnixNano: ns(traceStartMs),
+            endTimeUnixNano: ns(traceEndMs),
+            attributes: rootAttributes,
+            status: { code: 1 },
+        };
+        const childSpans = sortedEvents.map((event) => {
+            const startMs = event.startMs;
+            const durationMs = Math.max(1, (event.endMs ?? event.startMs + 1) - event.startMs);
+            const modelName = normalizeModelName(event.model);
+            const generation = isGenerationEvent(event);
+            const usage = usageDetails(event.usage);
+            const cost = costDetails(event.usage, modelName);
+            const costForLangfuse = cost === undefined
+                ? undefined
+                : {
+                    ...(cost.input !== undefined ? { input: cost.input } : {}),
+                    ...(cost.output !== undefined ? { output: cost.output } : {}),
+                    ...(cost.cache_read !== undefined ? { cache_read: cost.cache_read } : {}),
+                    ...(cost.cache_write !== undefined ? { cache_write: cost.cache_write } : {}),
+                    total: cost.total,
+                };
+            const attributes = [
+                attr("service.name", `agent.${event.agent}`),
+                attr("deployment.environment", "local"),
+                attr("langfuse.environment", "local"),
+                attr("langfuse.session.id", event.sessionId),
+                attr("session.id", event.sessionId),
+                attr("langfuse.observation.type", generation ? "generation" : "span"),
+                attr("langfuse.observation.model.name", generation ? modelName : undefined),
+                attr("langfuse.observation.usage_details", usage),
+                attr("langfuse.observation.cost_details", costForLangfuse),
+                attr("gen_ai.response.model", generation ? modelName : undefined),
+                attr("gen_ai.usage.input_tokens", usage?.input),
+                attr("gen_ai.usage.output_tokens", usage?.output),
+                attr("gen_ai.usage.total_tokens", usage?.total),
+                attr("gen_ai.usage.cost", cost?.total),
+                attr("agent.name", event.agent),
+                attr("agent.session_id", event.sessionId),
+                attr("agent.record_id", event.recordId),
+                attr("agent.original_start_time", new Date(event.startMs).toISOString()),
+                attr("agent.original_end_time", event.endMs === undefined ? undefined : new Date(event.endMs).toISOString()),
+                attr("langfuse.trace.metadata.agent", event.agent),
+                attr("langfuse.trace.metadata.source_path", event.sourcePath),
+                attr("langfuse.trace.metadata.model", event.model),
+                attr("langfuse.trace.metadata.provider", event.provider),
+                attr("langfuse.observation.metadata.agent", event.agent),
+                attr("langfuse.observation.metadata.record_id", event.recordId),
+                attr("langfuse.observation.metadata.model", modelName ?? event.model),
+                attr("langfuse.observation.metadata.provider", event.provider),
+                attr("langfuse.observation.metadata.cost_source", cost?.source),
+                attr("langfuse.trace.input", event.input),
+                attr("langfuse.trace.output", event.output),
+                attr("langfuse.observation.input", event.input),
+                attr("langfuse.observation.output", event.output),
+                attr("source.path", event.sourcePath),
+                attr("cwd", event.cwd),
+                attr("role", event.role),
+                attr("agent.model", event.model),
+                attr("agent.provider", event.provider),
+                attr("input.value", event.input),
+                attr("output.value", event.output),
+                attr("metadata", event.metadata),
+            ].filter((item) => Boolean(item));
+            return {
+                traceId: traceId(event),
+                spanId: spanId(event),
+                parentSpanId: rootSpanId(event),
+                name: event.name,
+                kind: 1,
+                startTimeUnixNano: ns(startMs),
+                endTimeUnixNano: ns(startMs + durationMs),
+                attributes,
+                status: { code: 1 },
+            };
+        });
+        return [rootSpan, ...childSpans];
+    });
+    return {
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: [
+                        {
+                            key: "service.name",
+                            value: { stringValue: "agent-history-backfill" },
+                        },
+                        {
+                            key: "telemetry.sdk.name",
+                            value: { stringValue: "toolbox-langfuse-backfill" },
+                        },
+                    ],
+                },
+                scopeSpans: [
+                    {
+                        scope: { name: "toolbox.langfuse.backfill", version: "1" },
+                        spans,
+                    },
+                ],
+            },
+        ],
+    };
+}
+async function postOtlp(endpoint, events) {
+    let response;
+    try {
+        response = await fetch(endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(toOtlp(events)),
+        });
+    }
+    catch (error) {
+        throw new Error(describeError(error));
+    }
+    if (!response.ok) {
+        throw new Error(`OTLP POST failed: ${response.status} ${await response.text()}`);
+    }
+}
+function describeError(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const cause = error.cause;
+    if (!cause)
+        return error.message;
+    const parts = [
+        typeof cause.code === "string" ? cause.code : undefined,
+        typeof cause.syscall === "string" ? cause.syscall : undefined,
+        typeof cause.address === "string" && typeof cause.port === "number"
+            ? `${cause.address}:${cause.port}`
+            : undefined,
+        typeof cause.message === "string" ? `cause: ${cause.message}` : undefined,
+    ].filter(Boolean);
+    return parts.length > 0
+        ? `${error.message} (${parts.join("; ")})`
+        : error.message;
+}
+function discoverEvents(options) {
+    const providers = {
+        claude: (inner) => claudeEvents(inner.homeDir),
+        codex: (inner) => codexEvents(inner.homeDir),
+        grok: (inner) => grokEvents(inner.homeDir),
+        opencode: (inner) => opencodeEvents(inner.homeDir, inner.limit),
+        pi: (inner) => piEvents(inner.homeDir),
+    };
+    return allAgents
+        .filter((agent) => options.agents.has(agent))
+        .flatMap((agent) => providers[agent](options))
+        .filter((event) => options.sinceMs === undefined || event.startMs >= options.sinceMs)
+        .filter((event) => options.untilMs === undefined || event.startMs <= options.untilMs)
+        .sort((a, b) => a.startMs - b.startMs);
+}
+async function run(options) {
+    const state = loadState(options.statePath);
+    const events = discoverEvents(options);
+    const discovered = Object.fromEntries(allAgents.map((agent) => [agent, 0]));
+    for (const event of events) {
+        discovered[event.agent] = (discovered[event.agent] ?? 0) + 1;
+    }
+    const unsent = events.filter((event) => state.sent[fingerprint(event)] === undefined);
+    const selected = options.limit === undefined
+        ? unsent
+        : unsent.slice(0, options.limit);
+    let sent = 0;
+    let failed = 0;
+    let aborted = false;
+    let lastError;
+    if (!options.dryRun) {
+        for (let index = 0; index < selected.length; index += options.batchSize) {
+            const batch = selected.slice(index, index + options.batchSize);
+            try {
+                await postOtlp(options.endpoint, batch);
+                for (const event of batch) {
+                    state.sent[fingerprint(event)] = new Date().toISOString();
+                }
+                saveState(options.statePath, state);
+                sent += batch.length;
+            }
+            catch (error) {
+                failed += batch.length;
+                aborted = true;
+                lastError = describeError(error);
+                console.error(`OTLP POST failed for batch ${Math.floor(index / options.batchSize) + 1} (${batch.length} event(s)) to ${options.endpoint}: ${lastError}`);
+                const remaining = selected.length - index - batch.length;
+                if (remaining > 0) {
+                    console.error(`Aborting backfill after first failed POST; ${remaining} selected event(s) were not attempted. Fix the endpoint and rerun to resume from the local dedupe state.`);
+                }
+                break;
+            }
+        }
+    }
+    return {
+        discovered,
+        sent: options.dryRun ? 0 : sent,
+        skipped: events.length - selected.length,
+        failed,
+        notAttempted: selected.length - sent - failed,
+        aborted,
+        ...(lastError ? { error: lastError } : {}),
+        dryRun: options.dryRun,
+        endpoint: options.endpoint,
+        statePath: options.statePath,
+    };
+}
+async function main(argv = process.argv.slice(2)) {
+    const summary = await run(parseArgs(argv));
+    console.log(JSON.stringify(summary, null, 2));
+    return summary;
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    try {
+        const summary = await main();
+        process.exit(summary.failed > 0 ? 1 : 0);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+export { claudeEvents, codexEvents, discoverEvents, fingerprint, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };