lollms-client 0.12.6__py3-none-any.whl → 0.13.1__py3-none-any.whl

examples/text_2_audio.py

@@ -0,0 +1,77 @@
+from lollms_client import LollmsClient # Removed LollmsTTS import
+from lollms_client.lollms_types import MSG_TYPE # Import MSG_TYPE if callback uses it
+import random
+from ascii_colors import ASCIIColors # Assuming this might be used for better output
+
+# Initialize the LollmsClient instance, enabling the TTS binding
+# We'll use the 'lollms' tts binding by default.
+# The host_address in LollmsClient will be used by the lollms tts binding.
+lc = LollmsClient(
+    tts_binding_name="lollms" # Explicitly enable the lollms TTS binding
+)
+
+if not lc.tts:
+    ASCIIColors.error("TTS binding could not be initialized. Please check your LollmsClient setup and server.")
+    exit()
+
+voices = lc.tts.list_voices() # Use the new method via lc.tts
+
+# Pick a voice randomly
+if voices:
+    random_voice = random.choice(voices)
+    ASCIIColors.info(f"Selected voice: {random_voice}")
+else:
+    ASCIIColors.warning("No voices found. Using server default.")
+    random_voice = None # Or a known default like "main_voice"
+
+# Generate Text
+# response = lc.generate_text(prompt="Once upon a time", stream=False, temperature=0.5)
+# print(response)
+
+# # Generate Completion
+# response = lc.generate_completion(prompt="What is the capital of France", stream=False, temperature=0.5)
+# print(response)
+
+
+def cb(chunk, msg_type: MSG_TYPE, params=None, metadata=None): # Added params and metadata for full signature
+    print(chunk,end="",flush=True)
+    return True # Callback should return True to continue streaming
+
+response_text = lc.generate_text(prompt="One plus one equals ", stream=False, temperature=0.5, streaming_callback=cb)
+print() # For newline after streaming
+ASCIIColors.green(f"Generated text: {response_text}")
+print()
+
+if response_text and not isinstance(response_text, dict): # Check if generation was successful
+    try:
+        # Assuming generate_audio now might return status or file path rather than direct audio bytes for 'lollms' binding
+        # based on its current server behavior.
+        # If generate_audio for 'lollms' binding is expected to save a file and return status:
+        audio_generation_status = lc.tts.generate_audio(response_text, voice=random_voice, fn="output_example_text_2_audio.wav") # Example filename
+        ASCIIColors.info(f"Audio generation request status: {audio_generation_status}")
+        ASCIIColors.yellow(f"Audio should be saved as 'output_example_text_2_audio.wav' by the server in its default output path.")
+
+    except Exception as e:
+        ASCIIColors.error(f"Error during text to audio conversion: {e}")
+else:
+    ASCIIColors.error(f"Text generation failed or returned an error: {response_text}")
+
+
+# List Mounted Personalities (This is an LLM feature, specific to 'lollms' LLM binding)
+if lc.binding and hasattr(lc.binding, 'lollms_listMountedPersonalities'):
+    personalities_response = lc.listMountedPersonalities()
+    ASCIIColors.blue("\nMounted Personalities:")
+    print(personalities_response)
+else:
+    ASCIIColors.yellow("\nlistMountedPersonalities not available for the current LLM binding.")
+
+
+# List Models (This is an LLM feature)
+models_response = lc.listModels()
+ASCIIColors.blue("\nAvailable LLM Models:")
+print(models_response)
+
+# List available TTS bindings (for demonstration)
+if hasattr(lc, 'tts_binding_manager'):
+    available_tts_bindings = lc.tts_binding_manager.get_available_bindings()
+    ASCIIColors.cyan(f"\nAvailable TTS bindings in client: {available_tts_bindings}")

examples/text_2_image.py

