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

autobyteus/multimedia/image/api/gemini_image_client.py

@@ -1,16 +1,14 @@
-import asyncio
-import base64
 import logging
-import mimetypes
+import base64
 import os
 from typing import Optional, List, Dict, Any, TYPE_CHECKING
-
-# ✅ Legacy Gemini SDK (as requested)
-import google.generativeai as genai
+from google import genai
+from PIL import Image
 import requests
 
 from autobyteus.multimedia.image.base_image_client import BaseImageClient
 from autobyteus.multimedia.utils.response_types import ImageGenerationResponse
+from autobyteus.multimedia.utils.api_utils import load_image_from_url
 
 if TYPE_CHECKING:
     from autobyteus.multimedia.image.image_model import ImageModel
@@ -18,157 +16,86 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-
-def _data_uri(mime_type: str, raw: bytes) -> str:
-    """Convert raw bytes to a data URI."""
-    b64 = base64.b64encode(raw).decode("utf-8")
-    return f"data:{mime_type};base64,{b64}"
-
-
-def _guess_mime_from_url(url: str) -> str:
-    """Best-effort MIME guess from URL; fall back to image/jpeg."""
-    mime, _ = mimetypes.guess_type(url)
-    return mime or "image/jpeg"
-
-
-def _fetch_image_part(url: str) -> Dict[str, Any]:
-    """
-    Download an image and return an inline-data Part compatible with the legacy SDK:
-    { "mime_type": "...", "data": <bytes> }
-    """
-    resp = requests.get(url, timeout=30)
-    resp.raise_for_status()
-    mime = resp.headers.get("Content-Type") or _guess_mime_from_url(url)
-    return {"mime_type": mime.split(";")[0], "data": resp.content}
-
-
-def _extract_inline_images(response) -> List[Dict[str, bytes]]:
-    """
-    Collect inline image parts from the legacy SDK response.
-    Returns list of { "mime_type": str, "data": bytes }.
-    """
-    images = []
-    try:
-        candidates = getattr(response, "candidates", []) or []
-        if not candidates:
-            return images
-
-        parts = candidates[0].content.parts if candidates[0].content else []
-        for p in parts:
-            inline = getattr(p, "inline_data", None)
-            if not inline:
-                continue
-            mime = getattr(inline, "mime_type", "") or ""
-            if not mime.startswith("image/"):
-                continue
-
-            data = getattr(inline, "data", None)
-            if isinstance(data, bytes):
-                images.append({"mime_type": mime, "data": data})
-            elif isinstance(data, str):
-                # Some bindings expose base64 text
-                images.append({"mime_type": mime, "data": base64.b64decode(data)})
-    except Exception as e:
-        logger.error("Failed to parse inline image(s): %s", e)
-        raise
-    return images
-
-
 class GeminiImageClient(BaseImageClient):
     """
-    Image generation client using Google's legacy SDK (`google.generativeai`).
+    An image client that uses Google's Gemini models for image generation tasks.
 
-    Notes:
-      - We configure `response_mime_type='image/png'` to request image output.
-      - You can guide generation with input images by passing URLs; they’re added as inline image Parts.
-      - This runs the blocking SDK call in a worker thread to keep your async API.
+    **Setup Requirements:**
+    1.  **Authentication:** Set the `GEMINI_API_KEY` environment variable with your API key.
     """
 
     def __init__(self, model: "ImageModel", config: "MultimediaConfig"):
         super().__init__(model, config)
-
         api_key = os.getenv("GEMINI_API_KEY")
         if not api_key:
             raise ValueError("Please set the GEMINI_API_KEY environment variable.")
-
+        
         try:
-            genai.configure(api_key=api_key)
-            # `self.model.value` should be an image-capable model.
-            # Examples (subject to availability): "imagen-3.0-generate", "imagen-3.0-fast",
-            # or Gemini image-preview models that support image output.
-            model_name = self.model.value or "imagen-3.0-generate"
-            self._model = genai.GenerativeModel(model_name)
-            logger.info("GeminiImageClient (legacy SDK) initialized for model '%s'.", model_name)
+            self.client = genai.Client()
+            self.async_client = self.client.aio
+            logger.info(f"GeminiImageClient initialized for model '{self.model.name}'.")
         except Exception as e:
