autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

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="dall-e-3",
+        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/__init__.py

@@ -1,23 +1,36 @@
 # file: autobyteus/autobyteus/task_management/__init__.py
 """
 This package defines components for task management and state tracking,
-including task plans and live task boards. It is designed to be a general-purpose
-module usable by various components, such as agents or agent teams.
+including task plans and live plan execution tracking. It is designed to be a
+general-purpose module usable by various components, such as agents or agent teams.
 """
 from .task import Task
 from .schemas import (TasksDefinitionSchema, TaskDefinitionSchema, TaskStatusReportSchema,
-                      TaskStatusReportItemSchema, FileDeliverableSchema)
-from .base_task_board import BaseTaskBoard, TaskStatus
-from .in_memory_task_board import InMemoryTaskBoard
+                      TaskStatusReportItemSchema, FileDeliverableSchema, ToDoDefinitionSchema, ToDosDefinitionSchema)
+from .base_task_plan import BaseTaskPlan, TaskStatus
+from .in_memory_task_plan import InMemoryTaskPlan
 from .deliverable import FileDeliverable
-from .tools import GetTaskBoardStatus, PublishTasks, PublishTask, UpdateTaskStatus, AssignTaskTo
-from .converters import TaskBoardConverter
-from .events import BaseTaskBoardEvent, TasksAddedEvent, TaskStatusUpdatedEvent
+from .tools import (
+    GetTaskPlanStatus,
+    CreateTasks,
+    CreateTask,
+    UpdateTaskStatus,
+    AssignTaskTo,
+    GetMyTasks,
+    CreateToDoList,
+    AddToDo,
+    GetToDoList,
+    UpdateToDoStatus as UpdateToDoStatusTool,
+)
+from .converters import TaskPlanConverter
+from .events import BaseTaskPlanEvent, TasksCreatedEvent, TaskStatusUpdatedEvent
+from .todo import ToDo, ToDoStatus
+from .todo_list import ToDoList
 
-# For convenience, we can alias InMemoryTaskBoard as the default TaskBoard.
-# This allows other parts of the code to import `TaskBoard` without needing
+# For convenience, we can alias InMemoryTaskPlan as the default TaskPlan.
+# This allows other parts of the code to import `TaskPlan` without needing
 # to know the specific implementation being used by default.
