lollms-client 1.5.6__py3-none-any.whl → 1.7.13__py3-none-any.whl

lollms_client/lollms_mcp_binding.py

@@ -1,51 +1,32 @@
 # lollms_client/lollms_mcp_binding.py
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 from ascii_colors import trace_exception, ASCIIColors
 import yaml
-class LollmsMCPBinding(ABC):
+from lollms_client.lollms_base_binding import LollmsBaseBinding
+
+class LollmsMCPBinding(LollmsBaseBinding):
     """
     Abstract Base Class for LOLLMS Model Context Protocol (MCP) Bindings.
-
-    MCP bindings are responsible for interacting with MCP-compliant tool servers
-    or emulating MCP tool interactions locally. They handle tool discovery
-    and execution based on requests, typically orchestrated by an LLM.
     """
 
     def __init__(self,
-                 binding_name: str
+                 binding_name: str,
+                 **kwargs
                  ):
         """
         Initialize the LollmsMCPBinding.
-
-        Args:
-            binding_name (str): The unique name of this binding.
         """
-        self.binding_name = binding_name
+        super().__init__(binding_name=binding_name, **kwargs)
+        self.settings = kwargs
 
 
     @abstractmethod
     def discover_tools(self, **kwargs) -> List[Dict[str, Any]]:
         """
         Discover available tools compliant with the MCP specification.
-
-        Each tool definition should follow the MCP standard, typically including:
-        - name (str): Unique name of the tool.
-        - description (str): Natural language description of what the tool does.
-        - input_schema (dict): JSON schema defining the tool's input parameters.
-        - output_schema (dict): JSON schema defining the tool's output.
-        (Other MCP fields like `prompts`, `resources` could be supported by specific bindings)
-
-        Args:
-            **kwargs: Additional arguments specific to the binding's discovery mechanism
-                      (e.g., tool_server_url, specific_tool_names_to_filter).
-
-        Returns:
-            List[Dict[str, Any]]: A list of tool definitions. Each dictionary
-                                  should conform to the MCP tool definition structure.
-                                  Returns an empty list if no tools are found or an error occurs.
         """
         pass
 
@@ -56,35 +37,35 @@ class LollmsMCPBinding(ABC):
                      **kwargs) -> Dict[str, Any]:
         """
         Execute a specified tool with the given parameters.
-
-        The execution should adhere to the input and output schemas defined in the
-        tool's MCP definition.
-
-        Args:
-            tool_name (str): The name of the tool to execute.
-            params (Dict[str, Any]): A dictionary of parameters to pass to the tool,
-                                     conforming to the tool's `input_schema`.
-            **kwargs: Additional arguments specific to the binding's execution mechanism
-                      (e.g., timeout, user_context).
-
-        Returns:
-            Dict[str, Any]: The result of the tool execution, conforming to the
-                            tool's `output_schema`. If an error occurs during
-                            execution, the dictionary should ideally include an 'error'
-                            key with a descriptive message.
-                            Example success: {"result": "Weather is sunny"}
-                            Example error: {"error": "API call failed", "details": "..."}
         """
         pass
 
     def get_binding_config(self) -> Dict[str, Any]:
         """
         Returns the configuration of the binding.
+        """
+        return self.settings
+
+    def list_models(self) -> List[Any]:
+        """
+        For MCP, list_models returns an empty list as it primarily deals with tools.
+        Or could be implemented to return available tools as models if desired.
+        """
+        return []
+    
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
 
-        Returns:
-            Dict[str, Any]: The configuration dictionary.
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
         """
-        return self.config
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
 
 class LollmsMCPBindingManager:
     """
@@ -94,25 +75,17 @@ class LollmsMCPBindingManager:
     def __init__(self, mcp_bindings_dir: Union[str, Path] = Path(__file__).parent / "mcp_bindings"):
         """
         Initialize the LollmsMCPBindingManager.
-
-        Args:
-            mcp_bindings_dir (Union[str, Path]): Directory containing MCP binding implementations.
-                                                 Defaults to "mcp_bindings" subdirectory relative to this file.
         """
         self.mcp_bindings_dir = Path(mcp_bindings_dir)
         if not self.mcp_bindings_dir.is_absolute():
-             # If relative, assume it's relative to the parent of this file (lollms_client directory)
             self.mcp_bindings_dir = (Path(__file__).parent.parent / mcp_bindings_dir).resolve()
 
         self.available_bindings: Dict[str, type[LollmsMCPBinding]] = {}
