@toninho09/opencode-usage 1.0.0 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 # OpenCode Usage Plugin
 
-Track your AI coding assistant usage in one place. This plugin shows quota information and usage statistics for GitHub Copilot, Claude Code, and Z.ai with a single command.
+Track your AI coding assistant usage in one place. This plugin shows both provider quota information and real-time token usage statistics for GitHub Copilot, Claude Code, and Z.ai.
 
 ## Table of Contents
 
@@ -69,7 +69,7 @@ npm install
 #### Option B: Install via npm (coming soon)
 
 ```bash
-npm install -g opencode-usage
+npm install -g @toninho09/opencode-usage@latest
 ```
 
 Then add to your `opencode.json` config file:
@@ -99,31 +99,68 @@ Now check your usage:
 ## What You'll See
 
 ```
-╔════════════════════════════════════════╗
-║         GITHUB COPILOT                 ║
-╚════════════════════════════════════════╝
-Plan:            individual
-Premium:         [##                  ] 11% (33/300)
-Chat:            Unlimited
-Completions:     Unlimited
-Quota Resets:    18d 20h (9999-12-31 23:59 UTC-03:00)
-╔════════════════════════════════════════╗
-║       CLAUDE CODE                      ║
-╚════════════════════════════════════════╝
-5 Hour:          [################### ] 94%
-7 Day:           [#                   ] 7%
-5h Resets:       2h (9999-12-31 23:59 UTC-03:00)
-7d Resets:       6d 21h (9999-12-31 23:59 UTC-03:00)
-Extra Usage:     Disabled
-╔════════════════════════════════════════╗
-║       Z.AI CODING PLAN                 ║
-╚════════════════════════════════════════╝
-Account:         xxxxxxxx............ (Z.AI Coding Plan)
-Tokens:          [#                   ] 4%
-5h Resets:       3h (9999-12-31 23:59 UTC-03:00)
-MCP Searches:    [                    ] 0% (0/100)
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                                 GITHUB COPILOT                                 ║
+╚════════════════════════════════════════════════════════════════════════════════╝
+  Plan:            individual
+  Premium:         [##                  ] 11% (33/300)
+  Chat:            Unlimited
+  Completions:     Unlimited
+Quota Resets:      18d 0h (2026-02-28 21:00 UTC-03:00)
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                                  CLAUDE CODE                                   ║
+╚════════════════════════════════════════════════════════════════════════════════╝
+  5 Hour:          [###                 ] 15%
+  7 Day:           [##                  ] 11%
+  5h Resets:      4h (2026-02-11 00:59 UTC-03:00)
+  7d Resets:      6d 1h (2026-02-16 21:59 UTC-03:00)
+  Extra Usage:     Disabled
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                                Z.AI CODING PLAN                                ║
+╚════════════════════════════════════════════════════════════════════════════════╝
+  Account:         xxxxxxxx............ (Z.AI Coding Plan)
+  Tokens:          [                    ] 1%
+  5h Resets:      4h (2026-02-11 00:45 UTC-03:00)
+  MCP Searches:    [                    ] 0% (0/100)
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                                Current Session                                 ║
+╚════════════════════════════════════════════════════════════════════════════════╝
+  Total Tokens:    14,650
+  Messages:        2
+  Models:
+  ────────────────────────────────────────────────────────────────────────────
+  github-copilot/gpt-5-mini
+    In: 14,190  Out: 460  Rea: 0  Cache-Rd: 0  Cache-Wr: 0  Messages: 2
+╔════════════════════════════════════════════════════════════════════════════════╗
+║                           All Sessions (2 sessions)                            ║
+╚════════════════════════════════════════════════════════════════════════════════╝
+  Total Tokens:    30,332
+  Messages:        4
+  Models:
+  ────────────────────────────────────────────────────────────────────────────
+  zai-coding-plan/glm-4.7-flash
+    In: 15,102  Out: 492  Rea: 0  Cache-Rd: 88  Cache-Wr: 0  Messages: 2
+  github-copilot/gpt-5-mini
+    In: 14,190  Out: 460  Rea: 0  Cache-Rd: 0  Cache-Wr: 0  Messages: 2
 ```
 
