autobyteus 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

autobyteus/multimedia/image/api/openai_image_client.py

@@ -1,9 +1,14 @@
 import logging
 import os
+import tempfile
+from pathlib import Path
 from typing import Optional, List, Dict, Any, TYPE_CHECKING
+
 from openai import OpenAI
+
 from autobyteus.multimedia.image.base_image_client import BaseImageClient
 from autobyteus.multimedia.utils.response_types import ImageGenerationResponse
+from autobyteus.utils.download_utils import download_file_from_url
 
 if TYPE_CHECKING:
     from autobyteus.multimedia.image.image_model import ImageModel
@@ -11,9 +16,19 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+
+def _mime_type_from_format(output_format: str) -> str:
+    fmt = (output_format or "png").lower()
+    if fmt in {"jpg", "jpeg"}:
+        return "image/jpeg"
+    if fmt == "webp":
+        return "image/webp"
+    return "image/png"
+
+
 class OpenAIImageClient(BaseImageClient):
     """
-    An image client that uses OpenAI's DALL-E models.
+    An image client that uses OpenAI's gpt-image series via the images API.
     """
 
     def __init__(self, model: "ImageModel", config: "MultimediaConfig"):
@@ -34,49 +49,68 @@ class OpenAIImageClient(BaseImageClient):
         **kwargs
     ) -> ImageGenerationResponse:
         """
-        Generates an image using an OpenAI DALL-E model via the v1/images/generations endpoint.
-        Note: This endpoint does not support image inputs, even for multimodal models like gpt-image-1.
+        Generates an image using OpenAI's images generation endpoint.
+        Note: This endpoint does not support image inputs.
         """
         if input_image_urls:
             logger.warning(
-                f"The OpenAI `images.generate` API used by this client does not support input images. "
-                f"The images provided for model '{self.model.value}' will be ignored. "
-                f"To use image inputs, a client based on the Chat Completions API is required."
+                "The OpenAI `images.generate` API used by this client does not support input images. "
+                "The images provided for model '%s' will be ignored. "
+                "To use image inputs, a client based on the Chat Completions API is required.",
+                self.model.value,
             )
 
         try:
             image_model = self.model.value
-            logger.info(f"Generating image with OpenAI model '{image_model}' and prompt: '{prompt[:50]}...'")
+            logger.info("Generating image with OpenAI model '%s' and prompt: '%s...'", image_model, prompt[:50])
 
             # Combine default config with any overrides
             final_config = self.config.to_dict().copy()
             if generation_config:
                 final_config.update(generation_config)
