autobyteus 1.0.0__tar.gz

autobyteus-1.0.0/LICENSE

@@ -0,0 +1,14 @@
+MIT License with Additional Terms for Commercial Use
+
+Permission is hereby granted, free of charge, to any person or organization obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, subject to the following conditions:
+
+1. Commercial Use: The use of the Software for commercial purposes requires the payment of a licensing fee. For details regarding licensing and fees, please contact ryan.zheng at ryan.zheng.work@gmail.com.
+
+2. Redistributions: Redistributions of the Software in source code or other forms must include the above copyright notice, this list of conditions, and the following disclaimer.
+
+3. Patent Grant: The provisions of the Apache 2.0 License regarding patent grants apply to this License.
+
+4. No Warranty/Liability: The Software is provided "as is," without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the Software or the use or other dealings in the Software.
+
+AutoByteus
+17.07.2023

autobyteus-1.0.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.2
+Name: autobyteus
+Version: 1.0.0
+Summary: Multi-Agent framework
+Home-page: https://github.com/AutoByteus/autobyteus
+Author: Ryan Zheng
+Author-email: ryan.zheng.work@gmail.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: beautifulsoup4>=4.12.2
+Requires-Dist: openai
+Requires-Dist: requests
+Requires-Dist: tiktoken==0.7.0
+Requires-Dist: google-api-python-client
+Requires-Dist: google-generativeai
+Requires-Dist: mistralai
+Requires-Dist: boto3
+Requires-Dist: botocore
+Requires-Dist: anthropic==0.37.1
+Requires-Dist: Jinja2
+Requires-Dist: ollama==0.4.5
+Requires-Dist: mistral_common
+Requires-Dist: aiohttp
+Requires-Dist: autobyteus-llm-client==1.0.8
+Requires-Dist: brui-core==1.0.4
+Provides-Extra: dev
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: numpy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: gitpython==3.1.31; extra == "dev"
+Requires-Dist: auto-gpt-plugin-template; extra == "dev"
+Requires-Dist: mkdocs; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: asynctest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-benchmark; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-integration; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: vcrpy; extra == "dev"
+Requires-Dist: pytest-vcr; extra == "dev"
+Requires-Dist: load_dotenv; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Autobyteus
+
+Autobyteus is an open-source coding assistance tool designed to enhance the software development workflow by making it context-aware. Each step in the workflow is interactive through a user-friendly interface, incorporating the entire software development lifecycle into each stage.
+
+## Features
+
+- **Context-Aware Workflows**: Each step in the development process interacts with large language models to provide relevant assistance.
+- **Lifecycle Integration**: Supports the entire software development lifecycle, starting from requirement engineering.
+- **Memory Management**: Custom memory management system supporting different memory providers and embeddings.
+
+## Knowledge Base
+
+A significant part of Autobytus is our custom-designed knowledge base focused on software and application development. The knowledge base is structured to support the entire development process, with particular emphasis on requirement engineering, which is crucial for successful project outcomes.
+
+## Getting Started
+
+### Installation
+
+1. **For users:**
+   To install Autobyteus, run:
+   ```
+   pip install .
+   ```
+
+2. **For developers:**
+   To install Autobyteus with development dependencies, run:
+   ```
+   pip install -r requirements-dev.txt
+   ```
+
+3. **Platform-specific dependencies:**
+   To install platform-specific dependencies, run:
+   ```
+   python setup.py install_platform_deps
+   ```
+
+### Building the Library
+
+To build Autobyteus as a distributable package, follow these steps:
+
+1. Ensure you have the latest version of `setuptools` and `wheel` installed:
+   ```
+   pip install --upgrade setuptools wheel
+   ```
+
+2. Build the distribution packages:
+   ```
+   python setup.py sdist bdist_wheel
+   ```
+
+   This will create a `dist` directory containing the built distributions.
+
+3. (Optional) To create a source distribution only:
+   ```
+   python setup.py sdist
+   ```
+
+4. (Optional) To create a wheel distribution only:
+   ```
+   python setup.py bdist_wheel
+   ```
+
+The built packages will be in the `dist` directory and can be installed using pip or distributed as needed.
+
+### Usage
+
+(Add basic commands and examples to get users started)
+
+### Contributing
+
+(Add guidelines for contributing to the project)
+
+## License
+
+This project is licensed under the MIT License.

