Skip to content

Tool Registry

The tool registry provides a centralized way to register, store, and retrieve tools. It supports both individual tool registration and batch registration of multiple tools.

Features

  • Register individual tools or batches of tools
  • Retrieve tools by name
  • List all registered tools
  • Singleton pattern for global access

rllm.tools.registry

ToolRegistry

A registry for tools that handles registration, retrieval, and management.

Source code in rllm/tools/registry.py 
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
class ToolRegistry:
    """
    A registry for tools that handles registration, retrieval, and management.
    """

    _instance = None
    _initialized = False

    def __new__(cls):
        """
        Implement singleton pattern to ensure there's only one registry instance.
        """
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        """
        Initialize the registry if it hasn't been initialized yet.
        """
        if not ToolRegistry._initialized:
            self._tools: dict[str, type[Tool]] = {}
            ToolRegistry._initialized = True

    def register(self, name: str, tool_cls: type[Tool]) -> None:
        """
        Register a tool with the registry.

        Args:
            name: The name to register the tool under
            tool_cls: The tool class to register
        """
        if not issubclass(tool_cls, Tool):
            raise TypeError(f"Tool class must be a subclass of Tool, got {tool_cls}")

        self._tools[name] = tool_cls

    def register_all(self, tools_dict: dict[str, type[Tool]]) -> None:
        """
        Register multiple tools at once.

        Args:
            tools_dict: A dictionary mapping names to tool classes
        """
        for name, tool_cls in tools_dict.items():
            self.register(name, tool_cls)

    def get(self, name: str) -> type[Tool] | None:
        """
        Get a tool class by name.

        Args:
            name: The name of the tool to retrieve

        Returns:
            The tool class if found, None otherwise
        """
        return self._tools.get(name)

    def instantiate(self, name: str, *args, **kwargs) -> Tool | None:
        """
        Instantiate a tool by name.

        Args:
            name: The name of the tool to instantiate
            *args: Positional arguments to pass to the tool constructor
            **kwargs: Keyword arguments to pass to the tool constructor

        Returns:
            An instance of the tool if found, None otherwise
        """
        tool_cls = self.get(name)
        if tool_cls is None:
            return None
        return tool_cls(*args, **kwargs)

    def list_tools(self) -> list[str]:
        """
        List all registered tool names.

        Returns:
            A list of tool names
        """
        return list(self._tools.keys())

    def clear(self) -> None:
        """
        Clear all registered tools.
        """
        self._tools.clear()

    def unregister(self, name: str) -> bool:
        """
        Unregister a tool by name.

        Args:
            name: The name of the tool to unregister

        Returns:
            True if the tool was unregistered, False if it wasn't found
        """
        if name in self._tools:
            del self._tools[name]
            return True
        return False

    def __contains__(self, name: str) -> bool:
        """
        Check if a tool is registered.

        Args:
            name: The name of the tool to check

        Returns:
            True if the tool is registered, False otherwise
        """
        return name in self._tools

    def __getitem__(self, name: str) -> type[Tool]:
        """
        Get a tool class by name using dictionary-like syntax.

        Args:
            name: The name of the tool to retrieve

        Returns:
            The tool class

        Raises:
            KeyError: If the tool is not found
        """
        if name not in self._tools:
            raise KeyError(f"Tool '{name}' not found in registry")
        return self._tools[name]

    def __setitem__(self, name: str, tool_cls: type[Tool]) -> None:
        """
        Register a tool using dictionary-like syntax.

        Args:
            name: The name to register the tool under
            tool_cls: The tool class to register
        """
        self.register(name, tool_cls)

    def __iter__(self):
        """
        Iterate over tool names.

        Returns:
            An iterator over tool names
        """
        return iter(self._tools)

    def __len__(self) -> int:
        """
        Get the number of registered tools.

        Returns:
            The number of registered tools
        """
        return len(self._tools)

    def to_dict(self) -> dict[str, type[Tool]]:
        """
        Convert the registry to a dictionary.

        Returns:
            A dictionary mapping tool names to tool classes
        """
        return self._tools