@@ -0,0 +1,140 @@
+from lollms_client import LollmsClient
+from lollms_client.lollms_types import MSG_TYPE # If using callbacks
+from ascii_colors import ASCIIColors, trace_exception
+from PIL import Image
+from pathlib import Path
+import io
+import os
+
+# --- Configuration ---
+# This client_id should match one known by your LoLLMs WebUI if security is enabled for these endpoints.
+# For a default local setup, it might not be strictly checked for /generate_image,
+# but IS required for /list_tti_services, /get_active_tti_settings, /set_active_tti_settings.
+LOLLMS_CLIENT_ID = "my_lollms_client_id" # Replace with your actual client ID or a test one
+
+# Initialize LollmsClient, enabling the TTI 'lollms' binding
+# The service_key here is used as client_id by the TTI binding for lollms
+lc = LollmsClient(
+    host_address="http://localhost:9600",
+    tti_binding_name="lollms"
+)
+
+if not lc.tti:
+    ASCIIColors.error("TTI binding could not be initialized. Please check LollmsClient setup.")
+    exit()
+
+def test_list_tti_services():
+    ASCIIColors.cyan("\n--- Testing List TTI Services ---")
+    try:
+        # client_id is taken from lc.service_key by the binding
+        services = lc.tti.list_services()
+        if services:
+            ASCIIColors.green("Available TTI Services:")
+            for i, service in enumerate(services):
+                print(f"  {i+1}. Name: {service.get('name')}, Caption: {service.get('caption')}")
+        else:
+            ASCIIColors.yellow("No TTI services listed or an empty list was returned.")
+    except Exception as e:
+        ASCIIColors.error(f"Error listing TTI services: {e}")
+        trace_exception(e)
+
+def test_get_tti_settings():
+    ASCIIColors.cyan("\n--- Testing Get Active TTI Settings ---")
+    try:
+        # client_id is taken from lc.service_key by the binding
+        settings = lc.tti.get_settings()
+        if settings: # Server returns a list for settings template
+            ASCIIColors.green("Current Active TTI Settings/Template:")
+            # Assuming settings is a list of dicts (template format)
+            for setting_item in settings:
+                print(f"  - Name: {setting_item.get('name')}, Type: {setting_item.get('type')}, Value: {setting_item.get('value')}, Help: {setting_item.get('help')}")
+        elif isinstance(settings, dict) and not settings: # Empty dict if no TTI active
+             ASCIIColors.yellow("No active TTI service or settings configured on the server.")
+        else:
+            ASCIIColors.yellow("Could not retrieve TTI settings or format unexpected.")
+            print(f"Received: {settings}")
+    except Exception as e:
+        ASCIIColors.error(f"Error getting TTI settings: {e}")
+        trace_exception(e)
+
+def test_set_tti_settings():
+    ASCIIColors.cyan("\n--- Testing Set Active TTI Settings (Illustrative) ---")
+    ASCIIColors.yellow("Note: This test requires knowing the exact settings structure of your active TTI service.")
+    ASCIIColors.yellow("Skipping actual setting change to avoid misconfiguration.")
+    # Example: If you knew your TTI service had a 'quality' setting:
+    # example_settings_to_set = [
+    #     {"name": "quality", "value": "high", "type": "str", "help": "Image quality"},
+    #     # ... other settings from get_settings()
+    # ]
+    # try:
+    #     # client_id is taken from lc.service_key
+    #     success = lc.tti.set_settings(example_settings_to_set)
+    #     if success:
+    #         ASCIIColors.green("Successfully sent settings update request.")
+    #     else:
+    #         ASCIIColors.red("Failed to set TTI settings (server indicated failure or no change).")
+    # except Exception as e:
+    #     ASCIIColors.error(f"Error setting TTI settings: {e}")
+
+def test_generate_image():
+    ASCIIColors.cyan("\n--- Testing Generate Image ---")
+    prompt = "A futuristic cityscape at sunset, neon lights, flying vehicles"
+    negative_prompt = "blurry, low quality, ugly, text, watermark"
+    width = 512
+    height = 512
+    home_dir = Path.home()
+    documents_dir = home_dir / "Documents"
+    output_filename = documents_dir/"generated_lollms_image.jpg"
+
+    ASCIIColors.info(f"Prompt: {prompt}")
+    ASCIIColors.info(f"Negative Prompt: {negative_prompt}")
+    ASCIIColors.info(f"Dimensions: {width}x{height}")
+
+    try:
+        image_bytes = lc.tti.generate_image(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=width,
+            height=height
+            # You can add other kwargs here if your TTI service supports them, e.g., seed=12345
+        )
+
+        if image_bytes:
+            ASCIIColors.green(f"Image generated successfully ({len(image_bytes)} bytes).")
+            try:
+                image = Image.open(io.BytesIO(image_bytes))
+                image.save(output_filename)
+                ASCIIColors.green(f"Image saved as {output_filename}")
+                # Attempt to show image if possible (platform dependent)
+                if os.name == 'nt': # Windows
+                    os.startfile(output_filename)
+                elif os.name == 'posix': # MacOS/Linux
+                    try:
+                        import subprocess
+                        opener = "open" if platform.system() == "Darwin" else "xdg-open"
+                        subprocess.call([opener, output_filename])
+                    except:
+                        ASCIIColors.yellow(f"Could not auto-open image. Please find it at {output_filename}")
+
+            except Exception as e:
+                ASCIIColors.error(f"Error processing or saving image: {e}")
+                # Save raw bytes if PIL fails, for debugging
+                with open("generated_lollms_image_raw.data", "wb") as f_raw:
+                    f_raw.write(image_bytes)
+                ASCIIColors.yellow("Raw image data saved as generated_lollms_image_raw.data for inspection.")
+
+        else:
+            ASCIIColors.red("Image generation returned empty bytes.")
+
+    except Exception as e:
+        ASCIIColors.error(f"Error during image generation: {e}")
+        trace_exception(e)
+
+if __name__ == "__main__":
+    # Test management functions first
+    test_list_tti_services()
+    test_get_tti_settings()
+    test_set_tti_settings() # Currently illustrative
+
+    # Then test image generation
+    test_generate_image()

