autobyteus 1.0.5__tar.gz → 1.0.6__tar.gz

{autobyteus-1.0.5 → autobyteus-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.0.5
+Version: 1.0.6
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -28,7 +28,7 @@ Requires-Dist: Jinja2
 Requires-Dist: ollama==0.4.5
 Requires-Dist: mistral_common
 Requires-Dist: aiohttp
-Requires-Dist: autobyteus-llm-client==1.0.9
+Requires-Dist: autobyteus-llm-client==1.1.0
 Requires-Dist: brui-core==1.0.8
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"

{autobyteus-1.0.5 → autobyteus-1.0.6}/autobyteus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.0.5
+Version: 1.0.6
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -28,7 +28,7 @@ Requires-Dist: Jinja2
 Requires-Dist: ollama==0.4.5
 Requires-Dist: mistral_common
 Requires-Dist: aiohttp
-Requires-Dist: autobyteus-llm-client==1.0.9
+Requires-Dist: autobyteus-llm-client==1.1.0
 Requires-Dist: brui-core==1.0.8
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"

{autobyteus-1.0.5 → autobyteus-1.0.6}/autobyteus.egg-info/SOURCES.txt

@@ -14,11 +14,9 @@ autobyteus/agent/agent.py
 autobyteus/agent/async_agent.py
 autobyteus/agent/async_group_aware_agent.py
 autobyteus/agent/exceptions.py
-autobyteus/agent/remote_agent.py
 autobyteus/agent/status.py
 autobyteus/agent/tool_invocation.py
 autobyteus/agent/factory/__init__.py
-autobyteus/agent/factory/agent_factory.py
 autobyteus/agent/group/__init__.py
 autobyteus/agent/group/async_group_aware_agent.py
 autobyteus/agent/group/coordinator_agent.py
@@ -31,9 +29,6 @@ autobyteus/agent/orchestrator/__init__.py
 autobyteus/agent/orchestrator/base_agent_orchestrator.py
 autobyteus/agent/orchestrator/multi_replica_agent_orchestrator.py
 autobyteus/agent/orchestrator/single_replica_agent_orchestrator.py
-autobyteus/agent/registry/__init__.py
-autobyteus/agent/registry/agent_definition.py
-autobyteus/agent/registry/agent_registry.py
 autobyteus/agent/response_parser/__init__.py
 autobyteus/agent/response_parser/tool_usage_command_parser.py
 autobyteus/conversation/__init__.py
@@ -100,7 +95,6 @@ autobyteus/tools/__init__.py
 autobyteus/tools/ask_user_input.py
 autobyteus/tools/base_tool.py
 autobyteus/tools/image_downloader.py
-autobyteus/tools/mcp_remote_tool.py
 autobyteus/tools/pdf_downloader.py
 autobyteus/tools/timer.py
 autobyteus/tools/tool_meta.py

{autobyteus-1.0.5 → autobyteus-1.0.6}/autobyteus.egg-info/requires.txt

@@ -12,7 +12,7 @@ Jinja2
 ollama==0.4.5
 mistral_common
 aiohttp
-autobyteus-llm-client==1.0.9
+autobyteus-llm-client==1.1.0
 brui-core==1.0.8
 
 [dev]

{autobyteus-1.0.5 → autobyteus-1.0.6}/setup.py

@@ -16,13 +16,13 @@ common_dependencies = [
     "ollama==0.4.5",
     "mistral_common",
     "aiohttp",
-    "autobyteus-llm-client==1.0.9",
+    "autobyteus-llm-client==1.1.0",
     "brui-core==1.0.8",
 ]
 
 setup(
     name="autobyteus",
-    version="1.0.5",
+    version="1.0.6",
     packages=find_packages(exclude=["tests", "tests.*"]),
     include_package_data=True,
     install_requires=[

autobyteus-1.0.5/autobyteus/agent/factory/agent_factory.py

@@ -1,94 +0,0 @@
-# file: autobyteus/agent/factory/agent_factory.py
-import logging
-from autobyteus.agent.agent import Agent
-from autobyteus.agent.group.group_aware_agent import GroupAwareAgent
-from autobyteus.llm.llm_factory import LLMFactory
-from autobyteus.tools.factory.tool_factory import ToolFactory
-from autobyteus.prompt.prompt_builder import PromptBuilder
-from autobyteus.llm.models import LLMModel
-from typing import List, Union
-
-logger = logging.getLogger(__name__)
-
-class AgentFactory:
-    """
-    Factory class for creating different types of agents.
-
-    This factory simplifies the creation of Agent instances by encapsulating
-    the necessary dependencies and configurations.
-    """
-    def __init__(self,
-                 role: str,
-                 agent_type: str,
-                 tool_factory: ToolFactory,
-                 llm_factory: LLMFactory,
-                 prompt_builder: PromptBuilder, # Agent requires prompt_builder or initial_user_message
-                 llm_model: LLMModel,
-                 tool_names: List[str]):
-        """
-        Initializes the AgentFactory.
-
-        Args:
-            role: The role the created agents will fulfill.
-            agent_type: The type of agent to create ("standalone" or "group_aware").
-            tool_factory: A factory to create tool instances.
-            llm_factory: A factory to create LLM instances.
-            prompt_builder: The PromptBuilder instance to configure the agent's system prompt.
-            llm_model: The specific LLM model configuration to use.
-            tool_names: A list of tool names the agent should be equipped with.
-        """
-        self.role = role
-        self.agent_type = agent_type
-        self.tool_factory = tool_factory
-        self.llm_factory = llm_factory
-        self.prompt_builder = prompt_builder
-        self.llm_model = llm_model
-        self.tool_names = tool_names
-        logger.info(f"AgentFactory initialized for role '{role}' and type '{agent_type}'")
-
-    def create_agent(self, agent_id: str) -> Union[Agent, GroupAwareAgent]:
-        """
-        Creates an agent instance based on the factory's configuration.
-
-        Args:
-            agent_id: The unique identifier for the agent being created.
-
-        Returns:
-            An instance of Agent or GroupAwareAgent.
-
-        Raises:
-            ValueError: If the configured agent_type is unsupported.
-        """
-        logger.info(f"Creating agent with id '{agent_id}' for role '{self.role}' and type '{self.agent_type}'")
-        try:
-            tools = [self.tool_factory.create_tool(name) for name in self.tool_names]
-            logger.debug(f"Tools created for agent '{agent_id}': {[tool.get_name() for tool in tools]}")
-        except Exception as e:
-            logger.error(f"Error creating tools for agent '{agent_id}': {e}")
-            raise ValueError(f"Failed to create tools for agent {agent_id}: {e}") from e
-
-        try:
-            llm = self.llm_factory.create_llm(self.llm_model)
-            logger.debug(f"LLM instance created for agent '{agent_id}' using model '{self.llm_model.model_name}'")
-        except Exception as e:
-            logger.error(f"Error creating LLM for agent '{agent_id}': {e}")
-            raise ValueError(f"Failed to create LLM for agent {agent_id}: {e}") from e
-
-        agent_args = {
-            "agent_id": agent_id,
-            "role": self.role,
-            "prompt_builder": self.prompt_builder,
-            "llm": llm,
-            "tools": tools
-        }
-
-        if self.agent_type == "standalone":
-            logger.debug(f"Instantiating Agent with args: {agent_args}")
-            return Agent(**agent_args)
-        elif self.agent_type == "group_aware":
-            logger.debug(f"Instantiating GroupAwareAgent with args: {agent_args}")
-            return GroupAwareAgent(**agent_args)
-        else:
-            logger.error(f"Unsupported agent type specified in factory: {self.agent_type}")
-            raise ValueError(f"Unsupported agent type: {self.agent_type}")
-

autobyteus-1.0.5/autobyteus/agent/registry/__init__.py

@@ -1,11 +0,0 @@
-# file: autobyteus/autobyteus/agent/registry/__init__.py
-from .agent_definition import AgentDefinition
-from .agent_registry import AgentRegistry, default_agent_registry
-from autobyteus.agent.factory.agent_factory import AgentFactory
-
-__all__ = [
-    "AgentDefinition",
-    "AgentRegistry",
-    "default_agent_registry",
-    "AgentFactory"
-]

autobyteus-1.0.5/autobyteus/agent/registry/agent_definition.py

@@ -1,94 +0,0 @@
-import logging
-from typing import Dict, List, Any, Optional
-
-logger = logging.getLogger(__name__)
-
-class AgentDefinition:
-    """
-    Represents the static definition of an agent, containing its role, description,
-    tools, optional system prompt, and optional initial user message.
-    """
-    def __init__(self,
-                 role: str,
-                 description: str,
-                 tools: List[str],
-                 system_prompt: Optional[str] = None,
-                 initial_user_message: Optional[str] = None):
-        """
-        Initializes the AgentDefinition.
-
-        Args:
-            role: The unique role identifier of the agent (e.g., 'coordinator', 'worker').
-            description: A human-readable description of the agent's purpose.
-            tools: A list of tool names the agent can use.
-            system_prompt: An optional system prompt to configure the LLM's behavior.
-            initial_user_message: An optional initial user message to start the agent's conversation.
-
-        Raises:
-            ValueError: If role, description, or tools are invalid, or if system_prompt or
-                        initial_user_message are not strings when provided.
-        """
-        if not role or not isinstance(role, str):
-            raise ValueError("AgentDefinition requires a non-empty string 'role'.")
-        if not description or not isinstance(description, str):
-            raise ValueError(f"AgentDefinition '{role}' requires a non-empty string 'description'.")
-        if not isinstance(tools, list) or not all(isinstance(t, str) and t for t in tools):
-            raise ValueError(f"AgentDefinition '{role}' requires a non-empty list of tool name strings.")
-        if system_prompt is not None and not isinstance(system_prompt, str):
-            raise ValueError(f"AgentDefinition '{role}' system_prompt must be a string or None.")
-        if initial_user_message is not None and not isinstance(initial_user_message, str):
-            raise ValueError(f"AgentDefinition '{role}' initial_user_message must be a string or None.")
-
-        self._role = role
-        self._description = description
-        self._tools = tools
-        self._system_prompt = system_prompt
-        self._initial_user_message = initial_user_message
-
-        logger.debug(f"AgentDefinition created for role '{self.role}'.")
-
-    @property
-    def role(self) -> str:
-        """The unique role identifier of the agent."""
-        return self._role
-
-    @property
-    def description(self) -> str:
-        """The human-readable description of the agent's purpose."""
-        return self._description
-
-    @property
-    def tools(self) -> List[str]:
-        """The list of tool names the agent can use."""
-        return self._tools
-
-    @property
-    def system_prompt(self) -> Optional[str]:
-        """The optional system prompt for the agent."""
-        return self._system_prompt
-
-    @property
-    def initial_user_message(self) -> Optional[str]:
-        """The optional initial user message for the agent."""
-        return self._initial_user_message
-
-    def __repr__(self) -> str:
-        """Provides a developer-friendly string representation."""
-        desc_repr = self.description
-        if len(desc_repr) > 70:
-            desc_repr = desc_repr[:67] + "..."
-        # Remove newlines/tabs for cleaner logging
-        desc_repr = desc_repr.replace('\n', '\\n').replace('\t', '\\t')
-        return (f"AgentDefinition(role='{self.role}', description='{desc_repr}', "
-                f"tools={self.tools}, system_prompt='{self.system_prompt}', "
-                f"initial_user_message='{self.initial_user_message}')")
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Returns a dictionary representation of the agent definition."""
-        return {
-            "role": self.role,
-            "description": self.description,
-            "tools": self.tools,
-            "system_prompt": self.system_prompt,
-            "initial_user_message": self.initial_user_message
-        }

autobyteus-1.0.5/autobyteus/agent/registry/agent_registry.py

@@ -1,114 +0,0 @@
-# file: autobyteus/autobyteus/agent/registry/agent_registry.py
-import logging
-from typing import Dict, List, Optional
-
-from autobyteus.utils.singleton import SingletonMeta
-from autobyteus.agent.factory.agent_factory import AgentFactory
-from .agent_definition import AgentDefinition
-
-logger = logging.getLogger(__name__)
-
-class AgentRegistry(metaclass=SingletonMeta):
-    """
-    Manages AgentDefinitions (role, description, tools, initial_user_message, agent_class),
-    populated exclusively via programmatic registration. Uses AgentFactory to create agent instances.
-    """
-    _definitions: Dict[str, AgentDefinition] = {}
-
-    def __init__(self, agent_factory: AgentFactory):
-        """
-        Initializes the AgentRegistry with an AgentFactory.
-
-        Args:
-            agent_factory: The AgentFactory instance used to create agent instances.
-        """
-        self.agent_factory = agent_factory
-        logger.info("AgentRegistry initialized with AgentFactory.")
-
-    def register_agent(self, definition: AgentDefinition):
-        """
-        Registers an agent definition (role, description, tools, initial_user_message, agent_class) programmatically.
-
-        Args:
-            definition: The AgentDefinition object to register.
-
-        Raises:
-            ValueError: If the definition is invalid. Overwrites existing definitions with the same role.
-        """
-        if not isinstance(definition, AgentDefinition):
-            raise ValueError("Attempted to register an object that is not an AgentDefinition.")
-
-        role = definition.role
-        if role in self._definitions:
-            logger.warning(f"Overwriting existing agent definition for role: '{role}'")
-        AgentRegistry._definitions[role] = definition
-        logger.info(f"Successfully registered agent definition: '{role}'")
-
-    def get_agent_definition(self, role: str) -> Optional[AgentDefinition]:
-        """
-        Retrieves the definition for a specific agent role.
-
-        Args:
-            role: The unique role of the agent definition to retrieve.
-
-        Returns:
-            The AgentDefinition object if found, otherwise None.
-        """
-        definition = self._definitions.get(role)
-        if not definition:
-            logger.debug(f"Agent definition not found for role: '{role}'")
-        return definition
-
-    def create_agent(self, role: str, agent_id: str):
-        """
-        Creates an agent instance using the AgentFactory based on the agent definition.
-
-        Args:
-            role: The role of the agent to create.
-            agent_id: The unique identifier for the agent instance.
-
-        Returns:
-            The agent instance if the definition exists, otherwise None.
-
-        Raises:
-            ValueError: If the agent definition is not found.
-        """
-        definition = self.get_agent_definition(role)
-        if not definition:
-            logger.error(f"Cannot create agent: No definition found for role '{role}'")
-            raise ValueError(f"No agent definition found for role '{role}'")
-        
-        logger.info(f"Creating agent instance for role '{role}' with id '{agent_id}' using AgentFactory")
-        return self.agent_factory.create_agent(agent_id)
-
-    def list_agents(self) -> List[AgentDefinition]:
-        """
-        Returns a list of all registered agent definitions.
-
-        Returns:
-            A list of AgentDefinition objects.
-        """
-        return list(self._definitions.values())
-
-    def list_agent_roles(self) -> List[str]:
-        """
-        Returns a list of the roles of all registered agents.
-
-        Returns:
-            A list of agent role strings.
-        """
-        return list(self._definitions.keys())
-
-    def get_all_definitions(self) -> Dict[str, AgentDefinition]:
-        """Returns the internal dictionary of definitions."""
-        return dict(AgentRegistry._definitions)
-
-default_agent_registry = AgentRegistry(agent_factory=AgentFactory(
-    role="default",
-    agent_type="group_aware",
-    tool_factory=ToolFactory(),
-    llm_factory=LLMFactory(),
-    prompt_builder=PromptBuilder(),
-    llm_model=LLMModel(),
-    tool_names=[]
-))

autobyteus-1.0.5/autobyteus/agent/remote_agent.py

@@ -1,9 +0,0 @@
-# file: autobyteus/autobyteus/agent/remote_agent.py
-from autobyteus.agent.agent import Agent
-
-class RemoteAgent(Agent):
-    """
-    A placeholder class for remote agents that will interact with external systems
-    (e.g., via MCP or HTTP protocols). To be implemented in the future.
-    """
-    pass

autobyteus-1.0.5/autobyteus/tools/mcp_remote_tool.py

@@ -1,82 +0,0 @@
-# file: autobyteus/autobyteus/tools/mcp_remote_tool.py
-import logging
-from typing import Any, Dict
-
-from autobyteus.tools.base_tool import BaseTool
-import mcp
-
-logger = logging.getLogger(__name__)
-
-class McpRemoteTool(BaseTool):
-    """
-    A tool that executes remote tool calls on an MCP (Model Context Protocol) server.
-    """
-    def __init__(self, name: str, description: str, connection_params: Dict[str, Any]):
-        """
-        Initializes the McpRemoteTool.
-
-        Args:
-            name: The unique name/identifier of the tool (e.g., 'McpRemoteTool').
-            description: A human-readable description of the tool's purpose.
-            connection_params: A dictionary containing MCP server connection details
-                              (e.g., {'host': 'localhost', 'port': 5000}).
-
-        Raises:
-            ValueError: If name, description, or connection_params are invalid.
-        """
-        if not name or not isinstance(name, str):
-            raise ValueError("McpRemoteTool requires a non-empty string 'name'.")
-        if not description or not isinstance(description, str):
-            raise ValueError(f"McpRemoteTool '{name}' requires a non-empty string 'description'.")
-        if not isinstance(connection_params, dict) or not connection_params:
-            raise ValueError(f"McpRemoteTool '{name}' requires a non-empty dictionary for 'connection_params'.")
-
-        super().__init__(name, description)
-        self.connection_params = connection_params
-        logger.debug(f"McpRemoteTool initialized with name '{self.name}' and connection_params: {self.connection_params}")
-
-    def execute(self, args: Dict[str, Any]) -> Any:
-        """
-        Executes the remote tool call on the MCP server.
-
-        Args:
-            args: A dictionary containing the tool name and parameters to pass to the MCP server
-                  (e.g., {'tool_name': 'do_mcp_analysis', 'params': {...}}).
-
-        Returns:
-            The result of the tool execution, typically a dictionary or string.
-
-        Raises:
-            ValueError: If args is invalid or missing required fields.
-            RuntimeError: If the MCP server connection or tool execution fails.
-        """
-        if not isinstance(args, dict) or 'tool_name' not in args:
-            logger.error(f"Invalid arguments for McpRemoteTool '{self.name}': 'tool_name' is required.")
-            raise ValueError("McpRemoteTool requires a dictionary with a 'tool_name' key.")
-
-        tool_name = args['tool_name']
-        params = args.get('params', {})
-        logger.info(f"Executing McpRemoteTool '{self.name}' with tool_name '{tool_name}' and params: {params}")
-
-        try:
-            # Step 17: Establish connection to MCP server
-            client = mcp.stdio_client(self.connection_params)
-            logger.debug(f"Connected to MCP server with connection_params: {self.connection_params}")
-
-            # Step 19: Create client session
-            session = client.ClientSession()
-            logger.debug(f"Created MCP client session for tool '{tool_name}'")
-
-            # Step 20: Initialize session
-            session.initialize()
-            logger.debug(f"Initialized MCP session for tool '{tool_name}'")
-
-            # Step 21: Call the remote tool
-            result = session.call_tool(tool_name, params)
-            logger.info(f"Successfully executed MCP tool '{tool_name}' with result: {result}")
-
-            return result
-
-        except Exception as e:
-            logger.error(f"Failed to execute McpRemoteTool '{self.name}' for tool '{tool_name}': {str(e)}")
-            raise RuntimeError(f"McpRemoteTool execution failed: {str(e)}")