__new__ 

__new__()

Implement singleton pattern to ensure there's only one registry instance.

Source code in rllm/tools/registry.py 
12
13
14
15
16
17
18
def __new__(cls):
    """
    Implement singleton pattern to ensure there's only one registry instance.
    """
    if cls._instance is None:
        cls._instance = super().__new__(cls)
    return cls._instance

__init__ 

__init__()

Initialize the registry if it hasn't been initialized yet.

Source code in rllm/tools/registry.py 
20
21
22
23
24
25
26
def __init__(self):
    """
    Initialize the registry if it hasn't been initialized yet.
    """
    if not ToolRegistry._initialized:
        self._tools: dict[str, type[Tool]] = {}
        ToolRegistry._initialized = True

register 

register(name: str, tool_cls: type[Tool]) -> None

Register a tool with the registry.

Parameters:

Name Type Description Default
name str

The name to register the tool under

 required
tool_cls type[Tool]

The tool class to register

 required
Source code in rllm/tools/registry.py 
28
29
30
31
32
33
34
35
36
37
38
39
def register(self, name: str, tool_cls: type[Tool]) -> None:
    """
    Register a tool with the registry.

    Args:
        name: The name to register the tool under
        tool_cls: The tool class to register
    """
    if not issubclass(tool_cls, Tool):
        raise TypeError(f"Tool class must be a subclass of Tool, got {tool_cls}")

    self._tools[name] = tool_cls

register_all 

register_all(tools_dict: dict[str, type[Tool]]) -> None

Register multiple tools at once.

Parameters:

Name Type Description Default
tools_dict dict[str, type[Tool]]

A dictionary mapping names to tool classes

 required
Source code in rllm/tools/registry.py 
41
42
43
44
45
46
47
48
49
def register_all(self, tools_dict: dict[str, type[Tool]]) -> None:
    """
    Register multiple tools at once.

    Args:
        tools_dict: A dictionary mapping names to tool classes
    """
    for name, tool_cls in tools_dict.items():
        self.register(name, tool_cls)

get 

get(name: str) -> type[Tool] | None

Get a tool class by name.

Parameters:

Name Type Description Default
name str

The name of the tool to retrieve

 required

Returns:

Type Description
type[Tool] | None

The tool class if found, None otherwise
Source code in rllm/tools/registry.py 
51
52
53
54
55
56
57
58
59
60
61
def get(self, name: str) -> type[Tool] | None:
    """
    Get a tool class by name.

    Args:
        name: The name of the tool to retrieve

    Returns:
        The tool class if found, None otherwise
    """
    return self._tools.get(name)

instantiate 

instantiate(name: str, *args, **kwargs) -> Tool | None

Instantiate a tool by name.

Parameters:

Name Type Description Default
name str

The name of the tool to instantiate

 required
*args

Positional arguments to pass to the tool constructor

 ()
**kwargs

Keyword arguments to pass to the tool constructor

 {}

Returns:

Type Description
Tool | None

An instance of the tool if found, None otherwise
Source code in rllm/tools/registry.py 
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
def instantiate(self, name: str, *args, **kwargs) -> Tool | None:
    """
    Instantiate a tool by name.

    Args:
        name: The name of the tool to instantiate
        *args: Positional arguments to pass to the tool constructor
        **kwargs: Keyword arguments to pass to the tool constructor

    Returns:
        An instance of the tool if found, None otherwise
    """
    tool_cls = self.get(name)
    if tool_cls is None:
        return None
    return tool_cls(*args, **kwargs)

list_tools 

list_tools() -> list[str]

List all registered tool names.

Returns:

Type Description
list[str]

