@ramarivera/coding-agent-langfuse 0.1.15 → 0.1.17

package/README.md

@@ -18,7 +18,18 @@ npx @ramarivera/coding-agent-langfuse@latest \
   --agents claude,codex,grok,pi,opencode \
   --endpoint https://langfuse.ai.roxasroot.net/otel/v1/traces \
   --state "$HOME/.local/state/coding-agent-langfuse/backfill-v6.json" \
-  --batch-size 1000
+  --batch-size 10
+```
+
+Run live incremental forwarding without putting inference behind a gateway:
+
+```sh
+npx @ramarivera/coding-agent-langfuse@latest \
+  --agents codex \
+  --endpoint https://langfuse.ai.roxasroot.net/otel/v1/traces \
+  --state "$HOME/.local/state/coding-agent-langfuse/live-codex.json" \
+  --batch-size 10 \
+  --follow
 ```
 
 The importer is fail-fast: the first failed OTLP POST stops the run, prints the

package/dist/backfill.d.ts

@@ -33,6 +33,9 @@ type BackfillOptions = {
     statePath: string;
     homeDir: string;
     dryRun: boolean;
+    follow: boolean;
+    pollIntervalMs: number;
+    idleExitAfterMs?: number;
     limit?: number;
     sinceMs?: number;
     untilMs?: number;
@@ -50,6 +53,10 @@ type RunSummary = {
     endpoint: string;
     statePath: string;
 };
+type FollowSummary = RunSummary & {
+    iterations: number;
+    follow: true;
+};
 declare function parseArgs(argv: string[]): BackfillOptions;
 declare function codexEvents(homeDir: string): BackfillEvent[];
 declare function claudeEvents(homeDir: string): BackfillEvent[];
@@ -60,5 +67,6 @@ declare function fingerprint(event: BackfillEvent): string;
 declare function toOtlp(events: BackfillEvent[]): Record<string, unknown>;
 declare function discoverEvents(options: BackfillOptions): BackfillEvent[];
 declare function run(options: BackfillOptions): Promise<RunSummary>;
-declare function main(argv?: string[]): Promise<RunSummary>;
-export { type BackfillEvent, type BackfillOptions, claudeEvents, codexEvents, discoverEvents, fingerprint, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };
+declare function follow(options: BackfillOptions): Promise<FollowSummary>;
+declare function main(argv?: string[]): Promise<RunSummary | FollowSummary>;
+export { type BackfillEvent, type BackfillOptions, claudeEvents, codexEvents, discoverEvents, fingerprint, follow, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };

package/dist/backfill.js

@@ -5,7 +5,7 @@ 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 = "v7-host-independent-session-traces";
+const importIdentityVersion = "v8-cached-input-token-split";
 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");
@@ -21,6 +21,9 @@ Options:
   --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)
+  --follow                Keep scanning and sending newly written events
+  --poll-interval-ms N    Delay between --follow scans (default: 5000)
+  --idle-exit-after-ms N  Stop --follow after this much time without new sends
   --dry-run               Discover and dedupe without sending or mutating state
   --help                  Show this help
 `;
