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

autobyteus/tools/usage/providers/xml_schema_provider.py

@@ -1,29 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/providers/xml_schema_provider.py
-from typing import Optional, TYPE_CHECKING
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.registries.xml_schema_formatter_registry import XmlSchemaFormatterRegistry
-
-if TYPE_CHECKING:
-    from autobyteus.tools.registry import ToolDefinition
-
-class XmlSchemaProvider:
-    """
-    Provides the schema for a single tool formatted as an XML string.
-    """
-    def __init__(self):
-        self._registry = XmlSchemaFormatterRegistry()
-
-    def provide(self, tool_definition: 'ToolDefinition', llm_provider: Optional[LLMProvider] = None) -> str:
-        """
-        Generates an XML string for a single tool's schema.
-
-        Args:
-            tool_definition: A ToolDefinition object.
-            llm_provider: This argument is passed to the registry for API consistency.
-
-        Returns:
-            A string containing the XML tool schema.
-        """
-        formatter = self._registry.get_formatter(llm_provider)
-        return formatter.provide(tool_definition)

autobyteus/tools/usage/providers/xml_tool_usage_parser_provider.py

@@ -1,26 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/providers/xml_tool_usage_parser_provider.py
-from typing import Optional, TYPE_CHECKING
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.registries.xml_tool_usage_parser_registry import XmlToolUsageParserRegistry
-
-if TYPE_CHECKING:
-    from autobyteus.tools.usage.parsers.base_parser import BaseToolUsageParser
-
-class XmlToolUsageParserProvider:
-    """Provides a tool usage parser for XML-based responses."""
-
-    def __init__(self):
-        self._registry = XmlToolUsageParserRegistry()
-
-    def provide(self, llm_provider: Optional[LLMProvider] = None) -> 'BaseToolUsageParser':
-        """
-        Gets the appropriate parser from the registry.
-
-        Args:
-            llm_provider: Ignored, for API consistency.
-
-        Returns:
-            An instance of a class derived from BaseToolUsageParser.
-        """
-        return self._registry.get_parser(llm_provider)

autobyteus/tools/usage/registries/json_example_formatter_registry.py

@@ -1,51 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/registries/json_example_formatter_registry.py
-import logging
-from typing import Dict
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.formatters.base_formatter import BaseExampleFormatter
-from autobyteus.tools.usage.formatters.default_json_example_formatter import DefaultJsonExampleFormatter
-from autobyteus.tools.usage.formatters.openai_json_example_formatter import OpenAiJsonExampleFormatter
-from autobyteus.tools.usage.formatters.anthropic_json_example_formatter import AnthropicJsonExampleFormatter
-from autobyteus.tools.usage.formatters.gemini_json_example_formatter import GeminiJsonExampleFormatter
-from autobyteus.utils.singleton import SingletonMeta
-
-logger = logging.getLogger(__name__)
-
-class JsonExampleFormatterRegistry(metaclass=SingletonMeta):
-    """A singleton registry for retrieving JSON example formatters based on LLM provider."""
-
-    def __init__(self):
-        self._formatters: Dict[LLMProvider, BaseExampleFormatter] = {
-            LLMProvider.OPENAI: OpenAiJsonExampleFormatter(),
-            LLMProvider.MISTRAL: OpenAiJsonExampleFormatter(),
-            LLMProvider.DEEPSEEK: OpenAiJsonExampleFormatter(),
-            LLMProvider.GROK: OpenAiJsonExampleFormatter(),
-            LLMProvider.ANTHROPIC: AnthropicJsonExampleFormatter(),
-            LLMProvider.GEMINI: GeminiJsonExampleFormatter(),
-        }
-        self._default_formatter = DefaultJsonExampleFormatter()
-        logger.info("JsonExampleFormatterRegistry initialized.")
-
-    def get_formatter(self, provider: LLMProvider) -> BaseExampleFormatter:
-        """
-        Retrieves the appropriate example formatter for a given LLM provider.
-
-        Args:
-            provider: The LLMProvider enum member.
-
-        Returns:
-            An instance of a class derived from BaseExampleFormatter.
-        """
-        formatter = self._formatters.get(provider)
-        if formatter:
-            logger.debug(f"Found specific example formatter for provider {provider.name}: {formatter.__class__.__name__}")
-            return formatter
-        
-        logger.debug(f"No specific example formatter for provider {provider.name}. "
-                     f"Returning default: {self._default_formatter.__class__.__name__}")
-        return self._default_formatter
-    
-    def get_default_formatter(self) -> BaseExampleFormatter:
-        """Explicitly returns the default formatter."""
-        return self._default_formatter

