lollms-client 1.4.1__py3-none-any.whl → 1.4.5__py3-none-any.whl

lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "1.4.1" # Updated version
+__version__ = "1.4.5" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/llm_bindings/novita_ai/__init__.py

@@ -0,0 +1,303 @@
+import os
+import json
+import requests
+from typing import Optional, Callable, List, Union, Dict
+
+from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+
+import pipmaster as pm
+
+# Ensure the required packages are installed
+pm.ensure_packages(["requests", "tiktoken"])
+
+import tiktoken
+
+BindingName = "NovitaAIBinding"
+API_BASE_URL = "https://api.novita.ai"
+
+# A hardcoded list of models based on Novita AI's documentation.
+# The API is OpenAI-compatible but does not provide a models listing endpoint.
+# Sourced from: https://docs.novita.ai/language-model/models
+_FALLBACK_MODELS = [
+    {'model_name': 'meta-llama/Llama-3-8B-Instruct', 'display_name': 'Llama 3 8B Instruct', 'description': 'Meta\'s Llama 3 8B instruction-tuned model.', 'owned_by': 'Meta'},
+    {'model_name': 'meta-llama/Llama-3-70B-Instruct', 'display_name': 'Llama 3 70B Instruct', 'description': 'Meta\'s Llama 3 70B instruction-tuned model.', 'owned_by': 'Meta'},
+    {'model_name': 'mistralai/Mixtral-8x7B-Instruct-v0.1', 'display_name': 'Mixtral 8x7B Instruct', 'description': 'Mistral AI\'s Mixtral 8x7B instruction-tuned model.', 'owned_by': 'Mistral AI'},
+    {'model_name': 'mistralai/Mistral-7B-Instruct-v0.2', 'display_name': 'Mistral 7B Instruct v0.2', 'description': 'Mistral AI\'s 7B instruction-tuned model.', 'owned_by': 'Mistral AI'},
+    {'model_name': 'google/gemma-7b-it', 'display_name': 'Gemma 7B IT', 'description': 'Google\'s Gemma 7B instruction-tuned model.', 'owned_by': 'Google'},
+    {'model_name': 'google/gemma-2-9b-it', 'display_name': 'Gemma 2 9B IT', 'description': 'Google\'s next-generation Gemma 2 9B instruction-tuned model.', 'owned_by': 'Google'},
+    {'model_name': 'deepseek-ai/deepseek-coder-33b-instruct', 'display_name': 'Deepseek Coder 33B Instruct', 'description': 'A powerful coding model from Deepseek AI.', 'owned_by': 'Deepseek AI'},
+]
+
+class NovitaAIBinding(LollmsLLMBinding):
+    """Novita AI-specific binding implementation using their OpenAI-compatible API."""
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the Novita AI binding.
+
+        Args:
+            model_name (str): Name of the Novita AI model to use.
+            service_key (str): Novita AI API key.
+        """
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name")
+        self.service_key = kwargs.get("service_key")
+
+        if not self.service_key:
+            self.service_key = os.getenv("NOVITA_API_KEY")
+
+        if not self.service_key:
+            raise ValueError("Novita AI API key is required. Please set it via the 'service_key' parameter or the NOVITA_API_KEY environment variable.")
+
+        self.headers = {
+            "Authorization": f"Bearer {self.service_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+
+    def _construct_parameters(self,
+                              temperature: float,
+                              top_p: float,
+                              n_predict: int,
+                              presence_penalty: float,
+                              frequency_penalty: float) -> Dict[str, any]:
+        """Builds a parameters dictionary for the Novita AI API."""
+        params = {}
+        if temperature is not None: params['temperature'] = float(temperature)
+        if top_p is not None: params['top_p'] = top_p
+        if n_predict is not None: params['max_tokens'] = n_predict
+        if presence_penalty is not None: params['presence_penalty'] = presence_penalty
+        if frequency_penalty is not None: params['frequency_penalty'] = frequency_penalty
+        return params
+
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = 2048,
+             stream: Optional[bool] = False,
+             temperature: float = 0.7,
+             top_k: int = 50, # Not supported by Novita API
+             top_p: float = 0.9,
+             repeat_penalty: float = 1.1, # maps to frequency_penalty
+             presence_penalty: Optional[float] = 0.0,
+             seed: Optional[int] = None, # Not supported
+             n_threads: Optional[int] = None, # Not applicable
+             ctx_size: Optional[int] = None, # Determined by model
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with a Novita AI model using a LollmsDiscussion object.
+        """
+        system_prompt = discussion.system_prompt
+        messages = discussion.get_messages(branch_tip_id)
+
+        history = []
+        if system_prompt and system_prompt.strip():
+            history.append({"role": "system", "content": system_prompt})
+
+        for msg in messages:
+            role = 'user' if msg.sender_type == "user" else 'assistant'
+            
+            if msg.images:
+                ASCIIColors.warning("Novita AI API does not support images. They will be ignored.")
+
+            if msg.content and msg.content.strip():
+                history.append({"role": role, "content": msg.content})
+
+        if not history:
+            return {"status": "error", "message": "Cannot start chat with an empty discussion."}
+
+        api_params = self._construct_parameters(
+            temperature, top_p, n_predict, presence_penalty, repeat_penalty
+        )
+        
+        payload = {
+            "model": self.model_name,
+            "messages": history,
+            "stream": stream,
+            **api_params
+        }
+        
+        url = f"{API_BASE_URL}/v1/chat/completions"
+        full_response_text = ""
+
+        try:
+            if stream:
+                with requests.post(url, headers=self.headers, json=payload, stream=True) as response:
+                    response.raise_for_status()
+                    for line in response.iter_lines():
+                        if line:
+                            decoded_line = line.decode('utf-8')
+                            if decoded_line.startswith("data:"):
+                                content = decoded_line[len("data: "):].strip()
+                                if content == "[DONE]":
+                                    break
+                                try:
+                                    chunk = json.loads(content)
+                                    delta = chunk.get("choices", [{}])[0].get("delta", {})
+                                    text_chunk = delta.get("content", "")
+                                    if text_chunk:
+                                        full_response_text += text_chunk
+                                        if streaming_callback:
+                                            if not streaming_callback(text_chunk, MSG_TYPE.MSG_TYPE_CHUNK):
+                                                break
+                                except json.JSONDecodeError:
+                                    ASCIIColors.error(f"Failed to decode JSON chunk: {content}")
+                                    continue
+                return full_response_text
+            else:
+                response = requests.post(url, headers=self.headers, json=payload)
+                response.raise_for_status()
+                data = response.json()
+                return data["choices"][0]["message"]["content"]
+        except requests.exceptions.HTTPError as e:
+            try:
+                error_details = e.response.json()
+                error_message = error_details.get("error", {}).get("message", e.response.text)
+            except json.JSONDecodeError:
+                error_message = e.response.text
+            ASCIIColors.error(f"HTTP Error received from Novita AI API: {e.response.status_code} - {error_message}")
+            return {"status": "error", "message": f"HTTP Error: {e.response.status_code} - {error_message}"}
+        except requests.exceptions.RequestException as e:
+            error_message = f"An error occurred with the Novita AI API: {e}"
+            trace_exception(e)
+            return {"status": "error", "message": str(e)}
+
+    def tokenize(self, text: str) -> list:
+        """
+        Tokenize the input text. Novita uses an OpenAI-compatible API,
+        so we use the same tokenizer as GPT-4.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.encode(text)
+        except Exception as e:
+            ASCIIColors.error(f"Could not use tiktoken, falling back to simple encoding: {e}")
+            return list(text.encode('utf-8'))
+
+    def detokenize(self, tokens: list) -> str:
+        """
+        Detokenize a list of tokens.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.decode(tokens)
+        except Exception as e:
+            ASCIIColors.error(f"Could not use tiktoken, falling back to simple decoding: {e}")
+            return bytes(tokens).decode('utf-8', errors='ignore')
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text.
+        """
+        return len(self.tokenize(text))
+
+    def embed(self, text: str, **kwargs) -> List[float]:
+        """
+        Get embeddings for the input text.
+        """
+        ASCIIColors.warning("Novita AI does not offer a public embedding API via this binding. This method is not implemented.")
+        raise NotImplementedError("Novita AI binding does not support embeddings.")
+
+    def get_model_info(self) -> dict:
+        """Return information about the current model setup."""
+        return {
+            "name": self.binding_name,
+            "host_address": API_BASE_URL,
+            "model_name": self.model_name,
+            "supports_vision": False
+        }
+
+    def listModels(self) -> List[Dict[str, str]]:
+        """
+        Lists available models. Novita AI API does not have a models endpoint,
+        so a hardcoded list from their documentation is returned.
+        """
+        return sorted(_FALLBACK_MODELS, key=lambda x: x['display_name'])
+
+    def load_model(self, model_name: str) -> bool:
+        """Set the model name for subsequent operations."""
+        self.model_name = model_name
+        ASCIIColors.info(f"Novita AI model set to: {model_name}.")
+        return True
+
+if __name__ == '__main__':
+    if 'NOVITA_API_KEY' not in os.environ:
+        ASCIIColors.red("Error: NOVITA_API_KEY environment variable not set.")
+        print("Please get your key from novita.ai and set it.")
+        exit(1)
+
+    ASCIIColors.yellow("--- Testing NovitaAIBinding ---")
+    
+    test_model_name = "meta-llama/Llama-3-8B-Instruct"
+
+    try:
+        # --- Initialization ---
+        ASCIIColors.cyan("\n--- Initializing Binding ---")
+        binding = NovitaAIBinding(model_name=test_model_name)
+        ASCIIColors.green("Binding initialized successfully.")
+
+        # --- List Models ---
+        ASCIIColors.cyan("\n--- Listing Models (static list) ---")
+        models = binding.listModels()
+        if models:
+            ASCIIColors.green(f"Found {len(models)} models.")
+            for m in models:
+                print(f"- {m['model_name']} ({m['display_name']})")
+        else:
+            ASCIIColors.error("Failed to list models.")
+
+        # --- Count Tokens ---
+        ASCIIColors.cyan("\n--- Counting Tokens ---")
+        sample_text = "Hello, world! This is a test."
+        token_count = binding.count_tokens(sample_text)
+        ASCIIColors.green(f"Token count for '{sample_text}': {token_count}")
+
+        # --- Chat (Non-Streaming) ---
+        ASCIIColors.cyan("\n--- Chat (Non-Streaming) ---")
+        discussion_non_stream = LollmsDiscussion.from_messages(
+            messages=[
+                {"sender":"user", "content": "What is the largest planet in our solar system?"}
+            ],
+            system_prompt="You are a helpful and concise astronomical assistant."
+        )
+        ASCIIColors.info(f"Prompt: What is the largest planet in our solar system?")
+        generated_text = binding.chat(discussion_non_stream, n_predict=50, stream=False)
+        if isinstance(generated_text, str):
+            ASCIIColors.green(f"Generated text:\n{generated_text}")
+        else:
+            ASCIIColors.error(f"Generation failed: {generated_text}")
+
+        # --- Chat (Streaming) ---
+        ASCIIColors.cyan("\n--- Chat (Streaming) ---")
+        
+        captured_chunks = []
+        def stream_callback(chunk: str, msg_type: int):
+            ASCIIColors.green(chunk, end="", flush=True)
+            captured_chunks.append(chunk)
+            return True
+        
+        discussion_stream = LollmsDiscussion.from_messages(
+            messages=[
+                {"sender":"user", "content": "Explain the concept of photosynthesis in one short paragraph."}
+            ]
+        )
+        ASCIIColors.info(f"Prompt: Explain the concept of photosynthesis in one short paragraph.")
+        result = binding.chat(
+            discussion_stream, 
+            n_predict=150, 
+            stream=True, 
+            streaming_callback=stream_callback
+        )
+        print("\n--- End of Stream ---")
+        full_streamed_text = "".join(captured_chunks)
+        assert result == full_streamed_text
+
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during testing: {e}")
+        trace_exception(e)
+
+    ASCIIColors.yellow("\nNovitaAIBinding test finished.")

lollms_client/llm_bindings/perplexity/__init__.py

@@ -0,0 +1,326 @@
+import base64
+import os
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, Callable, List, Union, Dict
+import json
+import requests
+
+from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+
+import pipmaster as pm
+
+# Ensure the required packages are installed
+pm.ensure_packages(["requests", "tiktoken"])
+
+import tiktoken
+
+BindingName = "PerplexityBinding"
+API_BASE_URL = "https://api.perplexity.ai"
+
+# A hardcoded list of models based on Perplexity's documentation
+# The API does not provide a models listing endpoint.
+# Sourced from: https://docs.perplexity.ai/docs/models
+_FALLBACK_MODELS = [
+    # Sonar Models
+    {'model_name': 'llama-3.1-sonar-small-128k-chat', 'display_name': 'Llama 3.1 Sonar Small Chat (128k)', 'description': 'Fast and cost-effective conversational model.', 'owned_by': 'Perplexity'},
+    {'model_name': 'llama-3.1-sonar-small-128k-online', 'display_name': 'Llama 3.1 Sonar Small Online (128k)', 'description': 'Fast and cost-effective conversational model with web access.', 'owned_by': 'Perplexity'},
+    {'model_name': 'llama-3.1-sonar-large-128k-chat', 'display_name': 'Llama 3.1 Sonar Large Chat (128k)', 'description': 'State-of-the-art conversational model.', 'owned_by': 'Perplexity'},
+    {'model_name': 'llama-3.1-sonar-large-128k-online', 'display_name': 'Llama 3.1 Sonar Large Online (128k)', 'description': 'State-of-the-art conversational model with web access.', 'owned_by': 'Perplexity'},
+    # Llama 3 Instruct Models
+    {'model_name': 'llama-3-8b-instruct', 'display_name': 'Llama 3 8B Instruct', 'description': 'Meta\'s Llama 3 8B instruction-tuned model.', 'owned_by': 'Meta'},
+    {'model_name': 'llama-3-70b-instruct', 'display_name': 'Llama 3 70B Instruct', 'description': 'Meta\'s Llama 3 70B instruction-tuned model.', 'owned_by': 'Meta'},
+    # Mixtral Model
+    {'model_name': 'mixtral-8x7b-instruct', 'display_name': 'Mixtral 8x7B Instruct', 'description': 'Mistral AI\'s Mixtral 8x7B instruction-tuned model.', 'owned_by': 'Mistral AI'},
+    # Legacy Sonar Models
+    {'model_name': 'sonar-small-32k-chat', 'display_name': 'Sonar Small Chat (32k)', 'description': 'Legacy small conversational model.', 'owned_by': 'Perplexity'},
+    {'model_name': 'sonar-small-32k-online', 'display_name': 'Sonar Small Online (32k)', 'description': 'Legacy small conversational model with web access.', 'owned_by': 'Perplexity'},
+    {'model_name': 'sonar-medium-32k-chat', 'display_name': 'Sonar Medium Chat (32k)', 'description': 'Legacy medium conversational model.', 'owned_by': 'Perplexity'},
+    {'model_name': 'sonar-medium-32k-online', 'display_name': 'Sonar Medium Online (32k)', 'description': 'Legacy medium conversational model with web access.', 'owned_by': 'Perplexity'},
+]
+
+class PerplexityBinding(LollmsLLMBinding):
+    """Perplexity AI-specific binding implementation."""
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the Perplexity binding.
+
+        Args:
+            model_name (str): Name of the Perplexity model to use.
+            service_key (str): Perplexity API key.
+        """
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name")
+        self.service_key = kwargs.get("service_key")
+
+        if not self.service_key:
+            self.service_key = os.getenv("PERPLEXITY_API_KEY")
+
+        if not self.service_key:
+            raise ValueError("Perplexity API key is required. Please set it via the 'service_key' parameter or the PERPLEXITY_API_KEY environment variable.")
+
+        self.headers = {
+            "Authorization": f"Bearer {self.service_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+
+    def _construct_parameters(self,
+                              temperature: float,
+                              top_p: float,
+                              top_k: int,
+                              n_predict: int,
+                              presence_penalty: float,
+                              frequency_penalty: float) -> Dict[str, any]:
+        """Builds a parameters dictionary for the Perplexity API."""
+        params = {}
+        if temperature is not None: params['temperature'] = float(temperature)
+        if top_p is not None: params['top_p'] = top_p
+        if top_k is not None: params['top_k'] = top_k
+        if n_predict is not None: params['max_tokens'] = n_predict
+        if presence_penalty is not None: params['presence_penalty'] = presence_penalty
+        if frequency_penalty is not None: params['frequency_penalty'] = frequency_penalty
+        return params
+
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = 2048,
+             stream: Optional[bool] = False,
+             temperature: float = 0.7,
+             top_k: int = 50,
+             top_p: float = 0.9,
+             repeat_penalty: float = 1.1, # maps to frequency_penalty
+             presence_penalty: Optional[float] = 0.0,
+             seed: Optional[int] = None, # Not supported
+             n_threads: Optional[int] = None, # Not applicable
+             ctx_size: Optional[int] = None, # Determined by model
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with the Perplexity model using a LollmsDiscussion object.
+        """
+        system_prompt = discussion.system_prompt
+        messages = discussion.get_messages(branch_tip_id)
+
+        history = []
+        if system_prompt and system_prompt.strip():
+            history.append({"role": "system", "content": system_prompt})
+
+        for msg in messages:
+            if msg.sender_type == "user":
+                role = "user"
+            else:
+                role = "assistant"
+            
+            if msg.images:
+                ASCIIColors.warning("Perplexity API does not support images. They will be ignored.")
+
+            if msg.content and msg.content.strip():
+                history.append({"role": role, "content": msg.content})
+
+        if not history:
+            return {"status": "error", "message": "Cannot start chat with an empty discussion."}
+
+        api_params = self._construct_parameters(
+            temperature, top_p, top_k, n_predict, presence_penalty, repeat_penalty
+        )
+        
+        payload = {
+            "model": self.model_name,
+            "messages": history,
+            "stream": stream,
+            **api_params
+        }
+        
+        url = f"{API_BASE_URL}/chat/completions"
+        full_response_text = ""
+
+        try:
+            if stream:
+                with requests.post(url, headers=self.headers, json=payload, stream=True) as response:
+                    response.raise_for_status()
+                    for line in response.iter_lines():
+                        if line:
+                            decoded_line = line.decode('utf-8')
+                            if decoded_line.startswith("data:"):
+                                content = decoded_line[len("data: "):].strip()
+                                if content == "[DONE]":
+                                    break
+                                try:
+                                    chunk = json.loads(content)
+                                    delta = chunk.get("choices", [{}])[0].get("delta", {})
+                                    text_chunk = delta.get("content", "")
+                                    if text_chunk:
+                                        full_response_text += text_chunk
+                                        if streaming_callback:
+                                            if not streaming_callback(text_chunk, MSG_TYPE.MSG_TYPE_CHUNK):
+                                                break
+                                except json.JSONDecodeError:
+                                    ASCIIColors.error(f"Failed to decode JSON chunk: {content}")
+                                    continue
+                return full_response_text
+            else:
+                response = requests.post(url, headers=self.headers, json=payload)
+                response.raise_for_status()
+                data = response.json()
+                return data["choices"][0]["message"]["content"]
+        except requests.exceptions.RequestException as e:
+            error_message = f"An error occurred with the Perplexity API: {e}"
+            trace_exception(e)
+            return {"status": "error", "message": str(e)}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred: {str(ex)}"
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}
+
+    def tokenize(self, text: str) -> list:
+        """
+        Tokenize the input text. Perplexity uses the same tokenizer as GPT-4.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.encode(text)
+        except Exception as e:
+            ASCIIColors.error(f"Could not use tiktoken, falling back to simple encoding: {e}")
+            return list(text.encode('utf-8'))
+
+    def detokenize(self, tokens: list) -> str:
+        """
+        Detokenize a list of tokens.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.decode(tokens)
+        except Exception as e:
+            ASCIIColors.error(f"Could not use tiktoken, falling back to simple decoding: {e}")
+            return bytes(tokens).decode('utf-8', errors='ignore')
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text.
+        """
+        return len(self.tokenize(text))
+
+    def embed(self, text: str, **kwargs) -> List[float]:
+        """
+        Get embeddings for the input text.
+        """
+        ASCIIColors.warning("Perplexity does not offer a public embedding API. This method is not implemented.")
+        raise NotImplementedError("Perplexity binding does not support embeddings.")
+
+    def get_model_info(self) -> dict:
+        """Return information about the current model setup."""
+        return {
+            "name": self.binding_name,
+            "version": "1.0",
+            "host_address": API_BASE_URL,
+            "model_name": self.model_name,
+            "supports_vision": False,
+            "supports_structured_output": False
+        }
+
+    def listModels(self) -> List[Dict[str, str]]:
+        """
+        Lists available models. Perplexity API does not have a models endpoint,
+        so a hardcoded list is returned.
+        """
+        return sorted(_FALLBACK_MODELS, key=lambda x: x['display_name'])
+
+    def load_model(self, model_name: str) -> bool:
+        """Set the model name for subsequent operations."""
+        self.model_name = model_name
+        ASCIIColors.info(f"Perplexity model set to: {model_name}.")
+        return True
+
+if __name__ == '__main__':
+    if 'PERPLEXITY_API_KEY' not in os.environ:
+        ASCIIColors.red("Error: PERPLEXITY_API_KEY environment variable not set.")
+        print("Please get your key from Perplexity AI and set it.")
+        exit(1)
+
+    ASCIIColors.yellow("--- Testing PerplexityBinding ---")
+    
+    test_model_name = "llama-3.1-sonar-small-128k-online"
+
+    try:
+        # --- Initialization ---
+        ASCIIColors.cyan("\n--- Initializing Binding ---")
+        binding = PerplexityBinding(model_name=test_model_name)
+        ASCIIColors.green("Binding initialized successfully.")
+
+        # --- List Models ---
+        ASCIIColors.cyan("\n--- Listing Models (static list) ---")
+        models = binding.listModels()
+        if models:
+            ASCIIColors.green(f"Found {len(models)} models.")
+            for m in models:
+                print(f"- {m['model_name']} ({m['display_name']})")
+        else:
+            ASCIIColors.error("Failed to list models.")
+
+        # --- Count Tokens ---
+        ASCIIColors.cyan("\n--- Counting Tokens ---")
+        sample_text = "Hello, world! This is a test."
+        token_count = binding.count_tokens(sample_text)
+        ASCIIColors.green(f"Token count for '{sample_text}': {token_count}")
+
+        # --- Chat (Non-Streaming) ---
+        ASCIIColors.cyan("\n--- Chat (Non-Streaming) ---")
+        discussion_non_stream = LollmsDiscussion.from_messages(
+            messages=[
+                {"sender":"user", "content": "What is the capital of France?"}
+            ],
+            system_prompt="You are a helpful and concise assistant."
+        )
+        ASCIIColors.info(f"Prompt: What is the capital of France?")
+        generated_text = binding.chat(discussion_non_stream, n_predict=50, stream=False)
+        if isinstance(generated_text, str):
+            ASCIIColors.green(f"Generated text:\n{generated_text}")
+        else:
+            ASCIIColors.error(f"Generation failed: {generated_text}")
+
+        # --- Chat (Streaming) ---
+        ASCIIColors.cyan("\n--- Chat (Streaming) ---")
+        
+        captured_chunks = []
+        def stream_callback(chunk: str, msg_type: int):
+            ASCIIColors.green(chunk, end="", flush=True)
+            captured_chunks.append(chunk)
+            return True
+        
+        discussion_stream = LollmsDiscussion.from_messages(
+            messages=[
+                {"sender":"user", "content": "Explain the importance of bees in one short paragraph."}
+            ],
+            system_prompt="You are a helpful assistant."
+        )
+        ASCIIColors.info(f"Prompt: Explain the importance of bees in one short paragraph.")
+        result = binding.chat(
+            discussion_stream, 
+            n_predict=150, 
+            stream=True, 
+            streaming_callback=stream_callback
+        )
+        print("\n--- End of Stream ---")
+        full_streamed_text = "".join(captured_chunks)
+        assert result == full_streamed_text
+
+        # --- Embeddings (Expected to fail) ---
+        ASCIIColors.cyan("\n--- Embeddings ---")
+        try:
+            binding.embed("This should not work.")
+        except NotImplementedError as e:
+            ASCIIColors.green(f"Successfully caught expected error for embeddings: {e}")
+        except Exception as e:
+            ASCIIColors.error(f"Caught an unexpected error for embeddings: {e}")
+
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during testing: {e}")
+        trace_exception(e)
+
+    ASCIIColors.yellow("\nPerplexityBinding test finished.")

lollms_client/tti_bindings/leonardo_ai/__init__.py

@@ -0,0 +1,124 @@
+import os
+import requests
+import time
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+pm.ensure_packages(["requests", "Pillow"])
+from PIL import Image
+
+BindingName = "LeonardoAITTIBinding"
+
+# Sourced from https://docs.leonardo.ai/docs/models
+LEONARDO_AI_MODELS = [
+    {"model_name": "ac4f3991-8a40-42cd-b174-14a8e33738e4", "display_name": "Leonardo Phoenix", "description": "Fast, high-quality photorealism."},
+    {"model_name": "1e65d070-22c9-4aed-a5be-ce58a1b65b38", "display_name": "Leonardo Diffusion XL", "description": "The flagship general-purpose SDXL model."},
+    {"model_name": "b24e16ff-06e3-43eb-a255-db4322b0f345", "display_name": "AlbedoBase XL", "description": "Versatile model for photorealism and artistic styles."},
+    {"model_name": "6bef9f1b-29cb-40c7-b9df-32b51c1f67d3", "display_name": "Absolute Reality v1.6", "description": "Classic photorealistic model."},
+    {"model_name": "f3296a34-a868-4665-8b2f-f4313f8c8533", "display_name": "RPG v5", "description": "Specialized in RPG characters and assets."},
+    {"model_name": "2067ae58-a02e-4318-9742-2b55b2a4c813", "display_name": "DreamShaper v7", "description": "Popular versatile artistic model."},
+]
+
+class LeonardoAITTIBinding(LollmsTTIBinding):
+    """Leonardo.ai TTI binding for LoLLMS"""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName)
+        self.config = kwargs
+        self.api_key = self.config.get("api_key") or os.environ.get("LEONARDO_API_KEY")
+        if not self.api_key:
+            raise ValueError("Leonardo.ai API key is required.")
+        self.model_name = self.config.get("model_name", "ac4f3991-8a40-42cd-b174-14a8e33738e4")
+        self.base_url = "https://cloud.leonardo.ai/api/rest/v1"
+        self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+    def listModels(self) -> list:
+        # You could also fetch this dynamically from /models endpoint
+        return LEONARDO_AI_MODELS
+    
+    def _wait_for_generation(self, generation_id: str) -> List[bytes]:
+        while True:
+            url = f"{self.base_url}/generations/{generation_id}"
+            response = requests.get(url, headers=self.headers)
+            response.raise_for_status()
+            data = response.json().get("generations_by_pk", {})
+            status = data.get("status")
+
+            if status == "COMPLETE":
+                ASCIIColors.green("Generation complete.")
+                images_data = []
+                for img in data.get("generated_images", []):
+                    img_url = img.get("url")
+                    if img_url:
+                        img_response = requests.get(img_url)
+                        img_response.raise_for_status()
+                        images_data.append(img_response.content)
+                return images_data
+            elif status == "FAILED":
+                raise Exception("Leonardo.ai generation failed.")
+            else:
+                ASCIIColors.info(f"Generation status: {status}. Waiting...")
+                time.sleep(3)
+
+    def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:
+        url = f"{self.base_url}/generations"
+        payload = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "modelId": self.model_name,
+            "width": width,
+            "height": height,
+            "num_images": 1,
+            "guidance_scale": kwargs.get("guidance_scale", 7),
+            "seed": kwargs.get("seed"),
+            "sd_version": "SDXL" # Most models are SDXL based
+        }
+        
+        try:
+            ASCIIColors.info(f"Submitting generation job to Leonardo.ai ({self.model_name})...")
+            response = requests.post(url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            generation_id = response.json()["sdGenerationJob"]["generationId"]
+            ASCIIColors.info(f"Job submitted with ID: {generation_id}")
+            images = self._wait_for_generation(generation_id)
+            return images[0]
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Leonardo.ai API error: {error_msg}")
+            except:
+                raise Exception(f"Leonardo.ai API request failed: {e}")
+
+    def edit_image(self, **kwargs) -> bytes:
+        ASCIIColors.warning("Leonardo.ai edit_image (inpainting/img2img) is not yet implemented in this binding.")
+        raise NotImplementedError("This binding does not yet support image editing.")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Leonardo.ai TTI Binding Test ---")
+    if "LEONARDO_API_KEY" not in os.environ:
+        ASCIIColors.error("LEONARDO_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = LeonardoAITTIBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Text-to-Image ---")
+        prompt = "A majestic lion wearing a crown, hyperrealistic, 8k"
+        img_bytes = binding.generate_image(prompt, width=1024, height=1024)
+        
+        assert len(img_bytes) > 1000
+        output_path = Path(__file__).parent / "tmp_leonardo_t2i.png"
+        with open(output_path, "wb") as f:
+            f.write(img_bytes)
+        ASCIIColors.green(f"Text-to-Image generation OK. Image saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Leonardo.ai binding test failed: {e}")

lollms_client/tti_bindings/novita_ai/__init__.py

@@ -0,0 +1,102 @@
+import os
+import requests
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+pm.ensure_packages(["requests"])
+
+BindingName = "NovitaAITTIBinding"
+
+# Sourced from https://docs.novita.ai/image-generation/models
+NOVITA_AI_MODELS = [
+    {"model_name": "sd_xl_base_1.0.safetensors", "display_name": "Stable Diffusion XL 1.0", "description": "Official SDXL 1.0 Base model."},
+    {"model_name": "dreamshaper_xl_1_0.safetensors", "display_name": "DreamShaper XL 1.0", "description": "Versatile artistic SDXL model."},
+    {"model_name": "juggernaut_xl_v9_rundiffusion.safetensors", "display_name": "Juggernaut XL v9", "description": "High-quality realistic and cinematic model."},
+    {"model_name": "realistic_vision_v5.1.safetensors", "display_name": "Realistic Vision v5.1", "description": "Popular photorealistic SD1.5 model."},
+    {"model_name": "absolutereality_v1.8.1.safetensors", "display_name": "Absolute Reality v1.8.1", "description": "General-purpose realistic SD1.5 model."},
+    {"model_name": "meinamix_meina_v11.safetensors", "display_name": "MeinaMix v11", "description": "High-quality anime illustration model."},
+]
+
+class NovitaAITTIBinding(LollmsTTIBinding):
+    """Novita.ai TTI binding for LoLLMS"""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName)
+        self.config = kwargs
+        self.api_key = self.config.get("api_key") or os.environ.get("NOVITA_API_KEY")
+        if not self.api_key:
+            raise ValueError("Novita.ai API key is required.")
+        self.model_name = self.config.get("model_name", "juggernaut_xl_v9_rundiffusion.safetensors")
+        self.base_url = "https://api.novita.ai/v3"
+        self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+    def listModels(self) -> list:
+        return NOVITA_AI_MODELS
+    
+    def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:
+        url = f"{self.base_url}/text2img"
+        payload = {
+            "model_name": self.model_name,
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "width": width,
+            "height": height,
+            "sampler_name": "DPM++ 2M Karras",
+            "cfg_scale": kwargs.get("guidance_scale", 7.0),
+            "steps": kwargs.get("num_inference_steps", 25),
+            "seed": kwargs.get("seed", -1),
+            "n_iter": 1,
+            "batch_size": 1
+        }
+        
+        try:
+            ASCIIColors.info(f"Requesting image from Novita.ai ({self.model_name})...")
+            response = requests.post(url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            data = response.json()
+            if "images" not in data or not data["images"]:
+                raise Exception(f"API returned no images. Response: {data}")
+            
+            b64_image = data["images"][0]["image_base64"]
+            return base64.b64decode(b64_image)
+            
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Novita.ai API error: {error_msg}")
+            except:
+                raise Exception(f"Novita.ai API request failed: {e}")
+
+    def edit_image(self, **kwargs) -> bytes:
+        ASCIIColors.warning("Novita.ai edit_image (inpainting/img2img) is not yet implemented in this binding.")
+        raise NotImplementedError("This binding does not yet support image editing.")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Novita.ai TTI Binding Test ---")
+    if "NOVITA_API_KEY" not in os.environ:
+        ASCIIColors.error("NOVITA_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = NovitaAITTIBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Text-to-Image ---")
+        prompt = "A cute capybara wearing a top hat, sitting in a field of flowers, painterly style"
+        img_bytes = binding.generate_image(prompt, width=1024, height=1024, num_inference_steps=30)
+        
+        assert len(img_bytes) > 1000
+        output_path = Path(__file__).parent / "tmp_novita_t2i.png"
+        with open(output_path, "wb") as f:
+            f.write(img_bytes)
+        ASCIIColors.green(f"Text-to-Image generation OK. Image saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Novita.ai binding test failed: {e}")

lollms_client/tti_bindings/stability_ai/__init__.py

@@ -0,0 +1,176 @@
+import os
+import requests
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+pm.ensure_packages(["requests", "Pillow"])
+
+from PIL import Image
+
+BindingName = "StabilityAITTIBinding"
+
+# Sourced from https://platform.stability.ai/docs/getting-started/models
+STABILITY_AI_MODELS = [
+    # SD3
+    {"model_name": "stable-diffusion-3-medium", "display_name": "Stable Diffusion 3 Medium", "description": "Most advanced text-to-image model.", "owned_by": "Stability AI"},
+    {"model_name": "stable-diffusion-3-large", "display_name": "Stable Diffusion 3 Large", "description": "Most advanced model with higher quality.", "owned_by": "Stability AI"},
+    {"model_name": "stable-diffusion-3-large-turbo", "display_name": "Stable Diffusion 3 Large Turbo", "description": "Fast, high-quality generation.", "owned_by": "Stability AI"},
+    # SDXL
+    {"model_name": "stable-diffusion-xl-1024-v1-0", "display_name": "Stable Diffusion XL 1.0", "description": "High-quality 1024x1024 generation.", "owned_by": "Stability AI"},
+    {"model_name": "stable-diffusion-xl-beta-v2-2-2", "display_name": "SDXL Beta", "description": "Legacy anime-focused SDXL model.", "owned_by": "Stability AI"},
+    # SD 1.x & 2.x
+    {"model_name": "stable-diffusion-v1-6", "display_name": "Stable Diffusion 1.6", "description": "Improved version of SD 1.5.", "owned_by": "Stability AI"},
+    {"model_name": "stable-diffusion-2-1", "display_name": "Stable Diffusion 2.1", "description": "768x768 native resolution model.", "owned_by": "Stability AI"},
+]
+
+class StabilityAITTIBinding(LollmsTTIBinding):
+    """Stability AI TTI binding for LoLLMS"""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName)
+        self.config = kwargs
+        self.api_key = self.config.get("api_key") or os.environ.get("STABILITY_API_KEY")
+        if not self.api_key:
+            raise ValueError("Stability AI API key is required. Please set it in the configuration or as STABILITY_API_KEY environment variable.")
+        self.model_name = self.config.get("model_name", "stable-diffusion-3-medium")
+
+    def listModels(self) -> list:
+        return STABILITY_AI_MODELS
+
+    def _get_api_url(self, task: str) -> str:
+        base_url = "https://api.stability.ai/v2beta/stable-image"
+        # SD3 models use a different endpoint structure
+        if "stable-diffusion-3" in self.model_name:
+            return f"{base_url}/generate/sd3"
+        
+        task_map = {
+            "text2image": "generate/core",
+            "image2image": "edit/image-to-image",
+            "inpainting": "edit/in-painting",
+            "upscale": "edit/upscale"
+        }
+        if task not in task_map:
+            raise ValueError(f"Unsupported task for this model family: {task}")
+        return f"{base_url}/{task_map[task]}"
+
+    def _decode_image_input(self, item: Union[str, Path, bytes]) -> Image.Image:
+        if isinstance(item, bytes):
+            return Image.open(BytesIO(item))
+        s = str(item).strip()
+        if s.startswith("data:image/") and ";base64," in s:
+            b64 = s.split(";base64,")[-1]
+            return Image.open(BytesIO(base64.b64decode(b64)))
+        try:
+            p = Path(s)
+            if p.exists():
+                return Image.open(p)
+        except:
+            pass
+        if s.startswith("http"):
+            response = requests.get(s, stream=True)
+            response.raise_for_status()
+            return Image.open(response.raw)
+        # Fallback for raw base64
+        return Image.open(BytesIO(base64.b64decode(s)))
+
+    def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:
+        url = self._get_api_url("text2image")
+        
+        data = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "output_format": "png",
+            "seed": kwargs.get("seed", 0)
+        }
+
+        # SD3 uses aspect_ratio, older models use width/height
+        if "stable-diffusion-3" in self.model_name:
+            data["aspect_ratio"] = f"{width}:{height}"
+            data["model"] = self.model_name
+        else:
+            data["width"] = width
+            data["height"] = height
+            data["style_preset"] = kwargs.get("style_preset", "photographic")
+
+        headers = {"authorization": f"Bearer {self.api_key}", "accept": "image/*"}
+        
+        try:
+            ASCIIColors.info(f"Requesting image from Stability AI ({self.model_name})...")
+            response = requests.post(url, headers=headers, files={"none": ''}, data=data)
+            response.raise_for_status()
+            return response.content
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Stability AI API error: {error_msg}")
+            except:
+                raise Exception(f"Stability AI API request failed: {e}")
+
+    def edit_image(self, images: Union[str, List[str]], prompt: str, negative_prompt: Optional[str] = "", mask: Optional[str] = None, **kwargs) -> bytes:
+        init_image_bytes = BytesIO()
+        init_image = self._decode_image_input(images[0] if isinstance(images, list) else images)
+        init_image.save(init_image_bytes, format="PNG")
+        
+        task = "inpainting" if mask else "image2image"
+        url = self._get_api_url(task)
+
+        files = {"image": init_image_bytes.getvalue()}
+        data = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt or "",
+            "output_format": "png",
+            "seed": kwargs.get("seed", 0)
+        }
+
+        if task == "inpainting":
+            mask_image_bytes = BytesIO()
+            mask_image = self._decode_image_input(mask)
+            mask_image.save(mask_image_bytes, format="PNG")
+            files["mask"] = mask_image_bytes.getvalue()
+        else: # image2image
+            data["strength"] = kwargs.get("strength", 0.6) # mode IMAGE_STRENGTH
+        
+        headers = {"authorization": f"Bearer {self.api_key}", "accept": "image/*"}
+
+        try:
+            ASCIIColors.info(f"Requesting image edit from Stability AI ({self.model_name})...")
+            response = requests.post(url, headers=headers, files=files, data=data)
+            response.raise_for_status()
+            return response.content
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Stability AI API error: {error_msg}")
+            except:
+                raise Exception(f"Stability AI API request failed: {e}")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Stability AI TTI Binding Test ---")
+    if "STABILITY_API_KEY" not in os.environ:
+        ASCIIColors.error("STABILITY_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = StabilityAITTIBinding(model_name="stable-diffusion-3-medium")
+        
+        ASCIIColors.cyan("\n--- Test: Text-to-Image ---")
+        prompt = "a cinematic photo of a robot drinking coffee in a Parisian cafe"
+        img_bytes = binding.generate_image(prompt, width=1024, height=1024)
+        
+        assert len(img_bytes) > 1000, "Generated image bytes are too small."
+        output_path = Path(__file__).parent / "tmp_stability_t2i.png"
+        with open(output_path, "wb") as f:
+            f.write(img_bytes)
+        ASCIIColors.green(f"Text-to-Image generation OK. Image saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Stability AI binding test failed: {e}")

{lollms_client-1.4.1.dist-info → lollms_client-1.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.4.1
+Version: 1.4.5
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License

{lollms_client-1.4.1.dist-info → lollms_client-1.4.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lollms_client/__init__.py,sha256=G2ENRPwIlHb_nTaBEbn_AvUQvlsBYpIuQXGWYkYmyo0,1146
+lollms_client/__init__.py,sha256=1ATuXFW5bb2NSxUu0nl6c3tXgX30-GS0pYWv6hkA8Vg,1146
 lollms_client/lollms_agentic.py,sha256=pQiMEuB_XkG29-SW6u4KTaMFPr6eKqacInggcCuCW3k,13914
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
 lollms_client/lollms_core.py,sha256=aCEoxmEF6ZmkBgJgZd74lKkM4A3PVVyt2IwMvLfScWw,315053
@@ -29,10 +29,12 @@ lollms_client/llm_bindings/llamacpp/__init__.py,sha256=llPF85AzYgMp7Cpo_4OvEHKlx
 lollms_client/llm_bindings/lollms/__init__.py,sha256=XFQKtTJnkW8OwF1IoyzHqAZ8JAJ0PnAUKDdeOLGcbrE,24310
 lollms_client/llm_bindings/lollms_webui/__init__.py,sha256=iuDfhZZoLC-PDEPLHrcjk5-962S5c7OeCI7PMdJxI_A,17753
 lollms_client/llm_bindings/mistral/__init__.py,sha256=cddz9xIj8NRFLKHe2JMxzstpUrNIu5s9juci3mhiHfo,14133
+lollms_client/llm_bindings/novita_ai/__init__.py,sha256=NOg6_NBCxuz9gwrijTCzrp9a78AbmBdT4k67baCTtuc,13877
 lollms_client/llm_bindings/ollama/__init__.py,sha256=a6cgzXPuo8ZLhIZHJFy8QF0n5ZTk0X4OC1JSyXG1enk,46013
 lollms_client/llm_bindings/open_router/__init__.py,sha256=cAFWtCWJx0WjIe1w2JReCf6WlAZjrXYA4jZ8l3zqxMs,14915
 lollms_client/llm_bindings/openai/__init__.py,sha256=ElLbtHLwR61Uj3W6G4g6QIhxtCqUGOCQBYwhQyN60us,26142
 lollms_client/llm_bindings/openllm/__init__.py,sha256=RC9dVeopslS-zXTsSJ7VC4iVsKgZCBwfmccmr_LCHA0,29971
+lollms_client/llm_bindings/perplexity/__init__.py,sha256=lMRPdbVbGX_weByAdcsZakdxDg7nFF3uCbdzakQmBOc,15006
 lollms_client/llm_bindings/pythonllamacpp/__init__.py,sha256=ZTuVa5ngu9GPVImjs_g8ArV7Bx7a1Rze518Tz8AFJ3U,31807
 lollms_client/llm_bindings/tensor_rt/__init__.py,sha256=xiT-JAyNI_jo6CE0nle9Xoc7U8-UHAfEHrnCwmDTiOE,32023
 lollms_client/llm_bindings/transformers/__init__.py,sha256=hEonNvmrVSc9YWg_1uVwxe31rC-fsjVGh6QvyBc0TEE,37598
@@ -51,8 +53,11 @@ lollms_client/stt_bindings/whispercpp/__init__.py,sha256=xSAQRjAhljak3vWCpkP0Vmd
 lollms_client/tti_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/tti_bindings/diffusers/__init__.py,sha256=Pi5Zw4nHGXVc0Vcb0ib7KkoiOx__0JukWtL01BUzd7c,41692
 lollms_client/tti_bindings/gemini/__init__.py,sha256=f9fPuqnrBZ1Z-obcoP6EVvbEXNbNCSg21cd5efLCk8U,16707
+lollms_client/tti_bindings/leonardo_ai/__init__.py,sha256=EvjKyV8kM7-tmLwC1agSQ-v7thrNgflrmFxhDLqzT8U,5884
 lollms_client/tti_bindings/lollms/__init__.py,sha256=5Tnsn4b17djvieQkcjtIDBm3qf0pg5ZWWov-4_2wmo0,8762
+lollms_client/tti_bindings/novita_ai/__init__.py,sha256=1PZbM_R7cZwImbYxeuLqTlrc6Sfg43_YCbjw2ZJLnhc,4802
 lollms_client/tti_bindings/openai/__init__.py,sha256=YWJolJSQfIzTJvrLQVe8rQewP7rddf6z87g4rnp-lTs,4932
+lollms_client/tti_bindings/stability_ai/__init__.py,sha256=GJxE0joQ0UZbheozysbN96AvQq60pjY2UjnSLFmRh4g,8025
 lollms_client/ttm_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/ttm_bindings/audiocraft/__init__.py,sha256=a0k6wTrHth6GaVOiNnVboeFY3oKVvCQPbQlqO38XEyc,14328
 lollms_client/ttm_bindings/bark/__init__.py,sha256=Pr3ou2a-7hNYDqbkxrAbghZpO5HvGUhz7e-7VGXIHHA,18976
@@ -71,8 +76,8 @@ lollms_client/tts_bindings/xtts/server/main.py,sha256=T-Kn5NM-u1FJMygeV8rOoZKlqn
 lollms_client/tts_bindings/xtts/server/setup_voices.py,sha256=UdHaPa5aNcw8dR-aRGkZr2OfSFFejH79lXgfwT0P3ss,1964
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-1.4.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.4.1.dist-info/METADATA,sha256=eBfpms3EJ5sD7D-xBTXggnqOc1g8IE0inftnXGQmb6w,58689
-lollms_client-1.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.4.1.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.4.1.dist-info/RECORD,,
+lollms_client-1.4.5.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.4.5.dist-info/METADATA,sha256=IJc5k53zOajOIIvuq-dhLQQ67bHpLwzNyTqxlQZNCz8,58689
+lollms_client-1.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.4.5.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.4.5.dist-info/RECORD,,