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

autobyteus/tools/multimedia/audio_tools.py

@@ -0,0 +1,116 @@
+import os
+import logging
+from typing import Optional, List
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.multimedia.audio import audio_client_factory, AudioModel, AudioClientFactory
+
+logger = logging.getLogger(__name__)
+
+
+def _get_configured_model_identifier(env_var: str, default_model: Optional[str] = None) -> str:
+    """
+    Retrieves a model identifier from an environment variable.
+    """
+    model_identifier = os.getenv(env_var)
+    if not model_identifier:
+        if default_model:
+            return default_model
+        raise ValueError(f"The '{env_var}' environment variable is not set. Please configure it.")
+    return model_identifier
+
+
+def _build_dynamic_audio_schema(base_params: List[ParameterDefinition], model_env_var: str, default_model: str) -> ParameterSchema:
+    """
+    Builds a tool schema dynamically based on a configured audio model.
+    """
+    try:
+        model_identifier = _get_configured_model_identifier(model_env_var, default_model)
+        AudioClientFactory.ensure_initialized()
+        model = AudioModel[model_identifier]
+    except (ValueError, KeyError) as e:
+        logger.error(f"Cannot generate audio tool schema. Check environment and model registry. Error: {e}")
+        raise RuntimeError(f"Failed to configure audio tool. Error: {e}")
+
+    config_schema = ParameterSchema()
+    if model.parameter_schema:
+        for name, meta in model.parameter_schema.items():
+            param_type_str = meta.get("type", "string").upper()
+            param_type = getattr(ParameterType, param_type_str, ParameterType.STRING)
+            
+            allowed_values = meta.get("allowed_values")
+            if param_type == ParameterType.STRING and allowed_values:
+                param_type = ParameterType.ENUM
+
+            config_schema.add_parameter(ParameterDefinition(
+                name=name,
+                param_type=param_type,
+                description=meta.get("description", ""),
+                required=False,
+                default_value=meta.get("default"),
+                enum_values=allowed_values
+            ))
+
+    schema = ParameterSchema()
+    for param in base_params:
+        schema.add_parameter(param)
+    
+    if config_schema.parameters:
+        schema.add_parameter(ParameterDefinition(
+            name="generation_config",
+            param_type=ParameterType.OBJECT,
+            description=f"Model-specific parameters for the configured '{model_identifier}' model.",
+            required=False,
+            object_schema=config_schema.to_json_schema_dict()
+        ))
+    return schema
+
+
+class GenerateSpeechTool(BaseTool):
+    """
+    An agent tool for generating speech from text using a Text-to-Speech (TTS) model.
+    """
+    CATEGORY = ToolCategory.MULTIMEDIA
+    MODEL_ENV_VAR = "DEFAULT_SPEECH_GENERATION_MODEL"
+    DEFAULT_MODEL = "gemini-2.5-flash-tts"
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "GenerateSpeech"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Generates spoken audio from text using the system's default Text-to-Speech (TTS) model. "
+            "Returns a list of local file paths to the generated audio files (.wav) upon success."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        base_params = [
+            ParameterDefinition(
+                name="prompt",
+                param_type=ParameterType.STRING,
+                description="The text to be converted into spoken audio.",
+                required=True
+            )
+        ]
+        return _build_dynamic_audio_schema(base_params, cls.MODEL_ENV_VAR, cls.DEFAULT_MODEL)
+
+    async def _execute(self, context, prompt: str, generation_config: Optional[dict] = None) -> str:
+        model_identifier = _get_configured_model_identifier(self.MODEL_ENV_VAR, self.DEFAULT_MODEL)
+        logger.info(f"GenerateSpeechTool executing with configured model '{model_identifier}'.")
+        client = None
+        try:
+            client = audio_client_factory.create_audio_client(model_identifier=model_identifier)
+            response = await client.generate_speech(prompt=prompt, generation_config=generation_config)
+            
+            if not response.audio_urls:
+                raise ValueError("Speech generation failed to return any audio file paths.")
+            
+            return f"Speech generation successful. Audio file(s) saved at: {response.audio_urls}"
+        finally:
+            if client:
+                await client.cleanup()

autobyteus/tools/multimedia/image_tools.py

@@ -0,0 +1,186 @@
+import os
+import logging
+from typing import Optional, List
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.multimedia.image import image_client_factory, ImageModel, ImageClientFactory
+
+logger = logging.getLogger(__name__)
+
+
+def _get_configured_model_identifier(env_var: str, default_model: Optional[str] = None) -> str:
+    """
+    Retrieves a model identifier from an environment variable, with a fallback to a default.
+    """
+    model_identifier = os.getenv(env_var)
+    if not model_identifier:
+        if default_model:
+            return default_model
+        raise ValueError(f"The '{env_var}' environment variable is not set. Please configure it.")
+    return model_identifier
+
+
+def _build_dynamic_image_schema(base_params: List[ParameterDefinition], model_env_var: str, default_model: str) -> ParameterSchema:
+    """
+    Builds the tool schema dynamically based on the configured image model.
+    """
+    try:
+        model_identifier = _get_configured_model_identifier(model_env_var, default_model)
+        ImageClientFactory.ensure_initialized()
+        model = ImageModel[model_identifier]
+    except (ValueError, KeyError) as e:
+        logger.error(f"Cannot generate image tool schema. Check environment and model registry. Error: {e}")
+        raise RuntimeError(f"Failed to configure image tool. Error: {e}")
+
+    config_schema = ParameterSchema()
+    if model.parameter_schema:
+        for name, meta in model.parameter_schema.items():
+            param_type_str = meta.get("type", "string").upper()
+            param_type = getattr(ParameterType, param_type_str, ParameterType.STRING)
+            
+            allowed_values = meta.get("allowed_values")
+            if param_type == ParameterType.STRING and allowed_values:
+                param_type = ParameterType.ENUM
+
+            config_schema.add_parameter(ParameterDefinition(
+                name=name,
+                param_type=param_type,
+                description=meta.get("description", ""),
+                required=False,
+                default_value=meta.get("default"),
+                enum_values=allowed_values
+            ))
+
+    schema = ParameterSchema()
+    for param in base_params:
+        schema.add_parameter(param)
+    
+    if config_schema.parameters:
+        schema.add_parameter(ParameterDefinition(
+            name="generation_config",
+            param_type=ParameterType.OBJECT,
+            description=f"Model-specific generation parameters for the configured '{model_identifier}' model.",
+            required=False,
+            object_schema=config_schema.to_json_schema_dict()
+        ))
+    return schema
+
+
+class GenerateImageTool(BaseTool):
+    """
+    An agent tool for generating images from a text prompt using a pre-configured model.
+    """
+    CATEGORY = ToolCategory.MULTIMEDIA
+    MODEL_ENV_VAR = "DEFAULT_IMAGE_GENERATION_MODEL"
+    DEFAULT_MODEL = "gpt-image-1"
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "GenerateImage"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Generates one or more images based on a textual description (prompt) using the system's default image model. "
+            "Returns a list of URLs to the generated images upon success."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        base_params = [
+            ParameterDefinition(
+                name="prompt",
+                param_type=ParameterType.STRING,
+                description="A detailed textual description of the image to generate.",
+                required=True
+            )
+        ]
+        return _build_dynamic_image_schema(base_params, cls.MODEL_ENV_VAR, cls.DEFAULT_MODEL)
+
+    async def _execute(self, context, prompt: str, generation_config: Optional[dict] = None) -> str:
+        model_identifier = _get_configured_model_identifier(self.MODEL_ENV_VAR, self.DEFAULT_MODEL)
+        logger.info(f"GenerateImageTool executing with configured model '{model_identifier}'.")
+        client = None
+        try:
+            client = image_client_factory.create_image_client(model_identifier=model_identifier)
+            response = await client.generate_image(prompt=prompt, generation_config=generation_config)
+            
+            if not response.image_urls:
+                raise ValueError("Image generation failed to return any image URLs.")
+            
+            return f"Image generation successful. URLs: {response.image_urls}"
+        finally:
+            if client:
+                await client.cleanup()
+
+
+class EditImageTool(BaseTool):
+    """
+    An agent tool for editing an existing image using a text prompt and a pre-configured model.
+    """
+    CATEGORY = ToolCategory.MULTIMEDIA
+    MODEL_ENV_VAR = "DEFAULT_IMAGE_GENERATION_MODEL"
+    DEFAULT_MODEL = "gpt-image-1"
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "EditImage"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Edits an existing image based on a textual description (prompt) using the system's default image model. "
+            "A mask can be provided to specify the exact area to edit (inpainting). "
+            "Returns a list of URLs to the edited images."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        base_params = [
+            ParameterDefinition(
+                name="prompt",
+                param_type=ParameterType.STRING,
+                description="A detailed textual description of the edits to apply to the image.",
+                required=True
+            ),
+            ParameterDefinition(
+                name="input_image_urls",
+                param_type=ParameterType.STRING,
+                description="A comma-separated string of URLs to the source images that need to be edited. Some models may only use the first URL.",
+                required=True
+            ),
+            ParameterDefinition(
+                name="mask_image_url",
+                param_type=ParameterType.STRING,
+                description="Optional. A URL to a mask image (PNG). The transparent areas of this mask define where the input image should be edited.",
+                required=False
+            )
+        ]
+        return _build_dynamic_image_schema(base_params, cls.MODEL_ENV_VAR, cls.DEFAULT_MODEL)
+
+    async def _execute(self, context, prompt: str, input_image_urls: str, generation_config: Optional[dict] = None, mask_image_url: Optional[str] = None) -> str:
+        model_identifier = _get_configured_model_identifier(self.MODEL_ENV_VAR, self.DEFAULT_MODEL)
+        logger.info(f"EditImageTool executing with configured model '{model_identifier}'.")
+        client = None
+        try:
+            urls_list = [url.strip() for url in input_image_urls.split(',') if url.strip()]
+            if not urls_list:
+                raise ValueError("The 'input_image_urls' parameter cannot be empty.")
+
+            client = image_client_factory.create_image_client(model_identifier=model_identifier)
+            response = await client.edit_image(
+                prompt=prompt,
+                input_image_urls=urls_list,
+                mask_url=mask_image_url,
+                generation_config=generation_config
+            )
+
+            if not response.image_urls:
+                raise ValueError("Image editing failed to return any image URLs.")
+
+            return f"Image editing successful. URLs: {response.image_urls}"
+        finally:
+            if client:
+                await client.cleanup()

autobyteus/tools/tool_category.py

@@ -17,6 +17,7 @@ class ToolCategory(str, Enum):
     TASK_MANAGEMENT = "Task Management" # NEW CATEGORY ADDED
     GENERAL = "General"
     MCP = "MCP"
+    MULTIMEDIA = "Multimedia"
 
     def __str__(self) -> str:
         return self.value

autobyteus/tools/usage/parsers/provider_aware_tool_usage_parser.py

@@ -44,8 +44,11 @@ class ProviderAwareToolUsageParser:
         else:
             logger.warning(f"Agent '{context.agent_id}': LLM instance or model not available. Cannot determine provider for tool response parsing.")
         
-        # Get the correct parser directly from the new central registry.
-        parser = self._parser_registry.get_parser(llm_provider)
+        # Retrieve the override flag from the agent's configuration.
+        use_xml_tool_format = context.config.use_xml_tool_format
+
+        # Get the correct parser from the registry, passing the override flag.
+        parser = self._parser_registry.get_parser(llm_provider, use_xml_tool_format=use_xml_tool_format)
         
         logger.debug(f"ProviderAwareToolUsageParser selected delegate parser '{parser.get_name()}' for LLM provider '{llm_provider.name if llm_provider else 'Unknown'}'.")
 

autobyteus/tools/usage/providers/tool_manifest_provider.py

@@ -30,21 +30,23 @@ class ToolManifestProvider:
 
     def provide(self,
                 tool_definitions: List['ToolDefinition'],
-                provider: Optional[LLMProvider] = None) -> str:
+                provider: Optional[LLMProvider] = None,
+                use_xml_tool_format: bool = False) -> str:
         """
         Generates the manifest string for a list of tools.
 
         Args:
             tool_definitions: A list of ToolDefinition objects.
             provider: The LLM provider, for provider-specific formatting.
+            use_xml_tool_format: If True, forces the use of XML formatters.
 
         Returns:
             A single string containing the formatted manifest.
         """
         tool_blocks = []
 
-        # Get the correct formatting pair from the registry using only the provider.
-        formatter_pair = self._formatting_registry.get_formatter_pair(provider)
+        # Get the correct formatting pair from the registry, passing the override flag.
+        formatter_pair = self._formatting_registry.get_formatter_pair(provider, use_xml_tool_format=use_xml_tool_format)
         schema_formatter = formatter_pair.schema_formatter
         example_formatter = formatter_pair.example_formatter
 

autobyteus/tools/usage/registries/tool_formatting_registry.py

@@ -36,19 +36,26 @@ class ToolFormattingRegistry(metaclass=SingletonMeta):
         }
         # A default pair for any provider not explicitly listed (defaults to JSON)
         self._default_pair = ToolFormatterPair(DefaultJsonSchemaFormatter(), DefaultJsonExampleFormatter())
+        # A specific pair for the XML override
+        self._xml_override_pair = ToolFormatterPair(DefaultXmlSchemaFormatter(), DefaultXmlExampleFormatter())
         
         logger.info("ToolFormattingRegistry initialized with direct provider-to-formatter mappings.")
 
-    def get_formatter_pair(self, provider: Optional[LLMProvider]) -> ToolFormatterPair:
+    def get_formatter_pair(self, provider: Optional[LLMProvider], use_xml_tool_format: bool = False) -> ToolFormatterPair:
         """
-        Retrieves the appropriate formatting pair for a given provider.
+        Retrieves the appropriate formatting pair for a given provider, honoring the XML override.
 
         Args:
             provider: The LLMProvider enum member.
+            use_xml_tool_format: If True, forces the use of XML formatters.
 
         Returns:
             The corresponding ToolFormatterPair instance.
         """
+        if use_xml_tool_format:
+            logger.debug("XML tool format is forced by configuration. Returning XML formatter pair.")
+            return self._xml_override_pair
+
         if provider and provider in self._pairs:
             pair = self._pairs[provider]
             logger.debug(f"Found specific formatter pair for provider {provider.name}: {pair}")

autobyteus/tools/usage/registries/tool_usage_parser_registry.py

@@ -34,18 +34,25 @@ class ToolUsageParserRegistry(metaclass=SingletonMeta):
         }
         # A default parser for any provider not explicitly listed (defaults to JSON)
         self._default_parser = DefaultJsonToolUsageParser()
+        # A specific parser for the XML override
+        self._xml_override_parser = DefaultXmlToolUsageParser()
         logger.info("ToolUsageParserRegistry initialized with direct provider-to-parser mappings.")
 
-    def get_parser(self, provider: Optional[LLMProvider]) -> BaseToolUsageParser:
+    def get_parser(self, provider: Optional[LLMProvider], use_xml_tool_format: bool = False) -> BaseToolUsageParser:
         """
-        Retrieves the appropriate tool usage parser for a given provider.
+        Retrieves the appropriate tool usage parser for a given provider, honoring the XML override.
 
         Args:
             provider: The LLMProvider enum member.
+            use_xml_tool_format: If True, forces the use of the XML parser.
 
         Returns:
             The corresponding BaseToolUsageParser instance.
         """
+        if use_xml_tool_format:
+            logger.debug("XML tool format is forced by configuration. Returning XML parser.")
+            return self._xml_override_parser
+
         if provider and provider in self._parsers:
             parser = self._parsers[provider]
             logger.debug(f"Found specific tool usage parser for provider {provider.name}: {parser.get_name()}")

{autobyteus-1.1.5.dist-info → autobyteus-1.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.5
+Version: 1.1.6
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -15,9 +15,9 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
-Requires-Dist: anthropic==0.37.1
-Requires-Dist: autobyteus-llm-client==1.1.2
-Requires-Dist: beautifulsoup4>=4.12.2
+Requires-Dist: anthropic
+Requires-Dist: autobyteus-llm-client==1.1.3
+Requires-Dist: beautifulsoup4
 Requires-Dist: boto3
 Requires-Dist: botocore
 Requires-Dist: brui-core==1.0.9
@@ -25,17 +25,17 @@ Requires-Dist: certifi==2025.4.26
 Requires-Dist: google-api-python-client
 Requires-Dist: google-generativeai
 Requires-Dist: Jinja2
-Requires-Dist: mcp[cli]==1.9.1
-Requires-Dist: mistral_common==1.6.3
+Requires-Dist: mcp[cli]
+Requires-Dist: mistral_common
 Requires-Dist: mistralai
-Requires-Dist: mistralai==1.5.2
-Requires-Dist: numpy==2.2.5
+Requires-Dist: numpy
 Requires-Dist: ollama
 Requires-Dist: openai
 Requires-Dist: requests
 Requires-Dist: rich
 Requires-Dist: textual
-Requires-Dist: tiktoken==0.7.0
+Requires-Dist: tiktoken
+Requires-Dist: tokenizers
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: flake8; extra == "dev"