autobyteus/tools/usage/registries/json_schema_formatter_registry.py

@@ -1,51 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/registries/json_schema_formatter_registry.py
-import logging
-from typing import Dict
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.formatters.base_formatter import BaseSchemaFormatter
-from autobyteus.tools.usage.formatters.default_json_schema_formatter import DefaultJsonSchemaFormatter
-from autobyteus.tools.usage.formatters.openai_json_schema_formatter import OpenAiJsonSchemaFormatter
-from autobyteus.tools.usage.formatters.anthropic_json_schema_formatter import AnthropicJsonSchemaFormatter
-from autobyteus.tools.usage.formatters.gemini_json_schema_formatter import GeminiJsonSchemaFormatter
-from autobyteus.utils.singleton import SingletonMeta
-
-logger = logging.getLogger(__name__)
-
-class JsonSchemaFormatterRegistry(metaclass=SingletonMeta):
-    """A singleton registry for retrieving JSON schema formatters based on LLM provider."""
-
-    def __init__(self):
-        self._formatters: Dict[LLMProvider, BaseSchemaFormatter] = {
-            LLMProvider.OPENAI: OpenAiJsonSchemaFormatter(),
-            LLMProvider.MISTRAL: OpenAiJsonSchemaFormatter(),
-            LLMProvider.DEEPSEEK: OpenAiJsonSchemaFormatter(),
-            LLMProvider.GROK: OpenAiJsonSchemaFormatter(),
-            LLMProvider.ANTHROPIC: AnthropicJsonSchemaFormatter(),
-            LLMProvider.GEMINI: GeminiJsonSchemaFormatter(),
-        }
-        self._default_formatter = DefaultJsonSchemaFormatter()
-        logger.info("JsonSchemaFormatterRegistry initialized.")
-
-    def get_formatter(self, provider: LLMProvider) -> BaseSchemaFormatter:
-        """
-        Retrieves the appropriate schema formatter for a given LLM provider.
-
-        Args:
-            provider: The LLMProvider enum member.
-
-        Returns:
-            An instance of a class derived from BaseSchemaFormatter.
-        """
-        formatter = self._formatters.get(provider)
-        if formatter:
-            logger.debug(f"Found specific schema formatter for provider {provider.name}: {formatter.__class__.__name__}")
-            return formatter
-
-        logger.debug(f"No specific schema formatter for provider {provider.name}. "
-                     f"Returning default: {self._default_formatter.__class__.__name__}")
-        return self._default_formatter
-
-    def get_default_formatter(self) -> BaseSchemaFormatter:
-        """Explicitly returns the default formatter."""
-        return self._default_formatter

autobyteus/tools/usage/registries/json_tool_usage_parser_registry.py

@@ -1,42 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/registries/json_tool_usage_parser_registry.py
-import logging
-from typing import Dict
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.parsers.base_parser import BaseToolUsageParser
-from autobyteus.tools.usage.parsers.default_json_tool_usage_parser import DefaultJsonToolUsageParser
-from autobyteus.tools.usage.parsers.openai_json_tool_usage_parser import OpenAiJsonToolUsageParser
-from autobyteus.tools.usage.parsers.gemini_json_tool_usage_parser import GeminiJsonToolUsageParser
-from autobyteus.utils.singleton import SingletonMeta
-
-logger = logging.getLogger(__name__)
-
-class JsonToolUsageParserRegistry(metaclass=SingletonMeta):
-    """A singleton registry for retrieving JSON-based tool usage parsers."""
-
-    def __init__(self):
-        self._parsers: Dict[LLMProvider, BaseToolUsageParser] = {
-            LLMProvider.OPENAI: OpenAiJsonToolUsageParser(),
-            LLMProvider.MISTRAL: OpenAiJsonToolUsageParser(),
-            LLMProvider.DEEPSEEK: OpenAiJsonToolUsageParser(),
-            LLMProvider.GROK: OpenAiJsonToolUsageParser(),
-            LLMProvider.GEMINI: GeminiJsonToolUsageParser(),
-        }
-        self._default_parser = DefaultJsonToolUsageParser()
-        logger.info("JsonToolUsageParserRegistry initialized.")
-
-    def get_parser(self, provider: LLMProvider) -> BaseToolUsageParser:
-        """
-        Retrieves the appropriate parser for a given LLM provider.
-        """
-        parser = self._parsers.get(provider)
-        if parser:
-            logger.debug(f"Found specific tool usage parser for provider {provider.name}: {parser.get_name()}")
-            return parser
-        
-        logger.debug(f"No specific tool usage parser for provider {provider.name}. Returning default: {self._default_parser.get_name()}")
-        return self._default_parser
-    
-    def get_default_parser(self) -> BaseToolUsageParser:
-        """Explicitly returns the default parser."""
-        return self._default_parser

