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

lollms_client/llm_bindings/grok/__init__.py

@@ -26,9 +26,11 @@ GROK_API_BASE_URL = "https://api.x.ai/v1"
 
 # A hardcoded list to be used as a fallback if the API call fails
 _FALLBACK_MODELS = [
-    {'model_name': 'grok-1', 'display_name': 'Grok 1', 'description': 'The flagship conversational model from xAI.', 'owned_by': 'xAI'},
-    {'model_name': 'grok-1.5', 'display_name': 'Grok 1.5', 'description': 'The latest multimodal model from xAI.', 'owned_by': 'xAI'},
-    {'model_name': 'grok-1.5-vision-preview', 'display_name': 'Grok 1.5 Vision (Preview)', 'description': 'Multimodal model with vision capabilities (preview).', 'owned_by': 'xAI'},
+    {'model_name': 'grok-2-latest', 'display_name': 'Grok 2 Latest', 'description': 'The latest conversational model from xAI.', 'owned_by': 'xAI'},
+    {'model_name': 'grok-2', 'display_name': 'Grok 2', 'description': 'Grok 2 model.', 'owned_by': 'xAI'},
+    {'model_name': 'grok-2-vision-latest', 'display_name': 'Grok 2 Vision Latest', 'description': 'Latest multimodal model from xAI.', 'owned_by': 'xAI'},
+    {'model_name': 'grok-beta', 'display_name': 'Grok Beta', 'description': 'Beta model.', 'owned_by': 'xAI'},
+    {'model_name': 'grok-vision-beta', 'display_name': 'Grok Vision Beta', 'description': 'Beta vision model.', 'owned_by': 'xAI'},
 ]
 
 # Helper to check if a string is a valid path to an image
@@ -70,7 +72,7 @@ class GrokBinding(LollmsLLMBinding):
             service_key (str): xAI API key.
         """
         super().__init__(BindingName, **kwargs)
-        self.model_name = kwargs.get("model_name", "grok-1.5-vision-preview")
+        self.model_name = kwargs.get("model_name", "grok-2-latest")
         self.service_key = kwargs.get("service_key")
         self.base_url = kwargs.get("base_url", GROK_API_BASE_URL)
         self._cached_models: Optional[List[Dict[str, str]]] = None
@@ -101,7 +103,8 @@ class GrokBinding(LollmsLLMBinding):
     def _process_and_handle_stream(self,
                                   response: requests.Response,
                                   stream: bool,
-                                  streaming_callback: Optional[Callable[[str, MSG_TYPE], None]]
+                                  streaming_callback: Optional[Callable[[str, MSG_TYPE], None]],
+                                  think: bool = False
                                   ) -> Union[str, dict]:
         """Helper to process streaming responses from the API."""
         full_response_text = ""
@@ -119,6 +122,21 @@ class GrokBinding(LollmsLLMBinding):
                             if chunk['choices']:
                                 delta = chunk['choices'][0].get('delta', {})
                                 content = delta.get('content', '')
+                                # Check for reasoning content (DeepSeek-style) if Grok adopts it or if proxied
+                                reasoning = delta.get('reasoning_content', '')
+
+                                if reasoning:
+                                    # If thinking is requested and we get reasoning tokens
+                                    if think:
+                                        if streaming_callback:
+                                            # We just stream the reasoning as is, user UI typically handles tagging or we could inject <think>
+                                            # Here we assume just passing the text is safer unless we track state
+                                            streaming_callback(reasoning, MSG_TYPE.MSG_TYPE_CHUNK)
+                                    # We don't append reasoning to full_response_text usually if it's separate, 
+                                    # unless we want to return it in the final string wrapped.
+                                    # Let's wrap it for the final return string.
+                                    full_response_text += f"<think>{reasoning}</think>" # Naive wrapping for stream accumulation
+
                                 if content:
                                     full_response_text += content
                                     if stream and streaming_callback:
@@ -154,6 +172,9 @@ class GrokBinding(LollmsLLMBinding):
                      n_threads: Optional[int] = None, # Not applicable
                      ctx_size: int | None = None,     # Determined by model
                      streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     think: Optional[bool] = False,
+                     reasoning_effort: Optional[str] = "low", # low, medium, high
+                     reasoning_summary: Optional[bool] = False, # auto
                      **kwargs
                      ) -> Union[str, dict]:
         """
