letmecode 0.1.30 → 0.1.32

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

@@ -19,7 +19,12 @@ export function selectLatestActiveLimitWindows(windows, nowMs = Date.now()) {
             continue;
         }
         const startMs = Date.parse(window.startTimeUtcIso);
-        const groupKey = JSON.stringify([window.planType, window.windowMinutes]);
+        // `limitId` is part of the key because a plan can run several limits of the
+        // same duration side by side: Claude meters an all-models week and a
+        // model-family week that share a plan, a length and a reset instant. Keyed
+        // on plan and duration alone they collapse into one group and the family
+        // window loses the tie, so it never counts as active.
+        const groupKey = JSON.stringify([window.planType, window.limitId, window.windowMinutes]);
         const current = latestByPlanAndWindow.get(groupKey);
         if (!current || startMs > current.startMs) {
             latestByPlanAndWindow.set(groupKey, { window, startMs });

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

@@ -44,7 +44,17 @@ export async function fetchModelPricing(modelIds, source) {
             output: model.output,
             inputCacheRead: model.input_cache_read,
             inputCacheWrite5m: model.input_cache_w5m,
-            inputCacheWrite1h: model.input_cache_w1h
+            inputCacheWrite1h: model.input_cache_w1h,
+            longContext: model.long_context
+                ? {
+                    inputTokensThreshold: model.long_context.input_tokens_threshold,
+                    input: model.long_context.input,
+                    output: model.long_context.output,
+                    inputCacheRead: model.long_context.input_cache_read,
+                    inputCacheWrite5m: model.long_context.input_cache_w5m,
+                    inputCacheWrite1h: model.long_context.input_cache_w1h
+                }
+                : null
         }
     ]));
     return new Map([...slugByModelId.entries()].flatMap(([modelId, slug]) => {
@@ -56,17 +66,24 @@ export function modelCostCredits(pricing, usage) {
     if (!pricing) {
         return undefined;
     }
-    if (usage.cacheWrite5mInputTokens > 0 && pricing.inputCacheWrite5m === null) {
+    const totalInputTokens = usage.inputTokens +
+        usage.cacheReadInputTokens +
+        usage.cacheWrite5mInputTokens +
+        usage.cacheWrite1hInputTokens;
+    const rates = pricing.longContext && totalInputTokens > pricing.longContext.inputTokensThreshold
+        ? pricing.longContext
+        : pricing;
+    if (usage.cacheWrite5mInputTokens > 0 && rates.inputCacheWrite5m === null) {
         return undefined;
     }
-    if (usage.cacheWrite1hInputTokens > 0 && pricing.inputCacheWrite1h === null) {
+    if (usage.cacheWrite1hInputTokens > 0 && rates.inputCacheWrite1h === null) {
         return undefined;
     }
-    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;
+    return ((usage.inputTokens / 1000000) * rates.input +
+        (usage.cacheReadInputTokens / 1000000) * rates.inputCacheRead +
+        (usage.cacheWrite5mInputTokens / 1000000) * (rates.inputCacheWrite5m ?? 0) +
+        (usage.cacheWrite1hInputTokens / 1000000) * (rates.inputCacheWrite1h ?? 0) +
+        (usage.outputTokens / 1000000) * rates.output) * USD_TO_CREDITS;
 }
 async function fetchCached(request) {
     const key = JSON.stringify(request);

package/ink-app/dist/reporting.js

@@ -8,6 +8,11 @@ const CREDIT_TO_DOLLARS = 0.01;
 // Limit windows at or below this used-percent carry too little signal to be
 // worth reporting, so they are dropped from the anonymous usage payload.
 const SKIP_REPORT_USED_PERCENTS = 3;
+// Name of the catch-all limit class: the window meters every model the plan
+// offers, rather than one carved-out family.
+const ALL_LIMIT_CLASS = "All";
+// Mirrors the reporting endpoint's schema, which caps `limit_class` at 64.
+const LIMIT_CLASS_MAX_LENGTH = 64;
 let versionCache = null;
 export async function reportAnonymousUsage(statsList) {
     const payload = await buildAnonymousUsagePayload(statsList);
@@ -36,6 +41,7 @@ function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
     return {
         agent: stats.analytics?.agentName ?? stats.providerLabel.replace(/\s+/g, ""),
         model_type: resolveReportModelType(stats, window),
+        limit_class: resolveReportLimitClass(stats, window),
         userid_hash: stats.analytics?.userIdHash ?? "",
         plan_id: window.planType,
         window_duration_seconds: window.windowMinutes * 60,
@@ -48,6 +54,52 @@ function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
         letmecode_version: letmecodeVersion
     };
 }
+/**
+ * Canonical, display-ready name of the limit class a window belongs to.
+ * Every provider words the same idea differently - Antigravity separates Gemini
+ * from third-party models, Claude carves a model family out of the weekly
+ * window - so letmecode folds them onto one vocabulary and consumers never have
+ * to learn the provider-specific spellings in `model_type`.
+ *
+ * The vocabulary is open: a class nobody has seen before is reported under its
+ * own name rather than forced into an existing bucket.
+ */
+function resolveReportLimitClass(stats, window) {
+    if (stats.providerId === "claude") {
+        const modelFamily = window.modelType?.toLowerCase().replace(/\s+only$/, "").trim();
+        return modelFamily ? toLimitClassName(modelFamily) : ALL_LIMIT_CLASS;
+    }
+    if (stats.providerId === "antigravity") {
+        const limitId = window.limitId.toLowerCase();
+        if (limitId.includes("gemini")) {
+            return "Main";
+        }
+        if (limitId.startsWith("3p") || limitId.includes("third-party")) {
+            return "Other";
+        }
+        return toLimitClassName(window.limitId);
+    }
+    if (stats.providerId === "copilot") {
+        // Copilot quota labels ("AI Credits", "Premium requests") are already the
+        // name of the bucket they meter.
+        return window.modelType ? toLimitClassName(window.modelType) : ALL_LIMIT_CLASS;
+    }
+    // Codex, and anything else, meters every model against one shared allowance.
+    return ALL_LIMIT_CLASS;
+}
+/**
+ * Title-case a provider string into a class name, leaving words that already
+ * carry capitals alone so acronyms such as "AI Credits" survive intact.
+ */
+function toLimitClassName(value) {
+    const name = value
+        .trim()
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((word) => (/[A-Z]/.test(word) ? word : word.charAt(0).toUpperCase() + word.slice(1)))
+        .join(" ");
+    return name ? truncateSchemaString(name, LIMIT_CLASS_MAX_LENGTH) : ALL_LIMIT_CLASS;
+}
 function resolveReportModelType(stats, window) {
     if (stats.providerId === "antigravity") {
         return resolveAntigravityReportModelType(stats, window);

package/package.json

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