letmecode 0.1.28 → 0.1.30

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/limits.js

@@ -88,6 +88,7 @@ export function buildWindowLists(windows) {
             lastSeenUtcIso: formatIsoFromMilliseconds(window.lastSeenMs),
             minUsedPercent: window.minUsedPercent,
             maxUsedPercent: window.maxUsedPercent,
+            measuredUsedPercent: usage.measuredUsedPercent,
             totals: usage.totals,
             modelUsage: usage.modelUsage,
             eventCount: 0
@@ -178,6 +179,10 @@ function collapseNearbyWindows(rows) {
             existing.lastSeenUtcIso > row.lastSeenUtcIso ? existing.lastSeenUtcIso : row.lastSeenUtcIso;
         existing.minUsedPercent = Math.min(existing.minUsedPercent, row.minUsedPercent);
         existing.maxUsedPercent = Math.max(existing.maxUsedPercent, row.maxUsedPercent);
+        existing.measuredUsedPercent =
+            existing.minUsedPercent === existing.maxUsedPercent
+                ? 0
+                : clampUsedPercent(existing.maxUsedPercent - existing.minUsedPercent);
         addUsageTotals(existing.totals, row.totals);
         existing.modelUsage = mergeModelUsageRows(existing.modelUsage, row.modelUsage);
         existing.eventCount = existing.totals.eventCount;
@@ -189,13 +194,22 @@ function computeWindowUsage(events) {
     // saturation has to be applied after we sort the captured window events.
     const totals = createEmptyUsageTotals();
     const byModel = new Map();
-    let sawBelowCap = false;
-    let isExhausted = false;
-    for (const event of [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs)) {
+    const sortedEvents = [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs);
+    const baselinePercent = clampUsedPercent(sortedEvents[0]?.usedPercent ?? 0);
+    // Each rate-limit snapshot is recorded after the usage event on the same
+    // line. The first event therefore has no matching "before" percentage, even
+    // when its post-event value rounds to zero. Keep its percentage only as the
+    // baseline and aggregate requests from the next snapshot onward.
+    const firstIncludedIndex = sortedEvents.length > 0 ? 1 : 0;
+    let highestIncludedPercent = baselinePercent;
+    let sawBelowCap = baselinePercent < 100;
+    let isExhausted = baselinePercent >= 100;
+    for (const [index, event] of sortedEvents.entries()) {
         sawBelowCap || (sawBelowCap = event.usedPercent < 100);
-        if (!isExhausted) {
+        if (index >= firstIncludedIndex && !isExhausted) {
             addUsageTotals(totals, event.totals);
             addWindowModelUsage(byModel, event.modelId, event.totals);
+            highestIncludedPercent = Math.max(highestIncludedPercent, clampUsedPercent(event.usedPercent));
             if (sawBelowCap && event.usedPercent >= 100) {
                 isExhausted = true;
             }
@@ -203,9 +217,32 @@ function computeWindowUsage(events) {
     }
     return {
         totals,
-        modelUsage: buildModelUsageRows(byModel)
+        modelUsage: buildModelUsageRows(byModel),
+        measuredUsedPercent: clampUsedPercent(highestIncludedPercent - baselinePercent)
     };
 }
+/**
+ * Return the provider percentage represented by a window's token totals.
+ * Older/injected rows without the explicit field retain the legacy derivation.
+ */
+export function resolveMeasuredUsedPercent(window) {
+    if (window.measuredUsedPercent === null) {
+        return null;
+    }
+    if (typeof window.measuredUsedPercent === "number" && Number.isFinite(window.measuredUsedPercent)) {
+        return clampUsedPercent(window.measuredUsedPercent);
+    }
+    if (window.minUsedPercent === window.maxUsedPercent) {
+        return clampUsedPercent(window.maxUsedPercent);
+    }
+    return clampUsedPercent(window.maxUsedPercent - window.minUsedPercent);
+}
+function clampUsedPercent(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(100, value));
+}
 function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, modelId, deltaTotals) {
     if (!window) {
         return;

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/ink-app/dist/reporting.js

@@ -2,6 +2,7 @@ import { request } from "node:https";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveMeasuredUsedPercent } from "./providers/limits.js";
 const REPORTING_ENDPOINT = "https://devforth.io/admin/api/report_ussage_anonymous";
 const CREDIT_TO_DOLLARS = 0.01;
 // Limit windows at or below this used-percent carry too little signal to be
@@ -99,13 +100,11 @@ function buildUsageRaw(modelUsage) {
     return usageRaw;
 }
 function resolveReportedUsedPercents(window) {
-    if (window.minUsedPercent === window.maxUsedPercent) {
-        return clampPercent(window.maxUsedPercent);
-    }
-    return clampPercent(window.maxUsedPercent - window.minUsedPercent);
+    return clampPercent(resolveMeasuredUsedPercent(window) ?? 0);
 }
 function shouldReportUsageWindow(window) {
-    return resolveReportedUsedPercents(window) > SKIP_REPORT_USED_PERCENTS;
+    return (window.totals.estimatedCreditsStatus !== "unavailable" &&
+        resolveReportedUsedPercents(window) > SKIP_REPORT_USED_PERCENTS);
 }
 function clampPercent(value) {
     if (!Number.isFinite(value)) {

package/package.json

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