letmecode 0.1.3 → 0.1.5

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

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -5,10 +6,11 @@ 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";
 const RATE_CARD = {
-    "gpt-5.5": { input: 125, cachedInput: 12.5, output: 750 },
-    "gpt-5.4": { input: 62.5, cachedInput: 6.25, output: 375 },
-    "gpt-5.4-mini": { input: 18.75, cachedInput: 1.875, output: 113 }
+    "gpt-5.5": { input: 125, cacheRead: 12.5, cacheWrite: 125, cacheWrite5m: 125, cacheWrite1h: 125, output: 750 },
+    "gpt-5.4": { input: 62.5, cacheRead: 6.25, cacheWrite: 62.5, cacheWrite5m: 62.5, cacheWrite1h: 62.5, output: 375 },
+    "gpt-5.4-mini": { input: 18.75, cacheRead: 1.875, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 18.75, output: 113 }
 };
 export class CodexUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
@@ -17,6 +19,8 @@ export class CodexUsageProvider extends UsageProviderBase {
     }
     async getStats(_options = {}) {
         const sessionsRoot = path.join(this.root, ".codex", "sessions");
+        const knownModels = await readCodexModelMetadata(this.root);
+        const userIdHash = await readCodexUserIdHash(this.root, this.label);
         const byModel = new Map();
         const byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
@@ -30,7 +34,7 @@ export class CodexUsageProvider extends UsageProviderBase {
         };
         for await (const file of walkSessionFiles(sessionsRoot)) {
             parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes);
+            const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes, knownModels);
             parseTotals.linesRead += fileStats.linesRead;
             parseTotals.tokenEvents += fileStats.tokenEvents;
             parseTotals.malformedLines += fileStats.malformedLines;
@@ -43,7 +47,7 @@ export class CodexUsageProvider extends UsageProviderBase {
             .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
         const unknownPricedModels = modelUsage
             .map((row) => row.modelId)
-            .filter((modelId) => !RATE_CARD[modelId]);
+            .filter((modelId) => !RATE_CARD[modelId] && !isAssumedZeroRatedCodexModel(modelId, knownModels));
         if (unknownPricedModels.length > 0) {
             warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
         }
@@ -70,10 +74,132 @@ export class CodexUsageProvider extends UsageProviderBase {
             dayUsage,
             primaryLimitWindows,
             secondaryLimitWindows,
-            warnings
+            warnings,
+            analytics: {
+                agentName: normalizeAnalyticsAgentName(this.label),
+                userIdHash
+            }
         };
     }
 }
