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

autobyteus/task_management/events.py

@@ -5,23 +5,23 @@ Defines the Pydantic models for events emitted by a TaskBoard.
 from typing import List, Optional
 from pydantic import BaseModel
 
-from autobyteus.task_management.task_plan import TaskPlan
+from autobyteus.task_management.task import Task
 from autobyteus.task_management.base_task_board import TaskStatus
 from .deliverable import FileDeliverable
 
 class BaseTaskBoardEvent(BaseModel):
     """Base class for all task board events."""
     team_id: str
-    plan_id: Optional[str]
 
-class TaskPlanPublishedEvent(BaseTaskBoardEvent):
-    """Payload for when a new task plan is published to the board."""
-    plan: TaskPlan
+class TasksAddedEvent(BaseTaskBoardEvent):
+    """
+    Payload for when one or more tasks are added to the board.
+    """
+    tasks: List[Task]
 
 class TaskStatusUpdatedEvent(BaseTaskBoardEvent):
     """Payload for when a task's status is updated."""
     task_id: str
     new_status: TaskStatus
     agent_name: str
-    # This field is added to ensure listeners get the full state, including deliverables.
     deliverables: Optional[List[FileDeliverable]] = None

autobyteus/task_management/in_memory_task_board.py

@@ -8,9 +8,9 @@ from typing import Optional, List, Dict, Any
 from enum import Enum
 
 from autobyteus.events.event_types import EventType
-from .task_plan import TaskPlan, Task
+from .task import Task
 from .base_task_board import BaseTaskBoard, TaskStatus
-from .events import TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from .events import TasksAddedEvent, TaskStatusUpdatedEvent
 
 logger = logging.getLogger(__name__)
 
@@ -23,37 +23,63 @@ class InMemoryTaskBoard(BaseTaskBoard):
         """
         Initializes the InMemoryTaskBoard.
         """
-        # BaseTaskBoard now handles EventEmitter initialization
         super().__init__(team_id=team_id)
-        self.current_plan: Optional[TaskPlan] = None
         self.task_statuses: Dict[str, TaskStatus] = {}
         self._task_map: Dict[str, Task] = {}
         logger.info(f"InMemoryTaskBoard initialized for team '{self.team_id}'.")
 
-    def load_task_plan(self, plan: TaskPlan) -> bool:
+    def add_tasks(self, tasks: List[Task]) -> bool:
         """
-        Loads a new plan onto the board, resetting its state and emitting an event.
+        Adds new tasks to the board. This is an additive-only operation.
         """
-        if not isinstance(plan, TaskPlan):
-            logger.error(f"Team '{self.team_id}': Failed to load task plan. Provided object is not a TaskPlan.")
-            return False
+        for task in tasks:
+            self.tasks.append(task)
+            self.task_statuses[task.task_id] = TaskStatus.NOT_STARTED
+            self._task_map[task.task_id] = task
 
-        self.current_plan = plan
-        self.task_statuses = {task.task_id: TaskStatus.NOT_STARTED for task in plan.tasks}
-        self._task_map = {task.task_id: task for task in plan.tasks}
-        
-        logger.info(f"Team '{self.team_id}': New TaskPlan '{plan.plan_id}' loaded. Emitting event.")
+        self._hydrate_all_dependencies()
+        logger.info(f"Team '{self.team_id}': Added {len(tasks)} new task(s) to the board. Emitting TasksAddedEvent.")
         
