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

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"))
 
 

lollms_client/tti_bindings/diffusers/__init__.py

@@ -126,25 +126,24 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         "torch_dtype_str": "auto",  # "auto", "float16", "bfloat16", "float32"
         "use_safetensors": True,
         "scheduler_name": "default",
-        "safety_checker_on": True, # Note: Diffusers default is ON
+        "safety_checker_on": True,  # Note: Diffusers default is ON
         "num_inference_steps": 25,
         "guidance_scale": 7.5,
-        "default_width": 768, # Default for SD 2.1 base
-        "default_height": 768, # Default for SD 2.1 base
+        "default_width": 768,  # Default for SD 2.1 base
+        "default_height": 768,  # Default for SD 2.1 base
         "seed": -1,  # -1 for random on each call
         "enable_cpu_offload": False,
         "enable_sequential_cpu_offload": False,
-        "enable_xformers": False, # Explicit opt-in for xformers
+        "enable_xformers": False,  # Explicit opt-in for xformers
         "hf_variant": None,  # e.g., "fp16"
         "hf_token": None,
         "local_files_only": False,
     }
 
-
     def __init__(self,
                  config: Optional[Dict[str, Any]] = None,
                  lollms_paths: Optional[Dict[str, Union[str, Path]]] = None,
-                 **kwargs # Catches other potential parameters like 'service_key' or 'client_id'
+                 **kwargs  # Catches other potential parameters like 'service_key' or 'client_id'
                  ):
         """
         Initialize the Diffusers TTI binding.
@@ -157,7 +156,7 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
             **kwargs: Catches other parameters (e.g. service_key).
         """
         super().__init__(binding_name="diffusers")
-        
+
         if not DIFFUSERS_AVAILABLE:
             ASCIIColors.error("Diffusers library or its dependencies (torch, Pillow, transformers) are not installed or failed to import.")
             ASCIIColors.info("Attempting to install/verify packages...")
@@ -171,7 +170,7 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
                 globals()['AutoPipelineForText2Image'] = _AutoPipelineForText2Image
                 globals()['DiffusionPipeline'] = _DiffusionPipeline
                 globals()['Image'] = _Image
-                
+
                 # Re-populate torch dtype maps if torch was just loaded
                 global TORCH_DTYPE_MAP_STR_TO_OBJ, TORCH_DTYPE_MAP_OBJ_TO_STR
                 TORCH_DTYPE_MAP_STR_TO_OBJ = {
@@ -189,27 +188,32 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
                     f"Error: {e}"
                 ) from e
 
+        # Merge configs, lollms_paths, and kwargs
         self.config = {**self.DEFAULT_CONFIG, **(config or {}), **kwargs}
-        self.lollms_paths = {k: Path(v) for k, v in lollms_paths.items()} if lollms_paths else {}
-        
+        self.lollms_paths = {k: Path(v) for k, v in (lollms_paths or {}).items()} if lollms_paths else {}
+
         self.pipeline: Optional[DiffusionPipeline] = None
-        self.current_model_id_or_path = None # To track if model needs reload
+        self.current_model_id_or_path = None  # To track if model needs reload
 
         # Resolve auto settings for device and dtype
         if self.config["device"].lower() == "auto":
-            if torch.cuda.is_available(): self.config["device"] = "cuda"
-            elif torch.backends.mps.is_available(): self.config["device"] = "mps"
-            else: self.config["device"] = "cpu"
-        
+            if torch.cuda.is_available():
+                self.config["device"] = "cuda"
+            elif torch.backends.mps.is_available():
+                self.config["device"] = "mps"
+            else:
+                self.config["device"] = "cpu"
+
         if self.config["torch_dtype_str"].lower() == "auto":
