lollms-client 0.27.2__py3-none-any.whl → 0.27.3__py3-none-any.whl

examples/lollms_chat/calculator.py

@@ -0,0 +1,59 @@
+# This is a simple example of a calculator using lollms_chat. don't expect this to be perfect as LLMs are very bad in computing 
+# this can be used for very simple calculations. don't expect it to be accurate to compute sqrt(35) or something
+# it is just for the purpose of experimentation as even the best models in the world are not capable of doing accurate calculations yet without a calculator
+
+from lollms_client import LollmsClient
+import json
+import math  # Import the math module for calculations
+
+# Make sure you use your key
+lc = LollmsClient(
+    "openai",
+    "http://localhost:9642/v1/",
+    service_key="lollms_y-uyV-p2_AQGo5Ut6uHDmfIoRk6rKfmf0Rz6xQx-Zkl8cNyVUSFM"# make sure you generate your own key
+)
+
+# if you want to see what binding/model does the server support, use this:
+models = lc.listModels()
+print(f"Found models:\n{models}")
+
+lc.set_model_name("ollama/gemma3:27b")  # Or your preferred binding/model
+
+expression = input("Give an expression to evaluate: ")
+
+# Construct a detailed prompt
+system_prompt = (
+    "You are a highly accurate calculator.  You receive a mathematical expression "
+    "as input and return the result as a JSON object.  "
+    "The expression can include numbers, basic arithmetic operators (+, -, *, /), "
+    "parentheses, and common mathematical functions like sin, cos, tan, pi, sqrt, and log.  "
+    "Always evaluate the expression and return the final numeric result.  If the expression is invalid, return 'Error'."
+)
+
+template = '{"result": the numeric result of the evaluated expression}'
+
+# Include the expression in the user prompt.  This is important!
+user_prompt = f"Evaluate the following expression: {expression}"
+
+# Generate the code
+generation_output = lc.generate_code(
+    user_prompt,
+    system_prompt=system_prompt,
+    template=template
+)
+
+try:
+    # Attempt to parse the JSON response
+    generation_output = json.loads(generation_output)
+    result = generation_output["result"]
+
+    # Attempt to convert the result to a float
+    try:
+        result = float(result)
+        print(f"Result: {result}")
+    except ValueError:
+        print(f"Result: {result} (Could not convert to a number)") #Handles cases where the LLM returns non-numeric output
+except json.JSONDecodeError:
+    print(f"Error: Could not decode JSON response: {generation_output}")
+except KeyError:
+    print(f"Error: 'result' key not found in JSON response: {generation_output}")

examples/lollms_chat/derivative.py

@@ -0,0 +1,48 @@
+from lollms_client import LollmsClient
+import json
+
+# Make sure you use your key
+lc = LollmsClient(
+    "openai",
+    "http://localhost:9642/v1/",
+    service_key="lollms_y-uyV-p2_AQGo5Ut6uHDmfIoRk6rKfmf0Rz6xQx-Zkl8cNyVUSFM"  # make sure you generate your own key
+)
+
+# if you want to see what binding/model does the server support, use this:
+models = lc.listModels()
+print(f"Found models:\n{models}")
+
+lc.set_model_name("ollama/gemma3:27b")  # Or your preferred binding/model
+
+function = input("Enter the function (e.g., x^2 + 2*x): ")
+parameter = input("Enter the parameter to differentiate with respect to (e.g., x): ")
+
+# Construct a detailed prompt
+system_prompt = (
+    "You are a symbolic differentiation engine. You receive a mathematical function "
+    "and a parameter as input, and you return the derivative of the function with respect to that parameter. "
+    "The function can include variables, numbers, and common mathematical operations. "
+    "Return the derivative as a string. If the function or parameter is invalid, return 'Error'."
+)
+
+template = '"{derivative}": the derivative of the function with respect to the parameter'
+
+# Include the function and parameter in the user prompt. This is important!
+user_prompt = f"Find the derivative of the function '{function}' with respect to '{parameter}'."
+
+# Generate the code
+generation_output = lc.generate_code(
+    user_prompt,
+    system_prompt=system_prompt,
+    template=template
+)
+
+try:
+    # Attempt to parse the JSON response
+    generation_output = json.loads(generation_output)
+    derivative = generation_output["derivative"]
+    print(f"Derivative: {derivative}")
+except json.JSONDecodeError:
+    print(f"Error: Could not decode JSON response: {generation_output}")
+except KeyError:
+    print(f"Error: 'derivative' key not found in JSON response: {generation_output}")

examples/lollms_chat/test_openai_compatible_with_lollms_chat.py

@@ -0,0 +1,12 @@
+from lollms_client import LollmsClient
+#make sure you use your key
+lc = LollmsClient("openai","http://localhost:9642/v1/", service_key="lollms_zXQdyvrP_ecMXm3UZ0D004x979aHpyF8iq4ki_b52q0WdFuiEfMo")
+models = lc.listModels()
+print(f"Found models:\n{models}")
+
+lc.set_model_name("ollama/gemma3:27b")
+
+res = lc.generate_text("Describe this image",images=[
+    r"C:\Users\parisneo\Pictures\me.jpg"
+])
+print(res)

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__ = "0.27.2" # Updated version
+__version__ = "0.27.3" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/llm_bindings/litellm/__init__.py