-        ASCIIColors.info(f"LollmsMCPBindingManager initialized. Bindings directory: {self.mcp_bindings_dir}")
 
 
     def _load_binding_class(self, binding_name: str) -> Optional[type[LollmsMCPBinding]]:
         """
-        Dynamically load a specific MCP binding class from the mcp_bindings directory.
-        Assumes each binding is in a subdirectory named after the binding_name,
-        and has an __init__.py that defines a `BindingName` variable and the binding class.
+        Dynamically load a specific MCP binding class.
         """
         binding_dir = self.mcp_bindings_dir / binding_name
         if binding_dir.is_dir():
@@ -127,7 +100,6 @@ class LollmsMCPBindingManager:
                         module = importlib.util.module_from_spec(module_spec)
                         module_spec.loader.exec_module(module)
                         
-                        # Ensure BindingName is defined in the module, and it matches the class name
                         if not hasattr(module, 'BindingName'):
                             ASCIIColors.warning(f"Binding '{binding_name}' __init__.py does not define BindingName variable.")
                             return None
@@ -155,15 +127,6 @@ class LollmsMCPBindingManager:
                        ) -> Optional[LollmsMCPBinding]:
         """
         Create an instance of a specific MCP binding.
-
-        Args:
-            binding_name (str): Name of the MCP binding to create.
-            config (Optional[Dict[str, Any]]): Configuration for the binding.
-            lollms_paths (Optional[Dict[str, Union[str, Path]]]): LOLLMS specific paths.
-
-
-        Returns:
-            Optional[LollmsMCPBinding]: Binding instance or None if creation failed.
         """
         if binding_name not in self.available_bindings:
             binding_class = self._load_binding_class(binding_name)
@@ -177,6 +140,7 @@ class LollmsMCPBindingManager:
         if binding_class_to_instantiate:
             try:
                 return binding_class_to_instantiate(
+                    binding_name=binding_name,
                     **kwargs
                 )
             except Exception as e:
@@ -188,8 +152,7 @@ class LollmsMCPBindingManager:
 
     def get_available_bindings(self) -> List[str]:
         """
-        Return list of available MCP binding names based on subdirectories.
-        This method scans the directory structure.
+        Return list of available MCP binding names.
         """
         available = []
         if self.mcp_bindings_dir.is_dir():
@@ -201,12 +164,6 @@ class LollmsMCPBindingManager:
     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"
@@ -226,4 +183,19 @@ class LollmsMCPBindingManager:
         except Exception as e:
             ASCIIColors.error(f"Error reading description.yaml for MCP binding '{binding_name}': {e}")
             trace_exception(e)
-            return None
+            return None
+
+def list_binding_models(mcp_binding_name: str, mcp_binding_config: Optional[Dict[str, any]]|None = None, mcp_bindings_dir: str|Path = Path(__file__).parent / "mcp_bindings") -> List[Dict]:
+    """
+    Lists all available models/tools for a specific binding.
+    """
+    binding = LollmsMCPBindingManager(mcp_bindings_dir).create_binding(
+        binding_name=mcp_binding_name,
+        **{
+            k: v
+            for k, v in (mcp_binding_config or {}).items()
+            if k != "binding_name"
+        }
+    )
+
+    return binding.discover_tools() if binding else []

lollms_client/lollms_stt_binding.py

@@ -1,39 +1,27 @@
 # lollms_client/lollms_stt_binding.py
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 from ascii_colors import trace_exception
+import yaml
+from lollms_client.lollms_base_binding import LollmsBaseBinding
 
-class LollmsSTTBinding(ABC):
+class LollmsSTTBinding(LollmsBaseBinding):
     """Abstract base class for all LOLLMS Speech-to-Text bindings."""
 
     def __init__(self,
-                 binding_name:str="unknown"):
+                 binding_name:str="unknown",
+                 **kwargs):
         """
         Initialize the LollmsSTTBinding base class.
-
-        Args:
-            binding_name (Optional[str]): The binding name
         """