-            logger.error("Failed to initialize Gemini image client: %s", e)
-            raise RuntimeError(f"Failed to initialize Gemini image client: {e}")
+            logger.error(f"Failed to initialize Gemini client for images: {e}")
+            raise RuntimeError(f"Failed to initialize Gemini client for images: {e}")
 
     async def generate_image(
         self,
         prompt: str,
         input_image_urls: Optional[List[str]] = None,
-        generation_config: Optional[Dict[str, Any]] = None
+        generation_config: Optional[Dict[str, Any]] = None,
+        **kwargs
     ) -> ImageGenerationResponse:
         """
-        Generate an image (text→image or image-guided).
-
-        `generation_config` supports common fields; we always ensure
-        `response_mime_type='image/png'` so the SDK returns inline image bytes.
+        Generates an image using a Google Gemini model. Can be text-to-image or image-to-image.
         """
         try:
-            logger.info("Generating image with model '%s'...", self._model.model_name)
-
-            # Build contents array: [text, (optional) image parts...]
-            contents: List[Any] = [prompt]
+            logger.info(f"Generating image with Google Gemini model '{self.model.value}'...")
 
+            content = [prompt]
             if input_image_urls:
-                logger.info("Loading %d input image(s) for guidance...", len(input_image_urls))
+                logger.info(f"Loading {len(input_image_urls)} input image(s) for generation.")
                 for url in input_image_urls:
                     try:
-                        contents.append(_fetch_image_part(url))
+                        content.append(load_image_from_url(url))
                     except Exception as e:
-                        logger.error("Skipping image '%s' due to error: %s", url, e)
-
-            # Merge config and force image output
-            gen_cfg: Dict[str, Any] = (generation_config or {}).copy()
-            gen_cfg["response_mime_type"] = gen_cfg.get("response_mime_type", "image/png")
-
-            # Call the (sync) SDK in a worker thread
-            response = await asyncio.to_thread(
-                self._model.generate_content,
-                contents,
-                generation_config=gen_cfg,
-            )
-
-            # Handle safety blocks if present
-            feedback = getattr(response, "prompt_feedback", None)
-            block_reason = getattr(feedback, "block_reason", None)
-            if block_reason:
-                reason = getattr(block_reason, "name", str(block_reason))
-                logger.error("Image generation blocked by safety settings: %s", reason)
-                raise ValueError(f"Image generation failed due to safety settings: {reason}")
-
-            images = _extract_inline_images(response)
-            if not images:
-                logger.warning("No image parts returned for prompt: '%.100s...'", prompt)
-                raise ValueError("Gemini API did not return any images.")
-
-            image_urls = [_data_uri(img["mime_type"], img["data"]) for img in images]
-            logger.info("Successfully generated %d image(s).", len(image_urls))
+                        logger.error(f"Skipping image at '{url}' due to loading error: {e}")
+
+            # Note: The google-genai library uses the synchronous client for the `.generate_content` method on a model
+            # even in an async context, as there isn't a direct async equivalent exposed for this specific call on the model object.
+            # We use the top-level async client for other potential future calls if the library API changes.
+            model_instance = self.client.get_generative_model(model_name=f"models/{self.model.value}")
+            response = await model_instance.generate_content_async(contents=content)
+
+
+            image_urls = []
+            for part in response.parts:
+                if part.inline_data and "image" in part.inline_data.mime_type:
+                    image_bytes = part.inline_data.data
+                    base64_image = base64.b64encode(image_bytes).decode("utf-8")
+                    data_uri = f"data:{part.inline_data.mime_type};base64,{base64_image}"
+                    image_urls.append(data_uri)
+            
+            if not image_urls:
+                # Check for a safety-related refusal to generate content
+                if response.prompt_feedback.block_reason:
+                    reason = response.prompt_feedback.block_reason.name
+                    logger.error(f"Image generation blocked due to safety settings. Reason: {reason}")
+                    raise ValueError(f"Image generation failed due to safety settings: {reason}")
+                
+                logger.warning(f"Gemini API did not return any images for the prompt: '{prompt[:100]}...'")
+                raise ValueError("Gemini API did not return any processable images.")
+
+            logger.info(f"Successfully generated {len(image_urls)} image(s) with Gemini.")
 
             return ImageGenerationResponse(
                 image_urls=image_urls,
-                revised_prompt=None  # legacy SDK does not provide a revised prompt here
+                revised_prompt=None  # genai library does not provide a revised prompt for images
             )