autobyteus-1.0.0/README.md

@@ -0,0 +1,75 @@
+# Autobyteus
+
+Autobyteus is an open-source coding assistance tool designed to enhance the software development workflow by making it context-aware. Each step in the workflow is interactive through a user-friendly interface, incorporating the entire software development lifecycle into each stage.
+
+## Features
+
+- **Context-Aware Workflows**: Each step in the development process interacts with large language models to provide relevant assistance.
+- **Lifecycle Integration**: Supports the entire software development lifecycle, starting from requirement engineering.
+- **Memory Management**: Custom memory management system supporting different memory providers and embeddings.
+
+## Knowledge Base
+
+A significant part of Autobytus is our custom-designed knowledge base focused on software and application development. The knowledge base is structured to support the entire development process, with particular emphasis on requirement engineering, which is crucial for successful project outcomes.
+
+## Getting Started
+
+### Installation
+
+1. **For users:**
+   To install Autobyteus, run:
+   ```
+   pip install .
+   ```
+
+2. **For developers:**
+   To install Autobyteus with development dependencies, run:
+   ```
+   pip install -r requirements-dev.txt
+   ```
+
+3. **Platform-specific dependencies:**
+   To install platform-specific dependencies, run:
+   ```
+   python setup.py install_platform_deps
+   ```
+
+### Building the Library
+
+To build Autobyteus as a distributable package, follow these steps:
+
+1. Ensure you have the latest version of `setuptools` and `wheel` installed:
+   ```
+   pip install --upgrade setuptools wheel
+   ```
+
+2. Build the distribution packages:
+   ```
+   python setup.py sdist bdist_wheel
+   ```
+
+   This will create a `dist` directory containing the built distributions.
+
+3. (Optional) To create a source distribution only:
+   ```
+   python setup.py sdist
+   ```
+
+4. (Optional) To create a wheel distribution only:
+   ```
+   python setup.py bdist_wheel
+   ```
+
+The built packages will be in the `dist` directory and can be installed using pip or distributed as needed.
+
+### Usage
+
+(Add basic commands and examples to get users started)
+
+### Contributing
+
+(Add guidelines for contributing to the project)
+
+## License
+
+This project is licensed under the MIT License.

autobyteus-1.0.0/autobyteus/__init__.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+import sys
+
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))

autobyteus-1.0.0/autobyteus/agent/agent.py

