@tasszz2k/agentlens 0.5.10 → 0.5.12

package/dist/cost.js

@@ -5,6 +5,14 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { loadConfig } from './config.js';
 const execFileAsync = promisify(execFile);
+function extractErrorMessage(err) {
+    if (!(err instanceof Error))
+        return String(err);
+    const cause = err.cause;
+    if (cause instanceof Error)
+        return `${err.message}: ${cause.message}`;
+    return err.message;
+}
 function localDateStr(d) {
     const y = d.getFullYear();
     const m = String(d.getMonth() + 1).padStart(2, '0');
@@ -161,7 +169,7 @@ export async function fetchClaudeCodeCosts() {
             totalOutputTokens: 0,
             models: [],
             period,
-            error: err instanceof Error ? err.message : String(err),
+            error: extractErrorMessage(err),
         };
     }
 }
@@ -183,6 +191,26 @@ const CURSOR_TIER_NAMES = {
 function normalizeCursorTierName(key) {
     return CURSOR_TIER_NAMES[key] ?? key;
 }
+function parseUsageBucket(bucket) {
+    if (!bucket || typeof bucket !== 'object')
+        return undefined;
+    const b = bucket;
+    if (typeof b.enabled !== 'boolean')
+        return undefined;
+    const used = typeof b.used === 'number' ? b.used : Number(b.used);
+    const limit = typeof b.limit === 'number' ? b.limit : Number(b.limit);
+    return {
+        enabled: b.enabled,
+        usedCents: Number.isFinite(used) ? used : 0,
+        limitCents: Number.isFinite(limit) ? limit : 0,
+    };
+}
+function parseIsoMs(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : undefined;
+}
 async function fetchCursorUsageSummary(token) {
     try {
         const res = await fetch('https://cursor.com/api/usage-summary', {
@@ -195,27 +223,32 @@ async function fetchCursorUsageSummary(token) {
         const mt = data.membershipType;
         if (typeof mt === 'string' && mt !== 'free')
             planType = mt;
-        let onDemand;
-        const ind = data.individualUsage;
-        const indOd = ind?.onDemand;
-        if (indOd && typeof indOd.enabled === 'boolean') {
-            onDemand = {
-                enabled: indOd.enabled,
-                usedCents: typeof indOd.used === 'number' ? indOd.used : 0,
-                limitCents: typeof indOd.limit === 'number' ? indOd.limit : 0,
-            };
+        let limitType;
+        if (data.limitType === 'team' || data.limitType === 'individual') {
+            limitType = data.limitType;
         }
-        let teamOnDemand;
+        const ind = data.individualUsage;
         const team = data.teamUsage;
-        const teamOd = team?.onDemand;
-        if (teamOd && typeof teamOd.enabled === 'boolean') {
-            teamOnDemand = {
-                enabled: teamOd.enabled,
-                usedCents: typeof teamOd.used === 'number' ? teamOd.used : 0,
-                limitCents: typeof teamOd.limit === 'number' ? teamOd.limit : 0,
-            };
-        }
-        return { planType, onDemand, teamOnDemand };
+        // New shape: individualUsage.overall is the user's monthly bucket.
+        // Legacy shape: individualUsage.onDemand was the on-demand tracker.
+        const included = parseUsageBucket(ind?.overall) ??
+            parseUsageBucket(ind?.included);
+        // On-demand now lives under teamUsage.onDemand for team plans; fall back
+        // to legacy individualUsage.onDemand if present.
+        const onDemand = parseUsageBucket(team?.onDemand) ??
+            parseUsageBucket(ind?.onDemand);
+        const teamOnDemand = parseUsageBucket(team?.onDemand);
+        const pooled = parseUsageBucket(team?.pooled);
+        return {
+            planType,
+            limitType,
+            included,
+            onDemand,
+            teamOnDemand,
+            pooled,
+            billingCycleStartMs: parseIsoMs(data.billingCycleStart),
+            billingCycleEndMs: parseIsoMs(data.billingCycleEnd),
+        };
     }
     catch {
         return null;
@@ -350,7 +383,26 @@ async function getCursorEmail() {
     }
     return readVscdbKey('cursorAuth/cachedEmail');
 }
-async function fetchCursorTeamId(token) {
+async function fetchCursorMe(token) {
+    try {
+        const res = await fetch('https://cursor.com/api/auth/me', {
+            headers: { Cookie: `WorkosCursorSessionToken=${token}` },
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        if (typeof data.id !== 'number')
+            return null;
+        return {
+            userId: data.id,
+            email: typeof data.email === 'string' ? data.email : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchCursorTeamInfo(token) {
     try {
         const res = await fetch('https://cursor.com/api/dashboard/teams', {
             method: 'POST',
@@ -365,7 +417,58 @@ async function fetchCursorTeamId(token) {
             return null;
         const data = (await res.json());
         const first = data.teams?.[0];
-        return typeof first?.id === 'number' ? first.id : null;
+        if (!first || typeof first.id !== 'number')
+            return null;
+        const startMs = typeof first.billingCycleStart === 'string' ? Number(first.billingCycleStart) : NaN;
+        const endMs = typeof first.billingCycleEnd === 'string' ? Number(first.billingCycleEnd) : NaN;
+        return {
+            teamId: first.id,
+            billingCycleStartMs: Number.isFinite(startMs) ? startMs : 0,
+            billingCycleEndMs: Number.isFinite(endMs) ? endMs : 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchCursorDailySpend(token, teamId, userId, periodStartMs, periodEndMs) {
+    try {
+        const res = await fetch('https://cursor.com/api/dashboard/get-daily-spend-by-category', {
+            method: 'POST',
+            headers: {
+                Cookie: buildCursorCookie(token, { team_id: teamId }),
+                'Content-Type': 'application/json',
+                Origin: 'https://cursor.com',
+            },
+            body: JSON.stringify({ teamId, userId, periodStartMs, periodEndMs, groupBy: 1, spendType: 1 }),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        if (!Array.isArray(data.dailySpend))
+            return null;
+        const byCategory = {};
+        for (const entry of data.dailySpend) {
+            const cat = typeof entry.category === 'string' ? entry.category : '';
+            if (!cat)
+                continue;
+            const tokens = typeof entry.totalTokens === 'string' ? Number(entry.totalTokens) : 0;
+            const spend = typeof entry.spendCents === 'number' ? entry.spendCents : 0;
+            if (!byCategory[cat])
+                byCategory[cat] = { tokens: 0, spendCents: 0 };
+            byCategory[cat].tokens += tokens;
+            byCategory[cat].spendCents += spend;
+        }
+        const models = Object.entries(byCategory).map(([cat, agg]) => ({
+            model: cat,
+            inputTokens: agg.tokens,
+            outputTokens: 0,
+            cacheWriteTokens: 0,
+            cacheReadTokens: 0,
+            costUsd: agg.spendCents / 100,
+        }));
+        models.sort((a, b) => b.inputTokens - a.inputTokens);
+        return models;
     }
     catch {
         return null;
@@ -387,72 +490,90 @@ export async function fetchCursorCosts() {
                     + '  To get your token: cursor.com > DevTools (F12) > Application > Cookies > WorkosCursorSessionToken',
             };
         }
-        const usageRes = await fetch('https://cursor.com/api/usage', {
-            headers: { Cookie: `WorkosCursorSessionToken=${token}` },
-        });
-        if (!usageRes.ok) {
-            const body = await usageRes.text().catch(() => '');
-            const parsed = (() => { try {
-                return JSON.parse(body);
-            }
-            catch {
-                return null;
-            } })();
-            const detail = parsed?.error ?? `HTTP ${usageRes.status}`;
-            const hint = detail.includes('origin') || detail.includes('authenticated')
-                ? '\n  Try updating your token: agentlens config --set-cursor-token <token>\n'
-                    + '  Get it from: cursor.com > DevTools (F12) > Application > Cookies > WorkosCursorSessionToken'
-                : '';
-            return {
-                tool: 'Cursor',
-                totalCostUsd: 0,
-                totalInputTokens: 0,
-                totalOutputTokens: 0,
-                models: [],
-                period,
-                error: `API error: ${detail}${hint}`,
-            };
-        }
-        const usageData = (await usageRes.json());
-        const models = [];
-        let totalTokens = 0;
+        const [usageRes, meResult, configResult, usageSummaryResult] = await Promise.all([
+            fetch('https://cursor.com/api/usage', {
+                headers: { Cookie: `WorkosCursorSessionToken=${token}` },
+            }).catch((err) => err),
+            fetchCursorMe(token),
+            loadConfig().catch(() => ({ cursorTeamId: undefined })),
+            fetchCursorUsageSummary(token),
+        ]);
+        const subErrors = [];
+        // Premium request counts from /api/usage (legacy; may be empty for new dollar-based plans)
         let totalRequests = 0;
         let maxRequests;
-        for (const [key, val] of Object.entries(usageData)) {
-            if (key === 'startOfMonth' || typeof val !== 'object' || !val)
-                continue;
-            const entry = val;
-            const numTokens = typeof entry.numTokens === 'number' ? entry.numTokens : 0;
-            const reqs = typeof entry.numRequests === 'number' ? entry.numRequests : 0;
-            const maxReq = typeof entry.maxRequestUsage === 'number' ? entry.maxRequestUsage : undefined;
-            totalTokens += numTokens;
-            totalRequests += reqs;
-            if (maxReq != null)
-                maxRequests = (maxRequests ?? 0) + maxReq;
-            models.push({
-                model: normalizeCursorTierName(key),
-                inputTokens: numTokens,
-                outputTokens: 0,
-                cacheWriteTokens: 0,
-                cacheReadTokens: 0,
-                costUsd: 0,
-                numRequests: reqs,
-            });
+        if (usageRes instanceof Error) {
+            subErrors.push(`usage: ${usageRes.message}`);
+        }
+        else if (usageRes.ok) {
+            try {
+                const usageData = (await usageRes.json());
+                for (const [key, val] of Object.entries(usageData)) {
+                    if (key === 'startOfMonth' || typeof val !== 'object' || !val)
+                        continue;
+                    const entry = val;
+                    const reqs = typeof entry.numRequests === 'number' ? entry.numRequests : 0;
+                    const maxReq = typeof entry.maxRequestUsage === 'number' ? entry.maxRequestUsage : undefined;
+                    totalRequests += reqs;
+                    if (maxReq != null)
+                        maxRequests = (maxRequests ?? 0) + maxReq;
+                }
+            }
+            catch (err) {
+                subErrors.push(`usage parse: ${extractErrorMessage(err)}`);
+            }
+        }
+        else {
+            subErrors.push(`usage: HTTP ${usageRes.status}`);
         }
-        models.sort((a, b) => b.inputTokens - a.inputTokens);
         let planType;
+        let limitType;
+        let included;
         let onDemand;
         let teamOnDemand;
+        let pooled;
+        let billingCycleStartMs;
+        let billingCycleEndMs;
         let leaderboard;
-        const [emailResult, configResult, usageSummaryResult] = await Promise.all([
-            getCursorEmail(),
-            loadConfig().catch(() => ({ cursorTeamId: undefined })),
-            fetchCursorUsageSummary(token),
-        ]);
-        const email = emailResult;
+        if (usageSummaryResult) {
+            planType = usageSummaryResult.planType;
+            limitType = usageSummaryResult.limitType;
+            included = usageSummaryResult.included;
+            onDemand = usageSummaryResult.onDemand;
+            teamOnDemand = usageSummaryResult.teamOnDemand;
+            pooled = usageSummaryResult.pooled;
+            billingCycleStartMs = usageSummaryResult.billingCycleStartMs;
+            billingCycleEndMs = usageSummaryResult.billingCycleEndMs;
+        }
+        else {
+            subErrors.push('usage-summary: failed');
+        }
+        const email = meResult?.email || await getCursorEmail();
         let teamId = configResult.cursorTeamId ?? null;
-        if (teamId == null && email) {
-            teamId = await fetchCursorTeamId(token);
+        let billingStart = billingCycleStartMs ?? 0;
+        let billingEnd = billingCycleEndMs ?? 0;
+        const teamInfo = await fetchCursorTeamInfo(token);
+        if (teamInfo) {
+            teamId = teamInfo.teamId;
+            // Prefer team endpoint cycle if usage-summary didn't provide one.
+            if (billingStart === 0)
+                billingStart = teamInfo.billingCycleStartMs;
+            if (billingEnd === 0)
+                billingEnd = teamInfo.billingCycleEndMs;
+        }
+        // Per-model token + cost data from daily-spend API
+        let models = [];
+        let totalTokens = 0;
+        const userId = meResult?.userId ?? null;
+        if (teamId != null && userId != null && billingStart > 0 && billingEnd > 0) {
+            const dailyModels = await fetchCursorDailySpend(token, teamId, userId, billingStart, billingEnd);
+            if (dailyModels && dailyModels.length > 0) {
+                models = dailyModels;
+                totalTokens = models.reduce((sum, m) => sum + m.inputTokens, 0);
+            }
+            else {
+                subErrors.push('daily-spend: no data');
+            }
         }
         let leaderboardResult;
         if (teamId != null && email) {
@@ -463,15 +584,23 @@ export async function fetchCursorCosts() {
         else {
             leaderboardResult = { status: 'fulfilled', value: null };
         }
-        if (usageSummaryResult) {
-            planType = usageSummaryResult.planType;
-            onDemand = usageSummaryResult.onDemand;
-            teamOnDemand = usageSummaryResult.teamOnDemand;
-        }
         if (leaderboardResult.status === 'fulfilled' && leaderboardResult.value) {
             leaderboard = leaderboardResult.value;
         }
-        const cursorCostUsd = onDemand?.enabled ? onDemand.usedCents / 100 : 0;
+        const includedSpendCents = included?.enabled ? included.usedCents : 0;
+        const onDemandSpendCents = onDemand?.enabled ? onDemand.usedCents : 0;
+        const dailySpendCents = models.reduce((sum, m) => sum + Math.round(m.costUsd * 100), 0);
+        // Prefer the daily-spend total when present (matches dashboard exactly);
+        // fall back to included + on-demand from the usage-summary buckets.
+        const totalCents = dailySpendCents > 0 ? dailySpendCents : includedSpendCents + onDemandSpendCents;
+        const cursorCostUsd = totalCents / 100;
+        // Only surface sub-errors when we have nothing useful to show.
+        const hasAnyData = cursorCostUsd > 0 ||
+            included != null ||
+            onDemand != null ||
+            pooled != null ||
+            models.length > 0 ||
+            totalRequests > 0;
         return {
             tool: 'Cursor',
             totalCostUsd: cursorCostUsd,
@@ -480,11 +609,17 @@ export async function fetchCursorCosts() {
             totalRequests,
             maxRequests,
             planType,
+            limitType,
+            included,
             onDemand,
             teamOnDemand,
+            pooled,
+            billingCycleStartMs: billingStart > 0 ? billingStart : undefined,
+            billingCycleEndMs: billingEnd > 0 ? billingEnd : undefined,
             leaderboard,
             models,
             period,
+            error: hasAnyData ? undefined : (subErrors.length > 0 ? subErrors.join('; ') : 'No data returned from Cursor APIs'),
         };
     }
     catch (err) {
@@ -495,7 +630,7 @@ export async function fetchCursorCosts() {
             totalOutputTokens: 0,
             models: [],
             period,
-            error: err instanceof Error ? err.message : String(err),
+            error: extractErrorMessage(err),
         };
     }
 }
@@ -509,6 +644,24 @@ async function getClaudeSessionToken() {
     }
 }
 const BROWSER_UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+function normalizeClaudePlanType(raw) {
+    const lower = raw.toLowerCase();
+    if (lower.includes('enterprise'))
+        return 'enterprise';
+    if (lower.includes('team'))
+        return 'team';
+    if (lower === 'max' || lower.includes('max'))
+        return 'max';
+    if (lower === 'pro' || lower.includes('professional') || lower.includes('pro_'))
+        return 'pro';
+    if (lower === 'free' || lower.includes('free'))
+        return 'free';
+    if (lower.includes('subscription') || lower.includes('stripe'))
+        return undefined;
+    if (lower.includes('individual'))
+        return 'pro';
+    return undefined;
+}
 async function fetchClaudeBootstrap(token) {
     try {
         const res = await fetch('https://claude.ai/api/bootstrap', {
@@ -526,9 +679,48 @@ async function fetchClaudeBootstrap(token) {
             for (const m of memberships) {
                 const org = m.organization;
                 if (org && typeof org.uuid === 'string') {
+                    let planType;
+                    for (const key of ['billing_type', 'plan_type', 'subscription_type', 'plan', 'type']) {
+                        const val = org[key];
+                        if (typeof val === 'string' && val) {
+                            const normalized = normalizeClaudePlanType(val);
+                            if (normalized) {
+                                planType = normalized;
+                                break;
+                            }
+                        }
+                    }
+                    if (!planType) {
+                        const settings = org.settings;
+                        if (settings) {
+                            for (const key of ['billing_type', 'plan_type']) {
+                                const val = settings[key];
+                                if (typeof val === 'string' && val) {
+                                    const normalized = normalizeClaudePlanType(val);
+                                    if (normalized) {
+                                        planType = normalized;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    const activeFlags = org.active_flags;
+                    if (!planType && Array.isArray(activeFlags)) {
+                        for (const flag of activeFlags) {
+                            if (typeof flag !== 'string')
+                                continue;
+                            const normalized = normalizeClaudePlanType(flag);
+                            if (normalized) {
+                                planType = normalized;
+                                break;
+                            }
+                        }
+                    }
                     orgs.push({
                         uuid: org.uuid,
                         name: typeof org.name === 'string' ? org.name : '',
+                        planType,
                     });
                 }
             }
@@ -539,6 +731,78 @@ async function fetchClaudeBootstrap(token) {
         return null;
     }
 }
+async function fetchClaudeAdminUsage(adminKey, startDate, endDate) {
+    try {
+        const params = new URLSearchParams({
+            group_by: 'model',
+            start_date: startDate,
+            end_date: endDate,
+            interval: 'month',
+        });
+        const res = await fetch(`https://api.anthropic.com/v1/organizations/usage_report/messages?${params.toString()}`, {
+            headers: {
+                'x-api-key': adminKey,
+                'anthropic-version': '2023-06-01',
+            },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        const rows = data.data;
+        if (!Array.isArray(rows))
+            return [];
+        const byModel = {};
+        for (const row of rows) {
+            const model = typeof row.model === 'string' ? row.model : 'unknown';
+            if (!byModel[model]) {
+                byModel[model] = { model, inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
+            }
+            const m = byModel[model];
+            m.inputTokens += typeof row.input_tokens === 'number' ? row.input_tokens : 0;
+            m.outputTokens += typeof row.output_tokens === 'number' ? row.output_tokens : 0;
+            m.cacheCreationTokens += typeof row.cache_creation_input_tokens === 'number' ? row.cache_creation_input_tokens : 0;
+            m.cacheReadTokens += typeof row.cache_read_input_tokens === 'number' ? row.cache_read_input_tokens : 0;
+        }
+        return Object.values(byModel);
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchClaudeAdminCost(adminKey, startDate, endDate) {
+    try {
+        const params = new URLSearchParams({
+            group_by: 'model',
+            start_date: startDate,
+            end_date: endDate,
+            interval: 'month',
+        });
+        const res = await fetch(`https://api.anthropic.com/v1/organizations/cost_report?${params.toString()}`, {
+            headers: {
+                'x-api-key': adminKey,
+                'anthropic-version': '2023-06-01',
+            },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        const rows = data.data;
+        if (!Array.isArray(rows))
+            return [];
+        const byModel = {};
+        for (const row of rows) {
+            const model = typeof row.model === 'string' ? row.model : 'unknown';
+            if (!byModel[model]) {
+                byModel[model] = { model, costUsd: 0 };
+            }
+            byModel[model].costUsd += typeof row.cost_usd === 'number' ? row.cost_usd : 0;
+        }
+        return Object.values(byModel);
+    }
+    catch {
+        return [];
+    }
+}
 export async function fetchClaudeAiCosts() {
     const period = formatPeriod();
     try {
@@ -607,13 +871,50 @@ export async function fetchClaudeAiCosts() {
                 spentCents,
                 limitCents,
                 orgName: org.name,
+                planType: org.planType,
             };
+            const now = new Date();
+            const startDate = localDateStr(new Date(now.getFullYear(), now.getMonth(), 1));
+            const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+            const endDate = localDateStr(nextMonth);
+            let models = [];
+            let totalInput = 0;
+            let totalOutput = 0;
+            let totalCacheW = 0;
+            let totalCacheR = 0;
+            if (config.claudeAdminApiKey) {
+                const [usageRows, costRows] = await Promise.all([
+                    fetchClaudeAdminUsage(config.claudeAdminApiKey, startDate, endDate),
+                    fetchClaudeAdminCost(config.claudeAdminApiKey, startDate, endDate),
+                ]);
+                if (usageRows.length > 0) {
+                    const costMap = new Map(costRows.map((c) => [c.model, c.costUsd]));
+                    for (const u of usageRows) {
+                        totalInput += u.inputTokens;
+                        totalOutput += u.outputTokens;
+                        totalCacheW += u.cacheCreationTokens;
+                        totalCacheR += u.cacheReadTokens;
+                        models.push({
+                            model: u.model,
+                            inputTokens: u.inputTokens,
+                            outputTokens: u.outputTokens,
+                            cacheWriteTokens: u.cacheCreationTokens,
+                            cacheReadTokens: u.cacheReadTokens,
+                            costUsd: costMap.get(u.model) ?? 0,
+                        });
+                    }
+                    models.sort((a, b) => b.costUsd - a.costUsd);
+                }
+            }
             return {
                 tool: 'Claude.ai',
                 totalCostUsd: spentCents / 100,
-                totalInputTokens: 0,
-                totalOutputTokens: 0,
-                models: [],
+                totalInputTokens: totalInput,
+                totalOutputTokens: totalOutput,
+                totalCacheWriteTokens: totalCacheW > 0 ? totalCacheW : undefined,
+                totalCacheReadTokens: totalCacheR > 0 ? totalCacheR : undefined,
+                planType: org.planType,
+                models,
                 claudeAi,
                 period,
             };
@@ -636,11 +937,11 @@ export async function fetchClaudeAiCosts() {
             totalOutputTokens: 0,
             models: [],
             period,
-            error: err instanceof Error ? err.message : String(err),
+            error: extractErrorMessage(err),
         };
     }
 }
-export async function fetchAllCosts(disabledCostTools) {
+export async function fetchAllCosts(disabledCostTools, onTool) {
     const now = new Date();
     const monthStart = localDateStr(new Date(now.getFullYear(), now.getMonth(), 1));
     const monthNames = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
@@ -654,25 +955,26 @@ export async function fetchAllCosts(disabledCostTools) {
         fetchers.push({ tool: 'Claude Code', promise: fetchClaudeCodeCosts() });
     if (!skip.has('Cursor'))
         fetchers.push({ tool: 'Cursor', promise: fetchCursorCosts() });
-    const results = await Promise.allSettled(fetchers.map((f) => f.promise));
-    const tools = [];
-    for (let i = 0; i < fetchers.length; i++) {
-        const r = results[i];
-        if (r.status === 'fulfilled') {
-            tools.push(r.value);
-        }
-        else {
-            tools.push({
-                tool: fetchers[i].tool,
-                totalCostUsd: 0,
-                totalInputTokens: 0,
-                totalOutputTokens: 0,
-                models: [],
-                period: formatPeriod(),
-                error: r.reason?.message ?? String(r.reason),
-            });
-        }
-    }
+    // Settle each fetcher independently and stream updates via onTool as they
+    // resolve, so the UI can render Claude Code (fast/local) immediately
+    // without waiting for Cursor (slow/remote).
+    const wrapped = fetchers.map((f) => f.promise.then((value) => {
+        onTool?.(value);
+        return value;
+    }, (reason) => {
+        const errorSummary = {
+            tool: f.tool,
+            totalCostUsd: 0,
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            models: [],
+            period: formatPeriod(),
+            error: extractErrorMessage(reason),
+        };
+        onTool?.(errorSummary);
+        return errorSummary;
+    }));
+    const tools = await Promise.all(wrapped);
     return {
         tools,
         month: monthLabel,