autobyteus 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

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/__init__.py

@@ -1,16 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/__init__.py
-"""
-This package contains the MCP Call Handlers.
-Each handler is responsible for performing a complete, end-to-end tool call
-for a specific transport protocol (e.g., STDIO, Streamable HTTP).
-"""
-
-from .base_handler import McpCallHandler
-from .stdio_handler import StdioMcpCallHandler
-from .streamable_http_handler import StreamableHttpMcpCallHandler
-
-__all__ = [
-    "McpCallHandler",
-    "StdioMcpCallHandler",
-    "StreamableHttpMcpCallHandler",
-]

autobyteus/tools/mcp/call_handlers/base_handler.py

@@ -1,40 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/base_handler.py
-import logging
-from abc import ABC, abstractmethod
-from typing import Dict, Any, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ..types import BaseMcpConfig
-
-logger = logging.getLogger(__name__)
-
-class McpCallHandler(ABC):
-    """
-    Abstract base class for a handler that performs a single, end-to-end
-    MCP tool call for a specific transport protocol.
-    """
-
-    @abstractmethod
-    async def handle_call(
-        self, 
-        config: 'BaseMcpConfig', 
-        remote_tool_name: str, 
-        arguments: Dict[str, Any]
-    ) -> Any:
-        """
-        Handles a complete MCP tool call, including connection, execution,
-        and disconnection if necessary.
-
-        Args:
-            config: The configuration object for the target MCP server.
-            remote_tool_name: The name of the tool to call on the remote server.
-            arguments: A dictionary of arguments for the tool call.
-
-        Returns:
-            The result returned by the remote tool.
-            
-        Raises:
-            NotImplementedError: If the handler for a specific transport is not implemented.
-            RuntimeError: If the tool call fails for any reason.
-        """
-        pass

autobyteus/tools/mcp/call_handlers/stdio_handler.py

@@ -1,76 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/stdio_handler.py
-import logging
-import asyncio
-from typing import Dict, Any, cast, TYPE_CHECKING
-
-from .base_handler import McpCallHandler
-from mcp import StdioServerParameters, ClientSession
-from mcp.client.stdio import stdio_client
-
-if TYPE_CHECKING:
-    from ..types import BaseMcpConfig, StdioMcpServerConfig
-
-logger = logging.getLogger(__name__)
-
-# A default timeout for STDIO subprocesses to prevent indefinite hangs.
-DEFAULT_STDIO_TIMEOUT = 30  # seconds
-
-class StdioMcpCallHandler(McpCallHandler):
-    """Handles MCP tool calls over a stateless STDIO transport."""
-
-    async def handle_call(
-        self, 
-        config: 'BaseMcpConfig', 
-        remote_tool_name: str, 
-        arguments: Dict[str, Any]
-    ) -> Any:
-        """
-        Creates a new subprocess, establishes a session, and executes the
-        requested tool call. It handles 'list_tools' as a special case.
-        Includes a timeout to prevent hanging on unresponsive subprocesses.
-        """
-        logger.debug(f"Handling STDIO call to tool '{remote_tool_name}' on server '{config.server_id}'.")
-        
-        from ..types import StdioMcpServerConfig
-        if not isinstance(config, StdioMcpServerConfig):
-            raise TypeError(f"StdioMcpCallHandler requires a StdioMcpServerConfig, but got {type(config).__name__}.")
-        
-        stdio_config = cast(StdioMcpServerConfig, config)
-
-        mcp_lib_stdio_params = StdioServerParameters(
-            command=stdio_config.command,
-            args=stdio_config.args,
-            env=stdio_config.env,
-            cwd=stdio_config.cwd
-        )
-
-        async def _perform_call():
-            """Inner function to be wrapped by the timeout."""
-            # The stdio_client context manager provides the read/write streams.
-            async with stdio_client(mcp_lib_stdio_params) as (read_stream, write_stream):
-                # The ClientSession is its own context manager that handles initialization.
-                async with ClientSession(read_stream, write_stream) as session:
-                    logger.debug(f"STDIO session established for '{config.server_id}'. Calling tool '{remote_tool_name}'.")
-                    
-                    # The 'list_tools' command is a special method on the session.
-                    if remote_tool_name == "list_tools":
-                        result = await session.list_tools()
-                    else:
-                        result = await session.call_tool(remote_tool_name, arguments)
-                    
-                    logger.debug(f"STDIO call to tool '{remote_tool_name}' on server '{config.server_id}' completed.")
-                    return result
-
-        try:
-            return await asyncio.wait_for(_perform_call(), timeout=DEFAULT_STDIO_TIMEOUT)
-        except asyncio.TimeoutError:
-            error_message = (f"MCP call to '{remote_tool_name}' on server '{config.server_id}' timed out "
-                             f"after {DEFAULT_STDIO_TIMEOUT} seconds. The subprocess may have hung.")
-            logger.error(error_message)
-            raise RuntimeError(error_message) from None
-        except Exception as e:
-            logger.error(
-                f"An error occurred during STDIO tool call to '{remote_tool_name}' on server '{config.server_id}': {e}",
-                exc_info=True
-            )
-            raise RuntimeError(f"Failed to execute MCP tool '{remote_tool_name}' via STDIO on server '{config.server_id}': {e}") from e