examples/text_and_image_2_audio.py

@@ -0,0 +1,59 @@
+"""
+Author: ParisNeo, a computer geek passionate about AI
+
+This example code demonstrates how to use the LoLLMs (Lord of Large Language Models) system to capture an image from a webcam, send it to the LollmsClient for analysis, and receive a descriptive response. The response is then converted to audio using the LollmsXTTS service.
+
+Requirements:
+- LoLLMs should be up and running.
+- The XTTS service within LoLLMs must be working.
+
+Steps:
+1. Initialize the LollmsClient instance.
+2. Fetch available voices and randomly select one.
+3. Capture an image from the webcam and save it to a file.
+4. Generate a descriptive text for the captured image using the LollmsClient.
+5. Convert the generated text to audio using the selected voice.
+
+Make sure you have the necessary dependencies installed and your webcam is accessible.
+"""
+import cv2
+from lollms_client import LollmsClient
+from lollms_client.lollms_tts_binding import LollmsTTS 
+import random
+
+# Initialize the LollmsClient instance
+lc = LollmsClient("http://localhost:9600")
+tts = LollmsTTS(lc)
+voices = tts.get_voices()
+
+# Pick a voice randomly
+random_voice = random.choice(voices)
+print(f"Selected voice: {random_voice}")
+
+# Capture image from webcam and save it to a file
+def capture_image(file_path):
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        raise Exception("Could not open webcam")
+
+    ret, frame = cap.read()
+    if not ret:
+        raise Exception("Failed to capture image")
+
+    cv2.imwrite(file_path, frame)
+    cap.release()
+
+# File path to save the captured image
+image_path = "captured_image.jpg"
+
+# Capture and save the image
+capture_image(image_path)
+
+# Function to handle streaming callback
+def cb(chunk, type):
+    print(chunk, end="", flush=True)
+
+# Generate text with image
+response = lc.generate_with_images(prompt="user: describe the content of the image.\nassistant: ", images=[image_path], stream=False, temperature=0.5, streaming_callback=cb)
+print(f"response: {response}")
+tts.text2Audio(response, random_voice)

examples/text_gen.py