-
         except Exception as e:
-            logger.error("Error during Gemini image generation (legacy SDK): %s", e)
-            # Region support / feature gating errors sometimes include 'Unsupported' hints.
+            logger.error(f"Error during Google Gemini image generation: {str(e)}")
+            # Re-raise with a more specific message if it's a known type of error
             if "Unsupported" in str(e) and "location" in str(e):
-                raise ValueError(
-                    "Image generation may not be supported in your configured region or project. "
-                    "Check your API access and region settings."
-                )
+                 raise ValueError(f"Image generation is not supported in your configured region. Please check your Google Cloud project settings.")
             raise ValueError(f"Google Gemini image generation failed: {str(e)}")
 
     async def edit_image(
@@ -176,13 +103,28 @@ class GeminiImageClient(BaseImageClient):
         prompt: str,
         input_image_urls: List[str],
         mask_url: Optional[str] = None,
-        generation_config: Optional[Dict[str, Any]] = None
+        generation_config: Optional[Dict[str, Any]] = None,
+        **kwargs
     ) -> ImageGenerationResponse:
         """
-        Image editing/redraw with masks isn’t exposed via this legacy path here.
+        Edits an image using a Google Gemini model by providing the image(s) as context.
+        This method leverages the same underlying 'generate_content' call as generate_image.
+        Note: The Gemini API via the google-genai library does not support explicit masking.
         """
-        logger.error("Image editing is not supported by the GeminiImageClient (legacy SDK).")
-        raise NotImplementedError("The GeminiImageClient does not support the edit_image method.")
+        if mask_url:
+            logger.warning(
+                f"The GeminiImageClient for model '{self.model.name}' received a 'mask_url' but does not support "
+                "explicit masking. The mask will be ignored. The model will perform a general edit based on the prompt."
+            )
+        
+        # For Gemini, editing is the same as generating with an input image.
+        # The generate_image method already handles this logic correctly.
+        return await self.generate_image(
+            prompt=prompt,
+            input_image_urls=input_image_urls,
+            generation_config=generation_config,
+            **kwargs
+        )
 
     async def cleanup(self):
-        logger.debug("GeminiImageClient cleanup called (legacy SDK; nothing to release).")
+        logger.debug("GeminiImageClient cleanup called.")

autobyteus/multimedia/image/api/openai_image_client.py

@@ -30,7 +30,8 @@ class OpenAIImageClient(BaseImageClient):
         self,
         prompt: str,
         input_image_urls: Optional[List[str]] = None,
-        generation_config: Optional[Dict[str, Any]] = None
+        generation_config: Optional[Dict[str, Any]] = None,
+        **kwargs
     ) -> ImageGenerationResponse:
         """
         Generates an image using an OpenAI DALL-E model via the v1/images/generations endpoint.
@@ -83,7 +84,8 @@ class OpenAIImageClient(BaseImageClient):
         prompt: str,
         input_image_urls: List[str],
         mask_url: Optional[str] = None,
-        generation_config: Optional[Dict[str, Any]] = None
+        generation_config: Optional[Dict[str, Any]] = None,
+        **kwargs
     ) -> ImageGenerationResponse:
         """
         Edits an image using an OpenAI model that supports the v1/images/edits endpoint.

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
@@ -19,7 +19,9 @@ class AutobyteusImageModelProvider:
 
     @staticmethod
     def _get_hosts() -> List[str]:
-        """Gets Autobyteus server hosts from env vars."""
+        """
+        Gets Autobyteus server hosts from env vars. Skips discovery if no host is configured.
+        """
         hosts_str = os.getenv('AUTOBYTEUS_LLM_SERVER_HOSTS')
         if hosts_str:
             return [host.strip() for host in hosts_str.split(',')]
@@ -28,7 +30,7 @@ class AutobyteusImageModelProvider:
         if legacy_host:
             return [legacy_host]
             
-        return [AutobyteusImageModelProvider.DEFAULT_SERVER_URL]
+        return []
 
     @staticmethod
     def discover_and_register():