+**Token Tracking Key:**
+- `In` = Input tokens
+- `Out` = Output tokens
+- `Rea` = Reasoning tokens
+- `Cache-Rd` = Cache read tokens
+- `Cache-Wr` = Cache write tokens
+- `Messages` = Message count
+
+## Features
+
+- ✅ **Provider quota monitoring**: Shows usage limits and remaining quota for Copilot, Claude, and Z.ai
+- ✅ **Real-time token tracking**: Automatically monitors token usage from all AI messages
+- ✅ **Provider/Model breakdown**: See usage grouped by AI provider and model
+- ✅ **Token type tracking**: Input, output, reasoning, cache read, and cache write tokens
+- ✅ **Multi-session support**: View current session and all sessions history
+- ✅ **No external dependencies**: Uses only in-memory tracking (reset when app closes)
+
 ## License
 
 MIT

package/index.ts

@@ -1,30 +1,141 @@
 import type { Plugin } from "@opencode-ai/plugin"
 import { handleUsageCommand } from "./lib/usage-handler"
+import { state } from "./lib/tracking/types"
+import { addTokens } from "./lib/tracking/tracker"
 
 export const TestPlugin: Plugin = async ({ client }) => {
     return {
+        event: async ({ event }) => {
+            // Send notification on session completion
+            if (event.type === "message.updated") {
+                try {
+                    const sessionID = event.properties?.info.sessionID;
+                    const info = event.properties?.info;
+                    const app = client.app
+                    await app.log({
+                        body: {
+                            service: "usage-plugin",
+                            level: "debug",
+                            message: "message.updated event received",
+                            extra: { sessionID, role: info?.role },
+                        },
+                    })
+
+                    if (sessionID && info?.role === "assistant" && info?.tokens) {
+                        const { input, output, reasoning, cache } = info.tokens;
+                        const app = client.app
+
+                        await app.log({
+                            body: {
+                                service: "usage-plugin",
+                                level: "debug",
+                                message: "Tokens detected in event",
+                                extra: { input, output, reasoning, cacheRead: cache?.read, cacheWrite: cache?.write },
+                            },
+                        })
+
+                        if ((input ?? 0) > 0 || (output ?? 0) > 0) {
+                            const provider = info.providerID || "unknown";
+                            const model = info.modelID || "unknown";
+                            const app = client.app
+
+                            await app.log({
+                                body: {
+                                    service: "usage-plugin",
+                                    level: "debug",
+                                    message: "Adding tokens to session",
+                                    extra: { provider, model },
+                                },
+                            })
+                            state.currentSessionID = sessionID;
+
+                            addTokens(
+                                sessionID,
+                                provider,
+                                model,
+                                {
+                                    input: input ?? 0,
+                                    output: output ?? 0,
+                                    reasoning: reasoning ?? 0,
+                                    cacheRead: cache?.read ?? 0,
+                                    cacheWrite: cache?.write ?? 0,
+                                },
+                            );
+                        } else {
+                            const app = client.app
+
+                            await app.log({
+                                body: {
+                                    service: "usage-plugin",
+                                    level: "warn",
+                                    message: "Zero or negative tokens - Ignoring",
+                                    extra: { input, output, reasoning },
+                                },
+                            })
+                        }
+                    } else {
+                        const app = client.app
+
+                        await app.log({
+                            body: {
+                                service: "usage-plugin",
+                                level: "debug",
+                                message: "Event does not contain token data",
+                                extra: { sessionID, role: info?.role },
+                            },
+                        })
+                    }
+                } catch (error) {
+                    const app = client.app
+
+                    await app.log({
+                        body: {
+                            service: "usage-plugin",
+                            level: "error",
+                                message: "Error in message.updated",
+                            extra: { error: error instanceof Error ? error.message : String(error) },
+                        },
+                    })
+                }
+            }
+        },
         config: async (opencodeConfig) => {
             opencodeConfig.command ??= {}
             opencodeConfig.command["usage"] = {
                 template: "",
-                description: "Shows usage for Copilot, Claude Code and Z.ai",
+                description: "Shows token usage for all sessions by provider and model",
             }
         },
         "command.execute.before": async (input, output) => {
             if (input.command === "usage") {
                 try {
+                    const app = client.app
+                    await app.log({
+                        body: {
+                            service: "usage-plugin",
+                            level: "info",
+                            message: "/usage command executed",
+                        },
+                    })
                     await handleUsageCommand({
                         client,
                         sessionID: input.sessionID,
                         params: output,
                     })
                 } catch (err) {
-                    console.error(err instanceof Error ? err.message : String(err))
+                    const app = client.app
+                    await app.log({
+                        body: {
+                            service: "usage-plugin",
+                            level: "error",
+                            message: err instanceof Error ? err.message : String(err),
+                        },
+                    })
                 }
 
                 throw new Error("__USAGE_COMMAND_HANDLED__")
             }
-        },
+        }
     }
 }
 

