letmecode 0.1.29 → 0.1.30

package/ink-app/dist/providers/antigravity/models.js

@@ -20,7 +20,19 @@ const MODEL_IDS = {
     "claude-opus-4-6-20251201": "claude-opus-4-6"
 };
 export function normalizeAntigravityModelId(modelId) {
-    return MODEL_IDS[modelId] ?? (modelId || "unknown");
+    const exactModelId = MODEL_IDS[modelId];
+    if (exactModelId) {
+        return exactModelId;
+    }
+    const currentGeminiModel = [
+        "gemini-3.8-flash",
+        "gemini-3.7-flash",
+        "gemini-3.6-flash",
+        "gemini-3.1-pro"
+    ].find((candidate) => modelId === candidate ||
+        modelId === `${candidate}-preview` ||
+        ["low", "medium", "high"].some((level) => modelId === `${candidate}-${level}`));
+    return currentGeminiModel ?? (modelId || "unknown");
 }
 export function antigravityModelScope(rawModelId) {
     const modelId = normalizeAntigravityModelId(rawModelId);

package/ink-app/dist/providers/antigravity/provider.js

@@ -1,68 +1,12 @@
 import { createHash } from "node:crypto";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "../contract.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "../daily.js";
-import { resolveUsageRate } from "../pricing.js";
+import { fetchModelPricing, modelCostCredits } from "../pricing.js";
 import { modelScopeLabel, modelScopeMatches, normalizeAntigravityModelId } from "./models.js";
 import { parseAntigravityQuotaEntries } from "./quota-parser.js";
 import { findAntigravityLocalServer } from "./rpc/discovery.js";
 import { extractQuotaGroups, fetchAntigravityUserStatus } from "./rpc/quota.js";
 import { collectUsageFromLocalRpc } from "./usage-parse.js";
-const RATE_CARD = {
-    "gemini-3.5-flash": {
-        input: 150,
-        cacheRead: 15,
-        cacheWrite: 150,
-        cacheWrite5m: 150,
-        cacheWrite1h: 150,
-        output: 900
-    },
-    "gemini-3.1-pro": {
-        input: 200,
-        cacheRead: 20,
-        cacheWrite: 200,
-        cacheWrite5m: 200,
-        cacheWrite1h: 200,
-        output: 1200,
-        longContext: {
-            thresholdTokens: 200000,
-            rate: {
-                input: 400,
-                cacheRead: 40,
-                cacheWrite: 400,
-                cacheWrite5m: 400,
-                cacheWrite1h: 400,
-                output: 1800
-            }
-        }
-    },
-    "gemini-3-flash": {
-        input: 50,
-        cacheRead: 5,
-        cacheWrite: 50,
-        cacheWrite5m: 50,
-        cacheWrite1h: 50,
-        output: 300
-    },
-    "claude-sonnet-4-6": {
-        input: 300,
-        cacheRead: 30,
-        cacheWrite: 375,
-        cacheWrite5m: 375,
-        cacheWrite1h: 600,
-        output: 1500
-    },
-    "claude-opus-4-6": {
-        input: 500,
-        cacheRead: 50,
-        cacheWrite: 625,
-        cacheWrite5m: 625,
-        cacheWrite1h: 1000,
-        output: 2500
-    }
-};
-const UNPRICED_MODELS = new Set([
-    "gpt-oss-120b"
-]);
 export class AntigravityUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super("antigravity", "Antigravity");
@@ -104,11 +48,18 @@ export class AntigravityUsageProvider extends UsageProviderBase {
         if (duplicateEvents > 0) {
             warnings.push(`Collapsed ${duplicateEvents} duplicate Antigravity usage response(s).`);
         }
+        let pricing = new Map();
+        try {
+            pricing = await fetchModelPricing(selectedRecords.map((record) => normalizeAntigravityModelId(record.modelId)), "antigravity");
+        }
+        catch {
+            warnings.push("Model pricing API is unavailable.");
+        }
         const byModel = new Map();
         const byDay = createDailyUsageAggregates();
         for (const record of selectedRecords) {
             const modelId = normalizeAntigravityModelId(record.modelId);
-            const totals = usageRecordToTotals(modelId, record);
+            const totals = usageRecordToTotals(modelId, record, pricing);
             addModelUsage(byModel, modelId, totals);
             addDailyUsage(byDay, record.timestamp, modelId, undefined, totals);
         }
@@ -120,12 +71,12 @@ export class AntigravityUsageProvider extends UsageProviderBase {
             .sort((left, right) => right.totals.estimatedCredits -
             left.totals.estimatedCredits);
         const unknownPricedModels = modelUsage
-            .filter((row) => !rateForModel(row.modelId, rowInputTokens(row)) && !UNPRICED_MODELS.has(row.modelId))
+            .filter((row) => row.totals.estimatedCreditsStatus === "unavailable")
             .map((row) => row.modelId);
         if (unknownPricedModels.length > 0) {
-            warnings.push(`No Antigravity estimated API-equivalent rate configured for: ${unknownPricedModels.join(", ")}.`);
+            warnings.push(`No complete Antigravity API-equivalent pricing returned for: ${unknownPricedModels.join(", ")}.`);
         }
-        const limitWindows = quotaSnapshot?.entries.map((quota) => buildAntigravityLimitWindow(quota, quotaSnapshot.planType, selectedRecords, quotaSnapshot.fetchedAt)) ?? [];
+        const limitWindows = quotaSnapshot?.entries.map((quota) => buildAntigravityLimitWindow(quota, quotaSnapshot.planType, selectedRecords, quotaSnapshot.fetchedAt, pricing)) ?? [];
         return {
             providerId: this.id,
             providerLabel: this.label,
@@ -177,7 +128,7 @@ async function collectQuotaFromConnection(connect) {
             : null
     };
 }
-function buildAntigravityLimitWindow(quota, planType, records, fetchedAt) {
+function buildAntigravityLimitWindow(quota, planType, records, fetchedAt, pricing) {
     const startAt = quota.resetAt - quota.windowMinutes * 60000;
     const byModel = new Map();
     const matchingTimestamps = [];
@@ -189,7 +140,7 @@ function buildAntigravityLimitWindow(quota, planType, records, fetchedAt) {
             continue;
         }
         matchingTimestamps.push(record.timestamp);
-        addModelUsage(byModel, modelId, usageRecordToTotals(modelId, record));
+        addModelUsage(byModel, modelId, usageRecordToTotals(modelId, record, pricing));
     }
     const modelUsage = [...byModel.entries()]
         .map(([modelId, totals]) => ({
@@ -250,7 +201,8 @@ function deduplicateRecords(records) {
 function recordTokenTotal(record) {
     return record.input + record.cacheRead + record.cacheWrite + record.output;
 }
-function usageRecordToTotals(modelId, record) {
+function usageRecordToTotals(modelId, record, pricing) {
+    const estimatedCredits = creditsFor(modelId, record, pricing);
     return {
         inputTokens: record.input,
         outputTokens: record.output,
@@ -263,7 +215,7 @@ function usageRecordToTotals(modelId, record) {
             record.cacheRead +
             record.cacheWrite +
             record.output,
-        estimatedCredits: creditsFor(modelId, record),
+        estimatedCredits: estimatedCredits ?? 0,
         eventCount: 1,
         // The local RPC reports cache reads but never cache writes, so a zero cache
         // write is genuinely unknown (not a confirmed zero) and is surfaced as "-".
@@ -271,26 +223,17 @@ function usageRecordToTotals(modelId, record) {
         // which case it is both billed (see creditsFor) and shown as known.
         cacheReadStatus: "known",
         cacheWriteStatus: record.cacheWrite > 0 ? "known" : "unavailable",
-        estimatedCreditsStatus: rateForModel(modelId, record.input)
-            ? "known"
-            : "unavailable"
+        estimatedCreditsStatus: estimatedCredits === undefined ? "unavailable" : "known"
     };
 }
-function creditsFor(modelId, record) {
-    const rate = rateForModel(modelId, record.input);
-    if (!rate) {
-        return 0;
-    }
-    return ((record.input / 1000000) * rate.input +
-        (record.cacheRead / 1000000) * rate.cacheRead +
-        (record.cacheWrite / 1000000) * rate.cacheWrite +
-        (record.output / 1000000) * rate.output);
-}
-function rateForModel(modelId, inputTokens) {
-    return resolveUsageRate(RATE_CARD, modelId, inputTokens);
-}
-function rowInputTokens(row) {
-    return row.totals.inputTokens + row.totals.cacheReadInputTokens + row.totals.cacheWriteInputTokens;
+function creditsFor(modelId, record, pricing) {
+    return modelCostCredits(pricing.get(modelId), {
+        inputTokens: record.input,
+        outputTokens: record.output,
+        cacheReadInputTokens: record.cacheRead,
+        cacheWrite5mInputTokens: record.cacheWrite,
+        cacheWrite1hInputTokens: 0
+    });
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const totals = byModel.get(modelId) ?? createEmptyUsageTotals();

package/ink-app/dist/providers/claude.js

@@ -8,28 +8,21 @@ import { promisify } from "node:util";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
 import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
-import { resolveUsageRate } from "./pricing.js";
-// Source: https://platform.claude.com/docs/en/about-claude/pricing
-// (checked 2026-09-05).
-const RATE_CARD = {
-    "claude-fable-5-1": { input: 10, cacheRead: 0.25, cacheWrite: 12.5, cacheWrite5m: 12.5, cacheWrite1h: 20, output: 50 },
-    "claude-fable-5": { input: 10, cacheRead: 1, cacheWrite: 12.5, cacheWrite5m: 12.5, cacheWrite1h: 20, output: 50 },
-    "claude-opus-5": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-8": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-7": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-6": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-5": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
-    "claude-opus-4-1": { input: 15, cacheRead: 1.5, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 30, output: 75 },
-    "claude-opus-4": { input: 15, cacheRead: 1.5, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 30, output: 75 },
-    "claude-sonnet-5": { input: 2, cacheRead: 0.2, cacheWrite: 2.5, cacheWrite5m: 2.5, cacheWrite1h: 4, output: 10 },
-    "claude-sonnet-4-6": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
-    "claude-sonnet-4-5": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
-    "claude-sonnet-4": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
-    "claude-haiku-4-5": { input: 1, cacheRead: 0.1, cacheWrite: 1.25, cacheWrite5m: 1.25, cacheWrite1h: 2, output: 5 },
-    "claude-haiku-3-5": { input: 0.8, cacheRead: 0.08, cacheWrite: 1, cacheWrite5m: 1, cacheWrite1h: 1.6, output: 4 }
-};
+import { fetchModelPricing, modelCostCredits } from "./pricing.js";
+/*
+Previous local prices in USD per 1M tokens, kept temporarily as requested:
+claude-fable-5-1 and claude-mythos-5-1 10 / 0.25 / 12.5 / 20 / 50
+claude-fable-5 and claude-mythos-5 10 / 1 / 12.5 / 20 / 50
+claude-opus-5, 4-8, 4-7, 4-6, 4-5 5 / 0.5 / 6.25 / 10 / 25
+claude-opus-4-1 and 4 15 / 1.5 / 18.75 / 30 / 75
+claude-sonnet-5 2 / 0.2 / 2.5 / 4 / 10
+claude-sonnet-4-6, 4-5, 4 3 / 0.3 / 3.75 / 6 / 15
+claude-haiku-4-5 1 / 0.1 / 1.25 / 2 / 5
+claude-haiku-3-5 0.8 / 0.08 / 1 / 1.6 / 4
+Columns: input / cache read / cache write 5m / cache write 1h / output.
+*/
 const execFileAsync = promisify(execFile);
-const USD_TO_CREDITS = 100;
+const EMPTY_MODEL_PRICING = new Map();
 const VSCODE_CLAUDE_EXTENSION_PREFIX = "anthropic.claude-code-";
 const CLAUDE_SESSION_WINDOW_MINUTES = 5 * 60;
 const CLAUDE_WEEK_WINDOW_MINUTES = 7 * 24 * 60;
@@ -115,7 +108,17 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         if (selectedEvents.length === 0 && parsedSessionFiles.length > 0) {
             traceClaude(options.traceLogger, "No assistant usage events were found in the parsed Claude session files.");
         }
+        let pricing = new Map();
+        try {
+            pricing = await fetchModelPricing(selectedEvents
+                .map((event) => event.modelId)
+                .filter((modelId) => !isInternalClaudeModel(modelId)), "claude_code");
+        }
+        catch {
+            warnings.push("Model pricing API is unavailable.");
+        }
         for (const event of selectedEvents) {
+            event.totals = usageToTotals(event.modelId, event.usage, event.timestampMs, pricing);
             addModelUsage(byModel, event.modelId, event.totals);
             const planType = typeof event.rateLimits?.plan_type === "string" ? event.rateLimits.plan_type : undefined;
             const safeEventTimeMs = Number.isFinite(event.timestampMs) ? event.timestampMs : 0;
@@ -136,10 +139,10 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             .map(([modelId, totals]) => ({ modelId, totals }))
             .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
         const unknownPricedModels = modelUsage
-            .map((row) => row.modelId)
-            .filter((modelId) => !resolveRate(modelId) && !isInternalClaudeModel(modelId));
+            .filter((row) => row.totals.estimatedCreditsStatus === "unavailable")
+            .map((row) => row.modelId);
         if (unknownPricedModels.length > 0) {
-            warnings.push(`No API-equivalent rate configured for: ${unknownPricedModels.join(", ")}.`);
+            warnings.push(`No complete API-equivalent pricing returned for: ${unknownPricedModels.join(", ")}.`);
         }
         if (parsedSessionFiles.length === 0) {
             warnings.push(`No Claude session files found under ${sessionsRoot}.`);
@@ -216,17 +219,10 @@ function normalizeUsage(value) {
         webSearchRequests: numberOrZero(serverToolUse?.web_search_requests)
     };
 }
-function resolveRate(modelId, timestampMs) {
-    return resolveUsageRate(RATE_CARD, modelId, 0, { prefixMatch: true, timestampMs });
-}
 function isInternalClaudeModel(modelId) {
     return modelId === "<synthetic>";
 }
-function creditsFor(modelId, usage, timestampMs) {
-    const rate = resolveRate(modelId, timestampMs);
-    if (!rate) {
-        return 0;
-    }
+function creditsFor(modelId, usage, pricing) {
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     // The US inference surcharge must match regardless of the casing the source
     // reports (e.g. "us", "US"), so compare case-insensitively.
@@ -234,22 +230,28 @@ function creditsFor(modelId, usage, timestampMs) {
     const speedMultiplier = usage.speed.trim().toLowerCase() === "fast" && isClaudeFastPricedModel(modelId)
         ? 2
         : 1;
-    const tokenCostUsd = (usage.inputTokens / 1000000) * rate.input +
-        (usage.cacheReadInputTokens / 1000000) * rate.cacheRead +
-        (cacheWriteBreakdown.cacheWrite5mInputTokens / 1000000) * rate.cacheWrite5m +
-        (cacheWriteBreakdown.cacheWrite1hInputTokens / 1000000) * rate.cacheWrite1h +
-        (usage.outputTokens / 1000000) * rate.output;
-    const webSearchCostUsd = usage.webSearchRequests * 0.01;
-    return (tokenCostUsd * speedMultiplier * inferenceMultiplier + webSearchCostUsd) * USD_TO_CREDITS;
+    const tokenCostCredits = modelCostCredits(pricing.get(modelId), {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadInputTokens: usage.cacheReadInputTokens,
+        cacheWrite5mInputTokens: cacheWriteBreakdown.cacheWrite5mInputTokens,
+        cacheWrite1hInputTokens: cacheWriteBreakdown.cacheWrite1hInputTokens
+    });
+    if (tokenCostCredits === undefined) {
+        return undefined;
+    }
+    return (tokenCostCredits * speedMultiplier * inferenceMultiplier +
+        usage.webSearchRequests);
 }
 function isClaudeFastPricedModel(modelId) {
     return ["claude-opus-5", "claude-opus-4-8"].some((candidate) => modelId === candidate || modelId.startsWith(`${candidate}-`));
 }
-function usageToTotals(modelId, usage, timestampMs) {
+function usageToTotals(modelId, usage, _timestampMs, pricing = EMPTY_MODEL_PRICING) {
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     const cacheWriteInputTokens = cacheWriteBreakdown.cacheWrite5mInputTokens +
         cacheWriteBreakdown.cacheWrite1hInputTokens;
-    const rateKnown = Boolean(resolveRate(modelId, timestampMs)) || isInternalClaudeModel(modelId);
+    const estimatedCredits = creditsFor(modelId, usage, pricing);
+    const rateKnown = estimatedCredits !== undefined || isInternalClaudeModel(modelId);
     return {
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
@@ -262,7 +264,7 @@ function usageToTotals(modelId, usage, timestampMs) {
             usage.cacheReadInputTokens +
             cacheWriteInputTokens +
             usage.outputTokens,
-        estimatedCredits: creditsFor(modelId, usage, timestampMs),
+        estimatedCredits: estimatedCredits ?? 0,
         eventCount: 1,
         estimatedCreditsStatus: rateKnown ? "known" : "unavailable"
     };

package/ink-app/dist/providers/codex.js

@@ -6,95 +6,7 @@ import readline from "node:readline";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
 import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
-import { resolveUsageRate } from "./pricing.js";
-// One credit equals $0.01 (see CODEX_CREDIT_COST_USD in index.tsx), so credits
-// equal USD * 100. Rate cards are expressed in the model's actual API price in
-// USD per 1M tokens and scaled to credits in creditsFor, matching the Claude
-// provider. These are the real OpenAI API prices, not the (4x cheaper) Codex
-// subscription credit prices.
-// Source: https://developers.openai.com/api/docs/pricing (checked 2026-09-05).
-// GPT-5.6 Sol's current promotional rate is guaranteed only through at least
-// 2026-11-21, so it must be rechecked after that date.
-const USD_TO_CREDITS = 100;
-const GPT_6_ASTRA_RATE = {
-    input: 10,
-    cacheRead: 1,
-    cacheWrite: 12.5,
-    cacheWrite5m: 12.5,
-    cacheWrite1h: 12.5,
-    output: 50,
-    longContext: {
-        thresholdTokens: 272000,
-        rate: { input: 20, cacheRead: 2, cacheWrite: 25, cacheWrite5m: 25, cacheWrite1h: 25, output: 75 }
-    }
-};
-const GPT_5_6_SOL_RATE = {
-    input: 4,
-    cacheRead: 0.4,
-    cacheWrite: 5,
-    cacheWrite5m: 5,
-    cacheWrite1h: 5,
-    output: 20,
-    longContext: {
-        thresholdTokens: 272000,
-        rate: { input: 8, cacheRead: 0.8, cacheWrite: 10, cacheWrite5m: 10, cacheWrite1h: 10, output: 30 }
-    }
-};
-const RATE_CARD = {
-    "gpt-6-astra": GPT_6_ASTRA_RATE,
-    "gpt-5.6-sol": GPT_5_6_SOL_RATE,
-    "gpt-5.6-terra": {
-        input: 2,
-        cacheRead: 0.2,
-        cacheWrite: 2.5,
-        cacheWrite5m: 2.5,
-        cacheWrite1h: 2.5,
-        output: 12,
-        longContext: {
-            thresholdTokens: 272000,
-            rate: { input: 4, cacheRead: 0.4, cacheWrite: 5, cacheWrite5m: 5, cacheWrite1h: 5, output: 18 }
-        }
-    },
-    "gpt-5.6-luna": {
-        input: 0.2,
-        cacheRead: 0.02,
-        cacheWrite: 0.25,
-        cacheWrite5m: 0.25,
-        cacheWrite1h: 0.25,
-        output: 1.2,
-        longContext: {
-            thresholdTokens: 272000,
-            rate: { input: 0.4, cacheRead: 0.04, cacheWrite: 0.5, cacheWrite5m: 0.5, cacheWrite1h: 0.5, output: 1.8 }
-        }
-    },
-    "gpt-5.5": {
-        input: 5,
-        cacheRead: 0.5,
-        cacheWrite: 0,
-        cacheWrite5m: 0,
-        cacheWrite1h: 0,
-        output: 30,
-        longContext: {
-            thresholdTokens: 272000,
-            rate: { input: 10, cacheRead: 1, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 45 }
-        }
-    },
-    "gpt-5.4": {
-        input: 2.5,
-        cacheRead: 0.25,
-        cacheWrite: 0,
-        cacheWrite5m: 0,
-        cacheWrite1h: 0,
-        output: 15,
-        longContext: {
-            thresholdTokens: 272000,
-            rate: { input: 5, cacheRead: 0.5, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 22.5 }
-        }
-    },
-    "gpt-5.4-mini": { input: 0.75, cacheRead: 0.075, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 4.5 },
-    "gpt-5.3-codex": { input: 1.75, cacheRead: 0.175, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 14 },
-    "gpt-5.2": { input: 1.75, cacheRead: 0.175, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 14 }
-};
+import { fetchModelPricing, modelCostCredits } from "./pricing.js";
 export class CodexUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super("codex", "Codex");
@@ -112,6 +24,7 @@ export class CodexUsageProvider extends UsageProviderBase {
         const byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
         const planTypes = new Set();
+        const events = [];
         const warnings = [];
         const parseTotals = {
             filesScanned: 0,
@@ -130,12 +43,35 @@ export class CodexUsageProvider extends UsageProviderBase {
                 }
                 seenSessionFiles.add(sessionFileId);
                 parseTotals.filesScanned += 1;
-                const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes, knownModels);
+                const fileStats = await parseSessionFile(file, events);
                 parseTotals.linesRead += fileStats.linesRead;
                 parseTotals.tokenEvents += fileStats.tokenEvents;
                 parseTotals.malformedLines += fileStats.malformedLines;
             }
         }
+        let pricing = new Map();
+        try {
+            pricing = await fetchModelPricing(events
+                .map((event) => pricingModelId(event.modelId))
+                .filter((modelId) => !isAssumedZeroRatedCodexModel(modelId, knownModels)), "codex");
+        }
+        catch {
+            warnings.push("Model pricing API is unavailable.");
+        }
+        for (const event of events) {
+            const deltaTotals = createUsageTotalsForModel(event.modelId, event.usage, knownModels, pricing, event.serviceTier);
+            deltaTotals.estimatedCredits += event.webSearchCalls;
+            if (!hasCountedRawUsage(event.usage) && event.webSearchCalls > 0) {
+                deltaTotals.estimatedCreditsStatus = "known";
+            }
+            const planType = typeof event.rateLimits?.plan_type === "string"
+                ? event.rateLimits.plan_type
+                : undefined;
+            const safeEventTimeMs = Number.isFinite(event.eventTimeMs) ? event.eventTimeMs : 0;
+            addModelUsage(byModel, event.modelId, deltaTotals);
+            addDailyUsage(byDay, event.eventTimeMs, event.modelId, planType, deltaTotals);
+            applyRateLimits(windows, event.rateLimits, safeEventTimeMs, event.modelId, deltaTotals, planTypes);
+        }
         if (parseTotals.malformedLines > 0) {
             warnings.push(`Skipped ${parseTotals.malformedLines} malformed JSONL line(s).`);
         }
@@ -144,10 +80,10 @@ export class CodexUsageProvider extends UsageProviderBase {
             .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
         const unknownPricedModels = modelUsage
             .filter((row) => row.totals.totalTokens > 0)
-            .map((row) => row.modelId)
-            .filter((modelId) => !rateForCodexModel(modelId) && !isAssumedZeroRatedCodexModel(modelId, knownModels));
+            .filter((row) => row.totals.estimatedCreditsStatus === "unavailable")
+            .map((row) => row.modelId);
         if (unknownPricedModels.length > 0) {
-            warnings.push(`No API-equivalent rate configured for: ${unknownPricedModels.join(", ")}.`);
+            warnings.push(`No complete API-equivalent pricing returned for: ${unknownPricedModels.join(", ")}.`);
         }
         if (parseTotals.filesScanned === 0) {
             warnings.push(`No Codex session files found under ${codexRoot}.`);
@@ -319,18 +255,18 @@ function normalizeRawUsage(value) {
         totalTokens: numberOrZero(usage.total_tokens)
     };
 }
-function creditsFor(modelId, usage, serviceTier) {
-    const rate = rateForCodexModel(modelId, usage.inputTokens);
-    if (!rate) {
-        return 0;
-    }
+function creditsFor(modelId, usage, pricing, serviceTier) {
     const { inputTokens, cacheReadInputTokens, cacheWriteInputTokens } = resolveCodexInputBreakdown(usage);
-    return (((inputTokens / 1000000) * rate.input +
-        (cacheReadInputTokens / 1000000) * rate.cacheRead +
-        (cacheWriteInputTokens / 1000000) * rate.cacheWrite +
-        (usage.outputTokens / 1000000) * rate.output) *
-        serviceTierPriceMultiplier(serviceTier) *
-        USD_TO_CREDITS);
+    const credits = modelCostCredits(pricing.get(pricingModelId(modelId)), {
+        inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadInputTokens,
+        cacheWrite5mInputTokens: cacheWriteInputTokens,
+        cacheWrite1hInputTokens: 0
+    });
+    return credits === undefined
+        ? undefined
+        : credits * serviceTierPriceMultiplier(serviceTier);
 }
 function serviceTierPriceMultiplier(serviceTier) {
     switch (serviceTier?.trim().toLowerCase()) {
@@ -346,15 +282,12 @@ function serviceTierPriceMultiplier(serviceTier) {
 function isSupportedServiceTier(serviceTier) {
     return ["default", "priority", "fast", "flex"].includes(serviceTier?.trim().toLowerCase() ?? "");
 }
-function rateForCodexModel(modelId, inputTokens = 0) {
-    // The unsuffixed API alias routes to Sol. Normalize only the exact alias so
-    // an unknown future gpt-5.6-* tier is not accidentally charged at Sol rates.
-    const pricedModelId = modelId === "gpt-5.6"
+function pricingModelId(modelId) {
+    return (modelId === "gpt-5.6"
         ? "gpt-5.6-sol"
         : modelId === "codex-auto-review"
             ? "gpt-5.4"
-            : modelId;
-    return resolveUsageRate(RATE_CARD, pricedModelId, inputTokens, { prefixMatch: true });
+            : modelId);
 }
 function rawUsageToTotals(usage) {
     const { inputTokens, cacheReadInputTokens, cacheWriteInputTokens } = resolveCodexInputBreakdown(usage);
@@ -381,12 +314,13 @@ function resolveCodexInputBreakdown(usage) {
         cacheWriteInputTokens
     };
 }
-function createUsageTotalsForModel(modelId, usage, knownModels, serviceTier) {
+function createUsageTotalsForModel(modelId, usage, knownModels, pricing, serviceTier) {
     const resolvedModelId = modelId || "unknown";
     const deltaTotals = rawUsageToTotals(usage);
-    deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage, serviceTier);
+    const estimatedCredits = creditsFor(resolvedModelId, usage, pricing, serviceTier);
+    deltaTotals.estimatedCredits = estimatedCredits ?? 0;
     deltaTotals.eventCount = 1;
-    if (!rateForCodexModel(resolvedModelId, usage.inputTokens) && !isAssumedZeroRatedCodexModel(resolvedModelId, knownModels)) {
+    if (estimatedCredits === undefined && !isAssumedZeroRatedCodexModel(resolvedModelId, knownModels)) {
         deltaTotals.estimatedCreditsStatus = "unavailable";
     }
     return deltaTotals;
@@ -427,7 +361,7 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, knownModels) {
+async function parseSessionFile(filePath, events) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let currentModel = "unknown";
@@ -442,7 +376,7 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, kn
     let pendingWebSearchCalls = 0;
     let lastSeenTimestampMs = 0;
     const recordUsage = (modelId, usage, eventTimeMs, rateLimits = null, serviceTier = currentServiceTier) => {
-        const webSearchCostCredits = pendingWebSearchCalls;
+        const webSearchCalls = pendingWebSearchCalls;
         pendingWebSearchCalls = 0;
         // Current-format-only policy: without the applied tier the exact cost is
         // unknowable. Silently ignore the event instead of guessing Standard or
@@ -450,24 +384,19 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, kn
         if (!isSupportedServiceTier(serviceTier)) {
             return;
         }
-        if (!hasCountedRawUsage(usage) && webSearchCostCredits === 0) {
+        if (!hasCountedRawUsage(usage) && webSearchCalls === 0) {
             return;
         }
         const resolvedModelId = modelId || "unknown";
-        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage, knownModels, serviceTier);
-        // OpenAI API web search is $10 / 1k calls: $0.01, or one dashboard
-        // credit, per completed call. Search-content tokens are already present in
-        // the model usage record and are priced normally above.
-        deltaTotals.estimatedCredits += webSearchCostCredits;
-        if (!hasCountedRawUsage(usage) && webSearchCostCredits > 0) {
-            deltaTotals.estimatedCreditsStatus = "known";
-        }
-        const planType = typeof rateLimits?.plan_type === "string" ? rateLimits.plan_type : undefined;
-        const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
         tokenEvents += 1;
-        addModelUsage(byModel, resolvedModelId, deltaTotals);
-        addDailyUsage(byDay, eventTimeMs, resolvedModelId, planType, deltaTotals);
-        applyRateLimits(windows, rateLimits, safeEventTimeMs, resolvedModelId, deltaTotals, planTypes);
+        events.push({
+            modelId: resolvedModelId,
+            usage,
+            eventTimeMs,
+            rateLimits,
+            serviceTier,
+            webSearchCalls
+        });
     };
     const flushPendingUsageRecord = () => {
         if (!pendingUsageRecord) {
@@ -527,6 +456,12 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, kn
         if (payloadObject.type === "event_msg") {
             const payload = asRecord(payloadObject.payload);
             if (payload?.type === "thread_settings_applied") {
+                // Compacted/background sessions can begin with a cumulative usage
+                // snapshot before their first model and tier settings. Flush it while
+                // the captured settings are still incomplete so the current-contract
+                // guard below ignores it instead of attributing it to "unknown" with
+                // settings that arrived later.
+                flushPendingUsageRecord();
                 const threadSettings = asRecord(payload.thread_settings);
                 if (typeof threadSettings?.model === "string" && threadSettings.model.trim()) {
                     currentModel = threadSettings.model;

package/ink-app/dist/providers/copilot/models.js

@@ -1,56 +1,35 @@
-import { resolveUsageRate } from "../pricing.js";
-/**
- * Copilot-specific estimated API-equivalent rate card (micro-credits per
- * million tokens). This is intentionally separate from the Codex and
- * Antigravity rate cards — Copilot bills the same model families at different
- * effective rates, so there is no single shared source of truth to reuse.
- */
-export const RATE_CARD = {
-    "gpt-5-mini": { input: 25, cacheRead: 2.5, cacheWrite: 25, cacheWrite5m: 25, cacheWrite1h: 25, output: 200 },
-    "gpt-5.3-codex": { input: 175, cacheRead: 17.5, cacheWrite: 175, cacheWrite5m: 175, cacheWrite1h: 175, output: 1400 },
-    "gpt-5.4": { input: 250, cacheRead: 25, cacheWrite: 250, cacheWrite5m: 250, cacheWrite1h: 250, output: 1500, longContext: { thresholdTokens: 272000, rate: { input: 500, cacheRead: 50, cacheWrite: 500, cacheWrite5m: 500, cacheWrite1h: 500, output: 2250 } } },
-    "gpt-5.4-mini": { input: 75, cacheRead: 7.5, cacheWrite: 75, cacheWrite5m: 75, cacheWrite1h: 75, output: 450 },
-    "gpt-5.4-nano": { input: 20, cacheRead: 2, cacheWrite: 20, cacheWrite5m: 20, cacheWrite1h: 20, output: 125 },
-    "gpt-5.5": { input: 500, cacheRead: 50, cacheWrite: 500, cacheWrite5m: 500, cacheWrite1h: 500, output: 3000, longContext: { thresholdTokens: 272000, rate: { input: 1000, cacheRead: 100, cacheWrite: 1000, cacheWrite5m: 1000, cacheWrite1h: 1000, output: 4500 } } },
-    "claude-haiku-4-5": { input: 100, cacheRead: 10, cacheWrite: 125, cacheWrite5m: 125, cacheWrite1h: 200, output: 500 },
-    "claude-sonnet-4-5": { input: 300, cacheRead: 30, cacheWrite: 375, cacheWrite5m: 375, cacheWrite1h: 600, output: 1500 },
-    "claude-sonnet-4-6": { input: 300, cacheRead: 30, cacheWrite: 375, cacheWrite5m: 375, cacheWrite1h: 600, output: 1500 },
-    "claude-opus-4-5": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
-    "claude-opus-4-6": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
-    "claude-opus-4-7": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
-    "claude-opus-4-8": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
-    "claude-opus-5": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
-    "claude-fable-5": { input: 1000, cacheRead: 100, cacheWrite: 1250, cacheWrite5m: 1250, cacheWrite1h: 2000, output: 5000 },
-    "gemini-2.5-pro": { input: 125, cacheRead: 12.5, cacheWrite: 125, cacheWrite5m: 125, cacheWrite1h: 125, output: 1000 },
-    "gemini-3-flash": { input: 50, cacheRead: 5, cacheWrite: 50, cacheWrite5m: 50, cacheWrite1h: 50, output: 300 },
-    "gemini-3.1-pro": { input: 200, cacheRead: 20, cacheWrite: 200, cacheWrite5m: 200, cacheWrite1h: 200, output: 1200, longContext: { thresholdTokens: 200000, rate: { input: 400, cacheRead: 40, cacheWrite: 400, cacheWrite5m: 400, cacheWrite1h: 400, output: 1800 } } },
-    "gemini-3.5-flash": { input: 150, cacheRead: 15, cacheWrite: 150, cacheWrite5m: 150, cacheWrite1h: 150, output: 900 },
-    "mai-code-1-flash": { input: 75, cacheRead: 7.5, cacheWrite: 75, cacheWrite5m: 75, cacheWrite1h: 75, output: 450 },
-    "raptor-mini": { input: 25, cacheRead: 2.5, cacheWrite: 25, cacheWrite5m: 25, cacheWrite1h: 25, output: 200 }
-};
-/**
- * Model id prefixes that Copilot does not bill (inline completions / next-edit
- * suggestions). These are zero-rated rather than "unknown" so they never turn
- * aggregate credit totals unknown.
- */
+/*
+Previous local prices in credits per 1M tokens, kept temporarily as requested:
+gpt-5-mini 25 / 2.5 / 0 / 200; gpt-5.3-codex 175 / 17.5 / 0 / 1400
+gpt-5.4 250 / 25 / 0 / 1500; gpt-5.4-mini 75 / 7.5 / 0 / 450
+gpt-5.4-nano 20 / 2 / 0 / 125; gpt-5.5 500 / 50 / 0 / 3000
+gpt-5.6-luna 20 / 2 / 25 / 120; gpt-5.6-sol 400 / 40 / 500 / 2000
+gpt-5.6-terra 200 / 20 / 250 / 1200; gpt-6-astra 1000 / 100 / 1250 / 5000
+claude-haiku-4-5 100 / 10 / 125 / 200 / 500
+claude-sonnet-4-5 and 4-6 300 / 30 / 375 / 600 / 1500
+claude-opus-4-5, 4-6, 4-7, 4-8, 5 500 / 50 / 625 / 1000 / 2500
+claude-opus-4-8-fast 1000 / 100 / 1250 / 2000 / 5000
+claude-fable-5 1000 / 100 / 1250 / 2000 / 5000
+claude-fable-5-1 1000 / 25 / 1250 / 2000 / 5000
+claude-sonnet-5 200 / 20 / 250 / 400 / 1000
+gemini-2.5-pro 125 / 12.5 / 0 / 1000; gemini-3-flash 50 / 5 / 0 / 300
+gemini-3.1-pro 200 / 20 / 0 / 1200; gemini-3.5-flash 150 / 15 / 0 / 900
+gemini-3.6-flash, 3.7-flash, 3.8-flash 75 / 7.5 / 0 / 375
+mai-code-1-flash 75 / 7.5 / 0 / 450; mai-code-1.1-flash 20 / 2 / 0 / 120
+grok-4.5 and 4.6 200 / 50 / 0 / 600
+kimi-k2.7-code 95 / 19 / 0 / 400; kimi-k3 300 / 30 / 0 / 1500
+raptor-mini 25 / 2.5 / 0 / 200
+Columns with four values: input / cache read / cache write / output.
+Columns with five values: input / cache read / cache write 5m / cache write 1h / output.
+*/
 export const NON_BILLABLE_MODEL_PREFIXES = [
     "copilot-nes",
     "copilot-suggestion",
     "copilot-suggestions"
 ];
-/**
- * Canonicalize a Copilot model id. The exporter already emits stable,
- * human-readable ids (including dated suffixes like `gpt-5.4-2026-03-01`), and
- * the dashboard surfaces those verbatim, so this only guards the empty case.
- * Prefix-based rate resolution (see {@link rateForCopilotModel}) handles dated
- * suffixes without collapsing the displayed id.
- */
 export function normalizeCopilotModelId(modelId) {
     return modelId || "unknown";
 }
-export function rateForCopilotModel(modelId, inputTokens) {
-    return resolveUsageRate(RATE_CARD, modelId, inputTokens, { prefixMatch: true });
-}
 export function isNonBillableCopilotModel(modelId) {
     return NON_BILLABLE_MODEL_PREFIXES.some((prefix) => modelId === prefix || modelId.startsWith(`${prefix}-`));
 }

package/ink-app/dist/providers/copilot/provider.js

@@ -6,6 +6,8 @@ import { discoverCopilotOtelFiles } from "./otel/discover.js";
 import { parseCopilotOtelFiles } from "./otel/parse.js";
 import { getCopilotUserInfo, subtractOneUtcCalendarMonth } from "./quota.js";
 import { aggregateCopilotUsage, filterCopilotUsageEvents } from "./usage/aggregate.js";
+import { isNonBillableCopilotModel } from "./models.js";
+import { fetchModelPricing } from "../pricing.js";
 // The token-metered bucket that maps to the "AI Credits" window.
 const AI_CREDITS_QUOTA_ID = "premium_interactions";
 export { configureCopilotVsCodeLogging, getCopilotCliOtelEnv };
@@ -48,11 +50,12 @@ export class CopilotUsageProvider extends UsageProviderBase {
                 linesRead: 0,
                 events: [],
                 aggregated: aggregateCopilotUsage([]),
+                pricing: new Map(),
                 warnings: ["Copilot OTEL usage is unavailable."]
             };
         warnings.push(...usage.warnings);
         const { windows, unknownLabels, windowWarnings } = quotaInfo
-            ? buildLimitWindows(quotaInfo, usage.events)
+            ? buildLimitWindows(quotaInfo, usage.events, usage.pricing)
             : { windows: [], unknownLabels: [], windowWarnings: [] };
         if (unknownLabels.length > 0) {
             warnings.push(`Copilot quota usage is unknown for: ${unknownLabels.join(", ")}.`);
@@ -83,8 +86,25 @@ export class CopilotUsageProvider extends UsageProviderBase {
     async loadUsage() {
         const discovery = await discoverCopilotOtelFiles({ root: this.root, env: this.env });
         const parsed = await parseCopilotOtelFiles(discovery.files);
-        const aggregated = aggregateCopilotUsage(parsed.events);
         const warnings = [...discovery.warnings, ...parsed.warnings];
+        let pricing = new Map();
+        try {
+            pricing = await fetchModelPricing(parsed.events
+                .map((event) => event.modelId)
+                .filter((modelId) => !isNonBillableCopilotModel(modelId)), "github_copilot");
+        }
+        catch {
+            warnings.push("Model pricing API is unavailable.");
+        }
+        const aggregated = aggregateCopilotUsage(parsed.events, pricing);
+        const unpricedModels = [
+            ...new Set(parsed.events
+                .map((event) => event.modelId)
+                .filter((modelId) => !isNonBillableCopilotModel(modelId) && !pricing.has(modelId)))
+        ];
+        if (unpricedModels.length > 0) {
+            warnings.push(`No Copilot API-equivalent pricing returned for: ${unpricedModels.join(", ")}.`);
+        }
         if (parsed.malformedLines > 0) {
             warnings.push(`Skipped ${parsed.malformedLines} malformed Copilot JSONL line(s).`);
         }
@@ -99,6 +119,7 @@ export class CopilotUsageProvider extends UsageProviderBase {
             linesRead: parsed.linesRead,
             events: parsed.events,
             aggregated,
+            pricing,
             warnings
         };
     }
@@ -120,7 +141,7 @@ async function describeMissingOtelFile(root) {
         ? `VS Code Copilot logging is enabled, but ${missing.path} has not been created yet. Reload VS Code and send a Copilot Chat request.`
         : undefined;
 }
-function buildLimitWindows(quotaInfo, events) {
+function buildLimitWindows(quotaInfo, events, pricing) {
     const planType = quotaInfo.plan ?? "unknown";
     const billing = deriveBillingWindow(quotaInfo.resetAt);
     const windows = [];
@@ -152,7 +173,7 @@ function buildLimitWindows(quotaInfo, events) {
         // local OTEL token usage that falls inside this billing window.
         if (isAiCredits && billing) {
             const windowEvents = filterCopilotUsageEvents(events, billing.startMs, billing.endMs);
-            const windowUsage = aggregateCopilotUsage(windowEvents);
+            const windowUsage = aggregateCopilotUsage(windowEvents, pricing);
             totals = windowUsage.summaryTotals;
             modelUsage = windowUsage.modelUsage;
             eventCount = windowUsage.tokenEvents;

package/ink-app/dist/providers/copilot/usage/aggregate.js

@@ -1,6 +1,7 @@
 import { addUsageTotals, sumUsageTotals } from "../../contract.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "../../daily.js";
-import { isNonBillableCopilotModel, normalizeCopilotModelId, rateForCopilotModel } from "../models.js";
+import { isNonBillableCopilotModel, normalizeCopilotModelId } from "../models.js";
+import { modelCostCredits } from "../../pricing.js";
 /**
  * Select events whose timestamp falls in the half-open interval
  * `[startTimeMs, endTimeMs)`. An event exactly at `endTimeMs` belongs to the
@@ -16,7 +17,7 @@ export function filterCopilotUsageEvents(events, startTimeMs, endTimeMs) {
  * reported input already INCLUDES cache-read tokens but NOT cache-write tokens.
  * Pure and deterministic: independent of input ordering.
  */
-export function aggregateCopilotUsage(events) {
+export function aggregateCopilotUsage(events, pricing = new Map()) {
     const byModel = new Map();
     const byDay = createDailyUsageAggregates();
     for (const event of events) {
@@ -35,15 +36,17 @@ export function aggregateCopilotUsage(events) {
         const output = event.outputTokens;
         const reasoning = Math.min(event.reasoningOutputTokens, output);
         const nonBillable = isNonBillableCopilotModel(modelId);
-        const rate = nonBillable ? undefined : rateForCopilotModel(modelId, event.inputTokens);
-        const creditsKnown = nonBillable || (hasCacheInfo && rate !== undefined);
+        const estimatedCredits = hasCacheInfo
+            ? modelCostCredits(pricing.get(modelId), {
+                inputTokens: uncachedInput,
+                outputTokens: output,
+                cacheReadInputTokens: cacheRead,
+                cacheWrite5mInputTokens: cacheWrite,
+                cacheWrite1hInputTokens: 0
+            })
+            : undefined;
+        const creditsKnown = nonBillable || estimatedCredits !== undefined;
         const estimatedCreditsStatus = creditsKnown ? "known" : "unavailable";
-        const estimatedCredits = rate !== undefined && hasCacheInfo
-            ? (uncachedInput / 1000000) * rate.input +
-                (cacheRead / 1000000) * rate.cacheRead +
-                (cacheWrite / 1000000) * rate.cacheWrite +
-                (output / 1000000) * rate.output
-            : 0;
         const totals = {
             inputTokens: uncachedInput,
             outputTokens: output,
@@ -53,7 +56,7 @@ export function aggregateCopilotUsage(events) {
             cacheWrite1hInputTokens: 0,
             reasoningOutputTokens: reasoning,
             totalTokens: uncachedInput + cacheRead + cacheWrite + output,
-            estimatedCredits,
+            estimatedCredits: nonBillable ? 0 : (estimatedCredits ?? 0),
             eventCount: 1,
             cacheReadStatus: event.cacheReadStatus,
             cacheWriteStatus: event.cacheWriteStatus,

package/ink-app/dist/providers/pricing.js

@@ -1,23 +1,123 @@
-export function resolveUsageRate(rateCard, modelId, inputTokens = 0, options = {}) {
-    const model = options.prefixMatch
-        ? Object.keys(rateCard)
-            .sort((left, right) => right.length - left.length)
-            .find((candidate) => modelId === candidate || modelId.startsWith(`${candidate}-`))
-        : modelId;
-    if (!model) {
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+const MODEL_PRICING_ENDPOINT = process.env.LETMECODE_MODEL_PRICING_ENDPOINT ??
+    "https://devforth.io/admin/adminapi/v1/get_model_pricing";
+const PRICE_CACHE_TTL_MS = 5 * 60000;
+const USD_TO_CREDITS = 100;
+const MODEL_SLUG_ALIASES = {
+    "claude-haiku-4-5": "claude-4-5-haiku-reasoning",
+    "claude-sonnet-4-5": "claude-4-5-sonnet-thinking",
+    "gemini-3-1-pro": "gemini-3-1-pro-preview"
+};
+const responseCache = new Map();
+let pricingTransport = postModelPricingRequest;
+export function configureModelPricingTransport(transport) {
+    pricingTransport = transport;
+    responseCache.clear();
+}
+export function modelPricingSlug(modelId) {
+    const slug = modelId
+        .trim()
+        .toLowerCase()
+        .replace(/[._\s]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/-(?:\d{8}|\d{4}-\d{2}-\d{2})$/, "");
+    return MODEL_SLUG_ALIASES[slug] ?? slug;
+}
+export async function fetchModelPricing(modelIds, source) {
+    const slugByModelId = new Map([...new Set(modelIds)]
+        .filter((modelId) => modelId !== "unknown" && modelId !== "<synthetic>")
+        .map((modelId) => [modelId, modelPricingSlug(modelId)]));
+    const slugs = [...new Set(slugByModelId.values())].sort();
+    if (slugs.length === 0) {
+        return new Map();
+    }
+    const request = {
+        slugs,
+        available_in: { main: [source], other: [] }
+    };
+    const response = await fetchCached(request);
+    const pricingBySlug = new Map(response.models.map((model) => [
+        model.slug,
+        {
+            input: model.input,
+            output: model.output,
+            inputCacheRead: model.input_cache_read,
+            inputCacheWrite5m: model.input_cache_w5m,
+            inputCacheWrite1h: model.input_cache_w1h
+        }
+    ]));
+    return new Map([...slugByModelId.entries()].flatMap(([modelId, slug]) => {
+        const pricing = pricingBySlug.get(slug);
+        return pricing ? [[modelId, pricing]] : [];
+    }));
+}
+export function modelCostCredits(pricing, usage) {
+    if (!pricing) {
         return undefined;
     }
-    const rate = rateCard[model];
-    if (!rate) {
+    if (usage.cacheWrite5mInputTokens > 0 && pricing.inputCacheWrite5m === null) {
         return undefined;
     }
-    if (rate.longContext && inputTokens > rate.longContext.thresholdTokens) {
-        return rate.longContext.rate;
+    if (usage.cacheWrite1hInputTokens > 0 && pricing.inputCacheWrite1h === null) {
+        return undefined;
     }
-    if (rate.introOffer &&
-        Number.isFinite(options.timestampMs) &&
-        options.timestampMs < rate.introOffer.effectiveUntilMs) {
-        return rate.introOffer.rate;
+    return ((usage.inputTokens / 1000000) * pricing.input +
+        (usage.cacheReadInputTokens / 1000000) * pricing.inputCacheRead +
+        (usage.cacheWrite5mInputTokens / 1000000) * (pricing.inputCacheWrite5m ?? 0) +
+        (usage.cacheWrite1hInputTokens / 1000000) * (pricing.inputCacheWrite1h ?? 0) +
+        (usage.outputTokens / 1000000) * pricing.output) * USD_TO_CREDITS;
+}
+async function fetchCached(request) {
+    const key = JSON.stringify(request);
+    const cached = responseCache.get(key);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.response;
+    }
+    const response = pricingTransport(request);
+    responseCache.set(key, {
+        expiresAt: Date.now() + PRICE_CACHE_TTL_MS,
+        response
+    });
+    try {
+        return await response;
     }
-    return rate;
+    catch (error) {
+        responseCache.delete(key);
+        throw error;
+    }
+}
+async function postModelPricingRequest(body) {
+    return new Promise((resolve, reject) => {
+        const encodedBody = Buffer.from(JSON.stringify(body), "utf8");
+        const target = new URL(MODEL_PRICING_ENDPOINT);
+        const request = target.protocol === "http:" ? httpRequest : httpsRequest;
+        const req = request({
+            method: "POST",
+            protocol: target.protocol,
+            hostname: target.hostname,
+            port: target.port,
+            path: `${target.pathname}${target.search}`,
+            headers: {
+                "content-type": "application/json",
+                "content-length": encodedBody.byteLength
+            }
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+            res.on("end", () => {
+                if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+                    reject(new Error(`Model pricing request failed with status ${res.statusCode ?? "unknown"}`));
+                    return;
+                }
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+            });
+        });
+        req.on("error", reject);
+        req.setTimeout(5000, () => {
+            req.destroy(new Error("Model pricing request timed out"));
+        });
+        req.write(encodedBody);
+        req.end();
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmecode",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "Terminal AI usage dashboard for Codex, Claude, Copilot, and Antigravity.",
   "author": "Devforth (https://devforth.io)",
   "license": "MIT",