+async function readCodexModelMetadata(root) {
+    const modelsCachePath = path.join(root, ".codex", "models_cache.json");
+    let fileText;
+    try {
+        fileText = await fs.promises.readFile(modelsCachePath, "utf8");
+    }
+    catch {
+        return new Map();
+    }
+    let payload;
+    try {
+        payload = JSON.parse(fileText);
+    }
+    catch {
+        return new Map();
+    }
+    const models = asRecord(payload)?.models;
+    if (!Array.isArray(models)) {
+        return new Map();
+    }
+    const metadata = new Map();
+    for (const model of models) {
+        const record = asRecord(model);
+        const slug = typeof record?.slug === "string" ? record.slug : "";
+        if (!slug) {
+            continue;
+        }
+        metadata.set(slug, {
+            visibility: typeof record?.visibility === "string" ? record.visibility : ""
+        });
+    }
+    return metadata;
+}
+async function readCodexUserIdHash(root, agentName) {
+    const authPath = path.join(root, ".codex", "auth.json");
+    let fileText;
+    try {
+        fileText = await fs.promises.readFile(authPath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(fileText);
+    }
+    catch {
+        return null;
+    }
+    const tokens = asRecord(asRecord(payload)?.tokens);
+    const idToken = typeof tokens?.id_token === "string" ? tokens.id_token : "";
+    const accessToken = typeof tokens?.access_token === "string" ? tokens.access_token : "";
+    const identity = extractCodexIdentity(idToken) ?? extractCodexIdentity(accessToken);
+    if (!identity) {
+        return null;
+    }
+    return buildUserIdHash([
+        normalizeAnalyticsAgentName(agentName),
+        identity.email,
+        identity.orgId,
+        identity.orgName
+    ]);
+}
+function extractCodexIdentity(token) {
+    const payload = decodeJwtPayload(token);
+    if (!payload) {
+        return null;
+    }
+    const authRecord = asRecord(payload["https://api.openai.com/auth"]);
+    const profileRecord = asRecord(payload["https://api.openai.com/profile"]);
+    const organizations = Array.isArray(authRecord?.organizations) ? authRecord.organizations : [];
+    const defaultOrganizationRecord = organizations
+        .map((organization) => asRecord(organization))
+        .find((organization) => organization?.is_default === true) ??
+        organizations
+            .map((organization) => asRecord(organization))
+            .find(Boolean) ??
+        null;
+    const emailCandidates = [
+        typeof payload.email === "string" ? payload.email : "",
+        typeof profileRecord?.email === "string" ? profileRecord.email : ""
+    ];
+    const email = emailCandidates.find((candidate) => candidate) ?? "";
+    const orgId = typeof defaultOrganizationRecord?.id === "string" ? defaultOrganizationRecord.id : "";
+    const orgName = typeof defaultOrganizationRecord?.title === "string" ? defaultOrganizationRecord.title : "";
+    if (!email || !orgId || !orgName) {
+        return null;
+    }
+    return { email, orgId, orgName };
+}
+function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length < 2 || !parts[1]) {
+        return null;
+    }
+    try {
+        const payloadText = Buffer.from(normalizeBase64Url(parts[1]), "base64").toString("utf8");
+        const payload = JSON.parse(payloadText);
+        return asRecord(payload);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeBase64Url(value) {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const paddingLength = (4 - (normalized.length % 4)) % 4;
+    return normalized + "=".repeat(paddingLength);
+}
+function buildUserIdHash(parts) {
+    if (parts.some((part) => !part)) {
+        return null;
+    }
+    return createHash("md5").update(parts.join("-")).digest("hex");
+}
+function normalizeAnalyticsAgentName(label) {
+    return label.replace(/\s+/g, "");
+}
 function createEmptyRawUsage() {
     return {
         inputTokens: 0,
@@ -103,44 +229,56 @@ function subtractRawUsage(current, previous) {
     };
 }
 function creditsFor(modelId, usage) {
-    const rate = RATE_CARD[modelId];
+    const rate = resolveUsageRate(RATE_CARD, modelId);
     if (!rate) {
         return 0;
     }
-    return ((usage.inputTokens / 1000000) * rate.input +
-        (usage.cachedInputTokens / 1000000) * rate.cachedInput +
+    const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
+    const nonCachedInputTokens = Math.max(0, usage.inputTokens - cachedInputTokens);
+    return ((nonCachedInputTokens / 1000000) * rate.input +
+        (cachedInputTokens / 1000000) * rate.cacheRead +
         (usage.outputTokens / 1000000) * rate.output);
 }
 function rawUsageToTotals(usage) {
-    const inputTotalTokens = usage.inputTokens + usage.cachedInputTokens;
+    const cacheReadInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
+    const inputTokens = Math.max(0, usage.inputTokens - cacheReadInputTokens);
     return {
-        inputTotalTokens,
+        inputTokens,
         outputTokens: usage.outputTokens,
+        cacheReadInputTokens,
+        cacheWriteInputTokens: 0,
+        cacheWrite5mInputTokens: 0,
+        cacheWrite1hInputTokens: 0,
         reasoningOutputTokens: usage.reasoningOutputTokens,
-        totalTokens: inputTotalTokens + usage.outputTokens,
+        totalTokens: inputTokens + cacheReadInputTokens + usage.outputTokens,
         estimatedCredits: 0,
-        eventCount: 0,
-        tokenBreakdown: {
-            schema: "openai",
-            nonCachedInputTokens: usage.inputTokens,
-            cachedInputTokens: usage.cachedInputTokens,
-            outputTokens: usage.outputTokens
-        }
+        eventCount: 0
     };
 }
-function createUsageTotalsForModel(modelId, usage) {
+function createUsageTotalsForModel(modelId, usage, knownModels) {
     const resolvedModelId = modelId || "unknown";
     const deltaTotals = rawUsageToTotals(usage);
     deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage);
     deltaTotals.eventCount = 1;
+    if (!RATE_CARD[resolvedModelId] && !isAssumedZeroRatedCodexModel(resolvedModelId, knownModels)) {
+        deltaTotals.estimatedCreditsStatus = "unavailable";
+    }
     return deltaTotals;
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("openai");
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }
+function isHiddenCodexModel(modelId, knownModels) {
+    return knownModels.get(modelId)?.visibility === "hide";
+}
+function isAssumedZeroRatedCodexModel(modelId, knownModels) {
+    // Hidden internal Codex models do not have a public rate card entry. For dashboard
+    // rollups we treat them as zero-rated so they do not turn aggregate totals unknown.
+    return isHiddenCodexModel(modelId, knownModels);
+}
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.codex${path.sep}sessions${path.sep}`);
 }
@@ -162,7 +300,7 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function parseSessionFile(filePath, byModel, byDay, windows, planTypes) {
+async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, knownModels) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let currentModel = "unknown";
@@ -203,7 +341,7 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes) {
         const usage = lastUsage ? normalizeRawUsage(lastUsage) : previousTotal ? subtractRawUsage(totalUsage, previousTotal) : totalUsage;
         previousTotal = totalUsage;
         const resolvedModelId = currentModel || "unknown";
-        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage);
+        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage, knownModels);
         tokenEvents += 1;
         addModelUsage(byModel, resolvedModelId, deltaTotals);
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));

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

@@ -4,31 +4,34 @@ export class UsageProviderBase {
         this.label = label;
     }
 }
-export function createEmptyUsageTotals(schema = "openai") {
+export function createEmptyUsageTotals() {
     return {
-        inputTotalTokens: 0,
+        inputTokens: 0,
         outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheWriteInputTokens: 0,
+        cacheWrite5mInputTokens: 0,
+        cacheWrite1hInputTokens: 0,
         reasoningOutputTokens: 0,
         totalTokens: 0,
         estimatedCredits: 0,
-        eventCount: 0,
-        tokenBreakdown: createEmptyUsageTokenBreakdown(schema)
+        eventCount: 0
     };
 }
 export function cloneUsageTotals(totals) {
-    return {
-        ...totals,
-        tokenBreakdown: { ...totals.tokenBreakdown }
-    };
+    return { ...totals };
 }
 export function addUsageTotals(target, source) {
-    target.inputTotalTokens += source.inputTotalTokens;
+    target.inputTokens += source.inputTokens;
     target.outputTokens += source.outputTokens;
+    target.cacheReadInputTokens += source.cacheReadInputTokens;
+    target.cacheWriteInputTokens += source.cacheWriteInputTokens;
+    target.cacheWrite5mInputTokens += source.cacheWrite5mInputTokens;
+    target.cacheWrite1hInputTokens += source.cacheWrite1hInputTokens;
     target.reasoningOutputTokens += source.reasoningOutputTokens;
     target.totalTokens += source.totalTokens;
     target.estimatedCredits += source.estimatedCredits;
     target.eventCount += source.eventCount;
-    addUsageTokenBreakdown(target.tokenBreakdown, source.tokenBreakdown);
     if (source.cacheStatus === "unavailable") {
         target.cacheStatus = "unavailable";
     }
@@ -37,44 +40,9 @@ export function addUsageTotals(target, source) {
     }
 }
 export function sumUsageTotals(rows) {
-    const totals = createEmptyUsageTotals(rows[0]?.tokenBreakdown.schema ?? "openai");
+    const totals = createEmptyUsageTotals();
     for (const row of rows) {
         addUsageTotals(totals, row);
     }
     return totals;
 }
-function createEmptyUsageTokenBreakdown(schema) {
-    if (schema === "anthropic") {
-        return {
-            schema,
-            inputTokens: 0,
-            cacheWrite5mInputTokens: 0,
-            cacheWrite1hInputTokens: 0,
-            cacheReadInputTokens: 0,
-            outputTokens: 0
-        };
-    }
-    return {
-        schema,
-        nonCachedInputTokens: 0,
-        cachedInputTokens: 0,
-        outputTokens: 0
-    };
-}
-function addUsageTokenBreakdown(target, source) {
-    if (target.schema !== source.schema) {
-        throw new Error(`Cannot merge ${source.schema} usage totals into ${target.schema} totals.`);
-    }
-    target.outputTokens += source.outputTokens;
-    if (target.schema === "anthropic" && source.schema === "anthropic") {
-        target.inputTokens += source.inputTokens;
-        target.cacheWrite5mInputTokens += source.cacheWrite5mInputTokens;
-        target.cacheWrite1hInputTokens += source.cacheWrite1hInputTokens;
-        target.cacheReadInputTokens += source.cacheReadInputTokens;
-        return;
-    }
-    if (target.schema === "openai" && source.schema === "openai") {
-        target.nonCachedInputTokens += source.nonCachedInputTokens;
-        target.cachedInputTokens += source.cachedInputTokens;
-    }
-}

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

@@ -6,37 +6,33 @@ import readline from "node:readline";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 import { asRecord } from "./limits.js";
+import { resolveUsageRate } from "./pricing.js";
 const VSCODE_OTEL_SETTINGS = {
     "github.copilot.chat.otel.enabled": true,
     "github.copilot.chat.otel.exporterType": "file",
     "github.copilot.chat.otel.captureContent": false
 };
 const RATE_CARD = {
-    "gpt-5-mini": { input: 25, cachedInput: 2.5, output: 200 },
-    "gpt-5.3-codex": { input: 175, cachedInput: 17.5, output: 1400 },
-    "gpt-5.4": { input: 250, cachedInput: 25, output: 1500 },
-    "gpt-5.4-mini": { input: 75, cachedInput: 7.5, output: 450 },
-    "gpt-5.4-nano": { input: 20, cachedInput: 2, output: 125 },
-    "gpt-5.5": { input: 500, cachedInput: 50, output: 3000 },
-    "claude-haiku-4-5": { input: 100, cachedInput: 10, cacheWrite: 125, output: 500 },
-    "claude-sonnet-4-5": { input: 300, cachedInput: 30, cacheWrite: 375, output: 1500 },
-    "claude-sonnet-4-6": { input: 300, cachedInput: 30, cacheWrite: 375, output: 1500 },
-    "claude-opus-4-5": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
-    "claude-opus-4-6": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
-    "claude-opus-4-7": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
-    "claude-opus-4-8": { input: 500, cachedInput: 50, cacheWrite: 625, output: 2500 },
-    "claude-fable-5": { input: 1000, cachedInput: 100, cacheWrite: 1250, output: 5000 },
-    "gemini-2.5-pro": { input: 125, cachedInput: 12.5, output: 1000 },
-    "gemini-3-flash": { input: 50, cachedInput: 5, output: 300 },
-    "gemini-3.1-pro": { input: 200, cachedInput: 20, output: 1200 },
-    "gemini-3.5-flash": { input: 150, cachedInput: 15, output: 900 },
-    "mai-code-1-flash": { input: 75, cachedInput: 7.5, output: 450 },
-    "raptor-mini": { input: 25, cachedInput: 2.5, output: 200 }
-};
-const LONG_CONTEXT_RATE_CARD = {
-    "gpt-5.4": { thresholdInputTokens: 272000, input: 500, cachedInput: 50, output: 2250 },
-    "gpt-5.5": { thresholdInputTokens: 272000, input: 1000, cachedInput: 100, output: 4500 },
-    "gemini-3.1-pro": { thresholdInputTokens: 200000, input: 400, cachedInput: 40, output: 1800 }
+    "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-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 }
 };
 const NON_BILLABLE_MODEL_PREFIXES = ["copilot-nes", "copilot-suggestion"];
 export class CopilotUsageProvider extends UsageProviderBase {
@@ -226,20 +222,18 @@ function createUsageTotals(modelId, usage) {
     const cacheWriteInputTokens = hasCacheInfo ? Math.max(0, usage.cacheCreationInputTokens ?? 0) : 0;
     const uncachedInputTokens = hasCacheInfo
         ? Math.max(0, usage.inputTokens - cachedInputTokens - cacheWriteInputTokens)
-        : 0;
+        : usage.inputTokens;
     return {
-        inputTotalTokens: usage.inputTokens,
+        inputTokens: uncachedInputTokens,
         outputTokens: usage.outputTokens,
+        cacheReadInputTokens: cachedInputTokens,
+        cacheWriteInputTokens,
+        cacheWrite5mInputTokens: 0,
+        cacheWrite1hInputTokens: 0,
         reasoningOutputTokens: Math.min(usage.reasoningOutputTokens ?? 0, usage.outputTokens),
         totalTokens: usage.inputTokens + usage.outputTokens,
         estimatedCredits: creditsFor(modelId, usage),
         eventCount: 1,
-        tokenBreakdown: {
-            schema: "openai",
-            nonCachedInputTokens: uncachedInputTokens,
-            cachedInputTokens,
-            outputTokens: usage.outputTokens
-        },
         cacheStatus: hasCacheInfo ? "known" : "unavailable",
         estimatedCreditsStatus: hasKnownCreditPricing ? "known" : "unavailable"
     };
@@ -259,28 +253,19 @@ function creditsFor(modelId, usage) {
     const cacheWrite = Math.min(usage.cacheCreationInputTokens ?? 0, Math.max(0, usage.inputTokens - cacheRead));
     const regularInput = Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
     return ((regularInput / 1000000) * rate.input +
-        (cacheRead / 1000000) * rate.cachedInput +
-        (cacheWrite / 1000000) * (rate.cacheWrite ?? rate.input) +
+        (cacheRead / 1000000) * rate.cacheRead +
+        (cacheWrite / 1000000) * rate.cacheWrite +
         (usage.outputTokens / 1000000) * rate.output);
 }
 function rateForModel(modelId, inputTokens) {
-    const candidates = Object.keys(RATE_CARD).sort((left, right) => right.length - left.length);
-    const model = candidates.find((candidate) => modelId === candidate || modelId.startsWith(`${candidate}-`));
-    if (!model) {
-        return undefined;
-    }
-    const longContextRate = LONG_CONTEXT_RATE_CARD[model];
-    if (longContextRate && inputTokens > longContextRate.thresholdInputTokens) {
-        return longContextRate;
-    }
-    return RATE_CARD[model];
+    return resolveUsageRate(RATE_CARD, modelId, inputTokens, { prefixMatch: true });
 }
 function isNonBillableModel(modelId) {
     return NON_BILLABLE_MODEL_PREFIXES.some((prefix) => modelId === prefix || modelId.startsWith(`${prefix}-`));
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("openai");
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }

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

@@ -1,9 +1,22 @@
 import { ClaudeUsageProvider } from "./claude.js";
 import { CodexUsageProvider } from "./codex.js";
 import { CopilotUsageProvider } from "./copilot.js";
+import { AntigravityUsageProvider } from "./antigravity.js";
 export function createProviders() {
-    return [new CodexUsageProvider(), new ClaudeUsageProvider(), new CopilotUsageProvider()];
+    return [
+        new CodexUsageProvider(),
+        new ClaudeUsageProvider(),
+        new ClaudeUsageProvider({
+            id: "claude-vscode",
+            label: "Claude VSCode",
+            entrypoints: ["claude-vscode"],
+            usageCommandKind: "vscode"
+        }),
+        new CopilotUsageProvider(),
+        new AntigravityUsageProvider()
+    ];
 }
+export { AntigravityUsageProvider } from "./antigravity.js";
 export { ClaudeUsageProvider } from "./claude.js";
 export { CodexUsageProvider } from "./codex.js";
 export { CopilotUsageProvider, configureCopilotVsCodeLogging } from "./copilot.js";

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

@@ -93,7 +93,7 @@ function collapseNearbyWindows(rows) {
 function computeWindowTotals(events) {
     // Session files are not guaranteed to be parsed in timestamp order, so
     // saturation has to be applied after we sort the captured window events.
-    const totals = createEmptyUsageTotals(events[0]?.totals.tokenBreakdown.schema ?? "openai");
+    const totals = createEmptyUsageTotals();
     let sawBelowCap = false;
     let isExhausted = false;
     for (const event of [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs)) {

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

@@ -0,0 +1,18 @@
+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) {
+        return undefined;
+    }
+    const rate = rateCard[model];
+    if (!rate) {
+        return undefined;
+    }
+    if (rate.longContext && inputTokens > rate.longContext.thresholdTokens) {
+        return rate.longContext.rate;
+    }
+    return rate;
+}

package/ink-app/dist/reporting.js

@@ -0,0 +1,99 @@
+import { request } from "node:https";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const REPORTING_ENDPOINT = "https://devforth.io/admin/api/report_ussage_anonymous";
+const CREDIT_TO_DOLLARS = 0.01;
+let versionCache = null;
+export async function reportAnonymousUsage(statsList) {
+    const payload = await buildAnonymousUsagePayload(statsList);
+    if (payload.data.length === 0) {
+        return;
+    }
+    await postJson(REPORTING_ENDPOINT, payload);
+}
+export async function buildAnonymousUsageReports(statsList) {
+    const letmecodeVersion = await readLetmecodeVersion();
+    return statsList.flatMap((stats) => {
+        if (!stats.analytics?.userIdHash) {
+            return [];
+        }
+        return [...stats.primaryLimitWindows, ...stats.secondaryLimitWindows].map((window) => buildAnonymousUsageReport(stats, window, letmecodeVersion));
+    });
+}
+export async function buildAnonymousUsagePayload(statsList) {
+    return {
+        data: await buildAnonymousUsageReports(statsList)
+    };
+}
+function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
+    return {
+        agent: stats.analytics?.agentName ?? stats.providerLabel.replace(/\s+/g, ""),
+        userid_hash: stats.analytics?.userIdHash ?? "",
+        plan_id: window.planType,
+        window_duration_seconds: window.windowMinutes * 60,
+        window_start_utc_iso: window.startTimeUtcIso,
+        window_end_utc_iso: window.endTimeUtcIso,
+        used_percents: resolveReportedUsedPercents(window),
+        used_exhausted: window.maxUsedPercent >= 100,
+        value_dollars: roundDollars(window.totals.estimatedCredits * CREDIT_TO_DOLLARS),
+        letmecode_version: letmecodeVersion
+    };
+}
+function resolveReportedUsedPercents(window) {
+    if (window.minUsedPercent === window.maxUsedPercent) {
+        return clampPercent(window.maxUsedPercent);
+    }
+    return clampPercent(window.maxUsedPercent - window.minUsedPercent);
+}
+function clampPercent(value) {
+    return Math.max(0, Math.min(100, Math.round(value)));
+}
+function roundDollars(value) {
+    return Number(value.toFixed(6));
+}
+async function readLetmecodeVersion() {
+    if (versionCache) {
+        return versionCache;
+    }
+    versionCache = (async () => {
+        const currentFilePath = fileURLToPath(import.meta.url);
+        const packageJsonPath = path.resolve(path.dirname(currentFilePath), "..", "..", "package.json");
+        const fileText = await fs.readFile(packageJsonPath, "utf8");
+        const payload = JSON.parse(fileText);
+        return typeof payload.version === "string" && payload.version ? payload.version : "unknown";
+    })();
+    return versionCache;
+}
+async function postJson(url, body) {
+    await new Promise((resolve, reject) => {
+        const encodedBody = Buffer.from(JSON.stringify(body), "utf8");
+        const target = new URL(url);
+        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) => {
+            res.resume();
+            res.on("end", () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve();
+                    return;
+                }
+                reject(new Error(`Unexpected response status: ${res.statusCode ?? "unknown"}`));
+            });
+        });
+        req.on("error", reject);
+        req.setTimeout(5000, () => {
+            req.destroy(new Error("Anonymous usage reporting timed out"));
+        });
+        req.write(encodedBody);
+        req.end();
+    });
+}