lollms-client 0.29.0__py3-none-any.whl → 0.29.1__py3-none-any.whl

lollms_client/llm_bindings/lollms/__init__.py

@@ -1,51 +1,62 @@
-# bindings/lollms/binding.py
+# 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 ascii_colors import ASCIIColors, trace_exception
 from typing import Optional, Callable, List, Union
-import json
+from ascii_colors import ASCIIColors, trace_exception
+from typing import List, Dict
+
+import pipmaster as pm
+
+pm.ensure_packages(["openai","tiktoken"])
 
-BindingName = "LollmsLLMBinding"
+import openai
+import tiktoken
+import os
 
+BindingName = "LollmsBinding"
 
-class LollmsLLMBinding(LollmsLLMBinding):
-    """LOLLMS-specific binding implementation"""
+
+class LollmsBinding(LollmsLLMBinding):
+    """Lollms-specific binding implementation (open ai compatible with some extra parameters)"""
     
-    DEFAULT_HOST_ADDRESS = "http://localhost:9600"
     
-    def __init__(self, 
-                 host_address: str = None,
+    def __init__(self,
+                 host_address: str = "http://localhost:9642", #This is the default local installation 
                  model_name: str = "",
-                 service_key: str = None,
+                 service_key: str|None = None, # a key generated on the lollms interface (it is advised to use LOLLMS_API_KEY environment variable instead)
                  verify_ssl_certificate: bool = True,
-                 personality: Optional[int] = None, 
-                 **kwargs
-                 ):
+                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat,
+                 **kwargs):
         """
-        Initialize the LOLLMS binding.
+        Initialize the OpenAI binding.
 
         Args:
-            host_address (str): Host address for the LOLLMS service. Defaults to DEFAULT_HOST_ADDRESS.
+            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.
+            service_key (str): Authentication key for the service. Defaults to None. This is a key generated 
+                               on the lollms interface (it is advised to use LOLLMS_API_KEY environment variable instead)
             verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
-            personality (Optional[int]): Personality ID for generation. Defaults to None.
+            personality (Optional[int]): Ignored parameter for compatibility with LollmsLLMBinding.
         """
         super().__init__(
-            binding_name = "lollms"
+            binding_name = "openai",
         )