@@ -181,7 +202,9 @@ class GrokBinding(LollmsLLMBinding):
                             b64_data = base64.b64encode(image_file.read()).decode('utf-8')
                     else: # Assume it's a base64 string
                         b64_data = image_data
-                        media_type = "image/png" # Assume PNG if raw base64
+                        if b64_data.startswith("data:image"):
+                             b64_data = b64_data.split(",")[1]
+                        media_type = "image/png" # Default assumption
 
                     user_content.append({
                         "type": "image_url",
@@ -214,7 +237,7 @@ class GrokBinding(LollmsLLMBinding):
             )
             response.raise_for_status()
             
-            return self._process_and_handle_stream(response, stream, streaming_callback)
+            return self._process_and_handle_stream(response, stream, streaming_callback, think=think)
 
         except requests.exceptions.RequestException as ex:
             error_message = f"Grok API request failed: {str(ex)}"
@@ -238,6 +261,9 @@ class GrokBinding(LollmsLLMBinding):
              temperature: float = 0.7,
              top_p: float = 0.9,
              streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+             think: Optional[bool] = False,
+             reasoning_effort: Optional[str] = "low", # low, medium, high
+             reasoning_summary: Optional[bool] = False, # auto
              **kwargs
              ) -> Union[str, dict]:
         """
@@ -273,6 +299,18 @@ class GrokBinding(LollmsLLMBinding):
                             })
                         except Exception as e:
                             ASCIIColors.warning(f"Could not load image {file_path}: {e}")
+                    else:
+                        # Attempt to handle base64
+                        try:
+                            b64_data = file_path
+                            if b64_data.startswith("data:image"):
+                                b64_data = b64_data.split(",")[1]
+                            content_parts.append({
+                                "type": "image_url",
+                                "image_url": {"url": f"data:image/png;base64,{b64_data}"}
+                            })
+                        except:
+                            pass
             
             # Grok API expects content to be a string for assistant, or list for user.
             if role == 'user':
@@ -303,7 +341,7 @@ class GrokBinding(LollmsLLMBinding):
             )
             response.raise_for_status()
             
-            return self._process_and_handle_stream(response, stream, streaming_callback)
+            return self._process_and_handle_stream(response, stream, streaming_callback, think=think)
 
         except requests.exceptions.RequestException as ex:
             error_message = f"Grok API request failed: {str(ex)}"
@@ -362,10 +400,10 @@ class GrokBinding(LollmsLLMBinding):
             "host_address": self.base_url,
             "model_name": self.model_name,
             "supports_structured_output": False,
-            "supports_vision": "vision" in self.model_name or "grok-1.5" == self.model_name,
+            "supports_vision": "vision" in self.model_name or "grok-1.5" in self.model_name or "grok-2" in self.model_name,
         }
 
-    def listModels(self) -> List[Dict[str, str]]:
+    def list_models(self) -> List[Dict[str, str]]:
         """
         Lists available models from the xAI API.
         Caches the result to avoid repeated API calls.
@@ -433,8 +471,8 @@ if __name__ == '__main__':
     ASCIIColors.yellow("--- Testing GrokBinding ---")
 
     # --- Configuration ---
-    test_model_name = "grok-1"
-    test_vision_model_name = "grok-1.5-vision-preview"
+    test_model_name = "grok-2-latest"
+    test_vision_model_name = "grok-2-vision-latest"
 
     try:
         # --- Initialization ---