autobyteus/tools/usage/registries/xml_example_formatter_registry.py

@@ -1,30 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/registries/xml_example_formatter_registry.py
-import logging
-from typing import Optional
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.formatters.base_formatter import BaseExampleFormatter
-from autobyteus.tools.usage.formatters.default_xml_example_formatter import DefaultXmlExampleFormatter
-from autobyteus.utils.singleton import SingletonMeta
-
-logger = logging.getLogger(__name__)
-
-class XmlExampleFormatterRegistry(metaclass=SingletonMeta):
-    """A singleton registry for retrieving XML example formatters."""
-
-    def __init__(self):
-        self._default_formatter = DefaultXmlExampleFormatter()
-        logger.info("XmlExampleFormatterRegistry initialized.")
-
-    def get_formatter(self, provider: Optional[LLMProvider] = None) -> BaseExampleFormatter:
-        """
-        Retrieves the appropriate XML example formatter.
-
-        Args:
-            provider: The LLMProvider enum member. This is currently ignored
-                      but is kept for API consistency and future expansion.
-
-        Returns:
-            An instance of the DefaultXmlExampleFormatter.
-        """
-        return self._default_formatter

autobyteus/tools/usage/registries/xml_schema_formatter_registry.py

@@ -1,33 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/registries/xml_schema_formatter_registry.py
-import logging
-from typing import Dict, Optional
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.formatters.base_formatter import BaseSchemaFormatter
-from autobyteus.tools.usage.formatters.default_xml_schema_formatter import DefaultXmlSchemaFormatter
-from autobyteus.utils.singleton import SingletonMeta
-
-logger = logging.getLogger(__name__)
-
-class XmlSchemaFormatterRegistry(metaclass=SingletonMeta):
-    """A singleton registry for retrieving XML schema formatters based on LLM provider."""
-
-    def __init__(self):
-        # Currently, there is only one XML format, so all providers map to it.
-        # This structure allows for future expansion if providers diverge.
-        self._default_formatter = DefaultXmlSchemaFormatter()
-        logger.info("XmlSchemaFormatterRegistry initialized.")
-
-    def get_formatter(self, provider: Optional[LLMProvider] = None) -> BaseSchemaFormatter:
-        """
-        Retrieves the appropriate XML schema formatter.
-
-        Args:
-            provider: The LLMProvider enum member. This is currently ignored
-                      but is kept for API consistency and future expansion.
-
-        Returns:
-            An instance of the DefaultXmlSchemaFormatter.
-        """
-        # For now, we only have one XML formatter. This always returns it.
-        return self._default_formatter

autobyteus/tools/usage/registries/xml_tool_usage_parser_registry.py

@@ -1,30 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/registries/xml_tool_usage_parser_registry.py
-import logging
-from typing import Optional
-
-from autobyteus.llm.providers import LLMProvider
-from autobyteus.tools.usage.parsers.base_parser import BaseToolUsageParser
-from autobyteus.tools.usage.parsers.default_xml_tool_usage_parser import DefaultXmlToolUsageParser
-from autobyteus.utils.singleton import SingletonMeta
-
-logger = logging.getLogger(__name__)
-
-class XmlToolUsageParserRegistry(metaclass=SingletonMeta):
-    """A singleton registry for retrieving XML-based tool usage parsers."""
-
-    def __init__(self):
-        self._default_parser = DefaultXmlToolUsageParser()
-        logger.info("XmlToolUsageParserRegistry initialized.")
-
-    def get_parser(self, provider: Optional[LLMProvider] = None) -> BaseToolUsageParser:
-        """
-        Retrieves the appropriate XML parser.
-
-        Args:
-            provider: The LLMProvider enum member. Currently ignored but kept for API consistency.
-
-        Returns:
-            An instance of a class derived from BaseToolUsageParser.
-        """
-        # For now, there's only one XML format, so always return the default.
-        return self._default_parser

autobyteus/workflow/simple_task.py

