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

autobyteus/events/event_types.py

@@ -34,6 +34,7 @@ class EventType(Enum):
     AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE = "agent_data_assistant_complete_response"
     AGENT_DATA_TOOL_LOG = "agent_data_tool_log" 
     AGENT_DATA_TOOL_LOG_STREAM_END = "agent_data_tool_log_stream_end" 
+    AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED = "agent_data_system_task_notification_received" # NEW
     
     # --- Agent Requests for External Interaction ---
     AGENT_REQUEST_TOOL_INVOCATION_APPROVAL = "agent_request_tool_invocation_approval" 
@@ -42,5 +43,12 @@ class EventType(Enum):
     # --- Agent Errors (not necessarily phase changes, e.g., error during output generation) ---
     AGENT_ERROR_OUTPUT_GENERATION = "agent_error_output_generation"
 
+    # --- Agent Team Events ---
+    TEAM_STREAM_EVENT = "team_stream_event" # For unified agent team event stream
+
+    # --- Task Board Events ---
+    TASK_BOARD_PLAN_PUBLISHED = "task_board_plan_published"
+    TASK_BOARD_STATUS_UPDATED = "task_board_status_updated"
+
     def __str__(self): 
         return self.value

autobyteus/llm/api/autobyteus_llm.py

@@ -11,18 +11,17 @@ import uuid
 logger = logging.getLogger(__name__)
 
 class AutobyteusLLM(BaseLLM):
-    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
-        # Provide defaults if not specified
-        if model is None:
-            # This should be set by the factory/caller, but providing a fallback
-            raise ValueError("AutobyteusLLM requires a model to be specified")
-        if llm_config is None:
-            llm_config = LLMConfig()
-            
+    def __init__(self, model: LLMModel, llm_config: LLMConfig):
+        # The host URL is now passed via the model object.
+        if not model.host_url:
+            raise ValueError("AutobyteusLLM requires a host_url to be set in its LLMModel object.")
+
         super().__init__(model=model, llm_config=llm_config)
-        self.client = AutobyteusClient()
+        
+        # Instantiate the client with the specific host for this model.
+        self.client = AutobyteusClient(server_url=self.model.host_url)
         self.conversation_id = str(uuid.uuid4())