@@ -444,7 +482,7 @@ if __name__ == '__main__':
 
         # --- List Models ---
         ASCIIColors.cyan("\n--- Listing Models (dynamic) ---")
-        models = binding.listModels()
+        models = binding.list_models()
         if models:
             ASCIIColors.green(f"Found {len(models)} models.")
             for m in models:
@@ -462,7 +500,7 @@ if __name__ == '__main__':
         ASCIIColors.cyan("\n--- Text Generation (Non-Streaming) ---")
         prompt_text = "Explain who Elon Musk is in one sentence."
         ASCIIColors.info(f"Prompt: {prompt_text}")
-        generated_text = binding.generate_text(prompt_text, n_predict=100, stream=False, system_prompt="Be very concise.")
+        generated_text = binding.generate_text(prompt_text, n_predict=100, stream=False, system_prompt="Be very concise.", think=True)
         if isinstance(generated_text, str):
             ASCIIColors.green(f"Generated text:\n{generated_text}")
         else:

lollms_client/llm_bindings/groq/__init__.py

@@ -179,7 +179,7 @@ class GroqBinding(LollmsLLMBinding):
             "supports_vision": False, # Groq models do not currently support vision
         }
 
-    def listModels(self) -> List[Dict[str, str]]:
+    def list_models(self) -> List[Dict[str, str]]:
         """Lists available models from the Groq service."""
         if not self.client:
             ASCIIColors.error("Groq client not initialized. Cannot list models.")
@@ -229,7 +229,7 @@ if __name__ == '__main__':
 
         # --- List Models ---
         ASCIIColors.cyan("\n--- Listing Models ---")
-        models = binding.listModels()
+        models = binding.list_models()
         if models:
             ASCIIColors.green(f"Found {len(models)} models on Groq. Available models:")
             for m in models:

lollms_client/llm_bindings/hugging_face_inference_api/__init__.py

@@ -196,7 +196,7 @@ class HuggingFaceInferenceAPIBinding(LollmsLLMBinding):
             "supports_vision": False, # Vision models use a different API call
         }
 
-    def listModels(self) -> List[Dict[str, str]]:
+    def list_models(self) -> List[Dict[str, str]]:
         """Lists text-generation models from the Hugging Face Hub."""
         if not self.hf_api:
             ASCIIColors.error("HF API client not initialized. Cannot list models.")
@@ -252,7 +252,7 @@ if __name__ == '__main__':
 
         # --- List Models ---
         ASCIIColors.cyan("\n--- Listing Models ---")
-        models = binding.listModels()
+        models = binding.list_models()
         if models:
             ASCIIColors.green(f"Successfully fetched {len(models)} text-generation models.")
             ASCIIColors.info("Top 5 most downloaded models:")

lollms_client/llm_bindings/litellm/__init__.py

@@ -185,7 +185,7 @@ class LiteLLMBinding(LollmsLLMBinding):
             ASCIIColors.error(f"--- [LiteLLM Binding] Fallback method failed: {e}")
         return entries
 
-    def listModels(self) -> List[Dict]:
+    def list_models(self) -> List[Dict]:
         url = f'{self.host_address}/model/info'
         headers = {'Authorization': f'Bearer {self.service_key}'}
         entries = []

lollms_client/llm_bindings/llamacpp/__init__.py

@@ -66,20 +66,27 @@ pm.ensure_packages(["requests", "pillow", "psutil"]) # pillow for dummy image in
 if not pm.is_installed("llama-cpp-binaries"):
     def install_llama_cpp():
         system = platform.system()
-        python_version_simple = f"py{sys.version_info.major}" # e.g. py310 for 3.10
-
-        cuda_suffix = "+cu124" 
+        python_version_simple = f"py{sys.version_info.major}{sys.version_info.minor}"  # e.g. py310 for 3.10
 
+        version_tag = "v0.56.0"
+        cuda_suffix = "+cu124"
 
         if system == "Windows":