-        self.binding_name = binding_name
+        super().__init__(binding_name=binding_name, **kwargs)
 
     @abstractmethod
     def transcribe_audio(self, audio_path: Union[str, Path], model: Optional[str] = None, **kwargs) -> str:
         """
         Transcribes the audio file at the given path into text.
-
-        Args:
-            audio_path (Union[str, Path]): The path to the audio file to transcribe.
-            model (Optional[str]): The specific STT model to use (if supported by the binding).
-                                  If None, a default model might be used.
-            **kwargs: Additional binding-specific parameters (e.g., language hint).
-
-        Returns:
-            str: The transcribed text.
-
-        Raises:
-            Exception: If audio transcription fails.
         """
         pass
 
@@ -41,26 +29,27 @@ class LollmsSTTBinding(ABC):
     def list_models(self, **kwargs) -> List[str]:
         """
         Lists the available STT models supported by the binding.
+        """
+        pass
 
-        Args:
-            **kwargs: Additional binding-specific parameters.
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
 
-        Returns:
-            List[str]: A list of available STT model identifiers.
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
         """
-        pass
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
 
 class LollmsSTTBindingManager:
     """Manages STT binding discovery and instantiation."""
 
     def __init__(self, stt_bindings_dir: Union[str, Path] = Path(__file__).parent.parent / "stt_bindings"):
-        """
-        Initialize the LollmsSTTBindingManager.
-
-        Args:
-            stt_bindings_dir (Union[str, Path]): Directory containing STT binding implementations.
-                                                 Defaults to the "stt_bindings" subdirectory.
-        """
         self.stt_bindings_dir = Path(stt_bindings_dir)
         self.available_bindings = {}
 
@@ -85,17 +74,6 @@ class LollmsSTTBindingManager:
                       **kwargs) -> Optional[LollmsSTTBinding]:
         """
         Create an instance of a specific STT binding.
-
-        Args:
-            binding_name (str): Name of the STT binding to create.
-            host_address (Optional[str]): Host address for the service.
-            model_name (Optional[str]): Default model identifier.
-            service_key (Optional[str]): Authentication key for the service.
-            verify_ssl_certificate (bool): Whether to verify SSL certificates.
-            **kwargs: Additional parameters specific to the binding's __init__.
-
-        Returns:
-            Optional[LollmsSTTBinding]: Binding instance or None if creation failed.
         """
         if binding_name not in self.available_bindings:
             self._load_binding(binding_name)
@@ -103,11 +81,14 @@ class LollmsSTTBindingManager:
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
             try:
-                return binding_class(host_address=host_address,
-                                     model_name=model_name,
-                                     service_key=service_key,
-                                     verify_ssl_certificate=verify_ssl_certificate,
-                                     **kwargs)
+                # Merge specific args into kwargs to match unified init
+                kwargs.update({
+                    "host_address": host_address,
+                    "model_name": model_name,
+                    "service_key": service_key,
+                    "verify_ssl_certificate": verify_ssl_certificate
+                })
+                return binding_class(binding_name=binding_name, **kwargs)
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to instantiate STT binding {binding_name}: {str(e)}")
@@ -117,9 +98,75 @@ class LollmsSTTBindingManager:
     def get_available_bindings(self) -> list[str]:
         """
         Return list of available STT binding names based on subdirectories.
-
-        Returns:
-            list[str]: List of binding names.
         """
         return [binding_dir.name for binding_dir in self.stt_bindings_dir.iterdir()
-                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+
+
+    @staticmethod
+    def _get_fallback_description(binding_name: str) -> Dict:
+        return {
+            "binding_name": binding_name,
+            "title": binding_name.replace("_", " ").title(),
+            "author": "Unknown",
+            "version": "N/A",
+            "description": f"A binding for {binding_name}. No description.yaml file was found.",
+            "input_parameters": [
+                 {
+                    "name": "model_name",
+                    "type": "str",
+                    "description": "The model name or ID to be used.",
+                    "mandatory": False,
+                    "default": ""
+                }
+            ],
+            "generate_audio_parameters": []
+        }
+    @staticmethod
+    def get_bindings_list(stt_bindings_dir: Union[str, Path]) -> List[Dict]:
+        bindings_dir = Path(stt_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 = LollmsSTTBindingManager._get_fallback_description(binding_name)
+                else:
+                    binding_info = LollmsSTTBindingManager._get_fallback_description(binding_name)
+                
+                bindings_list.append(binding_info)
+
+        return sorted(bindings_list, key=lambda b: b.get('title', b['binding_name']))
+    
+
+def get_available_bindings(stt_bindings_dir: Union[str, Path] = None) -> List[Dict]:
+    if stt_bindings_dir is None:
+        stt_bindings_dir = Path(__file__).resolve().parent / "stt_bindings"
+    return LollmsSTTBindingManager.get_bindings_list(stt_bindings_dir)
+
+def list_binding_models(stt_binding_name: str, stt_binding_config: Optional[Dict[str, any]]|None = None, stt_bindings_dir: str|Path = Path(__file__).parent / "stt_bindings") -> List[Dict]:
+    """
+    Lists all available models for a specific binding.
+    """
+    binding = LollmsSTTBindingManager(stt_bindings_dir).create_binding(
+        binding_name=stt_binding_name,
+        **{
+            k: v
+            for k, v in (stt_binding_config or {}).items()
+            if k != "binding_name"
+        }
+    )
+
+    return binding.list_models() if binding else []

lollms_client/lollms_tti_binding.py

@@ -1,22 +1,21 @@
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 from ascii_colors import trace_exception
 import yaml
+from lollms_client.lollms_base_binding import LollmsBaseBinding
 
-class LollmsTTIBinding(ABC):
+class LollmsTTIBinding(LollmsBaseBinding):
     """Abstract base class for all LOLLMS Text-to-Image bindings."""
 
     def __init__(self,
-                 binding_name:str="unknown"):
+                 binding_name:str="unknown",
+                 **kwargs):
         """
         Initialize the LollmsTTIBinding base class.
