How to get custom menu items show up in the search bar?
All the math node operations
Note: this doesn't answer how to put your operators into the search, rather is intended to offer another way to have same functionality in a far more easily extendable way

From one look at the question code instantly has me quoting

Foghorn Leghorn
No, no, no your're doing it all wrong

No menus one operator
Have taken code above and edited to have functionality as demonstrated, with no menus and one operator.
All the question operators are doing pretty much the same thing, the code varies little between them. Instead of an operator for each operation, one operator and an enum of possible operations.
The tricky bit.
When we add a math node, we add an instance of the type bpy.types.ShaderNodeMath.  All the possible operations are available from its definition of the &quot;operation&quot; property.
[Look for links, been well covered]
Our one operator is going to pinch these.
The menus can be ditched because blender can automatically make a menu from the options.  And boy there are a few.  The items list can be narrowed to a select few if desired
Categorize the other way
The naming convention of your operators is, going by &quot;standards&quot;, a bit A about T. Using &quot;node.add_math_subtract&quot; will classify it with all the other bpy.ops.node prefixed operators.
Operators use context
For any code run in the shader editor the material we're &quot;lookin' at&quot; is context material. This is the material the bpy.ops.node.foo_bar will work on.  This will not always be bpy.data.materials[&quot;Material&quot;]
Similarly only the first math node added via operator (bpy.ops.node.add_node(..)) will have the name &quot;Math&quot;.  Hence on subsequent runnings of question code will add a new node but change the operation of the first one added, ie the one with name &quot;Math&quot;.  Directly after running the operator the new node will be context.active_node .. another context member of the node editor.
Have instead added a math node to the node tree of the context material and set its operation and name accordingly.
import bpy
from bpy.types import Menu, Operator, ShaderNodeMath
from bpy.props import EnumProperty
 
class AddMathNode(Operator):
    ''' Add Math Node '''
    bl_idname = &quot;node.add_math&quot;
    bl_label = &quot;Add Math Node&quot;
    items = [
        (p.identifier, p.name, p.description) 
        for p in ShaderNodeMath.bl_rna.properties[&quot;operation&quot;].enum_items
            ]
    #print(items)
    operation : EnumProperty(
        items=items,
        name=&quot;Operation&quot;,
        default='ADD',
        )
            
    def execute(self, context):
        # the material in the node editor
        mat = context.material  
        # add a new math node to its nodes         
        n = mat.node_tree.nodes.new(&quot;ShaderNodeMath&quot;)
        # set some properties
        n.operation = self.operation
        n.name = self.operation.lower().title()
        # make active
        mat.node_tree.nodes.active = n
        return {'FINISHED'}
        #return bpy.ops.transform.translate('INVOKE_DEFAULT') # use translate   
      
classes = (AddMathNode,)
def draw_menu(self, context):
    layout = self.layout
    layout.operator_menu_enum(&quot;node.add_math&quot;, &quot;operation&quot;)
def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.NODE_MT_add.append(draw_menu)
 
def unregister():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.NODE_MT_add.remove(draw_menu)

 
if __name__ == &quot;__main__&quot;:
    register()

Sorting them
There's lots of them. This change circa lines 9-12 sorts them by IDENTIFIER, eg ADD, SUBTRACT
    items = sorted(
        (p.identifier, p.name, p.description) 
        for p in ShaderNodeMath.bl_rna.properties[&quot;operation&quot;].enum_items
            )

Adding to the search menu.
Because this is now only a single operator removes the sense of searching for it.  Possibly the logical extension of this is to categorize the operation (as is done via the UI to select math node operation)
With developer extras set to show view source option can right click over the add nodes menu and view source, revealing how the search menu is constructed and laid out.
def draw(self, context):
    layout = self.layout

    layout.operator_context = 'INVOKE_DEFAULT'

    if nodeitems_utils.has_node_categories(context):
        props = layout.operator(&quot;node.add_search&quot;, text=&quot;Search...&quot;, icon='VIEWZOOM')
        props.use_transform = True

        layout.separator()

        # actual node submenus are defined by draw functions from node categories
        nodeitems_utils.draw_node_categories_menu(self, context)

Which reveals a helper module nodeitems_utils which we can pretty much pinch, to instead of using enum menu expansion can search and categorize.  Perhaps for another day.