@ramarivera/coding-agent-langfuse 0.1.55 → 0.1.57

package/README.md

@@ -135,15 +135,27 @@ 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, 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:
-`$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. 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.
+By default, the importer refreshes model pricing from `https://models.dev/api.json`
+and caches it locally. The cache is used for both one-shot backfills and
+`--follow` services, so long-running collectors do not hit the network for every
+scan. The built-in catalog remains only as an offline fallback for known local
+models; explicit `--cost-rates` and `--cost-rates-json` overrides always win.
+
+Control the pricing cache with:
+
+```sh
+npx @ramarivera/coding-agent-langfuse@latest \
+  --models-dev-cache "$HOME/.cache/coding-agent-langfuse/models-dev-v1.json" \
+  --models-dev-ttl-ms 86400000
+```
+
+Use `--models-dev` to force-enable the cache if an environment disabled it. Use
+`--no-models-dev` or `CODING_AGENT_LANGFUSE_MODELS_DEV=0` for fully static
+offline pricing. Advanced deployments can set `--models-dev-url`,
+`CODING_AGENT_LANGFUSE_MODELS_DEV_CACHE`,
+`CODING_AGENT_LANGFUSE_MODELS_DEV_TTL_MS`, or
+`CODING_AGENT_LANGFUSE_MODELS_DEV_FETCH_TIMEOUT_MS`.
+
 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`.
@@ -228,6 +240,12 @@ with a conservative cross-platform PATH. Use `--npx-path` and `--path` when a
 host keeps Node.js somewhere outside the normal npm/Homebrew/system locations,
 including nvm, fnm, Volta, asdf, mise, or another shell manager.
 
+The public API exposes `serviceCreators` for macOS LaunchAgent, Linux systemd
+user units, and Windows Scheduled Task scripts, plus `agentProcessors` for
+Claude Code, Codex, Grok, OpenCode, and Pi. These registries are the extension
+points for adding another host service target or coding-agent history reader
+without adding more platform or agent conditionals to the CLI internals.
+
 ## Backfill windows
 
 Backfill only a timeframe when repairing a host or replaying a recent window:

package/dist/backfill.d.ts

@@ -50,6 +50,8 @@ type BackfillOptions = {
     maxFieldBytes: number;
     postDelayMs: number;
     costRates: CostCatalog;
+    costRateOverrides: CostCatalog;
+    modelsDev: ModelsDevOptions;
     pathTagsConfigPath?: string;
     pathTagsConfig: PathTagsConfig;
 };
@@ -63,6 +65,13 @@ type CostRates = {
     cacheWrite1h?: number;
 };
 type CostCatalog = Record<string, CostRates>;
+type ModelsDevOptions = {
+    enabled: boolean;
+    url: string;
+    cachePath: string;
+    ttlMs: number;
+    fetchTimeoutMs: number;
+};
 type OtlpOptions = {
     maxFieldBytes?: number;
     costRates?: CostCatalog;
@@ -88,6 +97,10 @@ type ProjectTagOverlay = {
     projectFolder?: string;
     sourcePath?: string;
 };
+type AgentProcessor = {
+    name: AgentName;
+    discover(options: BackfillOptions): BackfillEvent[];
+};
 type RunSummary = {
     discovered: Record<string, number>;
     sent: number;
@@ -107,6 +120,7 @@ type FollowSummary = RunSummary & {
 declare const allAgents: AgentName[];
 declare const defaultEndpoint = "https://langfuse.ai.roxasroot.net/otel/v1/traces";
 declare function parseArgs(argv: string[]): BackfillOptions;
+declare function parseModelsDevCostCatalog(value: unknown, source?: string): CostCatalog;
 declare function codexEvents(homeDir: string, options?: {
     sessionIds?: Set<string>;
     sinceMs?: number;
@@ -121,8 +135,9 @@ declare function opencodeEvents(homeDir: string, options?: {
 }): BackfillEvent[];
 declare function fingerprint(event: BackfillEvent): string;
 declare function toOtlp(events: BackfillEvent[], options?: OtlpOptions): Record<string, unknown>;
+declare const agentProcessors: Record<AgentName, AgentProcessor>;
 declare function discoverEvents(options: BackfillOptions): BackfillEvent[];
 declare function run(options: BackfillOptions): Promise<RunSummary>;
 declare function follow(options: BackfillOptions): Promise<FollowSummary>;
 declare function main(argv?: string[]): Promise<RunSummary | FollowSummary>;
-export { type BackfillEvent, type BackfillOptions, type AgentName, allAgents, claudeEvents, codexEvents, defaultEndpoint, discoverEvents, fingerprint, follow, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };
+export { type BackfillEvent, type BackfillOptions, type AgentName, type AgentProcessor, type CostCatalog, type CostRates, type ModelsDevOptions, agentProcessors, allAgents, claudeEvents, codexEvents, defaultEndpoint, discoverEvents, fingerprint, follow, grokEvents, parseModelsDevCostCatalog, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };

package/dist/backfill.js

@@ -2,16 +2,16 @@
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { closeSync, existsSync, mkdirSync, openSync, renameSync, readdirSync, readFileSync, readSync, statSync, writeFileSync, } from "node:fs";
-import { hostname, homedir } from "node:os";
+import { hostname, homedir, platform as osPlatform } from "node:os";
 import { dirname, join } from "node:path";
 const allAgents = ["claude", "codex", "grok", "opencode", "pi"];
-const importStateIdentityVersion = "v9-cost-details";
+const importStateIdentityVersion = "v10-models-dev-cost-catalog";
 const importStateIdentityVersions = {
-    claude: "v13-claude-message-snapshot-dedupe",
-    codex: "v12-codex-token-accounting-priced",
-    grok: "v12-cost-details",
-    opencode: "v11-cost-details",
-    pi: "v12-cost-details",
+    claude: "v14-models-dev-cost-catalog",
+    codex: "v13-models-dev-cost-catalog",
+    grok: "v13-models-dev-cost-catalog",
+    opencode: "v12-models-dev-cost-catalog",
+    pi: "v13-models-dev-cost-catalog",
 };
 const langfuseIdIdentityVersion = "v8-cached-input-token-split";
 const langfuseIdIdentityVersions = {
@@ -21,10 +21,10 @@ const langfuseIdIdentityVersions = {
     opencode: "v10-opencode-message-parts",
     pi: "v11-tool-results",
 };
-const importPayloadVersion = "v10-cost-details";
+const importPayloadVersion = "v11-models-dev-cost-catalog";
 const importPayloadVersions = {
-    claude: "v11-claude-message-snapshot-dedupe",
-    codex: "v12-codex-token-accounting-priced",
+    claude: "v12-models-dev-cost-catalog",
+    codex: "v13-models-dev-cost-catalog",
 };
 const defaultEndpoint = "https://langfuse.ai.roxasroot.net/otel/v1/traces";
 const deadRemoteEndpoint = "http://langfuse.ai.roxasroot.net:14318/v1/traces";
@@ -32,6 +32,10 @@ const defaultMaxRequestBytes = 12 * 1024 * 1024;
 const defaultMaxFieldBytes = 512 * 1024;
 const defaultStatePath = join(homedir(), ".local/state/coding-agent-langfuse/backfill-v6.json");
 const defaultPathTagsConfigPath = join(homedir(), ".config/coding-agent-langfuse/path-tags.json");
+const defaultModelsDevUrl = "https://models.dev/api.json";
+const defaultModelsDevTtlMs = 24 * 60 * 60 * 1000;
+const defaultModelsDevFetchTimeoutMs = 5_000;
+const defaultModelsDevCachePath = join(defaultCacheDir(), "models-dev-v1.json");
 const currentHost = hostname();
 const projectLocalConfigFile = ".langfuse-ca.json";
 const projectLocalConfigCache = new Map();
@@ -115,6 +119,8 @@ const defaultCostRates = {
     "anthropic/claude-opus-4": claudeOpus4Rates,
     "claude-opus-4-1": claudeOpus4Rates,
     "anthropic/claude-opus-4-1": claudeOpus4Rates,
+    "claude-opus-4-5": claudeOpus4Rates,
+    "anthropic/claude-opus-4-5": claudeOpus4Rates,
     "claude-opus-4-6": claudeOpus4Rates,
     "anthropic/claude-opus-4-6": claudeOpus4Rates,
     "claude-opus-4-7": claudeOpus4Rates,
@@ -338,6 +344,11 @@ Options:
   --max-request-bytes N   Split OTLP POSTs below this JSON byte size (default: ${defaultMaxRequestBytes})
   --max-field-bytes N     Truncate individual input/output fields above this byte size (default: ${defaultMaxFieldBytes})
   --post-delay-ms N       Delay after each successful OTLP POST (default: 0)
+  --models-dev            Enable models.dev pricing cache refresh
+  --no-models-dev         Disable models.dev pricing cache refresh
+  --models-dev-url URL    models.dev-compatible pricing catalog URL (default: ${defaultModelsDevUrl})
+  --models-dev-cache PATH Local pricing cache path (default: ${defaultModelsDevCachePath})
+  --models-dev-ttl-ms N   Refresh models.dev cache after this many ms (default: ${defaultModelsDevTtlMs})
   --cost-rates PATH       JSON model cost-rate overrides in USD per 1M tokens
   --cost-rates-json JSON  Inline JSON model cost-rate overrides in USD per 1M tokens
   --path-tags-config PATH JSON path-prefix rules that add Langfuse tags/metadata
@@ -370,7 +381,8 @@ function parseArgs(argv) {
     let postDelayMs = Number.parseInt(process.env.LANGFUSE_BACKFILL_POST_DELAY_MS ?? "", 10);
     if (!Number.isFinite(postDelayMs))
         postDelayMs = 0;
-    let costRates = loadCostCatalogFromEnv();
+    let modelsDev = loadModelsDevOptionsFromEnv();
+    let costRateOverrides = loadCostCatalogOverridesFromEnv();
     let pathTagsConfigPath = process.env.CODING_AGENT_LANGFUSE_PATH_TAGS_CONFIG ??
         process.env.LANGFUSE_BACKFILL_PATH_TAGS_CONFIG ??
         defaultPathTagsConfigPath;
@@ -434,11 +446,26 @@ function parseArgs(argv) {
         else if (arg === "--post-delay-ms") {
             postDelayMs = Number.parseInt(next(), 10);
         }
+        else if (arg === "--models-dev") {
+            modelsDev = { ...modelsDev, enabled: true };
+        }
+        else if (arg === "--no-models-dev") {
+            modelsDev = { ...modelsDev, enabled: false };
+        }
+        else if (arg === "--models-dev-url") {
+            modelsDev = { ...modelsDev, url: next() };
+        }
+        else if (arg === "--models-dev-cache") {
+            modelsDev = { ...modelsDev, cachePath: next() };
+        }
+        else if (arg === "--models-dev-ttl-ms") {
+            modelsDev = { ...modelsDev, ttlMs: Number.parseInt(next(), 10) };
+        }
         else if (arg === "--cost-rates") {
-            costRates = mergeCostCatalog(costRates, loadCostCatalogFile(next()));
+            costRateOverrides = mergeCostCatalog(costRateOverrides, loadCostCatalogFile(next()));
         }
         else if (arg === "--cost-rates-json") {
-            costRates = mergeCostCatalog(costRates, parseCostCatalogJson(next()));
+            costRateOverrides = mergeCostCatalog(costRateOverrides, parseCostCatalogJson(next()));
         }
         else if (arg === "--path-tags-config") {
             pathTagsConfigPath = next();
@@ -481,6 +508,13 @@ function parseArgs(argv) {
     if (!Number.isFinite(postDelayMs) || postDelayMs < 0) {
         throw new Error("--post-delay-ms must be a non-negative integer");
     }
+    if (!Number.isFinite(modelsDev.ttlMs) || modelsDev.ttlMs < 0) {
+        throw new Error("--models-dev-ttl-ms must be a non-negative integer");
+    }
+    if (!Number.isFinite(modelsDev.fetchTimeoutMs) ||
+        modelsDev.fetchTimeoutMs < 1) {
+        throw new Error("CODING_AGENT_LANGFUSE_MODELS_DEV_FETCH_TIMEOUT_MS must be a positive integer");
+    }
     if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 1) {
         throw new Error("--poll-interval-ms must be a positive integer");
     }
@@ -494,6 +528,7 @@ function parseArgs(argv) {
     if (auth !== undefined && auth.trim().length === 0) {
         throw new Error("--auth must not be empty");
     }
+    const costRates = resolveCostCatalogSync(modelsDev, costRateOverrides);
     return {
         agents,
         endpoint,
@@ -514,6 +549,8 @@ function parseArgs(argv) {
         maxFieldBytes,
         postDelayMs,
         costRates,
+        costRateOverrides,
+        modelsDev,
         pathTagsConfigPath,
         pathTagsConfig: loadPathTagsConfig(pathTagsConfigPath),
     };
@@ -628,7 +665,22 @@ function isSameOrChildPath(child, parent) {
         normalizedChild.startsWith(`${normalizedParent}/`);
 }
 function loadCostCatalogFromEnv() {
-    let catalog = { ...defaultCostRates };
+    return resolveCostCatalogSync(loadModelsDevOptionsFromEnv(), loadCostCatalogOverridesFromEnv());
+}
+function resolveCostCatalogSync(modelsDev, overrides = {}) {
+    const modelsDevCatalog = modelsDev.enabled
+        ? loadModelsDevCostCatalogFromCache(modelsDev)
+        : {};
+    return mergeCostCatalog(mergeCostCatalog(defaultCostRates, modelsDevCatalog), overrides);
+}
+async function resolveCostCatalog(options) {
+    const modelsDevCatalog = options.modelsDev.enabled
+        ? await loadModelsDevCostCatalog(options.modelsDev)
+        : {};
+    return mergeCostCatalog(mergeCostCatalog(defaultCostRates, modelsDevCatalog), options.costRateOverrides);
+}
+function loadCostCatalogOverridesFromEnv() {
+    let catalog = {};
     const path = process.env.CODING_AGENT_LANGFUSE_COST_RATES_PATH ??
         process.env.LANGFUSE_BACKFILL_COST_RATES_PATH;
     const inlineJson = process.env.CODING_AGENT_LANGFUSE_COST_RATES_JSON ??
@@ -639,6 +691,184 @@ function loadCostCatalogFromEnv() {
         catalog = mergeCostCatalog(catalog, parseCostCatalogJson(inlineJson));
     return catalog;
 }
+function loadModelsDevOptionsFromEnv() {
+    const enabledValue = process.env.CODING_AGENT_LANGFUSE_MODELS_DEV ??
+        process.env.LANGFUSE_BACKFILL_MODELS_DEV;
+    const ttlMs = Number.parseInt(process.env.CODING_AGENT_LANGFUSE_MODELS_DEV_TTL_MS ??
+        process.env.LANGFUSE_BACKFILL_MODELS_DEV_TTL_MS ??
+        `${defaultModelsDevTtlMs}`, 10);
+    const fetchTimeoutMs = Number.parseInt(process.env.CODING_AGENT_LANGFUSE_MODELS_DEV_FETCH_TIMEOUT_MS ??
+        `${defaultModelsDevFetchTimeoutMs}`, 10);
+    return {
+        enabled: !isFalseLike(enabledValue),
+        url: process.env.CODING_AGENT_LANGFUSE_MODELS_DEV_URL ??
+            process.env.LANGFUSE_BACKFILL_MODELS_DEV_URL ??
+            defaultModelsDevUrl,
+        cachePath: process.env.CODING_AGENT_LANGFUSE_MODELS_DEV_CACHE ??
+            process.env.LANGFUSE_BACKFILL_MODELS_DEV_CACHE ??
+            defaultModelsDevCachePath,
+        ttlMs,
+        fetchTimeoutMs,
+    };
+}
+function isFalseLike(value) {
+    return value !== undefined && /^(0|false|off|no)$/i.test(value.trim());
+}
+function defaultCacheDir() {
+    const xdgCacheHome = process.env.XDG_CACHE_HOME;
+    if (xdgCacheHome)
+        return join(xdgCacheHome, "coding-agent-langfuse");
+    if (osPlatform() === "darwin") {
+        return join(homedir(), "Library/Caches/coding-agent-langfuse");
+    }
+    return join(homedir(), ".cache/coding-agent-langfuse");
+}
+async function loadModelsDevCostCatalog(options) {
+    const cached = readModelsDevCache(options.cachePath);
+    if (cached && !modelsDevCacheExpired(cached.fetchedAt, options.ttlMs)) {
+        return cached.catalog;
+    }
+    try {
+        const rawCatalog = await fetchModelsDevCatalog(options);
+        writeModelsDevCache(options.cachePath, options.url, rawCatalog);
+        return parseModelsDevCostCatalog(rawCatalog, options.url);
+    }
+    catch (error) {
+        if (cached) {
+            console.warn(`Could not refresh models.dev pricing from ${options.url}; using cached pricing from ${options.cachePath}: ${describeError(error)}`);
+            return cached.catalog;
+        }
+        console.warn(`Could not load models.dev pricing from ${options.url}; using built-in fallback rates: ${describeError(error)}`);
+        return {};
+    }
+}
+function loadModelsDevCostCatalogFromCache(options) {
+    return readModelsDevCache(options.cachePath)?.catalog ?? {};
+}
+function readModelsDevCache(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const json = readFileSync(path, "utf8");
+        const parsed = JSON.parse(json);
+        const record = asRecord(parsed);
+        const fetchedAt = asString(record.fetchedAt) ??
+            asString(record.fetched_at) ??
+            new Date(statSync(path).mtimeMs).toISOString();
+        return {
+            fetchedAt,
+            catalog: parseModelsDevCostCatalog(parsed, path),
+        };
+    }
+    catch (error) {
+        console.warn(`Ignoring invalid models.dev pricing cache ${path}: ${describeError(error)}`);
+        return undefined;
+    }
+}
+function modelsDevCacheExpired(fetchedAt, ttlMs) {
+    if (ttlMs === 0)
+        return true;
+    const fetchedAtMs = Date.parse(fetchedAt);
+    if (!Number.isFinite(fetchedAtMs))
+        return true;
+    return Date.now() - fetchedAtMs > ttlMs;
+}
+async function fetchModelsDevCatalog(options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.fetchTimeoutMs);
+    try {
+        const response = await fetch(options.url, {
+            headers: { accept: "application/json" },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} ${await response.text()}`);
+        }
+        return await response.json();
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function writeModelsDevCache(path, sourceUrl, catalog) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tempPath = `${path}.${process.pid}.tmp`;
+    writeFileSync(tempPath, `${JSON.stringify({
+        version: 1,
+        sourceUrl,
+        fetchedAt: new Date().toISOString(),
+        catalog,
+    }, null, 2)}\n`);
+    renameSync(tempPath, path);
+}
+function parseModelsDevCostCatalog(value, source = "models.dev catalog") {
+    const root = asRecord(value);
+    const catalogRoot = asRecord(root.catalog);
+    const providerRoot = asRecord(catalogRoot.providers);
+    const providers = Object.keys(providerRoot).length > 0
+        ? providerRoot
+        : Object.keys(catalogRoot).length > 0
+            ? catalogRoot
+            : root;
+    const out = {};
+    for (const [providerId, rawProvider] of Object.entries(providers)) {
+        const provider = asRecord(rawProvider);
+        const models = asRecord(provider.models);
+        for (const [modelId, rawModel] of Object.entries(models)) {
+            const rates = modelsDevCostRates(rawModel, `${providerId}/${modelId}`, source);
+            if (!rates)
+                continue;
+            for (const alias of modelsDevAliases(providerId, modelId)) {
+                out[alias] = { ...(out[alias] ?? {}), ...rates };
+            }
+        }
+    }
+    return out;
+}
+function modelsDevCostRates(rawModel, modelKey, source) {
+    const model = asRecord(rawModel);
+    const cost = asRecord(model.cost);
+    if (Object.keys(cost).length === 0)
+        return undefined;
+    const cacheWrite = asNumber(cost.cache_write);
+    return normalizeCostRates({
+        input: cost.input,
+        output: cost.output,
+        reasoning: cost.reasoning,
+        cacheRead: cost.cache_read,
+        cacheWrite,
+        cacheWrite5m: cacheWrite,
+        cacheWrite1h: cacheWrite,
+    }, modelKey, source);
+}
+function modelsDevAliases(providerId, modelId) {
+    const aliases = new Set([modelId, `${providerId}/${modelId}`]);
+    const canonicalProviderPrefixes = [
+        "anthropic",
+        "openai",
+        "fireworks-ai",
+        "fireworks",
+        "fireworks-firepass",
+        "opencode",
+    ];
+    for (const prefix of canonicalProviderPrefixes) {
+        if (modelId.startsWith(`${prefix}/`)) {
+            aliases.add(modelId.slice(prefix.length + 1));
+        }
+    }
+    if (providerId === "anthropic")
+        aliases.add(`anthropic/${modelId}`);
+    if (providerId === "openai")
+        aliases.add(`openai/${modelId}`);
+    if (providerId === "fireworks-ai") {
+        aliases.add(`fireworks/${modelId}`);
+        aliases.add(`fireworks-firepass/${modelId}`);
+    }
+    if (providerId === "opencode") {
+        aliases.add(modelId);
+    }
+    return [...aliases];
+}
 function loadCostCatalogFile(path) {
     return parseCostCatalogJson(readFileSync(path, "utf8"), path);
 }
