feat: add lastId to grouped console messages and match by argCount

Extend console message grouping to include lastId so that consumers
can access the last message in a group via get_console_message.
Also require argCount to match for grouping, preventing false
grouping of messages with different argument counts.

- Add lastId field to grouped output (string and JSON)
- Add argCount equality check in groupConsecutive()
- Add unit tests for grouping, toStringGrouped, toJSONGrouped

Fixes #904

Author: masamaru0513

src/McpResponse.ts

@@ -1039,16 +1039,16 @@ Call ${handleDialog.name} to handle it before continuing.`);
         structuredContent.pagination = paginationData.pagination;
         response.push(...paginationData.info);
         response.push(
-          ...paginationData.items.map(({message, count}) =>
+          ...paginationData.items.map(({message, count, lastId}) =>
             message instanceof ConsoleFormatter
-              ? message.toStringGrouped(count)
+              ? message.toStringGrouped(count, lastId)
               : message.toString(),
           ),
         );
         structuredContent.consoleMessages = paginationData.items.map(
-          ({message, count}) =>
+          ({message, count, lastId}) =>
             message instanceof ConsoleFormatter
-              ? message.toJSONGrouped(count)
+              ? message.toJSONGrouped(count, lastId)
               : message.toJSON(),
         );
       } else {

src/formatters/ConsoleFormatter.ts

@@ -35,6 +35,7 @@ interface ConsoleMessageConcise {
   argsCount: number;
   id: number;
   count?: number;
+  lastId?: number;
 }
 
 interface ConsoleMessageDetailed extends ConsoleMessageConcise {
@@ -179,10 +180,13 @@ export class ConsoleFormatter {
   }
 
   // The short format with a repeat count.
-  toStringGrouped(count: number): string {
+  toStringGrouped(count: number, lastId?: number): string {
     const json = this.toJSON();
     if (count > 1) {
       json.count = count;
+      if (lastId !== undefined) {
+        json.lastId = lastId;
+      }
     }
     return convertConsoleMessageConciseToString(json);
   }
@@ -213,24 +217,28 @@ export class ConsoleFormatter {
     };
   }
 
-  toJSONGrouped(count: number): ConsoleMessageConcise {
+  toJSONGrouped(count: number, lastId?: number): ConsoleMessageConcise {
     const json = this.toJSON();
     if (count > 1) {
       json.count = count;
+      if (lastId !== undefined) {
+        json.lastId = lastId;
+      }
     }
     return json;
   }
 
   /**
-   * Groups consecutive messages with the same type and text.
+   * Groups consecutive messages with the same type, text, and argument count.
    * Similar to Chrome DevTools' console grouping behavior.
    */
   static groupConsecutive(
     messages: Array<ConsoleFormatter | IssueFormatter>,
-  ): Array<{message: ConsoleFormatter | IssueFormatter; count: number}> {
+  ): Array<{message: ConsoleFormatter | IssueFormatter; count: number; lastId?: number}> {
     const grouped: Array<{
       message: ConsoleFormatter | IssueFormatter;
       count: number;
+      lastId?: number;
     }> = [];
     for (const msg of messages) {
       const prev = grouped[grouped.length - 1];
@@ -239,9 +247,11 @@ export class ConsoleFormatter {
         prev.message instanceof ConsoleFormatter &&
         msg instanceof ConsoleFormatter &&
         prev.message.#type === msg.#type &&
-        prev.message.#text === msg.#text
+        prev.message.#text === msg.#text &&
+        prev.message.#argCount === msg.#argCount
       ) {
         prev.count++;
+        prev.lastId = msg.#id;
       } else {
         grouped.push({message: msg, count: 1});
       }
@@ -264,7 +274,9 @@ export class ConsoleFormatter {
 }
 
 function convertConsoleMessageConciseToString(msg: ConsoleMessageConcise) {
-  const countSuffix = msg.count && msg.count > 1 ? ` [${msg.count} times]` : '';
+  const countSuffix = msg.count && msg.count > 1
+    ? ` [${msg.count} times${msg.lastId ? `, last msgid=${msg.lastId}` : ''}]`
+    : '';
   return `msgid=${msg.id} [${msg.type}] ${msg.text} (${msg.argsCount} args)${countSuffix}`;
 }
 

tests/formatters/ConsoleFormatterGrouping.test.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
+
+import {ConsoleFormatter} from '../../src/formatters/ConsoleFormatter.js';
+import type {ConsoleMessage} from '../../src/third_party/index.js';
+
+const createMockMessage = (
+  type: string,
+  text: string,
+  argsCount = 0,
+): ConsoleMessage => {
+  const args = Array.from({length: argsCount}, () => ({
+    jsonValue: async () => 'val',
+    remoteObject: () => ({type: 'string'}),
+  }));
+  return {
+    type: () => type,
+    text: () => text,
+    args: () => args,
+  } as unknown as ConsoleMessage;
+};
+
+const makeFormatter = (id: number, type: string, text: string, argsCount = 0) =>
+  ConsoleFormatter.from(createMockMessage(type, text, argsCount), {id});
+
+describe('ConsoleFormatter grouping', () => {
+  describe('groupConsecutive', () => {
+    it('groups identical consecutive messages', async () => {
+      const msgs = await Promise.all([
+        makeFormatter(1, 'log', 'hello'),
+        makeFormatter(2, 'log', 'hello'),
+        makeFormatter(3, 'log', 'hello'),
+      ]);
+      const grouped = ConsoleFormatter.groupConsecutive(msgs);
+      assert.strictEqual(grouped.length, 1);
+      assert.strictEqual(grouped[0].count, 3);
+      assert.strictEqual(grouped[0].lastId, 3);
+    });
+
+    it('does not group different messages', async () => {
+      const msgs = await Promise.all([
+        makeFormatter(1, 'log', 'aaa'),
+        makeFormatter(2, 'log', 'bbb'),
+        makeFormatter(3, 'log', 'ccc'),
+      ]);
+      const grouped = ConsoleFormatter.groupConsecutive(msgs);
+      assert.strictEqual(grouped.length, 3);
+      for (const g of grouped) {
+        assert.strictEqual(g.count, 1);
+        assert.strictEqual(g.lastId, undefined);
+      }
+    });
+
+    it('groups A,A,B,A,A correctly', async () => {
+      const msgs = await Promise.all([
+        makeFormatter(1, 'log', 'A'),
+        makeFormatter(2, 'log', 'A'),
+        makeFormatter(3, 'log', 'B'),
+        makeFormatter(4, 'log', 'A'),
+        makeFormatter(5, 'log', 'A'),
+      ]);
+      const grouped = ConsoleFormatter.groupConsecutive(msgs);
+      assert.strictEqual(grouped.length, 3);
+      assert.strictEqual(grouped[0].count, 2);
+      assert.strictEqual(grouped[0].lastId, 2);
+      assert.strictEqual(grouped[1].count, 1);
+      assert.strictEqual(grouped[1].lastId, undefined);
+      assert.strictEqual(grouped[2].count, 2);
+      assert.strictEqual(grouped[2].lastId, 5);
+    });
+
+    it('does not group messages with different types', async () => {
+      const msgs = await Promise.all([
+        makeFormatter(1, 'log', 'hello'),
+        makeFormatter(2, 'error', 'hello'),
+      ]);
+      const grouped = ConsoleFormatter.groupConsecutive(msgs);
+      assert.strictEqual(grouped.length, 2);
+    });
+
+    it('does not group messages with different argsCount', async () => {
+      const msgs = await Promise.all([
+        makeFormatter(1, 'log', 'hello', 1),
+        makeFormatter(2, 'log', 'hello', 2),
+      ]);
+      const grouped = ConsoleFormatter.groupConsecutive(msgs);
+      assert.strictEqual(grouped.length, 2);
+    });
+
+    it('returns empty array for empty input', () => {
+      const grouped = ConsoleFormatter.groupConsecutive([]);
+      assert.strictEqual(grouped.length, 0);
+    });
+
+    it('handles single message', async () => {
+      const msgs = await Promise.all([makeFormatter(1, 'log', 'solo')]);
+      const grouped = ConsoleFormatter.groupConsecutive(msgs);
+      assert.strictEqual(grouped.length, 1);
+      assert.strictEqual(grouped[0].count, 1);
+      assert.strictEqual(grouped[0].lastId, undefined);
+    });
+  });
+
+  describe('toStringGrouped', () => {
+    it('appends count and lastId suffix when count > 1', async () => {
+      const f = await makeFormatter(1, 'log', 'hello');
+      const str = f.toStringGrouped(5, 5);
+      assert.ok(str.includes('[5 times, last msgid=5]'), `expected [5 times, last msgid=5] in: ${str}`);
+    });
+
+    it('does not append count suffix when count is 1', async () => {
+      const f = await makeFormatter(1, 'log', 'hello');
+      const str = f.toStringGrouped(1);
+      assert.ok(!str.includes('times'), `unexpected times in: ${str}`);
+    });
+  });
+
+  describe('toJSONGrouped', () => {
+    it('includes count and lastId when count > 1', async () => {
+      const f = await makeFormatter(1, 'log', 'hello');
+      const json = f.toJSONGrouped(3, 3);
+      assert.strictEqual(json.count, 3);
+      assert.strictEqual(json.lastId, 3);
+    });
+
+    it('does not include count or lastId when count is 1', async () => {
+      const f = await makeFormatter(1, 'log', 'hello');
+      const json = f.toJSONGrouped(1);
+      assert.strictEqual(json.count, undefined);
+      assert.strictEqual(json.lastId, undefined);
+    });
+  });
+});