autobyteus 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

autobyteus/llm/lmstudio_provider.py

@@ -0,0 +1,104 @@
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.api.lmstudio_llm import LMStudioLLM
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.llm.runtimes import LLMRuntime
+from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
+from typing import TYPE_CHECKING, List
+import os
+import logging
+from openai import OpenAI, APIConnectionError, OpenAIError
+from urllib.parse import urlparse
+
+if TYPE_CHECKING:
+    from autobyteus.llm.llm_factory import LLMFactory
+
+logger = logging.getLogger(__name__)
+
+class LMStudioModelProvider:
+    DEFAULT_LMSTUDIO_HOST = 'http://localhost:1234'
+
+    @staticmethod
+    def _get_hosts() -> List[str]:
+        """Gets LM Studio hosts from env vars, supporting comma-separated list."""
+        hosts_str = os.getenv('LMSTUDIO_HOSTS')
+        if hosts_str:
+            return [host.strip() for host in hosts_str.split(',')]
+        
+        legacy_host = os.getenv('LMSTUDIO_HOST') # For backward compatibility
+        if legacy_host:
+            return [legacy_host]
+        
+        return [LMStudioModelProvider.DEFAULT_LMSTUDIO_HOST]
+
+    @staticmethod
+    def is_valid_url(url: str) -> bool:
+        """Validate if the provided URL is properly formatted."""
+        try:
+            result = urlparse(url)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+
+    @staticmethod
+    def discover_and_register():
+        """
+        Discovers models from all configured LM Studio instances and registers them.
+        """
+        try:
+            from autobyteus.llm.llm_factory import LLMFactory
+            
+            hosts = LMStudioModelProvider._get_hosts()
+            total_registered_count = 0
+
+            for host_url in hosts:
+                if not LMStudioModelProvider.is_valid_url(host_url):
+                    logger.error(f"Invalid LM Studio host URL: {host_url}, skipping.")
+                    continue
+
+                logger.info(f"Discovering LM Studio models from host: {host_url}")
+                base_url = f"{host_url}/v1"
+                client = OpenAI(base_url=base_url, api_key="lm-studio") # Dummy key
+
+                try:
+                    response = client.models.list()
+                    models = response.data
+                except APIConnectionError:
+                    logger.warning(f"Could not connect to LM Studio at {host_url}. Please ensure the server is running.")
+                    continue
+                except OpenAIError as e:
+                    logger.error(f"An error occurred fetching models from LM Studio at {host_url}: {e}")
+                    continue
+
+                host_registered_count = 0
+                for model_info in models:
+                    model_id = model_info.id
+                    if not model_id:
+                        continue
+                    
+                    try:
+                        llm_model = LLMModel(
+                            name=model_id,
+                            value=model_id,
+                            provider=LLMProvider.LMSTUDIO, # LMStudio is both provider and runtime
+                            llm_class=LMStudioLLM,
+                            canonical_name=model_id,
+                            runtime=LLMRuntime.LMSTUDIO,
+                            host_url=host_url,
+                            default_config=LLMConfig(
+                                pricing_config=TokenPricingConfig(0.0, 0.0) # Local models are free
+                            )
+                        )
+                        LLMFactory.register_model(llm_model)
+                        host_registered_count += 1
+                    except Exception as e:
+                        logger.warning(f"Failed to register LM Studio model '{model_id}' from {host_url}: {e}")
+
+                if host_registered_count > 0:
+                    logger.info(f"Registered {host_registered_count} models from LM Studio host {host_url}")
+                total_registered_count += host_registered_count
+
+            if total_registered_count > 0:
+                logger.info(f"Finished LM Studio discovery. Total models registered: {total_registered_count}")
+
+        except Exception as e:
+            logger.error(f"An unexpected error occurred during LM Studio model discovery: {e}")

autobyteus/llm/models.py

@@ -1,8 +1,10 @@
 import logging
 from typing import TYPE_CHECKING, Type, Optional, List, Iterator
 from dataclasses import dataclass
