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

autobyteus/multimedia/audio/api/openai_audio_client.py

@@ -0,0 +1,112 @@
+import asyncio
+import logging
+import os
+import uuid
+from pathlib import Path
+from typing import Optional, Dict, Any, TYPE_CHECKING
+
+from openai import OpenAI
+
+from autobyteus.multimedia.audio.base_audio_client import BaseAudioClient
+from autobyteus.multimedia.utils.response_types import SpeechGenerationResponse
+
+if TYPE_CHECKING:
+    from autobyteus.multimedia.audio.audio_model import AudioModel
+    from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+
+logger = logging.getLogger(__name__)
+
+_AUDIO_TEMP_DIR = Path("/tmp/autobyteus_audio")
+
+
+def _save_audio_bytes(audio_bytes: bytes, file_extension: Optional[str]) -> str:
+    """Saves audio bytes to disk with a random file name."""
+    _AUDIO_TEMP_DIR.mkdir(parents=True, exist_ok=True)
+    suffix = (file_extension or "mp3").lstrip(".")
+    file_path = _AUDIO_TEMP_DIR / f"{uuid.uuid4()}.{suffix}"
+    file_path.write_bytes(audio_bytes)
+    logger.info(f"Successfully saved generated audio to {file_path}")
+    return str(file_path)
+
+
+class OpenAIAudioClient(BaseAudioClient):
+    """
+    An audio client that uses OpenAI's Text-to-Speech (Speech) API.
+
+    **Setup Requirements:**
+    1. Set the `OPENAI_API_KEY` environment variable with your OpenAI API key.
+    """
+
+    def __init__(self, model: "AudioModel", config: "MultimediaConfig"):
+        super().__init__(model, config)
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            logger.error("OPENAI_API_KEY environment variable is not set.")
+            raise ValueError("OPENAI_API_KEY environment variable is not set.")
+
+        try:
+            self.client = OpenAI(api_key=api_key, base_url="https://api.openai.com/v1")
+            logger.info(f"OpenAIAudioClient initialized for model '{self.model.name}'.")
+        except Exception as exc:
+            logger.error(f"Failed to configure OpenAI client: {exc}")
+            raise RuntimeError(f"Failed to configure OpenAI client: {exc}") from exc
+
+    async def generate_speech(
+        self,
+        prompt: str,
+        generation_config: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> SpeechGenerationResponse:
+        """
+        Generates speech using OpenAI's Speech endpoint and returns a local file path.
+        """
+        try:
+            final_config = self.config.to_dict().copy()
+            if generation_config:
+                final_config.update(generation_config)
+
+            voice = final_config.get("voice", "alloy")
+            response_format = (
+                final_config.get("response_format")
+                or final_config.get("format")
+                or "mp3"
+            )
+            instructions = final_config.get("instructions")
+
+            logger.info(
+                "Generating speech with OpenAI TTS model '%s' using voice '%s' and format '%s'.",
+                self.model.value,
+                voice,
+                response_format,
+            )
+
+            request_kwargs = {
+                "model": self.model.value,
+                "voice": voice,
+                "input": prompt,
+            }
+
+            if instructions:
+                request_kwargs["instructions"] = instructions
+
+            if response_format:
+                request_kwargs["response_format"] = response_format
+
+            response = await asyncio.to_thread(
+                self.client.audio.speech.create,
+                **request_kwargs,
+            )
+
+            audio_bytes = getattr(response, "content", None)
+            if not audio_bytes:
+                raise ValueError("OpenAI Speech API returned an empty response.")
+
+            audio_path = _save_audio_bytes(audio_bytes, response_format)
+            return SpeechGenerationResponse(audio_urls=[audio_path])
+
+        except Exception as exc:
+            logger.error("Error during OpenAI speech generation: %s", exc)
+            raise ValueError(f"OpenAI speech generation failed: {exc}") from exc
+
+    async def cleanup(self):
+        logger.debug("OpenAIAudioClient cleanup called.")

autobyteus/multimedia/audio/audio_client_factory.py

@@ -5,6 +5,7 @@ from autobyteus.multimedia.audio.base_audio_client import BaseAudioClient
 from autobyteus.multimedia.audio.audio_model import AudioModel
 from autobyteus.multimedia.providers import MultimediaProvider
 from autobyteus.multimedia.audio.api.gemini_audio_client import GeminiAudioClient
+from autobyteus.multimedia.audio.api.openai_audio_client import OpenAIAudioClient
 from autobyteus.multimedia.audio.autobyteus_audio_provider import AutobyteusAudioModelProvider
 from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
 from autobyteus.utils.singleton import SingletonMeta
@@ -20,6 +21,11 @@ GEMINI_TTS_VOICES = [
     "Vindemiatrix", "Sadachbia", "Sadaltager", "Sulafat"
 ]
 
+OPENAI_TTS_VOICES = [
+    "alloy", "ash", "ballad", "coral", "echo", "fable", "onyx",
+    "nova", "sage", "shimmer", "verse"
+]
+
 class AudioClientFactory(metaclass=SingletonMeta):
     """
     A factory for creating instances of audio clients based on registered AudioModels.
@@ -101,7 +107,38 @@ class AudioClientFactory(metaclass=SingletonMeta):
             parameter_schema=gemini_tts_schema
         )
 
+        openai_tts_schema = ParameterSchema(parameters=[
+            ParameterDefinition(
+                name="voice",
+                param_type=ParameterType.ENUM,
+                default_value="alloy",
+                enum_values=OPENAI_TTS_VOICES,
+                description="The OpenAI TTS voice to use for generation."
+            ),
+            ParameterDefinition(
+                name="format",
+                param_type=ParameterType.ENUM,
+                default_value="mp3",
+                enum_values=["mp3", "wav"],
+                description="The audio format to generate."
+            ),
+            ParameterDefinition(
+                name="instructions",
+                param_type=ParameterType.STRING,
+                description="Optional delivery instructions (tone, pacing, accent, etc.)."
+            )
+        ])
+
+        openai_tts_model = AudioModel(
+            name="gpt-4o-mini-tts",
+            value="gpt-4o-mini-tts",
+            provider=MultimediaProvider.OPENAI,
+            client_class=OpenAIAudioClient,
+            parameter_schema=openai_tts_schema
+        )
+
         models_to_register = [
+            openai_tts_model,
             gemini_tts_model,
         ]
         

autobyteus/multimedia/audio/autobyteus_audio_provider.py

@@ -3,7 +3,7 @@ from typing import List
 import os
 from urllib.parse import urlparse
 
-from autobyteus_llm_client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 from autobyteus.multimedia.audio.api.autobyteus_audio_client import AutobyteusAudioClient
 from autobyteus.multimedia.audio.audio_model import AudioModel
 from autobyteus.multimedia.providers import MultimediaProvider

autobyteus/multimedia/image/api/autobyteus_image_client.py

@@ -1,6 +1,6 @@
 import logging
 from typing import Optional, List, Dict, Any, TYPE_CHECKING
-from autobyteus_llm_client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 from autobyteus.multimedia.image.base_image_client import BaseImageClient
 from autobyteus.multimedia.utils.response_types import ImageGenerationResponse
 

autobyteus/multimedia/image/autobyteus_image_provider.py

@@ -3,7 +3,7 @@ from typing import Dict, Any, List
 import os
 from urllib.parse import urlparse
 
-from autobyteus_llm_client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 from autobyteus.multimedia.image.api.autobyteus_image_client import AutobyteusImageClient
 from autobyteus.multimedia.image.image_model import ImageModel
 from autobyteus.multimedia.providers import MultimediaProvider

autobyteus/multimedia/image/image_client_factory.py

@@ -49,7 +49,7 @@ class ImageClientFactory(metaclass=SingletonMeta):
 
         gpt_image_1_model = ImageModel(
             name="gpt-image-1",
-            value="dall-e-3",
+            value="gpt-image-1",
             provider=MultimediaProvider.OPENAI,
             client_class=OpenAIImageClient,
             parameter_schema=gpt_image_1_schema

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
-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,17 +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",
-    "TaskBoardConverter",
-    "BaseTaskBoardEvent",
-    "TasksAddedEvent",
+    "AssignTaskTo",
+    "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

autobyteus/task_management/{in_memory_task_board.py → in_memory_task_plan.py}

@@ -1,6 +1,6 @@
-# file: autobyteus/autobyteus/task_management/in_memory_task_board.py
+# file: autobyteus/autobyteus/task_management/in_memory_task_plan.py
 """
-An in-memory implementation of the BaseTaskBoard.
+An in-memory implementation of the BaseTaskPlan.
 It tracks task statuses in a simple dictionary and emits events on state changes.
 """
 import logging
@@ -8,50 +8,62 @@ from typing import Optional, List, Dict, Any
 from enum import Enum
 
 from autobyteus.events.event_types import EventType
+from .schemas import TaskDefinitionSchema
 from .task import Task
-from .base_task_board import BaseTaskBoard, TaskStatus
-from .events import TasksAddedEvent, TaskStatusUpdatedEvent
+from .base_task_plan import BaseTaskPlan, TaskStatus
+from .events import TasksCreatedEvent, TaskStatusUpdatedEvent
 
 logger = logging.getLogger(__name__)
 
-class InMemoryTaskBoard(BaseTaskBoard):
+class InMemoryTaskPlan(BaseTaskPlan):
     """
-    An in-memory, dictionary-based implementation of the TaskBoard that emits
+    An in-memory, dictionary-based implementation of the TaskPlan that emits
     events on state changes.
     """
     def __init__(self, team_id: str):
         """
-        Initializes the InMemoryTaskBoard.
+        Initializes the InMemoryTaskPlan.
         """
         super().__init__(team_id=team_id)
         self.task_statuses: Dict[str, TaskStatus] = {}
         self._task_map: Dict[str, Task] = {}
-        logger.info(f"InMemoryTaskBoard initialized for team '{self.team_id}'.")
+        self._id_counter: int = 0
+        logger.info(f"InMemoryTaskPlan initialized for team '{self.team_id}'.")
+    
+    def _generate_next_id(self) -> str:
+        self._id_counter += 1
+        return f"task_{self._id_counter:04d}"
 
-    def add_tasks(self, tasks: List[Task]) -> bool:
+    def add_tasks(self, task_definitions: List[TaskDefinitionSchema]) -> List[Task]:
         """
-        Adds 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 tasks.
         """
-        for task in tasks:
+        new_tasks: List[Task] = []
+        for task_def in task_definitions:
+            new_id = self._generate_next_id()
+            task = Task(task_id=new_id, **task_def.model_dump())
+            
             self.tasks.append(task)
             self.task_statuses[task.task_id] = TaskStatus.NOT_STARTED
             self._task_map[task.task_id] = task
+            new_tasks.append(task)
 
         self._hydrate_all_dependencies()
-        logger.info(f"Team '{self.team_id}': Added {len(tasks)} new task(s) to the board. Emitting TasksAddedEvent.")
+        logger.info(f"Team '{self.team_id}': Added {len(new_tasks)} new task(s) to the plan. Emitting TasksCreatedEvent.")
         
-        event_payload = TasksAddedEvent(
+        event_payload = TasksCreatedEvent(
             team_id=self.team_id,
-            tasks=tasks,
+            tasks=new_tasks,
         )
-        self.emit(EventType.TASK_BOARD_TASKS_ADDED, payload=event_payload)
-        return True
+        self.emit(EventType.TASK_PLAN_TASKS_CREATED, payload=event_payload)
+        return new_tasks
 
-    def add_task(self, task: Task) -> bool:
+    def add_task(self, task_definition: TaskDefinitionSchema) -> Optional[Task]:
         """
-        Adds a single new task to the board by wrapping it in a list and calling add_tasks.
+        Creates a single new task from a definition, adds it to the plan, and returns it.
         """
-        return self.add_tasks([task])
+        created_tasks = self.add_tasks([task_definition])
+        return created_tasks[0] if created_tasks else None
         
     def _hydrate_all_dependencies(self):
         """
@@ -67,7 +79,7 @@ class InMemoryTaskBoard(BaseTaskBoard):
 
             resolved_deps = []
             for dep in task.dependencies:
-                # Case 1: The dependency is already a valid task_id on the board.
+                # Case 1: The dependency is already a valid task_id on the plan.
                 if dep in all_task_ids:
                     resolved_deps.append(dep)
                 # Case 2: The dependency is a task_name that can be resolved.
@@ -103,12 +115,12 @@ class InMemoryTaskBoard(BaseTaskBoard):
             agent_name=agent_name,
             deliverables=task_deliverables
         )