-            url = f"https://github.com/oobabooga/llama-cpp-binaries/releases/download/v0.39.0/llama_cpp_binaries-0.39.0{cuda_suffix}-{python_version_simple}-none-win_amd64.whl"
-            fallback_url = "https://github.com/oobabooga/llama-cpp-binaries/releases/download/v0.39.0/llama_cpp_binaries-0.39.0+cu124-py3-none-win_amd64.whl" # Generic py3
+            # Try version-specific URL first
+            url = f"https://github.com/oobabooga/llama-cpp-binaries/releases/download/{version_tag}/llama_cpp_binaries-{version_tag.lstrip('v')}{cuda_suffix}-{python_version_simple}-none-win_amd64.whl"
+            # Fallback to generic py3 if version-specific doesn't exist
+            fallback_url = f"https://github.com/oobabooga/llama-cpp-binaries/releases/download/{version_tag}/llama_cpp_binaries-{version_tag.lstrip('v')}{cuda_suffix}-py3-none-win_amd64.whl"
         elif system == "Linux":
-            url = f"https://github.com/oobabooga/llama-cpp-binaries/releases/download/v0.39.0/llama_cpp_binaries-0.39.0{cuda_suffix}-{python_version_simple}-none-linux_x86_64.whl"
-            fallback_url = "https://github.com/oobabooga/llama-cpp-binaries/releases/download/v0.39.0/llama_cpp_binaries-0.39.0+cu124-py3-none-linux_x86_64.whl" # Generic py3
+            # Try version-specific URL first
+            url = f"https://github.com/oobabooga/llama-cpp-binaries/releases/download/{version_tag}/llama_cpp_binaries-{version_tag.lstrip('v')}{cuda_suffix}-{python_version_simple}-none-linux_x86_64.whl"
+            # Fallback to generic py3 if version-specific doesn't exist
+            fallback_url = f"https://github.com/oobabooga/llama-cpp-binaries/releases/download/{version_tag}/llama_cpp_binaries-{version_tag.lstrip('v')}{cuda_suffix}-py3-none-linux_x86_64.whl"
         else:
-            ASCIIColors.warning(f"Unsupported OS for prebuilt llama-cpp-binaries: {system}. Please install manually.")
-            return
+            ASCIIColors.error(f"Unsupported OS for precompiled llama-cpp-binaries: {system}. "
+                            "You might need to set 'llama_server_binary_path' in the binding config "
+                            "to point to a manually compiled llama.cpp server binary.")
+            return False
+
 
         ASCIIColors.info(f"Attempting to install llama-cpp-binaries from: {url}")
         try:
@@ -628,7 +635,7 @@ class LlamaCppServerBinding(LollmsLLMBinding):
         
         if not model_to_load:
             self._scan_models()
-            available_models = self.listModels()
+            available_models = self.list_models()
             if not available_models:
                 ASCIIColors.error("No model specified and no GGUF models found in models path.")
                 return False
@@ -964,7 +971,7 @@ class LlamaCppServerBinding(LollmsLLMBinding):
         
         ASCIIColors.info(f"Scanned {len(self._model_path_map)} models from {self.models_path}.")
 
-    def listModels(self) -> List[Dict[str, Any]]:
+    def list_models(self) -> List[Dict[str, Any]]:
         self._scan_models()
         models_found = []
         for unique_name, model_path in self._model_path_map.items():

lollms_client/llm_bindings/lollms/__init__.py

@@ -1,4 +1,4 @@
-# bindings/Lollms_chat/binding.py
+# bindings/lollms/__init__.py
 import requests
 import json
 from lollms_client.lollms_llm_binding import LollmsLLMBinding
@@ -11,6 +11,8 @@ from ascii_colors import ASCIIColors, trace_exception
 from typing import List, Dict
 import httpx
 import pipmaster as pm