@@ -0,0 +1,28 @@
+from lollms_client import LollmsClient
+
+# Initialize the LollmsClient instance
+lc = LollmsClient("http://localhost:9600")
+# Generate Text
+# response = lc.generate_text(prompt="Once upon a time", stream=False, temperature=0.5)
+# print(response)
+
+# # Generate Completion
+# response = lc.generate_completion(prompt="What is the capital of France", stream=False, temperature=0.5)
+# print(response)
+
+def cb(chunk, type):
+    print(chunk,end="",flush=True)
+    
+response = lc.generate_text(prompt="One plus one equals ", stream=False, temperature=0.5, streaming_callback=cb)
+print()
+print(response)
+print()
+
+
+# List Mounted Personalities
+response = lc.listMountedPersonalities()
+print(response)
+
+# List Models
+response = lc.listModels()
+print(response)

lollms_client/__init__.py

@@ -6,15 +6,16 @@ from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
 from lollms_client.lollms_utilities import PromptReshaper # Keep general utilities
 from lollms_client.lollms_functions import FunctionCalling_Library
 
+__version__ = "0.13.1"
+
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [
     "LollmsClient",
     "ELF_COMPLETION_FORMAT",
     "TasksLibrary",
     "MSG_TYPE",
-    "LollmsPersonality",
     "LollmsDiscussion",
     "LollmsMessage",
     "PromptReshaper",
     "FunctionCalling_Library"
-]
+]

lollms_client/llm_bindings/lollms/__init__.py

@@ -21,8 +21,9 @@ class LollmsLLMBinding(LollmsLLMBinding):
                  model_name: str = "",
                  service_key: str = None,
                  verify_ssl_certificate: bool = True,
-                 personality: Optional[int] = None,
-                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat):
+                 personality: Optional[int] = None, 
+                 **kwargs
+                 ):
         """
         Initialize the LOLLMS binding.
 
@@ -34,13 +35,14 @@ class LollmsLLMBinding(LollmsLLMBinding):
             personality (Optional[int]): Personality ID for generation. Defaults to None.
         """
         super().__init__(
-            binding_name = "lollms",
-            host_address=host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS,
-            model_name=model_name,
-            service_key=service_key,
-            verify_ssl_certificate=verify_ssl_certificate,
-            default_completion_format=default_completion_format
+            binding_name = "lollms"
         )
+        
+        self.host_address=host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS
+        self.model_name=model_name
+        self.service_key=service_key
+        self.verify_ssl_certificate=verify_ssl_certificate
+        self.default_completion_format=kwargs.get("default_completion_format",ELF_COMPLETION_FORMAT.Chat) 
         self.personality = personality
         self.model = None
     
@@ -133,7 +135,7 @@ class LollmsLLMBinding(LollmsLLMBinding):
         if not stream:
             if response.status_code == 200:
                 try:
-                    text = response.text.strip().rstrip('!')
+                    text = response.text.strip()
                     return text
                 except Exception as ex:
                     return {"status": False, "error": str(ex)}
@@ -276,8 +278,8 @@ class LollmsLLMBinding(LollmsLLMBinding):
 
         if response.status_code == 200:
             try:
-                text = json.loads(response.content.decode("utf-8"))
-                return text
+                models = json.loads(response.content.decode("utf-8"))
+                return [{"model_name":m} for m in models]
             except Exception as ex:
                 return {"status": False, "error": str(ex)}
         else:

lollms_client/llm_bindings/ollama/__init__.py