-        # Emit event
-        event_payload = TaskPlanPublishedEvent(
+        event_payload = TasksAddedEvent(
             team_id=self.team_id,
-            plan_id=plan.plan_id,
-            plan=plan
+            tasks=tasks,
         )
-        self.emit(EventType.TASK_BOARD_PLAN_PUBLISHED, payload=event_payload)
-        
+        self.emit(EventType.TASK_BOARD_TASKS_ADDED, payload=event_payload)
         return True
 
+    def add_task(self, task: Task) -> bool:
+        """
+        Adds a single new task to the board by wrapping it in a list and calling add_tasks.
+        """
+        return self.add_tasks([task])
+        
+    def _hydrate_all_dependencies(self):
+        """
+        Re-calculates all dependencies to ensure they are all valid task_ids.
+        This robustly handles dependencies that are already IDs and those that are names.
+        """
+        name_to_id_map = {task.task_name: task.task_id for task in self.tasks}
+        all_task_ids = set(self._task_map.keys())
+
+        for task in self.tasks:
+            if not task.dependencies:
+                continue
+
+            resolved_deps = []
+            for dep in task.dependencies:
+                # Case 1: The dependency is already a valid task_id on the board.
+                if dep in all_task_ids:
+                    resolved_deps.append(dep)
+                # Case 2: The dependency is a task_name that can be resolved.
+                elif dep in name_to_id_map:
+                    resolved_deps.append(name_to_id_map[dep])
+                # Case 3: The dependency is invalid.
+                else:
+                    logger.warning(f"Team '{self.team_id}': Dependency '{dep}' for task '{task.task_name}' could not be resolved to a known task ID or name.")
+            
+            task.dependencies = resolved_deps
+
+
     def update_task_status(self, task_id: str, status: TaskStatus, agent_name: str) -> bool:
         """
         Updates the status of a specific task and emits an event.
@@ -67,40 +93,27 @@ class InMemoryTaskBoard(BaseTaskBoard):
         log_msg = f"Team '{self.team_id}': Status of task '{task_id}' updated from '{old_status.value if isinstance(old_status, Enum) else old_status}' to '{status.value}' by agent '{agent_name}'."
         logger.info(log_msg)
         
-        # Find the task to get its deliverables for the event payload
         task = self._task_map.get(task_id)
         task_deliverables = task.file_deliverables if task else None
 
-        # Emit event
         event_payload = TaskStatusUpdatedEvent(
             team_id=self.team_id,
-            plan_id=self.current_plan.plan_id if self.current_plan else None,
             task_id=task_id,
             new_status=status,
             agent_name=agent_name,
             deliverables=task_deliverables
         )
         self.emit(EventType.TASK_BOARD_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.
+        The overall_goal is now fetched from the context via the converter.
         """
-        if not self.current_plan:
-            return {
-                "plan_id": None,
-                "overall_goal": None,
-                "task_statuses": {},
-                "tasks": []
-            }
-        
         return {
-            "plan_id": self.current_plan.plan_id,
-            "overall_goal": self.current_plan.overall_goal,
             "task_statuses": {task_id: status.value for task_id, status in self.task_statuses.items()},
-            "tasks": [task.model_dump() for task in self.current_plan.tasks]
+            "tasks": [task.model_dump() for task in self.tasks]
         }
 
     def get_next_runnable_tasks(self) -> List[Task]:
@@ -108,9 +121,6 @@ class InMemoryTaskBoard(BaseTaskBoard):
         Calculates which tasks can be executed now based on dependencies and statuses.
         """
         runnable_tasks: List[Task] = []
-        if not self.current_plan:
-            return runnable_tasks
-
         for task_id, status in self.task_statuses.items():
             if status == TaskStatus.NOT_STARTED:
                 task = self._task_map.get(task_id)

autobyteus/task_management/schemas/__init__.py

@@ -2,12 +2,12 @@
 """
 Exposes the public schema models for the task management module.
 """
-from .plan_definition import TaskPlanDefinitionSchema, TaskDefinitionSchema
+from .task_definition import TasksDefinitionSchema, TaskDefinitionSchema
 from .task_status_report import TaskStatusReportSchema, TaskStatusReportItemSchema
 from .deliverable_schema import FileDeliverableSchema
 
 __all__ = [
-    "TaskPlanDefinitionSchema",
+    "TasksDefinitionSchema",
     "TaskDefinitionSchema",
     "TaskStatusReportSchema",
     "TaskStatusReportItemSchema",

autobyteus/task_management/schemas/{plan_definition.py → task_definition.py}

@@ -1,5 +1,5 @@
 """
-Defines the Pydantic models for task plan "definitions".
+Defines the Pydantic models for task "definitions".
 
 These models represent the exact structure that an LLM is expected to generate.
 They serve as a blueprint or definition for a plan, which the system then uses
@@ -19,14 +19,13 @@ class TaskDefinitionSchema(BaseModel):
         description="A list of 'task_name' values for tasks that must be completed first."
     )
 