@@ -1,98 +0,0 @@
-import asyncio
-import logging
-from typing import Optional, Callable, Any, List, Union
-
-from autobyteus.agent.agent import Agent
-from autobyteus.events.event_types import EventType
-from autobyteus.llm.models import LLMModel
-from autobyteus.llm.llm_factory import LLMFactory
-from autobyteus.conversation.user_message import UserMessage
-
-logger = logging.getLogger(__name__)
-
-class SimpleTask:
-    """
-    A simplified task execution class for running single-instruction tasks
-    with minimal configuration and built-in result handling.
-    """
-    
-    def __init__(
-        self,
-        name: str,
-        instruction: str,
-        llm_model: LLMModel,
-        input_data: Optional[Union[str, List[str]]] = None,
-        output_parser: Optional[Callable[[str], Any]] = None,
-    ):
-        """
-        Initialize a SimpleTask.
-
-        Args:
-            name (str): Name of the task
-            instruction (str): Task instruction/prompt
-            llm_model (LLMModel): LLM model to use
-            input_data (Optional[Union[str, List[str]]], optional): Input data or file paths. Defaults to None.
-            output_parser (Optional[Callable], optional): Function to parse the output. Defaults to None.
-        """
-        self.name = name
-        self.instruction = instruction
-        self.llm_model = llm_model
-        self.input_data = input_data if isinstance(input_data, list) else ([input_data] if input_data else [])
-        self.output_parser = output_parser
-        
-        logger.info(f"Initialized task '{self.name}' with model {self.llm_model.value} and {len(self.input_data)} inputs")
-
-    async def execute(self) -> Any:
-        """
-        Execute the task and return the result.
-
-        Returns:
-            The result of the task execution, parsed if output_parser is provided
-        """
-        try:
-            llm = LLMFactory.create_llm(self.llm_model)
-            
-            user_message = UserMessage(
-                content=self.instruction,
-                file_paths=self.input_data
-            )
-
-            agent = Agent(
-                role=self.name,
-                llm=llm,
-                initial_user_message=user_message
-            )
-
-            result_queue = asyncio.Queue()
-
-            async def handle_response(*args, **kwargs):
-                response = kwargs.get('response')
-                if response:
-                    await result_queue.put(response)
-
-            agent.subscribe(EventType.ASSISTANT_RESPONSE, handle_response, agent.agent_id)
-
-            try:
-                agent.start()
-                result = await asyncio.wait_for(
-                    result_queue.get(),
-                    timeout=30.0
-                )
-                
-                # Only parse if output_parser is provided
-                if self.output_parser:
-                    return self.output_parser(result)
-                return result
-
-            except asyncio.TimeoutError:
-                logger.error(f"Task '{self.name}' timed out")
-                raise TimeoutError(f"Task '{self.name}' execution timed out")
-
-            finally:
-                agent.unsubscribe("ASSISTANT_RESPONSE", handle_response, agent.agent_id)
-                agent.stop()
-                await agent.cleanup()
-
-        except Exception as e:
-            logger.error(f"Error executing task '{self.name}': {str(e)}")
-            raise

autobyteus/workflow/task.py

