ToolRegistry¶

from toolregistry import ToolRegistry

registry = ToolRegistry()

# Register a simple function
def add_numbers(a: int, b: int) -> int:
    return a + b

registry.register(add_numbers)

from toolregistry import ToolRegistry

registry = ToolRegistry()

class Calculator:
    @staticmethod
    def multiply(a: int, b: int) -> int:
        return a * b

    def divide(self, a: int, b: int) -> float:
        return a / b

# Register all methods from the class
registry.register_from_class(Calculator)

from toolregistry import ToolRegistry

class BaseCalculator:
    @staticmethod
    def add(a: int, b: int) -> int:
        return a + b

class AdvancedCalculator(BaseCalculator):
    @staticmethod
    def multiply(a: int, b: int) -> int:
        return a * b

registry = ToolRegistry()

# Default behavior (traverse_mro=True): includes inherited methods from BaseCalculator
registry.register_from_class(AdvancedCalculator)
print(registry.get_available_tools())
# Output: ['advanced_calculator-add', 'advanced_calculator-multiply']

# With traverse_mro=False: only methods defined directly on AdvancedCalculator
registry2 = ToolRegistry()
registry2.register_from_class(AdvancedCalculator, traverse_mro=False)
print(registry2.get_available_tools())
# Output: ['advanced_calculator-multiply']

from toolregistry import ToolRegistry

registry = ToolRegistry()

# Register with custom namespace
registry.register(my_function, namespace="math_utils")

# Access tools with namespace
available_tools = registry.get_available_tools(namespace="math_utils")

from toolregistry import ToolRegistry, ChangeEvent, ChangeEventType

registry = ToolRegistry()

def my_callback(event: ChangeEvent) -> None:
    """Handle tool registry changes."""
    print(f"[{event.event_type.value}] {event.tool_name}")
    if event.reason:
        print(f"  Reason: {event.reason}")

# Register the callback
registry.on_change(my_callback)

# Changes will trigger the callback
def add(a: int, b: int) -> int:
    return a + b

registry.register(add)  # Triggers: [register] add
registry.disable("add", reason="Maintenance")  # Triggers: [disable] add
registry.enable("add")  # Triggers: [enable] add

# Remove callback when no longer needed
registry.remove_on_change(my_callback)

from toolregistry import ToolRegistry

registry = ToolRegistry()

def add(a: int, b: int) -> int:
    return a + b

def subtract(a: int, b: int) -> int:
    return a - b

registry.register(add)
registry.register(subtract)

# Disable a tool with a reason
registry.disable("subtract", reason="Under maintenance")

# Get status of all tools
status = registry.get_tools_status()
print(status)
# Output:
# [
#     {"name": "add", "enabled": True, "reason": None, "namespace": None},
#     {"name": "subtract", "enabled": False, "reason": "Under maintenance", "namespace": None}
# ]

# Filter to find disabled tools
disabled_tools = [s for s in status if not s["enabled"]]
print(disabled_tools)
# Output: [{"name": "subtract", "enabled": False, "reason": "Under maintenance", "namespace": None}]

from toolregistry import ToolRegistry, ToolMetadata, ToolTag

registry = ToolRegistry()

def read_file(path: str) -> str:
    """Read a file from disk."""
    ...

def delete_file(path: str) -> None:
    """Delete a file from disk."""
    ...

def send_email(to: str, body: str) -> None:
    """Send an email."""
    ...

registry.register(read_file, metadata=ToolMetadata(tags={ToolTag.FILE_SYSTEM, ToolTag.READ_ONLY}))
registry.register(delete_file, metadata=ToolMetadata(tags={ToolTag.FILE_SYSTEM, ToolTag.DESTRUCTIVE}))
registry.register(send_email, metadata=ToolMetadata(tags={ToolTag.NETWORK}))

# match="any" (default): disable tools that have AT LEAST ONE of the given tags
disabled = registry.disable_by_tags(
    {ToolTag.DESTRUCTIVE, ToolTag.NETWORK},
    match="any",
    reason="Restricted in read-only mode",
)
print(disabled)  # ['delete_file', 'send_email']

# match="all": disable only tools that carry EVERY specified tag
registry2 = ToolRegistry()
registry2.register(read_file, metadata=ToolMetadata(tags={ToolTag.FILE_SYSTEM, ToolTag.READ_ONLY}))
registry2.register(delete_file, metadata=ToolMetadata(tags={ToolTag.FILE_SYSTEM, ToolTag.DESTRUCTIVE}))

disabled2 = registry2.disable_by_tags(
    {ToolTag.FILE_SYSTEM, ToolTag.DESTRUCTIVE},
    match="all",
    reason="No destructive filesystem ops allowed",
)
print(disabled2)  # ['delete_file']

from toolregistry import ToolRegistry, PostRegisterHook, ToolMetadata, ToolTag

registry = ToolRegistry()

# Hook: auto-disable any privileged tool at registration time
def deny_privileged(tool_name: str, tool, registry) -> str | None:
    tags = tool.metadata.tags if tool.metadata else set()
    if ToolTag.PRIVILEGED in tags:
        return f"Privileged tool '{tool_name}' is not allowed in this environment"
    return None

registry.add_post_register_hook(deny_privileged)

def sudo_command(cmd: str) -> str:
    """Run a command with elevated privileges."""
    ...

registry.register(sudo_command, metadata=ToolMetadata(tags={ToolTag.PRIVILEGED}))

print(registry.is_enabled("sudo_command"))     # False
print(registry.get_disable_reason("sudo_command"))
# "Privileged tool 'sudo_command' is not allowed in this environment"

# Multiple hooks are invoked in registration order
def log_all(tool_name: str, tool, registry) -> None:
    print(f"[hook] registered: {tool_name}")

registry.add_post_register_hook(log_all)