-class TaskPlanDefinitionSchema(BaseModel):
-    """A Pydantic model representing a full task plan as generated by an LLM."""
-    overall_goal: str = Field(..., description="The high-level objective of the entire plan.")
-    tasks: List[TaskDefinitionSchema] = Field(..., description="The list of tasks that make up this plan.")
+class TasksDefinitionSchema(BaseModel):
+    """A Pydantic model representing a list of tasks as generated by an LLM."""
+    tasks: List[TaskDefinitionSchema] = Field(..., description="The list of tasks to be published.")
 
     @field_validator('tasks')
     def task_names_must_be_unique(cls, tasks: List[TaskDefinitionSchema]) -> List[TaskDefinitionSchema]:
-        """Ensures that the LLM-provided task_names are unique within the plan."""
+        """Ensures that the LLM-provided task_names are unique within this list."""
         seen_names = set()
         for task in tasks:
             if task.task_name in seen_names:

autobyteus/task_management/schemas/task_status_report.py

@@ -23,5 +23,4 @@ class TaskStatusReportItemSchema(BaseModel):
 
 class TaskStatusReportSchema(BaseModel):
     """Represents a full task board status report in an LLM-friendly format."""
-    overall_goal: str = Field(..., description="The high-level objective of the entire plan.")
     tasks: List[TaskStatusReportItemSchema] = Field(..., description="The list of tasks and their current statuses.")

autobyteus/task_management/task.py

@@ -0,0 +1,60 @@
+# file: autobyteus/autobyteus/task_management/task.py
+"""
+Defines the data structures for a task.
+"""
+import logging
+import uuid
+from typing import List, Any
+from pydantic import BaseModel, Field, model_validator
+
+# To avoid circular import, we use a string forward reference.
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from autobyteus.task_management.deliverable import FileDeliverable
+
+logger = logging.getLogger(__name__)
+
+def generate_task_id():
+    """Generates a unique task identifier."""
+    return f"task_{uuid.uuid4().hex}"
+
+class Task(BaseModel):
+    """
+    Represents a single, discrete unit of work.
+    """
+    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.")
+    
+    task_id: str = Field(default_factory=generate_task_id, description="A unique system-generated identifier for this task within the plan.")
+    
+    assignee_name: str = Field(..., description="The unique name of the agent or sub-team responsible for executing this task (e.g., 'SoftwareEngineer', 'ResearchTeam').")
+    description: str = Field(..., description="A clear and concise description of what this task entails.")
+    
+    dependencies: List[str] = Field(
+        default_factory=list,
+        description="A list of 'task_name' values for tasks that must be completed before this one can be started."
+    )
+    
+    # This is the updated field as per user request.
+    file_deliverables: List["FileDeliverable"] = Field(
+        default_factory=list,
+        description="A list of file deliverables that were produced as a result of completing this task."
+    )
+
+    @model_validator(mode='before')
+    @classmethod
+    def handle_local_id_compatibility(cls, data: Any) -> Any:
+        """Handles backward compatibility for the 'local_id' field."""
+        if isinstance(data, dict) and 'local_id' in data:
+            data['task_name'] = data.pop('local_id')
+        # Compatibility for old artifact field
+        if isinstance(data, dict) and 'produced_artifact_ids' in data:
+            del data['produced_artifact_ids']
+        return data
+
+    def model_post_init(self, __context: Any) -> None:
+        """Called after the model is initialized and validated."""
+        logger.debug(f"Task created: Name='{self.task_name}', SystemID='{self.task_id}', Assignee='{self.assignee_name}'")
+
+# This is necessary for Pydantic v2 to correctly handle the recursive model
+from autobyteus.task_management.deliverable import FileDeliverable
+Task.model_rebuild()

autobyteus/task_management/tools/__init__.py