-
-        Args:
-            binding_name (Optional[str]): The binding name
         """
-        self.binding_name = binding_name
+        super().__init__(binding_name=binding_name, **kwargs)
 
     @abstractmethod
     def generate_image(self,
@@ -27,19 +26,6 @@ class LollmsTTIBinding(ABC):
                        **kwargs) -> bytes:
         """
         Generates image data from the provided text prompt.
-
-        Args:
-            prompt (str): The positive text prompt describing the desired image.
-            negative_prompt (Optional[str]): Text prompt describing elements to avoid.
-            width (int): The desired width of the image.
-            height (int): The desired height of the image.
-            **kwargs: Additional binding-specific parameters (e.g., seed, steps, cfg_scale).
-
-        Returns:
-            bytes: The generated image data (e.g., in PNG or JPEG format).
-
-        Raises:
-            Exception: If image generation fails.
         """
         pass
 
@@ -54,21 +40,6 @@ class LollmsTTIBinding(ABC):
                    **kwargs) -> bytes:
         """
         Edits an image or a set of images based on the provided prompts.
-
-        Args:
-            images (Union[str, List[str]]): One or multiple images in URL or base64 format.
-            prompt (str): Positive prompt describing desired modifications.
-            negative_prompt (Optional[str]): Prompt describing elements to avoid.
-            mask (Optional[str]): A mask image (URL or base64). Only valid if a single image is provided.
-            width (Optional[int]): Desired width of the output. If None, binding decides.
-            height (Optional[int]): Desired height of the output. If None, binding decides.
-            **kwargs: Additional binding-specific parameters (e.g., seed, steps, cfg_scale).
-
-        Returns:
-            bytes: The edited/generated image data (e.g., in PNG or JPEG format).
-
-        Raises:
-            Exception: If image editing fails.
         """
         pass
 
@@ -83,9 +54,23 @@ class LollmsTTIBinding(ABC):
         pass
 
     @abstractmethod
-    def listModels(self) -> list:
+    def list_models(self) -> list:
         """Lists models"""
         pass
+    
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
+
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
 
     @abstractmethod
     def set_settings(self, settings: Dict[str, Any], **kwargs) -> bool:
@@ -120,7 +105,7 @@ class LollmsTTIBindingManager:
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
             try:
-                return binding_class(**kwargs)
+                return binding_class(binding_name=binding_name, **kwargs)
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to instantiate TTI binding {binding_name}: {str(e)}")
@@ -204,3 +189,18 @@ def get_available_bindings(tti_bindings_dir: Union[str, Path] = None) -> List[Di
     if tti_bindings_dir is None:
         tti_bindings_dir = Path(__file__).parent / "tti_bindings"
     return LollmsTTIBindingManager.get_bindings_list(tti_bindings_dir)
+
+def list_binding_models(tti_binding_name: str, tti_binding_config: Optional[Dict[str, any]]|None = None, tti_bindings_dir: str|Path = Path(__file__).parent / "tti_bindings") -> List[Dict]:
+    """
+    Lists all available models for a specific binding.
+    """
+    binding = LollmsTTIBindingManager(tti_bindings_dir).create_binding(
+        binding_name=tti_binding_name,
+        **{
+            k: v
+            for k, v in (tti_binding_config or {}).items()
+            if k != "binding_name"
+        }
+    )
+
+    return binding.list_models() if binding else []

lollms_client/lollms_ttm_binding.py

@@ -1,38 +1,27 @@
 # lollms_client/lollms_ttm_binding.py
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 from ascii_colors import trace_exception
+from lollms_client.lollms_base_binding import LollmsBaseBinding
 
-class LollmsTTMBinding(ABC):
+class LollmsTTMBinding(LollmsBaseBinding):
     """Abstract base class for all LOLLMS Text-to-Music bindings."""
 
     def __init__(self,
-                 binding_name:str="unknown"):
+                 binding_name:str="unknown",
+                 **kwargs):
         """
         Initialize the LollmsTTMBinding base class.
