lollms-client 0.32.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

lollms_client/lollms_llm_binding.py

@@ -12,11 +12,42 @@ from lollms_client.lollms_types import MSG_TYPE
 from lollms_client.lollms_discussion import LollmsDiscussion
 from lollms_client.lollms_utilities import ImageTokenizer
 import re
+import yaml
+
+from pathlib import Path
+import json
+
+def load_known_contexts():
+    """
+    Loads the known_contexts data from a JSON file.
+
+    Args:
+        file_path (str): The path to the JSON file.
+
+    Returns:
+        dict: A dictionary containing the known_contexts data, or None if an error occurs.
+    """
+    try:
+        file_path = Path(__file__).parent / "assets" / "models_ctx_sizes.json"
+        with open(file_path, "r") as f:
+            known_contexts = json.load(f)
+        return known_contexts
+    except FileNotFoundError:
+        print(f"Error: File not found at {file_path}")
+        return None
+    except json.JSONDecodeError:
+        print(f"Error: Could not decode JSON from {file_path}")
+        return None
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        return None
+
 class LollmsLLMBinding(ABC):
     """Abstract base class for all LOLLMS LLM bindings"""
     
     def __init__(self, 
-                 binding_name: Optional[str] ="unknown"
+                 binding_name: Optional[str] ="unknown",
+                 **kwargs
         ):
         """
         Initialize the LollmsLLMBinding base class.
@@ -26,6 +57,18 @@ class LollmsLLMBinding(ABC):
         """
         self.binding_name=binding_name
         self.model_name = None #Must be set by the instance
