autobyteus 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

autobyteus/agent/group/agent_group_context.py

@@ -1,81 +0,0 @@
-# file: autobyteus/autobyteus/agent/group/agent_group_context.py
-import logging
-from typing import List, Dict, Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from autobyteus.agent.agent import Agent 
-
-logger = logging.getLogger(__name__)
-
-class AgentGroupContext:
-    """
-    Stores contextual information about an agent group, including its ID,
-    member agents, and the designated coordinator. Provides methods to
-    discover agents within the group.
-    """
-    def __init__(self,
-                 group_id: str,
-                 agents: List['Agent'],
-                 coordinator_agent_id: str):
-        """
-        Initializes the AgentGroupContext.
-        """
-        if not group_id or not isinstance(group_id, str):
-            raise ValueError("AgentGroupContext requires a non-empty string 'group_id'.")
-        if not coordinator_agent_id or not isinstance(coordinator_agent_id, str):
-            raise ValueError("AgentGroupContext requires a non-empty string 'coordinator_agent_id'.")
-        if not agents:
-            raise ValueError("AgentGroupContext requires a non-empty list of 'agents'.")
-
-        from autobyteus.agent.agent import Agent as AgentClassRef
-        if not all(isinstance(agent, AgentClassRef) for agent in agents):
-            raise TypeError("All items in 'agents' list must be instances of the 'Agent' class.")
-
-        self.group_id: str = group_id
-        self._agents_by_id: Dict[str, 'Agent'] = {agent.agent_id: agent for agent in agents}
-        self._coordinator_agent_id: str = coordinator_agent_id
-
-        if self._coordinator_agent_id not in self._agents_by_id:
-            logger.error(f"Coordinator agent with ID '{self._coordinator_agent_id}' not found in the provided list of agents for group '{self.group_id}'.")
-        
-        logger.info(f"AgentGroupContext initialized for group_id '{self.group_id}'.")
-
-    def get_agent(self, agent_id: str) -> Optional['Agent']:
-        """
-        Retrieves an agent from the group by its unique agent_id.
-        """
-        return self._agents_by_id.get(agent_id)
-
-    def get_agents_by_role(self, role_name: str) -> List['Agent']:
-        """
-        Retrieves all agents within the group that match the specified role name.
-        """
-        if not isinstance(role_name, str):
-            logger.warning(f"Attempted to get_agents_by_role with non-string role_name: {role_name} in group '{self.group_id}'.")
-            return []
-            
-        matching_agents: List['Agent'] = [
-            agent for agent in self._agents_by_id.values()
-            if agent.context and agent.context.config and agent.context.config.role == role_name
-        ]
-        
-        if not matching_agents:
-            logger.debug(f"No agents found with role '{role_name}' in group '{self.group_id}'.")
-        return matching_agents
-
-    def get_coordinator_agent(self) -> Optional['Agent']:
-        """
-        Retrieves the designated coordinator agent for this group.
-        """
-        return self.get_agent(self._coordinator_agent_id)
-
-    def get_all_agents(self) -> List['Agent']:
-        """
-        Retrieves all agents currently part of this group.
-        """
-        return list(self._agents_by_id.values())
-
-    def __repr__(self) -> str:
-        return (f"<AgentGroupContext group_id='{self.group_id}', "
-                f"num_agents={len(self._agents_by_id)}, "
-                f"coordinator_id='{self._coordinator_agent_id}'>")

autobyteus/agent/input_processor/content_prefixing_input_processor.py