@@ -37,6 +39,10 @@ class AutobyteusImageModelProvider:
             from autobyteus.multimedia.image.image_client_factory import ImageClientFactory
 
             hosts = AutobyteusImageModelProvider._get_hosts()
+            if not hosts:
+                logger.info("No Autobyteus server hosts configured. Skipping Autobyteus image model discovery.")
+                return
+
             total_registered_count = 0
 
             for host_url in hosts:

autobyteus/multimedia/image/base_image_client.py

@@ -21,7 +21,8 @@ class BaseImageClient(ABC):
         self,
         prompt: str,
         input_image_urls: Optional[List[str]] = None,
-        generation_config: Optional[Dict[str, Any]] = None
+        generation_config: Optional[Dict[str, Any]] = None,
+        **kwargs
     ) -> ImageGenerationResponse:
         """
         Generates an image based on a textual prompt.
@@ -33,6 +34,7 @@ class BaseImageClient(ABC):
             generation_config (Optional[Dict[str, Any]]): Provider-specific parameters for image generation
                                                         to override defaults.
                                                         (e.g., n, size, quality, style).
+            **kwargs: Additional keyword arguments for extensibility.
 
         Returns:
             ImageGenerationResponse: An object containing URLs to the generated images.
@@ -45,7 +47,8 @@ class BaseImageClient(ABC):
         prompt: str,
         input_image_urls: List[str],
         mask_url: Optional[str] = None,
-        generation_config: Optional[Dict[str, Any]] = None
+        generation_config: Optional[Dict[str, Any]] = None,
+        **kwargs
     ) -> ImageGenerationResponse:
         """
         Edits an existing image based on a textual prompt.
@@ -56,6 +59,7 @@ class BaseImageClient(ABC):
             mask_url (Optional[str]): The path to a mask image. The transparent areas of the mask
                                        indicate where the image should be edited.
             generation_config (Optional[Dict[str, Any]]): Provider-specific parameters.
+            **kwargs: Additional keyword arguments for extensibility.
 
         Returns:
             ImageGenerationResponse: An object containing URLs to the edited images.

autobyteus/multimedia/image/image_client_factory.py

@@ -8,6 +8,7 @@ from autobyteus.multimedia.image.api.openai_image_client import OpenAIImageClien
 from autobyteus.multimedia.image.api.gemini_image_client import GeminiImageClient
 from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
 from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 logger = logging.getLogger(__name__)
 
@@ -39,28 +40,19 @@ class ImageClientFactory(metaclass=SingletonMeta):
         """Initializes the registry with built-in image models and discovers remote ones."""
         
         # OpenAI Models
+        gpt_image_1_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.")
+        ])
+
         gpt_image_1_model = ImageModel(
             name="gpt-image-1",
             value="dall-e-3",
             provider=MultimediaProvider.OPENAI,
             client_class=OpenAIImageClient,
-            parameter_schema={
-                "n": {"type": "integer", "default": 1, "allowed_values": [1], "description": "The number of images to generate."},
-                "size": {"type": "string", "default": "1024x1024", "allowed_values": ["1024x1024", "1792x1024", "1024x1792"], "description": "The size of the generated images."},
-                "quality": {"type": "string", "default": "hd", "allowed_values": ["standard", "hd"], "description": "The quality of the image that will be generated."},
-                "style": {"type": "string", "default": "vivid", "allowed_values": ["vivid", "natural"], "description": "The style of the generated images."}
-            }
-        )
-
-        dall_e_2_model = ImageModel(
-            name="dall-e-2",
-            value="dall-e-2",
-            provider=MultimediaProvider.OPENAI,
-            client_class=OpenAIImageClient,
-            parameter_schema={
-                "n": {"type": "integer", "default": 1, "description": "The number of images to generate."},
-                "size": {"type": "string", "default": "1024x1024", "allowed_values": ["256x256", "512x512", "1024x1024"], "description": "The size of the generated images."}
-            }
+            parameter_schema=gpt_image_1_schema
         )
 
         # Google Imagen Models (via Gemini API)
@@ -69,13 +61,22 @@ class ImageClientFactory(metaclass=SingletonMeta):
             value="imagen-4.0-generate-001",
             provider=MultimediaProvider.GOOGLE,
             client_class=GeminiImageClient,