+import mimetypes
+import base64
 
 pm.ensure_packages(["openai","tiktoken"])
 
@@ -20,7 +22,63 @@ import os
 
 BindingName = "LollmsBinding"
 
-
+def _read_file_as_base64(path):
+    with open(path, "rb") as f:
+        return base64.b64encode(f.read()).decode("utf-8")
+
+def _extract_markdown_path(s):
+    s = s.strip()
+    if s.startswith("[") and s.endswith(")"):
+        lb, rb = s.find("["), s.find("]")
+        if lb != -1 and rb != -1 and rb > lb:
+            return s[lb+1:rb].strip()
+    return s
+
+def _guess_mime_from_name(name, default="image/jpeg"):
+    mime, _ = mimetypes.guess_type(name)
+    return mime or default
+
+def _to_data_url(b64_str, mime):
+    return f"data:{mime};base64,{b64_str}"
+
+def normalize_image_input(img, default_mime="image/jpeg"):
+    """
+    Returns a Responses API-ready content block:
+      { "type": "input_image", "image_url": "data:<mime>;base64,<...>" }
+    Accepts:
+      - dict {'data': '<base64>', 'mime': 'image/png'}
+      - dict {'path': 'E:\\images\\x.png'}
+      - string raw base64
+      - string local path (Windows/POSIX), including markdown-like "[E:\\path\\img.png]()"
+    URLs are intentionally not supported (base64 only).
+    """
+    if isinstance(img, dict):
+        if "data" in img and isinstance(img["data"], str):
+            mime = img.get("mime", default_mime)
+            return {"type": "input_image", "image_url": _to_data_url(img["data"], mime)}
+        if "path" in img and isinstance(img["path"], str):
+            p = _extract_markdown_path(img["path"])
+            b64 = _read_file_as_base64(p)
+            mime = _guess_mime_from_name(p, default_mime)
+            return {"type": "input_image", "image_url": _to_data_url(b64, mime)}
+        if "url" in img:
+            raise ValueError("URL inputs not allowed here; provide base64 or local path")
+        raise ValueError("Unsupported dict format for image input")
+
+    if isinstance(img, str):
+        s = _extract_markdown_path(img)
+        # Accept already-correct data URLs as-is
+        if s.startswith("data:"):
+            return {"type": "input_image", "image_url": s}
+        # Local path heuristics: exists on disk or looks like a path
+        if os.path.exists(s) or (":" in s and "\\" in s) or s.startswith("/") or s.startswith("."):
+            b64 = _read_file_as_base64(s)
+            mime = _guess_mime_from_name(s, default_mime)
+            return {"type": "input_image", "image_url": _to_data_url(b64, mime)}
+        # Otherwise, treat as raw base64 payload
+        return {"type": "input_image", "image_url": _to_data_url(s, default_mime)}
+
+    raise ValueError("Unsupported image input type")
 class LollmsBinding(LollmsLLMBinding):
     """Lollms-specific binding implementation (open ai compatible with some extra parameters)"""
     
@@ -36,6 +94,7 @@ class LollmsBinding(LollmsLLMBinding):
             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.