@@ -1,41 +0,0 @@
-# file: autobyteus/autobyteus/agent/input_processor/content_prefixing_input_processor.py
-import logging
-from typing import TYPE_CHECKING
-
-from .base_user_input_processor import BaseAgentUserInputMessageProcessor 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-    from autobyteus.agent.context import AgentContext # Composite AgentContext
-    from autobyteus.agent.events import UserMessageReceivedEvent
-
-logger = logging.getLogger(__name__)
-
-class ContentPrefixingInputProcessor(BaseAgentUserInputMessageProcessor):
-    """
-    A processor that adds a predefined prefix to the message content.
-    The prefix is defined by the agent's custom_data (in AgentRuntimeState) or a default.
-    Example prefix key in custom_data: "content_prefix"
-    """
-    DEFAULT_PREFIX = "[Processed Message] "
-
-    async def process(self,
-                      message: 'AgentInputUserMessage', 
-                      context: 'AgentContext',
-                      triggering_event: 'UserMessageReceivedEvent') -> 'AgentInputUserMessage':
-        """
-        Handles the message by prefixing its content.
-        The 'triggering_event' parameter is ignored by this processor.
-        """
-        agent_id = context.agent_id # Convenience property
-        logger.debug(f"Agent '{agent_id}': ContentPrefixingInputProcessor processing message.")
-        
-        # Access custom_data via convenience property (or context.state.custom_data)
-        prefix = context.custom_data.get("content_prefix", self.DEFAULT_PREFIX)
-        if not isinstance(prefix, str):
-            logger.warning(f"Agent '{agent_id}': 'content_prefix' in custom_data is not a string. Using default prefix. Found: {type(prefix)}")
-            prefix = self.DEFAULT_PREFIX
-            
-        message.content = prefix + message.content
-        logger.info(f"Agent '{agent_id}': Prefixed message content with '{prefix}'.")
-        return message

autobyteus/agent/input_processor/metadata_appending_input_processor.py

@@ -1,34 +0,0 @@
-# file: autobyteus/autobyteus/agent/input_processor/metadata_appending_input_processor.py
-import logging
-from typing import TYPE_CHECKING
-
-from .base_user_input_processor import BaseAgentUserInputMessageProcessor 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-    from autobyteus.agent.context import AgentContext # Composite AgentContext
-    from autobyteus.agent.events import UserMessageReceivedEvent
-
-logger = logging.getLogger(__name__)
-
-class MetadataAppendingInputProcessor(BaseAgentUserInputMessageProcessor):
-    """
-    A processor that appends fixed metadata to the message.
-    Example: Appends agent_id and config_name to metadata.
-    """
-    async def process(self,
-                      message: 'AgentInputUserMessage', 
-                      context: 'AgentContext',
-                      triggering_event: 'UserMessageReceivedEvent') -> 'AgentInputUserMessage':
-        """
-        Handles the message by appending metadata.
-        The 'triggering_event' parameter is ignored by this processor.
-        """
-        agent_id = context.agent_id
-        config_name = context.config.name
-
-        logger.debug(f"Agent '{agent_id}': MetadataAppendingInputProcessor processing message.")
-        message.metadata["processed_by_agent_id"] = agent_id
-        message.metadata["processed_with_config_name"] = config_name
-        logger.info(f"Agent '{agent_id}': Appended 'processed_by_agent_id' and 'processed_with_config_name' to message metadata.")
-        return message

autobyteus/agent/input_processor/passthrough_input_processor.py

@@ -1,33 +0,0 @@
-# file: autobyteus/autobyteus/agent/input_processor/passthrough_input_processor.py
-import logging
-from typing import TYPE_CHECKING
-
-from .base_user_input_processor import BaseAgentUserInputMessageProcessor 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
-    from autobyteus.agent.context import AgentContext # Composite AgentContext
-    from autobyteus.agent.events import UserMessageReceivedEvent
-
-logger = logging.getLogger(__name__)
-
-class PassthroughInputProcessor(BaseAgentUserInputMessageProcessor):
-    """
-    A processor that returns the message unchanged.
-    Can be used as a default or for testing.
-    """
-    @classmethod
-    def get_name(cls) -> str:
-        return "PassthroughInputProcessor"
-
-    async def process(self,
-                      message: 'AgentInputUserMessage', 
-                      context: 'AgentContext',
-                      triggering_event: 'UserMessageReceivedEvent') -> 'AgentInputUserMessage':
-        """
-        Handles the message by returning it without modification.
-        The 'triggering_event' parameter is ignored by this processor.
-        """
-        agent_id = context.agent_id # Convenience property
-        logger.debug(f"Agent '{agent_id}': PassthroughInputProcessor received message, returning as is.")
-        return message