-
-        Args:
-            binding_name (Optional[str]): The binding name
         """
-        self.binding_name = binding_name
+        super().__init__(binding_name=binding_name, **kwargs)
 
 
     @abstractmethod
     def generate_music(self, prompt: str, **kwargs) -> bytes:
         """
         Generates music data from the provided text prompt.
-
-        Args:
-            prompt (str): The text prompt describing the desired music (e.g., genre, mood, instruments).
-            **kwargs: Additional binding-specific parameters (e.g., duration, style, seed).
-
-        Returns:
-            bytes: The generated music data (e.g., in WAV, MP3, or MIDI format).
-
-        Raises:
-            Exception: If music generation fails.
         """
         pass
 
@@ -40,26 +29,27 @@ class LollmsTTMBinding(ABC):
     def list_models(self, **kwargs) -> List[str]:
         """
         Lists the available TTM models or services supported by the binding.
+        """
+        pass
 
-        Args:
-            **kwargs: Additional binding-specific parameters.
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
 
-        Returns:
-            List[str]: A list of available model/service identifiers.
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
         """
-        pass
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
 
 class LollmsTTMBindingManager:
     """Manages TTM binding discovery and instantiation."""
 
     def __init__(self, ttm_bindings_dir: Union[str, Path] = Path(__file__).parent.parent / "ttm_bindings"):
-        """
-        Initialize the LollmsTTMBindingManager.
-
-        Args:
-            ttm_bindings_dir (Union[str, Path]): Directory containing TTM binding implementations.
-                                                 Defaults to the "ttm_bindings" subdirectory.
-        """
         self.ttm_bindings_dir = Path(ttm_bindings_dir)
         self.available_bindings = {}
 
@@ -80,13 +70,6 @@ class LollmsTTMBindingManager:
                       **kwargs) -> Optional[LollmsTTMBinding]:
         """
         Create an instance of a specific TTM binding.
-
-        Args:
-            binding_name (str): Name of the TTM binding to create.
-            **kwargs: Additional parameters specific to the binding's __init__.
-
-        Returns:
-            Optional[LollmsTTMBinding]: Binding instance or None if creation failed.
         """
         if binding_name not in self.available_bindings:
             self._load_binding(binding_name)
@@ -94,7 +77,7 @@ class LollmsTTMBindingManager:
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
             try:
-                return binding_class(**kwargs)
+                return binding_class(binding_name=binding_name, **kwargs)
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to instantiate TTM binding {binding_name}: {str(e)}")
@@ -104,9 +87,22 @@ class LollmsTTMBindingManager:
     def get_available_bindings(self) -> list[str]:
         """
         Return list of available TTM binding names based on subdirectories.
-
-        Returns:
-            list[str]: List of binding names.
         """
         return [binding_dir.name for binding_dir in self.ttm_bindings_dir.iterdir()
-                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+
+
+def list_binding_models(ttm_binding_name: str, ttm_binding_config: Optional[Dict[str, any]]|None = None, ttm_bindings_dir: str|Path = Path(__file__).parent / "ttm_bindings") -> List[Dict]:
+    """
+    Lists all available models for a specific binding.
+    """
+    binding = LollmsTTMBindingManager(ttm_bindings_dir).create_binding(
+        binding_name=ttm_binding_name,
+        **{
+            k: v
+            for k, v in (ttm_binding_config or {}).items()
+            if k != "binding_name"
+        }
+    )
+
+    return binding.list_models() if binding else []