-        logger.info(f"AutobyteusLLM initialized with model: {self.model} and conversation ID: {self.conversation_id}")
+        logger.info(f"AutobyteusLLM initialized for model '{self.model.model_identifier}' with conversation ID: {self.conversation_id}")
 
     async def _send_user_message_to_llm(
         self,
@@ -34,7 +33,7 @@ class AutobyteusLLM(BaseLLM):
         try:
             response = await self.client.send_message(
                 conversation_id=self.conversation_id,
-                model_name=self.model.name,
+                model_name=self.model.name, # Use `name` as it's the original model name for the API
                 user_message=user_message,
                 image_urls=image_urls
             )
@@ -70,7 +69,7 @@ class AutobyteusLLM(BaseLLM):
         try:
             async for chunk in self.client.stream_message(
                 conversation_id=self.conversation_id,
-                model_name=self.model.name,
+                model_name=self.model.name, # Use `name` for the API call
                 user_message=user_message,
                 image_urls=image_urls
             ):

autobyteus/llm/api/lmstudio_llm.py

@@ -0,0 +1,34 @@
+import logging
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+import os
+
+logger = logging.getLogger(__name__)
+
+class LMStudioLLM(OpenAICompatibleLLM):
+    """
+    LLM class for models served by a local LM Studio instance.
+    This class is now decoupled from environment variables and receives its connection
+    details from the LLMModel object.
+    """
+    
+    def __init__(self, model: LLMModel, llm_config: LLMConfig):
+        if not model.host_url:
+            raise ValueError("LMStudioLLM requires a host_url to be set in its LLMModel object.")
+
+        base_url = f"{model.host_url}/v1"
+
+        # The API key is often not needed for LM Studio, but we allow it to be set via env var.
+        # It defaults to a dummy value if not set.
+        super().__init__(
+            model=model,
+            llm_config=llm_config,
+            api_key_env_var="LMSTUDIO_API_KEY",
+            base_url=base_url,
+            api_key_default="lm-studio" # Dummy key for LM Studio
+        )
+        logger.info(f"LMStudioLLM initialized for model '{model.model_identifier}' with base URL: {base_url}")
+
+    async def cleanup(self):
+        await super().cleanup()

autobyteus/llm/api/ollama_llm.py

@@ -14,22 +14,17 @@ import os
 logger = logging.getLogger(__name__)
 
 class OllamaLLM(BaseLLM):
-    DEFAULT_OLLAMA_HOST = 'http://localhost:11434'
-
-    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
-        self.ollama_host = os.getenv('DEFAULT_OLLAMA_HOST', self.DEFAULT_OLLAMA_HOST)
-        logger.info(f"Initializing Ollama with host: {self.ollama_host}")
+    def __init__(self, model: LLMModel, llm_config: LLMConfig):
+        # The host URL is now passed via the model object, decoupling from environment variables here.
+        if not model.host_url:
+            raise ValueError("OllamaLLM requires a host_url to be set in its LLMModel object.")
+            
+        logger.info(f"Initializing OllamaLLM for model '{model.name}' with host: {model.host_url}")
         
-        self.client = AsyncClient(host=self.ollama_host)
+        self.client = AsyncClient(host=model.host_url)
         
-        # Provide defaults if not specified
-        if model is None:
-            model = LLMModel.OLLAMA_LLAMA_3_2
-        if llm_config is None:
-            llm_config = LLMConfig()
-            
         super().__init__(model=model, llm_config=llm_config)
-        logger.info(f"OllamaLLM initialized with model: {self.model}")
+        logger.info(f"OllamaLLM initialized with model: {self.model.model_identifier}")
 
     async def _send_user_message_to_llm(self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs) -> CompleteResponse:
         self.add_user_message(user_message)

autobyteus/llm/api/openai_compatible_llm.py

@@ -21,12 +21,29 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
         model: LLMModel,
         llm_config: LLMConfig,
         api_key_env_var: str,
-        base_url: str
+        base_url: str,
+        api_key_default: Optional[str] = None
     ):
+        """
+        Initializes an OpenAI-compatible LLM.
+
+        Args:
+            model (LLMModel): The model to use.
+            llm_config (LLMConfig): Configuration for the LLM.
+            api_key_env_var (str): The name of the environment variable for the API key.
+            base_url (str): The base URL for the API.
+            api_key_default (Optional[str], optional): A default API key to use if the
+                                                       environment variable is not set.
+                                                       Defaults to None.
+        """
         api_key = os.getenv(api_key_env_var)
         if not api_key:
-            logger.error(f"{api_key_env_var} environment variable is not set.")
-            raise ValueError(f"{api_key_env_var} environment variable is not set.")
+            if api_key_default:
+                api_key = api_key_default
+                logger.info(f"{api_key_env_var} not set, using default key.")
+            else:
+                logger.error(f"{api_key_env_var} environment variable is not set.")
+                raise ValueError(f"{api_key_env_var} environment variable is not set.")
 
         self.client = OpenAI(api_key=api_key, base_url=base_url)
         logger.info(f"Initialized OpenAI compatible client with base_url: {base_url}")

autobyteus/llm/autobyteus_provider.py

@@ -1,8 +1,9 @@
 from autobyteus.llm.api.autobyteus_llm import AutobyteusLLM
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.providers import LLMProvider
+from autobyteus.llm.runtimes import LLMRuntime
 from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
-from typing import Dict, Any, TYPE_CHECKING
+from typing import Dict, Any, TYPE_CHECKING, List, Optional
 import os
 import logging
 from urllib.parse import urlparse
@@ -15,63 +16,89 @@ logger = logging.getLogger(__name__)
 
 class AutobyteusModelProvider:
     DEFAULT_SERVER_URL = 'https://localhost:8000'