+            certificate_file_path (str): Path to a specific certificate file for SSL verification.
             personality (Optional[int]): Ignored parameter for compatibility with LollmsLLMBinding.
         """
         super().__init__(BindingName, **kwargs)
@@ -45,18 +104,28 @@ class LollmsBinding(LollmsLLMBinding):
         self.model_name=kwargs.get("model_name")
         self.service_key=kwargs.get("service_key")
         self.verify_ssl_certificate=kwargs.get("verify_ssl_certificate", True)
+        self.certificate_file_path=kwargs.get("certificate_file_path")
         self.default_completion_format=kwargs.get("default_completion_format", ELF_COMPLETION_FORMAT.Chat)
 
         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 self.host_address is None else self.host_address if len(self.host_address)>0 else None, http_client=httpx.Client(verify=self.verify_ssl_certificate))
+        
+        # Determine verification strategy: specific file takes precedence, otherwise boolean flag
+        verify = self.certificate_file_path if self.certificate_file_path else self.verify_ssl_certificate
+
+        self.client = openai.OpenAI(api_key=self.service_key, base_url=None if self.host_address is None else self.host_address if len(self.host_address)>0 else None, http_client=httpx.Client(verify=verify))
         self.completion_format = ELF_COMPLETION_FORMAT.Chat
 
     def lollms_listMountedPersonalities(self, host_address:str|None=None):
         host_address = host_address if host_address else self.host_address
-        url = f"{host_address}/list_mounted_personalities"
+        url = f"{host_address}/personalities"
+
+        headers = {
+            "Authorization": f"Bearer {self.service_key}",
+            "Accept": "application/json",
+        }
 
-        response = requests.get(url)
+        response = requests.get(url, headers=headers, timeout=30)
 
         if response.status_code == 200:
             try:
@@ -86,6 +155,12 @@ class LollmsBinding(LollmsLLMBinding):
             "stop", "max_tokens", "presence_penalty", "frequency_penalty",
             "logit_bias", "stream", "user", "max_completion_tokens"
         }
+        if kwargs.get("think", False):
+            allowed_params.append("reasoning")
+            kwargs["reasoning"]={
+                "effort": allowed_params.append("reasoning_effort", "low"),
+                "summary": allowed_params.append("reasoning_summary", "auto")
+            }
 
         params = {
             "model": model,
@@ -127,7 +202,11 @@ class LollmsBinding(LollmsLLMBinding):
                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
                     split: Optional[bool] = False,
                     user_keyword: Optional[str] = "!@>user:",
-                    ai_keyword: Optional[str] = "!@>assistant:"
+                    ai_keyword: Optional[str] = "!@>assistant:",
+                    think: Optional[bool] = False,
+                    reasoning_effort: Optional[bool] = "low", # low, medium, high
+                    reasoning_summary: Optional[bool] = "auto", # auto
+                    **kwargs
                     ) -> Union[str, dict]:
 
         count = 0
@@ -136,17 +215,18 @@ class LollmsBinding(LollmsLLMBinding):
 
         if images:
             if split:
+                # Original call to split message roles
                 messages += self.split_discussion(prompt, user_keyword=user_keyword, ai_keyword=ai_keyword)
-                messages[-1]["content"] = [{"type": "text", "text": messages[-1]["content"]}] + [
-                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encode_image(path)}"}}
-                    for path in images
-                ]
+                # Convert the last message content to the structured content array
+                last = messages[-1]
+                text_block = {"type": "text", "text": last["content"]}
+                image_blocks = [normalize_image_input(img) for img in images]
+                last["content"] = [text_block] + image_blocks
             else:
                 messages.append({
-                    'role': 'user',
-                    'content': [{"type": "text", "text": prompt}] + [
-                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encode_image(path)}"}}
-                        for path in images
+                    "role": "user",
+                    "content": [{"type": "text", "text": prompt}] + [
+                        normalize_image_input(img) for img in images
                     ]
                 })
         else:
@@ -163,12 +243,16 @@ class LollmsBinding(LollmsLLMBinding):
                                                 temperature=temperature,
                                                 top_p=top_p,
                                                 repeat_penalty=repeat_penalty,
-                                                seed=seed)
+                                                seed=seed,
+                                                think = think,
+                                                reasoning_effort=reasoning_effort,
+                                                reasoning_summary=reasoning_summary
+                                                )
                 try:
                     chat_completion = self.client.chat.completions.create(**params)
                 except Exception as ex:
                     # exception for new openai models
-                    params["max_completion_tokens"]=params["max_tokens"]
+                    params["max_completion_tokens"]=params.get("max_tokens") or params.get("max_completion_tokens") or self.default_ctx_size
                     params["temperature"]=1
                     try: del params["max_tokens"] 
                     except Exception: pass
@@ -199,7 +283,10 @@ class LollmsBinding(LollmsLLMBinding):
                                                 temperature=temperature,
                                                 top_p=top_p,
                                                 repeat_penalty=repeat_penalty,
-                                                seed=seed)
+                                                seed=seed,
+                                                think = think,
+                                                reasoning_effort=reasoning_effort,
+                                                reasoning_summary=reasoning_summary)
                 try:
                     completion =  self.client.completions.create(**params)
                 except Exception as ex:
@@ -252,6 +339,9 @@ class LollmsBinding(LollmsLLMBinding):
                      n_threads: Optional[int] = None,
                      ctx_size: int | None = None,
                      streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     think: Optional[bool] = False,
+                     reasoning_effort: Optional[bool] = "low", # low, medium, high
+                     reasoning_summary: Optional[bool] = "auto", # auto
                      **kwargs
                      ) -> Union[str, dict]:
         # Build the request parameters
@@ -300,20 +390,22 @@ class LollmsBinding(LollmsLLMBinding):
         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]:
+            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,
+            think: Optional[bool] = False,
+            **kwargs
+            ) -> Union[str, dict]:
         """
         Conduct a chat session with the OpenAI model using a LollmsDiscussion object.
 