@@ -0,0 +1,231 @@
+import asyncio
+import logging
+from typing import List, Optional
+from autobyteus.agent.response_parser.tool_usage_command_parser import ToolUsageCommandParser
+from autobyteus.events.event_emitter import EventEmitter
+from autobyteus.llm.base_llm import BaseLLM
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.prompt.prompt_builder import PromptBuilder
+from autobyteus.events.event_types import EventType
+from autobyteus.agent.status import AgentStatus
+from autobyteus.conversation.user_message import UserMessage
+from autobyteus.conversation.conversation import Conversation
+
+logger = logging.getLogger(__name__)
+
+class Agent(EventEmitter):
+    def __init__(self, role: str, llm: BaseLLM, tools: Optional[List[BaseTool]] = None,
+                 agent_id=None,
+                 prompt_builder: Optional[PromptBuilder] = None,
+                 initial_user_message: Optional[UserMessage] = None):
+        super().__init__()
+        self.role = role
+        self.llm = llm
+        self.tools = tools or []
+        self.tool_usage_response_parser = ToolUsageCommandParser() if self.tools else None
+        self.conversation = None
+        self.agent_id = agent_id or f"{self.role}-001"
+        self.status = AgentStatus.NOT_STARTED
+        self._run_task = None
+        self._queues_initialized = False
+        self.task_completed = None
+        self.prompt_builder = prompt_builder
+        self.initial_user_message = initial_user_message
+
+        if not self.prompt_builder and not self.initial_user_message:
+            raise ValueError("Either prompt_builder or initial_user_message must be provided")
+
+        if self.tools:
+            self.set_agent_id_on_tools()
+            
+        logger.info(f"StandaloneAgent initialized with role: {self.role}, agent_id: {self.agent_id}")
+
+    def _initialize_queues(self):
+        if not self._queues_initialized:
+            self.tool_result_messages = asyncio.Queue()
+            self.user_messages = asyncio.Queue()
+            self._queues_initialized = True
+            logger.info(f"Queues initialized for agent {self.role}")
+
+    def _initialize_task_completed(self):
+        if self.task_completed is None:
+            self.task_completed = asyncio.Event()
+            logger.info(f"task_completed Event initialized for agent {self.role}")
+
+    def get_task_completed(self):
+        if self.task_completed is None:
+            raise RuntimeError("task_completed Event accessed before initialization")
+        return self.task_completed
+
+    async def run(self):
+        try:
+            logger.info(f"Starting execution for agent: {self.role}")
+            self._initialize_queues()
+            self._initialize_task_completed()
+            await self.initialize_conversation()
+
+            user_message_handler = asyncio.create_task(self.handle_user_messages())
+            tool_result_handler = asyncio.create_task(self.handle_tool_result_messages())
+
+            # Once everything is ready, set the status to RUNNING
+            self.status = AgentStatus.RUNNING
+
+            await asyncio.gather(user_message_handler, tool_result_handler)
+
+        except Exception as e:
+            logger.error(f"Error in agent {self.role} execution: {str(e)}")
+            self.status = AgentStatus.ERROR
+        finally:
+            self.status = AgentStatus.ENDED
+            await self.cleanup()
+
+    async def handle_user_messages(self):
+        logger.info(f"Agent {self.role} started handling user messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                user_message: UserMessage = await asyncio.wait_for(self.user_messages.get(), timeout=1.0)
+                logger.info(f"Agent {self.role} handling user message")
+                response = await self.conversation.send_user_message(user_message.content, user_message.file_paths)
+                await self.process_llm_response(response)
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"User message handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling user message for agent {self.role}: {str(e)}")
+
+    async def receive_user_message(self, message: UserMessage):
+        """
+        This method gracefully waits for the agent to become RUNNING
+        if it's in the process of starting up, ensuring the queues are
+        initialized before we put a message into them.
+        """
+        logger.info(f"Agent {self.agent_id} received user message")
+
+        # If the agent is not started (or ended), begin the start process
+        if self.status in [AgentStatus.NOT_STARTED, AgentStatus.ENDED]:
+            self.start()
+
+        # If the agent is still starting, wait until it transitions to RUNNING
+        while self.status == AgentStatus.STARTING:
+            await asyncio.sleep(0.1)
+
+        if self.status != AgentStatus.RUNNING:
+            logger.error(f"Agent is not in a running state: {self.status}")
+            return
+
+        # Now that we are running, safely place the message in the queue
+        await self.user_messages.put(message)
+
+    async def handle_tool_result_messages(self):
+        logger.info(f"Agent {self.role} started handling tool result messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                message = await asyncio.wait_for(self.tool_result_messages.get(), timeout=1.0)
+                logger.info(f"Agent {self.role} handling tool result message: {message}")
+                response = await self.conversation.send_user_message(f"Tool execution result: {message}")
+                await self.process_llm_response(response)
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"Tool result handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling tool result for agent {self.role}: {str(e)}")
+
+    async def initialize_conversation(self):
+        logger.info(f"Initializing conversation for agent: {self.role}")
+        self.conversation = Conversation(self.llm)
+
+        if self.initial_user_message:
+            initial_message = self.initial_user_message
+        else:
+            prompt_content = self.prompt_builder.set_variable_value(
+                "external_tools", 
+                self._get_external_tools_section()
+            ).build()
+            initial_message = UserMessage(content=prompt_content)
+
+        logger.debug(f"Initial user message for agent {self.role}: {initial_message}")
+        initial_llm_response = await self.conversation.send_user_message(
+            initial_message.content,
+            initial_message.file_paths
+        )
+        await self.process_llm_response(initial_llm_response)
+
+    async def process_llm_response(self, response: str) -> None:
+        self.emit(EventType.ASSISTANT_RESPONSE, response=response)
+        
+        if self.tools and self.tool_usage_response_parser:
+            tool_invocation = self.tool_usage_response_parser.parse_response(response)
+            if tool_invocation.is_valid():
+                await self.execute_tool(tool_invocation)
+                return
+
+        logger.info(f"Assistant response for agent {self.role}: {response}")
+
+    async def execute_tool(self, tool_invocation):
+        name = tool_invocation.name
+        arguments = tool_invocation.arguments
+        logger.info(f"Agent {self.role} attempting to execute tool: {name}")
+
+        tool = next((t for t in self.tools if t.get_name() == name), None)
+        if tool:
+            try:
+                result = await tool.execute(**arguments)
+                logger.info(f"Tool '{name}' executed successfully by agent {self.role}. Result: {result}")
+                await self.tool_result_messages.put(result)
+            except Exception as e:
+                error_message = str(e)
+                logger.error(f"Error executing tool '{name}' by agent {self.role}: {error_message}")
+                await self.tool_result_messages.put(f"Error: {error_message}")
+        else:
+            logger.warning(f"Tool '{name}' not found for agent {self.role}.")
+
+    def start(self):
+        """
+        Starts the agent by creating a task that runs the main loop (run).
+        Sets the AgentStatus to STARTING to prevent message enqueuing before
+        the system is fully initialized.
+        """
+        if self.status in [AgentStatus.NOT_STARTED, AgentStatus.ENDED]:
+            logger.info(f"Starting agent {self.role}")
+            self.status = AgentStatus.STARTING
+            self._run_task = asyncio.create_task(self.run())
+        elif self.status == AgentStatus.STARTING:
+            logger.info(f"Agent {self.role} is already in STARTING state.")
+        elif self.status == AgentStatus.RUNNING:
+            logger.info(f"Agent {self.role} is already running.")
+        else:
+            logger.warning(f"Agent {self.role} is in an unexpected state: {self.status}")
+
+    def stop(self):
+        if self._run_task and not self._run_task.done():
+            self._run_task.cancel()
+
+    async def cleanup(self):
+        while not self.tool_result_messages.empty():
+            self.tool_result_messages.get_nowait()
+        while not self.user_messages.empty():
+            self.user_messages.get_nowait()
+        await self.llm.cleanup()
+        logger.info(f"Cleanup completed for agent: {self.role}")
+
+    def set_agent_id_on_tools(self):
+        if self.tools:
+            for tool in self.tools:
+                tool.set_agent_id(self.agent_id)
+
+    def _get_external_tools_section(self) -> str:
+        if not self.tools:
+            return ""
+            
+        external_tools_section = ""
+        for i, tool in enumerate(self.tools):
+            external_tools_section += f"  {i + 1} {tool.tool_usage_xml()}\n\n"
+        return external_tools_section.strip()
+
+    def on_task_completed(self, *args, **kwargs):
+        logger.info(f"Task completed event received for agent: {self.role}")
+        self.task_completed.set()