-    CONNECTION_TIMEOUT = 5.0
+
+    @staticmethod
+    def _get_hosts() -> List[str]:
+        """Gets Autobyteus LLM server hosts from env vars, supporting a comma-separated list."""
+        hosts_str = os.getenv('AUTOBYTEUS_LLM_SERVER_HOSTS')
+        if hosts_str:
+            return [host.strip() for host in hosts_str.split(',')]
+        
+        legacy_host = os.getenv('AUTOBYTEUS_LLM_SERVER_URL')
+        if legacy_host:
+            return [legacy_host]
+            
+        return [AutobyteusModelProvider.DEFAULT_SERVER_URL]
 
     @staticmethod
     def discover_and_register():
-        """Discover and register Autobyteus models synchronously"""
+        """Discover and register Autobyteus models from all configured hosts."""
         try:
-            from autobyteus.llm.llm_factory import LLMFactory  # Local import to avoid circular dependency
-
-            client = None
-            try:
-                client = AutobyteusClient()
-                response = client.get_available_models_sync()
-            except Exception as e:
-                logger.error(f"Client initialization failed: {str(e)}")
-                return
-            finally:
-                if client:
-                    client.sync_client.close()
+            from autobyteus.llm.llm_factory import LLMFactory
 
-            if not AutobyteusModelProvider._validate_server_response(response):
-                return
+            hosts = AutobyteusModelProvider._get_hosts()
+            total_registered_count = 0
 
-            models = response.get('models', [])
-            registered_count = 0
-            
-            for model_info in models:
+            for host_url in hosts:
+                if not AutobyteusModelProvider.is_valid_url(host_url):
+                    logger.error(f"Invalid Autobyteus host URL: {host_url}, skipping.")
+                    continue
+                
+                logger.info(f"Discovering Autobyteus models from host: {host_url}")
+                client = None
                 try:
-                    validation_result = AutobyteusModelProvider._validate_model_info(model_info)
-                    if not validation_result["valid"]:
-                        logger.warning(validation_result["message"])
-                        continue
-                        
-                    llm_config = AutobyteusModelProvider._parse_llm_config(model_info["config"])
-                    if not llm_config:
-                        continue
-                        
-                    llm_model = LLMModel(
-                        name=model_info["name"],
-                        value=model_info["value"],
-                        provider=LLMProvider(model_info["provider"]),  # Convert string to enum
-                        llm_class=AutobyteusLLM,
-                        canonical_name=model_info["canonical_name"],  # Add canonical_name
-                        default_config=llm_config
-                    )
-                    
-                    LLMFactory.register_model(llm_model)
-                    registered_count += 1
-                    logger.debug(f"Registered model: {model_info['name']} with canonical name: {model_info['canonical_name']}")
-                    
+                    # Instantiate client for this specific host
+                    client = AutobyteusClient(server_url=host_url)
+                    response = client.get_available_models_sync()
                 except Exception as e:
-                    logger.error(f"Model registration failed: {str(e)}")
+                    logger.warning(f"Could not connect or fetch models from Autobyteus server at {host_url}: {e}")
+                    continue
+                finally:
+                    if client:
+                        client.sync_client.close()
+
+                if not AutobyteusModelProvider._validate_server_response(response):
                     continue
+
+                models = response.get('models', [])
+                host_registered_count = 0
+                for model_info in models:
+                    try:
+                        validation_result = AutobyteusModelProvider._validate_model_info(model_info)
+                        if not validation_result["valid"]:
+                            logger.warning(validation_result["message"])
+                            continue
+                        
+                        llm_config = AutobyteusModelProvider._parse_llm_config(model_info["config"])
+                        if not llm_config:
+                            continue
                         
-            logger.info(f"Registered {registered_count} Autobyteus models")
+                        llm_model = LLMModel(
+                            name=model_info["name"],
+                            value=model_info["value"],
+                            provider=LLMProvider(model_info["provider"]),
+                            llm_class=AutobyteusLLM,
+                            canonical_name=model_info["canonical_name"],
+                            runtime=LLMRuntime.AUTOBYTEUS,
+                            host_url=host_url,
+                            default_config=llm_config
+                        )
+                        
+                        LLMFactory.register_model(llm_model)
+                        host_registered_count += 1
+                        
+                    except Exception as e:
+                        logger.error(f"Failed to register Autobyteus model '{model_info.get('name')}' from {host_url}: {e}")
+                
+                if host_registered_count > 0:
+                    logger.info(f"Registered {host_registered_count} models from Autobyteus host {host_url}")
+                total_registered_count += host_registered_count
+            
+            if total_registered_count > 0:
+                 logger.info(f"Finished Autobyteus discovery. Total models registered: {total_registered_count}")
 
         except Exception as e:
-            logger.error(f"Discovery failed: {str(e)}", exc_info=True)
+            logger.error(f"An unexpected error occurred during Autobyteus model discovery: {e}", exc_info=True)
 
     @staticmethod
     def _validate_server_response(response: Dict[str, Any]) -> bool:

autobyteus/llm/llm_factory.py

@@ -5,75 +5,48 @@ import inspect
 from autobyteus.llm.autobyteus_provider import AutobyteusModelProvider
 from autobyteus.llm.models import LLMModel, ModelInfo, ProviderModelGroup
 from autobyteus.llm.providers import LLMProvider
+from autobyteus.llm.runtimes import LLMRuntime
 from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
 from autobyteus.llm.base_llm import BaseLLM
 
 from autobyteus.llm.api.claude_llm import ClaudeLLM
 from autobyteus.llm.api.mistral_llm import MistralLLM
 from autobyteus.llm.api.openai_llm import OpenAILLM
-from autobyteus.llm.api.ollama_llm import OllamaLLM
 from autobyteus.llm.api.deepseek_llm import DeepSeekLLM
 from autobyteus.llm.api.grok_llm import GrokLLM
 from autobyteus.llm.api.kimi_llm import KimiLLM
 from autobyteus.llm.ollama_provider import OllamaModelProvider
+from autobyteus.llm.lmstudio_provider import LMStudioModelProvider
 from autobyteus.utils.singleton import SingletonMeta
 
 logger = logging.getLogger(__name__)
 
 class LLMFactory(metaclass=SingletonMeta):
     _models_by_provider: Dict[LLMProvider, List[LLMModel]] = {}
+    _models_by_identifier: Dict[str, LLMModel] = {}
     _initialized = False
 
-    @staticmethod
-    def register(model: LLMModel):
-        LLMFactory.register_model(model)
-
     @staticmethod
     def ensure_initialized():
-        """
-        Ensures the factory is initialized before use.
-        """
+        """Ensures the factory is initialized before use."""
         if not LLMFactory._initialized:
             LLMFactory._initialize_registry()
             LLMFactory._initialized = True
 
     @staticmethod
     def reinitialize():
-        """
-        Reinitializes the model registry by resetting the initialization state
-        and reinitializing the registry.
-        
-        This is useful when new provider API keys are configured and
-        we need to discover models that might be available with the new keys.
-        
-        Returns:
-            bool: True if reinitialization was successful, False otherwise.
-        """
-        try:
-            logger.info("Reinitializing LLM model registry...")
-            
-            # Reset the initialized flag
-            LLMFactory._initialized = False
-            
-            # Clear existing models registry
-            LLMFactory._models_by_provider = {}
-            
-            # Reinitialize the registry
-            LLMFactory.ensure_initialized()
-            
-            logger.info("LLM model registry reinitialized successfully")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to reinitialize LLM model registry: {str(e)}")
-            return False
+        """Reinitializes the model registry."""
+        logger.info("Reinitializing LLM model registry...")
+        LLMFactory._initialized = False
+        LLMFactory._models_by_provider.clear()
+        LLMFactory._models_by_identifier.clear()
+        LLMFactory.ensure_initialized()
+        logger.info("LLM model registry reinitialized successfully.")
 
     @staticmethod
     def _initialize_registry():