+from urllib.parse import urlparse
 
 from autobyteus.llm.providers import LLMProvider
+from autobyteus.llm.runtimes import LLMRuntime
 from autobyteus.llm.utils.llm_config import LLMConfig
 
 if TYPE_CHECKING:
@@ -13,9 +15,14 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class ModelInfo:
-    """A simple data structure for essential model information."""
-    name: str
+    """A detailed public data structure for model information."""
+    model_identifier: str
+    display_name: str
+    value: str
     canonical_name: str
+    provider: str
+    runtime: str
+    host_url: Optional[str] = None
 
 @dataclass
 class ProviderModelGroup:
@@ -33,62 +40,56 @@ class LLMModelMeta(type):
         Allows iteration over LLMModel instances (e.g., `for model in LLMModel:`).
         Ensures that the LLMFactory has initialized and registered all models.
         """
-        # Import LLMFactory locally to prevent circular import issues at module load time.
         from autobyteus.llm.llm_factory import LLMFactory
         LLMFactory.ensure_initialized()
+        
+        # Iterates over all registered models from the factory's internal dictionary
+        for model in LLMFactory._models_by_identifier.values():
+            yield model
 
-        for models in LLMFactory._models_by_provider.values():
-            yield from models
-
-    def __getitem__(cls, name_or_value: str) -> 'LLMModel':
+    def __getitem__(cls, name_or_identifier: str) -> 'LLMModel':
         """
-        Allows dictionary-like access to LLMModel instances by name (e.g., 'gpt-4o')
-        or by value (e.g., 'gpt-4o').
-        Search is performed by name first, then by value.
+        Allows dictionary-like access to LLMModel instances by name or identifier.
+        If a non-unique name is provided that matches multiple models, it raises an error.
         """
-        # Import LLMFactory locally to prevent circular import issues at module load time.
         from autobyteus.llm.llm_factory import LLMFactory
-        LLMFactory.ensure_initialized()
+        factory = LLMFactory()
+        factory.ensure_initialized()
 
-        # 1. Try to find by name first
-        for model in cls:
-            if model.name == name_or_value:
-                return model
+        # First, try a direct lookup by unique model_identifier
+        model = factory._models_by_identifier.get(name_or_identifier)
+        if model:
+            return model
+
+        # If not found, search by name (which might not be unique)
+        found_models = [m for m in factory._models_by_identifier.values() if m.name == name_or_identifier]
+
+        if len(found_models) == 1:
+            return found_models[0]
         
-        # 2. If not found by name, iterate and find by value
-        for model in cls:
-            if model.value == name_or_value:
-                return model
+        if len(found_models) > 1:
+            # Ambiguous name, guide the user to provide a unique identifier
+            identifiers = [m.model_identifier for m in found_models]
+            raise KeyError(
+                f"Model name '{name_or_identifier}' is ambiguous and exists on multiple runtimes. "
+                f"Please use one of the unique model identifiers: {identifiers}"
+            )
         
-        # 3. If not found by name or value, raise KeyError
-        available_models = [m.name for m in cls] 
-        raise KeyError(f"Model '{name_or_value}' not found. Available models are: {available_models}")
+        # If not found by identifier or name, raise KeyError
+        available_models = list(factory._models_by_identifier.keys())
+        raise KeyError(f"Model '{name_or_identifier}' not found. Available models are: {available_models}")
 
     def __len__(cls) -> int:
         """
         Allows getting the number of registered models (e.g., `len(LLMModel)`).
         """
-        # Import LLMFactory locally.
         from autobyteus.llm.llm_factory import LLMFactory
         LLMFactory.ensure_initialized()
-        
-        count = 0
-        for models in LLMFactory._models_by_provider.values():
-            count += len(models)
-        return count
+        return len(LLMFactory._models_by_identifier)
 
 class LLMModel(metaclass=LLMModelMeta):
     """
