fix(client): paginate prompt and resource list refresh

Author: mattzcarey

packages/client/src/client/client.ts

@@ -24,9 +24,11 @@ import type {
     MessageExtraInfo,
     NotificationMethod,
     ProtocolOptions,
+    Prompt,
     ReadResourceRequest,
     RequestMethod,
     RequestOptions,
+    Resource,
     Result,
     ServerCapabilities,
     SubscribeRequest,
@@ -270,15 +272,13 @@ export class Client extends Protocol<ClientContext> {
 
         if (config.prompts && this._serverCapabilities?.prompts?.listChanged) {
             this._setupListChangedHandler('prompts', 'notifications/prompts/list_changed', config.prompts, async () => {
-                const result = await this.listPrompts();
-                return result.prompts;
+                return this._listAllPrompts();
             });
         }
 
         if (config.resources && this._serverCapabilities?.resources?.listChanged) {
             this._setupListChangedHandler('resources', 'notifications/resources/list_changed', config.resources, async () => {
-                const result = await this.listResources();
-                return result.resources;
+                return this._listAllResources();
             });
         }
     }
@@ -296,6 +296,32 @@ export class Client extends Protocol<ClientContext> {
         return tools;
     }
 
+    private async _listAllPrompts(): Promise<Prompt[]> {
+        const prompts: Prompt[] = [];
+        let cursor: string | undefined;
+
+        do {
+            const result = await this.listPrompts(cursor === undefined ? undefined : { cursor });
+            prompts.push(...result.prompts);
+            cursor = result.nextCursor;
+        } while (cursor !== undefined);
+
+        return prompts;
+    }
+
+    private async _listAllResources(): Promise<Resource[]> {
+        const resources: Resource[] = [];
+        let cursor: string | undefined;
+
+        do {
+            const result = await this.listResources(cursor === undefined ? undefined : { cursor });
+            resources.push(...result.resources);
+            cursor = result.nextCursor;
+        } while (cursor !== undefined);
+
+        return resources;
+    }
+
     /**
      * Registers new capabilities. This can only be called before connecting to a transport.
      *

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

@@ -1411,6 +1411,94 @@ test('should handle resource list changed notification with auto refresh', async
     expect(notifications[0]![1]?.[1]!.name).toBe('test-resource');
 });
 
+test('should auto-refresh all paginated prompts after prompt list changed notification', async () => {
+    const server = new Server({ name: 'test-server', version: '1.0.0' }, { capabilities: { prompts: { listChanged: true } } });
+    const listRequests: Array<string | undefined> = [];
+    const notifications: [Error | null, Prompt[] | null][] = [];
+    let resolveNotification: () => void = () => {};
+    const notification = new Promise<void>(resolve => {
+        resolveNotification = resolve;
+    });
+
+    server.setRequestHandler('prompts/list', async request => {
+        listRequests.push(request.params?.cursor);
+        if (request.params?.cursor === 'page-2') {
+            return { prompts: [{ name: 'prompt-2', description: 'second page' }] };
+        }
+        return { prompts: [{ name: 'prompt-1', description: 'first page' }], nextCursor: 'page-2' };
+    });
+
+    const client = new Client(
+        { name: 'test-client', version: '1.0.0' },
+        {
+            listChanged: {
+                prompts: {
+                    debounceMs: 0,
+                    onChanged: (error, prompts) => {
+                        notifications.push([error, prompts]);
+                        resolveNotification();
+                    }
+                }
+            }
+        }
+    );
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
+
+    await server.notification({ method: 'notifications/prompts/list_changed' });
+    await notification;
+
+    expect(listRequests).toEqual([undefined, 'page-2']);
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0]![0]).toBeNull();
+    expect(notifications[0]![1]?.map(prompt => prompt.name)).toEqual(['prompt-1', 'prompt-2']);
+});
+
+test('should auto-refresh all paginated resources after resource list changed notification', async () => {
+    const server = new Server({ name: 'test-server', version: '1.0.0' }, { capabilities: { resources: { listChanged: true } } });
+    const listRequests: Array<string | undefined> = [];
+    const notifications: [Error | null, Resource[] | null][] = [];
+    let resolveNotification: () => void = () => {};
+    const notification = new Promise<void>(resolve => {
+        resolveNotification = resolve;
+    });
+
+    server.setRequestHandler('resources/list', async request => {
+        listRequests.push(request.params?.cursor);
+        if (request.params?.cursor === 'page-2') {
+            return { resources: [{ name: 'resource-2', uri: 'file:///resource-2.txt' }] };
+        }
+        return { resources: [{ name: 'resource-1', uri: 'file:///resource-1.txt' }], nextCursor: 'page-2' };
+    });
+
+    const client = new Client(
+        { name: 'test-client', version: '1.0.0' },
+        {
+            listChanged: {
+                resources: {
+                    debounceMs: 0,
+                    onChanged: (error, resources) => {
+                        notifications.push([error, resources]);
+                        resolveNotification();
+                    }
+                }
+            }
+        }
+    );
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
+
+    await server.notification({ method: 'notifications/resources/list_changed' });
+    await notification;
+
+    expect(listRequests).toEqual([undefined, 'page-2']);
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0]![0]).toBeNull();
+    expect(notifications[0]![1]?.map(resource => resource.name)).toEqual(['resource-1', 'resource-2']);
+});
+
 /***
  * Test: Handle Multiple List Changed Handlers
  */