-
-            response = self.client.images.generate(
-                model=image_model,
-                prompt=prompt,
-                n=final_config.get("n", 1),
-                size=final_config.get("size", "1024x1024"),
-                quality=final_config.get("quality", "standard"),
-                style=final_config.get("style", "vivid"),
-                response_format="url"
+            # Always request a single image for simplicity
+            final_config["n"] = 1
+
+            request_kwargs = {
+                "model": image_model,
+                "prompt": prompt,
+                "n": 1,
+                "size": final_config.get("size", "1024x1024"),
+                "quality": final_config.get("quality", "standard"),
+            }
+            if "output_format" in final_config:
+                request_kwargs["output_format"] = final_config["output_format"]
+            if "output_compression" in final_config:
+                request_kwargs["output_compression"] = final_config["output_compression"]
+
+            response = self.client.images.generate(**request_kwargs)
+
+            output_format = final_config.get("output_format", "png")
+            mime_type = _mime_type_from_format(output_format)
+            image_urls_list: List[str] = []
+            for img in response.data:
+                if getattr(img, "url", None):
+                    image_urls_list.append(img.url)
+                elif getattr(img, "b64_json", None):
+                    image_urls_list.append(f"data:{mime_type};base64,{img.b64_json}")
+
+            revised_prompt: Optional[str] = (
+                response.data[0].revised_prompt
+                if response.data and hasattr(response.data[0], "revised_prompt")
+                else None
             )
 
-            image_urls_list: List[str] = [img.url for img in response.data if img.url]
-            revised_prompt: Optional[str] = response.data[0].revised_prompt if response.data and hasattr(response.data[0], 'revised_prompt') else None
-
             if not image_urls_list:
-                raise ValueError("OpenAI API did not return any image URLs.")
+                raise ValueError("OpenAI API did not return any image data.")
 
-            logger.info(f"Successfully generated {len(image_urls_list)} image(s).")
+            logger.info("Successfully generated %s image(s).", len(image_urls_list))
 
             return ImageGenerationResponse(
                 image_urls=image_urls_list,
                 revised_prompt=revised_prompt
             )
         except Exception as e:
-            logger.error(f"Error during OpenAI image generation: {str(e)}")
+            logger.error("Error during OpenAI image generation: %s", str(e))
             raise ValueError(f"OpenAI image generation failed: {str(e)}")
 
     async def edit_image(
@@ -95,49 +129,97 @@ class OpenAIImageClient(BaseImageClient):
 
         source_image_url = input_image_urls[0]
         if len(input_image_urls) > 1:
-            logger.warning(f"OpenAI edit endpoint only supports one input image. Using '{source_image_url}' and ignoring the rest.")
+            logger.warning(
+                "OpenAI edit endpoint only supports one input image. Using '%s' and ignoring the rest.",
+                source_image_url,
+            )
 
+        temp_image_path: Optional[Path] = None
+        temp_mask_path: Optional[Path] = None
         try:
-            logger.info(f"Editing image '{source_image_url}' with prompt: '{prompt[:50]}...'")
+            logger.info("Editing image '%s' with prompt: '%s...'", source_image_url, prompt[:50])
 
             # Combine default config with any overrides
             final_config = self.config.to_dict().copy()
             if generation_config:
                 final_config.update(generation_config)
-
-            with open(source_image_url, "rb") as image_file:
-                mask_file = open(mask_url, "rb") if mask_url else None
+            # Always request a single edited image
+            final_config["n"] = 1
+
+            source_path = Path(source_image_url)
+            if not source_path.exists():
+                temp_image_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+                temp_image_file.close()
+                temp_image_path = Path(temp_image_file.name)
+                await download_file_from_url(source_image_url, temp_image_path)
+                source_path = temp_image_path
+
+            if mask_url:
+                mask_path = Path(mask_url)
+                if not mask_path.exists():
+                    temp_mask_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+                    temp_mask_file.close()
+                    temp_mask_path = Path(temp_mask_file.name)
+                    await download_file_from_url(mask_url, temp_mask_path)
+                    mask_path = temp_mask_path
+            else:
+                mask_path = None
+
+            with open(source_path, "rb") as image_file:
+                mask_file = open(mask_path, "rb") if mask_path else None
                 try:
-                    response = self.client.images.edit(
-                        image=image_file,
-                        mask=mask_file,
-                        prompt=prompt,
-                        model=self.model.value,
-                        n=final_config.get("n", 1),
-                        size=final_config.get("size", "1024x1024"),
-                        response_format="url"
-                    )
+                    request_kwargs = {
+                        "image": image_file,
+                        "prompt": prompt,
+                        "model": self.model.value,
+                        "n": final_config.get("n", 1),
+                        "size": final_config.get("size", "1024x1024"),
+                    }
+                    if mask_file:
+                        request_kwargs["mask"] = mask_file
+                    if "output_format" in final_config:
+                        request_kwargs["output_format"] = final_config["output_format"]
+                    if "output_compression" in final_config:
+                        request_kwargs["output_compression"] = final_config["output_compression"]
+                    response = self.client.images.edit(**request_kwargs)
                 finally:
                     if mask_file:
                         mask_file.close()
 
-            image_urls_list: List[str] = [img.url for img in response.data if img.url]
+            output_format = final_config.get("output_format", "png")
+            mime_type = _mime_type_from_format(output_format)
+            image_urls_list: List[str] = []
+            for img in response.data:
+                if getattr(img, "url", None):
+                    image_urls_list.append(img.url)
+                elif getattr(img, "b64_json", None):
+                    image_urls_list.append(f"data:{mime_type};base64,{img.b64_json}")
+
             if not image_urls_list:
-                raise ValueError("OpenAI API did not return any edited image URLs.")
+                raise ValueError("OpenAI API did not return any edited image data.")
 
-            logger.info(f"Successfully edited image, generated {len(image_urls_list)} version(s).")
+            logger.info("Successfully edited image, generated %s version(s).", len(image_urls_list))
             return ImageGenerationResponse(image_urls=image_urls_list)
 
         except FileNotFoundError as e:
-            logger.error(f"Image file not found for editing: {e.filename}")
+            logger.error("Image file not found for editing: %s", e.filename)
             raise
         except Exception as e:
-            logger.error(f"Error during OpenAI image editing: {str(e)}")
-            # The API might return a 400 Bad Request if the model doesn't support edits
+            logger.error("Error during OpenAI image editing: %s", str(e))
             if "does not support image editing" in str(e):
                 raise ValueError(f"The model '{self.model.value}' does not support the image editing endpoint.")
             raise ValueError(f"OpenAI image editing failed: {str(e)}")
-
+        finally:
+            if temp_image_path and temp_image_path.exists():
+                try:
+                    temp_image_path.unlink()
+                except OSError:
+                    logger.warning("Failed to clean up temp image file: %s", temp_image_path)
+            if temp_mask_path and temp_mask_path.exists():
+                try:
+                    temp_mask_path.unlink()
+                except OSError:
+                    logger.warning("Failed to clean up temp mask file: %s", temp_mask_path)
 
     async def cleanup(self):
         # The OpenAI client does not require explicit cleanup of a session.

autobyteus/multimedia/image/autobyteus_image_provider.py

@@ -86,7 +86,8 @@ class AutobyteusImageModelProvider:
                             client_class=AutobyteusImageClient,
                             runtime=MultimediaRuntime.AUTOBYTEUS,
                             host_url=host_url,
-                            parameter_schema=model_info.get("parameter_schema")
+                            parameter_schema=model_info.get("parameter_schema"),
+                            description=model_info.get("description")
                         )
                         
                         ImageClientFactory.register_model(image_model)

autobyteus/multimedia/image/image_client_factory.py

@@ -40,43 +40,75 @@ class ImageClientFactory(metaclass=SingletonMeta):
         """Initializes the registry with built-in image models and discovers remote ones."""
         
         # OpenAI Models
-        gpt_image_1_schema = ParameterSchema(parameters=[
+        gpt_image_15_schema = ParameterSchema(parameters=[
             ParameterDefinition(name="n", param_type=ParameterType.INTEGER, default_value=1, enum_values=[1], description="The number of images to generate."),
             ParameterDefinition(name="size", param_type=ParameterType.ENUM, default_value="1024x1024", enum_values=["1024x1024", "1792x1024", "1024x1792"], description="The size of the generated images."),
-            ParameterDefinition(name="quality", param_type=ParameterType.ENUM, default_value="hd", enum_values=["standard", "hd"], description="The quality of the image that will be generated."),
-            ParameterDefinition(name="style", param_type=ParameterType.ENUM, default_value="vivid", enum_values=["vivid", "natural"], description="The style of the generated images.")
+            ParameterDefinition(name="quality", param_type=ParameterType.ENUM, default_value="auto", enum_values=["auto", "low", "medium", "high"], description="The quality of the image that will be generated.")
         ])
 
-        gpt_image_1_model = ImageModel(
-            name="gpt-image-1",
-            value="gpt-image-1",
+        gemini_image_schema = ParameterSchema(parameters=[
+            ParameterDefinition(name="n", param_type=ParameterType.INTEGER, default_value=1, enum_values=[1], description="The number of images to generate."),
+            ParameterDefinition(name="size", param_type=ParameterType.ENUM, default_value="1024x1024", enum_values=["1024x1024", "1792x1024", "1024x1792"], description="The size of the generated images."),
+            ParameterDefinition(name="quality", param_type=ParameterType.ENUM, default_value="auto", enum_values=["auto", "low", "medium", "high"], description="The quality of the image that will be generated.")
+        ])
+
+        gpt_image_15_model = ImageModel(
+            name="gpt-image-1.5",
+            value="gpt-image-1.5",
             provider=MultimediaProvider.OPENAI,
             client_class=OpenAIImageClient,
-            parameter_schema=gpt_image_1_schema
+            parameter_schema=gpt_image_15_schema,
+            description=(
+                "OpenAI's latest **stateless (single-turn)** image model with faster renders, improved text rendering, "
+                "and higher fidelity edits. Same API surface as gpt-image-1."
+            )
         )
 
         # Google Imagen Models (via Gemini API)
         imagen_model = ImageModel(
             name="imagen-4",
             value="imagen-4.0-generate-001",
-            provider=MultimediaProvider.GOOGLE,
+            provider=MultimediaProvider.GEMINI,
             client_class=GeminiImageClient,
-            parameter_schema=None # The genai library doesn't expose these as simple params
+            parameter_schema=None, # The genai library doesn't expose these as simple params
+            description=(
+                "A high-fidelity **stateless (single-turn)** model. "
+                "Does **NOT** support input images (text-to-image only). "
+                "Any provided input images will be ignored."
+            )
         )
 
-        # Google Gemini Flash Image Model (aka "Nano Banana")
+        # Google Gemini 2.5 Flash Image (legacy, still widely available)
         gemini_flash_image_model = ImageModel(
-            name="gemini-2.5-flash-image-preview",
-            value="gemini-2.5-flash-image-preview",
-            provider=MultimediaProvider.GOOGLE,
+            name="gemini-2.5-flash-image",
+            value="gemini-2.5-flash-image",
+            provider=MultimediaProvider.GEMINI,
+            client_class=GeminiImageClient,
+            parameter_schema=None,  # Parameters handled by genai library
+            description=(
+                "Fast **conversational (multi-turn)** multimodal image model. "
+                "Supports context retention and input images for edits/variations."
+            )
+        )
+
+        # Google Gemini 3 Pro Image (aka "Nano Banana Pro")
+        gemini_pro_image_model = ImageModel(
+            name="gemini-3-pro-image-preview",
+            value="gemini-3-pro-image-preview",
+            provider=MultimediaProvider.GEMINI,
             client_class=GeminiImageClient,
-            parameter_schema=None # Parameters are not exposed for this model via the genai library.
+            parameter_schema=None,  # genai library handles options internally
+            description=(
+                "High-quality **conversational (multi-turn)** image model for complex edits and 4K renders. "
+                "Supports up to 14 reference images, advanced text rendering, and thinking mode."
+            )
         )
 
         models_to_register = [
-            gpt_image_1_model,
+            gpt_image_15_model,
             imagen_model,
             gemini_flash_image_model,
+            gemini_pro_image_model,
         ]
         
         for model in models_to_register:

autobyteus/multimedia/image/image_model.py

@@ -50,7 +50,8 @@ class ImageModel(metaclass=ImageModelMeta):
         client_class: Type["BaseImageClient"],
         parameter_schema: Optional[Union[Dict[str, Any], ParameterSchema]] = None,
         runtime: MultimediaRuntime = MultimediaRuntime.API,
-        host_url: Optional[str] = None
+        host_url: Optional[str] = None,
+        description: Optional[str] = None
     ):
         self.name = name
         self.value = value
@@ -58,6 +59,7 @@ class ImageModel(metaclass=ImageModelMeta):
         self.client_class = client_class
         self.runtime = runtime
         self.host_url = host_url
+        self.description = description
         
         if isinstance(parameter_schema, dict):
             self.parameter_schema = ParameterSchema.from_dict(parameter_schema)
@@ -79,7 +81,8 @@ class ImageModel(metaclass=ImageModelMeta):
         """Returns the unique identifier for the model."""
         if self.runtime == MultimediaRuntime.AUTOBYTEUS and self.host_url:
             try:
-                host = urlparse(self.host_url).hostname
+                parsed = urlparse(self.host_url)
+                host = parsed.netloc or parsed.hostname or self.host_url
                 return f"{self.name}@{host}"
             except Exception:
                 return f"{self.name}@{self.host_url}" # Fallback

autobyteus/multimedia/providers.py

@@ -2,5 +2,6 @@ from enum import Enum
 
 class MultimediaProvider(Enum):
     OPENAI = "OPENAI"
-    GOOGLE = "GOOGLE"
-    ALIBABA_QWEN = "ALIBABA_QWEN"
+    GEMINI = "GEMINI"
+    QWEN = "QWEN"
+    AUTOBYTEUS = "AUTOBYTEUS"

autobyteus/skills/loader.py

@@ -0,0 +1,71 @@
+import os
+import logging
+import re
+from typing import Optional
+from autobyteus.skills.model import Skill
+
+logger = logging.getLogger(__name__)
+
+class SkillLoader:
+    """
+    Responsible for loading and parsing SKILL.md files.
+    Designed to be forgiving of minor formatting variations in LLM-generated content.
+    """
+
+    @staticmethod
+    def load_skill(path: str) -> Skill:
+        """
+        Loads a skill from a given directory path.
+        """
+        if not os.path.isdir(path):
+             raise FileNotFoundError(f"Skill directory not found: {path}")
+
+        skill_file = os.path.join(path, "SKILL.md")
+        if not os.path.exists(skill_file):
+            raise FileNotFoundError(f"SKILL.md not found in {path}")
+
+        try:
+            with open(skill_file, 'r', encoding='utf-8') as f:
+                raw_content = f.read()
+        except Exception as e:
+            raise IOError(f"Failed to read SKILL.md at {skill_file}: {e}")
+
+        return SkillLoader._parse_skill(raw_content, path)
+
+    @staticmethod
+    def _parse_skill(raw_content: str, root_path: str) -> Skill:
+        """
+        Parses the content of a SKILL.md file. 
+        Extracts metadata from the frontmatter block (delimited by ---).
+        """
+        # Extract the frontmatter block
+        # Using a regex that is forgiving of whitespace around delimiters
+        match = re.search(r'^\s*---\s*\n(.*?)\n\s*---\s*\n(.*)', raw_content, re.DOTALL | re.MULTILINE) 
+        
+        if not match:
+            raise ValueError("Invalid SKILL.md format: Could not find frontmatter block delimited by '---'")
+
+        frontmatter_text = match.group(1)
+        body_content = match.group(2).strip()
+
+        # Parse frontmatter lines (Key: Value)
+        metadata = {}
+        for line in frontmatter_text.splitlines():
+            if ":" in line:
+                key, value = line.split(":", 1)
+                metadata[key.strip().lower()] = value.strip()
+
+        name = metadata.get("name")
+        description = metadata.get("description")
+
+        if not name:
+            raise ValueError("Missing 'name' in SKILL.md metadata")
+        if not description:
+            raise ValueError("Missing 'description' in SKILL.md metadata")
+
+        return Skill(
+            name=name,
+            description=description,
+            content=body_content,
+            root_path=root_path
+        )

autobyteus/skills/model.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+@dataclass
+class Skill:
+    """
+    Represents a loaded skill.
+    """
+    name: str
+    description: str
+    content: str  # The body of the SKILL.md file
+    root_path: str  # The absolute path to the skill directory

autobyteus/skills/registry.py

@@ -0,0 +1,70 @@
+import os
+import logging
+from typing import Dict, List, Optional
+from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.skills.model import Skill
+from autobyteus.skills.loader import SkillLoader
+
+logger = logging.getLogger(__name__)
+
+class SkillRegistry(metaclass=SingletonMeta):
+    """
+    A singleton registry for managing and discovering agent skills.
+    """
+
+    def __init__(self):
+        self._skills: Dict[str, Skill] = {}
+        logger.info("SkillRegistry initialized.")
+
+    def register_skill_from_path(self, path: str) -> Skill:
+        """
+        Loads a skill from the given path and registers it.
+        If a skill with the same name already exists, it will be overwritten.
+        """
+        try:
+            skill = SkillLoader.load_skill(path)
+            self._skills[skill.name] = skill
+            logger.info(f"Skill '{skill.name}' registered from path: {path}")
+            return skill
+        except Exception as e:
+            logger.error(f"Failed to register skill from path '{path}': {e}")
+            raise
+
+    def discover_skills(self, directory_path: str):
+        """
+        Scans a directory for skill subdirectories (those containing SKILL.md) 
+        and registers them.
+        """
+        if not os.path.isdir(directory_path):
+            logger.warning(f"Discovery directory not found: {directory_path}")
+            return
+
+        logger.debug(f"Discovering skills in: {directory_path}")
+        for entry in os.scandir(directory_path):
+            if entry.is_dir():
+                skill_md_path = os.path.join(entry.path, "SKILL.md")
+                if os.path.exists(skill_md_path):
+                    try:
+                        self.register_skill_from_path(entry.path)
+                    except Exception:
+                        # Continue discovering other skills even if one fails
+                        continue
+
+    def get_skill(self, name: str) -> Optional[Skill]:
+        """
+        Retrieves a skill by its name.
+        """
+        return self._skills.get(name)
+
+    def list_skills(self) -> List[Skill]:
+        """
+        Returns a list of all registered skills.
+        """
+        return list(self._skills.values())
+
+    def clear(self):
+        """
+        Clears all registered skills. Primarily for testing.
+        """
+        self._skills.clear()
+        logger.debug("SkillRegistry cleared.")

autobyteus/task_management/tools/todo_tools/add_todo.py

@@ -16,11 +16,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 def _notify_todo_update(context: 'AgentContext'):
-    if context.phase_manager and context.phase_manager.notifier:
+    if context.status_manager and context.status_manager.notifier:
         todo_list = context.state.todo_list
         if todo_list:
             todos_for_llm = [todo.model_dump(mode='json') for todo in todo_list.get_all_todos()]
-            context.phase_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
+            context.status_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
             logger.debug(f"Agent '{context.agent_id}': Notified ToDo list update with {len(todos_for_llm)} items.")
 
 class AddToDo(BaseTool):

autobyteus/task_management/tools/todo_tools/create_todo_list.py

@@ -17,11 +17,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 def _notify_todo_update(context: 'AgentContext'):
-    if context.phase_manager and context.phase_manager.notifier:
+    if context.status_manager and context.status_manager.notifier:
         todo_list = context.state.todo_list
         if todo_list:
             todos_for_llm = [todo.model_dump(mode='json') for todo in todo_list.get_all_todos()]
-            context.phase_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
+            context.status_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
             logger.debug(f"Agent '{context.agent_id}': Notified ToDo list update with {len(todos_for_llm)} items.")
 
 class CreateToDoList(BaseTool):

autobyteus/task_management/tools/todo_tools/update_todo_status.py

@@ -13,11 +13,11 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 def _notify_todo_update(context: 'AgentContext'):
-    if context.phase_manager and context.phase_manager.notifier:
+    if context.status_manager and context.status_manager.notifier:
         todo_list = context.state.todo_list
         if todo_list:
             todos_for_llm = [todo.model_dump(mode='json') for todo in todo_list.get_all_todos()]
-            context.phase_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
+            context.status_manager.notifier.notify_agent_data_todo_list_updated(todos_for_llm)
             logger.debug(f"Agent '{context.agent_id}': Notified ToDo list update with {len(todos_for_llm)} items.")
 
 class UpdateToDoStatus(BaseTool):