-    Represents a single model's metadata:
-      - name (str): A human-readable label, e.g. "gpt-4o"
-      - value (str): A unique identifier used in code or APIs, e.g. "gpt-4o"
-      - canonical_name (str): A shorter, standardized reference name for prompts, e.g. "gpt-4o" or "claude-3.7"
-      - provider (LLMProvider): The provider enum 
-      - llm_class (Type[BaseLLM]): Which Python class to instantiate 
-      - default_config (LLMConfig): Default configuration (token limit, etc.)
-
-    Each model also exposes a create_llm() method to instantiate the underlying class.
-    Supports Enum-like access via `LLMModel['MODEL_NAME']` and iteration `for model in LLMModel:`.
+    Represents a single model's metadata and connection properties.
     """
 
     def __init__(
@@ -98,7 +99,9 @@ class LLMModel(metaclass=LLMModelMeta):
         provider: LLMProvider,
         llm_class: Type["BaseLLM"],
         canonical_name: str,
-        default_config: Optional[LLMConfig] = None
+        default_config: Optional[LLMConfig] = None,
+        runtime: LLMRuntime = LLMRuntime.API,
+        host_url: Optional[str] = None
     ):
         self._name = name
         self._value = value
@@ -106,13 +109,32 @@ class LLMModel(metaclass=LLMModelMeta):
         self.provider = provider
         self.llm_class = llm_class
         self.default_config = default_config if default_config else LLMConfig()
+        self.runtime = runtime
+        self.host_url = host_url
+        self._model_identifier = self._generate_identifier()
+
+    def _generate_identifier(self) -> str:
+        """Generates the globally unique model identifier."""
+        if self.runtime == LLMRuntime.API:
+            return self.name
+        
+        if not self.host_url:
+            raise ValueError(f"host_url is required for runtime '{self.runtime.value}' on model '{self.name}'")
+        
+        try:
+            parsed_url = urlparse(self.host_url)
+            host_and_port = parsed_url.netloc
+            return f"{self.name}:{self.runtime.value.lower()}@{host_and_port}"
+        except Exception as e:
+            logger.error(f"Failed to parse host_url '{self.host_url}' for identifier generation: {e}")
+            # Fallback to a simpler, but still likely unique, identifier
+            return f"{self.name}:{self.runtime.value.lower()}@{self.host_url}"
 
     @property
     def name(self) -> str:
         """
-        A friendly or descriptive name for this model (could appear in UI).
-        This is the key used for `LLMModel['MODEL_NAME']` access.
-        Example: "gpt-4o"
+        The model's original name as expected by the runtime's API.
+        Example: "llama3:latest", "gpt-4o"
         """
         return self._name
 
@@ -120,16 +142,24 @@ class LLMModel(metaclass=LLMModelMeta):
     def value(self) -> str:
         """
         The underlying unique identifier for this model (e.g. an API model string).
-        Example: "gpt-4o"
+        Often the same as `name`. Example: "gpt-4o"
         """
         return self._value
+    
+    @property
+    def model_identifier(self) -> str:
+        """
+        A globally unique, dynamically generated identifier for use within the system.
+        Example: "llama3:latest:ollama@localhost:11434"
+        """
+        return self._model_identifier
 
     @property
     def canonical_name(self) -> str:
         """
         A standardized, shorter reference name for this model.
         Useful for prompt engineering and cross-referencing similar models.
-        Example: "gpt-4o"
+        Example: "gpt-4o", "llama3"
         """
         return self._canonical_name
 
@@ -145,16 +175,16 @@ class LLMModel(metaclass=LLMModelMeta):
         Returns:
             BaseLLM: An instance of the LLM.
         """
-        config_to_use = llm_config if llm_config is not None else self.default_config
-        # The llm_class constructor now expects model and llm_config as parameters
+        config_to_use = self.default_config
+        if llm_config:
+            # Create a copy to avoid modifying the default config
+            config_to_use = LLMConfig.from_dict(self.default_config.to_dict())
+            config_to_use.merge_with(llm_config)
+            
         return self.llm_class(model=self, llm_config=config_to_use)
 
     def __repr__(self):
         return (
-            f"LLMModel(name='{self._name}', value='{self._value}', "
-            f"canonical_name='{self._canonical_name}', "
-            f"provider='{self.provider.name}', llm_class='{self.llm_class.__name__}')"
+            f"LLMModel(identifier='{self.model_identifier}', name='{self.name}', "
+            f"provider='{self.provider.name}', runtime='{self.runtime.name}')"
         )
