feat: add usage tracking per model and update exit summary display

Author: qorzj

src/session.ts

@@ -72,6 +72,29 @@ function accumulateUsage(current: ModelUsage | null, next: unknown | null | unde
   return addUsageValue(current, next) as ModelUsage;
 }
 
+function usageWithRequestCount(usage: ModelUsage): ModelUsage {
+  const totalReqs = typeof usage.total_reqs === "number" ? usage.total_reqs + 1 : 1;
+  return {
+    ...usage,
+    total_reqs: totalReqs,
+  };
+}
+
+function accumulateUsagePerModel(
+  current: Record<string, ModelUsage> | null | undefined,
+  model: string,
+  next: ModelUsage | null | undefined
+): Record<string, ModelUsage> | null {
+  if (next == null) {
+    return current ?? null;
+  }
+
+  const usagePerModel = { ...(current ?? {}) };
+  const modelName = model.trim() || "unknown";
+  usagePerModel[modelName] = accumulateUsage(usagePerModel[modelName] ?? null, usageWithRequestCount(next))!;
+  return usagePerModel;
+}
+
 function getExtensionRoot(): string {
   if (typeof __dirname !== "undefined") {
     return path.resolve(__dirname, "..");
@@ -112,6 +135,7 @@ export type SessionEntry = {
   status: SessionStatus;
   failReason: string | null;
   usage: ModelUsage | null;
+  usagePerModel: Record<string, ModelUsage> | null;
   activeTokens: number;
   createTime: string;
   updateTime: string;
@@ -847,6 +871,7 @@ The candidate skills are as follows:\n\n`;
       status: "pending",
       failReason: null,
       usage: null,
+      usagePerModel: null,
       activeTokens: 0,
       createTime: now,
       updateTime: now,
@@ -1087,6 +1112,7 @@ ${skillMd}
           assistantRefusal: refusal,
           toolCalls,
           usage: accumulateUsage(entry.usage, responseUsage),
+          usagePerModel: accumulateUsagePerModel(entry.usagePerModel, model, responseUsage),
           activeTokens: getTotalTokens(responseUsage),
           status: refusal ? "failed" : waitingForUser ? "waiting_for_user" : toolCalls ? "processing" : "completed",
           failReason: refusal ? refusal : entry.failReason,
@@ -1196,6 +1222,7 @@ ${skillMd}
     this.updateSessionEntry(sessionId, (entry) => ({
       ...entry,
       usage: accumulateUsage(entry.usage, responseUsage),
+      usagePerModel: accumulateUsagePerModel(entry.usagePerModel, model, responseUsage),
       activeTokens: getTotalTokens(responseUsage),
       updateTime: now,
     }));
@@ -2108,6 +2135,7 @@ ${skillMd}
       status: this.normalizeSessionStatus(value.status),
       failReason: typeof value.failReason === "string" ? value.failReason : null,
       usage: (value.usage as ModelUsage) ?? null,
+      usagePerModel: this.normalizeUsagePerModel(value),
       activeTokens: typeof value.activeTokens === "number" ? value.activeTokens : 0,
       createTime: typeof value.createTime === "string" ? value.createTime : new Date().toISOString(),
       updateTime: typeof value.updateTime === "string" ? value.updateTime : new Date().toISOString(),
@@ -2129,6 +2157,23 @@ ${skillMd}
     return "pending";
   }
 
+  private normalizeUsagePerModel(entry: Record<string, unknown>): Record<string, ModelUsage> | null {
+    if (!Object.prototype.hasOwnProperty.call(entry, "usagePerModel")) {
+      return null;
+    }
+    if (!isUsageRecord(entry.usagePerModel)) {
+      return null;
+    }
+    const usagePerModel: Record<string, ModelUsage> = {};
+    for (const [model, usage] of Object.entries(entry.usagePerModel)) {
+      if (!model || !isUsageRecord(usage)) {
+        continue;
+      }
+      usagePerModel[model] = usage as ModelUsage;
+    }
+    return usagePerModel;
+  }
+
   private deserializeProcesses(value: unknown): Map<string, { startTime: string; command: string }> | null {
     if (!value || typeof value !== "object") {
       return null;

src/tests/exitSummary.test.ts

@@ -1,22 +1,23 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { buildExitSummaryText } from "../ui";
-import type { SessionEntry, SessionMessage, ModelUsage } from "../session";
+import type { ModelUsage, SessionEntry } from "../session";
 
 const stripAnsi = (text: string): string => text.replace(/\u001b\[[0-9;]*m/g, "");
 
 test("buildExitSummaryText only shows Goodbye and model usage with cached tokens", () => {
   const summary = stripAnsi(
     buildExitSummaryText({
-      session: buildSession({
-        prompt_tokens: 11_966,
-        completion_tokens: 236,
-        total_tokens: 12_202,
-        prompt_tokens_details: { cached_tokens: 11_776 },
-        completion_tokens_details: { reasoning_tokens: 144 },
+      session: buildSession(null, {
+        "mimo-v2.5-pro": {
+          prompt_tokens: 11_966,
+          completion_tokens: 236,
+          total_tokens: 12_202,
+          prompt_tokens_details: { cached_tokens: 11_776 },
+          completion_tokens_details: { reasoning_tokens: 144 },
+          total_reqs: 2,
+        },
       }),
-      messages: [buildAssistantMessage("assistant-1"), buildAssistantMessage("assistant-2")],
-      model: "mimo-v2.5-pro",
     })
   );
 
@@ -33,7 +34,63 @@ test("buildExitSummaryText only shows Goodbye and model usage with cached tokens
   assert.doesNotMatch(summary, /Reasoning Tokens/);
 });
 
-function buildSession(usage: ModelUsage | null): SessionEntry {
+test("buildExitSummaryText shows all usagePerModel rows sorted by request count", () => {
+  const summary = stripAnsi(
+    buildExitSummaryText({
+      session: buildSession(
+        {
+          prompt_tokens: 999,
+          completion_tokens: 999,
+          total_tokens: 1_998,
+        },
+        {
+          "deepseek-v4-pro": {
+            prompt_tokens: 100,
+            completion_tokens: 10,
+            total_tokens: 110,
+            total_reqs: 1,
+          },
+          "deepseek-v4-flash": {
+            prompt_tokens: 300,
+            completion_tokens: 30,
+            total_tokens: 330,
+            prompt_cache_hit_tokens: 111,
+            total_reqs: 3,
+          },
+        }
+      ),
+    })
+  );
+
+  const flashIndex = summary.indexOf("deepseek-v4-flash");
+  const proIndex = summary.indexOf("deepseek-v4-pro");
+
+  assert.notEqual(flashIndex, -1);
+  assert.notEqual(proIndex, -1);
+  assert.ok(flashIndex < proIndex);
+  assert.match(summary, /deepseek-v4-flash\s+3\s+300\s+30\s+111/);
+  assert.match(summary, /deepseek-v4-pro\s+1\s+100\s+10\s+0/);
+  assert.doesNotMatch(summary, /999/);
+});
+
+test("buildExitSummaryText does not derive usage rows from legacy aggregate usage", () => {
+  const summary = stripAnsi(
+    buildExitSummaryText({
+      session: buildSession({
+        prompt_tokens: 11_966,
+        completion_tokens: 236,
+        total_tokens: 12_202,
+        total_reqs: 2,
+      }),
+    })
+  );
+
+  assert.match(summary, /Goodbye!/);
+  assert.doesNotMatch(summary, /Model Usage/);
+  assert.doesNotMatch(summary, /11,966/);
+});
+
+function buildSession(usage: ModelUsage | null, usagePerModel: Record<string, ModelUsage> | null = null): SessionEntry {
   return {
     id: "session-1",
     summary: null,
@@ -44,24 +101,10 @@ function buildSession(usage: ModelUsage | null): SessionEntry {
     status: "completed",
     failReason: null,
     usage,
+    usagePerModel,
     activeTokens: 0,
     createTime: "2026-01-01T00:00:00.000Z",
     updateTime: "2026-01-01T00:00:01.000Z",
     processes: null,
   };
 }
-
-function buildAssistantMessage(id: string): SessionMessage {
-  return {
-    id,
-    sessionId: "session-1",
-    role: "assistant",
-    content: "",
-    contentParams: null,
-    messageParams: null,
-    compacted: false,
-    visible: true,
-    createTime: "2026-01-01T00:00:00.000Z",
-    updateTime: "2026-01-01T00:00:00.000Z",
-  };
-}

src/tests/session.test.ts

@@ -275,6 +275,20 @@ test("SessionManager normalizes legacy sessions without activeTokens to zero", (
   const manager = createSessionManager(workspace, "machine-id-legacy");
 
   assert.equal(manager.getSession("legacy-session")?.activeTokens, 0);
+  assert.equal(manager.getSession("legacy-session")?.usagePerModel, null);
+});
+
+test("SessionManager keeps usagePerModel null until response usage is available", async () => {
+  const workspace = createTempDir("deepcode-null-usage-per-model-workspace-");
+  const home = createTempDir("deepcode-null-usage-per-model-home-");
+  process.env.HOME = home;
+
+  const manager = createMockedClientSessionManager(workspace, [{ choices: [{ message: { content: "no usage" } }] }]);
+
+  const sessionId = await manager.createSession({ text: "" });
+
+  assert.equal(manager.getSession(sessionId)?.usage, null);
+  assert.equal(manager.getSession(sessionId)?.usagePerModel, null);
 });
 
 test("SessionManager marks skills loaded from existing session messages", async () => {
@@ -1122,6 +1136,7 @@ test("SessionManager accumulates response usage while active tokens track the la
 
   const session = manager.getSession(sessionId);
   const usage = session?.usage as Record<string, any>;
+  const usagePerModel = session?.usagePerModel?.["test-model"] as Record<string, any>;
   assert.equal(session?.activeTokens, 27);
   assert.equal(usage.prompt_tokens, 30);
   assert.equal(usage.completion_tokens, 12);
@@ -1130,6 +1145,75 @@ test("SessionManager accumulates response usage while active tokens track the la
   assert.equal(usage.completion_tokens_details.reasoning_tokens, 7);
   assert.equal(usage.prompt_cache_hit_tokens, 18);
   assert.equal(usage.prompt_cache_miss_tokens, 12);
+  assert.equal(usagePerModel.prompt_tokens, 30);
+  assert.equal(usagePerModel.completion_tokens, 12);
+  assert.equal(usagePerModel.total_tokens, 42);
+  assert.equal(usagePerModel.prompt_tokens_details.cached_tokens, 18);
+  assert.equal(usagePerModel.completion_tokens_details.reasoning_tokens, 7);
+  assert.equal(usagePerModel.prompt_cache_hit_tokens, 18);
+  assert.equal(usagePerModel.prompt_cache_miss_tokens, 12);
+  assert.equal(usagePerModel.total_reqs, 2);
+});
+
+test("SessionManager stores usage per model across model changes", async () => {
+  const workspace = createTempDir("deepcode-usage-per-model-workspace-");
+  const home = createTempDir("deepcode-usage-per-model-home-");
+  process.env.HOME = home;
+
+  let currentModel = "deepseek-v4-pro";
+  const responses = [
+    createChatResponse("pro response", {
+      prompt_tokens: 10,
+      completion_tokens: 5,
+      total_tokens: 15,
+    }),
+    createChatResponse("flash response", {
+      prompt_tokens: 20,
+      completion_tokens: 7,
+      total_tokens: 27,
+      prompt_cache_hit_tokens: 6,
+    }),
+  ];
+  const client = {
+    chat: {
+      completions: {
+        create: async () => {
+          const response = responses.shift();
+          assert.ok(response, "expected a queued chat response");
+          return response;
+        },
+      },
+    },
+  };
+  const manager = new SessionManager({
+    projectRoot: workspace,
+    createOpenAIClient: () => ({
+      client: client as any,
+      model: currentModel,
+      baseURL: "https://api.deepseek.com",
+      thinkingEnabled: false,
+    }),
+    getResolvedSettings: () => ({ model: currentModel }),
+    renderMarkdown: (text) => text,
+    onAssistantMessage: () => {},
+  });
+
+  const sessionId = await manager.createSession({ text: "" });
+  currentModel = "deepseek-v4-flash";
+  await manager.replySession(sessionId, { text: "" });
+
+  const session = manager.getSession(sessionId);
+  assert.deepEqual(Object.keys(session?.usagePerModel ?? {}).sort(), ["deepseek-v4-flash", "deepseek-v4-pro"]);
+  assert.equal(session?.usagePerModel?.["deepseek-v4-pro"]?.prompt_tokens, 10);
+  assert.equal(session?.usagePerModel?.["deepseek-v4-pro"]?.completion_tokens, 5);
+  assert.equal(session?.usagePerModel?.["deepseek-v4-pro"]?.total_reqs, 1);
+  assert.equal(session?.usagePerModel?.["deepseek-v4-flash"]?.prompt_tokens, 20);
+  assert.equal(session?.usagePerModel?.["deepseek-v4-flash"]?.completion_tokens, 7);
+  assert.equal(session?.usagePerModel?.["deepseek-v4-flash"]?.prompt_cache_hit_tokens, 6);
+  assert.equal(session?.usagePerModel?.["deepseek-v4-flash"]?.total_reqs, 1);
+  assert.equal(session?.usage?.prompt_tokens, 30);
+  assert.equal(session?.usage?.completion_tokens, 12);
+  assert.equal(session?.usage?.total_tokens, 42);
 });
 
 test("SessionManager resets active tokens to latest post-compaction response usage", async () => {
@@ -1163,10 +1247,15 @@ test("SessionManager resets active tokens to latest post-compaction response usa
 
   const session = manager.getSession(sessionId);
   const usage = session?.usage as Record<string, any>;
+  const usagePerModel = session?.usagePerModel?.["test-model"] as Record<string, any>;
   assert.equal(session?.activeTokens, 7);
   assert.equal(usage.prompt_tokens, 140_095);
   assert.equal(usage.completion_tokens, 35);
   assert.equal(usage.total_tokens, 140_130);
+  assert.equal(usagePerModel.prompt_tokens, 140_095);
+  assert.equal(usagePerModel.completion_tokens, 35);
+  assert.equal(usagePerModel.total_tokens, 140_130);
+  assert.equal(usagePerModel.total_reqs, 3);
 });
 
 test("SessionManager streams chat completions and counts reasoning progress", async () => {

src/ui/App.tsx

@@ -148,11 +148,7 @@ export function App({ projectRoot, version = "", onRestart }: AppProps): React.R
         setTimeout(() => {
           const activeSessionId = sessionManager.getActiveSessionId();
           const session = activeSessionId ? sessionManager.getSession(activeSessionId) : null;
-          const allMessages = activeSessionId
-            ? sessionManager.listSessionMessages(activeSessionId)
-            : messagesRef.current;
-          const resolved = resolveCurrentSettings(projectRoot);
-          const summary = buildExitSummaryText({ session, messages: allMessages, model: resolved.model });
+          const summary = buildExitSummaryText({ session });
           process.stdout.write("\n");
           process.stdout.write(chalk.green("> /exit "));
           process.stdout.write("\n\n");
@@ -256,7 +252,7 @@ export function App({ projectRoot, version = "", onRestart }: AppProps): React.R
         setRunningProcesses(null);
       }
     },
-    [exit, onRestart, projectRoot, sessionManager, refreshSkills, refreshSessionsList]
+    [exit, onRestart, sessionManager, refreshSkills, refreshSessionsList]
   );
 
   const handleInterrupt = useCallback(() => {