@ramarivera/coding-agent-langfuse 0.1.52 → 0.1.54

package/README.md

@@ -8,10 +8,12 @@ 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`.
+Codex `event_msg` `token_count` rows are imported as cost-accounting
+generations when they include input/output/cache buckets for a known priced
+model. The importer preserves the original token snapshot in metadata and sends
+Langfuse canonical `usage_details`/`cost_details` derived from the bucketed
+usage. Total-only Codex snapshots and unknown/free-preview models stay
+non-billable to avoid inventing cost from ambiguous telemetry.
 
 ```sh
 coding-agent-langfuse-backfill --agents codex,claude,grok,pi,opencode
@@ -63,13 +65,14 @@ There are two config layers:
 - Optional project-local overlays: every `.langfuse-ca.json` found while
   walking from the session cwd up to the scanned home directory
 
-Global config uses prefix rules:
+Global config uses path-prefix or Git-remote rules:
 
 ```json
 {
   "rules": [
     {
       "pathPrefix": "/Users/example/dev/acme",
+      "gitRemoteIncludes": ["github.com/acme"],
       "tags": ["acme", "client:acme"],
       "metadata": {
         "project_group": "acme",
@@ -82,6 +85,11 @@ Global config uses prefix rules:
 }
 ```
 
+Use `pathPrefix` for stable checkout roots. Use `gitRemoteIncludes` for
+temporary agent worktrees, where the cwd may live under a random directory such
+as `.codex/worktrees/<id>/repo` but the Git remote still identifies the real
+project.
+
 Project-local config is intentionally smaller and overrides/extends the matched
 global rule. Parent overlays are applied before child overlays, so a config at
 `~/work/client-a/.langfuse-ca.json` can tag a whole workstream while nested