@@ -34,6 +37,9 @@ function parseArgs(argv) {
     let sinceMs;
     let untilMs;
     let batchSize = 50;
+    let follow = false;
+    let pollIntervalMs = 5_000;
+    let idleExitAfterMs;
     const agents = new Set(allAgents);
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
@@ -75,6 +81,15 @@ function parseArgs(argv) {
         else if (arg === "--batch-size") {
             batchSize = Number.parseInt(next(), 10);
         }
+        else if (arg === "--follow") {
+            follow = true;
+        }
+        else if (arg === "--poll-interval-ms") {
+            pollIntervalMs = Number.parseInt(next(), 10);
+        }
+        else if (arg === "--idle-exit-after-ms") {
+            idleExitAfterMs = Number.parseInt(next(), 10);
+        }
         else if (arg === "--since") {
             sinceMs = parseTime(next());
         }
@@ -88,6 +103,13 @@ function parseArgs(argv) {
     if (!Number.isFinite(batchSize) || batchSize < 1) {
         throw new Error("--batch-size must be a positive integer");
     }
+    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 1) {
+        throw new Error("--poll-interval-ms must be a positive integer");
+    }
+    if (idleExitAfterMs !== undefined &&
+        (!Number.isFinite(idleExitAfterMs) || idleExitAfterMs < 1)) {
+        throw new Error("--idle-exit-after-ms must be a positive integer");
+    }
     if (limit !== undefined && (!Number.isFinite(limit) || limit < 1)) {
         throw new Error("--limit must be a positive integer");
     }
@@ -97,6 +119,9 @@ function parseArgs(argv) {
         statePath,
         homeDir,
         dryRun,
+        follow,
+        pollIntervalMs,
+        idleExitAfterMs,
         limit,
         sinceMs,
         untilMs,
@@ -227,9 +252,11 @@ function normalizeUsage(value) {
             asNumber(record.completion_tokens),
         reasoning: asNumber(record.reasoning) ??
             asNumber(record.reasoning_tokens) ??
+            asNumber(record.reasoning_output_tokens) ??
             asNumber(outputDetails.reasoning_tokens),
         cacheRead: asNumber(record.cacheRead) ??
             asNumber(record.cache_read_input_tokens) ??
+            asNumber(record.cached_input_tokens) ??
             asNumber(record.cached_tokens) ??
             asNumber(inputDetails.cached_tokens) ??
             asNumber(cache.read),
@@ -248,7 +275,6 @@ function normalizeUsage(value) {
         const total = (usage.input ?? 0) +
             (usage.output ?? 0) +
             (usage.reasoning ?? 0) +
-            (usage.cacheRead ?? 0) +
             (usage.cacheWrite ?? 0);
         if (total > 0)
             usage.total = total;
@@ -270,8 +296,13 @@ function usageDetails(usage) {
     if (!usage)
         return undefined;
     const details = {};
-    if (usage.input !== undefined)
-        details.input = usage.input;
+    const cachedInput = usage.cacheRead ?? 0;
+    const cacheWrite = usage.cacheWrite ?? 0;
+    const regularInput = usage.input === undefined
+        ? undefined
+        : Math.max(usage.input - cachedInput - cacheWrite, 0);
+    if (regularInput !== undefined)
+        details.input = regularInput;
     if (usage.output !== undefined)
         details.output = usage.output;
     if (usage.reasoning !== undefined)
@@ -313,12 +344,14 @@ function costDetails(usage, model) {
         return undefined;
     const rates = pricingForModel(model);
     if (rates) {
-        const input = ((usage.input ?? 0) * rates.input) / 1_000_000;
+        const cachedInput = usage.cacheRead ?? 0;
+        const cacheWriteTokens = usage.cacheWrite ?? 0;
+        const regularInput = Math.max((usage.input ?? 0) - cachedInput - cacheWriteTokens, 0);
+        const input = (regularInput * 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 cache_read = (cachedInput * rates.cacheRead) / 1_000_000;
+        const cache_write = (cacheWriteTokens * rates.cacheWrite) / 1_000_000;
         const total = input + output + cache_read + cache_write;
         if (total > 0) {
             return { input, output, cache_read, cache_write, total, source: "estimated" };
@@ -1027,8 +1060,63 @@ async function run(options) {
         statePath: options.statePath,
     };
 }
+function mergeSummary(base, next) {
+    return {
+        discovered: Object.fromEntries(allAgents.map((agent) => [
+            agent,
+            Math.max(base.discovered[agent] ?? 0, next.discovered[agent] ?? 0),
+        ])),
+        sent: base.sent + next.sent,
+        skipped: next.skipped,
+        failed: base.failed + next.failed,
+        notAttempted: next.notAttempted,
+        aborted: base.aborted || next.aborted,
+        ...(next.error ? { error: next.error } : base.error ? { error: base.error } : {}),
+        dryRun: base.dryRun,
+        endpoint: base.endpoint,
+        statePath: base.statePath,
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function follow(options) {
+    let iterations = 0;
+    let lastSendOrStartMs = Date.now();
+    let aggregate;
+    while (true) {
+        iterations += 1;
+        const summary = await run(options);
+        aggregate = aggregate === undefined ? summary : mergeSummary(aggregate, summary);
+        if (summary.sent > 0)
+            lastSendOrStartMs = Date.now();
+        if (summary.aborted)
+            break;
+        if (options.idleExitAfterMs !== undefined &&
+            Date.now() - lastSendOrStartMs >= options.idleExitAfterMs) {
+            break;
+        }
+        await sleep(options.pollIntervalMs);
+    }
+    return {
+        ...(aggregate ?? {
+            discovered: Object.fromEntries(allAgents.map((agent) => [agent, 0])),
+            sent: 0,
+            skipped: 0,
+            failed: 0,
+            notAttempted: 0,
+            aborted: false,
+            dryRun: options.dryRun,
+            endpoint: options.endpoint,
+            statePath: options.statePath,
+        }),
+        iterations,
+        follow: true,
+    };
+}
 async function main(argv = process.argv.slice(2)) {
-    const summary = await run(parseArgs(argv));
+    const options = parseArgs(argv);
+    const summary = options.follow ? await follow(options) : await run(options);
     console.log(JSON.stringify(summary, null, 2));
     return summary;
 }
@@ -1042,4 +1130,4 @@ if (import.meta.url === `file://${process.argv[1]}`) {
         process.exit(1);
     }
 }
-export { claudeEvents, codexEvents, discoverEvents, fingerprint, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };
+export { claudeEvents, codexEvents, discoverEvents, fingerprint, follow, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };

package/package.json

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