autobyteus/agent/workflow/__init__.py

@@ -1,11 +0,0 @@
-# file: autobyteus/autobyteus/agent/workflow/__init__.py
-"""
-Components for defining and running agentic workflows.
-"""
-from .agentic_workflow import AgenticWorkflow
-from .base_agentic_workflow import BaseAgenticWorkflow
-
-__all__ = [
-    "AgenticWorkflow",
-    "BaseAgenticWorkflow",
-]

autobyteus/agent/workflow/agentic_workflow.py

@@ -1,89 +0,0 @@
-# file: autobyteus/autobyteus/agent/workflow/agentic_workflow.py
-import logging
-import uuid
-from typing import List, Dict, Optional, Any, cast
-
-from autobyteus.agent.context.agent_config import AgentConfig
-from autobyteus.agent.group.agent_group import AgentGroup
-
-logger = logging.getLogger(__name__)
-
-class AgenticWorkflow:
-    """
-    A concrete class for defining and running multi-agent workflows declaratively.
-    It internally manages an AgentGroup and provides a user-friendly interface
-    to process tasks.
-    """
-    def __init__(self,
-                 agent_configs: List[AgentConfig],
-                 coordinator_config_name: str,
-                 workflow_id: Optional[str] = None,
-                 input_param_name: str = "input",
-                ):
-        """
-        Initializes the AgenticWorkflow.
-
-        Args:
-            agent_configs: List of pre-made AgentConfig instances for the agents in this workflow.
-            coordinator_config_name: Name of the agent config to be used as coordinator.
-            workflow_id: Optional. A unique ID for this workflow instance. Auto-generated if None.
-            input_param_name: The key to use in `process(**kwargs)` to find the initial
-                              input string for the coordinator. Defaults to "input".
-        """
-        self.workflow_id: str = workflow_id or f"workflow_{uuid.uuid4()}"
-        self._input_param_name: str = input_param_name
-
-        logger.info(f"Initializing AgenticWorkflow '{self.workflow_id}'. "
-                    f"Input parameter name for process(): '{self._input_param_name}'.")
-
-        # The AgentGroup is now initialized directly with the user-provided configs.
-        self.agent_group: AgentGroup = AgentGroup(
-            agent_configs=agent_configs,
-            coordinator_config_name=coordinator_config_name,
-            group_id=f"group_for_{self.workflow_id}",
-        )
-        logger.info(f"AgenticWorkflow '{self.workflow_id}' successfully instantiated internal AgentGroup '{self.agent_group.group_id}'.")
-
-    async def process(self, **kwargs: Any) -> Any:
-        logger.info(f"AgenticWorkflow '{self.workflow_id}' received process request with kwargs: {list(kwargs.keys())}")
-
-        initial_input_content = kwargs.get(self._input_param_name)
-        if initial_input_content is None:
-            raise ValueError(f"Required input parameter '{self._input_param_name}' not found in process() arguments.")
-        if not isinstance(initial_input_content, str):
-            raise ValueError(f"Input parameter '{self._input_param_name}' must be a string, "
-                             f"got {type(initial_input_content).__name__}.")
-
-        user_id: Optional[str] = cast(Optional[str], kwargs.get("user_id")) if isinstance(kwargs.get("user_id"), str) else None
-        
-        logger.debug(f"AgenticWorkflow '{self.workflow_id}': Extracted initial input for coordinator: '{initial_input_content[:100]}...'")
-
-        result = await self.agent_group.process_task_for_coordinator(
-            initial_input_content=initial_input_content,
-            user_id=user_id
-        )
-        
-        return result
-
-
-    async def start(self) -> None:
-        logger.info(f"AgenticWorkflow '{self.workflow_id}' received start() request. Delegating to AgentGroup.")
-        await self.agent_group.start()
-
-    async def stop(self, timeout: float = 10.0) -> None:
-        logger.info(f"AgenticWorkflow '{self.workflow_id}' received stop() request. Delegating to AgentGroup.")
-        await self.agent_group.stop(timeout)
-
-    @property
-    def is_running(self) -> bool:
-        return self.agent_group.is_running
-
-    @property
-    def group_id(self) -> str:
-        return self.agent_group.group_id
-
-    def __repr__(self) -> str:
-        return (f"<AgenticWorkflow workflow_id='{self.workflow_id}', "
-                f"group_id='{self.agent_group.group_id}', "
-                f"coordinator='{self.agent_group.coordinator_config_name}', "
-                f"is_running={self.is_running}>")