@@ -4,11 +4,13 @@ This package contains the class-based tools related to task and project
 management within an agent team.
 """
 from .get_task_board_status import GetTaskBoardStatus
-from .publish_task_plan import PublishTaskPlan
+from .publish_tasks import PublishTasks
+from .publish_task import PublishTask
 from .update_task_status import UpdateTaskStatus
 
 __all__ = [
     "GetTaskBoardStatus",
-    "PublishTaskPlan",
+    "PublishTasks",
+    "PublishTask",
     "UpdateTaskStatus",
 ]

autobyteus/task_management/tools/get_my_tasks.py

@@ -0,0 +1,80 @@
+# file: autobyteus/autobyteus/task_management/tools/get_my_tasks.py
+import json
+import logging
+from typing import TYPE_CHECKING, Optional, List
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.task_management.schemas import TaskDefinitionSchema
+from autobyteus.task_management.base_task_board import TaskStatus
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+class GetMyTasks(BaseTool):
+    """A tool for an agent to inspect its own assigned tasks from the central TaskBoard."""
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "GetMyTasks"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Retrieves the list of tasks currently assigned to you from the team's shared task board. "
+            "This is your personal to-do list. Use this to understand your current workload and decide what to do next."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[None]:
+        # This tool takes no arguments.
+        return None
+
+    async def _execute(self, context: 'AgentContext') -> str:
+        """
+        Executes the tool by fetching tasks from the team's TaskBoard and
+        filtering them for the current agent.
+        """
+        agent_name = context.config.name
+        logger.info(f"Agent '{agent_name}' is executing GetMyTasks.")
+
+        team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
+        if not team_context:
+            error_msg = "Error: Team context is not available. Cannot access the task board."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+
+        task_board = getattr(team_context.state, 'task_board', None)
+        if not task_board:
+            error_msg = "Error: Task board has not been initialized for this team."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+        
+        # Filter the tasks from the central board for this agent.
+        # An agent should only see tasks that are specifically for them and are ready to be worked on.
+        my_tasks = [
+            task for task in task_board.tasks 
+            if task.assignee_name == agent_name and task_board.task_statuses.get(task.task_id) == TaskStatus.QUEUED
+        ]
+
+        if not my_tasks:
+            return "Your personal task queue is empty. You have no new tasks assigned and ready to be started."
+
+        try:
+            # Convert the internal Task objects back to the LLM-friendly schema.
+            tasks_for_llm = [
+                TaskDefinitionSchema.model_validate(task).model_dump() for task in my_tasks
+            ]
+            
+            logger.info(f"Agent '{agent_name}' retrieved {len(tasks_for_llm)} tasks from the central task board.")
+            return json.dumps(tasks_for_llm, indent=2)
+            
+        except Exception as e:
+            error_msg = f"An unexpected error occurred while formatting your tasks: {e}"
+            logger.error(f"Agent '{agent_name}': {error_msg}", exc_info=True)
+            return f"Error: {error_msg}"

autobyteus/task_management/tools/get_task_board_status.py

@@ -25,8 +25,8 @@ class GetTaskBoardStatus(BaseTool):
     @classmethod
     def get_description(cls) -> str:
         return (
-            "Retrieves the current status of the team's task board, including the overall goal "
-            "and the status of all individual tasks. Returns the status as a structured, LLM-friendly JSON string."
+            "Retrieves the current status of the team's task board, including the status of all individual tasks. "
+            "Returns the status as a structured, LLM-friendly JSON string."
         )
 
     @classmethod
@@ -57,7 +57,7 @@ class GetTaskBoardStatus(BaseTool):
             status_report_schema = TaskBoardConverter.to_schema(task_board)
             
             if not status_report_schema:
-                return "The task board is currently empty. No plan has been published."
+                return "The task board is currently empty. No tasks have been published."
             
             logger.info(f"Agent '{context.agent_id}' successfully retrieved and formatted task board status.")
             return status_report_schema.model_dump_json(indent=2)

autobyteus/task_management/tools/publish_task.py

@@ -0,0 +1,77 @@
+# file: autobyteus/autobyteus/task_management/tools/publish_task.py
+import logging
+from typing import TYPE_CHECKING, Optional, Dict, Any
+
+from pydantic import ValidationError
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.utils.parameter_schema import ParameterSchema
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
+from autobyteus.task_management.schemas import TaskDefinitionSchema
+from autobyteus.task_management.task import Task
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+class PublishTask(BaseTool):
+    """A tool for any agent to add a single new task to the team's task board."""
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "PublishTask"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Adds a single new task to the team's shared task board. This is an additive action "
+            "and does not affect existing tasks. Use this to create follow-up tasks or delegate new work."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        # The schema for this tool is effectively the schema of a single task definition.
+        return pydantic_to_parameter_schema(TaskDefinitionSchema)
+
+    async def _execute(self, context: 'AgentContext', **kwargs: Any) -> str:
+        """
+        Executes the tool by validating the task object and adding it to the board.
+        """
+        agent_name = context.config.name
+        task_name = kwargs.get("task_name", "unnamed task")
+        logger.info(f"Agent '{agent_name}' is executing PublishTask for task '{task_name}'.")
+
+        team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
+        if not team_context:
+            error_msg = "Error: Team context is not available. Cannot access the task board."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+
+        task_board = getattr(team_context.state, 'task_board', None)
+        if not task_board:
+            error_msg = "Error: Task board has not been initialized for this team."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+            
+        try:
+            task_def_schema = TaskDefinitionSchema(**kwargs)
+            new_task = Task(**task_def_schema.model_dump())
+        except (ValidationError, ValueError) as e:
+            error_msg = f"Invalid task definition provided: {e}"
+            logger.warning(f"Agent '{agent_name}' provided an invalid definition for PublishTask: {error_msg}")
+            return f"Error: {error_msg}"
+
+        if task_board.add_task(new_task):
+            success_msg = f"Successfully published new task '{new_task.task_name}' to the task board."
+            logger.info(f"Agent '{agent_name}': {success_msg}")
+            return success_msg
+        else:
+            # This path is less likely now but kept for robustness.
+            error_msg = "Failed to publish task to the board for an unknown reason."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return f"Error: {error_msg}"