@@ -500,7 +592,7 @@ class LollmsBinding(LollmsLLMBinding):
             "model_name": self.model_name
         }
 
-    def listModels(self) -> List[Dict]:
+    def list_models(self) -> List[Dict]:
         # Known context lengths
         known_context_lengths = {
             "gpt-4o": 128000,
@@ -579,3 +671,30 @@ class LollmsBinding(LollmsLLMBinding):
         self.model = model_name
         self.model_name = model_name
         return True
+    
+    def ps(self):
+        """
+        List models (simulating a process status command).
+        Since Lollms/OpenAI API doesn't have a specific 'ps' endpoint for running models with memory stats,
+        we list available models and populate structure with available info, leaving hardware stats empty.
+        """
+        # Since there is no dedicated ps endpoint to see *running* models in the standard OpenAI API,
+        # we list available models and try to map relevant info.
+        models = self.list_models()
+        standardized_models = []
+        for m in models:
+            standardized_models.append({
+                "model_name": m.get("model_name"),
+                "size": None,
+                "vram_size": None,
+                "gpu_usage_percent": None,
+                "cpu_usage_percent": None,
+                "expires_at": None,
+                "parameters_size": None,
+                "quantization_level": None,
+                "parent_model": None,
+                "context_size": m.get("context_length"),
+                "owned_by": m.get("owned_by"),
+                "created": m.get("created")
+            })
+        return standardized_models

lollms_client/llm_bindings/lollms_webui/__init__.py

@@ -375,7 +375,7 @@ class LollmsWebuiLLMBinding(LollmsLLMBinding):
         }
 
 
-    def listModels(self) -> dict:
+    def list_models(self) -> dict:
         """Lists models"""
         url = f"{self.host_address}/list_models"
 

lollms_client/llm_bindings/mistral/__init__.py

@@ -224,7 +224,7 @@ class MistralBinding(LollmsLLMBinding):
             "supports_vision": False, # Mistral API does not currently support vision
         }
 
-    def listModels(self) -> List[Dict[str, str]]:
+    def list_models(self) -> List[Dict[str, str]]:
         """Lists available models from the Mistral service."""
         if not self.client:
             ASCIIColors.error("Mistral client not initialized. Cannot list models.")
@@ -273,7 +273,7 @@ if __name__ == '__main__':
 
         # --- List Models ---
         ASCIIColors.cyan("\n--- Listing Models ---")
-        models = binding.listModels()
+        models = binding.list_models()
         if models:
             ASCIIColors.green(f"Found {len(models)} models on Mistral. Available models:")
             for m in models: