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

autobyteus/multimedia/image/image_client_factory.py

@@ -0,0 +1,118 @@
+import logging
+from typing import Dict, Optional
+from autobyteus.multimedia.image.autobyteus_image_provider import AutobyteusImageModelProvider
+from autobyteus.multimedia.image.base_image_client import BaseImageClient
+from autobyteus.multimedia.image.image_model import ImageModel
+from autobyteus.multimedia.providers import MultimediaProvider
+from autobyteus.multimedia.image.api.openai_image_client import OpenAIImageClient
+from autobyteus.multimedia.image.api.gemini_image_client import GeminiImageClient
+from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+from autobyteus.utils.singleton import SingletonMeta
+
+logger = logging.getLogger(__name__)
+
+class ImageClientFactory(metaclass=SingletonMeta):
+    """
+    A factory for creating instances of image generation clients based on registered ImageModels.
+    """
+    _models_by_identifier: Dict[str, ImageModel] = {}
+    _initialized = False
+
+    @staticmethod
+    def ensure_initialized():
+        """Ensures the factory is initialized before use."""
+        if not ImageClientFactory._initialized:
+            ImageClientFactory._initialize_registry()
+            ImageClientFactory._initialized = True
+
+    @staticmethod
+    def reinitialize():
+        """Reinitializes the model registry, clearing all models and re-discovering them."""
+        logger.info("Reinitializing Image model registry...")
+        ImageClientFactory._initialized = False
+        ImageClientFactory._models_by_identifier.clear()
+        ImageClientFactory.ensure_initialized()
+        logger.info("Image model registry reinitialized successfully.")
+
+    @staticmethod
+    def _initialize_registry():
+        """Initializes the registry with built-in image models and discovers remote ones."""
+        
+        # OpenAI Models
+        gpt_image_1_model = ImageModel(
+            name="gpt-image-1",
+            value="dall-e-3",
+            provider=MultimediaProvider.OPENAI,
+            client_class=OpenAIImageClient,
+            parameter_schema={
+                "n": {"type": "integer", "default": 1, "allowed_values": [1], "description": "The number of images to generate."},
+                "size": {"type": "string", "default": "1024x1024", "allowed_values": ["1024x1024", "1792x1024", "1024x1792"], "description": "The size of the generated images."},
+                "quality": {"type": "string", "default": "hd", "allowed_values": ["standard", "hd"], "description": "The quality of the image that will be generated."},
+                "style": {"type": "string", "default": "vivid", "allowed_values": ["vivid", "natural"], "description": "The style of the generated images."}
+            }
+        )
+
+        dall_e_2_model = ImageModel(
+            name="dall-e-2",
+            value="dall-e-2",
+            provider=MultimediaProvider.OPENAI,
+            client_class=OpenAIImageClient,
+            parameter_schema={
+                "n": {"type": "integer", "default": 1, "description": "The number of images to generate."},
+                "size": {"type": "string", "default": "1024x1024", "allowed_values": ["256x256", "512x512", "1024x1024"], "description": "The size of the generated images."}
+            }
+        )
+
+        # Google Imagen Models (via Gemini API)
+        imagen_model = ImageModel(
+            name="imagen-4",
+            value="imagen-4.0-generate-001",
+            provider=MultimediaProvider.GOOGLE,
+            client_class=GeminiImageClient,
+            parameter_schema={} # The genai library doesn't expose these as simple params
+        )
+
+        models_to_register = [
+            gpt_image_1_model,
+            dall_e_2_model,
+            imagen_model,
+        ]
+        
+        for model in models_to_register:
+            ImageClientFactory.register_model(model)
+        
+        logger.info("Default API-based image models registered.")
+
+        # Discover models from remote Autobyteus servers
+        AutobyteusImageModelProvider.discover_and_register()
+
+    @staticmethod
+    def register_model(model: ImageModel):
+        """Registers a new image model."""
+        identifier = model.model_identifier
+        if identifier in ImageClientFactory._models_by_identifier:
+            logger.warning(f"Image model '{identifier}' is already registered. Overwriting.")
+        
+        if not isinstance(model.provider, MultimediaProvider):
+            try:
+                model.provider = MultimediaProvider(model.provider)
+            except ValueError:
+                logger.error(f"Cannot register model '{identifier}' with unknown provider '{model.provider}'.")
+                return
+
+        ImageClientFactory._models_by_identifier[identifier] = model
+
+    @staticmethod
+    def create_image_client(model_identifier: str, config_override: Optional[MultimediaConfig] = None) -> BaseImageClient:
+        """Creates an instance of a registered image client for a specific model."""
+        ImageClientFactory.ensure_initialized()
+        
+        model = ImageClientFactory._models_by_identifier.get(model_identifier)
+        if not model:
+            raise ValueError(f"No image model registered with the name '{model_identifier}'. "
+                             f"Available models: {list(ImageClientFactory._models_by_identifier.keys())}")
+        
+        logger.info(f"Creating instance of image client for model '{model_identifier}'.")
+        return model.create_client(config_override)
+
+image_client_factory = ImageClientFactory()

autobyteus/multimedia/image/image_model.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+import logging
+from typing import TYPE_CHECKING, Type, Optional, Iterator, Dict, Any
+from urllib.parse import urlparse
+
+from autobyteus.multimedia.providers import MultimediaProvider
+from autobyteus.multimedia.runtimes import MultimediaRuntime
+from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+
+if TYPE_CHECKING:
+    from autobyteus.multimedia.image.base_image_client import BaseImageClient
+
+logger = logging.getLogger(__name__)
+
+class ImageModelMeta(type):
+    """
+    Metaclass for ImageModel to allow discovery and access like an Enum.
+    """
+    def __iter__(cls) -> Iterator[ImageModel]:
+        from autobyteus.multimedia.image.image_client_factory import ImageClientFactory
+        ImageClientFactory.ensure_initialized()
+        for model in ImageClientFactory._models_by_identifier.values():
+            yield model
+
+    def __getitem__(cls, name_or_identifier: str) -> ImageModel:
+        from autobyteus.multimedia.image.image_client_factory import ImageClientFactory
+        ImageClientFactory.ensure_initialized()
+        model = ImageClientFactory._models_by_identifier.get(name_or_identifier)
+        if model:
+            return model
+        available_models = list(ImageClientFactory._models_by_identifier.keys())
+        raise KeyError(f"Image model '{name_or_identifier}' not found. Available models: {available_models}")
+
+    def __len__(cls) -> int:
+        from autobyteus.multimedia.image.image_client_factory import ImageClientFactory
+        ImageClientFactory.ensure_initialized()
+        return len(ImageClientFactory._models_by_identifier)
+
+
+class ImageModel(metaclass=ImageModelMeta):
+    """
+    Represents a single image model's metadata.
+    """
+    def __init__(
+        self,
+        name: str,
+        value: str,
+        provider: MultimediaProvider,
+        client_class: Type["BaseImageClient"],
+        parameter_schema: Optional[Dict[str, Any]] = None,
+        runtime: MultimediaRuntime = MultimediaRuntime.API,
+        host_url: Optional[str] = None
+    ):
+        self.name = name
+        self.value = value
+        self.provider = provider
+        self.client_class = client_class
+        self.runtime = runtime
+        self.host_url = host_url
+        self.parameter_schema = parameter_schema if parameter_schema else {}
+
+        # Automatically build default_config from the schema's default values
+        default_params = {
+            key: meta.get("default")
+            for key, meta in self.parameter_schema.items()
+            if "default" in meta
+        }
+        self.default_config = MultimediaConfig(params=default_params)
+
+    @property
+    def model_identifier(self) -> str:
+        """Returns the unique identifier for the model."""
+        if self.runtime == MultimediaRuntime.AUTOBYTEUS and self.host_url:
+            try:
+                host = urlparse(self.host_url).hostname
+                return f"{self.name}@{host}"
+            except Exception:
+                return f"{self.name}@{self.host_url}" # Fallback
+        return self.name
+
+    def create_client(self, config_override: Optional[MultimediaConfig] = None) -> "BaseImageClient":
+        """
+        Instantiates the client class for this model.
+        """
+        config_to_use = self.default_config
+        if config_override:
+            from copy import deepcopy
+            config_to_use = deepcopy(self.default_config)
+            config_to_use.merge_with(config_override)
+        
+        return self.client_class(model=self, config=config_to_use)
+
+    def __repr__(self):
+        return (
+            f"ImageModel(identifier='{self.model_identifier}', "
+            f"provider='{self.provider.name}', runtime='{self.runtime.value}')"
+        )

autobyteus/multimedia/providers.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+class MultimediaProvider(Enum):
+    OPENAI = "OPENAI"
+    GOOGLE = "GOOGLE"

autobyteus/multimedia/runtimes.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class MultimediaRuntime(Enum):
+    """
+    Specifies the execution environment for a multimedia model.
+    """
+    API = "api"
+    AUTOBYTEUS = "autobyteus"

autobyteus/multimedia/utils/__init__.py

@@ -0,0 +1,10 @@
+from .multimedia_config import MultimediaConfig
+from .response_types import ImageGenerationResponse, SpeechGenerationResponse
+from .api_utils import load_image_from_url
+
+__all__ = [
+    "MultimediaConfig",
+    "ImageGenerationResponse",
+    "SpeechGenerationResponse",
+    "load_image_from_url",
+]

autobyteus/multimedia/utils/api_utils.py

@@ -0,0 +1,19 @@
+import logging
+from PIL import Image
+import requests
+
+logger = logging.getLogger(__name__)
+
+def load_image_from_url(url: str) -> Image.Image:
+    """Loads an image from a URL (http, https, or file path)."""
+    try:
+        if url.startswith(('http://', 'https://')):
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
+            return Image.open(response.raw)
+        else:
+            # Assume it's a local file path
+            return Image.open(url)
+    except Exception as e:
+        logger.error(f"Failed to load image from URL/path '{url}': {e}")
+        raise

autobyteus/multimedia/utils/multimedia_config.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any
+
+@dataclass
+class MultimediaConfig:
+    """
+    Configuration for multimedia generation, using a flexible dictionary for parameters.
+    """
+    params: Dict[str, Any] = field(default_factory=dict)
+
+    def merge_with(self, override_config: Optional['MultimediaConfig']):
+        """
+        Merges parameters from an override config into this one.
+        """
+        if override_config and override_config.params:
+            self.params.update(override_config.params)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'MultimediaConfig':
+        """
+        Creates a MultimediaConfig instance from a dictionary of parameters.
+        """
+        return cls(params=data if data is not None else {})
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Returns the configuration parameters as a dictionary.
+        """
+        return self.params

autobyteus/multimedia/utils/response_types.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from typing import Optional, List
+
+@dataclass
+class ImageGenerationResponse:
+    """Response for image generation or editing."""
+    image_urls: List[str]
+    revised_prompt: Optional[str] = None
+
+@dataclass
+class SpeechGenerationResponse:
+    """Response for speech generation (Text-to-Speech)."""
+    audio_urls: List[str]

autobyteus/task_management/tools/publish_task_plan.py

@@ -4,12 +4,11 @@ import logging
 from typing import TYPE_CHECKING, Optional, Dict, Any
 
 from pydantic import ValidationError
-# No longer need GenerateJsonSchema from pydantic.json_schema
-# from pydantic.json_schema import GenerateJsonSchema
 
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
 from autobyteus.task_management.schemas import TaskPlanDefinitionSchema
 from autobyteus.task_management.converters import TaskPlanConverter, TaskBoardConverter
 
@@ -24,8 +23,6 @@ class PublishTaskPlan(BaseTool):
 
     CATEGORY = ToolCategory.TASK_MANAGEMENT
 
-    # The failing custom InlineSchemaGenerator has been removed.
-
     @classmethod
     def get_name(cls) -> str:
         return "PublishTaskPlan"
@@ -44,11 +41,8 @@ class PublishTaskPlan(BaseTool):
     def get_argument_schema(cls) -> Optional[ParameterSchema]:
         schema = ParameterSchema()
         
-        # CORRECTED IMPLEMENTATION:
-        # A direct, standard call to model_json_schema(). This generates a valid
-        # JSON schema with $refs, which the framework handles correctly.
-        # This completely avoids the TypeError caused by the unsupported 'ref_strategy' argument.
-        object_json_schema = TaskPlanDefinitionSchema.model_json_schema()
+        # Convert the Pydantic model to our native ParameterSchema for the nested object
+        plan_object_schema = pydantic_to_parameter_schema(TaskPlanDefinitionSchema)
         
         schema.add_parameter(ParameterDefinition(
             name="plan",
@@ -59,7 +53,7 @@ class PublishTaskPlan(BaseTool):
                 "Each task must have a unique name within the plan."
             ),
             required=True,
-            object_schema=object_json_schema
+            object_schema=plan_object_schema
         ))
         return schema
 
@@ -83,12 +77,8 @@ class PublishTaskPlan(BaseTool):
             return error_msg
             
         try:
-            # Step 1: The input is now a dictionary, so we can directly validate it.
             plan_definition_schema = TaskPlanDefinitionSchema(**plan)
-
-            # Step 2: Use the dedicated converter to create the internal TaskPlan object.
             final_plan = TaskPlanConverter.from_schema(plan_definition_schema)
-
         except (ValidationError, ValueError) as e:
             error_msg = f"Invalid or inconsistent task plan provided: {e}"
             logger.warning(f"Agent '{context.agent_id}' provided an invalid plan for PublishTaskPlan: {error_msg}")
@@ -100,12 +90,10 @@ class PublishTaskPlan(BaseTool):
 
         if task_board.load_task_plan(final_plan):
             logger.info(f"Agent '{context.agent_id}': Task plan published successfully. Returning new board status.")
-            # Convert the new state of the board back to an LLM-friendly schema and return it.
             status_report_schema = TaskBoardConverter.to_schema(task_board)
             if status_report_schema:
                 return status_report_schema.model_dump_json(indent=2)
             else:
-                # This is a fallback case, shouldn't happen right after a successful load.
                 return "Task plan published successfully, but could not generate status report."
         else:
             error_msg = "Failed to load task plan onto the board. This can happen if the board implementation rejects the plan."

autobyteus/task_management/tools/update_task_status.py

@@ -6,6 +6,7 @@ from pydantic import ValidationError
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
 from autobyteus.task_management.base_task_board import TaskStatus
 from autobyteus.task_management.deliverable import FileDeliverable
 from autobyteus.task_management.schemas import FileDeliverableSchema
@@ -53,14 +54,11 @@ class UpdateTaskStatus(BaseTool):
             param_type=ParameterType.ARRAY,
             description="Optional. A list of file deliverables to submit for this task, typically when status is 'completed'. Each deliverable must include a file_path and a summary.",
             required=False,
-            array_item_schema=FileDeliverableSchema.model_json_schema()
+            array_item_schema=pydantic_to_parameter_schema(FileDeliverableSchema)
         ))
         return schema
 
     async def _execute(self, context: 'AgentContext', task_name: str, status: str, deliverables: Optional[List[Dict[str, Any]]] = None) -> str:
-        """
-        Executes the tool to update a task's status and optionally submit deliverables.
-        """
         agent_name = context.config.name
         log_msg = f"Agent '{agent_name}' is executing UpdateTaskStatus for task '{task_name}' to status '{status}'"
         if deliverables:
@@ -84,12 +82,7 @@ class UpdateTaskStatus(BaseTool):
             logger.warning(f"Agent '{agent_name}' tried to update task status, but no plan is loaded.")
             return error_msg
 
-        # Find the task by name
-        target_task = None
-        for task in task_board.current_plan.tasks:
-            if task.task_name == task_name:
-                target_task = task
-                break
+        target_task = next((t for t in task_board.current_plan.tasks if t.task_name == task_name), None)
 
         if not target_task:
             error_msg = f"Failed to update status for task '{task_name}'. The task name does not exist on the current plan."
@@ -103,17 +96,11 @@ class UpdateTaskStatus(BaseTool):
             logger.warning(f"Agent '{agent_name}' provided invalid status for UpdateTaskStatus: {status}")
             return f"Error: {error_msg}"
         
-        # --- Process Deliverables FIRST --- (CORRECTED ORDER)
         if deliverables:
             try:
                 for d_data in deliverables:
-                    # Validate and create the internal deliverable object
                     deliverable_schema = FileDeliverableSchema(**d_data)
-                    full_deliverable = FileDeliverable(
-                        **deliverable_schema.model_dump(),
-                        author_agent_name=agent_name
-                    )
-                    # Append to the task object
+                    full_deliverable = FileDeliverable(**deliverable_schema.model_dump(), author_agent_name=agent_name)
                     target_task.file_deliverables.append(full_deliverable)
                 logger.info(f"Agent '{agent_name}' successfully processed and added {len(deliverables)} deliverables to task '{task_name}'.")
             except (ValidationError, TypeError) as e:
@@ -121,8 +108,6 @@ class UpdateTaskStatus(BaseTool):
                 logger.warning(f"Agent '{agent_name}': {error_msg}")
                 return f"Error: {error_msg}"
 
-        # --- Update Status SECOND --- (CORRECTED ORDER)
-        # This will now emit an event with the deliverables already attached to the task.
         if not task_board.update_task_status(target_task.task_id, status_enum, agent_name):
             error_msg = f"Failed to update status for task '{task_name}'. An unexpected error occurred on the task board."
             logger.error(f"Agent '{agent_name}': {error_msg}")

autobyteus/tools/__init__.py

@@ -16,18 +16,18 @@ from .tool_category import ToolCategory
 # --- Re-export specific tools for easier access ---
 
 # Functional tools (decorated functions are now instances)
-from .ask_user_input import ask_user_input
 from .pdf_downloader import pdf_downloader
 from .bash.bash_executor import bash_executor
 from .file.file_reader import file_reader
 from .file.file_writer import file_writer
 
 # General Class-based tools
+from .google_search import GoogleSearch 
 from .image_downloader import ImageDownloader
 from .timer import Timer
+from .multimedia.image_tools import GenerateImageTool, EditImageTool
 
 # Standalone Browser tools
-from .browser.standalone.google_search_ui import GoogleSearch
 from .browser.standalone.navigate_to import NavigateTo as StandaloneNavigateTo # Alias to avoid name clash
 from .browser.standalone.webpage_reader import WebPageReader as StandaloneWebPageReader # Alias
 from .browser.standalone.webpage_screenshot_taker import WebPageScreenshotTaker as StandaloneWebPageScreenshotTaker # Alias
@@ -53,18 +53,19 @@ __all__ = [
     "ToolCategory",
 
     # Re-exported functional tool instances
-    "ask_user_input",
     "pdf_downloader",
     "bash_executor",
     "file_reader",
     "file_writer",
 
     # Re-exported general class-based tools
+    "GoogleSearch",
     "ImageDownloader",
     "Timer",
+    "GenerateImageTool",
+    "EditImageTool",
 
     # Re-exported Standalone Browser tools
-    "GoogleSearch",
     "StandaloneNavigateTo",
     "StandaloneWebPageReader",
     "StandaloneWebPageScreenshotTaker",