A list of tool names
Source code in rllm/tools/registry.py 
80
81
82
83
84
85
86
87
def list_tools(self) -> list[str]:
    """
    List all registered tool names.

    Returns:
        A list of tool names
    """
    return list(self._tools.keys())

clear 

clear() -> None

Clear all registered tools.

Source code in rllm/tools/registry.py 
89
90
91
92
93
def clear(self) -> None:
    """
    Clear all registered tools.
    """
    self._tools.clear()

unregister 

unregister(name: str) -> bool

Unregister a tool by name.

Parameters:

Name Type Description Default
name str

The name of the tool to unregister

 required

Returns:

Type Description
bool

True if the tool was unregistered, False if it wasn't found
Source code in rllm/tools/registry.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
def unregister(self, name: str) -> bool:
    """
    Unregister a tool by name.

    Args:
        name: The name of the tool to unregister

    Returns:
        True if the tool was unregistered, False if it wasn't found
    """
    if name in self._tools:
        del self._tools[name]
        return True
    return False

__contains__ 

__contains__(name: str) -> bool

Check if a tool is registered.

Parameters:

Name Type Description Default
name str

The name of the tool to check

 required

Returns:

Type Description
bool

True if the tool is registered, False otherwise
Source code in rllm/tools/registry.py 
110
111
112
113
114
115
116
117
118
119
120
def __contains__(self, name: str) -> bool:
    """
    Check if a tool is registered.

    Args:
        name: The name of the tool to check

    Returns:
        True if the tool is registered, False otherwise
    """
    return name in self._tools

__getitem__ 

__getitem__(name: str) -> type[Tool]

Get a tool class by name using dictionary-like syntax.

Parameters:

Name Type Description Default
name str

The name of the tool to retrieve

 required

Returns:

Type Description
type[Tool]

The tool class

Raises:

Type Description
KeyError

If the tool is not found
Source code in rllm/tools/registry.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
def __getitem__(self, name: str) -> type[Tool]:
    """
    Get a tool class by name using dictionary-like syntax.

    Args:
        name: The name of the tool to retrieve

    Returns:
        The tool class

    Raises:
        KeyError: If the tool is not found
    """
    if name not in self._tools:
        raise KeyError(f"Tool '{name}' not found in registry")
    return self._tools[name]

__setitem__ 

__setitem__(name: str, tool_cls: type[Tool]) -> None

Register a tool using dictionary-like syntax.

Parameters:

Name Type Description Default
name str

The name to register the tool under

 required
tool_cls type[Tool]

The tool class to register

 required
Source code in rllm/tools/registry.py 
139
140
141
142
143
144
145
146
147
def __setitem__(self, name: str, tool_cls: type[Tool]) -> None:
    """
    Register a tool using dictionary-like syntax.

    Args:
        name: The name to register the tool under
        tool_cls: The tool class to register
    """
    self.register(name, tool_cls)

__iter__ 

__iter__()

Iterate over tool names.

Returns:

Type Description

An iterator over tool names
Source code in rllm/tools/registry.py 
149
150
151
152
153
154
155
156
def __iter__(self):
    """
    Iterate over tool names.

    Returns:
        An iterator over tool names
    """
    return iter(self._tools)

__len__ 

__len__() -> int

Get the number of registered tools.

Returns:

Type Description
int

The number of registered tools
Source code in rllm/tools/registry.py 
158
159
160
161
162
163
164
165
def __len__(self) -> int:
    """
    Get the number of registered tools.

    Returns:
        The number of registered tools
    """
    return len(self._tools)

to_dict 

to_dict() -> dict[str, type[Tool]]

Convert the registry to a dictionary.

Returns:

Type Description
dict[str, type[Tool]]

A dictionary mapping tool names to tool classes
Source code in rllm/tools/registry.py 
167
168
169
170
171
172
173
174
def to_dict(self) -> dict[str, type[Tool]]:
    """
    Convert the registry to a dictionary.

    Returns:
        A dictionary mapping tool names to tool classes
    """
    return self._tools