@@ -20,62 +20,44 @@ BindingName = "OllamaBinding"
 def count_tokens_ollama(
     text_to_tokenize: str,
     model_name: str,
-    ollama_host: str = "http://localhost:11434",
-    timeout: int = 30,
-    verify_ssl_certificate: bool = True,
-    headers: Optional[Dict[str, str]] = None
+    ollama_client: ollama.Client,
 ) -> int:
     """
-    Counts the number of tokens in a given text using a specified Ollama model
-    by calling the Ollama server's /api/tokenize endpoint.
+    Counts the number of tokens in a given text for a specified Ollama model
+    by making a minimal request to the /api/generate endpoint and extracting
+    the 'prompt_eval_count' from the response.
+
+    This method is generally more accurate for the specific Ollama model instance
+    than using an external tokenizer, but it incurs the overhead of an API call
+    and model processing for the prompt.
 
     Args:
-        text_to_tokenize (str): The text to be tokenized.
-        model_name (str): The name of the Ollama model to use (e.g., "llama3", "mistral").
-        ollama_host (str): The base URL of the Ollama server (default: "http://localhost:11434").
-        timeout (int): Timeout for the request in seconds (default: 30).
-        verify_ssl_certificate (bool): Whether to verify SSL.
-        headers (Optional[Dict[str, str]]): Optional headers for the request.
+        text_to_tokenize: The string to tokenize.
+        model_name: The name of the Ollama model (e.g., "llama3:8b", "mistral").
+        ollama_host: The URL of the Ollama API host.
+        timeout: Timeout for the request to Ollama.
+        verify_ssl_certificate: Whether to verify SSL certificates for the Ollama host.
+        headers: Optional custom headers for the request to Ollama.
+        num_predict_for_eval: How many tokens to ask the model to "predict" to get
+                              the prompt evaluation count. 0 is usually sufficient and most efficient.
+                              If 0 doesn't consistently yield `prompt_eval_count`, try 1.
 
     Returns:
-        int: The number of tokens. Returns -1 if an error occurs.
-    """
-    api_url = f"{ollama_host.rstrip('/')}/api/tokenize"
-    payload = {
-        "model": model_name,
-        "prompt": text_to_tokenize
-    }
-    request_headers = headers if headers else {}
-
-    try:
-        response = requests.post(api_url, json=payload, timeout=timeout, verify=verify_ssl_certificate, headers=request_headers)
-        response.raise_for_status()  # Raises HTTPError for bad responses (4xx or 5xx)
-
-        response_data = response.json()
-
-        if "tokens" in response_data and isinstance(response_data["tokens"], list):
-            return len(response_data["tokens"])
-        else:
-            ASCIIColors.warning(
-                f"Ollama response for token count did not contain a 'tokens' list. Response: {response_data}"
-            )
-            return -1 # Or raise ValueError
-
-    except requests.exceptions.HTTPError as http_err:
-        ASCIIColors.error(f"HTTP error occurred during token count: {http_err} - {http_err.response.text if http_err.response else 'No response text'}")
-        return -1
-    except requests.exceptions.RequestException as req_err:
-        ASCIIColors.error(f"Request error occurred during token count: {req_err}")
-        return -1
-    except json.JSONDecodeError as json_err:
-        ASCIIColors.error(
-            f"Failed to decode JSON response from Ollama during token count: {json_err}. Response text: {response.text if hasattr(response, 'text') else 'No response object'}"
-        )
-        return -1
-    except Exception as e:
-        ASCIIColors.error(f"An unexpected error occurred during token count: {e}")
-        return -1
+        The number of tokens as reported by 'prompt_eval_count'.
 
+    Raises:
+        requests.exceptions.RequestException: If the API request fails.
+        KeyError: If 'prompt_eval_count' is not found in the response.
+        json.JSONDecodeError: If the response is not valid JSON.
+        RuntimeError: For other operational errors.
+    """
+    res = ollama_client.chat(
+                        model=model_name,
+                        messages=[{"role":"system","content":""},{"role":"user", "content":text_to_tokenize}],
+                        stream=False,options={"num_predict":1}                        
+                    )
+    
+    return res.prompt_eval_count-5
 class OllamaBinding(LollmsLLMBinding):
     """Ollama-specific binding implementation using the ollama-python library."""
     
@@ -85,8 +67,8 @@ class OllamaBinding(LollmsLLMBinding):
                  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
+                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat,
+                 verify_ssl_certificate: bool = True
                  ):
         """
         Initialize the Ollama binding.
@@ -101,12 +83,13 @@ class OllamaBinding(LollmsLLMBinding):
         _host_address = host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS
         super().__init__(
             binding_name=BindingName, # Use the module-level BindingName
-            host_address=_host_address,
-            model_name=model_name,
-            service_key=service_key,
-            verify_ssl_certificate=verify_ssl_certificate,
-            default_completion_format=default_completion_format
         )
+        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 ollama is None:
             raise ImportError("Ollama library is not installed. Please run 'pip install ollama'.")
 