-        
-        self.host_address=host_address if host_address is not None else self.DEFAULT_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=kwargs.get("default_completion_format",ELF_COMPLETION_FORMAT.Chat) 
-        self.personality = personality
-        self.model = None
+        self.default_completion_format=default_completion_format
+
+        if not self.service_key:
+            self.service_key = os.getenv("LOLLMS_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,
@@ -53,11 +64,11 @@ class LollmsLLMBinding(LollmsLLMBinding):
                      system_prompt: str = "",
                      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,
+                     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,
@@ -92,242 +103,330 @@ class LollmsLLMBinding(LollmsLLMBinding):
         Returns:
             Union[str, dict]: Generated text or error dictionary if failed.
         """
-        # Determine endpoint based on presence of images
-        endpoint = "/lollms_generate_with_images" if images else "/lollms_generate"
-        url = f"{self.host_address}{endpoint}"
-        
-        # Set headers
-        headers = {
-            'Content-Type': 'application/json',
-        }
-        if self.service_key:
-            headers['Authorization'] = f'Bearer {self.service_key}'
+        count = 0
+        output = ""
+        messages = [
+            {
+                "role": "system",
+                "content": system_prompt or "You are a helpful assistant.",
+            }
+        ]
 
-        # Handle images if provided
-        image_data = []
+        # Prepare messages based on whether images are provided
         if images:
-            for image_path in images:
-                try:
-                    encoded_image = encode_image(image_path)
-                    image_data.append(encoded_image)
-                except Exception as e:
-                    return {"status": False, "error": f"Failed to process image {image_path}: {str(e)}"}
-        
-        # Prepare request data
-        data = {
-            "prompt":"!@>system: "+system_prompt+"\n"+"!@>user: "+prompt if system_prompt else prompt,
-            "model_name": self.model_name,
-            "personality": self.personality,
-            "n_predict": n_predict,
-            "stream": stream,
+            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_k": top_k,
             "top_p": top_p,
-            "repeat_penalty": repeat_penalty,
-            "repeat_last_n": repeat_last_n,
-            "seed": seed,
-            "n_threads": n_threads
+            "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}
         
-        if image_data:
-            data["images"] = image_data
-
-        # Make the request
-        response = requests.post(
-            url, 
-            json=data, 
-            headers=headers, 
-            stream=stream,
-            verify=self.verify_ssl_certificate
-        )
-        
-        if not stream:
-            if response.status_code == 200:
-                try:
-                    text = response.text.strip()
-                    return text
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            else:
-                return {"status": False, "error": response.text}
-        else:
-            text = ""
-            if response.status_code == 200:
-                try:
-                    for line in response.iter_lines():
-                        chunk = line.decode("utf-8")
-                        text += chunk
-                        if streaming_callback:
-                            streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK)
-                    # Handle potential quotes from streaming response
-                    if text and text[0] == '"':
-                        text = text[1:]
-                    if text and text[-1] == '"':
-                        text = text[:-1]
-                    return text.rstrip('!')
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
+        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:
-                return {"status": False, "error": response.text}
+                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: Optional[float] = None,
-             top_k: Optional[int] = None,
-             top_p: Optional[float] = None,
-             repeat_penalty: Optional[float] = None,
-             repeat_last_n: Optional[int] = 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,
+             ctx_size: Optional[int] = None,
              streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
              ) -> Union[str, dict]:
         """
-        Conduct a chat session with a lollms-webui server using a LollmsDiscussion object.
+        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.
-            ... (other parameters) ...
+            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 lollms-native text format
-        prompt_text = discussion.export("lollms_text", branch_tip_id)
-        
-        # 2. Extract images from the LAST message of the branch
-        # lollms-webui's endpoint associates images with the final prompt
-        active_branch_id = branch_tip_id or discussion.active_branch_id
-        branch = discussion.get_branch(active_branch_id)
-        last_message = branch[-1] if branch else None
-        
-        image_data = []
-        if last_message and last_message.images:
-            # The endpoint expects a list of base64 strings.
-            # We will only process images of type 'base64'. URL types are not supported by this endpoint.
-            for img in last_message.images:
-                if img['type'] == 'base64':
-                    image_data.append(img['data'])
-                # Note: 'url' type images are ignored for this binding.
-
-        # 3. Determine endpoint and build payload
-        endpoint = "/lollms_generate_with_images" if image_data else "/lollms_generate"
-        url = f"{self.host_address}{endpoint}"
-        
-        headers = {'Content-Type': 'application/json'}
-        if self.service_key:
-            headers['Authorization'] = f'Bearer {self.service_key}'
-
-        data = {
-            "prompt": prompt_text,
-            "model_name": self.model_name,
-            "personality": self.personality,
-            "n_predict": n_predict,
-            "stream": stream,
+        # 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_k": top_k,
             "top_p": top_p,
-            "repeat_penalty": repeat_penalty,
-            "repeat_last_n": repeat_last_n,
-            "seed": seed,
-            "n_threads": n_threads
+            "frequency_penalty": repeat_penalty,
+            "stream": stream
         }
-        if image_data:
-            data["images"] = image_data
+        # Add seed if available, as it's supported by newer OpenAI models
+        if seed is not None:
+            params["seed"] = seed
 
-        # 4. Make the request (logic copied and adapted from generate_text)
+        # 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:
-            response = requests.post(
-                url, 
-                json=data, 
-                headers=headers, 
-                stream=stream,
-                verify=self.verify_ssl_certificate
-            )
-            response.raise_for_status() # Raise an exception for bad status codes
-
-            if not stream:
-                return response.text.strip()
-            else:
-                full_response_text = ""
-                for line in response.iter_lines():
-                    if line:
-                        chunk = line.decode("utf-8")
-                        full_response_text += chunk
-                        if streaming_callback:
-                            if not streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK):
+            # 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
-                # Clean up potential quotes from some streaming formats
-                if full_response_text.startswith('"') and full_response_text.endswith('"'):
-                    full_response_text = full_response_text[1:-1]
-                return full_response_text.rstrip('!')
-
-        except requests.exceptions.RequestException as e:
-            error_message = f"lollms-webui request error: {e}"
+                        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}
-        except Exception as ex:
-            error_message = f"lollms-webui generation error: {str(ex)}"
-            return {"status": "error", "message": error_message}    
+            
+        return output    
     def tokenize(self, text: str) -> list:
         """
-        Tokenize the input text into a list of tokens using the /lollms_tokenize endpoint.
+        Tokenize the input text into a list of characters.
 
         Args:
             text (str): The text to tokenize.
 
         Returns:
-            list: List of tokens.
+            list: List of individual characters.
         """
-        response=None
         try:
-            # Prepare the request payload
-            payload = {
-                "prompt": text,
-                "return_named": False  # Set to True if you want named tokens
-            }
-            
-            # Make the POST request to the /lollms_tokenize endpoint
-            response = requests.post(f"{self.host_address}/lollms_tokenize", json=payload)
+            return tiktoken.model.encoding_for_model(self.model_name).encode(text)
+        except:
+            return tiktoken.model.encoding_for_model("gpt-3.5-turbo").encode(text)
             
