lollms-client 0.27.1__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.1" # 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

@@ -280,6 +280,26 @@ class LollmsClient():
             available = self.binding_manager.get_available_bindings()
             raise ValueError(f"Failed to update LLM binding: {binding_name}. Available: {available}")
 
+    def get_ctx_size(self, model_name=None):
+        if self.binding:
+            ctx_size = self.binding.get_ctx_size(model_name)
+            return ctx_size if ctx_size else self.default_ctx_size
+        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(
@@ -373,10 +393,6 @@ class LollmsClient():
         pass
 
     # --- Core LLM Binding Methods ---
-    def get_ctx_size(self, model_name):
-        return self.binding.get_ctx_size(model_name)
-
-
     def tokenize(self, text: str) -> list:
         """
         Tokenize text using the active LLM binding.
@@ -518,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,
@@ -1588,6 +1655,11 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             "description": """Generates and stores code into a buffer to be used by another tool. You can put the uuid of the generated code into the fields that require long code among the tools. If no tool requires code as input do not use put_code_in_buffer. put_code_in_buffer do not execute the code nor does it audit it.""",
             "input_schema": {"type": "object", "properties": {"prompt": {"type": "string", "description": "A detailed natural language description of the code's purpose and requirements."}, "language": {"type": "string", "description": "The programming language of the generated code. By default it uses python."}}, "required": ["prompt"]}
         })
+        available_tools.append({
+            "name": "view_generated_code",
+            "description": """Views the code that was generated and stored to the buffer. You need to have a valid uuid of the generated code.""",
+            "input_schema": {"type": "object", "properties": {"code_id": {"type": "string", "description": "The case sensitive uuid of the generated code."}}, "required": ["uuid"]}
+        })
         # Add the new refactor_scratchpad tool definition
         available_tools.append({
             "name": "refactor_scratchpad",
@@ -1599,7 +1671,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         formatted_tools_list += "\n**request_clarification**:\nUse if the user's request is ambiguous and you can not infer a clear idea of his intent. this tool has no parameters."
         formatted_tools_list += "\n**final_answer**:\nUse when you are ready to respond to the user. this tool has no parameters."
 
-        if discovery_step_id: log_event("**Discovering tools**",MSG_TYPE.MSG_TYPE_STEP_END, event_id=discovery_step_id)
+        if discovery_step_id: log_event(f"**Discovering tools** found {len(available_tools)} tools",MSG_TYPE.MSG_TYPE_STEP_END, event_id=discovery_step_id)
 
         # --- 2. Dynamic Reasoning Loop ---
         for i in range(max_reasoning_steps):
@@ -1699,6 +1771,16 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     if code_gen_id: log_event(f"Generating code...", MSG_TYPE.MSG_TYPE_TOOL_CALL, metadata={"id": code_gen_id, "result": tool_result})
                     if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, event_id= reasoning_step_id)
                     continue # Go to the next reasoning step immediately
+                if tool_name == 'view_generated_code':
+                    code_id = tool_params.get("code_id")
+                    if code_id:
+                        tool_result = {"status": "success", "code_id": code_id, "generated_code":generated_code_store[code_uuid]}
+                    else:
+                        tool_result = {"status": "error", "code_id": code_id, "error":"Unknown uuid"}
+                    observation_text = f"```json\n{json.dumps(tool_result, indent=2)}\n```"
+                    current_scratchpad += f"\n\n### Step {i+1}: Observation\n- **Action:** Called `{tool_name}`\n- **Result:**\n{observation_text}"
+                    log_event(f"Result from `{tool_name}`:\n```\n{generated_code_store[code_uuid]}\n```\n", MSG_TYPE.MSG_TYPE_TOOL_CALL, metadata={"id": code_gen_id, "result": tool_result})
+                    continue
                 if tool_name == 'refactor_scratchpad':
                     scratchpad_cleaning_prompt = f"""Enhance this scratchpad content to be more organized and comprehensive. Keep relevant experience information and remove any useless redundancies. Try to log learned things from the context so that you won't make the same mistakes again. Do not remove the main objective information or any crucial information that may be useful for the next iterations. Answer directly with the new scratchpad content without any comments.
 --- YOUR INTERNAL SCRATCHPAD (Work History & Analysis) ---

lollms_client/lollms_discussion.py

@@ -372,6 +372,7 @@ class LollmsDiscussion:
         object.__setattr__(self, 'autosave', autosave)
         object.__setattr__(self, 'max_context_size', max_context_size)
         object.__setattr__(self, 'scratchpad', "")
+        object.__setattr__(self, 'images', [])
         
         # Internal state
         object.__setattr__(self, '_session', None)
@@ -1048,6 +1049,61 @@ class LollmsDiscussion:
         self.touch()
         print(f"[INFO] Discussion auto-pruned. {len(messages_to_prune)} messages summarized. History preserved.")
 
+    def count_discussion_tokens(self, format_type: str, branch_tip_id: Optional[str] = None) -> int:
+        """Counts the number of tokens in the exported discussion content.
+
+        This method exports the discussion in the specified format and then uses
+        the lollmsClient's tokenizer to count the tokens in the resulting text.
+
+        Args:
+            format_type: The target format (e.g., "lollms_text", "openai_chat").
+            branch_tip_id: The ID of the message to use as the end of the context.
+                           Defaults to the active branch ID.
+
+        Returns:
+            The total number of tokens.
+        """
+        exported_content = self.export(format_type, branch_tip_id)
+        
+        text_to_count = ""
+        if isinstance(exported_content, str):
+            text_to_count = exported_content
+        elif isinstance(exported_content, list):
+            # Handle list of dicts (OpenAI/Ollama format)
+            full_content = []
+            for message in exported_content:
+                content = message.get("content")
+                if isinstance(content, str):
+                    full_content.append(content)
+                elif isinstance(content, list): # Handle OpenAI content parts
+                    for part in content:
+                        if part.get("type") == "text":
+                            full_content.append(part.get("text", ""))
+            text_to_count = "\n".join(full_content)
+
+        return self.lollmsClient.count_tokens(text_to_count)
+
+    def get_context_status(self, branch_tip_id: Optional[str] = None) -> Dict[str, Optional[int]]:
+        """Returns the current token count and the maximum context size.
+
+        This provides a snapshot of the context usage, taking into account
+        any non-destructive pruning that has occurred. The token count is
+        based on the "lollms_text" export format, which is the format used
+        for pruning calculations.
+
+        Args:
+            branch_tip_id: The ID of the message branch to measure. Defaults
+                           to the active branch.
+
+        Returns:
+            A dictionary with 'current_tokens' and 'max_tokens'.
+        """
+        current_tokens = self.count_discussion_tokens("lollms_text", branch_tip_id)
+        return {
+            "current_tokens": current_tokens,
+            "max_tokens": self.max_context_size
+        }
+
     def switch_to_branch(self, branch_id):
         self.active_branch_id = branch_id
 
@@ -1078,4 +1134,4 @@ class LollmsDiscussion:
         new_metadata = (self.metadata or {}).copy()
         new_metadata[itemname] = item_value
         self.metadata = new_metadata
-        self.commit()
+        self.commit()

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,
@@ -115,8 +153,9 @@ class LollmsLLMBinding(ABC):
         """
         pass
 
-    def get_ctx_size(self, model_name):
-        return 32000
+    def get_ctx_size(self, model_name=None):
+        # if model_name is none use current model name
+        return None
 
 
     @abstractmethod

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.27.1
+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.1.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=sUL95Hk1acM0CHbqz-eQZDE39r9R7dkV4Q6uK18_5IE,1147
+lollms_client/__init__.py,sha256=KvZT0D6ahj16AharXFGhRMw2qc4a4HXDLYO75H5medY,1147
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=x1RF4EZfEqawBtU7iJKMV3JiwwlYK_8AbwZJehHj4kc,163851
-lollms_client/lollms_discussion.py,sha256=aGjjAuRUaPaZvVh8sRWUrSYH8pEGa6j9iM9mTGIqdHQ,49633
+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=vtX158AWHSiUUDh7UU6BmyomhB3IXBTrxvGIXcADZfA,12391
+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.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.27.1.dist-info/METADATA,sha256=4QW25XghKUQNEX3y_RFrE9me4SP_efyvet4Z-76h4rc,25778
-lollms_client-0.27.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.27.1.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.27.1.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,,