fix(client): paginate tools listChanged refresh

Author: mattzcarey

packages/client/src/client/client.ts

@@ -264,8 +264,7 @@ export class Client extends Protocol<ClientContext> {
     private _setupListChangedHandlers(config: ListChangedHandlers): void {
         if (config.tools && this._serverCapabilities?.tools?.listChanged) {
             this._setupListChangedHandler('tools', 'notifications/tools/list_changed', config.tools, async () => {
-                const result = await this.listTools();
-                return result.tools;
+                return this._listAllTools();
             });
         }
 
@@ -284,6 +283,19 @@ export class Client extends Protocol<ClientContext> {
         }
     }
 
+    private async _listAllTools(): Promise<Tool[]> {
+        const tools: Tool[] = [];
+        let cursor: string | undefined;
+
+        do {
+            const result = await this.listTools(cursor === undefined ? undefined : { cursor });
+            tools.push(...result.tools);
+            cursor = result.nextCursor;
+        } while (cursor !== undefined);
+
+        return tools;
+    }
+
     /**
      * Registers new capabilities. This can only be called before connecting to a transport.
      *

test/integration/test/client/client.test.ts

@@ -1945,15 +1945,25 @@ describe('outputSchema validation', () => {
      * or the use of other tools (SEP-2106 safety-guard isolation).
      */
     test('preserves outputSchema validation metadata across paginated tool listings', async () => {
-        const server = new Server({ name: 'test-server', version: '1.0.0' }, { capabilities: { tools: {} } });
+        const server = new Server({ name: 'test-server', version: '1.0.0' }, { capabilities: { tools: { listChanged: true } } });
+        const listRequests: Array<string | undefined> = [];
+        const listChangedNotifications: Array<[Error | null, Tool[] | null]> = [];
+        let resolveListChangedNotification: () => void = () => {};
+        const listChangedNotification = new Promise<void>(resolve => {
+            resolveListChangedNotification = resolve;
+        });
+        let lastPageToolReturnsInvalid = false;
+        let lastPageBadToolCalled = false;
 
         server.setRequestHandler('initialize', async request => ({
             protocolVersion: request.params.protocolVersion,
-            capabilities: { tools: {} },
+            capabilities: { tools: { listChanged: true } },
             serverInfo: { name: 'test-server', version: '1.0.0' }
         }));
 
         server.setRequestHandler('tools/list', async request => {
+            listRequests.push(request.params?.cursor);
+
             if (request.params?.cursor === 'page-2') {
                 return {
                     tools: [
@@ -1962,6 +1972,12 @@ describe('outputSchema validation', () => {
                             description: 'a tool on the final page',
                             inputSchema: { type: 'object', properties: {} },
                             outputSchema: { type: 'object', properties: { ok: { type: 'boolean' } }, required: ['ok'] }
+                        },
+                        {
+                            name: 'last-page-bad-tool',
+                            description: 'a final-page tool with an outputSchema the SEP-2106 guard rejects',
+                            inputSchema: { type: 'object', properties: {} },
+                            outputSchema: { $ref: 'https://evil.example/final-page-schema.json' }
                         }
                     ]
                 };
@@ -1989,23 +2005,40 @@ describe('outputSchema validation', () => {
 
         server.setRequestHandler('tools/call', async request => {
             if (request.params.name === 'last-page-tool') {
-                return { content: [], structuredContent: { ok: true } };
+                return { content: [], structuredContent: { ok: lastPageToolReturnsInvalid ? 'not-a-boolean' : true } };
+            }
+            if (request.params.name === 'last-page-bad-tool') {
+                lastPageBadToolCalled = true;
+                return { content: [], structuredContent: { irrelevant: true } };
             }
             if (request.params.name === 'validated-tool') {
                 return { content: [], structuredContent: { ok: 'not-a-boolean' } };
             }
             return { content: [], structuredContent: { irrelevant: true } };
         });
 
-        const client = new Client({ name: 'test-client', version: '1.0.0' });
+        const client = new Client(
+            { name: 'test-client', version: '1.0.0' },
+            {
+                listChanged: {
+                    tools: {
+                        debounceMs: 0,
+                        onChanged: (error, tools) => {
+                            listChangedNotifications.push([error, tools]);
+                            resolveListChangedNotification();
+                        }
+                    }
+                }
+            }
+        );
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
         await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
 
         // listTools() must NOT reject just because one tool's schema is uncompilable.
         const firstPage = await client.listTools();
         expect(firstPage.tools.map(t => t.name).toSorted()).toEqual(['bad-tool', 'validated-tool']);
         const secondPage = await client.listTools({ cursor: firstPage.nextCursor });
-        expect(secondPage.tools.map(t => t.name)).toEqual(['last-page-tool']);
+        expect(secondPage.tools.map(t => t.name).toSorted()).toEqual(['last-page-bad-tool', 'last-page-tool']);
 
         // The final page's tool is fully usable.
         const lastPage = await client.callTool({ name: 'last-page-tool' });
@@ -2016,6 +2049,30 @@ describe('outputSchema validation', () => {
 
         // An earlier-page schema compile error also survives pagination and is scoped to that tool.
         await expect(client.callTool({ name: 'bad-tool' })).rejects.toThrow(/output schema that could not be compiled/i);
+
+        // A final-page schema compile error also survives pagination and is scoped to that tool.
+        await expect(client.callTool({ name: 'last-page-bad-tool' })).rejects.toThrow(/output schema that could not be compiled/i);
+        expect(lastPageBadToolCalled).toBe(false);
+
+        listRequests.length = 0;
+        lastPageToolReturnsInvalid = true;
+        await server.notification({ method: 'notifications/tools/list_changed' });
+        await listChangedNotification;
+
+        expect(listRequests).toEqual([undefined, 'page-2']);
+        expect(listChangedNotifications).toHaveLength(1);
+        expect(listChangedNotifications[0]![0]).toBeNull();
+        expect(listChangedNotifications[0]![1]?.map(t => t.name).toSorted()).toEqual([
+            'bad-tool',
+            'last-page-bad-tool',
+            'last-page-tool',
+            'validated-tool'
+        ]);
+
+        await expect(client.callTool({ name: 'last-page-tool' })).rejects.toThrow(/Structured content does not match/);
+        lastPageBadToolCalled = false;
+        await expect(client.callTool({ name: 'last-page-bad-tool' })).rejects.toThrow(/output schema that could not be compiled/i);
+        expect(lastPageBadToolCalled).toBe(false);
     });
 
     /***