autobyteus-1.0.0/autobyteus/agent/async_agent.py

@@ -0,0 +1,175 @@
+import asyncio
+import logging
+from typing import (
+    List, 
+    Optional, 
+    AsyncGenerator, 
+    Any, 
+    NoReturn,
+    Union,
+    AsyncIterator
+)
+from autobyteus.agent.agent import Agent
+from autobyteus.llm.base_llm import BaseLLM
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.prompt.prompt_builder import PromptBuilder
+from autobyteus.events.event_types import EventType
+from autobyteus.agent.status import AgentStatus
+from autobyteus.conversation.user_message import UserMessage
+from autobyteus.conversation.conversation import Conversation
+from autobyteus.agent.tool_invocation import ToolInvocation
+
+logger = logging.getLogger(__name__)
+
+class AsyncAgent(Agent):
+    """
+    An asynchronous agent that supports streaming LLM responses while maintaining
+    compatibility with the base agent functionality.
+    """
+    
+    def __init__(
+        self, 
+        role: str, 
+        llm: BaseLLM, 
+        tools: Optional[List[BaseTool]] = None,
+        agent_id: Optional[str] = None,
+        prompt_builder: Optional[PromptBuilder] = None,
+        initial_user_message: Optional[UserMessage] = None
+    ) -> None:
+        """
+        Initialize the AsyncAgent with the given parameters.
+
+        Args:
+            role: The role of the agent
+            llm: The language model instance
+            tools: List of available tools
+            use_xml_parser: Whether to use XML parser for responses
+            agent_id: Optional unique identifier for the agent
+            prompt_builder: Optional prompt builder instance
+            initial_user_message: Optional initial message to start the conversation
+        """
+        super().__init__(
+            role, 
+            llm, 
+            tools, 
+            agent_id, 
+            prompt_builder, 
+            initial_user_message
+        )
+
+    async def initialize_conversation(self) -> None:
+        """Initialize the conversation with initial message or prompt."""
+        logger.info(f"Initializing conversation for agent: {self.role}")
+        self.conversation = Conversation(self.llm)
+
+        if self.initial_user_message:
+            initial_message = self.initial_user_message
+        else:
+            prompt_content = self.prompt_builder.set_variable_value(
+                "external_tools", 
+                self._get_external_tools_section()
+            ).build()
+            initial_message = UserMessage(content=prompt_content)
+
+        logger.debug(f"Initial user message for agent {self.role}: {initial_message}")
+        await self.process_streaming_response(
+            self.conversation.stream_user_message(
+                initial_message.content, 
+                initial_message.file_paths
+            )
+        )
+
+    async def handle_user_messages(self) -> NoReturn:
+        """
+        Handle incoming user messages continuously.
+        Processes messages using streaming responses.
+        """
+        logger.info(f"Agent {self.role} started handling user messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                user_message: UserMessage = await asyncio.wait_for(
+                    self.user_messages.get(), 
+                    timeout=1.0
+                )
+                logger.info(f"Agent {self.role} handling user message")
+                await self.process_streaming_response(
+                    self.conversation.stream_user_message(
+                        user_message.content, 
+                        user_message.file_paths
+                    )
+                )
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"User message handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling user message for agent {self.role}: {str(e)}")
+
+    async def handle_tool_result_messages(self) -> NoReturn:
+        """
+        Handle tool execution result messages continuously.
+        Processes messages using streaming responses.
+        """
+        logger.info(f"Agent {self.role} started handling tool result messages")
+        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
+            try:
+                message: str = await asyncio.wait_for(
+                    self.tool_result_messages.get(), 
+                    timeout=1.0
+                )
+                logger.info(f"Agent {self.role} handling tool result message: {message}")
+                await self.process_streaming_response(
+                    self.conversation.stream_user_message(
+                        f"Tool execution result: {message}"
+                    )
+                )
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                logger.info(f"Tool result handler for agent {self.role} cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Error handling tool result for agent {self.role}: {str(e)}")
+
+    async def process_streaming_response(
+        self, 
+        response_stream: AsyncIterator[str]
+    ) -> None:
+        """
+        Process streaming responses from the LLM, emitting each chunk and handling
+        tool invocations after receiving the complete response.
+        
+        Args:
+            response_stream: AsyncIterator yielding response tokens
+        """
+        complete_response: str = ""
+        try:
+            async for chunk in response_stream:
+                # Emit each chunk as it arrives
+                self.emit(
+                    EventType.ASSISTANT_RESPONSE, 
+                    response=chunk,
+                    is_complete=False
+                )
+                complete_response += chunk
+            # Emit the complete response
+            self.emit(
+                EventType.ASSISTANT_RESPONSE, 
+                response=complete_response,
+                is_complete=True
+            )
+
+            if self.tools and self.tool_usage_response_parser:
+                tool_invocation: ToolInvocation = self.tool_usage_response_parser.parse_response(complete_response)
+                if tool_invocation.is_valid():
+                    await self.execute_tool(tool_invocation)
+                    return
+
+            logger.info(f"Assistant response for agent {self.role}: {complete_response}")
+
+        except Exception as e:
+            logger.error(f"Error processing streaming response for agent {self.role}: {str(e)}")
+            self.emit(
+                EventType.ERROR,
+                error=str(e))