+        self.default_ctx_size = kwargs.get("ctx_size") 
+        self.default_n_predict = kwargs.get("n_predict")
+        self.default_stream = kwargs.get("stream")
+        self.default_temperature = kwargs.get("temperature")
+        self.default_top_k = kwargs.get("top_k")
+        self.default_top_p = kwargs.get("top_p")
+        self.default_repeat_penalty = kwargs.get("repeat_penalty")
+        self.default_repeat_last_n = kwargs.get("repeat_last_n")
+        self.default_seed = kwargs.get("seed")
+        self.default_n_threads = kwargs.get("n_threads")
+        self.default_streaming_callback = kwargs.get("streaming_callback")
+
     
     @abstractmethod
     def generate_text(self,
@@ -154,8 +197,38 @@ class LollmsLLMBinding(ABC):
         """
         pass
 
-    def get_ctx_size(self, model_name:str|None=None):
-        # if model_name is none use current model name
+    def get_ctx_size(self, model_name: Optional[str] = None) -> Optional[int]:
+        """
+        Retrieves context size for a model from a hardcoded list.
+
+        This method checks if the model name contains a known base model identifier
+        (e.g., 'llama3.1', 'gemma2') to determine its context length. It's intended
+        as a failsafe when the context size cannot be retrieved directly from the
+        Ollama API.
+        """
+        if model_name is None:
+            model_name = self.model_name
+
+        # Hardcoded context sizes for popular models. More specific names (e.g., 'llama3.1')
+        # should appear, as they will be checked first due to the sorting logic below.
+        known_contexts = load_known_contexts()
+
+        normalized_model_name = model_name.lower().strip()
+
+        # Sort keys by length in descending order. This ensures that a more specific
+        # name like 'llama3.1' is checked before a less specific name like 'llama3'.
+        sorted_base_models = sorted(known_contexts.keys(), key=len, reverse=True)
+
+        for base_name in sorted_base_models:
+            if base_name in normalized_model_name:
+                context_size = known_contexts[base_name]
+                ASCIIColors.warning(
+                    f"Using hardcoded context size for model '{model_name}' "
+                    f"based on base name '{base_name}': {context_size}"
+                )
+                return context_size
+
+        ASCIIColors.warning(f"Context size not found for model '{model_name}' in the hardcoded list.")
         return None
 
 
@@ -349,16 +422,155 @@ class LollmsLLMBindingManager:
         if binding_class:
             return binding_class(**kwargs)
         return None
-
-    def get_available_bindings(self) -> list[str]:
+    @staticmethod
+    def _get_fallback_description(binding_name: str) -> Dict:
+        """
+        Generates a default description dictionary for a binding without a description.yaml file.
+        """
+        return {
+            "binding_name": binding_name,
+            "title": binding_name.replace("_", " ").title(),
+            "author": "Unknown",
+            "creation_date": "N/A",
+            "last_update_date": "N/A",
+            "description": f"A binding for {binding_name}. No description.yaml file was found, so common parameters are shown as a fallback.",
+            "input_parameters": [
+                {
+                    "name": "model_name",
+                    "type": "str",
+                    "description": "The model name, ID, or filename to be used.",
+                    "mandatory": False,
+                    "default": ""
+                },
+                {
+                    "name": "host_address",
+                    "type": "str",
+                    "description": "The host address of the service (for API-based bindings).",
+                    "mandatory": False,
+                    "default": ""
+                },
+                {
+                    "name": "models_path",
+                    "type": "str",
+                    "description": "The path to the models directory (for local bindings).",
+                    "mandatory": False,
+                    "default": ""
+                },
+                {
+                    "name": "service_key",
+                    "type": "str",
+                    "description": "The API key or service key for authentication (if applicable).",
+                    "mandatory": False,
+                    "default": ""
+                }
+            ]
+        }
+
+    @staticmethod
+    def get_bindings_list(llm_bindings_dir: Union[str, Path]) -> List[Dict]:
         """
-        Return list of available binding names.
+        Lists all available LLM bindings by scanning a directory, loading their
+        description.yaml file if present, or providing a default description.
+
+        Args:
+            llm_bindings_dir (Union[str, Path]): The path to the directory containing LLM binding folders.
 
         Returns:
-            list[str]: List of binding names.
+            List[Dict]: A list of dictionaries, each describing a binding.
         """
-        return [binding_dir.name for binding_dir in self.llm_bindings_dir.iterdir() if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+        bindings_dir = Path(llm_bindings_dir)
+        if not bindings_dir.is_dir():
+            return []
+
+        bindings_list = []
+        for binding_folder in bindings_dir.iterdir():
+            if binding_folder.is_dir() and (binding_folder / "__init__.py").exists():
+                binding_name = binding_folder.name
+                description_file = binding_folder / "description.yaml"
+                
+                binding_info = {}
+                if description_file.exists():
+                    try:
+                        with open(description_file, 'r', encoding='utf-8') as f:
+                            binding_info = yaml.safe_load(f)
+                        binding_info['binding_name'] = binding_name
+                    except Exception as e:
+                        print(f"Error loading description.yaml for {binding_name}: {e}")
+                        binding_info = LollmsLLMBindingManager._get_fallback_description(binding_name)
+                else:
+                    binding_info = LollmsLLMBindingManager._get_fallback_description(binding_name)
+                
+                bindings_list.append(binding_info)
 
-def get_available_bindings():
-    bindings_dir = Path(__file__).parent/"llm_bindings"
-    return [binding_dir.name for binding_dir in bindings_dir.iterdir() if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+        return sorted(bindings_list, key=lambda b: b.get('title', b['binding_name']))
+    
+    def get_available_bindings(self) -> List[Dict]:
+        """
+        Retrieves a list of all available LLM bindings with their full descriptions.
+
+        This method scans the configured `llm_bindings_dir`, parsing the `description.yaml`
+        file for each valid binding. If a `description.yaml` is missing, a fallback
+        description with common parameters is generated. This is the primary method
+        for discovering available bindings and their configuration requirements.
+
+        Returns:
+            List[Dict]: 
+                A list of dictionaries, where each dictionary represents the
+                full description of an available binding.
+
+                Each dictionary contains the following keys:
+                - ``binding_name`` (str): The programmatic name of the binding (its folder name).
+                - ``title`` (str): A user-friendly title for the binding.
+                - ``author`` (str): The creator of the binding.
+                - ``creation_date`` (str): The date the binding was created.
+                - ``last_update_date`` (str): The date of the last major update.
+                - ``description`` (str): A detailed explanation of the binding's purpose.
+                - ``input_parameters`` (List[Dict]): A list of parameters required to
+                  configure the binding. Each parameter is a dictionary with:
+                    - ``name`` (str): The parameter's name (e.g., 'model_name').
+                    - ``type`` (str): The expected data type ('str', 'int', 'float', 'bool').
+                    - ``description`` (str): A user-friendly description of the parameter.
+                    - ``mandatory`` (bool): True if the parameter must be provided.
+                    - ``default``: The default value for the parameter.
+
+        Example of a returned dictionary in the list:
+        .. code-block:: python
+
+            {
+                "binding_name": "ollama",
+                "title": "Ollama",
+                "author": "ParisNeo",
+                ...
+                "input_parameters": [
+                    {
+                        "name": "host_address",
+                        "type": "str",
+                        "description": "The URL of the Ollama server.",
+                        "mandatory": True,
+                        "default": "http://localhost:11434"
+                    },
+                    ...
+                ]
+            }
+        """
+        return LollmsLLMBindingManager.get_bindings_list(self.llm_bindings_dir)
+
+def get_available_bindings(llm_bindings_dir: Union[str, Path] = None) -> List[Dict]:
+    """
+    Lists all available LLM bindings with their detailed descriptions.
+
+    This function serves as a primary entry point for discovering what bindings
+    are available and how to configure them.
+
+    Args:
+        llm_bindings_dir (Union[str, Path], optional): 
+            The path to the LLM bindings directory. If None, it defaults to the
+            'llm_bindings' subdirectory relative to this file. 
+            Defaults to None.
+
+    Returns:
+        List[Dict]: A list of dictionaries, each describing a binding.
+    """
+    if llm_bindings_dir is None:
+        llm_bindings_dir = Path(__file__).parent / "llm_bindings"
+    return LollmsLLMBindingManager.get_bindings_list(llm_bindings_dir)

lollms_client/lollms_mcp_binding.py

@@ -4,7 +4,7 @@ import importlib
 from pathlib import Path
 from typing import Optional, List, Dict, Any, Union
 from ascii_colors import trace_exception, ASCIIColors
-
+import yaml
 class LollmsMCPBinding(ABC):
     """
     Abstract Base Class for LOLLMS Model Context Protocol (MCP) Bindings.
@@ -185,6 +185,7 @@ class LollmsMCPBindingManager:
                 return None
         return None
 
+
     def get_available_bindings(self) -> List[str]:
         """
         Return list of available MCP binding names based on subdirectories.
@@ -195,4 +196,34 @@ class LollmsMCPBindingManager:
             for item in self.mcp_bindings_dir.iterdir():
                 if item.is_dir() and (item / "__init__.py").exists():
                     available.append(item.name)
-        return available
+        return available
+
+    def get_binding_description(self, binding_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Loads and returns the content of the description.yaml file for a given binding.
+
+        Args:
+            binding_name (str): The name of the binding.
+
+        Returns:
+            Optional[Dict[str, Any]]: A dictionary with the parsed YAML content, or None if the file doesn't exist or is invalid.
+        """
+        binding_dir = self.mcp_bindings_dir / binding_name
+        description_file = binding_dir / "description.yaml"
+
+        if not description_file.exists():
+            ASCIIColors.warning(f"No description.yaml found for MCP binding '{binding_name}'.")
+            return None
+
+        try:
+            with open(description_file, 'r', encoding='utf-8') as f:
+                description = yaml.safe_load(f)
+            return description
+        except yaml.YAMLError as e:
+            ASCIIColors.error(f"Error parsing description.yaml for MCP binding '{binding_name}': {e}")
+            trace_exception(e)
+            return None
+        except Exception as e:
+            ASCIIColors.error(f"Error reading description.yaml for MCP binding '{binding_name}': {e}")
+            trace_exception(e)
+            return None

lollms_client/mcp_bindings/local_mcp/__init__.py

@@ -21,15 +21,16 @@ class LocalMCPBinding(LollmsMCPBinding):
     """
 
     def __init__(self,
-                 tools_folder_path: str|Path|None = None):
+                 **kwargs: Any
+                 ):
         """
         Initialize the LocalMCPBinding.
 
         Args:
-            binding_name (str): The name of this binding.
             tools_folder_path (str|Path) a folder where to find tools
         """
         super().__init__(binding_name="LocalMCP")
+        tools_folder_path = kwargs.get("tools_folder_path")
         if tools_folder_path:
             try:
                 self.tools_folder_path: Optional[Path] = Path(tools_folder_path)

lollms_client/mcp_bindings/remote_mcp/__init__.py

@@ -27,8 +27,8 @@ class RemoteMCPBinding(LollmsMCPBinding):
     Tools from all connected servers are aggregated and prefixed with the server's alias.
     """
     def __init__(self,
-                 servers_infos: Dict[str, Dict[str, Any]],
-                 **other_config_params: Any):
+                 **kwargs: Any
+                 ):
         """
         Initializes the binding to connect to multiple MCP servers.
 
@@ -41,10 +41,11 @@ class RemoteMCPBinding(LollmsMCPBinding):
                     "main_server": {"server_url": "http://localhost:8787", "auth_config": {}},
                     "experimental_server": {"server_url": "http://test.server:9000"}
                 }
-            **other_config_params (Any): Additional configuration parameters.
+            **kwargs (Any): Additional configuration parameters.
         """
         super().__init__(binding_name="remote_mcp")
         # initialization in case no servers are present