@@ -1,147 +0,0 @@
-"""
-task.py: Contains the Task class for representing individual tasks within a workflow.
-
-This module defines the Task class, which encapsulates the functionality for a single task,
-including its objective, input and output descriptions, associated tools, LLM integration,
-and execution logic using a dynamically created Agent.
-"""
-
-from typing import Any, List, Optional
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.llm.base_llm import BaseLLM
-from autobyteus.agent.agent import Agent
-from autobyteus.prompt.prompt_builder import PromptBuilder
-from autobyteus.person.person import Person
-
-class Task:
-    def __init__(
-        self,
-        description: str,
-        objective: str,
-        input_description: str,
-        expected_output_description: str,
-        workflow_description: Optional[str],
-        tools: List[BaseTool],
-        llm: BaseLLM,
-        person: Optional[Person] = None,
-        subtasks: Optional[List['Task']] = None
-    ):
-        self.description = description
-        self.objective = objective
-        self.input_description = input_description
-        self.expected_output_description = expected_output_description
-        self.workflow_description = workflow_description
-        self.tools = tools
-        self.llm = llm
-        self.person = None
-        if person:
-            self.assign_to(person)
-        self.subtasks = subtasks or []
-        self.result = None
-
-    def assign_to(self, person: Person):
-        if self.person:
-            self.person.unassign_task(self)
-        self.person = person
-        person.assign_task(self)
-
-    def unassign(self):
-        if self.person:
-            self.person.unassign_task(self)
-            self.person = None
-
-    async def execute(self, input_data: Any) -> Any:
-        if self.subtasks:
-            return await self._execute_subtasks(input_data)
-        else:
-            return await self._execute_single_task(input_data)
-
-    async def _execute_subtasks(self, input_data: Any) -> Any:
-        result = input_data
-        for subtask in self.subtasks:
-            print(f"Executing subtask: {subtask.objective}")
-            result = await subtask.execute(result)
-        self.result = result
-        return self.result
-
-    async def _execute_single_task(self, input_data: Any) -> Any:
-        agent = self._create_agent()
-        
-        # Set the variable values for the prompt
-        agent.prompt_builder.set_variable_value("name", self.person.name)
-        agent.prompt_builder.set_variable_value("role", self.person.role.name)
-        agent.prompt_builder.set_variable_value("person_description", self.person.get_description())
-        agent.prompt_builder.set_variable_value("task_description", self.description)
-        agent.prompt_builder.set_variable_value("objective", self.objective)
-        agent.prompt_builder.set_variable_value("input_description", self.input_description)
-        agent.prompt_builder.set_variable_value("expected_output_description", self.expected_output_description)
-        agent.prompt_builder.set_variable_value("workflow_description", self.workflow_description)
-        agent.prompt_builder.set_variable_value("tools", self._format_tools())
-        agent.prompt_builder.set_variable_value("input_data", str(input_data))
-        
-        # Run the agent
-        await agent.run()
-        
-        # Retrieve the result from the agent's conversation
-        self.result = agent.conversation.get_last_assistant_message()
-        return self.result
-
-    def _create_agent(self) -> Agent:
-        agent_id = f"task_{self.objective[:10]}_{id(self)}"
-        
-        # Generate the initial prompt
-        initial_prompt = self._generate_initial_prompt()
-        
-        return Agent(
-            role=f"Task_{self.objective[:20]}",
-            llm=self.llm,
-            tools=self.tools,
-            use_xml_parser=True,
-            agent_id=agent_id,
-            initial_user_message=initial_prompt
-        )
-
-    def _generate_initial_prompt(self) -> str:
-        template = """
-        You are {name}. Your role is {role}.
-
-        {person_description}
-
-        Task Description: {task_description}
-        Objective: {objective}
-
-        Input Description: {input_description}
-        Expected Output: {expected_output_description}
-
-        Workflow:
-        {workflow_description}
-
-        Available Tools:
-        {tools}
-
-        Input Data:
-        {input_data}
-
-        Please complete the task based on the given information and using the available tools.
-        """
-        prompt_builder = PromptBuilder.from_string(template)
-        prompt_builder.set_variable_value("name", self.person.name)
-        prompt_builder.set_variable_value("role", self.person.role.name)
-        prompt_builder.set_variable_value("person_description", self.person.get_description())
-        prompt_builder.set_variable_value("task_description", self.description)
-        prompt_builder.set_variable_value("objective", self.objective)
-        prompt_builder.set_variable_value("input_description", self.input_description)
-        prompt_builder.set_variable_value("expected_output_description", self.expected_output_description)
-        prompt_builder.set_variable_value("workflow_description", self.workflow_description)
-        prompt_builder.set_variable_value("tools", self._format_tools())
-        prompt_builder.set_variable_value("input_data", "To be provided during execution")
-        return prompt_builder.build()
-
-    def _format_tools(self) -> str:
-        return "\n".join([f"- {tool.get_name()}: {tool.get_description()}" for tool in self.tools])
-
-    def get_result(self) -> Any:
-        return self.result
-
-    def add_subtask(self, subtask: 'Task'):
-        self.subtasks.append(subtask)

autobyteus/workflow/workflow.py

@@ -1,49 +0,0 @@
-"""
-workflow.py: Contains the Workflow class for managing a sequence of tasks.
-
-This module defines the Workflow class, which represents a series of tasks to be executed in order.
-The Workflow class allows adding tasks, executing the entire workflow, and retrieving the final result.
-"""
-
-from typing import List, Any
-from autobyteus.workflow.task import Task
-
-class Workflow:
-    def __init__(self):
-        """
-        Initialize a new Workflow instance with an empty list of tasks.
-        """
-        self.tasks: List[Task] = []
-
-    def add_task(self, task: Task):
-        """
-        Add a new task to the workflow.
-
-        Args:
-            task (Task): The task to be added to the workflow.
-        """
-        self.tasks.append(task)
-
-    async def execute(self, input_data: Any) -> Any:
-        """
-        Execute all tasks in the workflow sequentially.
-
-        Args:
-            input_data (Any): The initial input data for the first task.
-
-        Returns:
-            Any: The result of the final task in the workflow.
-        """
-        result = input_data
-        for task in self.tasks:
-            result = await task.execute(result)
-        return result
-
-    def get_result(self) -> Any:
-        """
-        Get the result of the last task in the workflow.
-
-        Returns:
-            Any: The result of the last task, or None if there are no tasks.
-        """
-        return self.tasks[-1].get_result() if self.tasks else None