-            parameter_schema={} # The genai library doesn't expose these as simple params
+            parameter_schema=None # The genai library doesn't expose these as simple params
+        )
+
+        # Google Gemini Flash Image Model (aka "Nano Banana")
+        gemini_flash_image_model = ImageModel(
+            name="gemini-2.5-flash-image-preview",
+            value="gemini-2.5-flash-image-preview",
+            provider=MultimediaProvider.GOOGLE,
+            client_class=GeminiImageClient,
+            parameter_schema=None # Parameters are not exposed for this model via the genai library.
         )
 
         models_to_register = [
             gpt_image_1_model,
-            dall_e_2_model,
             imagen_model,
+            gemini_flash_image_model,
         ]
         
         for model in models_to_register:

autobyteus/multimedia/image/image_model.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 import logging
-from typing import TYPE_CHECKING, Type, Optional, Iterator, Dict, Any
+from typing import TYPE_CHECKING, Type, Optional, Iterator, Dict, Any, Union
 from urllib.parse import urlparse
 
 from autobyteus.multimedia.providers import MultimediaProvider
 from autobyteus.multimedia.runtimes import MultimediaRuntime
 from autobyteus.multimedia.utils.multimedia_config import MultimediaConfig
+from autobyteus.utils.parameter_schema import ParameterSchema
 
 if TYPE_CHECKING:
     from autobyteus.multimedia.image.base_image_client import BaseImageClient
@@ -47,7 +48,7 @@ class ImageModel(metaclass=ImageModelMeta):
         value: str,
         provider: MultimediaProvider,
         client_class: Type["BaseImageClient"],
-        parameter_schema: Optional[Dict[str, Any]] = None,
+        parameter_schema: Optional[Union[Dict[str, Any], ParameterSchema]] = None,
         runtime: MultimediaRuntime = MultimediaRuntime.API,
         host_url: Optional[str] = None
     ):
@@ -57,13 +58,19 @@ class ImageModel(metaclass=ImageModelMeta):
         self.client_class = client_class
         self.runtime = runtime
         self.host_url = host_url
-        self.parameter_schema = parameter_schema if parameter_schema else {}
+        
+        if isinstance(parameter_schema, dict):
+            self.parameter_schema = ParameterSchema.from_dict(parameter_schema)
+        elif parameter_schema is None:
+            self.parameter_schema = ParameterSchema()
+        else:
+            self.parameter_schema = parameter_schema
 
         # Automatically build default_config from the schema's default values
         default_params = {
-            key: meta.get("default")
-            for key, meta in self.parameter_schema.items()
-            if "default" in meta
+            param.name: param.default_value
+            for param in self.parameter_schema.parameters
+            if param.default_value is not None
         }
         self.default_config = MultimediaConfig(params=default_params)
 

autobyteus/multimedia/providers.py

@@ -3,3 +3,4 @@ from enum import Enum
 class MultimediaProvider(Enum):
     OPENAI = "OPENAI"
     GOOGLE = "GOOGLE"
+    ALIBABA_QWEN = "ALIBABA_QWEN"

autobyteus/task_management/__init__.py

