Added auto-refreshing tool list notification handler to client

Added handler for server's notifications/tools/list_changed notification
Implemented auto-refresh for tools list when notification is received
Added onToolListChanged callback property to provide updated tools to clients
Added setToolListChangedCallback convenience method for callback registration
Added capability validation to ensure tools support before refreshing
Fixed type definitions for proper TypeScript compliance
Added error handling for failed refreshes

Author: johnjjung

Diff for: src/client/index.ts

@@ -28,6 +28,7 @@ import {
   ListResourceTemplatesRequest,
   ListResourceTemplatesResultSchema,
   ListToolsRequest,
+  ListToolsResult,
   ListToolsResultSchema,
   LoggingLevel,
   Notification,
@@ -76,7 +77,7 @@ export type ClientOptions = ProtocolOptions & {
 export class Client<
   RequestT extends Request = Request,
   NotificationT extends Notification = Notification,
-  ResultT extends Result = Result,
+  ResultT extends Result = Result
 > extends Protocol<
   ClientRequest | RequestT,
   ClientNotification | NotificationT,
@@ -87,15 +88,38 @@ export class Client<
   private _capabilities: ClientCapabilities;
   private _instructions?: string;
 
+  /**
+   * Callback for when the server indicates that the tools list has changed.
+   * Client should typically refresh its list of tools in response.
+   */
+  onToolListChanged?: (tools?: ListToolsResult["tools"]) => void;
+
   /**
    * Initializes this client with the given name and version information.
    */
-  constructor(
-    private _clientInfo: Implementation,
-    options?: ClientOptions,
-  ) {
+  constructor(private _clientInfo: Implementation, options?: ClientOptions) {
     super(options);
     this._capabilities = options?.capabilities ?? {};
+
+    // Set up notification handlers
+    this.setNotificationHandler(
+      "notifications/tools/list_changed",
+      async () => {
+        // Automatically refresh the tools list when the server indicates a change
+        try {
+          // Only refresh if the server supports tools
+          if (this._serverCapabilities?.tools) {
+            const result = await this.listTools();
+            // Call the user's callback with the updated tools list
+            this.onToolListChanged?.(result.tools);
+          }
+        } catch (error) {
+          console.error("Failed to refresh tools list:", error);
+          // Still call the callback even if refresh failed
+          this.onToolListChanged?.(undefined);
+        }
+      }
+    );
   }
 
   /**
@@ -106,7 +130,7 @@ export class Client<
   public registerCapabilities(capabilities: ClientCapabilities): void {
     if (this.transport) {
       throw new Error(
-        "Cannot register capabilities after connecting to transport",
+        "Cannot register capabilities after connecting to transport"
       );
     }
 
@@ -115,11 +139,11 @@ export class Client<
 
   protected assertCapability(
     capability: keyof ServerCapabilities,
-    method: string,
+    method: string
   ): void {
     if (!this._serverCapabilities?.[capability]) {
       throw new Error(
-        `Server does not support ${capability} (required for ${method})`,
+        `Server does not support ${String(capability)} (required for ${method})`
       );
     }
   }
@@ -137,7 +161,7 @@ export class Client<
             clientInfo: this._clientInfo,
           },
         },
-        InitializeResultSchema,
+        InitializeResultSchema
       );
 
       if (result === undefined) {
@@ -146,7 +170,7 @@ export class Client<
 
       if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
         throw new Error(
-          `Server's protocol version is not supported: ${result.protocolVersion}`,
+          `Server's protocol version is not supported: ${result.protocolVersion}`
         );
       }
 
@@ -191,7 +215,7 @@ export class Client<
       case "logging/setLevel":
         if (!this._serverCapabilities?.logging) {
           throw new Error(
-            `Server does not support logging (required for ${method})`,
+            `Server does not support logging (required for ${method})`
           );
         }
         break;
@@ -200,7 +224,7 @@ export class Client<
       case "prompts/list":
         if (!this._serverCapabilities?.prompts) {
           throw new Error(
-            `Server does not support prompts (required for ${method})`,
+            `Server does not support prompts (required for ${method})`
           );
         }
         break;
@@ -212,7 +236,7 @@ export class Client<
       case "resources/unsubscribe":
         if (!this._serverCapabilities?.resources) {
           throw new Error(
-            `Server does not support resources (required for ${method})`,
+            `Server does not support resources (required for ${method})`
           );
         }
 
@@ -221,7 +245,7 @@ export class Client<
           !this._serverCapabilities.resources.subscribe
         ) {
           throw new Error(
-            `Server does not support resource subscriptions (required for ${method})`,
+            `Server does not support resource subscriptions (required for ${method})`
           );
         }
 
@@ -231,15 +255,15 @@ export class Client<
       case "tools/list":
         if (!this._serverCapabilities?.tools) {
           throw new Error(
-            `Server does not support tools (required for ${method})`,
+            `Server does not support tools (required for ${method})`
           );
         }
         break;
 
       case "completion/complete":
         if (!this._serverCapabilities?.prompts) {
           throw new Error(
-            `Server does not support prompts (required for ${method})`,
+            `Server does not support prompts (required for ${method})`
           );
         }
         break;
@@ -255,13 +279,23 @@ export class Client<
   }
 
   protected assertNotificationCapability(
-    method: NotificationT["method"],
+    method: NotificationT["method"]
   ): void {
     switch (method as ClientNotification["method"]) {
       case "notifications/roots/list_changed":
         if (!this._capabilities.roots?.listChanged) {
           throw new Error(
-            `Client does not support roots list changed notifications (required for ${method})`,
+            `Client does not support roots list changed notifications (required for ${method})`
+          );
+        }
+        break;
+
+      case "notifications/tools/list_changed":
+        if (!this._capabilities.tools?.listChanged) {
+          throw new Error(
+            `Client does not support tools capability (required for ${String(
+              method
+            )})`
           );
         }
         break;
@@ -285,15 +319,15 @@ export class Client<
       case "sampling/createMessage":
         if (!this._capabilities.sampling) {
           throw new Error(
-            `Client does not support sampling capability (required for ${method})`,
+            `Client does not support sampling capability (required for ${method})`
           );
         }
         break;
 
       case "roots/list":
         if (!this._capabilities.roots) {
           throw new Error(
-            `Client does not support roots capability (required for ${method})`,
+            `Client does not support roots capability (required for ${method})`
           );
         }
         break;
@@ -312,92 +346,92 @@ export class Client<
     return this.request(
       { method: "completion/complete", params },
       CompleteResultSchema,
-      options,
+      options
     );
   }
 
   async setLoggingLevel(level: LoggingLevel, options?: RequestOptions) {
     return this.request(
       { method: "logging/setLevel", params: { level } },
       EmptyResultSchema,
-      options,
+      options
     );
   }
 
   async getPrompt(
     params: GetPromptRequest["params"],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "prompts/get", params },
       GetPromptResultSchema,
-      options,
+      options
     );
   }
 
   async listPrompts(
     params?: ListPromptsRequest["params"],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "prompts/list", params },
       ListPromptsResultSchema,
-      options,
+      options
     );
   }
 
   async listResources(
     params?: ListResourcesRequest["params"],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "resources/list", params },
       ListResourcesResultSchema,
-      options,
+      options
     );
   }
 
   async listResourceTemplates(
     params?: ListResourceTemplatesRequest["params"],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "resources/templates/list", params },
       ListResourceTemplatesResultSchema,
-      options,
+      options
     );
   }
 
   async readResource(
     params: ReadResourceRequest["params"],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "resources/read", params },
       ReadResourceResultSchema,
-      options,
+      options
     );
   }
 
   async subscribeResource(
     params: SubscribeRequest["params"],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "resources/subscribe", params },
       EmptyResultSchema,
-      options,
+      options
     );
   }
 
   async unsubscribeResource(
     params: UnsubscribeRequest["params"],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "resources/unsubscribe", params },
       EmptyResultSchema,
-      options,
+      options
     );
   }
 
@@ -406,27 +440,43 @@ export class Client<
     resultSchema:
       | typeof CallToolResultSchema
       | typeof CompatibilityCallToolResultSchema = CallToolResultSchema,
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "tools/call", params },
       resultSchema,
-      options,
+      options
     );
   }
 
   async listTools(
     params?: ListToolsRequest["params"],
-    options?: RequestOptions,
+    options?: RequestOptions
   ) {
     return this.request(
       { method: "tools/list", params },
       ListToolsResultSchema,
-      options,
+      options
     );
   }
 
+  /**
+   * Registers a callback to be called when the server indicates that
+   * the tools list has changed. The callback should typically refresh the tools list.
+   *
+   * @param callback Function to call when tools list changes
+   */
+  setToolListChangedCallback(
+    callback: (tools?: ListToolsResult["tools"]) => void
+  ): void {
+    this.onToolListChanged = callback;
+  }
+
   async sendRootsListChanged() {
     return this.notification({ method: "notifications/roots/list_changed" });
   }
+
+  async sendToolListChanged() {
+    return this.notification({ method: "notifications/tools/list_changed" });
+  }
 }