+        servers_infos: Dict[str, Dict[str, Any]] = kwargs.get("servers_infos", {})
         self.servers = None
         if not MCP_LIBRARY_AVAILABLE:
             ASCIIColors.error(f"{self.binding_name}: MCP library not available. This binding will be disabled.")
@@ -56,8 +57,8 @@ class RemoteMCPBinding(LollmsMCPBinding):
 
         ### NEW: Store the overall configuration
         self.config = {
-            "servers_infos": servers_infos,
-            **other_config_params
+            "servers_infos": kwargs.get("servers_infos"),
+            **kwargs
         }
 
         ### NEW: State management for multiple servers.

lollms_client/mcp_bindings/standard_mcp/__init__.py

@@ -48,12 +48,10 @@ class StandardMCPBinding(LollmsMCPBinding):
     """
 
     def __init__(self,
-                 initial_servers: Optional[Dict[str, Dict[str, Any]]] = None,
-                 **other_config_params: Any):
+                 **kwargs: Any):
         super().__init__(binding_name="standard_mcp")
-
-        self.config = {"initial_servers": initial_servers if initial_servers else {}}
-        self.config.update(other_config_params)
+        self.config = kwargs
+        initial_servers = kwargs.get("initial_servers", {})
 
         self._server_configs: Dict[str, Dict[str, Any]] = {}
         # Type hint with ClientSession, actual obj if MCP_LIBRARY_AVAILABLE

lollms_client/stt_bindings/lollms/__init__.py

@@ -14,10 +14,8 @@ class LollmsSTTBinding_Impl(LollmsSTTBinding):
     """Concrete implementation of the LollmsSTTBinding for the standard LOLLMS server."""
 
     def __init__(self,
-                 host_address: Optional[str] = "http://localhost:9600", # Default LOLLMS host
-                 model_name: Optional[str] = None, # Default model (server decides if None)
-                 service_key: Optional[str] = None,
-                 verify_ssl_certificate: bool = True):
+                 **kwargs
+                 ):
         """
         Initialize the LOLLMS STT binding.
 