autobyteus/tools/mcp/call_handlers/sse_handler.py

@@ -1,22 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/sse_handler.py
-import logging
-from typing import Dict, Any, TYPE_CHECKING
-
-from .base_handler import McpCallHandler
-
-if TYPE_CHECKING:
-    from ..types import BaseMcpConfig
-
-logger = logging.getLogger(__name__)
-
-class SseMcpCallHandler(McpCallHandler):
-    """Placeholder handler for MCP tool calls over SSE."""
-
-    async def handle_call(
-        self, 
-        config: 'BaseMcpConfig', 
-        remote_tool_name: str, 
-        arguments: Dict[str, Any]
-    ) -> Any:
-        logger.warning(f"SseMcpCallHandler for server '{config.server_id}' is a placeholder and not fully implemented.")
-        raise NotImplementedError(f"SSE transport is not fully implemented for tool call to '{remote_tool_name}'.")

autobyteus/tools/mcp/registrar.py

@@ -1,323 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/registrar.py
-import logging
-from typing import Any, Dict, List, Optional, Union
-
-# Import the new handler architecture components
-from .call_handlers import (
-    McpCallHandler,
-    StdioMcpCallHandler,
-    StreamableHttpMcpCallHandler,
-    SseMcpCallHandler
-)
-
-# Consolidated imports from the autobyteus.autobyteus.mcp package public API
-from autobyteus.tools.mcp import (
-    McpConfigService,
-    McpSchemaMapper,
-    McpToolFactory,
-    McpTransportType,
-    BaseMcpConfig
-)
-
-from autobyteus.tools.registry import ToolRegistry, ToolDefinition
-from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.utils.singleton import SingletonMeta
-from mcp import types as mcp_types
-
-
-logger = logging.getLogger(__name__)
-
-class McpToolRegistrar(metaclass=SingletonMeta):
-    """
-    Orchestrates the discovery of remote MCP tools and their registration
-    with the AutoByteUs ToolRegistry using a handler-based architecture.
-    This class is a singleton.
-    """
-    def __init__(self):
-        """
-        Initializes the McpToolRegistrar singleton.
-        It retrieves singleton instances of its service dependencies and initializes
-        its internal state for tracking registered tools.
-        """
-        self._config_service: McpConfigService = McpConfigService()
-        self._tool_registry: ToolRegistry = ToolRegistry()
-        
-        # The handler registry maps a transport type to a reusable handler instance.
-        self._handler_registry: Dict[McpTransportType, McpCallHandler] = {
-            McpTransportType.STDIO: StdioMcpCallHandler(),
-            McpTransportType.STREAMABLE_HTTP: StreamableHttpMcpCallHandler(),
-            McpTransportType.SSE: SseMcpCallHandler(),
-        }
-
-        # Internal state to track which ToolDefinitions were registered from which server.
-        self._registered_tools_by_server: Dict[str, List[ToolDefinition]] = {}
-        
-        logger.info(f"McpToolRegistrar initialized with {len(self._handler_registry)} call handlers.")
-
-    def _create_tool_definition_from_remote(
-        self,
-        remote_tool: mcp_types.Tool,
-        server_config: BaseMcpConfig,
-        handler: McpCallHandler,
-        schema_mapper: McpSchemaMapper
-    ) -> ToolDefinition:
-        """
-        Maps a single remote tool from an MCP server to an AutoByteUs ToolDefinition.
-        This is a helper method to centralize the mapping logic.
-        """
-        if hasattr(remote_tool, 'model_dump_json'):
-            logger.debug(f"Processing remote tool from server '{server_config.server_id}':\n{remote_tool.model_dump_json(indent=2)}")
-
-        actual_arg_schema = schema_mapper.map_to_autobyteus_schema(remote_tool.inputSchema)
-        actual_desc = remote_tool.description
-        
-        registered_name = remote_tool.name
-        if server_config.tool_name_prefix:
-            registered_name = f"{server_config.tool_name_prefix.rstrip('_')}_{remote_tool.name}"
-
-        tool_factory = McpToolFactory(
-            mcp_server_config=server_config,
-            mcp_remote_tool_name=remote_tool.name,
-            mcp_call_handler=handler,
-            registered_tool_name=registered_name,
-            tool_description=actual_desc,
-            tool_argument_schema=actual_arg_schema
-        )
-        
-        tool_def = ToolDefinition(
-            name=registered_name,
-            description=actual_desc,
-            argument_schema=actual_arg_schema,
-            category=ToolCategory.MCP,
-            custom_factory=tool_factory.create_tool,
-            config_schema=None,
-            tool_class=None
-        )
-        return tool_def
-
-    async def discover_and_register_tools(self, mcp_config: Optional[Union[BaseMcpConfig, Dict[str, Any]]] = None) -> List[ToolDefinition]:
-        """
-        Discovers tools from MCP servers and registers them.
-
-        If `mcp_config` is provided (as a validated object or a raw dictionary),
-        it discovers tools only from that specific server, unregistering any
-        of its old tools first.
-        
-        If `mcp_config` is None, it unregisters all existing MCP tools and then
-        discovers tools from all enabled servers found in the McpConfigService.
-        
-        Returns:
-            A list of ToolDefinition objects for all tools that were successfully
-            discovered and registered during this call.
-        """
-        configs_to_process: List[BaseMcpConfig]
-        
-        if mcp_config:
-            validated_config: BaseMcpConfig
-            # If the user provided a raw dictionary, parse and add it via the service.
-            if isinstance(mcp_config, dict):
-                try:
-                    validated_config = self._config_service.load_config(mcp_config)
-                except ValueError as e:
-                    logger.error(f"Failed to parse provided MCP config dictionary: {e}")
-                    raise
-            # If a validated object was passed, add it to the service to ensure it's known.
-            elif isinstance(mcp_config, BaseMcpConfig):
-                validated_config = self._config_service.add_config(mcp_config)
-            else:
-                raise TypeError(f"mcp_config must be a BaseMcpConfig object or a dictionary, not {type(mcp_config)}.")
-            
-            logger.info(f"Starting targeted MCP tool discovery for server: {validated_config.server_id}")
-            # Unregister any existing tools from this server before re-discovering.
-            self.unregister_tools_from_server(validated_config.server_id)
-            configs_to_process = [validated_config]
-        else:
-            logger.info("Starting full MCP tool discovery and registration process. Unregistering all existing MCP tools first.")
-            # Get a copy of all server IDs that have tools registered.
-            all_server_ids = list(self._registered_tools_by_server.keys())
-            for server_id in all_server_ids:
-                self.unregister_tools_from_server(server_id)
-            
-            # The registrar's internal state should now be empty, but a clear() is a good safeguard.
-            self._registered_tools_by_server.clear()
-            
-            configs_to_process = self._config_service.get_all_configs()
-
-        if not configs_to_process:
-            logger.info("No MCP server configurations to process. Skipping discovery.")
-            return []
-
-        schema_mapper = McpSchemaMapper()
-        registered_tool_definitions: List[ToolDefinition] = []
-        for server_config in configs_to_process:
-            if not server_config.enabled:
-                logger.info(f"MCP server '{server_config.server_id}' is disabled. Skipping.")
-                continue
-
-            logger.info(f"Discovering tools from MCP server: '{server_config.server_id}' ({server_config.transport_type.value})")
-            try:
-                handler = self._handler_registry.get(server_config.transport_type)
-                if not handler:
-                    logger.error(f"No MCP call handler found for transport type '{server_config.transport_type.value}' on server '{server_config.server_id}'.")
-                    continue
-
-                remote_tools_result = await handler.handle_call(
-                    config=server_config,
-                    remote_tool_name="list_tools",
-                    arguments={}
-                )
-                
-                if not isinstance(remote_tools_result, mcp_types.ListToolsResult):
-                    logger.error(f"Expected ListToolsResult from handler for 'list_tools', but got {type(remote_tools_result)}. Skipping server '{server_config.server_id}'.")
-                    continue
-
-                actual_remote_tools: list[mcp_types.Tool] = remote_tools_result.tools
-                logger.info(f"Discovered {len(actual_remote_tools)} tools from server '{server_config.server_id}'.")
-
-                for remote_tool in actual_remote_tools: 
-                    try:
-                        tool_def = self._create_tool_definition_from_remote(remote_tool, server_config, handler, schema_mapper)
-                        
-                        self._tool_registry.register_tool(tool_def)
-                        self._registered_tools_by_server.setdefault(server_config.server_id, []).append(tool_def)
-                        registered_tool_definitions.append(tool_def)
-                        
-                        logger.info(f"Successfully registered MCP tool '{remote_tool.name}' from server '{server_config.server_id}' as '{tool_def.name}'.")
-
-                    except Exception as e_tool:
-                        logger.error(f"Failed to process or register remote tool '{remote_tool.name}' from server '{server_config.server_id}': {e_tool}", exc_info=True)
-            
-            except Exception as e_server:
-                logger.error(f"Failed to discover tools from MCP server '{server_config.server_id}': {e_server}", exc_info=True)
-        
-        logger.info(f"MCP tool discovery and registration process completed. Total tools registered: {len(registered_tool_definitions)}.")
-        return registered_tool_definitions
-
-    async def list_remote_tools(self, mcp_config: Union[BaseMcpConfig, Dict[str, Any]]) -> List[ToolDefinition]:
-        """
-        Previews tools from a remote MCP server without registering them or storing the configuration.
-        This is a stateless "dry-run" or "preview" operation.
-
-        Args:
-            mcp_config: A single MCP server configuration, as a validated object or a raw dictionary.
-        
-        Returns:
-            A list of ToolDefinition objects for all tools discovered on the server.
-        
-        Raises:
-            TypeError: If mcp_config is not a supported type.
-            ValueError: If the provided configuration is invalid.
-            RuntimeError: If the connection or tool call to the remote server fails.
-        """
-        validated_config: BaseMcpConfig
-        if isinstance(mcp_config, dict):
-            # Use the static method to parse the config without storing it in the service.
-            validated_config = McpConfigService.parse_mcp_config_dict(mcp_config)
-        elif isinstance(mcp_config, BaseMcpConfig):
-            validated_config = mcp_config
-        else:
-            raise TypeError(f"mcp_config must be a BaseMcpConfig object or a dictionary, not {type(mcp_config)}.")
-        
-        logger.info(f"Previewing tools from MCP server: '{validated_config.server_id}' ({validated_config.transport_type.value})")
-        
-        schema_mapper = McpSchemaMapper()
-        tool_definitions: List[ToolDefinition] = []
-
-        try:
-            handler = self._handler_registry.get(validated_config.transport_type)
-            if not handler:
-                raise ValueError(f"No MCP call handler found for transport type '{validated_config.transport_type.value}'.")
-
-            remote_tools_result = await handler.handle_call(
-                config=validated_config,
-                remote_tool_name="list_tools",
-                arguments={}
-            )
-            
-            if not isinstance(remote_tools_result, mcp_types.ListToolsResult):
-                error_msg = f"Expected ListToolsResult from handler, but got {type(remote_tools_result)}. Cannot preview tools from server '{validated_config.server_id}'."
-                logger.error(error_msg)
-                raise RuntimeError(error_msg)
-
-            actual_remote_tools: list[mcp_types.Tool] = remote_tools_result.tools
-            logger.info(f"Discovered {len(actual_remote_tools)} tools from server '{validated_config.server_id}' for preview.")
-
-            for remote_tool in actual_remote_tools:
-                try:
-                    tool_def = self._create_tool_definition_from_remote(remote_tool, validated_config, handler, schema_mapper)
-                    tool_definitions.append(tool_def)
-                except Exception as e_tool:
-                    logger.error(f"Failed to map remote tool '{remote_tool.name}' from server '{validated_config.server_id}' during preview: {e_tool}", exc_info=True)
-                    # For a preview, we continue to show other valid tools.
-            
-        except Exception as e_server:
-            logger.error(f"Failed to discover tools for preview from MCP server '{validated_config.server_id}': {e_server}", exc_info=True)
-            # Re-raise server-level exceptions to the caller as per AC5.
-            raise
-            
-        logger.info(f"MCP tool preview completed. Found {len(tool_definitions)} tools.")
-        return tool_definitions
-
-    def get_registered_tools_for_server(self, server_id: str) -> List[ToolDefinition]:
-        """
-        Returns a list of ToolDefinition objects that were successfully registered 
-        from a specific MCP server during the most recent discovery process.
-
-        Args:
-            server_id: The unique ID of the MCP server to query.
-
-        Returns:
-            A list of ToolDefinition objects. Returns an empty list if the server ID
-            is not found or registered no tools.
-        """
-        return self._registered_tools_by_server.get(server_id, [])
-
-    def get_all_registered_mcp_tools(self) -> List[ToolDefinition]:
-        """
-        Returns a flat list of all ToolDefinitions registered from any MCP server.
-        """
-        all_tools = []
-        for server_tools in self._registered_tools_by_server.values():
-            all_tools.extend(server_tools)
-        return all_tools
-
-    def is_server_registered(self, server_id: str) -> bool:
-        """
-        Checks if any tools from a specific MCP server are currently registered.
-
-        Args:
-            server_id: The unique ID of the MCP server.
-
-        Returns:
-            True if the server has tools registered, False otherwise.
-        """
-        is_registered = server_id in self._registered_tools_by_server
-        logger.debug(f"Checking if server '{server_id}' is registered: {is_registered}")
-        return is_registered
-
-    def unregister_tools_from_server(self, server_id: str) -> bool:
-        """
-        Unregisters all tools associated with a given MCP server ID from the
-        main ToolRegistry and removes the server from internal tracking.
-
-        Args:
-            server_id: The unique ID of the MCP server whose tools should be unregistered.
-
-        Returns:
-            True if the server was found and its tools were processed for unregistration,
-            False if the server was not found in the registrar's state.
-        """
-        if not self.is_server_registered(server_id):
-            logger.info(f"No tools found for server ID '{server_id}'. Nothing to unregister.")
-            return False
-
-        tools_to_unregister = self._registered_tools_by_server.get(server_id, [])
-        logger.info(f"Unregistering {len(tools_to_unregister)} tools from server ID: '{server_id}'...")
-
-        for tool_def in tools_to_unregister:
-            self._tool_registry.unregister_tool(tool_def.name)
-
-        # Remove the server from the tracking dictionary
-        del self._registered_tools_by_server[server_id]
-        logger.info(f"Successfully unregistered all tools and removed server '{server_id}' from registrar tracking.")
-        return True