autobyteus/tools/mcp/call_handlers/streamable_http_handler.py

@@ -1,55 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/call_handlers/streamable_http_handler.py
-import logging
-from typing import Dict, Any, cast, TYPE_CHECKING
-
-from .base_handler import McpCallHandler
-from mcp import ClientSession
-from mcp.client.streamable_http import streamablehttp_client
-
-if TYPE_CHECKING:
-    from ..types import BaseMcpConfig, StreamableHttpMcpServerConfig
-
-logger = logging.getLogger(__name__)
-
-class StreamableHttpMcpCallHandler(McpCallHandler):
-    """Handles MCP tool calls over a stateless Streamable HTTP transport."""
-
-    async def handle_call(
-        self, 
-        config: 'BaseMcpConfig', 
-        remote_tool_name: str, 
-        arguments: Dict[str, Any]
-    ) -> Any:
-        """
-        Creates a new HTTP connection, establishes a session, and executes the
-        requested tool call. It handles 'list_tools' as a special case.
-        """
-        logger.debug(f"Handling Streamable HTTP call to tool '{remote_tool_name}' on server '{config.server_id}'.")
-        
-        from ..types import StreamableHttpMcpServerConfig
-        if not isinstance(config, StreamableHttpMcpServerConfig):
-            raise TypeError(f"StreamableHttpMcpCallHandler requires a StreamableHttpMcpServerConfig, got {type(config).__name__}.")
-
-        http_config = cast(StreamableHttpMcpServerConfig, config)
-
-        try:
-            # The streamablehttp_client context manager provides the read/write streams.
-            async with streamablehttp_client(http_config.url, headers=http_config.headers) as (read_stream, write_stream):
-                # The ClientSession is its own context manager that handles initialization.
-                async with ClientSession(read_stream, write_stream) as session:
-                    logger.debug(f"Streamable HTTP session established for '{config.server_id}'. Calling tool '{remote_tool_name}'.")
-
-                    # The 'list_tools' command is a special method on the session.
-                    if remote_tool_name == "list_tools":
-                        result = await session.list_tools()
-                    else:
-                        result = await session.call_tool(remote_tool_name, arguments)
-
-                    logger.debug(f"Streamable HTTP call to tool '{remote_tool_name}' on server '{config.server_id}' completed.")
-                    return result
-        except Exception as e:
-            logger.error(
-                f"An error occurred during Streamable HTTP tool call to '{remote_tool_name}' on server '{config.server_id}': {e}",
-                exc_info=True
-            )
-            raise RuntimeError(f"Failed to execute MCP tool '{remote_tool_name}' via Streamable HTTP on server '{config.server_id}': {e}") from e

autobyteus/tools/mcp/registrar.py