@@ -110,6 +110,25 @@ class LiteLLMBinding(LollmsLLMBinding):
 
         return self._perform_generation(messages, n_predict, is_streaming, temperature, top_p, repeat_penalty, seed, streaming_callback)
 
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        is_streaming = stream if stream is not None else (streaming_callback is not None)
+        return self._perform_generation(messages, n_predict, is_streaming, temperature, top_p, repeat_penalty, seed, streaming_callback)
+        
+
     def chat(self, discussion: LollmsDiscussion, branch_tip_id: Optional[str] = None, n_predict: Optional[int] = None, stream: Optional[bool] = None, temperature: float = 0.7, top_p: float = 0.9, repeat_penalty: float = 1.1, seed: Optional[int] = None, streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None, **kwargs) -> Union[str, dict]:
         is_streaming = stream if stream is not None else (streaming_callback is not None)
         messages = discussion.export("openai_chat", branch_tip_id)
@@ -178,9 +197,9 @@ class LiteLLMBinding(LollmsLLMBinding):
                 entries.append({
                     "category": "api", "datasets": "unknown", "icon": get_icon_path(model_name),
                     "license": "unknown", "model_creator": model_info.get('owned_by', 'unknown'),
-                    "name": model_name, "provider": "litellm", "rank": "1.0", "type": "api",
+                    "model_name": model_name, "provider": "litellm", "rank": "1.0", "type": "api",
                     "variants": [{
-                        "name": model_name, "size": context_size,
+                        "model_name": model_name, "size": context_size,
                         "input_cost_per_token": model_info.get('input_cost_per_token', 0),
                         "output_cost_per_token": model_info.get('output_cost_per_token', 0),
                         "max_output_tokens": model_info.get('max_output_tokens', 0),

lollms_client/llm_bindings/lollms_chat/__init__.py

@@ -0,0 +1,547 @@
+# bindings/Lollms_chat/binding.py
+import requests
+import json
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+from lollms_client.lollms_utilities import encode_image
+from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
+from lollms_client.lollms_discussion import LollmsDiscussion
+from typing import Optional, Callable, List, Union
+from ascii_colors import ASCIIColors, trace_exception
+from typing import List, Dict
+
+import pipmaster as pm
+
+pm.ensure_packages(["openai","tiktoken"])
+
+import openai
+import tiktoken
+import os
+
+BindingName = "LollmsChatBinding"
+
+
+class LollmsChatBinding(LollmsLLMBinding):
+    """LollmsChat-specific binding implementation (open ai compatible with some extra parameters)"""
+    
+    
+    def __init__(self,
+                 host_address: str = None,
+                 model_name: str = "",
+                 service_key: str = None,
+                 verify_ssl_certificate: bool = True,
+                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat,
+                 **kwargs):
+        """
+        Initialize the OpenAI binding.
+
+        Args:
+            host_address (str): Host address for the OpenAI service. Defaults to DEFAULT_HOST_ADDRESS.
+            model_name (str): Name of the model to use. Defaults to empty string.
+            service_key (str): Authentication key for the service. Defaults to None.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
+            personality (Optional[int]): Ignored parameter for compatibility with LollmsLLMBinding.
+        """
+        super().__init__(
+            binding_name = "openai",
+        )
+        self.host_address=host_address
+        self.model_name=model_name
+        self.service_key=service_key
+        self.verify_ssl_certificate=verify_ssl_certificate
+        self.default_completion_format=default_completion_format
+
+        if not self.service_key:
+            self.service_key = os.getenv("OPENAI_API_KEY", self.service_key)
+        self.client = openai.OpenAI(api_key=self.service_key, base_url=None if host_address is None else host_address if len(host_address)>0 else None)
+        self.completion_format = ELF_COMPLETION_FORMAT.Chat
+
+    
+    def generate_text(self,
+                     prompt: str,
+                     images: Optional[List[str]] = None,
+                     system_prompt: str = "",
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: float = 0.7, 
+                     top_k: int = 40,          
+                     top_p: float = 0.9,       
+                     repeat_penalty: float = 1.1, 
+                     repeat_last_n: int = 64, 
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
+                     ) -> Union[str, dict]:
+        """
+        Generate text using the active LLM binding, using instance defaults if parameters are not provided.
+
+        Args:
+            prompt (str): The input prompt for text generation.
+            images (Optional[List[str]]): List of image file paths for multimodal generation.
+            n_predict (Optional[int]): Maximum number of tokens to generate. Uses instance default if None.
+            stream (Optional[bool]): Whether to stream the output. Uses instance default if None.
+            temperature (Optional[float]): Sampling temperature. Uses instance default if None.
+            top_k (Optional[int]): Top-k sampling parameter. Uses instance default if None.
+            top_p (Optional[float]): Top-p sampling parameter. Uses instance default if None.
+            repeat_penalty (Optional[float]): Penalty for repeated tokens. Uses instance default if None.
+            repeat_last_n (Optional[int]): Number of previous tokens to consider for repeat penalty. Uses instance default if None.
+            seed (Optional[int]): Random seed for generation. Uses instance default if None.
+            n_threads (Optional[int]): Number of threads to use. Uses instance default if None.
+            ctx_size (int | None): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, str], None]]): Callback function for streaming output.
+                - First parameter (str): The chunk of text received.
+                - Second parameter (str): The message type (e.g., MSG_TYPE.MSG_TYPE_CHUNK).
+            split:Optional[bool]: put to true if the prompt is a discussion
+            user_keyword:Optional[str]: when splitting we use this to extract user prompt 
+            ai_keyword:Optional[str]": when splitting we use this to extract ai prompt
+
+        Returns:
+            Union[str, dict]: Generated text or error dictionary if failed.
+        """
+        count = 0
+        output = ""
+        messages = [
+            {
+                "role": "system",
+                "content": system_prompt or "You are a helpful assistant.",
+            }
+        ]
+
+        # Prepare messages based on whether images are provided
+        if images:
+            if split:
+                messages += self.split_discussion(prompt,user_keyword=user_keyword, ai_keyword=ai_keyword)
+                if images:
+                    messages[-1]["content"] = [
+                        {
+                            "type": "text",
+                            "text": messages[-1]["content"]
+                        }
+                    ]+[
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{encode_image(image_path)}"
+                            }
+                        }
+                        for image_path in images
+                    ]
+            else:
+                messages.append({
+                        'role': 'user', 
+                        'content': [
+                                        {
+                                            "type": "text",
+                                            "text": prompt
+                                        }
+                                    ] + [
+                                        {
+                                            "type": "image_url",
+                                            "image_url": {
+                                                "url": f"data:image/jpeg;base64,{encode_image(image_path)}"
+                                            }
+                                        }
+                                        for image_path in images
+                                    ]
+                    }
+                )
+            
+        else:
+            
+            if split:
+                messages += self.split_discussion(prompt,user_keyword=user_keyword, ai_keyword=ai_keyword)
+                if images:
+                    messages[-1]["content"] = [
+                        {
+                            "type": "text",
+                            "text": messages[-1]["content"]
+                        }
+                    ]
+            else:
+                messages.append({
+                        'role': 'user', 
+                        'content': [
+                                        {
+                                            "type": "text",
+                                            "text": prompt
+                                        }
+                                    ]
+                    }
+                )
+
+        # Generate text using the OpenAI API
+        if self.completion_format == ELF_COMPLETION_FORMAT.Chat:
+            chat_completion = self.client.chat.completions.create(
+                model=self.model_name,  # Choose the engine according to your OpenAI plan
+                messages=messages,
+                max_tokens=n_predict,  # Adjust the desired length of the generated response
+                n=1,  # Specify the number of responses you want
+                temperature=temperature,  # Adjust the temperature for more or less randomness in the output
+                stream=stream
+            )
+
+            if stream:
+                for resp in chat_completion:
+                    if count >= n_predict:
+                        break
+                    try:
+                        word = resp.choices[0].delta.content
+                    except Exception as ex:
+                        word = ""
+                    if streaming_callback is not None:
+                        if not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                            break
+                    if word:
+                        output += word
+                        count += 1
+            else:
+                output = chat_completion.choices[0].message.content
+        else:
+            completion = self.client.completions.create(
+                model=self.model_name,  # Choose the engine according to your OpenAI plan
+                prompt=prompt,
+                max_tokens=n_predict,  # Adjust the desired length of the generated response
+                n=1,  # Specify the number of responses you want
+                temperature=temperature,  # Adjust the temperature for more or less randomness in the output
+                stream=stream
+            )
+
+            if stream:
+                for resp in completion:
+                    if count >= n_predict:
+                        break
+                    try:
+                        word = resp.choices[0].text
+                    except Exception as ex:
+                        word = ""
+                    if streaming_callback is not None:
+                        if not streaming_callback(word, "MSG_TYPE_CHUNK"):
+                            break
+                    if word:
+                        output += word
+                        count += 1
+            else:
+                output = completion.choices[0].text
+
+        return output
+    
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        # Build the request parameters
+        params = {
+            "model": self.model_name,
+            "messages": messages,
+            "max_tokens": n_predict,
+            "n": 1,
+            "temperature": temperature,
+            "top_p": top_p,
+            "frequency_penalty": repeat_penalty,
+            "stream": stream
+        }
+        # Add seed if available, as it's supported by newer OpenAI models
+        if seed is not None:
+            params["seed"] = seed
+
+        # Remove None values, as the API expects them to be absent
+        params = {k: v for k, v in params.items() if v is not None}
+        
+        output = ""
+        # 2. Call the API
+        try:
+            completion = self.client.chat.completions.create(**params)
+
+            if stream:
+                for chunk in completion:
+                    # The streaming response for chat has a different structure
+                    delta = chunk.choices[0].delta
+                    if delta.content:
+                        word = delta.content
+                        if streaming_callback is not None:
+                            if not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                        output += word
+            else:
+                output = completion.choices[0].message.content
+        
+        except Exception as e:
+            # Handle API errors gracefully
+            error_message = f"An error occurred with the OpenAI API: {e}"
+            if streaming_callback:
+                streaming_callback(error_message, MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {"status": "error", "message": error_message}
+            
+        return output
+    
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = None,
+             stream: Optional[bool] = None,
+             temperature: float = 0.7,
+             top_k: int = 40,
+             top_p: float = 0.9,
+             repeat_penalty: float = 1.1,
+             repeat_last_n: int = 64,
+             seed: Optional[int] = None,
+             n_threads: Optional[int] = None,
+             ctx_size: Optional[int] = None,
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with the OpenAI model using a LollmsDiscussion object.
+
+        Args:
+            discussion (LollmsDiscussion): The discussion object containing the conversation history.
+            branch_tip_id (Optional[str]): The ID of the message to use as the tip of the conversation branch. Defaults to the active branch.
+            n_predict (Optional[int]): Maximum number of tokens to generate.
+            stream (Optional[bool]): Whether to stream the output.
+            temperature (float): Sampling temperature.
+            top_k (int): Top-k sampling parameter (Note: not all OpenAI models use this).
+            top_p (float): Top-p sampling parameter.
+            repeat_penalty (float): Frequency penalty for repeated tokens.
+            seed (Optional[int]): Random seed for generation.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+
+        Returns:
+            Union[str, dict]: The generated text or an error dictionary.
+        """
+        # 1. Export the discussion to the OpenAI chat format
+        # This handles system prompts, user/assistant roles, and multi-modal content automatically.
+        messages = discussion.export("openai_chat", branch_tip_id)
+
+        # Build the request parameters
+        params = {
+            "model": self.model_name,
+            "messages": messages,
+            "max_tokens": n_predict,
+            "n": 1,
+            "temperature": temperature,
+            "top_p": top_p,
+            "frequency_penalty": repeat_penalty,
+            "stream": stream
+        }
+        # Add seed if available, as it's supported by newer OpenAI models
+        if seed is not None:
+            params["seed"] = seed
+
+        # Remove None values, as the API expects them to be absent
+        params = {k: v for k, v in params.items() if v is not None}
+        
+        output = ""
+        # 2. Call the API
+        try:
+            # Check if we should use the chat completions or legacy completions endpoint
+            if self.completion_format == ELF_COMPLETION_FORMAT.Chat:
+                completion = self.client.chat.completions.create(**params)
+
+                if stream:
+                    for chunk in completion:
+                        # The streaming response for chat has a different structure
+                        delta = chunk.choices[0].delta
+                        if delta.content:
+                            word = delta.content
+                            if streaming_callback is not None:
+                                if not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                                    break
+                            output += word
+                else:
+                    output = completion.choices[0].message.content
+
+            else: # Fallback to legacy completion format (not recommended for chat)
+                # We need to format the messages list into a single string prompt
+                legacy_prompt = discussion.export("openai_completion", branch_tip_id)
+                legacy_params = {
+                    "model": self.model_name,
+                    "prompt": legacy_prompt,
+                    "max_tokens": n_predict,
+                    "n": 1,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                    "frequency_penalty": repeat_penalty,
+                    "stream": stream
+                }
+                completion = self.client.completions.create(**legacy_params)
+
+                if stream:
+                    for chunk in completion:
+                        word = chunk.choices[0].text
+                        if streaming_callback is not None:
+                            if not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                        output += word
+                else:
+                    output = completion.choices[0].text
+        
+        except Exception as e:
+            # Handle API errors gracefully
+            error_message = f"An error occurred with the OpenAI API: {e}"
+            if streaming_callback:
+                streaming_callback(error_message, MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {"status": "error", "message": error_message}
+            
+        return output    
+    def tokenize(self, text: str) -> list:
+        """
+        Tokenize the input text into a list of characters.
+
+        Args:
+            text (str): The text to tokenize.
+
+        Returns:
+            list: List of individual characters.
+        """
+        try:
+            return tiktoken.model.encoding_for_model(self.model_name).encode(text)
+        except:
+            return tiktoken.model.encoding_for_model("gpt-3.5-turbo").encode(text)
+            
+    def detokenize(self, tokens: list) -> str:
+        """
+        Convert a list of tokens back to text.
+
+        Args:
+            tokens (list): List of tokens (characters) to detokenize.
+
+        Returns:
+            str: Detokenized text.
+        """
+        try:
+            return tiktoken.model.encoding_for_model(self.model_name).decode(tokens)
+        except:
+            return tiktoken.model.encoding_for_model("gpt-3.5-turbo").decode(tokens)
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text.
+
+        Args:
+            tokens (list): List of tokens to detokenize.
+
+        Returns:
+            int: Number of tokens in text.
+        """        
+        return len(self.tokenize(text))
+
+        
+    def embed(self, text: str, **kwargs) -> list:
+        """
+        Get embeddings for the input text using OpenAI API
+        
+        Args:
+            text (str or List[str]): Input text to embed
+            **kwargs: Additional arguments like model, truncate, options, keep_alive
+        
+        Returns:
+            dict: Response containing embeddings
+        """
+        pass    
+    def get_model_info(self) -> dict:
+        """
+        Return information about the current OpenAI model.
+
+        Returns:
+            dict: Dictionary containing model name, version, and host address.
+        """
+        return {
+            "name": "OpenAI",
+            "version": "2.0",
+            "host_address": self.host_address,
+            "model_name": self.model_name
+        }
+
+    def listModels(self) -> List[Dict]:
+        # Known context lengths
+        known_context_lengths = {
+            "gpt-4o": 128000,
+            "gpt-4": 8192,
+            "gpt-4-0613": 8192,
+            "gpt-4-1106-preview": 128000,
+            "gpt-4-0125-preview": 128000,
+            "gpt-4-turbo": 128000,
+            "gpt-3.5-turbo": 4096,
+            "gpt-3.5-turbo-16k": 16000,
+            "gpt-3.5-turbo-1106": 16385,
+            "gpt-3.5-turbo-0125": 16385,
+            "text-davinci-003": 4097,
+            "text-davinci-002": 4097,
+            "davinci": 2049,
+            "curie": 2049,
+            "babbage": 2049,
+            "ada": 2049,
+        }
+
+        generation_prefixes = (
+            "gpt-",
+            "text-davinci",
+            "davinci",
+            "curie",
+            "babbage",
+            "ada"
+        )
+
+        models_info = []
+        prompt_buffer = 500
+
+        try:
+            models = self.client.models.list()
+            for model in models.data:
+                model_id = model.id
+                if model_id.startswith(generation_prefixes):
+                    context_length = known_context_lengths.get(model_id, "unknown")
+                    max_generation = (
+                        context_length - prompt_buffer
+                        if isinstance(context_length, int)
+                        else "unknown"
+                    )
+                    models_info.append({
+                        "model_name": model_id,
+                        "owned_by": getattr(model, "owned_by", "N/A"),
+                        "created": getattr(model, "created", "N/A"),
+                        "context_length": context_length,
+                        "max_generation": max_generation,
+                    })
+                else:
+                    models_info.append({
+                        "model_name": model_id,
+                        "owned_by": getattr(model, "owned_by", "N/A"),
+                        "created": getattr(model, "created", "N/A"),
+                        "context_length": None,
+                        "max_generation": None,
+                    })
+                    
+        except Exception as e:
+            print(f"Failed to list models: {e}")
+
+        return models_info
+
+
+    def load_model(self, model_name: str) -> bool:
+        """
+        Load a specific model into the OpenAI binding.
+
+        Args:
+            model_name (str): Name of the model to load.
+
+        Returns:
+            bool: True if model loaded successfully.
+        """
+        self.model = model_name
+        self.model_name = model_name
+        return True

lollms_client/llm_bindings/ollama/__init__.py

@@ -258,7 +258,77 @@ class OllamaBinding(LollmsLLMBinding):
             error_message = f"An unexpected error occurred: {str(ex)}"
             trace_exception(ex)
             return {"status": False, "error": error_message}
+
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        if not self.ollama_client:
+             return {"status": False, "error": "Ollama client not initialized."}
+
+        options = {}
+        if n_predict is not None: options['num_predict'] = n_predict
+        if temperature is not None: options['temperature'] = float(temperature)
+        if top_k is not None: options['top_k'] = top_k
+        if top_p is not None: options['top_p'] = top_p
+        if repeat_penalty is not None: options['repeat_penalty'] = repeat_penalty
+        if repeat_last_n is not None: options['repeat_last_n'] = repeat_last_n
+        if seed is not None: options['seed'] = seed
+        if n_threads is not None: options['num_thread'] = n_threads
+        if ctx_size is not None: options['num_ctx'] = ctx_size
+        
+        full_response_text = ""
+
+        try:
+            if stream:
+                response_stream = self.ollama_client.chat(
+                    model=self.model_name,
+                    messages=messages,
+                    stream=True,
+                    options=options if options else None
+                )
+                for chunk_dict in response_stream:
+                    chunk_content = chunk_dict.get('message', {}).get('content', '')
+                    if chunk_content: # Ensure there is content to process
+                        full_response_text += chunk_content
+                        if streaming_callback:
+                            if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break # Callback requested stop
+                return full_response_text
+            else: # Not streaming
+                response_dict = self.ollama_client.chat(
+                    model=self.model_name,
+                    messages=messages,
+                    stream=False,
+                    options=options if options else None
+                )
+                return response_dict.get('message', {}).get('content', '')
+
+        except ollama.ResponseError as e:
+            error_message = f"Ollama API ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message, "status_code": e.status_code}
+        except ollama.RequestError as e: # Covers connection errors, timeouts during request
+            error_message = f"Ollama API RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
     
+
     def chat(self,
              discussion: LollmsDiscussion,
              branch_tip_id: Optional[str] = None,

lollms_client/llm_bindings/open_router/__init__.py

@@ -276,7 +276,6 @@ if __name__ == '__main__':
         binding.load_model("meta-llama/llama-3-8b-instruct:free") # Use the free tier on OpenRouter
         full_streamed_text = ""
         def stream_callback(chunk: str, msg_type: int):
-            nonlocal full_streamed_text
             ASCIIColors.green(chunk, end="", flush=True)
             full_streamed_text += chunk
             return True
@@ -301,4 +300,4 @@ if __name__ == '__main__':
         ASCIIColors.error(f"An error occurred during testing: {e}")
         trace_exception(e)
 
-    ASCIIColors.yellow("\nOpenRouterBinding test finished.")
+    ASCIIColors.yellow("\nOpenRouterBinding test finished.")

lollms_client/llm_bindings/openai/__init__.py

@@ -175,14 +175,25 @@ class OpenAIBinding(LollmsLLMBinding):
 
         # Generate text using the OpenAI API
         if self.completion_format == ELF_COMPLETION_FORMAT.Chat:
-            chat_completion = self.client.chat.completions.create(
-                model=self.model_name,  # Choose the engine according to your OpenAI plan
-                messages=messages,
-                max_tokens=n_predict,  # Adjust the desired length of the generated response
-                n=1,  # Specify the number of responses you want
-                temperature=temperature,  # Adjust the temperature for more or less randomness in the output
-                stream=stream
-            )
+            try:
+                chat_completion = self.client.chat.completions.create(
+                    model=self.model_name,  # Choose the engine according to your OpenAI plan
+                    messages=messages,
+                    max_tokens=n_predict,  # Adjust the desired length of the generated response
+                    n=1,  # Specify the number of responses you want
+                    temperature=temperature,  # Adjust the temperature for more or less randomness in the output
+                    stream=stream
+                )
+            except Exception as ex:
+                # exception for new openai models
+                chat_completion = self.client.chat.completions.create(
+                    model=self.model_name,  # Choose the engine according to your OpenAI plan
+                    messages=messages,
+                    max_completion_tokens=n_predict,  # Adjust the desired length of the generated response
+                    n=1,  # Specify the number of responses you want
+                    temperature=1,  # Adjust the temperature for more or less randomness in the output
+                    stream=stream
+                )
 
             if stream:
                 for resp in chat_completion:
@@ -229,6 +240,75 @@ class OpenAIBinding(LollmsLLMBinding):
 
         return output
     
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        # Build the request parameters
+        params = {
+            "model": self.model_name,
+            "messages": messages,
+            "max_tokens": n_predict,
+            "n": 1,
+            "temperature": temperature,
+            "top_p": top_p,
+            "frequency_penalty": repeat_penalty,
+            "stream": stream
+        }
+        # Add seed if available, as it's supported by newer OpenAI models
+        if seed is not None:
+            params["seed"] = seed
+
+        # Remove None values, as the API expects them to be absent
+        params = {k: v for k, v in params.items() if v is not None}
+        
+        output = ""
+        # 2. Call the API
+        try:
+            try:
+                completion = self.client.chat.completions.create(**params)
+            except Exception as ex:
+                # exception for new openai models
+                params["max_completion_tokens"]=params["max_tokens"]
+                params["temperature"]=1
+                del params["max_tokens"]
+                del params["top_p"]
+                del params["frequency_penalty"]
+                
+                completion = self.client.chat.completions.create(**params)
+            if stream:
+                for chunk in completion:
+                    # The streaming response for chat has a different structure
+                    delta = chunk.choices[0].delta
+                    if delta.content:
+                        word = delta.content
+                        if streaming_callback is not None:
+                            if not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                        output += word
+            else:
+                output = completion.choices[0].message.content
+        
+        except Exception as e:
+            # Handle API errors gracefully
+            error_message = f"An error occurred with the OpenAI API: {e}"
+            if streaming_callback:
+                streaming_callback(error_message, MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {"status": "error", "message": error_message}
+            
+        return output
+    
     def chat(self,
              discussion: LollmsDiscussion,
              branch_tip_id: Optional[str] = None,
@@ -289,8 +369,18 @@ class OpenAIBinding(LollmsLLMBinding):
         try:
             # Check if we should use the chat completions or legacy completions endpoint
             if self.completion_format == ELF_COMPLETION_FORMAT.Chat:
-                completion = self.client.chat.completions.create(**params)
-
+                try:
+                    completion = self.client.chat.completions.create(**params)
+                except Exception as ex:
+                    # exception for new openai models
+                    params["max_completion_tokens"]=params["max_tokens"]
+                    params["temperature"]=1
+                    del params["max_tokens"]
+                    del params["top_p"]
+                    del params["frequency_penalty"]
+                    
+                    completion = self.client.chat.completions.create(**params)
+                    
                 if stream:
                     for chunk in completion:
                         # The streaming response for chat has a different structure
@@ -457,6 +547,15 @@ class OpenAIBinding(LollmsLLMBinding):
                         "context_length": context_length,
                         "max_generation": max_generation,
                     })
+                else:
+                    models_info.append({
+                        "model_name": model_id,
+                        "owned_by": getattr(model, "owned_by", "N/A"),
+                        "created": getattr(model, "created", "N/A"),
+                        "context_length": None,
+                        "max_generation": None,
+                    })
+                    
         except Exception as e:
             print(f"Failed to list models: {e}")
 

lollms_client/lollms_core.py

@@ -287,6 +287,19 @@ class LollmsClient():
         else:
             return None
 
+    def get_model_name(self):
+        if self.binding:
+            return self.binding.model_name
+        else:
+            return None
+
+    def set_model_name(self, model_name)->bool:
+        if self.binding:
+            self.binding.model_name = model_name
+            return True
+        else:
+            return False
+
     def update_tts_binding(self, binding_name: str, config: Optional[Dict[str, Any]] = None):
         """Update the TTS binding with a new configuration."""
         self.tts = self.tts_binding_manager.create_binding(
@@ -521,6 +534,57 @@ class LollmsClient():
             )
         raise RuntimeError("LLM binding not initialized.")
 
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        """
+        Generate text using the active LLM binding, using instance defaults if parameters are not provided.
+
+        Args:
+            messages (List[Dict]): A openai compatible list of messages
+            n_predict (Optional[int]): Maximum number of tokens to generate. Uses instance default if None.
+            stream (Optional[bool]): Whether to stream the output. Uses instance default if None.
+            temperature (Optional[float]): Sampling temperature. Uses instance default if None.
+            top_k (Optional[int]): Top-k sampling parameter. Uses instance default if None.
+            top_p (Optional[float]): Top-p sampling parameter. Uses instance default if None.
+            repeat_penalty (Optional[float]): Penalty for repeated tokens. Uses instance default if None.
+            repeat_last_n (Optional[int]): Number of previous tokens to consider for repeat penalty. Uses instance default if None.
+            seed (Optional[int]): Random seed for generation. Uses instance default if None.
+            n_threads (Optional[int]): Number of threads to use. Uses instance default if None.
+            ctx_size (int | None): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+
+        Returns:
+            Union[str, dict]: Generated text or error dictionary if failed.
+        """
+        if self.binding:
+            return self.binding.generate_from_messages(
+                messages=messages,
+                n_predict=n_predict if n_predict is not None else self.default_n_predict,
+                stream=stream if stream is not None else self.default_stream,
+                temperature=temperature if temperature is not None else self.default_temperature,
+                top_k=top_k if top_k is not None else self.default_top_k,
+                top_p=top_p if top_p is not None else self.default_top_p,
+                repeat_penalty=repeat_penalty if repeat_penalty is not None else self.default_repeat_penalty,
+                repeat_last_n=repeat_last_n if repeat_last_n is not None else self.default_repeat_last_n,
+                seed=seed if seed is not None else self.default_seed,
+                n_threads=n_threads if n_threads is not None else self.default_n_threads,
+                ctx_size = ctx_size if ctx_size is not None else self.default_ctx_size,
+                streaming_callback=streaming_callback if streaming_callback is not None else self.default_streaming_callback,
+            )
+        raise RuntimeError("LLM binding not initialized.")
 
     def chat(self,
              discussion: LollmsDiscussion,

lollms_client/lollms_llm_binding.py

@@ -6,8 +6,8 @@ from typing import Optional, Callable, List, Union
 from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
 import importlib
 from pathlib import Path
-from typing import Optional
-from ascii_colors import trace_exception
+from typing import Optional, Dict, List
+from ascii_colors import trace_exception, ASCIIColors
 from lollms_client.lollms_types import MSG_TYPE
 from lollms_client.lollms_discussion import LollmsDiscussion
 import re
@@ -73,7 +73,45 @@ class LollmsLLMBinding(ABC):
             Union[str, dict]: Generated text or error dictionary if failed.
         """
         pass
-    
+
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        """
+        Generate text using the active LLM binding, using instance defaults if parameters are not provided.
+
+        Args:
+            messages (List[Dict]): A openai compatible list of messages
+            n_predict (Optional[int]): Maximum number of tokens to generate. Uses instance default if None.
+            stream (Optional[bool]): Whether to stream the output. Uses instance default if None.
+            temperature (Optional[float]): Sampling temperature. Uses instance default if None.
+            top_k (Optional[int]): Top-k sampling parameter. Uses instance default if None.
+            top_p (Optional[float]): Top-p sampling parameter. Uses instance default if None.
+            repeat_penalty (Optional[float]): Penalty for repeated tokens. Uses instance default if None.
+            repeat_last_n (Optional[int]): Number of previous tokens to consider for repeat penalty. Uses instance default if None.
+            seed (Optional[int]): Random seed for generation. Uses instance default if None.
+            n_threads (Optional[int]): Number of threads to use. Uses instance default if None.
+            ctx_size (int | None): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+
+        Returns:
+            Union[str, dict]: Generated text or error dictionary if failed.
+        """
+        ASCIIColors.red("This binding does not support generate_from_messages")
+
+
     @abstractmethod
     def chat(self,
              discussion: LollmsDiscussion,

{lollms_client-0.27.2.dist-info → lollms_client-0.27.3.dist-info}/METADATA

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

{lollms_client-0.27.2.dist-info → lollms_client-0.27.3.dist-info}/RECORD

@@ -20,18 +20,21 @@ examples/deep_analyze/deep_analyse.py,sha256=fZNmDrfEAuxEAfdbjAgJYIh1k6wbiuZ4Rvw
 examples/deep_analyze/deep_analyze_multiple_files.py,sha256=fOryShA33P4IFxcxUDe-nJ2kW0v9w9yW8KsToS3ETl8,1032
 examples/generate_and_speak/generate_and_speak.py,sha256=RAlvRwtEKXCh894l9M3iQbADe8CvF5N442jtRurK02I,13908
 examples/generate_game_sfx/generate_game_fx.py,sha256=MgLNGi4hGBRoyr4bqYuCUdCSqd-ldDVfF0VSDUjgzsg,10467
+examples/lollms_chat/calculator.py,sha256=0mIakM3XehyUaoCsBS0l3eDTrqc81E88itfdHmdMYYc,2484
+examples/lollms_chat/derivative.py,sha256=1a4LKx_mD6Mq9oh-iGON0nfINP3Ul_TUSeDjEX7vSzE,1896
+examples/lollms_chat/test_openai_compatible_with_lollms_chat.py,sha256=JsooHpu7Hk4HSZNXvlL6N76-K6eFyq4gOH1lcsv_BcA,419
 examples/mcp_examples/external_mcp.py,sha256=swx1KCOz6jk8jGTAycq-xu7GXPAhRMDe1x--SKocugE,13371
 examples/mcp_examples/local_mcp.py,sha256=w40dgayvHYe01yvekEE0LjcbkpwKjWwJ-9v4_wGYsUk,9113
 examples/mcp_examples/openai_mcp.py,sha256=7IEnPGPXZgYZyiES_VaUbQ6viQjenpcUxGiHE-pGeFY,11060
 examples/mcp_examples/run_remote_mcp_example_v2.py,sha256=bbNn93NO_lKcFzfIsdvJJijGx2ePFTYfknofqZxMuRM,14626
 examples/mcp_examples/run_standard_mcp_example.py,sha256=GSZpaACPf3mDPsjA8esBQVUsIi7owI39ca5avsmvCxA,9419
 examples/test_local_models/local_chat.py,sha256=slakja2zaHOEAUsn2tn_VmI4kLx6luLBrPqAeaNsix8,456
-lollms_client/__init__.py,sha256=FNukbXeOwWGP1i58B6V4_LtjA1QumGvROeGjoxK2wBs,1147
+lollms_client/__init__.py,sha256=KvZT0D6ahj16AharXFGhRMw2qc4a4HXDLYO75H5medY,1147
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=SuU5HpBHXkG9GGpSMRHiRA-qSDBFNEDis3V9ZaV_Tvw,165323
+lollms_client/lollms_core.py,sha256=QliAE6hYiIGqQSDWWmjii1Hj8hsj3IxwBuUFshxJDlM,169099
 lollms_client/lollms_discussion.py,sha256=tvANNvpTkUr4L6GKowosIyfV7l3SA6cXnzElt36e2s8,52133
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
-lollms_client/lollms_llm_binding.py,sha256=eBRbiTLsaB-g-UwB2JQTdzTQ6qFvDZk14viDdcxy-ck,12451
+lollms_client/lollms_llm_binding.py,sha256=cU0cmxZfIrp-ofutbRLx7W_59dxzPXpU-vO98MqVnQA,14788
 lollms_client/lollms_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
 lollms_client/lollms_personality.py,sha256=dILUI5DZdzJ3NDDQiIsK2UptVF-jZK3XYXZ2bpXP_ew,8035
 lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
@@ -49,13 +52,14 @@ lollms_client/llm_bindings/gemini/__init__.py,sha256=ZflZVwAkAa-GfctuehOWIav977o
 lollms_client/llm_bindings/grok/__init__.py,sha256=5tIf3348RgAEaSp6FdG-LM9N8R7aR0t7OFspHf3XATs,23141
 lollms_client/llm_bindings/groq/__init__.py,sha256=zyWKM78qHwSt5g0Bb8Njj7Jy8CYuLMyplx2maOKFFpg,12218
 lollms_client/llm_bindings/hugging_face_inference_api/__init__.py,sha256=PxgeRqT8dpa9GZoXwtSncy9AUgAN2cDKrvp_nbaWq0E,14027
-lollms_client/llm_bindings/litellm/__init__.py,sha256=xlTaKosxK1tKz1YJ6witK6wAJHIENTV6O7ZbfpUOdB4,11289
+lollms_client/llm_bindings/litellm/__init__.py,sha256=pNkwyRPeENvTM4CDh6Pj3kQfxHfhX2pvXhGJDjKjp30,12340
 lollms_client/llm_bindings/llamacpp/__init__.py,sha256=Qj5RvsgPeHGNfb5AEwZSzFwAp4BOWjyxmm9qBNtstrc,63716
 lollms_client/llm_bindings/lollms/__init__.py,sha256=7GNv-YyX4YyaR1EP2banQEHnX47QpUyNZU6toAiX1ak,17854
+lollms_client/llm_bindings/lollms_chat/__init__.py,sha256=UU3Ep1YkB_pAPkZEA9PpuY_f2KUXghVyzAnUD-u2-tg,23035
 lollms_client/llm_bindings/mistral/__init__.py,sha256=624Gr462yBh52ttHFOapKgJOn8zZ1vZcTEcC3i4FYt8,12750
-lollms_client/llm_bindings/ollama/__init__.py,sha256=QufsYqak2VlA2XGbzks8u55yNJFeDH2V35NGeZABkm8,32554
-lollms_client/llm_bindings/open_router/__init__.py,sha256=10Dyb73zTdJATOWawJVqPgDmjN6mAw7LwQIYFIN6oJk,13274
-lollms_client/llm_bindings/openai/__init__.py,sha256=4Mk8eBdc9VScI0Sdh4g4p_0eU2afJeCEUEJnCQO-QkM,20014
+lollms_client/llm_bindings/ollama/__init__.py,sha256=1yxw_JXye_8l1YaEznK5QhOZmLV_opY-FkYnwy530eo,36109
+lollms_client/llm_bindings/open_router/__init__.py,sha256=v91BpNcuQCbbA6r82gbgMP8UYhSrJUMOf4UtOzEo18Q,13235
+lollms_client/llm_bindings/openai/__init__.py,sha256=pXuLDI7Js0LLXVDCHIMMB5rAQb_wC6JqGvK8B5S0Uy0,24596
 lollms_client/llm_bindings/openllm/__init__.py,sha256=xv2XDhJNCYe6NPnWBboDs24AQ1VJBOzsTuMcmuQ6xYY,29864
 lollms_client/llm_bindings/pythonllamacpp/__init__.py,sha256=7dM42TCGKh0eV0njNL1tc9cInhyvBRIXzN3dcy12Gl0,33551
 lollms_client/llm_bindings/tensor_rt/__init__.py,sha256=nPaNhGRd-bsG0UlYwcEqjd_UagCMEf5VEbBUW-GWu6A,32203
@@ -88,8 +92,8 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=0IEWG4zH3_sOkSb9WbZzkeV5
 lollms_client/tts_bindings/xtts/__init__.py,sha256=FgcdUH06X6ZR806WQe5ixaYx0QoxtAcOgYo87a2qxYc,18266
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-0.27.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.27.2.dist-info/METADATA,sha256=PLlEliNSNJfH4IkjgrxdrTaNW2QEoEWuF91u2zCszbI,25778
-lollms_client-0.27.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.27.2.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.27.2.dist-info/RECORD,,
+lollms_client-0.27.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.27.3.dist-info/METADATA,sha256=mkv0Y0vIE5s2o5TwsgZmODaY7e4crlfr1G5OWwMCD8Q,25778
+lollms_client-0.27.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.27.3.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.27.3.dist-info/RECORD,,