@ramarivera/coding-agent-langfuse 0.1.43 → 0.1.45

package/README.md

@@ -8,6 +8,11 @@ Langfuse canonical `usage_details` and `cost_details` attributes so historical
 backfills participate in Langfuse model-usage and cost dashboards. Tool calls
 remain child spans under the same session.
 
+Codex `event_msg` `token_count` rows are imported as non-billable accounting
+spans. They are rolling/snapshot telemetry from the Codex session log, not
+individual model generations, so the importer preserves their token details in
+metadata without sending Langfuse generation `usage_details` or `cost_details`.
+
 ```sh
 coding-agent-langfuse-backfill --agents codex,claude,grok,pi,opencode
 ```
@@ -22,6 +27,16 @@ npx @ramarivera/coding-agent-langfuse@latest \
   --batch-size 10
 ```
 
+For a Langfuse endpoint that requires project API keys, pass Basic auth
+credentials as `publicKey:secretKey` or set `LANGFUSE_BACKFILL_AUTH`:
+
+```sh
+npx @ramarivera/coding-agent-langfuse@latest \
+  --agents claude,codex,grok,pi,opencode \
+  --endpoint http://127.0.0.1:3000/api/public/otel/v1/traces \
+  --auth pk-lf-example:sk-lf-example
+```
+
 Run live incremental forwarding without putting inference behind a gateway:
 
 ```sh
@@ -45,12 +60,18 @@ records a total cost, that recorded value wins. Otherwise, the importer
 calculates per-usage-type USD costs from a model catalog using rates in USD per
 1M tokens.
 
-The built-in catalog covers OpenAI GPT-5.5 API list pricing plus the toolbox/Pi
+The built-in catalog covers OpenAI GPT-5.5, GPT-5.4, and GPT-5.3-Codex API list
+pricing, Anthropic Claude Opus/Sonnet 4 API list pricing, plus the toolbox/Pi
 models already used in local configuration, including Fireworks Kimi K2.6,
 Fireworks DeepSeek V4 Pro, MiniMax-M3, Together DeepSeek/Kimi/GLM/MiniMax, and
 Zai GLM. `gpt-5.5` is charged at current standard API list price by default:
 `$5.00` input, `$0.50` cached input, and `$30.00` output per 1M tokens. GPT-5.5
-Pro defaults to `$30.00` input and `$180.00` output per 1M tokens.
+Pro defaults to `$30.00` input and `$180.00` output per 1M tokens. Claude Opus 4
+models default to `$15.00` input, `$1.50` cache hits, `$18.75` 5-minute cache
+writes, `$30.00` 1-hour cache writes, and `$75.00` output per 1M tokens.
+When a billable generation source only records a total token count without
+input/output/cache breakdown, the importer charges that total at the model input
+rate and marks the cost source as `calculated_total_as_input`.
 
 Use an override only when you intentionally want a different accounting policy:
 
@@ -72,7 +93,9 @@ services. A file can be either a direct model map or `{ "rates": { ... } }`:
       "input": 1,
       "output": 2,
       "cacheRead": 0.1,
-      "cacheWrite": 0
+      "cacheWrite": 0,
+      "cacheWrite5m": 0,
+      "cacheWrite1h": 0
     }
   }
 }
@@ -138,8 +161,26 @@ npx @ramarivera/coding-agent-langfuse@latest \
   --endpoint https://langfuse.ai.roxasroot.net/otel/v1/traces
 ```
 
-Deduplication is state-file based and keyed by agent, session id, and source
-record id. Reuse the same `--state` path for repeat repairs on a host.
+Deduplication is state-file based and keyed by importer state identity, agent,
+session id, and source record id. Reuse the same `--state` path for normal
+incremental runs.
+
+For an intentional repair replay, add `--force` to resend the selected window
+even when the state file says those events were already sent:
+
+```sh
+npx @ramarivera/coding-agent-langfuse@latest \
+  --agents claude,codex,grok,pi,opencode \
+  --since 2026-05-01T00:00:00Z \
+  --until 2026-06-01T00:00:00Z \
+  --force \
+  --endpoint https://langfuse.ai.roxasroot.net/otel/v1/traces
+```
+
+The Langfuse trace/span IDs intentionally stay pinned to the original pre-cost
+identity, while the state-file key can advance with importer payload changes.
+That lets cost repairs replace historical zero-cost rows instead of creating a
+new duplicate identity for the same source event.
 
 ## Verification
 
@@ -150,6 +191,7 @@ CLI against a local OTLP collector.
 npm run check
 npm test
 npm run test:e2e
+npm run test:e2e:langfuse
 ```
 
 The e2e suite verifies:
@@ -159,5 +201,8 @@ The e2e suite verifies:
 - Follow mode picking up newly written Codex events
 - One CLI run posting reconstructable traces for Claude Code, Codex, Grok,
   OpenCode, and Pi
+- A Docker-backed mini Langfuse import that queries the public observations API
+  and verifies usage/cost fields for sanitized multi-agent sessions, including
+  Claude Code Opus 4.7 and Opus 4.8 cache accounting
 - Service plan generation for Linux systemd user units, macOS LaunchAgents, and
   Windows Scheduled Tasks

package/dist/backfill.d.ts

@@ -6,6 +6,8 @@ type Usage = {
     reasoning?: number;
     cacheRead?: number;
     cacheWrite?: number;
+    cacheWrite5m?: number;
+    cacheWrite1h?: number;
     total?: number;
     cost?: number;
     inputIncludesCache?: boolean;
@@ -31,9 +33,11 @@ type BackfillEvent = {
 type BackfillOptions = {
     agents: Set<AgentName>;
     endpoint: string;
+    auth?: string;
     statePath: string;
     homeDir: string;
     dryRun: boolean;
+    force: boolean;
     follow: boolean;
     pollIntervalMs: number;
     idleExitAfterMs?: number;
@@ -53,6 +57,8 @@ type CostRates = {
     reasoning?: number;
     cacheRead?: number;
     cacheWrite?: number;
+    cacheWrite5m?: number;
+    cacheWrite1h?: number;
 };
 type CostCatalog = Record<string, CostRates>;
 type OtlpOptions = {

package/dist/backfill.js

@@ -5,14 +5,26 @@ import { existsSync, mkdirSync, renameSync, readdirSync, readFileSync, statSync,
 import { hostname, homedir } from "node:os";
 import { dirname, join } from "node:path";
 const allAgents = ["claude", "codex", "grok", "opencode", "pi"];
-const importIdentityVersion = "v9-cost-details";
-const importIdentityVersions = {
+const importStateIdentityVersion = "v9-cost-details";
+const importStateIdentityVersions = {
     claude: "v12-cost-details",
-    codex: "v10-cost-details",
+    codex: "v11-codex-token-accounting-nonbillable",
     grok: "v12-cost-details",
     opencode: "v11-cost-details",
     pi: "v12-cost-details",
 };
+const langfuseIdIdentityVersion = "v8-cached-input-token-split";
+const langfuseIdIdentityVersions = {
+    claude: "v11-tool-results",
+    codex: "v9-codex-conversation-events",
+    grok: "v11-chat-history-only",
+    opencode: "v10-opencode-message-parts",
+    pi: "v11-tool-results",
+};
+const importPayloadVersion = "v10-cost-details";
+const importPayloadVersions = {
+    codex: "v11-codex-token-accounting-nonbillable",
+};
 const defaultEndpoint = "https://langfuse.ai.roxasroot.net/otel/v1/traces";
 const deadRemoteEndpoint = "http://langfuse.ai.roxasroot.net:14318/v1/traces";
 const defaultMaxRequestBytes = 12 * 1024 * 1024;
@@ -49,11 +61,63 @@ const gpt55ProRates = {
     cacheRead: 30,
     cacheWrite: 30,
 };
+const gpt54Rates = {
+    input: 2.5,
+    output: 15,
+    cacheRead: 0.25,
+    cacheWrite: 2.5,
+};
+const gpt53CodexRates = {
+    input: 1.75,
+    output: 14,
+    cacheRead: 0.175,
+    cacheWrite: 1.75,
+};
+const claudeOpus4Rates = {
+    input: 15,
+    output: 75,
+    cacheRead: 1.5,
+    cacheWrite: 18.75,
+    cacheWrite5m: 18.75,
+    cacheWrite1h: 30,
+};
+const claudeSonnet4Rates = {
+    input: 3,
+    output: 15,
+    cacheRead: 0.3,
+    cacheWrite: 3.75,
+    cacheWrite5m: 3.75,
+    cacheWrite1h: 6,
+};
 const defaultCostRates = {
     "gpt-5.5": gpt55Rates,
     "openai/gpt-5.5": gpt55Rates,
     "gpt-5.5-pro": gpt55ProRates,
     "openai/gpt-5.5-pro": gpt55ProRates,
+    "gpt-5.4": gpt54Rates,
+    "openai/gpt-5.4": gpt54Rates,
+    "gpt-5.3-codex": gpt53CodexRates,
+    "openai/gpt-5.3-codex": gpt53CodexRates,
+    "claude-opus-4": claudeOpus4Rates,
+    "anthropic/claude-opus-4": claudeOpus4Rates,
+    "claude-opus-4-1": claudeOpus4Rates,
+    "anthropic/claude-opus-4-1": claudeOpus4Rates,
+    "claude-opus-4-6": claudeOpus4Rates,
+    "anthropic/claude-opus-4-6": claudeOpus4Rates,
+    "claude-opus-4-7": claudeOpus4Rates,
+    "anthropic/claude-opus-4-7": claudeOpus4Rates,
+    "claude-opus-4-8": claudeOpus4Rates,
+    "anthropic/claude-opus-4-8": claudeOpus4Rates,
+    "claude-sonnet-4": claudeSonnet4Rates,
+    "anthropic/claude-sonnet-4": claudeSonnet4Rates,
+    "claude-sonnet-4-5": claudeSonnet4Rates,
+    "anthropic/claude-sonnet-4-5": claudeSonnet4Rates,
+    "claude-sonnet-4.5": claudeSonnet4Rates,
+    "anthropic/claude-sonnet-4.5": claudeSonnet4Rates,
+    "claude-sonnet-4-6": claudeSonnet4Rates,
+    "anthropic/claude-sonnet-4-6": claudeSonnet4Rates,
+    "claude-sonnet-4.6": claudeSonnet4Rates,
+    "anthropic/claude-sonnet-4.6": claudeSonnet4Rates,
     "accounts/fireworks/routers/kimi-k2p6-turbo": kimiFirepassRates,
     "fireworks-firepass/accounts/fireworks/routers/kimi-k2p6-turbo": kimiFirepassRates,
     "kimi-for-coding": kimiFirepassRates,
@@ -67,24 +131,48 @@ const defaultCostRates = {
         cacheRead: 0.2,
         cacheWrite: 0,
     },
+    "deepseek-ai/DeepSeek-V4-Pro": {
+        input: 2.1,
+        output: 4.4,
+        cacheRead: 0.2,
+        cacheWrite: 0,
+    },
     "together/zai-org/GLM-5.1": {
         input: 1.4,
         output: 4.4,
         cacheRead: 0.2,
         cacheWrite: 0,
     },
+    "zai-org/GLM-5.1": {
+        input: 1.4,
+        output: 4.4,
+        cacheRead: 0.2,
+        cacheWrite: 0,
+    },
     "together/moonshotai/Kimi-K2.6": {
         input: 1.2,
         output: 4.5,
         cacheRead: 0.2,
         cacheWrite: 0,
     },
+    "moonshotai/Kimi-K2.6": {
+        input: 1.2,
+        output: 4.5,
+        cacheRead: 0.2,
+        cacheWrite: 0,
+    },
     "together/MiniMaxAI/MiniMax-M2.7": {
         input: 0.3,
         output: 1.2,
         cacheRead: 0.06,
         cacheWrite: 0,
     },
+    "MiniMax-M2.7": {
+        input: 0.3,
+        output: 1.2,
+        cacheRead: 0.06,
+        cacheWrite: 0,
+    },
     "zai/glm-5.1": {
         input: 1.4,
         output: 4.4,
@@ -108,6 +196,7 @@ function usage() {
 
 Options:
   --endpoint URL          OTLP HTTP traces endpoint (default: ${defaultEndpoint})
+  --auth USER:PASS        Optional Langfuse Basic auth credentials
   --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)
@@ -125,14 +214,18 @@ Options:
   --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
+  --force                 Resend discovered events even when present in local state
   --help                  Show this help
 `;
 }
 function parseArgs(argv) {
     let endpoint = normalizeEndpoint(process.env.LANGFUSE_BACKFILL_ENDPOINT ?? defaultEndpoint);
+    let auth = process.env.LANGFUSE_BACKFILL_AUTH ??
+        process.env.CODING_AGENT_LANGFUSE_AUTH;
     let statePath = process.env.LANGFUSE_BACKFILL_STATE ?? defaultStatePath;
     let homeDir = process.env.HOME ?? homedir();
     let dryRun = false;
+    let force = false;
     let limit;
     let sinceMs;
     let untilMs;
@@ -167,9 +260,15 @@ function parseArgs(argv) {
         if (arg === "--dry-run") {
             dryRun = true;
         }
+        else if (arg === "--force") {
+            force = true;
+        }
         else if (arg === "--endpoint") {
             endpoint = normalizeEndpoint(next());
         }
+        else if (arg === "--auth") {
+            auth = next();
+        }
         else if (arg === "--state") {
             statePath = next();
         }
@@ -255,12 +354,17 @@ function parseArgs(argv) {
     if (limit !== undefined && (!Number.isFinite(limit) || limit < 1)) {
         throw new Error("--limit must be a positive integer");
     }
+    if (auth !== undefined && auth.trim().length === 0) {
+        throw new Error("--auth must not be empty");
+    }
     return {
         agents,
         endpoint,
+        auth,
         statePath,
         homeDir,
         dryRun,
+        force,
         follow,
         pollIntervalMs,
         idleExitAfterMs,
@@ -329,6 +433,14 @@ function normalizeCostRates(value, modelKey, source) {
             asNumber(record.cache_write) ??
             asNumber(record.inputCacheCreation) ??
             asNumber(record.input_cache_creation),
+        cacheWrite5m: asNumber(record.cacheWrite5m) ??
+            asNumber(record.cache_write_5m) ??
+            asNumber(record.inputCacheCreation5m) ??
+            asNumber(record.input_cache_creation_5m),
+        cacheWrite1h: asNumber(record.cacheWrite1h) ??
+            asNumber(record.cache_write_1h) ??
+            asNumber(record.inputCacheCreation1h) ??
+            asNumber(record.input_cache_creation_1h),
     };
     const values = Object.entries(rates).filter(([, rate]) => rate !== undefined);
     if (values.length === 0)
@@ -467,11 +579,27 @@ function normalizeUsage(value) {
     const record = asRecord(value);
     const nestedCost = asRecord(record.cost);
     const cache = asRecord(record.cache);
+    const cacheCreation = asRecord(record.cache_creation);
     const inputDetails = asRecord(record.input_tokens_details);
     const outputDetails = asRecord(record.output_tokens_details);
     const directInput = asNumber(record.input);
     const aggregateInput = asNumber(record.input_tokens) ??
         asNumber(record.prompt_tokens);
+    const cacheWrite5m = asNumber(record.cacheWrite5m) ??
+        asNumber(record.cache_write_5m) ??
+        asNumber(record.input_cache_creation_5m) ??
+        asNumber(cacheCreation.ephemeral_5m_input_tokens);
+    const cacheWrite1h = asNumber(record.cacheWrite1h) ??
+        asNumber(record.cache_write_1h) ??
+        asNumber(record.input_cache_creation_1h) ??
+        asNumber(cacheCreation.ephemeral_1h_input_tokens);
+    const untypedCacheWrite = asNumber(record.cacheWrite) ??
+        asNumber(record.cache_creation_input_tokens) ??
+        asNumber(cache.write);
+    const hasTypedCacheWrite = cacheWrite5m !== undefined || cacheWrite1h !== undefined;
+    const hasAnthropicCacheShape = hasTypedCacheWrite ||
+        asNumber(record.cache_creation_input_tokens) !== undefined ||
+        asNumber(record.cache_read_input_tokens) !== undefined;
     const usage = {
         input: directInput ?? aggregateInput,
         output: asNumber(record.output) ??
@@ -487,9 +615,9 @@ function normalizeUsage(value) {
             asNumber(record.cached_tokens) ??
             asNumber(inputDetails.cached_tokens) ??
             asNumber(cache.read),
-        cacheWrite: asNumber(record.cacheWrite) ??
-            asNumber(record.cache_creation_input_tokens) ??
-            asNumber(cache.write),
+        cacheWrite: hasTypedCacheWrite ? undefined : untypedCacheWrite,
+        cacheWrite5m,
+        cacheWrite1h,
         total: asNumber(record.totalTokens) ?? asNumber(record.total_tokens) ??
             asNumber(record.total),
         cost: asNumber(nestedCost.total) ??
@@ -499,14 +627,17 @@ function normalizeUsage(value) {
             asNumber(record.cost),
     };
     if (usage.input !== undefined) {
-        usage.inputIncludesCache = directInput === undefined;
+        usage.inputIncludesCache = directInput === undefined && !hasAnthropicCacheShape;
     }
     if (usage.total === undefined) {
         const cacheRead = usage.inputIncludesCache === false ? (usage.cacheRead ?? 0) : 0;
+        const cacheWrite = (usage.cacheWrite ?? 0) +
+            (usage.cacheWrite5m ?? 0) +
+            (usage.cacheWrite1h ?? 0);
         const total = (usage.input ?? 0) +
             (usage.output ?? 0) +
             (usage.reasoning ?? 0) +
-            (usage.cacheWrite ?? 0) +
+            cacheWrite +
             cacheRead;
         if (total > 0)
             usage.total = total;
@@ -529,10 +660,13 @@ function usageDetails(usage) {
         return undefined;
     const details = {};
     const cachedInput = usage.inputIncludesCache === false ? 0 : (usage.cacheRead ?? 0);
-    const cacheWrite = usage.inputIncludesCache === false ? 0 : (usage.cacheWrite ?? 0);
+    const cacheWriteTotal = (usage.cacheWrite ?? 0) +
+        (usage.cacheWrite5m ?? 0) +
+        (usage.cacheWrite1h ?? 0);
+    const cacheWriteInInput = usage.inputIncludesCache === false ? 0 : cacheWriteTotal;
     const regularInput = usage.input === undefined
         ? undefined
-        : Math.max(usage.input - cachedInput - cacheWrite, 0);
+        : Math.max(usage.input - cachedInput - cacheWriteInInput, 0);
     if (regularInput !== undefined)
         details.input = regularInput;
     if (usage.output !== undefined)
@@ -543,6 +677,15 @@ function usageDetails(usage) {
         details.input_cached_tokens = usage.cacheRead;
     if (usage.cacheWrite !== undefined)
         details.input_cache_creation = usage.cacheWrite;
+    if (usage.cacheWrite5m !== undefined) {
+        details.input_cache_creation_5m = usage.cacheWrite5m;
+    }
+    if (usage.cacheWrite1h !== undefined) {
+        details.input_cache_creation_1h = usage.cacheWrite1h;
+    }
+    if (usage.cacheWrite === undefined && cacheWriteTotal > 0) {
+        details.input_cache_creation = cacheWriteTotal;
+    }
     if (usage.total !== undefined)
         details.total = usage.total;
     return Object.keys(details).length > 0 ? details : undefined;
@@ -565,13 +708,30 @@ function calculateCost(event, usage, costRates) {
     setCostPart(details, "output", usage.output, rates.output);
     setCostPart(details, "output_reasoning", usage.output_reasoning, rates.reasoning ?? rates.output);
     setCostPart(details, "input_cached_tokens", usage.input_cached_tokens, rates.cacheRead ?? rates.input);
-    setCostPart(details, "input_cache_creation", usage.input_cache_creation, rates.cacheWrite ?? rates.input);
+    const hasTypedCacheWrite = usage.input_cache_creation_5m !== undefined ||
+        usage.input_cache_creation_1h !== undefined;
+    setCostPart(details, "input_cache_creation_5m", usage.input_cache_creation_5m, rates.cacheWrite5m ?? rates.cacheWrite ?? rates.input);
+    setCostPart(details, "input_cache_creation_1h", usage.input_cache_creation_1h, rates.cacheWrite1h ?? rates.cacheWrite ?? rates.input);
+    if (!hasTypedCacheWrite) {
+        setCostPart(details, "input_cache_creation", usage.input_cache_creation, rates.cacheWrite ?? rates.input);
+    }
+    const calculatedTotal = Object.values(details).reduce((sum, value) => sum + value, 0);
+    let source = "calculated";
+    if (calculatedTotal === 0 &&
+        usage.total !== undefined &&
+        usage.total > 0 &&
+        rates.input !== undefined) {
+        for (const key of Object.keys(details))
+            delete details[key];
+        setCostPart(details, "input", usage.total, rates.input);
+        source = "calculated_total_as_input";
+    }
     if (Object.keys(details).length === 0)
         return undefined;
     details.total = roundCost(Object.values(details).reduce((sum, value) => sum + value, 0));
     return {
         details,
-        source: "calculated",
+        source,
         modelKey,
         rates,
     };
@@ -805,8 +965,12 @@ function codexEvents(homeDir, options = {}) {
                     cwd: currentCwd,
                     startMs: timestamp,
                     parentRecordId: "session",
-                    usage,
-                    metadata: pick(info, ["model_context_window"]),
+                    metadata: {
+                        ...pick(info, ["model_context_window"]),
+                        token_usage_billable: false,
+                        token_usage_source: "codex_event_msg_token_count",
+                        token_usage_details: usageDetails(usage),
+                    },
                 });
             }
         }
@@ -1343,19 +1507,28 @@ function stableId(input) {
     return createHash("sha256").update(input).digest("hex").slice(0, 32);
 }
 function importIdentity(event) {
-    return importIdentityVersions[event.agent] ?? importIdentityVersion;
+    return importStateIdentityVersions[event.agent] ?? importStateIdentityVersion;
+}
+function payloadVersion(event) {
+    return importPayloadVersions[event.agent] ?? importPayloadVersion;
+}
+function langfuseIdIdentity(event) {
+    return langfuseIdIdentityVersions[event.agent] ?? langfuseIdIdentityVersion;
 }
 function fingerprint(event) {
     return `${importIdentity(event)}:${event.agent}:${event.sessionId}:${event.recordId}`;
 }
+function langfuseFingerprint(event) {
+    return `${langfuseIdIdentity(event)}:${event.agent}:${event.sessionId}:${event.recordId}`;
+}
 function traceFingerprint(event) {
-    return `${importIdentity(event)}:${event.agent}:${event.sessionId}`;
+    return `${langfuseIdIdentity(event)}:${event.agent}:${event.sessionId}`;
 }
 function traceId(event) {
     return stableId(traceFingerprint(event));
 }
 function spanId(event) {
-    return stableId(fingerprint(event)).slice(0, 16);
+    return stableId(langfuseFingerprint(event)).slice(0, 16);
 }
 function rootSpanId(event) {
     return stableId(`${traceFingerprint(event)}:root`).slice(0, 16);
@@ -1446,6 +1619,9 @@ function toOtlp(events, options = {}) {
             attr("langfuse.trace.metadata.project_path", firstProject.projectPath),
             attr("langfuse.trace.metadata.project_name", firstProject.projectName),
             attr("langfuse.trace.metadata.project_folder", firstProject.projectFolder),
+            attr("langfuse.trace.metadata.import_payload_version", payloadVersion(first)),
+            attr("langfuse.trace.metadata.import_state_identity", importIdentity(first)),
+            attr("langfuse.trace.metadata.langfuse_id_identity", langfuseIdIdentity(first)),
             attr("langfuse.observation.metadata.agent", first.agent),
             attr("langfuse.observation.metadata.host", currentHost),
             attr("langfuse.observation.metadata.machine", currentHost),
@@ -1456,6 +1632,9 @@ function toOtlp(events, options = {}) {
             attr("langfuse.observation.metadata.project_path", firstProject.projectPath),
             attr("langfuse.observation.metadata.project_name", firstProject.projectName),
             attr("langfuse.observation.metadata.project_folder", firstProject.projectFolder),
+            attr("langfuse.observation.metadata.import_payload_version", payloadVersion(first)),
+            attr("langfuse.observation.metadata.import_state_identity", importIdentity(first)),
+            attr("langfuse.observation.metadata.langfuse_id_identity", langfuseIdIdentity(first)),
             attr("source.path", first.sourcePath),
             attr("cwd", first.cwd),
             attr("project.path", firstProject.projectPath),
@@ -1507,6 +1686,9 @@ function toOtlp(events, options = {}) {
                 attr("langfuse.observation.metadata.project_folder", eventProject.projectFolder),
                 attr("langfuse.observation.metadata.model", modelName ?? event.model),
                 attr("langfuse.observation.metadata.provider", event.provider),
+                attr("langfuse.observation.metadata.import_payload_version", payloadVersion(event)),
+                attr("langfuse.observation.metadata.import_state_identity", importIdentity(event)),
+                attr("langfuse.observation.metadata.langfuse_id_identity", langfuseIdIdentity(event)),
                 attr("langfuse.observation.usage_details", generation ? usage : undefined),
                 attr("langfuse.observation.cost_details", cost?.details),
                 attr("langfuse.observation.metadata.usage_details", usage),
@@ -1515,6 +1697,9 @@ function toOtlp(events, options = {}) {
                 attr("langfuse.observation.metadata.cost_model_key", cost?.modelKey),
                 attr("langfuse.observation.metadata.cost_rates", cost?.rates),
                 attr("langfuse.observation.metadata.recorded_cost", event.usage?.cost),
+                attr("langfuse.observation.metadata.token_usage_billable", event.metadata?.token_usage_billable),
+                attr("langfuse.observation.metadata.token_usage_source", event.metadata?.token_usage_source),
+                attr("langfuse.observation.metadata.token_usage_details", event.metadata?.token_usage_details),
                 attr("langfuse.observation.input", event.input),
                 attr("langfuse.observation.output", event.output),
                 attr("source.path", event.sourcePath),
@@ -1614,11 +1799,16 @@ function splitSendBatches(events, options) {
 }
 async function postOtlp(endpoint, events, options) {
     const body = JSON.stringify(toOtlp(events, options));
+    const headers = {
+        "content-type": "application/json",
+    };
+    if (options.auth)
+        headers.Authorization = authHeader(options.auth);
     let response;
     try {
         response = await fetch(endpoint, {
             method: "POST",
-            headers: { "content-type": "application/json" },
+            headers,
             body,
         });
     }
@@ -1629,6 +1819,11 @@ async function postOtlp(endpoint, events, options) {
         throw new Error(`OTLP POST failed: ${response.status} ${await response.text()}`);
     }
 }
+function authHeader(auth) {
+    if (/^(Basic|Bearer)\s+/i.test(auth))
+        return auth;
+    return `Basic ${Buffer.from(auth, "utf8").toString("base64")}`;
+}
 function describeError(error) {
     if (!(error instanceof Error))
         return String(error);
@@ -1677,7 +1872,9 @@ async function run(options) {
     for (const event of events) {
         discovered[event.agent] = (discovered[event.agent] ?? 0) + 1;
     }
-    const unsent = events.filter((event) => state.sent[fingerprint(event)] === undefined);
+    const unsent = options.force
+        ? events
+        : events.filter((event) => state.sent[fingerprint(event)] === undefined);
     const selected = options.limit === undefined
         ? unsent
         : unsent.slice(0, options.limit);
@@ -1719,6 +1916,7 @@ async function run(options) {
                 await postOtlp(options.endpoint, batch, {
                     maxFieldBytes: options.maxFieldBytes,
                     costRates: options.costRates,
+                    auth: options.auth,
                 });
                 for (const event of batch) {
                     state.sent[fingerprint(event)] = new Date().toISOString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ramarivera/coding-agent-langfuse",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "description": "Universal coding-agent Langfuse backfiller and live OTLP helpers",
   "type": "module",
   "license": "MIT",
@@ -25,6 +25,7 @@
     "check": "tsc --noEmit",
     "test": "node --disable-warning=MODULE_TYPELESS_PACKAGE_JSON --experimental-strip-types --test test/**/*.test.ts",
     "test:e2e": "npm run build && node --disable-warning=MODULE_TYPELESS_PACKAGE_JSON --experimental-strip-types --test e2e/test/**/*.test.ts",
+    "test:e2e:langfuse": "npm run build && LANGFUSE_DOCKER_E2E=1 node --disable-warning=MODULE_TYPELESS_PACKAGE_JSON --experimental-strip-types --test e2e/test/langfuse-docker.test.ts",
     "pack:dry-run": "npm pack --dry-run",
     "prepack": "npm run build"
   },