@@ -127,8 +135,8 @@ 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, GPT-5.4, and GPT-5.3-Codex API list
-pricing, Anthropic Claude Opus/Sonnet 4 API list pricing, plus the toolbox/Pi
+The built-in catalog covers OpenAI GPT-5.5, GPT-5.4, GPT-5.4 Mini, 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:
@@ -139,6 +147,10 @@ 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`.
+Codex token-count snapshots are the exception: they are charged only when the
+snapshot has explicit input/output/cache buckets. Codex reasoning tokens are
+kept in metadata, but not charged separately because Codex token-count output
+totals already include reasoning tokens.
 
 Use an override only when you intentionally want a different accounting policy:
 

package/dist/backfill.d.ts

@@ -70,7 +70,8 @@ type OtlpOptions = {
     homeDir?: string;
 };
 type PathTagRule = {
-    pathPrefix: string;
+    pathPrefix?: string;
+    gitRemoteIncludes?: string[];
     tags: string[];
     metadata: Record<string, unknown>;
     projectName?: string;

package/dist/backfill.js

@@ -8,7 +8,7 @@ const allAgents = ["claude", "codex", "grok", "opencode", "pi"];
 const importStateIdentityVersion = "v9-cost-details";
 const importStateIdentityVersions = {
     claude: "v13-claude-message-snapshot-dedupe",
-    codex: "v11-codex-token-accounting-nonbillable",
+    codex: "v12-codex-token-accounting-priced",
     grok: "v12-cost-details",
     opencode: "v11-cost-details",
     pi: "v12-cost-details",
@@ -24,7 +24,7 @@ const langfuseIdIdentityVersions = {
 const importPayloadVersion = "v10-cost-details";
 const importPayloadVersions = {
     claude: "v11-claude-message-snapshot-dedupe",
-    codex: "v11-codex-token-accounting-nonbillable",
+    codex: "v12-codex-token-accounting-priced",
 };
 const defaultEndpoint = "https://langfuse.ai.roxasroot.net/otel/v1/traces";
 const deadRemoteEndpoint = "http://langfuse.ai.roxasroot.net:14318/v1/traces";
@@ -72,6 +72,12 @@ const gpt54Rates = {
     cacheRead: 0.25,
     cacheWrite: 2.5,
 };
+const gpt54MiniRates = {
+    input: 0.75,
+    output: 4.5,
+    cacheRead: 0.075,
+    cacheWrite: 0.75,
+};
 const gpt53CodexRates = {
     input: 1.75,
     output: 14,
@@ -101,6 +107,8 @@ const defaultCostRates = {
     "openai/gpt-5.5-pro": gpt55ProRates,
     "gpt-5.4": gpt54Rates,
     "openai/gpt-5.4": gpt54Rates,
+    "gpt-5.4-mini": gpt54MiniRates,
+    "openai/gpt-5.4-mini": gpt54MiniRates,
     "gpt-5.3-codex": gpt53CodexRates,
     "openai/gpt-5.3-codex": gpt53CodexRates,
     "claude-opus-4": claudeOpus4Rates,
@@ -196,13 +204,20 @@ function projectMetadata(cwd) {
         projectFolder: projectName,
     };
 }
-function matchPathTags(cwd, config, homeDir) {
-    if (!cwd)
+function matchPathTags(cwd, config, homeDir, git) {
+    if (!cwd && !git?.remoteUrls?.length)
         return { tags: [], metadata: {} };
-    const normalizedCwd = normalizeRulePath(cwd);
+    const normalizedCwd = cwd ? normalizeRulePath(cwd) : undefined;
+    const normalizedRemotes = (git?.remoteUrls ?? []).map((remote) => remote.toLowerCase());
     const matched = config.rules.filter((rule) => {
-        const prefix = normalizeRulePath(rule.pathPrefix);
-        return normalizedCwd === prefix || normalizedCwd.startsWith(`${prefix}/`);
+        const pathMatch = rule.pathPrefix && normalizedCwd
+            ? (() => {
+                const prefix = normalizeRulePath(rule.pathPrefix);
+                return normalizedCwd === prefix || normalizedCwd.startsWith(`${prefix}/`);
+            })()
+            : false;
+        const gitRemoteMatch = (rule.gitRemoteIncludes ?? []).some((needle) => normalizedRemotes.some((remote) => remote.includes(needle.toLowerCase())));
+        return pathMatch || gitRemoteMatch;
     });
     const globalMatch = matched.reduce((acc, rule) => ({
         tags: [...new Set([...acc.tags, ...rule.tags])],
@@ -238,14 +253,15 @@ function matchPathTags(cwd, config, homeDir) {
 }
 function mergeProjectMetadata(cwd, config, homeDir) {
     const project = projectMetadata(cwd);
-    const pathTags = matchPathTags(cwd, config, homeDir);
+    const git = loadGitMetadata(cwd);
+    const pathTags = matchPathTags(cwd, config, homeDir, git);
     return {
         ...project,
         projectName: pathTags.projectName ?? project.projectName,
         projectFolder: pathTags.projectFolder ?? project.projectFolder,
         tags: pathTags.tags,
         metadata: pathTags.metadata,
-        git: loadGitMetadata(cwd),
+        git,
     };
 }
 function loadGitMetadata(cwd) {
@@ -263,10 +279,16 @@ function loadGitMetadata(cwd) {
     const branch = gitOutput(gitCwd, ["branch", "--show-current"]) ??
         gitOutput(gitCwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
     const commit = gitOutput(gitCwd, ["rev-parse", "--verify", "HEAD"]);
+    const remoteUrls = gitOutput(gitCwd, ["remote", "-v"])
+        ?.split("\n")
+        .map((line) => line.trim().split(/\s+/)[1])
+        .filter((remote) => Boolean(remote))
+        .filter((remote, index, remotes) => remotes.indexOf(remote) === index);
     const metadata = {
         worktreePath,
         branch: branch === "HEAD" ? undefined : branch,
         commit,
+        remoteUrls,
     };
     gitMetadataCache.set(gitCwd, metadata);
     return metadata;
@@ -511,8 +533,10 @@ function loadPathTagsConfig(path) {
     const rules = rawRules.map((rawRule, index) => {
         const rule = asRecord(rawRule);
         const pathPrefix = asString(rule.pathPrefix) ?? asString(rule.path_prefix);
-        if (!pathPrefix) {
-            throw new Error(`Invalid path tags config ${path}: rules[${index}].pathPrefix is required`);
+        const gitRemoteIncludes = stringArray(rule.gitRemoteIncludes ?? rule.git_remote_includes ?? rule.gitRemoteInclude ??
+            rule.git_remote_include);
+        if (!pathPrefix && gitRemoteIncludes.length === 0) {
+            throw new Error(`Invalid path tags config ${path}: rules[${index}] requires pathPrefix or gitRemoteIncludes`);
         }
         const tags = Array.isArray(rule.tags)
             ? rule.tags.filter((tag) => typeof tag === "string" && tag.trim().length > 0)
@@ -520,6 +544,7 @@ function loadPathTagsConfig(path) {
         const metadata = asRecord(rule.metadata);
         return {
             pathPrefix,
+            gitRemoteIncludes,
             tags,
             metadata,
             projectName: asString(rule.projectName) ?? asString(rule.project_name),
@@ -764,6 +789,13 @@ function getPath(value, keys) {
 function asString(value) {
     return typeof value === "string" ? value : undefined;
 }
+function stringArray(value) {
+    if (typeof value === "string" && value.trim().length > 0)
+        return [value];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
 function asNumber(value) {
     return typeof value === "number" && Number.isFinite(value)
         ? value
@@ -925,6 +957,28 @@ function usageTokenTotal(usage) {
             (usage.cacheWrite5m ?? 0) +
             (usage.cacheWrite1h ?? 0);
 }
+function codexBillableTokenUsage(usage) {
+    if (!usage)
+        return undefined;
+    const hasTokenBuckets = [
+        usage.input,
+        usage.output,
+        usage.reasoning,
+        usage.cacheRead,
+        usage.cacheWrite,
+        usage.cacheWrite5m,
+        usage.cacheWrite1h,
+    ].some((value) => value !== undefined && value > 0);
+    if (!hasTokenBuckets)
+        return undefined;
+    return {
+        ...usage,
+        output: usage.output ?? usage.reasoning,
+        // Codex token_count rows report reasoning as a subset of output tokens.
+        // Keep reasoning in metadata, but do not charge it a second time.
+        reasoning: undefined,
+    };
+}
 function textLength(value) {
     if (typeof value === "string")
         return value.length;
@@ -1190,6 +1244,7 @@ function codexEvents(homeDir, options = {}) {
                 const info = asRecord(rowPayload.info);
                 const usage = normalizeUsage(asRecord(info.last_token_usage)) ??
                     normalizeUsage(asRecord(info.total_token_usage));
+                const billableUsage = codexBillableTokenUsage(usage);
                 const tokenKey = JSON.stringify({
                     model: asString(info.model) ?? currentModel,
                     usage,
@@ -1207,9 +1262,10 @@ function codexEvents(homeDir, options = {}) {
                     cwd: currentCwd,
                     startMs: timestamp,
                     parentRecordId: "session",
+                    usage: billableUsage,
                     metadata: {
                         ...pick(info, ["model_context_window"]),
-                        token_usage_billable: false,
+                        token_usage_billable: billableUsage !== undefined,
                         token_usage_source: "codex_event_msg_token_count",
                         token_usage_details: usageDetails(usage),
                     },

package/package.json

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