autobyteus/task_management/tools/publish_tasks.py

@@ -0,0 +1,74 @@
+# file: autobyteus/autobyteus/task_management/tools/publish_tasks.py
+import logging
+from typing import TYPE_CHECKING, Optional, Dict, Any
+
+from pydantic import ValidationError
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.utils.parameter_schema import ParameterSchema
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
+from autobyteus.task_management.schemas import TasksDefinitionSchema
+from autobyteus.task_management.task import Task
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+class PublishTasks(BaseTool):
+    """
+    A tool to publish multiple tasks to the task board. This is an additive-only operation.
+    """
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "PublishTasks"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Adds a list of new tasks to the team's shared task board. This action is additive and "
+            "does not affect existing tasks or the team's overall goal."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        return pydantic_to_parameter_schema(TasksDefinitionSchema)
+
+    async def _execute(self, context: 'AgentContext', **kwargs: Any) -> str:
+        agent_name = context.config.name
+        logger.info(f"Agent '{agent_name}' is executing PublishTasks.")
+        
+        team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
+        if not team_context:
+            error_msg = "Error: Team context is not available. Cannot access the task board."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+            
+        task_board = getattr(team_context.state, 'task_board', None)
+        if not task_board:
+            error_msg = "Error: Task board has not been initialized for this team."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+            
+        try:
+            tasks_def_schema = TasksDefinitionSchema(**kwargs)
+            final_tasks = [Task(**task_def.model_dump()) for task_def in tasks_def_schema.tasks]
+        except (ValidationError, ValueError) as e:
+            error_msg = f"Invalid task definitions provided: {e}"
+            logger.warning(f"Agent '{agent_name}' provided an invalid definition for PublishTasks: {error_msg}")
+            return f"Error: {error_msg}"
+
+        if task_board.add_tasks(tasks=final_tasks):
+            success_msg = f"Successfully published {len(final_tasks)} new task(s) to the task board."
+            logger.info(f"Agent '{agent_name}': {success_msg}")
+            return success_msg
+        else:
+            # This path is less likely now but kept for robustness.
+            error_msg = "Failed to publish tasks to the board for an unknown reason."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return f"Error: {error_msg}"