-        """
-        Initialize the registry with supported models, discover plugins,
-        organize models by provider, and assign models as attributes on LLMModel.
-        """
-        # Organize supported models by provider sections
+        """Initializes the registry with built-in models and discovers runtime models."""
+        # Hardcoded direct-API models. Runtime defaults to API.
         supported_models = [
             # OPENAI Provider Models
             LLMModel(
@@ -305,133 +278,124 @@ class LLMFactory(metaclass=SingletonMeta):
         for model in supported_models:
             LLMFactory.register_model(model)
 
+        # Discover models from runtimes
         OllamaModelProvider.discover_and_register()
+        LMStudioModelProvider.discover_and_register()
         AutobyteusModelProvider.discover_and_register()
 
     @staticmethod
     def register_model(model: LLMModel):
-        """
-        Register a new LLM model, storing it under its provider category.
-        If a model with the same name already exists, it will be replaced.
-        """
-        # Using a flat list of all models to check for existing model by name
-        all_models = [m for models in LLMFactory._models_by_provider.values() for m in models]
-        
-        for existing_model in all_models:
-            if existing_model.name == model.name:
-                logger.warning(f"Model with name '{model.name}' is being redefined.")
-                # Remove the old model from its provider list
-                LLMFactory._models_by_provider[existing_model.provider].remove(existing_model)
-                break
+        """Registers a new LLM model."""
+        identifier = model.model_identifier
+        if identifier in LLMFactory._models_by_identifier:
+            logger.debug(f"Redefining model with identifier '{identifier}'.")
+            # Remove old model from provider group to replace it
+            old_model = LLMFactory._models_by_identifier[identifier]
+            if old_model.provider in LLMFactory._models_by_provider:
+                # This check is needed because a model might be in _models_by_identifier but not yet in _models_by_provider if re-registering
+                if old_model in LLMFactory._models_by_provider[old_model.provider]:
+                    LLMFactory._models_by_provider[old_model.provider].remove(old_model)
 
-        models = LLMFactory._models_by_provider.setdefault(model.provider, [])
-        models.append(model)
+        LLMFactory._models_by_identifier[identifier] = model
+        LLMFactory._models_by_provider.setdefault(model.provider, []).append(model)
 
     @staticmethod
     def create_llm(model_identifier: str, llm_config: Optional[LLMConfig] = None) -> BaseLLM:
         """
-        Create an LLM instance for the specified model identifier.
-        
-        Args:
-            model_identifier (str): The model name to create an instance for.
-            llm_config (Optional[LLMConfig]): Configuration for the LLM. If None,
-                                             the model's default configuration is used.
-        
-        Returns:
-            BaseLLM: An instance of the LLM.
-        
-        Raises:
-            ValueError: If the model is not supported.
+        Creates an LLM instance for the specified unique model identifier.
+        Raises an error if the identifier is not found or if a non-unique name is provided.
         """
         LLMFactory.ensure_initialized()
-        for models in LLMFactory._models_by_provider.values():
-            for model_instance in models:
-                if model_instance.name == model_identifier:
-                    return model_instance.create_llm(llm_config)
-        raise ValueError(f"Unsupported model: {model_identifier}")
+        
+        # First, try a direct lookup by the unique model_identifier
+        model = LLMFactory._models_by_identifier.get(model_identifier)
+        if model:
+            return model.create_llm(llm_config)
 
-    @staticmethod
-    def get_all_models() -> List[str]:
-        """
-        Returns a list of all registered model values.
-        """
-        LLMFactory.ensure_initialized()
-        all_models = []
-        for models in LLMFactory._models_by_provider.values():
-            all_models.extend(model.name for model in models)
-        return all_models
+        # If not found, check if the user provided a non-unique name by mistake
+        found_by_name = [m for m in LLMFactory._models_by_identifier.values() if m.name == model_identifier]
+        if len(found_by_name) > 1:
+            identifiers = [m.model_identifier for m in found_by_name]
+            raise ValueError(
+                f"The model name '{model_identifier}' is ambiguous. Please use one of the unique "
+                f"model identifiers: {identifiers}"
+            )
+        
+        raise ValueError(f"Model with identifier '{model_identifier}' not found.")
 
-    @staticmethod
-    def get_all_providers() -> Set[LLMProvider]:
-        """
-        Returns a set of all available LLM providers.
-        """
-        LLMFactory.ensure_initialized()
-        return set(LLMProvider)
+    # --- New Public API ---
 
     @staticmethod
-    def get_models_by_provider(provider: LLMProvider) -> List[str]:
-        """
-        Returns a list of all model values for a specific provider.
-        """
+    def list_available_models() -> List[ModelInfo]:
+        """Returns a list of all available models with their detailed info."""
         LLMFactory.ensure_initialized()
-        return [model.value for model in LLMFactory._models_by_provider.get(provider, [])]
+        models = sorted(LLMFactory._models_by_identifier.values(), key=lambda m: m.model_identifier)
+        return [
+            ModelInfo(
+                model_identifier=m.model_identifier,
+                display_name=m.name,
+                value=m.value,
+                canonical_name=m.canonical_name,
+                provider=m.provider.value,
+                runtime=m.runtime.value,
+                host_url=m.host_url
+            )
+            for m in models
+        ]
 
     @staticmethod
-    def get_models_for_provider(provider: LLMProvider) -> List[LLMModel]:
-        """
-        Returns a list of LLMModel instances for a specific provider.
-        """
+    def list_models_by_provider(provider: LLMProvider) -> List[ModelInfo]:
+        """Returns a list of available models for a specific provider."""
         LLMFactory.ensure_initialized()
-        return LLMFactory._models_by_provider.get(provider, [])
+        provider_models = sorted(
+            [m for m in LLMFactory._models_by_identifier.values() if m.provider == provider],
+            key=lambda m: m.model_identifier
+        )
+        return [
+            ModelInfo(
+                model_identifier=m.model_identifier,
+                display_name=m.name,
+                value=m.value,
+                canonical_name=m.canonical_name,
+                provider=m.provider.value,
+                runtime=m.runtime.value,
+                host_url=m.host_url
+            )
+            for m in provider_models
+        ]
 
     @staticmethod
-    def get_canonical_name(model_name: str) -> Optional[str]:
-        """
-        Get the canonical name for a model by its name.
-        
-        Args:
-            model_name (str): The model name (e.g., "gpt_4o")
-            
-        Returns:
-            Optional[str]: The canonical name if found, None otherwise
-        """
+    def list_models_by_runtime(runtime: LLMRuntime) -> List[ModelInfo]:
+        """Returns a list of available models for a specific runtime."""
         LLMFactory.ensure_initialized()
-        for models in LLMFactory._models_by_provider.values():
-            for model_instance in models:
-                if model_instance.name == model_name:
-                    return model_instance.canonical_name
-        return None
+        runtime_models = sorted(
+            [m for m in LLMFactory._models_by_identifier.values() if m.runtime == runtime],
+            key=lambda m: m.model_identifier
+        )
+        return [
+            ModelInfo(
+                model_identifier=m.model_identifier,
+                display_name=m.name,
+                value=m.value,
+                canonical_name=m.canonical_name,
+                provider=m.provider.value,
+                runtime=m.runtime.value,
+                host_url=m.host_url
+            )
+            for m in runtime_models
+        ]
 
     @staticmethod
-    def get_models_grouped_by_provider() -> List[ProviderModelGroup]:
+    def get_canonical_name(model_identifier: str) -> Optional[str]:
         """
-        Returns a list of all providers, each with a list of its available models,
-        sorted by provider name and model name. Providers with no models are included
-        with an empty model list.
+        Retrieves the canonical name for a given model identifier.
         """
         LLMFactory.ensure_initialized()
-        result: List[ProviderModelGroup] = []
-        # Sort all providers from the enum by name for consistent order
-        all_providers_sorted = sorted(list(LLMProvider), key=lambda p: p.name)
+        model = LLMFactory._models_by_identifier.get(model_identifier)
+        if model:
+            return model.canonical_name
         
-        for provider in all_providers_sorted:
-            # Get models for the current provider, defaults to [] if none are registered
-            models = LLMFactory._models_by_provider.get(provider, [])
-            
-            # Sort the models for this provider by name
-            sorted_models = sorted(models, key=lambda model: model.name)
-            
-            model_infos = [
-                ModelInfo(name=model.name, canonical_name=model.canonical_name)
-                for model in sorted_models
-            ]
-            
-            result.append(ProviderModelGroup(
-                provider=provider.name,
-                models=model_infos
-            ))
-            
-        return result
+        logger.warning(f"Could not find model with identifier '{model_identifier}' to get its canonical name.")
+        return None
 
 default_llm_factory = LLMFactory()