-TaskBoard = InMemoryTaskBoard
+TaskPlan = InMemoryTaskPlan
 
 __all__ = [
     "Task",
@@ -26,18 +39,28 @@ __all__ = [
     "TaskStatusReportSchema",
     "TaskStatusReportItemSchema",
     "FileDeliverableSchema",
-    "BaseTaskBoard",
+    "ToDoDefinitionSchema",
+    "ToDosDefinitionSchema",
+    "BaseTaskPlan",
     "TaskStatus",
-    "InMemoryTaskBoard",
-    "TaskBoard",  # Exposing the alias
+    "InMemoryTaskPlan",
+    "TaskPlan",  # Exposing the alias
     "FileDeliverable",
-    "GetTaskBoardStatus",
-    "PublishTasks",
-    "PublishTask",
+    "GetTaskPlanStatus",
+    "CreateTasks",
+    "CreateTask",
     "UpdateTaskStatus",
     "AssignTaskTo",
-    "TaskBoardConverter",
-    "BaseTaskBoardEvent",
-    "TasksAddedEvent",
+    "GetMyTasks",
+    "CreateToDoList",
+    "AddToDo",
+    "GetToDoList",
+    "UpdateToDoStatusTool",
+    "TaskPlanConverter",
+    "BaseTaskPlanEvent",
+    "TasksCreatedEvent",
     "TaskStatusUpdatedEvent",
+    "ToDo",
+    "ToDoStatus",
+    "ToDoList",
 ]

autobyteus/task_management/{base_task_board.py → base_task_plan.py}

@@ -1,19 +1,22 @@
-# file: autobyteus/autobyteus/task_management/base_task_board.py
+# file: autobyteus/autobyteus/task_management/base_task_plan.py
 """
-Defines the abstract interface for a TaskBoard and its related enums.
+Defines the abstract interface for a TaskPlan and its related enums.
 """
 import logging
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, TYPE_CHECKING
 
 from autobyteus.events.event_emitter import EventEmitter
 from .task import Task
 
+if TYPE_CHECKING:
+    from autobyteus.task_management.schemas import TaskDefinitionSchema
+
 logger = logging.getLogger(__name__)
 
 class TaskStatus(str, Enum):
-    """Enumerates the possible lifecycle states of a task on the TaskBoard."""
+    """Enumerates the possible lifecycle states of a task on the TaskPlan."""
     NOT_STARTED = "not_started"
     QUEUED = "queued"
     IN_PROGRESS = "in_progress"
@@ -25,12 +28,12 @@ class TaskStatus(str, Enum):
         """Returns True if the status is a final state."""
         return self in {TaskStatus.COMPLETED, TaskStatus.FAILED}
 
-class BaseTaskBoard(ABC, EventEmitter):
+class BaseTaskPlan(ABC, EventEmitter):
     """
-    Abstract base class for a TaskBoard.
+    Abstract base class for a TaskPlan.
 
     This class defines the contract for any component that manages the live state
-    of tasks for a team. It is a dynamic board, not a static plan.
+    of tasks for a team. It is a dynamic plan, not a static document.
     It inherits from EventEmitter to broadcast state changes.
     """
 
@@ -38,19 +41,19 @@ class BaseTaskBoard(ABC, EventEmitter):
         EventEmitter.__init__(self)
         self.team_id = team_id
         self.tasks: List[Task] = []
-        logger.debug(f"BaseTaskBoard initialized for team '{self.team_id}'.")
+        logger.debug(f"BaseTaskPlan initialized for team '{self.team_id}'.")
 
     @abstractmethod
-    def add_tasks(self, tasks: List[Task]) -> bool:
+    def add_tasks(self, task_definitions: List['TaskDefinitionSchema']) -> List[Task]:
         """
-        Adds a list of new tasks to the board. This is an additive-only operation.
+        Creates new tasks from definitions, adds them to the plan, and returns the created Task objects.
         """
         raise NotImplementedError
 
     @abstractmethod
-    def add_task(self, task: Task) -> bool:
+    def add_task(self, task_definition: 'TaskDefinitionSchema') -> Optional[Task]:
         """
-        Adds a single new task to the board.
+        Creates a single new task from a definition, adds it to the plan, and returns it.
         """
         raise NotImplementedError
 
@@ -64,7 +67,7 @@ class BaseTaskBoard(ABC, EventEmitter):
     @abstractmethod
     def get_status_overview(self) -> Dict[str, Any]:
         """
-        Returns a serializable dictionary of the board's current state.
+        Returns a serializable dictionary of the plan's current state.
         """
         raise NotImplementedError
 

autobyteus/task_management/converters/__init__.py

@@ -2,8 +2,8 @@
 """
 Exposes the public converters for the task management module.
 """
-from .task_board_converter import TaskBoardConverter
+from .task_plan_converter import TaskPlanConverter
 
 __all__ = [
-    "TaskBoardConverter",
+    "TaskPlanConverter",
 ]

autobyteus/task_management/converters/{task_board_converter.py → task_plan_converter.py}

@@ -1,4 +1,4 @@
-# file: autobyteus/autobyteus/task_management/converters/task_board_converter.py
+# file: autobyteus/autobyteus/task_management/converters/task_plan_converter.py
 """
 Contains converters for translating internal task management objects into
 LLM-friendly Pydantic schemas.
@@ -6,35 +6,35 @@ LLM-friendly Pydantic schemas.
 import logging
 from typing import Optional
 
-from autobyteus.task_management.base_task_board import BaseTaskBoard
+from autobyteus.task_management.base_task_plan import BaseTaskPlan
 from autobyteus.task_management.schemas import TaskStatusReportSchema, TaskStatusReportItemSchema
 
 logger = logging.getLogger(__name__)
 
-class TaskBoardConverter:
-    """A converter to transform TaskBoard state into LLM-friendly schemas."""
+class TaskPlanConverter:
+    """A converter to transform TaskPlan state into LLM-friendly schemas."""
 
     @staticmethod
-    def to_schema(task_board: BaseTaskBoard) -> Optional[TaskStatusReportSchema]:
+    def to_schema(task_plan: BaseTaskPlan) -> Optional[TaskStatusReportSchema]:
         """
-        Converts the current state of a TaskBoard into a TaskStatusReportSchema.
+        Converts the current state of a TaskPlan into a TaskStatusReportSchema.
 
         Args:
-            task_board: The task board instance to convert.
+            task_plan: The task plan instance to convert.
 
         Returns:
             A TaskStatusReportSchema object if there are tasks, otherwise None.
         """
-        if not task_board.tasks:
-            logger.debug(f"TaskBoard for team '{task_board.team_id}' has no tasks. Cannot generate report.")
+        if not task_plan.tasks:
+            logger.debug(f"TaskPlan for team '{task_plan.team_id}' has no tasks. Cannot generate report.")
             return None
 
-        internal_status = task_board.get_status_overview()
+        internal_status = task_plan.get_status_overview()
         
-        id_to_name_map = {task.task_id: task.task_name for task in task_board.tasks}
+        id_to_name_map = {task.task_id: task.task_name for task in task_plan.tasks}
         
         report_items = []
-        for task in task_board.tasks:
+        for task in task_plan.tasks:
             dep_names = [id_to_name_map.get(dep_id, str(dep_id)) for dep_id in task.dependencies]
             
             report_item = TaskStatusReportItemSchema(
@@ -51,5 +51,5 @@ class TaskBoardConverter:
             tasks=report_items
         )
         
-        logger.debug(f"Successfully converted TaskBoard state to TaskStatusReportSchema for team '{task_board.team_id}'.")
+        logger.debug(f"Successfully converted TaskPlan state to TaskStatusReportSchema for team '{task_plan.team_id}'.")
         return status_report

autobyteus/task_management/events.py

@@ -1,25 +1,25 @@
 # file: autobyteus/autobyteus/task_management/events.py
 """
-Defines the Pydantic models for events emitted by a TaskBoard.
+Defines the Pydantic models for events emitted by a TaskPlan.
 """
 from typing import List, Optional
 from pydantic import BaseModel
 
 from autobyteus.task_management.task import Task
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.base_task_plan import TaskStatus
 from .deliverable import FileDeliverable
 
-class BaseTaskBoardEvent(BaseModel):
-    """Base class for all task board events."""
+class BaseTaskPlanEvent(BaseModel):
+    """Base class for all task plan events."""
     team_id: str
 
-class TasksAddedEvent(BaseTaskBoardEvent):
+class TasksCreatedEvent(BaseTaskPlanEvent):
     """
-    Payload for when one or more tasks are added to the board.
+    Payload for when one or more tasks are created in the plan.
     """
     tasks: List[Task]
 
-class TaskStatusUpdatedEvent(BaseTaskBoardEvent):
+class TaskStatusUpdatedEvent(BaseTaskPlanEvent):
     """Payload for when a task's status is updated."""
     task_id: str
     new_status: TaskStatus