@@ -28,10 +26,10 @@ class LollmsSTTBinding_Impl(LollmsSTTBinding):
             verify_ssl_certificate (bool): Whether to verify SSL certificates.
         """
         super().__init__("lollms")
-        self.host_address=host_address
-        self.model_name=model_name
-        self.service_key=service_key
-        self.verify_ssl_certificate=verify_ssl_certificate
+        self.host_address=kwargs.get("host_address")
+        self.model_name=kwargs.get("model_name")
+        self.service_key=kwargs.get("service_key")
+        self.verify_ssl_certificate=kwargs.get("verify_ssl_certificate")
 
     def transcribe_audio(self, audio_path: Union[str, Path], model: Optional[str] = None, **kwargs) -> str:
         """

lollms_client/stt_bindings/whisper/__init__.py

@@ -70,8 +70,6 @@ class WhisperSTTBinding(LollmsSTTBinding):
     WHISPER_MODEL_SIZES = ["tiny", "tiny.en", "base", "base.en", "small", "small.en", "medium", "medium.en", "large", "large-v1", "large-v2", "large-v3"]
 
     def __init__(self,
-                 model_name: str = "base", # Default Whisper model size
-                 device: Optional[str] = None, # "cpu", "cuda", "mps", or None for auto
                  **kwargs # To catch any other LollmsSTTBinding standard args
                  ):
         """
@@ -88,7 +86,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
         if not _whisper_installed:
             raise ImportError(f"Whisper STT binding dependencies not met. Please ensure 'openai-whisper' and 'torch' are installed. Error: {_whisper_installation_error}")
 
-        self.device = device
+        self.device = kwargs.get("device",None)
         if self.device is None: # Auto-detect if not specified
             if torch.cuda.is_available():
                 self.device = "cuda"
@@ -101,7 +99,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
         
         self.loaded_model_name = None
         self.model = None
-        self._load_whisper_model(model_name)
+        self._load_whisper_model(kwargs.get("model_name", "base")) # Default to "base" if not specified
 
 
     def _load_whisper_model(self, model_name_to_load: str):

lollms_client/stt_bindings/whispercpp/__init__.py

@@ -18,20 +18,19 @@ DEFAULT_WHISPERCPP_EXE_NAMES = ["main", "whisper-cli", "whisper"] # Common names
 
 class WhisperCppSTTBinding(LollmsSTTBinding):
     def __init__(self,
-                 model_path: Union[str, Path], # Path to the GGUF Whisper model
-                 whispercpp_exe_path: Optional[Union[str, Path]] = None, # Path to whisper.cpp executable
-                 ffmpeg_path: Optional[Union[str, Path]] = None, # Path to ffmpeg executable (if not in PATH)
-                 models_search_path: Optional[Union[str, Path]] = None, # Optional dir to scan for more models
-                 default_language: str = "auto",
-                 n_threads: int = 4,
-                 # Catch LollmsSTTBinding standard args even if not directly used by this local binding
-                 host_address: Optional[str] = None, # Not used for local binding
-                 service_key: Optional[str] = None, # Not used for local binding
-                 verify_ssl_certificate: bool = True, # Not used for local binding
                  **kwargs): # Catch-all for future compatibility or specific whisper.cpp params
 
-        super().__init__(binding_name="whispercpp") 
-        
+        super().__init__(binding_name="whispercpp")
+
+        # --- Extract values from kwargs with defaults ---
+        model_path = kwargs.get("model_path")
+        whispercpp_exe_path = kwargs.get("whispercpp_exe_path")
+        ffmpeg_path = kwargs.get("ffmpeg_path")
+        models_search_path = kwargs.get("models_search_path")
+        default_language = kwargs.get("default_language", "auto")
+        n_threads = kwargs.get("n_threads", 4)
+        extra_whisper_args = kwargs.get("extra_whisper_args", [])  # e.g. ["--no-timestamps"]
+
         # --- Validate FFMPEG ---
         self.ffmpeg_exe = None
         if ffmpeg_path:
@@ -42,7 +41,7 @@ class WhisperCppSTTBinding(LollmsSTTBinding):
                 raise FileNotFoundError(f"Provided ffmpeg_path '{ffmpeg_path}' not found or not executable.")
         else:
             self.ffmpeg_exe = shutil.which("ffmpeg")
-        
+
         if not self.ffmpeg_exe:
             ASCIIColors.warning("ffmpeg not found in PATH or explicitly provided. Audio conversion will not be possible for non-WAV files or incompatible WAV files.")
             ASCIIColors.warning("Please install ffmpeg and ensure it's in your system's PATH, or provide ffmpeg_path argument.")
@@ -63,7 +62,7 @@ class WhisperCppSTTBinding(LollmsSTTBinding):
                     self.whispercpp_exe = found_path
                     ASCIIColors.info(f"Found whisper.cpp executable via PATH: {self.whispercpp_exe}")
                     break
-        
+
         if not self.whispercpp_exe:
             raise FileNotFoundError(
                 f"Whisper.cpp executable (tried: {', '.join(DEFAULT_WHISPERCPP_EXE_NAMES)}) not found in PATH or explicitly provided. "
@@ -79,11 +78,11 @@ class WhisperCppSTTBinding(LollmsSTTBinding):
                 self.model_path = Path(models_search_path, self.model_path).resolve()
             else:
                 raise FileNotFoundError(f"Whisper GGUF model file not found at '{self.model_path}'. Also checked in models_search_path if applicable.")
-        
+
         self.models_search_path = Path(models_search_path).resolve() if models_search_path else None
         self.default_language = default_language
         self.n_threads = n_threads
-        self.extra_whisper_args = kwargs.get("extra_whisper_args", []) # e.g. ["--no-timestamps"]
+        self.extra_whisper_args = extra_whisper_args
 
         ASCIIColors.green(f"WhisperCppSTTBinding initialized with model: {self.model_path}")
 

lollms_client/tti_bindings/dalle/__init__.py

@@ -35,22 +35,11 @@ DALLE_MODELS = {
         "max_prompt_length": 4000 # Characters
     }
 }
-
 class DalleTTIBinding_Impl(LollmsTTIBinding):
     """
     Concrete implementation of LollmsTTIBinding for OpenAI's DALL-E API.
     """
-
-    def __init__(self,
-                 api_key: Optional[str] = None, # Can be None to check env var
-                 model_name: str = "dall-e-3", # Default to DALL-E 3
-                 default_size: Optional[str] = None, # e.g. "1024x1024"
-                 default_quality: Optional[str] = None, # "standard" or "hd" (DALL-E 3)
-                 default_style: Optional[str] = None, # "vivid" or "natural" (DALL-E 3)
-                 host_address: str = DALLE_API_HOST, # OpenAI API host
-                 verify_ssl_certificate: bool = True,
-                 **kwargs # To catch any other lollms_client specific params like service_key/client_id
-                 ):
+    def __init__(self, **kwargs):
         """
         Initialize the DALL-E TTI binding.
 