-            if self.config["device"] == "cpu": self.config["torch_dtype_str"] = "float32" # CPU usually float32
-            else: self.config["torch_dtype_str"] = "float16" # Common default for GPU
+            if self.config["device"] == "cpu":
+                self.config["torch_dtype_str"] = "float32"  # CPU usually float32
+            else:
+                self.config["torch_dtype_str"] = "float16"  # Common default for GPU
 
         self.torch_dtype = TORCH_DTYPE_MAP_STR_TO_OBJ.get(self.config["torch_dtype_str"].lower(), torch.float32)
-        if self.torch_dtype == "auto": # Should have been resolved above
-             self.torch_dtype = torch.float16 if self.config["device"] != "cpu" else torch.float32
-             self.config["torch_dtype_str"] = TORCH_DTYPE_MAP_OBJ_TO_STR.get(self.torch_dtype, "float32")
-
+        if self.torch_dtype == "auto":  # Should have been resolved above
+            self.torch_dtype = torch.float16 if self.config["device"] != "cpu" else torch.float32
+            self.config["torch_dtype_str"] = TORCH_DTYPE_MAP_OBJ_TO_STR.get(self.torch_dtype, "float32")
 
         # For potential lollms client specific features
         self.client_id = kwargs.get("service_key", kwargs.get("client_id", "diffusers_client_user"))

lollms_client/tti_bindings/gemini/__init__.py