-    
-    # __class_getitem__ is now handled by the metaclass LLMModelMeta's __getitem__
-    # No need to define it here anymore.

autobyteus/llm/ollama_provider.py

@@ -1,9 +1,10 @@
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.api.ollama_llm import OllamaLLM
 from autobyteus.llm.providers import LLMProvider
+from autobyteus.llm.runtimes import LLMRuntime
 from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
 from autobyteus.llm.ollama_provider_resolver import OllamaProviderResolver
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 import os
 import logging
 from ollama import Client
@@ -17,7 +18,22 @@ logger = logging.getLogger(__name__)
 
 class OllamaModelProvider:
     DEFAULT_OLLAMA_HOST = 'http://localhost:11434'
-    CONNECTION_TIMEOUT = 5.0  # 5 seconds timeout
+    CONNECTION_TIMEOUT = 5.0
+
+    @staticmethod
+    def _get_hosts() -> List[str]:
+        """Gets Ollama hosts from env vars, supporting comma-separated list."""
+        # New multi-host variable
+        hosts_str = os.getenv('OLLAMA_HOSTS')
+        if hosts_str:
+            return [host.strip() for host in hosts_str.split(',')]
+        
+        # Legacy single-host variable for backward compatibility
+        legacy_host = os.getenv('DEFAULT_OLLAMA_HOST')
+        if legacy_host:
+            return [legacy_host]
+
+        return [OllamaModelProvider.DEFAULT_OLLAMA_HOST]
 
     @staticmethod
     def is_valid_url(url: str) -> bool:
@@ -31,73 +47,65 @@ class OllamaModelProvider:
     @staticmethod
     def discover_and_register():
         """
-        Discovers all models supported by Ollama using a synchronous Client
-        and registers them directly using LLMFactory.
-        
-        Handles various connection and operational errors gracefully to prevent
-        application crashes when Ollama is unavailable.
+        Discovers all models from all configured Ollama hosts and registers them.
         """
         try:
-            from autobyteus.llm.llm_factory import LLMFactory  # Local import to avoid circular dependency
-            
-            ollama_host = os.getenv('DEFAULT_OLLAMA_HOST', OllamaLLM.DEFAULT_OLLAMA_HOST)
-            
-            if not OllamaModelProvider.is_valid_url(ollama_host):
-                logger.error(f"Invalid Ollama host URL: {ollama_host}")
-                return
-            
-            client = Client(host=ollama_host)
-            
-            try:
-                response = client.list()
-            except httpx.ConnectError as e:
-                logger.warning(f"Could not connect to Ollama server at {ollama_host}. "
-                             f"Please ensure Ollama is running. Error: {str(e)}")
-                return
-            except httpx.TimeoutException as e:
-                logger.warning(f"Connection to Ollama server timed out. "
-                             f"Please check if the server is responsive. Error: {str(e)}")
-                return
-            except httpx.HTTPError as e:
-                logger.warning(f"HTTP error occurred while connecting to Ollama: {str(e)}")
-                return
-            
-            try:
-                models = response['models']
-            except (KeyError, TypeError) as e:
-                logger.error(f"Unexpected response format from Ollama server: {str(e)}")
-                return
-            
-            registered_count = 0
-            for model_info in models:
+            from autobyteus.llm.llm_factory import LLMFactory
+
+            hosts = OllamaModelProvider._get_hosts()
+            total_registered_count = 0
+
+            for host_url in hosts:
+                if not OllamaModelProvider.is_valid_url(host_url):
+                    logger.error(f"Invalid Ollama host URL provided: '{host_url}', skipping.")
+                    continue
+                
+                logger.info(f"Discovering Ollama models from host: {host_url}")
+                client = Client(host=host_url)
+                
                 try:
+                    response = client.list()
+                    models = response.get('models', [])
+                except httpx.ConnectError:
+                    logger.warning(f"Could not connect to Ollama server at {host_url}. Please ensure it's running.")
+                    continue
+                except Exception as e:
+                    logger.error(f"Failed to fetch models from {host_url}: {e}")
+                    continue
+
+                host_registered_count = 0
+                for model_info in models:
                     model_name = model_info.get('model')
                     if not model_name:
                         continue
 
-                    # Determine the provider based on the model name
-                    provider = OllamaProviderResolver.resolve(model_name)
+                    try:
+                        provider = OllamaProviderResolver.resolve(model_name)
                         
-                    llm_model = LLMModel(
-                        name=model_name,
-                        value=model_name,
-                        provider=provider,
-                        llm_class=OllamaLLM,
-                        canonical_name=model_name,  # Use model_name as the canonical_name
-                        default_config=LLMConfig(
-                            rate_limit=60,
-                            token_limit=8192,
-                            pricing_config=TokenPricingConfig(0.0, 0.0)
+                        llm_model = LLMModel(
+                            name=model_name,
+                            value=model_name,
+                            provider=provider,
+                            llm_class=OllamaLLM,
+                            canonical_name=model_name,
+                            runtime=LLMRuntime.OLLAMA,
+                            host_url=host_url,
+                            default_config=LLMConfig(
+                                pricing_config=TokenPricingConfig(0.0, 0.0) # Local models are free
+                            )
                         )
-                    )
-                    LLMFactory.register_model(llm_model)
-                    registered_count += 1
-                except Exception as e:
-                    logger.warning(f"Failed to register model {model_name}: {str(e)}")
-                    continue
-                    
-            logger.info(f"Successfully registered {registered_count} Ollama models from {ollama_host}")
+                        LLMFactory.register_model(llm_model)
+                        host_registered_count += 1
+                    except Exception as e:
+                        logger.warning(f"Failed to register model '{model_name}' from host {host_url}: {e}")
+                
+                if host_registered_count > 0:
+                    logger.info(f"Registered {host_registered_count} models from Ollama host {host_url}")
+                total_registered_count += host_registered_count
             
+            if total_registered_count > 0:
+                logger.info(f"Finished Ollama discovery. Total models registered: {total_registered_count}")
+
         except Exception as e:
-            logger.error(f"Unexpected error during Ollama model discovery: {str(e)}")
-            # Don't re-raise the exception to prevent application crash
+            logger.error(f"An unexpected error occurred during Ollama model discovery: {e}")
+

autobyteus/llm/ollama_provider_resolver.py

@@ -13,6 +13,7 @@ class OllamaProviderResolver:
     # A mapping from keywords to providers. The list is ordered to handle
     # potential overlaps, though current keywords are distinct.
     KEYWORD_PROVIDER_MAP = [
+        (['gpt'], LLMProvider.OPENAI),
         (['gemma', 'gemini'], LLMProvider.GEMINI),
         (['llama'], LLMProvider.GROQ),
         (['mistral'], LLMProvider.MISTRAL),

autobyteus/llm/providers.py

@@ -1,15 +1,16 @@
 from enum import Enum
 
 class LLMProvider(Enum):
-    OPENAI = "openai"
-    ANTHROPIC = "anthropic"
-    MISTRAL = "mistral"
-    GROQ = "groq"
-    GEMINI = "gemini"
-    NVIDIA = "nvidia"
-    PERPLEXITY = "perplexity"
-    OLLAMA = "ollama"
-    DEEPSEEK = "deepseek"
-    GROK = "grok"
-    AUTOBYTEUS = "autobyteus"
-    KIMI = "kimi"
+    OPENAI = "OPENAI"
+    ANTHROPIC = "ANTHROPIC"
+    MISTRAL = "MISTRAL"
+    GROQ = "GROQ"
+    GEMINI = "GEMINI"
+    NVIDIA = "NVIDIA"
+    PERPLEXITY = "PERPLEXITY"
+    OLLAMA = "OLLAMA"
+    DEEPSEEK = "DEEPSEEK"
+    GROK = "GROK"
+    AUTOBYTEUS = "AUTOBYTEUS"
+    KIMI = "KIMI"
+    LMSTUDIO = "LMSTUDIO"

autobyteus/llm/runtimes.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class LLMRuntime(Enum):
+    """
+    Represents the serving layer or environment where an LLM model is executed.
+    This is distinct from the LLMProvider, which is the creator of the model.
+    """
+    API = "api"
+    OLLAMA = "ollama"
+    LMSTUDIO = "lmstudio"
+    AUTOBYTEUS = "autobyteus"

autobyteus/llm/token_counter/token_counter_factory.py

@@ -36,6 +36,8 @@ def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
         return KimiTokenCounter(model, llm)
     elif model.provider == LLMProvider.OLLAMA:
         return OpenAITokenCounter(model, llm)
+    elif model.provider == LLMProvider.LMSTUDIO:
+        return OpenAITokenCounter(model, llm)
     elif model.provider == LLMProvider.GEMINI:
         return OpenAITokenCounter(model, llm)
     else:

autobyteus/task_management/__init__.py

@@ -0,0 +1,43 @@
+# 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.
+"""
+from .task_plan import TaskPlan, Task
+from .schemas import (TaskPlanDefinitionSchema, 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
+
+# For convenience, we can alias InMemoryTaskBoard as the default TaskBoard.
+# This allows other parts of the code to import `TaskBoard` without needing
+# to know the specific implementation being used by default.
+TaskBoard = InMemoryTaskBoard
+
+__all__ = [
+    "TaskPlan",
+    "Task",
+    "TaskPlanDefinitionSchema",
+    "TaskDefinitionSchema",
+    "TaskStatusReportSchema",
+    "TaskStatusReportItemSchema",
+    "FileDeliverableSchema",
+    "BaseTaskBoard",
+    "TaskStatus",
+    "InMemoryTaskBoard",
+    "TaskBoard",  # Exposing the alias
+    "FileDeliverable",
+    "GetTaskBoardStatus",
+    "PublishTaskPlan",
+    "UpdateTaskStatus",
+    "TaskBoardConverter",
+    "TaskPlanConverter",
+    "BaseTaskBoardEvent",
+    "TaskPlanPublishedEvent",
+    "TaskStatusUpdatedEvent",
+]

autobyteus/task_management/base_task_board.py

@@ -0,0 +1,68 @@
+# file: autobyteus/autobyteus/task_management/base_task_board.py
+"""
+Defines the abstract interface for a TaskBoard and its related enums.
+"""
+import logging
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Dict, Any, List, Optional
+
+from autobyteus.events.event_emitter import EventEmitter
+from .task_plan import Task, TaskPlan
+
+logger = logging.getLogger(__name__)
+
+class TaskStatus(str, Enum):
+    """Enumerates the possible lifecycle states of a task on the TaskBoard."""
+    NOT_STARTED = "not_started"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    BLOCKED = "blocked"
+    FAILED = "failed"
+
+    def is_terminal(self) -> bool:
+        """Returns True if the status is a final state."""
+        return self in {TaskStatus.COMPLETED, TaskStatus.FAILED}
+
+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.
+    """
+
+    def __init__(self, team_id: str):
+        EventEmitter.__init__(self)
+        self.team_id = team_id
+        logger.debug(f"BaseTaskBoard initialized for team '{self.team_id}'.")
+
+    @abstractmethod
+    def load_task_plan(self, plan: TaskPlan) -> bool:
+        """
+        Loads a new plan onto the board, resetting its state.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_task_status(self, task_id: str, status: TaskStatus, agent_name: str) -> bool:
+        """
+        Updates the status of a specific task.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_status_overview(self) -> Dict[str, Any]:
+        """
+        Returns a serializable dictionary of the board's current state.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_next_runnable_tasks(self) -> List[Task]:
+        """
+        Calculates which tasks can be executed now based on dependencies and statuses.
+        """
+        raise NotImplementedError