@@ -131,6 +114,7 @@ class OllamaBinding(LollmsLLMBinding):
                      images: Optional[List[str]] = None, # List of image file paths
                      n_predict: Optional[int] = None,
                      stream: bool = False,
+                     system_prompt = '',
                      temperature: float = 0.7, # Ollama default is 0.8, common default 0.7
                      top_k: int = 40,          # Ollama default is 40
                      top_p: float = 0.9,       # Ollama default is 0.9
@@ -190,7 +174,7 @@ class OllamaBinding(LollmsLLMBinding):
                     # If images were base64 strings, they would need decoding to bytes first.
                     processed_images.append(img_path)
 
-                messages = [{'role': 'user', 'content': prompt, 'images': processed_images if processed_images else None}]
+                messages = [{'role': 'system', 'content':system_prompt},{'role': 'user', 'content': prompt, 'images': processed_images if processed_images else None}]
                 
                 if stream:
                     response_stream = self.ollama_client.chat(
@@ -313,7 +297,7 @@ class OllamaBinding(LollmsLLMBinding):
         if not self.model_name:
             ASCIIColors.warning("Cannot count tokens, model_name is not set.")
             return -1
-        return count_tokens_ollama(text, self.model_name, self.host_address, verify_ssl_certificate=self.verify_ssl_certificate, headers=self.ollama_client_headers)
+        return count_tokens_ollama(text, self.model_name, self.ollama_client)
     
     def embed(self, text: str, **kwargs) -> List[float]:
         """
@@ -333,7 +317,7 @@ class OllamaBinding(LollmsLLMBinding):
         if not self.ollama_client:
              raise Exception("Ollama client not initialized.")
 
-        model_to_use = kwargs.get("model", self.model_name)
+        model_to_use = kwargs.get("model", "bge-m3")
         if not model_to_use:
             raise ValueError("Model name for embedding must be specified either in init or via kwargs.")
             
@@ -573,4 +557,4 @@ if __name__ == '__main__':
         ASCIIColors.error(f"An error occurred during testing: {e}")
         trace_exception(e)
 
-    ASCIIColors.yellow("\nOllamaBinding test finished.")
+    ASCIIColors.yellow("\nOllamaBinding test finished.")

lollms_client/llm_bindings/openai/__init__.py

@@ -7,6 +7,8 @@ from lollms_client.lollms_utilities import encode_image
 from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
 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"])
@@ -40,14 +42,16 @@ class OpenAIBinding(LollmsLLMBinding):
         """
         super().__init__(
             binding_name = "openai",
-            host_address=host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS,
-            model_name=model_name,
-            service_key=service_key,
-            verify_ssl_certificate=verify_ssl_certificate,
-            default_completion_format=default_completion_format
         )
-        self.service_key = os.getenv("OPENAI_API_KEY","")
-        self.client = openai.OpenAI(base_url=host_address)
+        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=host_address)
         self.completion_format = ELF_COMPLETION_FORMAT.Chat
 
     
@@ -134,7 +138,7 @@ class OpenAIBinding(LollmsLLMBinding):
                     except Exception as ex:
                         word = ""
                     if streaming_callback is not None:
-                        if not streaming_callback(word, "MSG_TYPE_CHUNK"):
+                        if not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
                             break
                     if word:
                         output += word
@@ -238,28 +242,64 @@ class OpenAIBinding(LollmsLLMBinding):
             "host_address": self.host_address,
             "model_name": self.model_name
         }
-    def listModels(self):
-        """ Lists available models """
-        url = f'{self.host_address}/v1/models'
-        headers = {
-                    'accept': 'application/json',
-                    'Authorization': f'Bearer {self.service_key}'
-                }
-        response = requests.get(url, headers=headers, verify= self.verify_ssl_certificate)
+
+    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:
-            data = response.json()
-            model_info = []
-
-            for model in data["data"]:
-                model_name = model['id']
-                owned_by = model['owned_by']
-                created_datetime = model["created"]
-                model_info.append({'model_name': model_name, 'owned_by': owned_by, 'created_datetime': created_datetime})
-
-            return model_info
-        except Exception as ex:
-            trace_exception(ex)
-            return []        
+            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,
+                    })
+        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.