letmecode 0.1.28 → 0.1.30

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

@@ -6,68 +6,25 @@ 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 gpt-5.* API prices, not the (4x cheaper) Codex
-// subscription credit prices.
-const USD_TO_CREDITS = 100;
-const GPT_5_6_SOL_RATE = {
-    input: 5,
-    cacheRead: 0.5,
-    cacheWrite: 6.25,
-    cacheWrite5m: 6.25,
-    cacheWrite1h: 6.25,
-    output: 30,
-    longContext: {
-        thresholdTokens: 272000,
-        rate: { input: 10, cacheRead: 1, cacheWrite: 12.5, cacheWrite5m: 12.5, cacheWrite1h: 12.5, output: 45 }
-    }
-};
-const RATE_CARD = {
-    "gpt-5.6-sol": GPT_5_6_SOL_RATE,
-    "gpt-5.6-terra": {
-        input: 2.5,
-        cacheRead: 0.25,
-        cacheWrite: 3.125,
-        cacheWrite5m: 3.125,
-        cacheWrite1h: 3.125,
-        output: 15,
-        longContext: {
-            thresholdTokens: 272000,
-            rate: { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 6.25, output: 22.5 }
-        }
-    },
-    "gpt-5.6-luna": {
-        input: 1,
-        cacheRead: 0.1,
-        cacheWrite: 1.25,
-        cacheWrite5m: 1.25,
-        cacheWrite1h: 1.25,
-        output: 6,
-        longContext: {
-            thresholdTokens: 272000,
-            rate: { input: 2, cacheRead: 0.2, cacheWrite: 2.5, cacheWrite5m: 2.5, cacheWrite1h: 2.5, output: 9 }
-        }
-    },
-    "gpt-5.5": { input: 5, cacheRead: 0.5, cacheWrite: 5, cacheWrite5m: 5, cacheWrite1h: 5, output: 30 },
-    "gpt-5.4": { input: 2.5, cacheRead: 0.25, cacheWrite: 2.5, cacheWrite5m: 2.5, cacheWrite1h: 2.5, output: 15 },
-    "gpt-5.4-mini": { input: 0.75, cacheRead: 0.075, cacheWrite: 0.75, cacheWrite5m: 0.75, cacheWrite1h: 0.75, output: 4.5 }
-};
+import { fetchModelPricing, modelCostCredits } from "./pricing.js";
 export class CodexUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super("codex", "Codex");
         this.root = path.resolve(options.root ?? os.homedir());
     }
     async getStats(_options = {}) {
-        const sessionsRoot = path.join(this.root, ".codex", "sessions");
+        const codexRoot = path.join(this.root, ".codex");
+        const sessionRoots = [
+            path.join(codexRoot, "sessions"),
+            path.join(codexRoot, "archived_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();
         const planTypes = new Set();
+        const events = [];
         const warnings = [];
         const parseTotals = {
             filesScanned: 0,
@@ -75,12 +32,45 @@ export class CodexUsageProvider extends UsageProviderBase {
             tokenEvents: 0,
             malformedLines: 0
         };
-        for await (const file of walkSessionFiles(sessionsRoot)) {
-            parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes, knownModels);
-            parseTotals.linesRead += fileStats.linesRead;
-            parseTotals.tokenEvents += fileStats.tokenEvents;
-            parseTotals.malformedLines += fileStats.malformedLines;
+        const seenSessionFiles = new Set();
+        for (const sessionRoot of sessionRoots) {
+            for await (const file of walkSessionFiles(sessionRoot)) {
+                // Archiving normally moves a rollout, but guard against a transient copy
+                // existing in both locations while Codex updates its session index.
+                const sessionFileId = path.basename(file);
+                if (seenSessionFiles.has(sessionFileId)) {
+                    continue;
+                }
+                seenSessionFiles.add(sessionFileId);
+                parseTotals.filesScanned += 1;
+                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).`);
@@ -89,13 +79,14 @@ export class CodexUsageProvider 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) => !rateForCodexModel(modelId) && !isAssumedZeroRatedCodexModel(modelId, knownModels));
+            .filter((row) => row.totals.totalTokens > 0)
+            .filter((row) => row.totals.estimatedCreditsStatus === "unavailable")
+            .map((row) => row.modelId);
         if (unknownPricedModels.length > 0) {
-            warnings.push(`No credit 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 ${sessionsRoot}.`);
+            warnings.push(`No Codex session files found under ${codexRoot}.`);
         }
         const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
         const dayUsage = buildDailyUsageRows(byDay);
@@ -110,8 +101,8 @@ export class CodexUsageProvider extends UsageProviderBase {
                 totals: summaryTotals,
                 distinctModels: modelUsage.map((row) => row.modelId),
                 distinctPlanTypes: [...planTypes].sort(),
-                rootLabel: "~/.codex/sessions",
-                rootPath: sessionsRoot
+                rootLabel: "~/.codex",
+                rootPath: codexRoot
             },
             modelUsage,
             dayUsage,
@@ -247,6 +238,7 @@ function createEmptyRawUsage() {
     return {
         inputTokens: 0,
         cachedInputTokens: 0,
+        cacheWriteInputTokens: 0,
         outputTokens: 0,
         reasoningOutputTokens: 0,
         totalTokens: 0
@@ -257,60 +249,78 @@ function normalizeRawUsage(value) {
     return {
         inputTokens: numberOrZero(usage.input_tokens),
         cachedInputTokens: numberOrZero(usage.cached_input_tokens),
+        cacheWriteInputTokens: numberOrZero(usage.cache_write_input_tokens),
         outputTokens: numberOrZero(usage.output_tokens),
         reasoningOutputTokens: numberOrZero(usage.reasoning_output_tokens),
         totalTokens: numberOrZero(usage.total_tokens)
     };
 }
-function subtractRawUsage(current, previous) {
-    return {
-        inputTokens: Math.max(0, current.inputTokens - previous.inputTokens),
-        cachedInputTokens: Math.max(0, current.cachedInputTokens - previous.cachedInputTokens),
-        outputTokens: Math.max(0, current.outputTokens - previous.outputTokens),
-        reasoningOutputTokens: Math.max(0, current.reasoningOutputTokens - previous.reasoningOutputTokens),
-        totalTokens: Math.max(0, current.totalTokens - previous.totalTokens)
-    };
+function creditsFor(modelId, usage, pricing, serviceTier) {
+    const { inputTokens, cacheReadInputTokens, cacheWriteInputTokens } = resolveCodexInputBreakdown(usage);
+    const credits = modelCostCredits(pricing.get(pricingModelId(modelId)), {
+        inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadInputTokens,
+        cacheWrite5mInputTokens: cacheWriteInputTokens,
+        cacheWrite1hInputTokens: 0
+    });
+    return credits === undefined
+        ? undefined
+        : credits * serviceTierPriceMultiplier(serviceTier);
 }
-function creditsFor(modelId, usage) {
-    const rate = rateForCodexModel(modelId, usage.inputTokens);
-    if (!rate) {
-        return 0;
+function serviceTierPriceMultiplier(serviceTier) {
+    switch (serviceTier?.trim().toLowerCase()) {
+        case "fast":
+        case "priority":
+            return 2;
+        case "flex":
+            return 0.5;
+        default:
+            return 1;
     }
-    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) *
-        USD_TO_CREDITS);
 }
-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" ? "gpt-5.6-sol" : modelId;
-    return resolveUsageRate(RATE_CARD, pricedModelId, inputTokens, { prefixMatch: true });
+function isSupportedServiceTier(serviceTier) {
+    return ["default", "priority", "fast", "flex"].includes(serviceTier?.trim().toLowerCase() ?? "");
+}
+function pricingModelId(modelId) {
+    return (modelId === "gpt-5.6"
+        ? "gpt-5.6-sol"
+        : modelId === "codex-auto-review"
+            ? "gpt-5.4"
+            : modelId);
 }
 function rawUsageToTotals(usage) {
-    const cacheReadInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
-    const inputTokens = Math.max(0, usage.inputTokens - cacheReadInputTokens);
+    const { inputTokens, cacheReadInputTokens, cacheWriteInputTokens } = resolveCodexInputBreakdown(usage);
     return {
         inputTokens,
         outputTokens: usage.outputTokens,
         cacheReadInputTokens,
-        cacheWriteInputTokens: 0,
-        cacheWrite5mInputTokens: 0,
+        cacheWriteInputTokens,
+        cacheWrite5mInputTokens: cacheWriteInputTokens,
         cacheWrite1hInputTokens: 0,
         reasoningOutputTokens: usage.reasoningOutputTokens,
-        totalTokens: inputTokens + cacheReadInputTokens + usage.outputTokens,
+        totalTokens: inputTokens + cacheReadInputTokens + cacheWriteInputTokens + usage.outputTokens,
         estimatedCredits: 0,
         eventCount: 0
     };
 }
-function createUsageTotalsForModel(modelId, usage, knownModels) {
+function resolveCodexInputBreakdown(usage) {
+    const cacheReadInputTokens = Math.min(Math.max(0, usage.cachedInputTokens), usage.inputTokens);
+    const inputAfterCacheRead = Math.max(0, usage.inputTokens - cacheReadInputTokens);
+    const cacheWriteInputTokens = Math.min(Math.max(0, usage.cacheWriteInputTokens), inputAfterCacheRead);
+    return {
+        inputTokens: Math.max(0, inputAfterCacheRead - cacheWriteInputTokens),
+        cacheReadInputTokens,
+        cacheWriteInputTokens
+    };
+}
+function createUsageTotalsForModel(modelId, usage, knownModels, pricing, serviceTier) {
     const resolvedModelId = modelId || "unknown";
     const deltaTotals = rawUsageToTotals(usage);
-    deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage);
+    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;
@@ -325,12 +335,13 @@ 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);
+    // Synthetic bookkeeping rows carry no billable model call. Other hidden
+    // models are not assumed free: Codex auto-review is mapped to GPT-5.4 above,
+    // and an unknown hidden model must make the estimate explicitly unavailable.
+    return modelId === "<synthetic>" && isHiddenCodexModel(modelId, knownModels);
 }
 function isSessionFile(filePath) {
-    return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.codex${path.sep}sessions${path.sep}`);
+    return filePath.endsWith(".jsonl");
 }
 async function* walkSessionFiles(directory) {
     let entries;
@@ -350,14 +361,50 @@ 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";
-    let previousTotal;
+    let currentServiceTier;
+    let pendingUsageRecord;
+    let firstSessionMetadataSeen = false;
+    let forkStartedAtMs = null;
+    let isOwnForkHistory = true;
     let linesRead = 0;
     let tokenEvents = 0;
     let malformedLines = 0;
+    let pendingWebSearchCalls = 0;
+    let lastSeenTimestampMs = 0;
+    const recordUsage = (modelId, usage, eventTimeMs, rateLimits = null, serviceTier = currentServiceTier) => {
+        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
+        // carrying compatibility warnings for legacy rollout formats.
+        if (!isSupportedServiceTier(serviceTier)) {
+            return;
+        }
+        if (!hasCountedRawUsage(usage) && webSearchCalls === 0) {
+            return;
+        }
+        const resolvedModelId = modelId || "unknown";
+        tokenEvents += 1;
+        events.push({
+            modelId: resolvedModelId,
+            usage,
+            eventTimeMs,
+            rateLimits,
+            serviceTier,
+            webSearchCalls
+        });
+    };
+    const flushPendingUsageRecord = () => {
+        if (!pendingUsageRecord) {
+            return;
+        }
+        recordUsage(pendingUsageRecord.modelId, pendingUsageRecord.usage, pendingUsageRecord.eventTimeMs, null, pendingUsageRecord.serviceTier);
+        pendingUsageRecord = undefined;
+    };
     for await (const line of lineReader) {
         linesRead += 1;
         if (!line.trim()) {
@@ -371,35 +418,117 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, kn
             malformedLines += 1;
             continue;
         }
+        const parsedTimestampMs = Date.parse(String(payloadObject.timestamp ?? ""));
+        if (Number.isFinite(parsedTimestampMs)) {
+            lastSeenTimestampMs = parsedTimestampMs;
+        }
+        if (payloadObject.type === "session_meta" && !firstSessionMetadataSeen) {
+            firstSessionMetadataSeen = true;
+            const payload = asRecord(payloadObject.payload);
+            const sessionStartedAtMs = parseSortableCodexIdTimestamp(payload?.id);
+            if (typeof payload?.forked_from_id === "string" && sessionStartedAtMs !== null) {
+                forkStartedAtMs = sessionStartedAtMs;
+                isOwnForkHistory = false;
+            }
+            continue;
+        }
         if (payloadObject.type === "turn_context") {
-            const payload = payloadObject.payload;
-            const collaborationMode = payload?.collaboration_mode;
-            const settings = collaborationMode?.settings;
+            const payload = asRecord(payloadObject.payload);
+            const turnStartedAtMs = parseSortableCodexIdTimestamp(payload?.turn_id);
+            if (forkStartedAtMs !== null && turnStartedAtMs !== null && turnStartedAtMs < forkStartedAtMs) {
+                continue;
+            }
+            if (!isOwnForkHistory) {
+                if (forkStartedAtMs !== null && turnStartedAtMs === null) {
+                    continue;
+                }
+                isOwnForkHistory = true;
+            }
+            flushPendingUsageRecord();
+            const collaborationMode = asRecord(payload?.collaboration_mode);
+            const settings = asRecord(collaborationMode?.settings);
             currentModel = String(payload?.model ?? settings?.model ?? currentModel);
             continue;
         }
+        // A fork inherits the latest thread settings from its parent history. Keep
+        // tracking those settings while skipping the inherited usage itself, so a
+        // child request is priced with the tier that was actually in force.
+        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;
+                }
+                if (typeof threadSettings?.service_tier === "string" && threadSettings.service_tier.trim()) {
+                    currentServiceTier = threadSettings.service_tier;
+                }
+                continue;
+            }
+        }
+        if (!isOwnForkHistory) {
+            continue;
+        }
+        if (payloadObject.type === "token_usage_record") {
+            flushPendingUsageRecord();
+            const payload = asRecord(payloadObject.payload);
+            const usage = normalizeRawUsage(payload?.usage);
+            if (hasCountedRawUsage(usage)) {
+                pendingUsageRecord = {
+                    modelId: currentModel || "unknown",
+                    usage,
+                    eventTimeMs: Date.parse(String(payloadObject.timestamp ?? "")),
+                    serviceTier: currentServiceTier
+                };
+            }
+            continue;
+        }
         if (payloadObject.type !== "event_msg") {
             continue;
         }
-        const payload = payloadObject.payload;
+        const payload = asRecord(payloadObject.payload);
+        if (payload?.type === "web_search_end") {
+            pendingWebSearchCalls += 1;
+            continue;
+        }
         if (payload?.type !== "token_count") {
             continue;
         }
-        const info = payload.info;
-        const totalUsage = normalizeRawUsage(info?.total_token_usage);
-        const lastUsage = info?.last_token_usage;
-        const usage = lastUsage ? normalizeRawUsage(lastUsage) : previousTotal ? subtractRawUsage(totalUsage, previousTotal) : totalUsage;
-        previousTotal = totalUsage;
-        const resolvedModelId = currentModel || "unknown";
-        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage, knownModels);
-        tokenEvents += 1;
-        addModelUsage(byModel, resolvedModelId, deltaTotals);
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
-        const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
         const rateLimits = asRecord(payload.rate_limits);
-        const planType = typeof rateLimits?.plan_type === "string" ? rateLimits.plan_type : undefined;
-        addDailyUsage(byDay, eventTimeMs, resolvedModelId, planType, deltaTotals);
-        applyRateLimits(windows, rateLimits, safeEventTimeMs, resolvedModelId, deltaTotals, planTypes);
+        if (pendingUsageRecord) {
+            const pending = pendingUsageRecord;
+            pendingUsageRecord = undefined;
+            recordUsage(pending.modelId, pending.usage, pending.eventTimeMs, rateLimits, pending.serviceTier);
+        }
+    }
+    flushPendingUsageRecord();
+    if (pendingWebSearchCalls > 0) {
+        recordUsage(currentModel, createEmptyRawUsage(), lastSeenTimestampMs);
     }
     return { linesRead, tokenEvents, malformedLines };
 }
+function hasCountedRawUsage(usage) {
+    return (usage.inputTokens > 0 ||
+        usage.cachedInputTokens > 0 ||
+        usage.cacheWriteInputTokens > 0 ||
+        usage.outputTokens > 0 ||
+        usage.reasoningOutputTokens > 0);
+}
+function parseSortableCodexIdTimestamp(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const timestampHex = value.replace(/-/g, "").slice(0, 12);
+    if (!/^[0-9a-f]{12}$/i.test(timestampHex)) {
+        return null;
+    }
+    const timestamp = Number.parseInt(timestampHex, 16);
+    return Number.isFinite(timestamp) ? timestamp : null;
+}

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;