-            # Check if the request was successful
-            if response.status_code == 200:
-                return response.json()
-            else:
-                raise Exception(f"Failed to tokenize text: {response.text}")
-        except Exception as ex:
-            trace_exception(ex)
-            raise Exception(f"Failed to tokenize text: {response.text}")
-          
     def detokenize(self, tokens: list) -> str:
         """
-        Convert a list of tokens back to text using the /lollms_detokenize endpoint.
+        Convert a list of tokens back to text.
 
         Args:
-            tokens (list): List of tokens to detokenize.
+            tokens (list): List of tokens (characters) to detokenize.
 
         Returns:
             str: Detokenized text.
         """
         try:
-            # Prepare the request payload
-            payload = {
-                "tokens": tokens,
-                "return_named": False  # Set to True if you want named tokens
-            }
-
-            # Make the POST request to the /lollms_detokenize endpoint
-            response = requests.post(f"{self.host_address}/lollms_detokenize", json=payload)
-
-            # Check if the request was successful
-            if response.status_code == 200:
-                return response.json()
-            else:
-                raise Exception(f"Failed to detokenize tokens: {response.text}")
-        except Exception as ex:
-            return {"status": False, "error": str(ex)}
+            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:
         """
@@ -340,66 +439,127 @@ class LollmsLLMBinding(LollmsLLMBinding):
             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 Ollama API
-        
+        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
-        
+            text (str): Input text to embed.
+            **kwargs: Additional arguments. The 'model' argument can be used 
+                      to specify the embedding model (e.g., "text-embedding-3-small").
+                      Defaults to "text-embedding-ada-002".
+
         Returns:
-            dict: Response containing embeddings
+            list: The embedding vector as a list of floats, or an empty list on failure.
         """
-        api_key = kwargs.pop("api_key", None)
-        headers = (
-            {"Content-Type": "application/json", "Authorization": api_key}
-            if api_key
-            else {"Content-Type": "application/json"}
-        )
-        embeddings = []
-        request_data = {"text": text}
-        response = requests.post(f"{self.host_address}/lollms_embed", json=request_data, headers=headers)
-        response.raise_for_status()
-        result = response.json()
-        return result["vector"]
+        # Determine the embedding model, prioritizing kwargs, with a default
+        embedding_model = kwargs.get("model", self.model_name)
+        
+        try:
+            # The OpenAI API expects the input to be a list of strings
+            response = self.client.embeddings.create(
+                model=embedding_model,
+                input=[text]  # Wrap the single text string in a list
+            )
+            
+            # Extract the embedding from the response
+            if response.data and len(response.data) > 0:
+                return response.data[0].embedding
+            else:
+                ASCIIColors.warning("OpenAI API returned no data for the embedding request.")
+                return []
+                
+        except Exception as e:
+            ASCIIColors.error(f"Failed to generate embeddings using OpenAI API: {e}")
+            trace_exception(e)
+            return []
+        
 
     def get_model_info(self) -> dict:
         """
-        Return information about the current LOLLMS model.
+        Return information about the current OpenAI model.
 
         Returns:
-            dict: Dictionary containing model name, version, host address, and personality.
+            dict: Dictionary containing model name, version, and host address.
         """
         return {
-            "name": "lollms",
-            "version": "1.0",
+            "name": "OpenAI",
+            "version": "2.0",
             "host_address": self.host_address,
-            "model_name": self.model_name,
-            "personality": self.personality
+            "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,
+        }
 
-    def listModels(self) -> dict:
-        """Lists models"""
-        url = f"{self.host_address}/list_models"
+        generation_prefixes = (
+            "gpt-",
+            "text-davinci",
+            "davinci",
+            "curie",
+            "babbage",
+            "ada"
+        )
 
-        response = requests.get(url)
+        models_info = []
+        prompt_buffer = 500
 
-        if response.status_code == 200:
-            try:
-                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:
-            return {"status": False, "error": response.text}
+        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 LOLLMS binding.
+        Load a specific model into the OpenAI binding.
 
         Args:
             model_name (str): Name of the model to load.
@@ -410,19 +570,3 @@ class LollmsLLMBinding(LollmsLLMBinding):
         self.model = model_name
         self.model_name = model_name
         return True
-
-    # Lollms specific methods
-    def lollms_listMountedPersonalities(self, host_address:str=None):
-        host_address = host_address if host_address else self.host_address
-        url = f"{host_address}/list_mounted_personalities"
-
-        response = requests.get(url)
-
-        if response.status_code == 200:
-            try:
-                text = json.loads(response.content.decode("utf-8"))
-                return text
-            except Exception as ex:
-                return {"status": False, "error": str(ex)}
-        else:
-            return {"status": False, "error": response.text}