@@ -70,44 +59,56 @@ class DalleTTIBinding_Impl(LollmsTTIBinding):
         """
         super().__init__(binding_name="dalle")
 
-        resolved_api_key = api_key
+        # Extract parameters from kwargs, providing defaults
+        self.api_key = kwargs.get("api_key")
+        self.model_name = kwargs.get("model_name")
+        self.default_size = kwargs.get("default_size")
+        self.default_quality = kwargs.get("default_quality")
+        self.default_style = kwargs.get("default_style")
+        self.host_address = kwargs.get("host_address", DALLE_API_HOST)  # Provide default
+        self.verify_ssl_certificate = kwargs.get("verify_ssl_certificate", True) # Provide default
+
+        # Resolve API key from kwargs or environment variable
+        resolved_api_key = self.api_key
         if not resolved_api_key:
             ASCIIColors.info(f"API key not provided directly, checking environment variable '{OPENAI_API_KEY_ENV_VAR}'...")
             resolved_api_key = os.environ.get(OPENAI_API_KEY_ENV_VAR)
 
         if not resolved_api_key:
             raise ValueError(f"OpenAI API key is required. Provide it directly or set the '{OPENAI_API_KEY_ENV_VAR}' environment variable.")
-        
+
         self.api_key = resolved_api_key
-        self.host_address = host_address
-        self.verify_ssl_certificate = verify_ssl_certificate
 
-        if model_name not in DALLE_MODELS:
-            raise ValueError(f"Unsupported DALL-E model: {model_name}. Supported models: {list(DALLE_MODELS.keys())}")
-        self.model_name = model_name
-        
+        # Model name validation
+        if not self.model_name:
+            raise ValueError("Model name is required.")
+        if self.model_name not in DALLE_MODELS:
+            raise ValueError(f"Unsupported DALL-E model: {self.model_name}. Supported models: {list(DALLE_MODELS.keys())}")
+
         model_props = DALLE_MODELS[self.model_name]
 
-        # Set defaults from model_props, overridden by user-provided defaults
-        self.current_size = default_size or model_props["default_size"]
+        # Size
+        self.current_size = self.default_size or model_props["default_size"]
         if self.current_size not in model_props["sizes"]:
             raise ValueError(f"Unsupported size '{self.current_size}' for model '{self.model_name}'. Supported sizes: {model_props['sizes']}")
 
+        # Quality
         if model_props["supports_quality"]:
-            self.current_quality = default_quality or model_props["default_quality"]
+            self.current_quality = self.default_quality or model_props["default_quality"]
             if self.current_quality not in model_props["qualities"]:
                 raise ValueError(f"Unsupported quality '{self.current_quality}' for model '{self.model_name}'. Supported qualities: {model_props['qualities']}")
         else:
-            self.current_quality = None # Explicitly None if not supported
+            self.current_quality = None  # Explicitly None if not supported
 
+        # Style
         if model_props["supports_style"]:
-            self.current_style = default_style or model_props["default_style"]
+            self.current_style = self.default_style or model_props["default_style"]
             if self.current_style not in model_props["styles"]:
                 raise ValueError(f"Unsupported style '{self.current_style}' for model '{self.model_name}'. Supported styles: {model_props['styles']}")
         else:
-            self.current_style = None # Explicitly None if not supported
-        
-        # For potential lollms client specific features, if `service_key` is passed as `client_id`
+            self.current_style = None  # Explicitly None if not supported
+
+        # Client ID
         self.client_id = kwargs.get("service_key", kwargs.get("client_id", "dalle_client_user"))