@@ -0,0 +1,215 @@
+# lollms_client/tti_bindings/gemini/__init__.py
+import sys
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import json
+
+try:
+    import pipmaster as pm
+    # google-cloud-aiplatform is the main dependency for Vertex AI
+    pm.ensure_packages(['google-cloud-aiplatform', 'Pillow'])
+    import vertexai
+    from vertexai.preview.vision_models import ImageGenerationModel
+    from google.api_core import exceptions as google_exceptions
+    GEMINI_AVAILABLE = True
+except ImportError as e:
+    GEMINI_AVAILABLE = False
+    _gemini_installation_error = e
+
+# Defines the binding name for the manager
+BindingName = "GeminiTTIBinding_Impl"
+
+# Known Imagen models on Vertex AI
+IMAGEN_MODELS = ["imagegeneration@006", "imagegeneration@005", "imagegeneration@002"]
+
+class GeminiTTIBinding_Impl(LollmsTTIBinding):
+    """
+    Concrete implementation of LollmsTTIBinding for Google's Imagen models via Vertex AI.
+    """
+    DEFAULT_CONFIG = {
+        "project_id": None,
+        "location": "us-central1",
+        "model_name": IMAGEN_MODELS[0],
+        "seed": -1, # -1 for random
+        "guidance_scale": 7.5,
+        "number_of_images": 1
+    }
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None, **kwargs):
+        """
+        Initialize the Gemini (Vertex AI Imagen) TTI binding.
+
+        Args:
+            config (Optional[Dict[str, Any]]): Configuration dictionary. Overrides DEFAULT_CONFIG.
+            **kwargs: Catches other potential parameters.
+        """
+        super().__init__(binding_name="gemini")
+
+        if not GEMINI_AVAILABLE:
+            raise ImportError(
+                "Gemini (Vertex AI) binding dependencies are not met. "
+                "Please ensure 'google-cloud-aiplatform' is installed. "
+                f"Error: {_gemini_installation_error}"
+            )
+        
+        self.config = {**self.DEFAULT_CONFIG, **(config or {}), **kwargs}
+        self.model: Optional[ImageGenerationModel] = None
+
+        self._initialize_client()
+
+    def _initialize_client(self):
+        """Initializes the Vertex AI client and loads the model."""
+        project_id = self.config.get("project_id")
+        location = self.config.get("location")
+        model_name = self.config.get("model_name")
+
+        if not project_id:
+            raise ValueError("Google Cloud 'project_id' is required for the Gemini (Vertex AI) binding.")
+        
+        ASCIIColors.info("Initializing Vertex AI client...")
+        try:
+            vertexai.init(project=project_id, location=location)
+            self.model = ImageGenerationModel.from_pretrained(model_name)
+            ASCIIColors.green(f"Vertex AI initialized successfully. Loaded model: {model_name}")
+        except google_exceptions.PermissionDenied as e:
+            trace_exception(e)
+            raise Exception(
+                "Authentication failed. Ensure you have run 'gcloud auth application-default login' "
+                "and that the Vertex AI API is enabled for your project."
+            ) from e
+        except Exception as e:
+            trace_exception(e)
+            raise Exception(f"Failed to initialize Vertex AI client: {e}") from e
+
+    def _validate_dimensions(self, width: int, height: int) -> None:
+        """Validates image dimensions against Imagen 2 constraints."""
+        if not (256 <= width <= 1536 and width % 64 == 0):
+            raise ValueError(f"Invalid width: {width}. Must be between 256 and 1536 and a multiple of 64.")
+        if not (256 <= height <= 1536 and height % 64 == 0):
+            raise ValueError(f"Invalid height: {height}. Must be between 256 and 1536 and a multiple of 64.")
+        if width * height > 1536 * 1536: # Max pixels might be more constrained, 1536*1536 is a safe upper bound.
+             raise ValueError(f"Invalid dimensions: {width}x{height}. The total number of pixels cannot exceed 1536*1536.")
+
+    def generate_image(self,
+                       prompt: str,
+                       negative_prompt: Optional[str] = "",
+                       width: int = 1024,
+                       height: int = 1024,
+                       **kwargs) -> bytes:
+        """
+        Generates image data using the Vertex AI Imagen model.
+
+        Args:
+            prompt (str): The positive text prompt.
+            negative_prompt (Optional[str]): The negative prompt.
+            width (int): Image width. Must be 256-1536 and a multiple of 64.
+            height (int): Image height. Must be 256-1536 and a multiple of 64.
+            **kwargs: Additional parameters:
+                      - seed (int)
+                      - guidance_scale (float)
+        Returns:
+            bytes: The generated image data (PNG format).
+        Raises:
+            Exception: If the request fails or image generation fails.
+        """
+        if not self.model:
+            raise RuntimeError("Vertex AI model is not loaded. Cannot generate image.")
+
+        self._validate_dimensions(width, height)
+
+        seed = kwargs.get("seed", self.config["seed"])
+        guidance_scale = kwargs.get("guidance_scale", self.config["guidance_scale"])
+        
+        # Use -1 for random seed, otherwise pass the integer value.
+        gen_seed = seed if seed != -1 else None
+
+        gen_params = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "number_of_images": 1, # This binding returns one image
+            "width": width,
+            "height": height,
+            "guidance_scale": guidance_scale,
+        }
+        if gen_seed is not None:
+            gen_params["seed"] = gen_seed
+
+        ASCIIColors.info(f"Generating image with prompt: '{prompt[:100]}...'")
+        ASCIIColors.debug(f"Imagen generation parameters: {gen_params}")
+
+        try:
+            response = self.model.generate_images(**gen_params)
+            
+            if not response.images:
+                raise Exception("Image generation resulted in no images. This may be due to safety filters.")
+
+            img_bytes = response.images[0]._image_bytes
+            return img_bytes
+
+        except google_exceptions.InvalidArgument as e:
+            trace_exception(e)
+            raise ValueError(f"Invalid argument sent to Vertex AI API: {e.message}") from e
+        except google_exceptions.GoogleAPICallError as e:
+            trace_exception(e)
+            raise Exception(f"A Google API call error occurred: {e.message}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise Exception(f"Imagen image generation failed: {e}") from e
+
+    def list_services(self, **kwargs) -> List[Dict[str, str]]:
+        """
+        Lists available Imagen models supported by this binding.
+        """
+        services = []
+        for model_name in IMAGEN_MODELS:
+            services.append({
+                "name": model_name,
+                "caption": f"Google Imagen 2 ({model_name})",
+                "help": "High-quality text-to-image model from Google, available on Vertex AI."
+            })
+        return services
+
+    def get_settings(self, **kwargs) -> List[Dict[str, Any]]:
+        """
+        Retrieves the current configurable settings for the binding.
+        """
+        return [
+            {"name": "project_id", "type": "str", "value": self.config["project_id"], "description": "Your Google Cloud project ID."},
+            {"name": "location", "type": "str", "value": self.config["location"], "description": "Google Cloud region for the project (e.g., 'us-central1')."},
+            {"name": "model_name", "type": "str", "value": self.config["model_name"], "description": "The Imagen model version to use.", "options": IMAGEN_MODELS},
+            {"name": "seed", "type": "int", "value": self.config["seed"], "description": "Default seed for generation (-1 for random)."},
+            {"name": "guidance_scale", "type": "float", "value": self.config["guidance_scale"], "description": "Default guidance scale (CFG). Higher values follow the prompt more strictly."},
+        ]
+
+    def set_settings(self, settings: Union[Dict[str, Any], List[Dict[str, Any]]], **kwargs) -> bool:
+        """
+        Applies new settings to the binding. Re-initializes the client if needed.
+        """
+        if isinstance(settings, list):
+            parsed_settings = {item["name"]: item["value"] for item in settings if "name" in item and "value" in item}
+        elif isinstance(settings, dict):
+            parsed_settings = settings
+        else:
+            ASCIIColors.error("Invalid settings format. Expected a dictionary or list of dictionaries.")
+            return False
+
+        needs_reinit = False
+        for key, value in parsed_settings.items():
+            if key in self.config and self.config[key] != value:
+                self.config[key] = value
+                ASCIIColors.info(f"Setting '{key}' changed to: {value}")
+                if key in ["project_id", "location", "model_name"]:
+                    needs_reinit = True
+        
+        if needs_reinit:
+            try:
+                self._initialize_client()
+                ASCIIColors.green("Vertex AI client re-initialized successfully with new settings.")
+            except Exception as e:
+                ASCIIColors.error(f"Failed to re-initialize client with new settings: {e}")
+                # Optionally, revert to old config here to maintain a working state
+                return False
+        
+        return True

lollms_client/tti_bindings/lollms/__init__.py

@@ -9,15 +9,12 @@ from ascii_colors import trace_exception, ASCIIColors
 import json # Added for potential error parsing
 
 # Defines the binding name for the manager
-BindingName = "LollmsTTIBinding_Impl"
-
-class LollmsTTIBinding_Impl(LollmsTTIBinding):
+BindingName = "LollmsWebuiTTIBinding_Impl"
+class LollmsWebuiTTIBinding_Impl(LollmsTTIBinding):
     """Concrete implementation of the LollmsTTIBinding for the standard LOLLMS server."""
 
     def __init__(self,
-                 host_address: Optional[str] = "http://localhost:9600", # Default LOLLMS host
-                 service_key: Optional[str] = None,
-                 verify_ssl_certificate: bool = True):
+                 **kwargs):
         """
         Initialize the LOLLMS TTI binding.
 
@@ -27,12 +24,14 @@ class LollmsTTIBinding_Impl(LollmsTTIBinding):
             verify_ssl_certificate (bool): Whether to verify SSL certificates.
         """
         super().__init__(binding_name="lollms")
-        self.host_address=host_address
-        self.verify_ssl_certificate = verify_ssl_certificate
+
+        # Extract parameters from kwargs, providing defaults
+        self.host_address = kwargs.get("host_address", "http://localhost:9600")  # Default LOLLMS host
+        self.verify_ssl_certificate = kwargs.get("verify_ssl_certificate", True)
 
         # The 'service_key' here will act as the 'client_id' for TTI requests if provided.
         # This assumes the client library user provides their LOLLMS client_id here.
-        self.client_id = service_key
+        self.client_id = kwargs.get("service_key", None) # Use service_key or None
 
     def _get_client_id(self, **kwargs) -> str:
         """Helper to get client_id, prioritizing kwargs then instance default."""