@@ -1,202 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp/registrar.py
-import logging
-from typing import Any, Dict, List, Optional, Union
-
-# Consolidated imports from the autobyteus.autobyteus.mcp package public API
-from .config_service import McpConfigService
-from .factory import McpToolFactory
-from .schema_mapper import McpSchemaMapper
-from .types import BaseMcpConfig, McpTransportType
-from .server import StdioManagedMcpServer, HttpManagedMcpServer, BaseManagedMcpServer
-
-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 stateful, server-centric architecture.
-    """
-    def __init__(self):
-        """
-        Initializes the McpToolRegistrar singleton.
-        """
-        self._config_service: McpConfigService = McpConfigService()
-        self._tool_registry: ToolRegistry = ToolRegistry()
-        self._registered_tools_by_server: Dict[str, List[ToolDefinition]] = {}
-        logger.info("McpToolRegistrar initialized.")
-
-    def _create_server_instance_for_discovery(self, server_config: BaseMcpConfig) -> BaseManagedMcpServer:
-        """Creates a server instance based on transport type."""
-        if server_config.transport_type == McpTransportType.STDIO:
-            return StdioManagedMcpServer(server_config)
-        elif server_config.transport_type == McpTransportType.STREAMABLE_HTTP:
-            return HttpManagedMcpServer(server_config)
-        else:
-            raise NotImplementedError(f"Discovery not implemented for transport type: {server_config.transport_type}")
-
-    async def _fetch_tools_from_server(self, server_config: BaseMcpConfig) -> List[mcp_types.Tool]:
-        """
-        Creates a temporary server instance to perform a single, one-shot
-        tool discovery, ensuring resources are properly closed.
-        """
-        discovery_server = self._create_server_instance_for_discovery(server_config)
-        try:
-            # The list_remote_tools method implicitly handles the connection.
-            remote_tools = await discovery_server.list_remote_tools()
-            return remote_tools
-        finally:
-            # The finally block guarantees the temporary server connection is closed.
-            await discovery_server.close()
-
-    def _create_tool_definition_from_remote(
-        self,
-        remote_tool: mcp_types.Tool,
-        server_config: BaseMcpConfig,
-        schema_mapper: McpSchemaMapper
-    ) -> ToolDefinition:
-        """
-        Maps a single remote tool from an MCP server to an AutoByteUs ToolDefinition.
-        """
-        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}"
-
-        # The factory now only needs key identifiers, not live objects.
-        tool_factory = McpToolFactory(
-            server_id=server_config.server_id,
-            remote_tool_name=remote_tool.name,
-            registered_tool_name=registered_name,
-            tool_description=actual_desc,
-            tool_argument_schema=actual_arg_schema
-        )
-        
-        return 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
-        )
-
-    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.
-        This process uses a helper to manage short-lived server instances for discovery.
-        """
-        configs_to_process: List[BaseMcpConfig]
-        
-        if mcp_config:
-            if isinstance(mcp_config, dict):
-                configs_to_process = [self._config_service.load_config(mcp_config)]
-            elif isinstance(mcp_config, BaseMcpConfig):
-                configs_to_process = [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: {configs_to_process[0].server_id}")
-            self.unregister_tools_from_server(configs_to_process[0].server_id)
-        else:
-            logger.info("Starting full MCP tool discovery. Unregistering all existing MCP tools first.")
-            all_server_ids = list(self._registered_tools_by_server.keys())
-            for server_id in all_server_ids:
-                self.unregister_tools_from_server(server_id)
-            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:
-                # The helper abstracts away the connect/close lifecycle for discovery.
-                remote_tools = await self._fetch_tools_from_server(server_config)
-                logger.info(f"Discovered {len(remote_tools)} tools from server '{server_config.server_id}'.")
-
-                for remote_tool in remote_tools:
-                    try:
-                        tool_def = self._create_tool_definition_from_remote(remote_tool, server_config, 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}': {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.
-        This is a stateless "dry-run" or "preview" operation.
-        """
-        validated_config: BaseMcpConfig
-        if isinstance(mcp_config, dict):
-            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:
-            # Use the same helper to fetch tools, abstracting away the connection lifecycle.
-            remote_tools = await self._fetch_tools_from_server(validated_config)
-            logger.info(f"Discovered {len(remote_tools)} tools from server '{validated_config.server_id}' for preview.")
-
-            for remote_tool in remote_tools:
-                try:
-                    tool_def = self._create_tool_definition_from_remote(remote_tool, validated_config, 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)
-            
-        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)
-            raise
-            
-        logger.info(f"MCP tool preview completed. Found {len(tool_definitions)} tools.")
-        return tool_definitions
-
-    def unregister_tools_from_server(self, server_id: str) -> bool:
-        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.pop(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)
-        logger.info(f"Successfully unregistered all tools and removed server '{server_id}' from registrar tracking.")
-        return True
-        
-    def is_server_registered(self, server_id: str) -> bool:
-        return server_id in self._registered_tools_by_server

autobyteus/tools/usage/providers/json_example_provider.py

@@ -1,32 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/providers/json_example_provider.py
-from typing import Optional, Any, TYPE_CHECKING
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.registries.json_example_formatter_registry import JsonExampleFormatterRegistry
-
-if TYPE_CHECKING:
-    from autobyteus.tools.registry import ToolDefinition
-
-class JsonExampleProvider:
-    """Provides a tool usage example as a JSON dictionary for a specific LLM provider."""
-
-    def __init__(self):
-        self._registry = JsonExampleFormatterRegistry()
-
-    def provide(self, tool_definition: 'ToolDefinition', llm_provider: Optional[LLMProvider] = None) -> Any:
-        """
-        Generates a JSON dictionary or string for a single tool usage example.
-
-        Args:
-            tool_definition: A ToolDefinition object.
-            llm_provider: The LLMProvider for which to format the JSON.
-
-        Returns:
-            A dictionary or string representing the tool usage example.
-        """
-        if llm_provider:
-            formatter = self._registry.get_formatter(llm_provider)
-        else:
-            formatter = self._registry.get_default_formatter()
-
-        return formatter.provide(tool_definition)

autobyteus/tools/usage/providers/json_schema_provider.py

@@ -1,35 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/providers/json_schema_provider.py
-from typing import Optional, Dict, TYPE_CHECKING
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.registries.json_schema_formatter_registry import JsonSchemaFormatterRegistry
-
-if TYPE_CHECKING:
-    from autobyteus.tools.registry import ToolDefinition
-
-class JsonSchemaProvider:
-    """
-    Provides the schema for a single tool formatted as a JSON dictionary,
-    tailored to the specific LLM provider's requirements.
-    """
-    def __init__(self):
-        self._registry = JsonSchemaFormatterRegistry()
-
-    def provide(self, tool_definition: 'ToolDefinition', llm_provider: Optional[LLMProvider] = None) -> Dict:
-        """
-        Generates a JSON dictionary for a single tool's schema.
-
-        Args:
-            tool_definition: A ToolDefinition object.
-            llm_provider: The LLMProvider for which to format the JSON. If None,
-                          a default generic format is used.
-
-        Returns:
-            A dictionary representing the tool schema.
-        """
-        if llm_provider:
-            formatter = self._registry.get_formatter(llm_provider)
-        else:
-            formatter = self._registry.get_default_formatter()
-
-        return formatter.provide(tool_definition)

autobyteus/tools/usage/providers/json_tool_usage_parser_provider.py

@@ -1,28 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/providers/json_tool_usage_parser_provider.py
-from typing import Optional, TYPE_CHECKING
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.registries.json_tool_usage_parser_registry import JsonToolUsageParserRegistry
-
-if TYPE_CHECKING:
-    from autobyteus.tools.usage.parsers.base_parser import BaseToolUsageParser
-
-class JsonToolUsageParserProvider:
-    """Provides a tool usage parser for JSON-based responses, specific to an LLM provider."""
-
-    def __init__(self):
-        self._registry = JsonToolUsageParserRegistry()
-
-    def provide(self, llm_provider: Optional[LLMProvider] = None) -> 'BaseToolUsageParser':
-        """
-        Gets the appropriate parser from the registry.
-
-        Args:
-            llm_provider: The LLMProvider for which to get a parser.
-
-        Returns:
-            An instance of a class derived from BaseToolUsageParser.
-        """
-        if llm_provider:
-            return self._registry.get_parser(llm_provider)
-        return self._registry.get_default_parser()

autobyteus/tools/usage/providers/xml_example_provider.py

@@ -1,28 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/providers/xml_example_provider.py
-from typing import Optional, TYPE_CHECKING
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.registries.xml_example_formatter_registry import XmlExampleFormatterRegistry
-
-if TYPE_CHECKING:
-    from autobyteus.tools.registry import ToolDefinition
-
-class XmlExampleProvider:
-    """Provides a tool usage example formatted as a single XML string."""
-
-    def __init__(self):
-        self._registry = XmlExampleFormatterRegistry()
-
-    def provide(self, tool_definition: 'ToolDefinition', llm_provider: Optional[LLMProvider] = None) -> str:
-        """
-        Generates a single XML string for a tool usage example.
-
-        Args:
-            tool_definition: A ToolDefinition object.
-            llm_provider: Ignored, for API consistency.
-
-        Returns:
-            A string containing the XML tool usage example.
-        """
-        formatter = self._registry.get_formatter(llm_provider)
-        return formatter.provide(tool_definition)