@@ -4,15 +4,15 @@ 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.
 """
-from .task_plan import TaskPlan, Task
-from .schemas import (TaskPlanDefinitionSchema, TaskDefinitionSchema, TaskStatusReportSchema,
+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
 from .deliverable import FileDeliverable
-from .tools import GetTaskBoardStatus, PublishTaskPlan, UpdateTaskStatus
-from .converters import TaskBoardConverter, TaskPlanConverter
-from .events import BaseTaskBoardEvent, TaskPlanPublishedEvent, TaskStatusUpdatedEvent
+from .tools import GetTaskBoardStatus, PublishTasks, PublishTask, UpdateTaskStatus, AssignTaskTo
+from .converters import TaskBoardConverter
+from .events import BaseTaskBoardEvent, TasksAddedEvent, TaskStatusUpdatedEvent
 
 # For convenience, we can alias InMemoryTaskBoard as the default TaskBoard.
 # This allows other parts of the code to import `TaskBoard` without needing
@@ -20,9 +20,8 @@ from .events import BaseTaskBoardEvent, TaskPlanPublishedEvent, TaskStatusUpdate
 TaskBoard = InMemoryTaskBoard
 
 __all__ = [
-    "TaskPlan",
     "Task",
-    "TaskPlanDefinitionSchema",
+    "TasksDefinitionSchema",
     "TaskDefinitionSchema",
     "TaskStatusReportSchema",
     "TaskStatusReportItemSchema",
@@ -33,11 +32,12 @@ __all__ = [
     "TaskBoard",  # Exposing the alias
     "FileDeliverable",
     "GetTaskBoardStatus",
-    "PublishTaskPlan",
+    "PublishTasks",
+    "PublishTask",
     "UpdateTaskStatus",
+    "AssignTaskTo",
     "TaskBoardConverter",
-    "TaskPlanConverter",
     "BaseTaskBoardEvent",
-    "TaskPlanPublishedEvent",
+    "TasksAddedEvent",
     "TaskStatusUpdatedEvent",
 ]

autobyteus/task_management/base_task_board.py

@@ -8,13 +8,14 @@ from enum import Enum
 from typing import Dict, Any, List, Optional
 
 from autobyteus.events.event_emitter import EventEmitter
-from .task_plan import Task, TaskPlan
+from .task import Task
 
 logger = logging.getLogger(__name__)
 
 class TaskStatus(str, Enum):
     """Enumerates the possible lifecycle states of a task on the TaskBoard."""
     NOT_STARTED = "not_started"
+    QUEUED = "queued"
     IN_PROGRESS = "in_progress"
     COMPLETED = "completed"
     BLOCKED = "blocked"
@@ -29,20 +30,27 @@ class BaseTaskBoard(ABC, EventEmitter):
     Abstract base class for a TaskBoard.
 
     This class defines the contract for any component that manages the live state
-    of a TaskPlan. Implementations could be in-memory, database-backed, or
-    connected to external services like JIRA. It inherits from EventEmitter to
-    broadcast state changes.
+    of tasks for a team. It is a dynamic board, not a static plan.
+    It inherits from EventEmitter to broadcast state changes.
     """
 
     def __init__(self, team_id: str):
         EventEmitter.__init__(self)
         self.team_id = team_id
+        self.tasks: List[Task] = []
         logger.debug(f"BaseTaskBoard initialized for team '{self.team_id}'.")
 
     @abstractmethod
-    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.
+        Adds a list of new tasks to the board. This is an additive-only operation.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def add_task(self, task: Task) -> bool:
+        """
+        Adds a single new task to the board.
         """
         raise NotImplementedError
 

autobyteus/task_management/converters/__init__.py

@@ -3,9 +3,7 @@
 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

@@ -23,26 +23,19 @@ class TaskBoardConverter:
             task_board: The task board instance to convert.
 
         Returns:
-            A TaskStatusReportSchema object if a plan is loaded, otherwise None.
+            A TaskStatusReportSchema object if there are tasks, otherwise None.
         """
-        internal_status = task_board.get_status_overview()
-        plan = task_board.current_plan
-
-        if not plan:
-            logger.debug(f"TaskBoard for team '{task_board.team_id}' has no plan loaded. Cannot generate report.")
+        if not task_board.tasks:
+            logger.debug(f"TaskBoard for team '{task_board.team_id}' has no tasks. Cannot generate report.")
             return None
 
-        # --- Conversion to LLM-Friendly Format ---
+        internal_status = task_board.get_status_overview()
         
-        # 1. Create maps for easy lookup
-        id_to_name_map = {task.task_id: task.task_name for task in plan.tasks}
+        id_to_name_map = {task.task_id: task.task_name for task in task_board.tasks}
         
-        # 2. Build the list of LLM-friendly task items
         report_items = []
-        for task in plan.tasks:
-            # Convert dependency IDs back to names. This is safe because the plan
-            # should have been hydrated already.
-            dep_names = [id_to_name_map[dep_id] for dep_id in task.dependencies]
+        for task in task_board.tasks:
+            dep_names = [id_to_name_map.get(dep_id, str(dep_id)) for dep_id in task.dependencies]
             
             report_item = TaskStatusReportItemSchema(
                 task_name=task.task_name,
@@ -54,9 +47,7 @@ class TaskBoardConverter:
             )
             report_items.append(report_item)
 
-        # 3. Assemble the final report object
         status_report = TaskStatusReportSchema(
-            overall_goal=plan.overall_goal,
             tasks=report_items
         )