feat(tools): implicitly register capabilities (#292)

When users add tools via AddTool or AddSessionTool, implicitly set the
tools capability.  If the user has not already called
WithToolCapabilities, then default listChanged to true, but honor any
existing value.

This mimics the behavior of the official typescript sdk, which registers
`tools.listChanged: true` when the user adds a tool to the MCP server.

Author: david-hamilton-glean

server/server.go

@@ -411,20 +411,29 @@ func (s *MCPServer) AddTool(tool mcp.Tool, handler ToolHandlerFunc) {
 	s.AddTools(ServerTool{Tool: tool, Handler: handler})
 }
 
-// AddTools registers multiple tools at once
-func (s *MCPServer) AddTools(tools ...ServerTool) {
+// Register tool capabilities due to a tool being added.  Default to
+// listChanged: true, but don't change the value if we've already explicitly
+// registered tools.listChanged false.
+func (s *MCPServer) implicitlyRegisterToolCapabilities() {
 	s.capabilitiesMu.RLock()
 	if s.capabilities.tools == nil {
 		s.capabilitiesMu.RUnlock()
 
 		s.capabilitiesMu.Lock()
 		if s.capabilities.tools == nil {
-			s.capabilities.tools = &toolCapabilities{}
+			s.capabilities.tools = &toolCapabilities{
+				listChanged: true,
+			}
 		}
 		s.capabilitiesMu.Unlock()
 	} else {
 		s.capabilitiesMu.RUnlock()
 	}
+}
+
+// AddTools registers multiple tools at once
+func (s *MCPServer) AddTools(tools ...ServerTool) {
+	s.implicitlyRegisterToolCapabilities()
 
 	s.toolsMu.Lock()
 	for _, entry := range tools {

server/server_test.go

@@ -1624,3 +1624,46 @@ func BenchmarkMCPServer_PaginationForReflect(b *testing.B) {
 		_, _, _ = listByPaginationForReflect[mcp.Tool](ctx, server, "dG9vbDY1NA==", list)
 	}
 }
+
+func TestMCPServer_ToolCapabilitiesBehavior(t *testing.T) {
+	tests := []struct {
+		name           string
+		serverOptions  []ServerOption
+		validateServer func(t *testing.T, s *MCPServer)
+	}{
+		{
+			name:          "no tool capabilities provided",
+			serverOptions: []ServerOption{
+				// No WithToolCapabilities
+			},
+			validateServer: func(t *testing.T, s *MCPServer) {
+				s.capabilitiesMu.RLock()
+				defer s.capabilitiesMu.RUnlock()
+
+				require.NotNil(t, s.capabilities.tools, "tools capability should be initialized")
+				assert.True(t, s.capabilities.tools.listChanged, "listChanged should be true when no capabilities were provided")
+			},
+		},
+		{
+			name: "tools.listChanged set to false",
+			serverOptions: []ServerOption{
+				WithToolCapabilities(false),
+			},
+			validateServer: func(t *testing.T, s *MCPServer) {
+				s.capabilitiesMu.RLock()
+				defer s.capabilitiesMu.RUnlock()
+
+				require.NotNil(t, s.capabilities.tools, "tools capability should be initialized")
+				assert.False(t, s.capabilities.tools.listChanged, "listChanged should remain false when explicitly set to false")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := NewMCPServer("test-server", "1.0.0", tt.serverOptions...)
+			server.AddTool(mcp.NewTool("test-tool"), nil)
+			tt.validateServer(t, server)
+		})
+	}
+}

server/session.go

@@ -224,6 +224,8 @@ func (s *MCPServer) AddSessionTools(sessionID string, tools ...ServerTool) error
 		return ErrSessionDoesNotSupportTools
 	}
 
+	s.implicitlyRegisterToolCapabilities()
+
 	// Get existing tools (this should return a thread-safe copy)
 	sessionTools := session.GetSessionTools()
 

server/session_test.go

@@ -802,3 +802,59 @@ func TestMCPServer_NotificationChannelBlocked(t *testing.T) {
 	assert.Equal(t, "blocked-session", localErrorSessionID, "Session ID should be captured in the error hook")
 	assert.Equal(t, "broadcast-message", localErrorMethod, "Method should be captured in the error hook")
 }
+
+func TestMCPServer_SessionToolCapabilitiesBehavior(t *testing.T) {
+	tests := []struct {
+		name           string
+		serverOptions  []ServerOption
+		validateServer func(t *testing.T, s *MCPServer, session *sessionTestClientWithTools)
+	}{
+		{
+			name:          "no tool capabilities provided",
+			serverOptions: []ServerOption{
+				// No WithToolCapabilities
+			},
+			validateServer: func(t *testing.T, s *MCPServer, session *sessionTestClientWithTools) {
+				s.capabilitiesMu.RLock()
+				defer s.capabilitiesMu.RUnlock()
+
+				require.NotNil(t, s.capabilities.tools, "tools capability should be initialized")
+				assert.True(t, s.capabilities.tools.listChanged, "listChanged should be true when no capabilities were provided")
+			},
+		},
+		{
+			name: "tools.listChanged set to false",
+			serverOptions: []ServerOption{
+				WithToolCapabilities(false),
+			},
+			validateServer: func(t *testing.T, s *MCPServer, session *sessionTestClientWithTools) {
+				s.capabilitiesMu.RLock()
+				defer s.capabilitiesMu.RUnlock()
+
+				require.NotNil(t, s.capabilities.tools, "tools capability should be initialized")
+				assert.False(t, s.capabilities.tools.listChanged, "listChanged should remain false when explicitly set to false")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := NewMCPServer("test-server", "1.0.0", tt.serverOptions...)
+
+			// Create and register a session
+			session := &sessionTestClientWithTools{
+				sessionID:           "test-session",
+				notificationChannel: make(chan mcp.JSONRPCNotification, 10),
+				initialized:         true,
+			}
+			err := server.RegisterSession(context.Background(), session)
+			require.NoError(t, err)
+
+			// Add a session tool and verify listChanged remains false
+			err = server.AddSessionTool(session.SessionID(), mcp.NewTool("test-tool"), nil)
+			require.NoError(t, err)
+
+			tt.validateServer(t, server, session)
+		})
+	}
+}