package/lib/providers/claude/formatter.ts

@@ -1,5 +1,5 @@
 import { formatResetLine } from "../../shared/formatting";
-import { createUsedProgressBar } from "../../shared/utils";
+import { createUsedProgressBar, boxHeader } from "../../shared/utils";
 import type { ClaudeUsageResponse, QuotaPeriod } from "./types";
 
 export class ClaudeFormatter {
@@ -8,13 +8,13 @@ export class ClaudeFormatter {
    */
   private formatQuotaLine(name: string, quota: QuotaPeriod | null): string {
     if (!quota) {
-      return `${name.padEnd(16)} N/A`;
+      return `  ${name.padEnd(16)} N/A`;
     }
 
     const percentUsed = Math.round(quota.utilization);
     const progressBar = createUsedProgressBar(percentUsed, 20);
 
-    return `${name.padEnd(16)} ${progressBar} ${percentUsed}%`;
+    return `  ${name.padEnd(16)} ${progressBar} ${percentUsed}%`;
   }
 
   /**
@@ -23,19 +23,17 @@ export class ClaudeFormatter {
   format(data: ClaudeUsageResponse): string {
     const lines: string[] = [];
 
-    lines.push("╔════════════════════════════════════════╗");
-    lines.push("║       CLAUDE CODE                      ║");
-    lines.push("╚════════════════════════════════════════╝");
+    lines.push(boxHeader("CLAUDE CODE", 80));
 
     lines.push(this.formatQuotaLine("5 Hour:", data.five_hour));
     lines.push(this.formatQuotaLine("7 Day:", data.seven_day));
 
     if (data.five_hour) {
-      lines.push(formatResetLine("5h Resets:", data.five_hour.resets_at, 16));
+      lines.push("  " + formatResetLine("5h Resets:", data.five_hour.resets_at, 15));
     }
 
     if (data.seven_day) {
-      lines.push(formatResetLine("7d Resets:", data.seven_day.resets_at, 16));
+      lines.push("  " + formatResetLine("7d Resets:", data.seven_day.resets_at, 15));
     }
 
     const extraUsage = data.extra_usage;
@@ -46,9 +44,9 @@ export class ClaudeFormatter {
         extraUsage.used_credits !== null && extraUsage.monthly_limit !== null
           ? `${extraUsage.used_credits}/${extraUsage.monthly_limit}`
           : "N/A";
-      lines.push(`Extra Usage:     Enabled - ${utilization} (${credits})`);
+      lines.push(`  Extra Usage:     Enabled - ${utilization} (${credits})`);
     } else {
-      lines.push("Extra Usage:     Disabled");
+      lines.push("  Extra Usage:     Disabled");
     }
 
     return lines.join("\n");

package/lib/providers/claude/index.ts

@@ -8,7 +8,7 @@ const formatter = new ClaudeFormatter();
 export const claudeProvider: UsageProvider = {
   name: "Claude Code",
   id: "claude",
-  description: "Monitoramento de uso do Claude Code",
+  description: "Claude Code usage monitoring",
 
   async getUsageData(): Promise<ProviderMessage | null> {
     try {

package/lib/providers/copilot/formatter.ts

@@ -1,5 +1,5 @@
 import { formatResetLine } from "../../shared/formatting";
-import { createUsedProgressBar } from "../../shared/utils";
+import { createUsedProgressBar, boxHeader } from "../../shared/utils";
 import type { CopilotUsageResponse, QuotaDetail } from "./types";
 
 export class CopilotFormatter {
@@ -12,7 +12,7 @@ export class CopilotFormatter {
     }
 
     if (quota.unlimited) {
-      return `${name.padEnd(16)} Unlimited`;
+      return `  ${name.padEnd(16)} Unlimited`;
     }
 
     const total = quota.entitlement;
@@ -20,7 +20,7 @@ export class CopilotFormatter {
     const percentUsed = Math.round((used / total) * 100);
     const progressBar = createUsedProgressBar(percentUsed, 20);
 
-    return `${name.padEnd(16)} ${progressBar} ${percentUsed}% (${used}/${total})`;
+    return `  ${name.padEnd(16)} ${progressBar} ${percentUsed}% (${used}/${total})`;
   }
 
   /**
@@ -29,10 +29,8 @@ export class CopilotFormatter {
   format(data: CopilotUsageResponse): string {
     const lines: string[] = [];
 
-    lines.push("╔════════════════════════════════════════╗");
-    lines.push("║         GITHUB COPILOT                 ║");
-    lines.push("╚════════════════════════════════════════╝");
-    lines.push(`Plan:            ${data.copilot_plan}`);
+    lines.push(boxHeader("GITHUB COPILOT", 80));
+    lines.push(`  Plan:            ${data.copilot_plan}`);
 
     const premium = data.quota_snapshots.premium_interactions;
     if (premium) {
@@ -58,7 +56,7 @@ export class CopilotFormatter {
       }
     }
 
-    lines.push(formatResetLine("Quota Resets:", data.quota_reset_date, 16));
+    lines.push(formatResetLine("Quota Resets:", data.quota_reset_date, 18));
 
     return lines.join("\n");
   }

package/lib/providers/copilot/index.ts

@@ -8,7 +8,7 @@ const formatter = new CopilotFormatter();
 export const copilotProvider: UsageProvider = {
   name: "GitHub Copilot",
   id: "copilot",
-  description: "Monitoramento de uso do GitHub Copilot",
+  description: "GitHub Copilot usage monitoring",
 
   async getUsageData(): Promise<ProviderMessage | null> {
     try {

package/lib/providers/zai/formatter.ts

@@ -1,5 +1,5 @@
 import { formatResetLine, formatTokens, maskApiKey } from "../../shared/formatting";
-import { createUsedProgressBar } from "../../shared/utils";
+import { createUsedProgressBar, boxHeader } from "../../shared/utils";
 import type { ZaiUsageResponse, UsageLimitItem } from "./types";
 
 export class ZaiFormatter {
@@ -36,13 +36,11 @@ export class ZaiFormatter {
     const limits = data.data.limits;
 
     const maskedKey = maskApiKey(apiKey);
-    lines.push("╔════════════════════════════════════════╗");
-    lines.push("║       Z.AI CODING PLAN                 ║");
-    lines.push("╚════════════════════════════════════════╝");
-    lines.push(`Account:         ${maskedKey} (Z.AI Coding Plan)`);
+    lines.push(boxHeader("Z.AI CODING PLAN", 80));
+    lines.push(`  Account:         ${maskedKey} (Z.AI Coding Plan)`);
 
     if (!limits || limits.length === 0) {
-      lines.push("No quota data available");
+      lines.push("  No quota data available");
       return lines.join("\n");
     }
 
@@ -52,10 +50,10 @@ export class ZaiFormatter {
       const progressBar = createUsedProgressBar(percentUsed, 20);
       const usageDisplay = this.calculateUsageDisplay(tokensLimit);
 
-      lines.push(`Tokens:          ${progressBar} ${percentUsed}%${usageDisplay}`);
+      lines.push(`  Tokens:          ${progressBar} ${percentUsed}%${usageDisplay}`);
 
       if (tokensLimit.nextResetTime) {
-        lines.push(formatResetLine("5h Resets:", tokensLimit.nextResetTime, 16));
+        lines.push("  " + formatResetLine("5h Resets:", tokensLimit.nextResetTime, 15));
       }
     }
 
@@ -68,7 +66,7 @@ export class ZaiFormatter {
       const total = timeLimit.usage ?? (timeLimit.remaining ?? 0);
 
       lines.push(
-        `MCP Searches:    ${progressBar} ${percentUsed}% (${currentValue}/${total})`,
+        `  MCP Searches:    ${progressBar} ${percentUsed}% (${currentValue}/${total})`,
       );
     }
 

package/lib/providers/zai/index.ts

@@ -8,7 +8,7 @@ const formatter = new ZaiFormatter();
 export const zaiProvider: UsageProvider = {
   name: "Z.ai Coding Plan",
   id: "zai",
-  description: "Monitoramento de uso do Z.ai Coding Plan",
+  description: "Z.ai Coding Plan usage monitoring",
 
   async getUsageData(): Promise<ProviderMessage | null> {
     try {

package/lib/shared/formatting.ts

@@ -33,15 +33,16 @@ export function formatResetLine(
   label: string,
   resetDate: string | number | undefined,
   labelWidth: number = 15,
+  prefix: string = "",
 ): string {
   if (!resetDate) {
-    return `${label.padEnd(labelWidth)} N/A`;
+    return `${prefix}${label.padEnd(labelWidth)} N/A`;
   }
 
   const countdown = formatResetCountdown(resetDate);
   const friendlyDate = formatFriendlyDate(resetDate);
 
-  return `${label.padEnd(labelWidth)} ${countdown} (${friendlyDate})`;
+  return `${prefix}${label.padEnd(labelWidth)} ${countdown} (${friendlyDate})`;
 }
 
 /**

package/lib/shared/notification.ts

@@ -2,23 +2,12 @@ export async function sendIgnoredMessage(
     client: any,
     sessionID: string,
     text: string,
-    params: any,
 ): Promise<void> {
-    const agent = params.agent || undefined
-    const variant = params.variant || undefined
-    const model = params.providerId && params.modelId ? {
-        providerID: params.providerId,
-        modelID: params.modelId,
-    } : undefined
-
     try {
         await client.session.prompt({
             path: { id: sessionID },
             body: {
                 noReply: true,
-                agent,
-                model,
-                variant,
                 parts: [{ type: "text", text, ignored: true }],
             },
         })

package/lib/shared/utils.ts

@@ -41,3 +41,26 @@ export function formatFriendlyDate(dateInput: string | number | Date): string {
   
   return `${year}-${month}-${day} ${hours}:${minutes} ${timezone}`;
 }
+
+/**
+ * Creates a centered box header with title
+ * Width is the inner content width (excludes the border characters)
+ * Example with width=80:
+ * ╔══════════════════════════════════════════════════════════════════════════════════╗
+ * ║                                  MY TITLE                                       ║
+ * ╚══════════════════════════════════════════════════════════════════════════════════╝
+ */
+export function boxHeader(title: string, width: number = 80): string {
+  const topLine = "╔" + "═".repeat(width) + "╗";
+  const bottomLine = "╚" + "═".repeat(width) + "╝";
+  
+  // Center the title within the width
+  const padding = Math.max(0, width - title.length);
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+  const centerTitle = " ".repeat(leftPad) + title + " ".repeat(rightPad);
+  
+  const middleLine = "║" + centerTitle + "║";
+  
+  return topLine + "\n" + middleLine + "\n" + bottomLine;
+}

package/lib/tracking/tracker.ts

@@ -0,0 +1,89 @@
+import { state, SessionUsage, TokenMetrics } from "./types";
+
+const logToApp = async (level: "debug" | "info" | "warn", message: string, extra?: Record<string, any>) => {
+  try {
+    const client = await (window as any).__opencodeClient
+    if (client?.app?.log) {
+      await client.app.log({
+        body: {
+          service: "tracking-plugin",
+          level,
+          message,
+          extra,
+        },
+      })
+    }
+  } catch {
+  }
+}
+
+export function getCurrentSession(): SessionUsage | null {
+  if (!state.currentSessionID) {
+    return null;
+  }
+  return getSession(state.currentSessionID);
+}
+
+export function getSession(sessionID: string): SessionUsage {
+  if (!state.sessions.has(sessionID)) {
+    logToApp("info", "Creating new session", { sessionID })
+    state.sessions.set(sessionID, {
+      sessionID,
+      total: { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 },
+      byModel: new Map(),
+    });
+  } else {
+    logToApp("debug", "Session found", { sessionID })
+  }
+  return state.sessions.get(sessionID)!;
+}
+
+export function updateSession(sessionID: string, sessionData: Partial<SessionUsage>): void {
+  const session = getSession(sessionID);
+  logToApp("debug", "Updating session", { sessionID, sessionData })
+  Object.assign(session, sessionData);
+}
+
+export function addTokens(
+  sessionID: string,
+  provider: string,
+  model: string,
+  tokens: TokenMetrics,
+): void {
+  logToApp("debug", "Adding tokens", { sessionID, provider, model, tokens })
+  
+  const session = getSession(sessionID);
+
+  session.total.input += tokens.input;
+  session.total.output += tokens.output;
+  session.total.reasoning += tokens.reasoning;
+  session.total.cacheRead += tokens.cacheRead;
+  session.total.cacheWrite += tokens.cacheWrite;
+
+  const key = `${provider}/${model}`;
+  let modelStats = session.byModel.get(key);
+  if (!modelStats) {
+    logToApp("info", "Creating new model stats", { key })
+    modelStats = {
+      provider,
+      model,
+      metrics: { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 },
+      messageCount: 0,
+    };
+    session.byModel.set(key, modelStats);
+  }
+  modelStats.metrics.input += tokens.input;
+  modelStats.metrics.output += tokens.output;
+  modelStats.metrics.reasoning += tokens.reasoning;
+  modelStats.metrics.cacheRead += tokens.cacheRead;
+  modelStats.metrics.cacheWrite += tokens.cacheWrite;
+  modelStats.messageCount++;
+  
+  logToApp("debug", "Tokens updated", { totalInput: session.total.input, totalOutput: session.total.output })
+}
+
+export function getAllSessions(): SessionUsage[] {
+  const sessions = Array.from(state.sessions.values());
+  logToApp("debug", "Returning total sessions", { count: sessions.length })
+  return sessions;
+}

package/lib/tracking/types.ts

@@ -0,0 +1,30 @@
+export interface TokenMetrics {
+  input: number;
+  output: number;
+  reasoning: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+export interface ModelStats {
+  provider: string;
+  model: string;
+  metrics: TokenMetrics;
+  messageCount: number;
+}
+
+export interface SessionUsage {
+  sessionID: string;
+  total: TokenMetrics;
+  byModel: Map<string, ModelStats>;
+}
+
+export interface UsageState {
+  sessions: Map<string, SessionUsage>;
+  currentSessionID: string | null;
+}
+
+export const state: UsageState = {
+  sessions: new Map(),
+  currentSessionID: null,
+};

package/lib/usage-handler.ts

@@ -1,5 +1,7 @@
 import { sendIgnoredMessage } from "./shared/notification";
+import { getCurrentSession, getAllSessions } from "./tracking/tracker";
 import { registry } from "./providers/registry";
+import { boxHeader } from "./shared/utils";
 
 interface UsageContext {
   client: any;
@@ -9,47 +11,183 @@ interface UsageContext {
 
 /**
  * Main handler for the /usage command
- * Fetches data from all registered providers and displays to user
+ * Shows provider usage data and token usage tracked from message events
  */
 export async function handleUsageCommand(ctx: UsageContext): Promise<void> {
   const { client, sessionID, params } = ctx;
 
-  // Gets all registered providers
-  const providers = registry.getAll();
-
-  // Fetches data from all providers in parallel
-  const results = await Promise.all(
-    providers.map(async (provider) => {
-      try {
-        const result = await provider.getUsageData();
-        if (result && result.content) {
-          return {
-            provider: provider.name,
-            content: result.content,
-          };
+  try {
+    let output = "";
+
+    // Fetch provider data (Copilot, Claude, Z.ai)
+    const providers = registry.getAll();
+    const providerResults = await Promise.all(
+      providers.map(async (provider) => {
+        try {
+          const result = await provider.getUsageData();
+          if (result && result.content) {
+            return {
+              provider: provider.name,
+              content: result.content,
+            };
+          }
+          return null;
+        } catch (error) {
+          console.error(`[${provider.name} Error]`, error);
+          return null;
+        }
+      }),
+    );
+
+    const validProviderResults = providerResults.filter(
+      (r): r is { provider: string; content: string } => r !== null,
+    );
+
+    // Add provider data if available
+    if (validProviderResults.length > 0) {
+      output += validProviderResults.map((r) => r.content).join("\n\n");
+      output += "\n";
+    }
+
+    // Fetch and add token tracking data
+    const current = getCurrentSession();
+    const allSessions = getAllSessions();
+
+    if (allSessions.length === 0) {
+      if (validProviderResults.length === 0) {
+        output = "No usage data available yet.\nConfigure providers or start a conversation to track token usage.";
+      } else {
+        output += "\nNo token usage data available yet.\nStart a conversation to track token usage.";
+      }
+    } else {
+      if (current) {
+        output += formatSession(current, "Current Session");
+      } else {
+        output += "No active session.\n";
+      }
+
+      if (allSessions.length > 1) {
+        output += formatAllSessions(allSessions, "All Sessions");
+      }
+    }
+
+    await sendIgnoredMessage(client, sessionID, output);
+  } catch (error) {
+    console.error("Error in handleUsageCommand:", error);
+  }
+}
+
+function formatSession(session: any, title: string): string {
+  const { total, byModel } = session;
+
+  let output = `\n${boxHeader(title, 80)}\n`;
+
+  const totalTokens =
+    total.input + total.output + total.reasoning + total.cacheRead + total.cacheWrite;
+  output += `  Total Tokens:    ${formatNumber(totalTokens)}\n`;
+
+  const messageCount =
+    byModel.size > 0
+      ? Array.from(byModel.values()).reduce((a: number, b: any) => a + b.messageCount, 0)
+      : 0;
+  output += `  Messages:        ${formatNumber(messageCount)}\n`;
+
+  if (byModel.size > 0) {
+    output += `\n  Models:\n`;
+    output += `  ${"─".repeat(76)}\n`;
+
+    const models = Array.from(byModel.values())
+      .sort((a: any, b: any) => {
+        const totalA = sumMetrics(a.metrics);
+        const totalB = sumMetrics(b.metrics);
+        return totalB - totalA;
+      });
+
+    models.forEach((modelStats: any) => {
+      const key = `${modelStats.provider}/${modelStats.model}`;
+      output += `  ${key}\n`;
+      output += `    ${formatMetricsLine(modelStats.metrics, modelStats.messageCount)}\n`;
+    });
+  }
+
+  return output;
+}
+
+function formatAllSessions(sessions: any[], title: string): string {
+  if (sessions.length <= 1) return "";
+
+  // Aggregate all sessions into a single summary
+  const aggregated = {
+    total: { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 },
+    byModel: new Map<string, any>(),
+  };
+
+  sessions.forEach((session: any) => {
+    aggregated.total.input += session.total.input;
+    aggregated.total.output += session.total.output;
+    aggregated.total.reasoning += session.total.reasoning;
+    aggregated.total.cacheRead += session.total.cacheRead;
+    aggregated.total.cacheWrite += session.total.cacheWrite;
+
+    if (session.byModel && session.byModel.size > 0) {
+      for (const [key, modelStats] of session.byModel.entries()) {
+        const existing = aggregated.byModel.get(key);
+        if (existing) {
+          existing.metrics.input += modelStats.metrics.input;
+          existing.metrics.output += modelStats.metrics.output;
+          existing.metrics.reasoning += modelStats.metrics.reasoning;
+          existing.metrics.cacheRead += modelStats.metrics.cacheRead;
+          existing.metrics.cacheWrite += modelStats.metrics.cacheWrite;
+          existing.messageCount += modelStats.messageCount;
+        } else {
+          aggregated.byModel.set(key, {
+            provider: modelStats.provider,
+            model: modelStats.model,
+            metrics: { ...modelStats.metrics },
+            messageCount: modelStats.messageCount,
+          });
         }
-        return null;
-      } catch (error) {
-        console.error(`[${provider.name} Error]`, error);
-        return null;
       }
-    }),
-  );
-
-  // Filters only providers with valid data
-  const validResults = results.filter((r): r is { provider: string; content: string } => r !== null);
-
-  // If no provider returned data, shows error message
-  if (validResults.length === 0) {
-    const message =
-      "No usage service configured.\nConfigure GitHub Copilot, Claude Code or Z.ai in your auth file.";
-    await sendIgnoredMessage(client, sessionID, message, params);
-    return;
+    }
+  });
+
+  let output = `\n${boxHeader(`${title} (${sessions.length} sessions)`, 80)}\n`;
+
+  const totalTokens =
+    aggregated.total.input + aggregated.total.output + aggregated.total.reasoning +
+    aggregated.total.cacheRead + aggregated.total.cacheWrite;
+  output += `  Total Tokens:    ${formatNumber(totalTokens)}\n`;
+
+  const messageCount = aggregated.byModel.size > 0
+    ? Array.from(aggregated.byModel.values()).reduce((a: number, b: any) => a + b.messageCount, 0)
+    : 0;
+  output += `  Messages:        ${formatNumber(messageCount)}\n`;
+
+  if (aggregated.byModel.size > 0) {
+    output += `\n  Models:\n`;
+    output += `  ${"─".repeat(76)}\n`;
+
+    const models = Array.from(aggregated.byModel.values())
+      .sort((a: any, b: any) => sumMetrics(b.metrics) - sumMetrics(a.metrics));
+
+    models.forEach((modelStats: any) => {
+      const key = `${modelStats.provider}/${modelStats.model}`;
+      output += `  ${key}\n`;
+      output += `    ${formatMetricsLine(modelStats.metrics, modelStats.messageCount)}\n`;
+    });
   }
 
-  // Joins all provider messages
-  const message = validResults.map((r) => r.content).join("\n\n");
+  return output;
+}
+
+function formatMetricsLine(metrics: any, messageCount: number): string {
+  return `In: ${formatNumber(metrics.input)}  Out: ${formatNumber(metrics.output)}  Rea: ${formatNumber(metrics.reasoning)}  Cache-Rd: ${formatNumber(metrics.cacheRead)}  Cache-Wr: ${formatNumber(metrics.cacheWrite)}  Messages: ${formatNumber(messageCount)}`;
+}
+
+function formatNumber(num: number): string {
+  return num.toLocaleString("en-US");
+}
 
-  // Sends final message to user
-  await sendIgnoredMessage(client, sessionID, message, params);
+function sumMetrics(metrics: any): number {
+  return metrics.input + metrics.output + metrics.reasoning + metrics.cacheRead + metrics.cacheWrite;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toninho09/opencode-usage",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "main": "index.ts",
   "dependencies": {