Demonstrate registration of tools conditioned upon client capability support. Also, obviated need for clientConnected callback to pass sessionId because we defer initial fetching of roots happens when you run the get-roots-list tool.

* In how-it-works.md,
  - added a section on conditional tool registration

* In server/index.ts
  - import registerConditionalTools
  - in an oninitialized handler for the server, call registerConditionalTools
  - removed clientConnected from ServerFactoryResponse and all mentions in docs

* In tools/index.ts
  - export a registerConditionalTools function
  - refactor/move calls to registerGetRootsListTool, registerTriggerElicitationRequestTool, and registerTriggerSamplingRequestTool out of registerTools and into registerConditionalTools

* In server/roots.ts
  - only act if client supports roots
  - remove setInterval from call to requestRoots. It isn't happening during the initialze handshake anymore, so it doesn't interfere with that process if called immediaately

* In get-roots-list.ts, trigger-elicitation-request.ts, and trigger-sampling-request.ts,
  - only register tool if client supports capability

* Throughout the rest of the files, removing all references to `clientConnected`

src/everything/server/roots.ts

@@ -22,56 +22,65 @@ export const roots: Map<string | undefined, Root[]> = new Map<
  *
  * @throws {Error} In case of a failure to request the roots from the client, an error log message is sent.
  */
-export const syncRoots = (server: McpServer, sessionId?: string) => {
-  // Function to request the updated roots list from the client
-  const requestRoots = async () => {
-    try {
-      // Request the updated roots list from the client
-      const response = await server.server.listRoots();
-      if (response && "roots" in response) {
-        // Store the roots list for this client
-        roots.set(sessionId, response.roots);
+export const syncRoots = async (server: McpServer, sessionId?: string) => {
 
-        // Notify the client of roots received
+  const clientCapabilities = server.server.getClientCapabilities() || {};
+  const clientSupportsRoots: boolean = clientCapabilities.roots !== undefined;
+
+  // If roots have not been fetched for this client, fetch them
+  if (clientSupportsRoots && !roots.has(sessionId)) {
+    // Function to request the updated roots list from the client
+    const requestRoots = async () => {
+      try {
+        // Request the updated roots list from the client
+        const response = await server.server.listRoots();
+        if (response && "roots" in response) {
+          // Store the roots list for this client
+          roots.set(sessionId, response.roots);
+
+          // Notify the client of roots received
+          await server.sendLoggingMessage(
+            {
+              level: "info",
+              logger: "everything-server",
+              data: `Roots updated: ${response.roots.length} root(s) received from client`,
+            },
+            sessionId
+          );
+        } else {
+          await server.sendLoggingMessage(
+            {
+              level: "info",
+              logger: "everything-server",
+              data: "Client returned no roots set",
+            },
+            sessionId
+          );
+        }
+      } catch (error) {
         await server.sendLoggingMessage(
           {
-            level: "info",
+            level: "error",
             logger: "everything-server",
-            data: `Roots updated: ${response.roots.length} root(s) received from client`,
-          },
-          sessionId
-        );
-      } else {
-        await server.sendLoggingMessage(
-          {
-            level: "info",
-            logger: "everything-server",
-            data: "Client returned no roots set",
+            data: `Failed to request roots from client: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
           },
           sessionId
         );
       }
-    } catch (error) {
-      await server.sendLoggingMessage(
-        {
-          level: "error",
-          logger: "everything-server",
-          data: `Failed to request roots from client: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        },
-        sessionId
-      );
-    }
-  };
+    };
 
-  // Set the list changed notification handler
-  server.server.setNotificationHandler(
-    RootsListChangedNotificationSchema,
-    requestRoots
-  );
+    // Set the list changed notification handler
+    server.server.setNotificationHandler(
+      RootsListChangedNotificationSchema,
+      requestRoots
+    );
 
-  // Request initial roots list after a brief delay
-  // Allows initial POST request to complete on streamableHttp transports
-  setTimeout(() => requestRoots(), 350);
+    // Request initial roots list immediatelys
+    await requestRoots();
+
+    // Return the roots list for this client
+    return roots.get(sessionId);
+  }
 };