@@ -2260,32 +2490,49 @@ function describeError(error) {
         ? `${error.message} (${parts.join("; ")})`
         : error.message;
 }
-function discoverEvents(options) {
-    const providers = {
-        claude: (inner) => claudeEvents(inner.homeDir),
-        codex: (inner) => codexEvents(inner.homeDir, {
-            sessionIds: inner.sessionIds,
-            sinceMs: inner.sinceMs,
+const agentProcessors = {
+    claude: {
+        name: "claude",
+        discover: (options) => claudeEvents(options.homeDir),
+    },
+    codex: {
+        name: "codex",
+        discover: (options) => codexEvents(options.homeDir, {
+            sessionIds: options.sessionIds,
+            sinceMs: options.sinceMs,
         }),
-        grok: (inner) => grokEvents(inner.homeDir),
-        opencode: (inner) => opencodeEvents(inner.homeDir, {
-            rowLimit: inner.limit,
-            sinceMs: inner.sinceMs,
-            untilMs: inner.untilMs,
+    },
+    grok: {
+        name: "grok",
+        discover: (options) => grokEvents(options.homeDir),
+    },
+    opencode: {
+        name: "opencode",
+        discover: (options) => opencodeEvents(options.homeDir, {
+            rowLimit: options.limit,
+            sinceMs: options.sinceMs,
+            untilMs: options.untilMs,
         }),
-        pi: (inner) => piEvents(inner.homeDir),
-    };
+    },
+    pi: {
+        name: "pi",
+        discover: (options) => piEvents(options.homeDir),
+    },
+};
+function discoverEvents(options) {
     return allAgents
         .filter((agent) => options.agents.has(agent))
-        .flatMap((agent) => providers[agent](options))
+        .flatMap((agent) => agentProcessors[agent].discover(options))
         .filter((event) => options.sinceMs === undefined || event.startMs >= options.sinceMs)
         .filter((event) => options.untilMs === undefined || event.startMs <= options.untilMs)
         .filter((event) => options.sessionIds.size === 0 || options.sessionIds.has(event.sessionId))
         .sort((a, b) => a.startMs - b.startMs);
 }
 async function run(options) {
+    const costRates = await resolveCostCatalog(options);
+    const runOptions = { ...options, costRates };
     const state = loadState(options.statePath);
-    const events = discoverEvents(options);
+    const events = discoverEvents(runOptions);
     const discovered = Object.fromEntries(allAgents.map((agent) => [agent, 0]));
     for (const event of events) {
         discovered[event.agent] = (discovered[event.agent] ?? 0) + 1;
@@ -2307,7 +2554,7 @@ async function run(options) {
                 batchSize: options.batchSize,
                 maxRequestBytes: options.maxRequestBytes,
                 maxFieldBytes: options.maxFieldBytes,
-                costRates: options.costRates,
+                costRates: runOptions.costRates,
                 pathTagsConfig: options.pathTagsConfig,
                 homeDir: options.homeDir,
             });
@@ -2335,7 +2582,7 @@ async function run(options) {
             try {
                 await postOtlp(options.endpoint, batch, {
                     maxFieldBytes: options.maxFieldBytes,
-                    costRates: options.costRates,
+                    costRates: runOptions.costRates,
                     pathTagsConfig: options.pathTagsConfig,
                     homeDir: options.homeDir,
                     auth: options.auth,
@@ -2446,4 +2693,4 @@ if (import.meta.url === `file://${process.argv[1]}`) {
         process.exit(1);
     }
 }
-export { allAgents, claudeEvents, codexEvents, defaultEndpoint, discoverEvents, fingerprint, follow, grokEvents, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };
+export { agentProcessors, allAgents, claudeEvents, codexEvents, defaultEndpoint, discoverEvents, fingerprint, follow, grokEvents, parseModelsDevCostCatalog, main, opencodeEvents, parseArgs, piEvents, run, toOtlp, };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { codexEvents, discoverEvents, fingerprint, parseArgs, piEvents, run, toOtlp, } from "./backfill.js";
-export { buildServicePlan, parseServiceArgs, serviceMain, } from "./service.js";
+export { type AgentProcessor, type CostCatalog, type CostRates, type ModelsDevOptions, agentProcessors, codexEvents, discoverEvents, fingerprint, parseModelsDevCostCatalog, parseArgs, piEvents, run, toOtlp, } from "./backfill.js";
+export { type ServiceCreator, buildServicePlan, parseServiceArgs, serviceMain, serviceCreators, } from "./service.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { codexEvents, discoverEvents, fingerprint, parseArgs, piEvents, run, toOtlp, } from "./backfill.js";
-export { buildServicePlan, parseServiceArgs, serviceMain, } from "./service.js";
+export { agentProcessors, codexEvents, discoverEvents, fingerprint, parseModelsDevCostCatalog, parseArgs, piEvents, run, toOtlp, } from "./backfill.js";
+export { buildServicePlan, parseServiceArgs, serviceMain, serviceCreators, } from "./service.js";

package/dist/service.d.ts

@@ -13,6 +13,11 @@ type ServiceOptions = {
     batchSize: number;
     pollIntervalMs: number;
     postDelayMs: number;
+    modelsDevEnabled: boolean;
+    modelsDevDisabled: boolean;
+    modelsDevUrl?: string;
+    modelsDevCachePath?: string;
+    modelsDevTtlMs?: number;
     costRatesPath?: string;
     costRatesJson?: string;
     pathTagsConfigPath?: string;
@@ -34,9 +39,14 @@ type ServicePlan = {
     uninstallCommands: string[][];
     statusCommands: string[][];
 };
+type ServiceCreator = {
+    platform: ServicePlatform;
+    create(options: ServiceOptions, command: string[]): ServicePlan;
+};
 declare function parseServiceArgs(argv: string[]): ServiceOptions;
+declare const serviceCreators: Record<ServicePlatform, ServiceCreator>;
 declare function buildServicePlan(options: ServiceOptions): ServicePlan;
 declare function serviceMain(argv?: string[]): Promise<ServicePlan>;
 declare function redactStatusOutput(output: string): string;
 declare function lifecycleEnv(): NodeJS.ProcessEnv;
-export { type ServiceOptions, type ServicePlan, buildServicePlan, redactStatusOutput, parseServiceArgs, serviceMain, lifecycleEnv, };
+export { type ServiceCreator, type ServiceOptions, type ServicePlan, buildServicePlan, serviceCreators, redactStatusOutput, parseServiceArgs, serviceMain, lifecycleEnv, };

package/dist/service.js

@@ -24,6 +24,11 @@ Service options:
   --batch-size N          OTLP spans per POST (default: 10)
   --poll-interval-ms N    Delay between --follow scans (default: 5000)
   --post-delay-ms N       Delay after each successful OTLP POST (default: 0)
+  --models-dev            Enable models.dev pricing cache refresh in the follower
+  --no-models-dev         Disable models.dev pricing cache refresh in the follower
+  --models-dev-url URL    models.dev-compatible pricing catalog URL
+  --models-dev-cache PATH Local pricing cache path
+  --models-dev-ttl-ms N   Refresh models.dev cache after this many ms
   --cost-rates PATH       JSON model cost-rate overrides in USD per 1M tokens
   --cost-rates-json JSON  Inline JSON model cost-rate overrides in USD per 1M tokens
   --path-tags-config PATH JSON path-prefix rules that add Langfuse tags/metadata
@@ -52,6 +57,11 @@ function parseServiceArgs(argv) {
     let batchSize = 10;
     let pollIntervalMs = 5_000;
     let postDelayMs = 0;
+    let modelsDevEnabled = false;
+    let modelsDevDisabled = false;
+    let modelsDevUrl;
+    let modelsDevCachePath;
+    let modelsDevTtlMs;
     let costRatesPath = process.env.CODING_AGENT_LANGFUSE_COST_RATES_PATH ??
         process.env.LANGFUSE_BACKFILL_COST_RATES_PATH;
     let costRatesJson = process.env.CODING_AGENT_LANGFUSE_COST_RATES_JSON ??
@@ -103,6 +113,23 @@ function parseServiceArgs(argv) {
         else if (arg === "--post-delay-ms") {
             postDelayMs = parseNonNegativeInt(arg, next());
         }
+        else if (arg === "--models-dev") {
+            modelsDevEnabled = true;
+            modelsDevDisabled = false;
+        }
+        else if (arg === "--no-models-dev") {
+            modelsDevEnabled = false;
+            modelsDevDisabled = true;
+        }
+        else if (arg === "--models-dev-url") {
+            modelsDevUrl = next();
+        }
+        else if (arg === "--models-dev-cache") {
+            modelsDevCachePath = next();
+        }
+        else if (arg === "--models-dev-ttl-ms") {
+            modelsDevTtlMs = parseNonNegativeInt(arg, next());
+        }
         else if (arg === "--cost-rates") {
             costRatesPath = next();
         }
@@ -151,6 +178,11 @@ function parseServiceArgs(argv) {
         batchSize,
         pollIntervalMs,
         postDelayMs,
+        modelsDevEnabled,
+        modelsDevDisabled,
+        modelsDevUrl,
+        modelsDevCachePath,
+        modelsDevTtlMs,
         costRatesPath,
         costRatesJson,
         pathTagsConfigPath,
@@ -161,96 +193,109 @@ function parseServiceArgs(argv) {
         pathEnv,
     };
 }
-function buildServicePlan(options) {
-    const command = buildFollowCommand(options);
-    if (options.platform === "darwin") {
-        const path = join(options.homeDir, "Library/LaunchAgents", `${options.name}.plist`);
-        return {
-            platform: options.platform,
-            action: options.action,
-            name: options.name,
-            path,
-            content: renderLaunchdPlist(options, command),
-            command,
-            postInstallCommands: options.start
-                ? [
-                    ["launchctl", "bootstrap", `gui/${process.getuid?.() ?? 501}`, path],
-                    ["launchctl", "kickstart", "-k", `gui/${process.getuid?.() ?? 501}/${options.name}`],
-                ]
-                : [],
-            uninstallCommands: [
-                ["launchctl", "bootout", `gui/${process.getuid?.() ?? 501}`, path],
-            ],
-            statusCommands: [
-                ["launchctl", "print", `gui/${process.getuid?.() ?? 501}/${options.name}`],
-            ],
-        };
-    }
-    if (options.platform === "linux") {
-        const path = join(options.homeDir, ".config/systemd/user", `${options.name}.service`);
-        return {
-            platform: options.platform,
-            action: options.action,
-            name: options.name,
-            path,
-            content: renderSystemdUnit(options, command),
-            command,
-            postInstallCommands: options.start
-                ? [
+const serviceCreators = {
+    darwin: {
+        platform: "darwin",
+        create(options, command) {
+            const path = join(options.homeDir, "Library/LaunchAgents", `${options.name}.plist`);
+            return {
+                platform: options.platform,
+                action: options.action,
+                name: options.name,
+                path,
+                content: renderLaunchdPlist(options, command),
+                command,
+                postInstallCommands: options.start
+                    ? [
+                        ["launchctl", "bootstrap", `gui/${process.getuid?.() ?? 501}`, path],
+                        ["launchctl", "kickstart", "-k", `gui/${process.getuid?.() ?? 501}/${options.name}`],
+                    ]
+                    : [],
+                uninstallCommands: [
+                    ["launchctl", "bootout", `gui/${process.getuid?.() ?? 501}`, path],
+                ],
+                statusCommands: [
+                    ["launchctl", "print", `gui/${process.getuid?.() ?? 501}/${options.name}`],
+                ],
+            };
+        },
+    },
+    linux: {
+        platform: "linux",
+        create(options, command) {
+            const path = join(options.homeDir, ".config/systemd/user", `${options.name}.service`);
+            return {
+                platform: options.platform,
+                action: options.action,
+                name: options.name,
+                path,
+                content: renderSystemdUnit(options, command),
+                command,
+                postInstallCommands: options.start
+                    ? [
+                        ["systemctl", "--user", "daemon-reload"],
+                        ["systemctl", "--user", "enable", "--now", `${options.name}.service`],
+                    ]
+                    : [["systemctl", "--user", "daemon-reload"]],
+                uninstallCommands: [
+                    ["systemctl", "--user", "disable", "--now", `${options.name}.service`],
                     ["systemctl", "--user", "daemon-reload"],
-                    ["systemctl", "--user", "enable", "--now", `${options.name}.service`],
-                ]
-                : [["systemctl", "--user", "daemon-reload"]],
-            uninstallCommands: [
-                ["systemctl", "--user", "disable", "--now", `${options.name}.service`],
-                ["systemctl", "--user", "daemon-reload"],
-            ],
-            statusCommands: [
-                ["systemctl", "--user", "status", `${options.name}.service`],
-            ],
-        };
-    }
-    const path = join(process.env.APPDATA ?? join(options.homeDir, "AppData/Roaming"), "coding-agent-langfuse", `${options.name}.ps1`);
-    const taskName = `CodingAgentLangfuse-${options.name}`;
-    return {
-        platform: options.platform,
-        action: options.action,
-        name: options.name,
-        path,
-        content: renderWindowsScript(command),
-        command,
-        postInstallCommands: options.start
-            ? [
-                [
-                    "powershell.exe",
-                    "-NoProfile",
-                    "-ExecutionPolicy",
-                    "Bypass",
-                    "-File",
-                    path,
-                    "-Install",
-                    "-TaskName",
-                    taskName,
                 ],
-            ]
-            : [],
-        uninstallCommands: [
-            [
-                "powershell.exe",
-                "-NoProfile",
-                "-Command",
-                `Unregister-ScheduledTask -TaskName ${powershellString(taskName)} -Confirm:$false -ErrorAction SilentlyContinue`,
-            ],
-        ],
-        statusCommands: [
-            [
-                "powershell.exe",
-                "-NoProfile",
-                "-Command",
-                `Get-ScheduledTask -TaskName ${powershellString(taskName)} | Format-List *`,
-            ],
-        ],
-    };
+                statusCommands: [
+                    ["systemctl", "--user", "status", `${options.name}.service`],
+                ],
+            };
+        },
+    },
+    win32: {
+        platform: "win32",
+        create(options, command) {
+            const path = join(process.env.APPDATA ?? join(options.homeDir, "AppData/Roaming"), "coding-agent-langfuse", `${options.name}.ps1`);
+            const taskName = `CodingAgentLangfuse-${options.name}`;
+            return {
+                platform: options.platform,
+                action: options.action,
+                name: options.name,
+                path,
+                content: renderWindowsScript(command),
+                command,
+                postInstallCommands: options.start
+                    ? [
+                        [
+                            "powershell.exe",
+                            "-NoProfile",
+                            "-ExecutionPolicy",
+                            "Bypass",
+                            "-File",
+                            path,
+                            "-Install",
+                            "-TaskName",
+                            taskName,
+                        ],
+                    ]
+                    : [],
+                uninstallCommands: [
+                    [
+                        "powershell.exe",
+                        "-NoProfile",
+                        "-Command",
+                        `Unregister-ScheduledTask -TaskName ${powershellString(taskName)} -Confirm:$false -ErrorAction SilentlyContinue`,
+                    ],
+                ],
+                statusCommands: [
+                    [
+                        "powershell.exe",
+                        "-NoProfile",
+                        "-Command",
+                        `Get-ScheduledTask -TaskName ${powershellString(taskName)} | Format-List *`,
+                    ],
+                ],
+            };
+        },
+    },
+};
+function buildServicePlan(options) {
+    return serviceCreators[options.platform].create(options, buildFollowCommand(options));
 }
 async function serviceMain(argv = process.argv.slice(2)) {
     const options = parseServiceArgs(argv);
@@ -302,6 +347,18 @@ function buildFollowCommand(options) {
     ];
     if (options.since)
         command.push("--since", options.since);
+    if (options.modelsDevEnabled)
+        command.push("--models-dev");
+    if (options.modelsDevDisabled)
+        command.push("--no-models-dev");
+    if (options.modelsDevUrl)
+        command.push("--models-dev-url", options.modelsDevUrl);
+    if (options.modelsDevCachePath) {
+        command.push("--models-dev-cache", options.modelsDevCachePath);
+    }
+    if (options.modelsDevTtlMs !== undefined) {
+        command.push("--models-dev-ttl-ms", String(options.modelsDevTtlMs));
+    }
     if (options.costRatesPath)
         command.push("--cost-rates", options.costRatesPath);
     if (options.costRatesJson)
@@ -368,15 +425,30 @@ function renderWindowsScript(command) {
     const commandArray = command.map(powershellString).join(", ");
     return `param(
   [switch]$Install,
+  [switch]$Run,
   [string]$TaskName = "CodingAgentLangfuse"
 )
 
 $Command = @(${commandArray})
-$Action = New-ScheduledTaskAction -Execute $Command[0] -Argument (($Command | Select-Object -Skip 1) -join " ")
-$Trigger = New-ScheduledTaskTrigger -AtLogOn
-$Settings = New-ScheduledTaskSettingsSet -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1)
+
+function Quote-PowerShellLiteral([string]$Value) {
+  return "'" + $Value.Replace("'", "''") + "'"
+}
+
+if ($Run) {
+  & $Command[0] @($Command | Select-Object -Skip 1)
+  exit $LASTEXITCODE
+}
 
 if ($Install) {
+  $ScriptPath = if ($PSCommandPath) { $PSCommandPath } else { $MyInvocation.MyCommand.Path }
+  $RunCommand = "& " + (Quote-PowerShellLiteral $ScriptPath) + " -Run"
+  $EncodedRunCommand = [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes($RunCommand))
+  $Action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand $EncodedRunCommand"
+  $Trigger = New-ScheduledTaskTrigger -AtLogOn
+  $Settings = New-ScheduledTaskSettingsSet -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1) -Hidden
+
+  Stop-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue
   Register-ScheduledTask -TaskName $TaskName -Action $Action -Trigger $Trigger -Settings $Settings -Force | Out-Null
   Start-ScheduledTask -TaskName $TaskName
 }
@@ -557,4 +629,4 @@ function escapeXml(value) {
         .replaceAll('"', """)
         .replaceAll("'", "'");
 }
-export { buildServicePlan, redactStatusOutput, parseServiceArgs, serviceMain, lifecycleEnv, };
+export { buildServicePlan, serviceCreators, redactStatusOutput, parseServiceArgs, serviceMain, lifecycleEnv, };

package/package.json

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