autobyteus/task_management/tools/update_task_status.py

@@ -5,7 +5,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.utils.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
@@ -77,12 +77,12 @@ class UpdateTaskStatus(BaseTool):
             logger.error(f"Agent '{agent_name}': {error_msg}")
             return error_msg
         
-        if not task_board.current_plan:
-            error_msg = "Error: No task plan is currently loaded on the task board."
-            logger.warning(f"Agent '{agent_name}' tried to update task status, but no plan is loaded.")
+        if not task_board.tasks:
+            error_msg = "Error: No tasks are currently loaded on the task board."
+            logger.warning(f"Agent '{agent_name}' tried to update task status, but the board is empty.")
             return error_msg
 
-        target_task = next((t for t in task_board.current_plan.tasks if t.task_name == task_name), None)
+        target_task = next((t for t in task_board.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."

autobyteus/tools/__init__.py

@@ -8,7 +8,7 @@ It also contains implementations of various standard tools.
 # Core components for defining tools
 from .base_tool import BaseTool
 from .functional_tool import tool # The @tool decorator
-from .parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from .tool_config import ToolConfig # Configuration data object, primarily for class-based tools
 from .tool_origin import ToolOrigin
 from .tool_category import ToolCategory
@@ -26,6 +26,7 @@ from .google_search import GoogleSearch
 from .image_downloader import ImageDownloader
 from .timer import Timer
 from .multimedia.image_tools import GenerateImageTool, EditImageTool
+from .multimedia.media_reader_tool import ReadMediaFile
 
 # Standalone Browser tools
 from .browser.standalone.navigate_to import NavigateTo as StandaloneNavigateTo # Alias to avoid name clash
@@ -64,6 +65,7 @@ __all__ = [
     "Timer",
     "GenerateImageTool",
     "EditImageTool",
+    "ReadMediaFile",
 
     # Re-exported Standalone Browser tools
     "StandaloneNavigateTo",

autobyteus/tools/base_tool.py

@@ -5,14 +5,14 @@ from abc import ABC, abstractmethod
 from typing import Optional, Any, TYPE_CHECKING, List as TypingList, Dict, Union
 
 from autobyteus.events.event_emitter import EventEmitter
-from autobyteus.tools.parameter_schema import ParameterType
+from autobyteus.utils.parameter_schema import ParameterType
 
 from .tool_meta import ToolMeta
 from .tool_state import ToolState
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition
+    from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition
     from autobyteus.tools.tool_config import ToolConfig
     from .tool_state import ToolState
     from autobyteus.tools.registry import ToolDefinition
@@ -90,8 +90,8 @@ class BaseTool(ABC, EventEmitter, metaclass=ToolMeta):
             if item_schema_dict and isinstance(item_schema_dict, dict) and item_schema_dict.get("type") == "object":
                 # Create a temporary ParameterSchema for the item type to enable recursion.
                 # This is a simplified conversion for coercion purposes only.
-                from .parameter_schema import ParameterSchema as TempSchema
-                from .parameter_schema import ParameterDefinition as TempDef
+                from autobyteus.utils.parameter_schema import ParameterSchema as TempSchema
+                from autobyteus.utils.parameter_schema import ParameterDefinition as TempDef
 
                 item_param_schema = TempSchema()
                 props = item_schema_dict.get("properties", {})

autobyteus/tools/browser/session_aware/browser_session_aware_navigate_to.py

@@ -6,7 +6,7 @@ from urllib.parse import urlparse
 from typing import Optional, TYPE_CHECKING, Any
 import logging
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext

autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py

@@ -7,7 +7,7 @@ import logging
 from autobyteus.tools.browser.session_aware.browser_session_aware_tool import BrowserSessionAwareTool
 from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
 from autobyteus.tools.browser.session_aware.web_element_action import WebElementAction
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_config import ToolConfig
 from autobyteus.tools.tool_category import ToolCategory