-        self.emit(EventType.TASK_BOARD_STATUS_UPDATED, payload=event_payload)
+        self.emit(EventType.TASK_PLAN_STATUS_UPDATED, payload=event_payload)
         return True
 
     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.
         The overall_goal is now fetched from the context via the converter.
         """
         return {

autobyteus/task_management/schemas/__init__.py

@@ -5,6 +5,7 @@ Exposes the public schema models for the task management module.
 from .task_definition import TasksDefinitionSchema, TaskDefinitionSchema
 from .task_status_report import TaskStatusReportSchema, TaskStatusReportItemSchema
 from .deliverable_schema import FileDeliverableSchema
+from .todo_definition import ToDoDefinitionSchema, ToDosDefinitionSchema
 
 __all__ = [
     "TasksDefinitionSchema",
@@ -12,4 +13,6 @@ __all__ = [
     "TaskStatusReportSchema",
     "TaskStatusReportItemSchema",
     "FileDeliverableSchema",
+    "ToDoDefinitionSchema",
+    "ToDosDefinitionSchema",
 ]

autobyteus/task_management/schemas/task_definition.py

@@ -13,7 +13,7 @@ class TaskDefinitionSchema(BaseModel):
     """A Pydantic model representing a single task as defined by an LLM."""
     task_name: str = Field(..., description="A short, unique, descriptive name for this task within the plan (e.g., 'setup_project', 'implement_scraper'). Used for defining dependencies.")
     assignee_name: str = Field(..., description="The name of the agent or sub-team assigned to this task.")
-    description: str = Field(..., description="A detailed description of the task.")
+    description: str = Field(..., description="A clear, detailed, and unambiguous description of what this task entails. Provide all necessary context for the assignee to complete the work. For example, if the task involves a file, specify its full, absolute path. If it requires creating a file, specify where it should be saved. Mention any specific requirements or expected outputs.")
     dependencies: List[str] = Field(
         default_factory=list,
         description="A list of 'task_name' values for tasks that must be completed first."

autobyteus/task_management/schemas/task_status_report.py

@@ -9,18 +9,18 @@ but includes dynamic state information (like task status).
 from typing import List, Optional
 from pydantic import BaseModel, Field
 
-from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.base_task_plan import TaskStatus
 from autobyteus.task_management.deliverable import FileDeliverable
 
 class TaskStatusReportItemSchema(BaseModel):
     """Represents the status of a single task in an LLM-friendly format."""
     task_name: str = Field(..., description="The unique, descriptive name for this task.")
     assignee_name: str = Field(..., description="The name of the agent or sub-team assigned to this task.")
-    description: str = Field(..., description="A detailed description of the task.")
+    description: str = Field(..., description="A clear, detailed, and unambiguous description of what this task entails. Provide all necessary context for the assignee to complete the work. For example, if the task involves a file, specify its full, absolute path. If it requires creating a file, specify where it should be saved. Mention any specific requirements or expected outputs.")
     dependencies: List[str] = Field(..., description="A list of 'task_name' values for tasks that must be completed first.")
     status: TaskStatus = Field(..., description="The current status of this task.")
     file_deliverables: List[FileDeliverable] = Field(default_factory=list, description="A list of files submitted as deliverables for this task.")
 
 class TaskStatusReportSchema(BaseModel):
-    """Represents a full task board status report in an LLM-friendly format."""
+    """Represents a full task plan status report in an LLM-friendly format."""
     tasks: List[TaskStatusReportItemSchema] = Field(..., description="The list of tasks and their current statuses.")

autobyteus/task_management/schemas/todo_definition.py

@@ -0,0 +1,15 @@
+# file: autobyteus/autobyteus/task_management/schemas/todo_definition.py
+"""
+Defines the Pydantic models for ToDo "definitions".
+These models represent the structure an LLM is expected to generate for personal planning.
+"""
+from typing import List
+from pydantic import BaseModel, Field
+
+class ToDoDefinitionSchema(BaseModel):
+    """A Pydantic model representing a single to-do item as defined by an LLM."""
+    description: str = Field(..., description="A clear, detailed description of what this to-do item or step entails.")
+
+class ToDosDefinitionSchema(BaseModel):
+    """A Pydantic model representing a list of to-do items as generated by an LLM."""
+    todos: List[ToDoDefinitionSchema] = Field(..., description="The list of to-do items to create.")