@agent-finops/core 0.5.9 → 0.6.0

package/dist/localAgentLogs.js

@@ -53,7 +53,7 @@ function totalUsageTokens(usage) {
         (usage.cacheWrite1hTokens ?? 0);
 }
 /** Parse one Claude Code transcript (JSONL). Exported for tests. */
-export function parseClaudeCodeTranscript(content, filePath = "", sinceMs) {
+export function parseClaudeCodeTranscript(content, filePath = "", sinceMs, onDiagnostic) {
     const calls = [];
     const seen = new Set();
     const pendingPrompts = [];
@@ -63,6 +63,7 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs) {
     let latestActivityKey;
     let isSubagent = filePath.split(sep).includes("subagents");
     let parentSessionId;
+    let malformedLines = 0;
     for (const line of content.split("\n")) {
         if (!line.trim())
             continue;
@@ -71,6 +72,7 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs) {
             entry = JSON.parse(line);
         }
         catch {
+            malformedLines += 1;
             continue;
         }
         if (!isRecord(entry))
@@ -179,10 +181,13 @@ export function parseClaudeCodeTranscript(content, filePath = "", sinceMs) {
     for (const call of calls) {
         call.activity = activities.get(localActivityScopeKey(call.sessionId, call.workingDirectory, call.project));
     }
+    if (malformedLines > 0) {
+        onDiagnostic?.({ code: "malformed_jsonl", count: malformedLines });
+    }
     return calls;
 }
 /** Parse one Codex rollout file (JSONL event stream). Exported for tests. */
-export function parseCodexRollout(content, onEntry) {
+export function parseCodexRollout(content, onEntry, onDiagnostic) {
     let model;
     let rootCwd;
     const toolWorkdirs = new Map();
@@ -201,6 +206,7 @@ export function parseCodexRollout(content, onEntry) {
     let toolCallCount = 0;
     let isSubagent = false;
     let parentSessionId;
+    let malformedLines = 0;
     for (const line of content.split("\n")) {
         if (!line.trim())
             continue;
@@ -209,6 +215,7 @@ export function parseCodexRollout(content, onEntry) {
             entry = JSON.parse(line);
         }
         catch {
+            malformedLines += 1;
             continue;
         }
         if (!isRecord(entry))
@@ -300,14 +307,33 @@ export function parseCodexRollout(content, onEntry) {
     // safer than charging the parent cumulative counter again. Likewise, a
     // recognized boundary with no later total_token_usage is not a financial
     // call yet.
+    if (malformedLines > 0) {
+        onDiagnostic?.({ code: "malformed_jsonl", count: malformedLines });
+    }
     if (!lastTotal || isSubagent && !rootTaskStarted)
         return [];
-    const input = Math.max(0, (numberOf(lastTotal.input_tokens) ?? 0) -
-        (numberOf(inheritedUsageBaseline?.input_tokens) ?? 0));
-    const cached = Math.max(0, (numberOf(lastTotal.cached_input_tokens) ?? 0) -
+    const rawInput = numberOf(lastTotal.input_tokens);
+    const rawOutput = numberOf(lastTotal.output_tokens);
+    const rawCached = numberOf(lastTotal.cached_input_tokens);
+    const rawReportedTotal = numberOf(lastTotal.total_tokens);
+    const baselineInput = numberOf(inheritedUsageBaseline?.input_tokens);
+    const baselineOutput = numberOf(inheritedUsageBaseline?.output_tokens);
+    const baselineReportedTotal = numberOf(inheritedUsageBaseline?.total_tokens);
+    const currentComponentsComplete = rawInput !== undefined && rawOutput !== undefined && !((rawReportedTotal ?? 0) > 0 && rawInput === 0 && rawOutput === 0);
+    const baselineComponentsComplete = !inheritedUsageBaseline || (baselineInput !== undefined && baselineOutput !== undefined && !((baselineReportedTotal ?? 0) > 0 && baselineInput === 0 && baselineOutput === 0));
+    const usageSupport = currentComponentsComplete && baselineComponentsComplete
+        ? "complete"
+        : "unsupported_token_shape";
+    if (usageSupport === "unsupported_token_shape") {
+        onDiagnostic?.({ code: "unsupported_token_shape", count: 1 });
+    }
+    const input = Math.max(0, (rawInput ?? 0) - (baselineInput ?? 0));
+    const cached = Math.max(0, (rawCached ?? 0) -
         (numberOf(inheritedUsageBaseline?.cached_input_tokens) ?? 0));
-    const output = Math.max(0, (numberOf(lastTotal.output_tokens) ?? 0) -
-        (numberOf(inheritedUsageBaseline?.output_tokens) ?? 0));
+    const output = Math.max(0, (rawOutput ?? 0) - (baselineOutput ?? 0));
+    const reportedTotalTokens = rawReportedTotal === undefined
+        ? undefined
+        : Math.max(0, rawReportedTotal - (baselineReportedTotal ?? 0));
     const latestTurnUsage = lastTurn
         ? codexTurnUsage(lastTurn)
         : undefined;
@@ -333,6 +359,8 @@ export function parseCodexRollout(content, onEntry) {
             activity,
             latestTurnUsage,
             usageScope: "session_cumulative",
+            usageSupport,
+            ...(reportedTotalTokens !== undefined ? { reportedTotalTokens } : {}),
             usage: {
                 // Codex input_tokens INCLUDES cached tokens; split them out.
                 inputTokens: Math.max(0, input - cached),
@@ -417,24 +445,51 @@ export async function loadLocalAgentUsage(options = {}) {
     let filesParsed = 0;
     const since = options.sinceIso ? Date.parse(options.sinceIso) : undefined;
     const sinceMs = typeof since === "number" && Number.isFinite(since) ? since : undefined;
-    for (const file of await listJsonlFiles(claudeDir)) {
-        const content = await readFile(file, "utf8").catch(() => "");
+    const diagnostics = [];
+    const sourceScans = [
+        emptySourceScan("claude-code"),
+        emptySourceScan("codex")
+    ];
+    const claudeScan = sourceScans[0];
+    const codexScan = sourceScans[1];
+    for (const file of await listJsonlFiles(claudeDir, claudeScan, diagnostics)) {
+        let content;
+        try {
+            content = await readFile(file, "utf8");
+        }
+        catch (error) {
+            recordUnreadableFile("claude-code", claudeScan, diagnostics, error);
+            continue;
+        }
         if (!content)
             continue;
         filesParsed += 1;
-        calls.push(...parseClaudeCodeTranscript(content, file, sinceMs));
+        claudeScan.filesParsed += 1;
+        calls.push(...parseClaudeCodeTranscript(content, file, sinceMs, (diagnostic) => {
+            recordParseDiagnostic("claude-code", claudeScan, diagnostics, diagnostic);
+        }));
     }
-    for (const file of await listJsonlFiles(codexDir)) {
+    for (const file of await listJsonlFiles(codexDir, codexScan, diagnostics)) {
         if (!basename(file).startsWith("rollout-"))
             continue;
-        const content = await readFile(file, "utf8").catch(() => "");
+        let content;
+        try {
+            content = await readFile(file, "utf8");
+        }
+        catch (error) {
+            recordUnreadableFile("codex", codexScan, diagnostics, error);
+            continue;
+        }
         if (!content)
             continue;
         filesParsed += 1;
+        codexScan.filesParsed += 1;
         const collector = codexInvocationFiles
             ? createCodexInvocationCollector(sinceMs)
             : undefined;
-        calls.push(...parseCodexRollout(content, collector?.consume));
+        calls.push(...parseCodexRollout(content, collector?.consume, (diagnostic) => {
+            recordParseDiagnostic("codex", codexScan, diagnostics, diagnostic);
+        }));
         if (collector)
             codexInvocationFiles.push(collector.finish());
     }
@@ -447,6 +502,8 @@ export async function loadLocalAgentUsage(options = {}) {
         calls: filtered,
         filesParsed,
         agentsDetected: [...new Set(filtered.map((call) => call.agent))],
+        sourceScans,
+        diagnostics,
         ...(codexInvocationFiles ? { codexInvocationFiles } : {})
     };
 }
@@ -468,8 +525,9 @@ export function aggregateCalls(calls) {
             cacheWrite5mTokens: sum(groupCalls, (c) => c.usage.cacheWrite5mTokens ?? 0),
             cacheWrite1hTokens: sum(groupCalls, (c) => c.usage.cacheWrite1hTokens ?? 0)
         };
-        const amountUsd = estimateTokenCostUsd(model, usage);
-        const priced = typeof amountUsd === "number";
+        const usageSupported = groupCalls.every((call) => call.usageSupport !== "unsupported_token_shape");
+        const amountUsd = usageSupported ? estimateTokenCostUsd(model, usage) : undefined;
+        const priced = usageSupported && typeof amountUsd === "number";
         records.push({
             id: slug(["local", agent, day, model, project].join("-")),
             timestamp: new Date(`${day}T00:00:00Z`).toISOString(),
@@ -498,25 +556,131 @@ export function aggregateCalls(calls) {
     }
     return records.sort((left, right) => left.id.localeCompare(right.id));
 }
-async function listJsonlFiles(root) {
-    const exists = await stat(root).then((s) => s.isDirectory()).catch(() => false);
-    if (!exists)
+async function listJsonlFiles(root, scan, diagnostics) {
+    let rootStat;
+    try {
+        rootStat = await stat(root);
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT")) {
+            scan.directoryStatus = "missing";
+            diagnostics.push({
+                agent: scan.agent,
+                code: "directory_missing",
+                severity: "info",
+                message: `${agentLabel(scan.agent)} transcript directory was not found.`,
+                count: 1
+            });
+        }
+        else {
+            scan.directoryStatus = "unreadable";
+            diagnostics.push({
+                agent: scan.agent,
+                code: "directory_unreadable",
+                severity: "error",
+                message: `${agentLabel(scan.agent)} transcript directory could not be read${errorCodeSuffix(error)}.`,
+                count: 1
+            });
+        }
         return [];
+    }
+    if (!rootStat.isDirectory()) {
+        scan.directoryStatus = "unreadable";
+        diagnostics.push({
+            agent: scan.agent,
+            code: "directory_unreadable",
+            severity: "error",
+            message: `${agentLabel(scan.agent)} transcript path is not a readable directory.`,
+            count: 1
+        });
+        return [];
+    }
+    scan.directoryStatus = "readable";
     const out = [];
     const queue = [root];
     while (queue.length > 0) {
         const dir = queue.pop();
-        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            scan.directoryStatus = "unreadable";
+            diagnostics.push({
+                agent: scan.agent,
+                code: "directory_unreadable",
+                severity: "error",
+                message: `${agentLabel(scan.agent)} transcript directory could not be read${errorCodeSuffix(error)}.`,
+                count: 1
+            });
+            continue;
+        }
         for (const entry of entries) {
             const path = join(dir, entry.name);
             if (entry.isDirectory())
                 queue.push(path);
-            else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
                 out.push(path);
+                scan.filesDiscovered += 1;
+            }
         }
     }
     return out;
 }
+function emptySourceScan(agent) {
+    return {
+        agent,
+        directoryStatus: "readable",
+        filesDiscovered: 0,
+        filesParsed: 0,
+        malformedLines: 0,
+        unreadableFiles: 0,
+        unsupportedUsageSnapshots: 0
+    };
+}
+function recordUnreadableFile(agent, scan, diagnostics, error) {
+    scan.unreadableFiles += 1;
+    diagnostics.push({
+        agent,
+        code: "file_unreadable",
+        severity: "error",
+        message: `${agentLabel(agent)} transcript file could not be read${errorCodeSuffix(error)}.`,
+        count: 1
+    });
+}
+function recordParseDiagnostic(agent, scan, diagnostics, diagnostic) {
+    if (diagnostic.code === "malformed_jsonl") {
+        scan.malformedLines += diagnostic.count;
+        diagnostics.push({
+            agent,
+            code: diagnostic.code,
+            severity: "warning",
+            message: `${diagnostic.count} malformed JSONL line(s) were skipped in ${agentLabel(agent)} transcripts.`,
+            count: diagnostic.count
+        });
+        return;
+    }
+    scan.unsupportedUsageSnapshots += diagnostic.count;
+    diagnostics.push({
+        agent,
+        code: diagnostic.code,
+        severity: "warning",
+        message: `${diagnostic.count} ${agentLabel(agent)} token snapshot(s) lacked the input/output components required for pricing.`,
+        count: diagnostic.count
+    });
+}
+function agentLabel(agent) {
+    return agent === "claude-code" ? "Claude Code" : "Codex";
+}
+function errorCodeSuffix(error) {
+    const code = error instanceof Error
+        ? error.code
+        : undefined;
+    return code && /^[A-Z0-9_]+$/.test(code) ? ` (${code})` : "";
+}
+function isNodeError(error, code) {
+    return error instanceof Error && error.code === code;
+}
 function projectFromCwd(cwd) {
     if (!cwd)
         return undefined;

package/dist/modelPricing.js

@@ -52,7 +52,6 @@ const pricingRules = [
     // Open-weight models with NO canonical price (llama, qwen, mistral, glm):
     // hosting rates vary several-fold by provider, so we deliberately return
     // undefined -> costConfidence "missing" instead of inventing a number.
-    { match: /codex/i, inputPerM: 1.25, outputPerM: 10, cacheReadPerM: 0.125 }
 ];
 export function findPricingRule(model) {
     return pricingRules.find((rule) => rule.match.test(model));

package/dist/providerConnectors.d.ts

@@ -8,6 +8,7 @@ type ProviderResponse = {
         get: (name: string) => string | null;
     };
     json: () => Promise<unknown>;
+    text?: () => Promise<string>;
 };
 export type ProviderQaPagination = {
     label: string;
@@ -73,9 +74,9 @@ export type CreateProviderConnectionInput = {
     sourceId?: string;
     authReference: string;
     verifiedRecordCount: number;
-    totalUsd: number;
+    totalUsd: number | null;
     fetchedAt?: Date;
-    /** Record-derived completeness; the source's verification label mirrors it. */
+    /** Record-derived completeness; this controls financial evidence, not connector validation. */
     completeness?: ProviderConnectorResult["completeness"];
 };
 export type TokenResolver = (reference: string) => string;