lollms-client 1.5.6__py3-none-any.whl → 1.7.13__py3-none-any.whl

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
@@ -94,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)
@@ -103,11 +104,16 @@ 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):
@@ -149,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,
@@ -190,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
@@ -227,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
@@ -263,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:
@@ -316,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
@@ -364,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.
 
@@ -564,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,
@@ -643,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:

lollms_client/llm_bindings/novita_ai/__init__.py

@@ -19,8 +19,6 @@ BindingName = "NovitaAIBinding"
 API_BASE_URL = "https://api.novita.ai"
 
 # A hardcoded list of models based on Novita AI's documentation.
-# The API is OpenAI-compatible but does not provide a models listing endpoint.
-# Sourced from: https://docs.novita.ai/language-model/models
 _FALLBACK_MODELS = [
     {'model_name': 'meta-llama/Llama-3-8B-Instruct', 'display_name': 'Llama 3 8B Instruct', 'description': 'Meta\'s Llama 3 8B instruction-tuned model.', 'owned_by': 'Meta'},
     {'model_name': 'meta-llama/Llama-3-70B-Instruct', 'display_name': 'Llama 3 70B Instruct', 'description': 'Meta\'s Llama 3 70B instruction-tuned model.', 'owned_by': 'Meta'},
@@ -28,6 +26,7 @@ _FALLBACK_MODELS = [
     {'model_name': 'mistralai/Mistral-7B-Instruct-v0.2', 'display_name': 'Mistral 7B Instruct v0.2', 'description': 'Mistral AI\'s 7B instruction-tuned model.', 'owned_by': 'Mistral AI'},
     {'model_name': 'google/gemma-7b-it', 'display_name': 'Gemma 7B IT', 'description': 'Google\'s Gemma 7B instruction-tuned model.', 'owned_by': 'Google'},
     {'model_name': 'google/gemma-2-9b-it', 'display_name': 'Gemma 2 9B IT', 'description': 'Google\'s next-generation Gemma 2 9B instruction-tuned model.', 'owned_by': 'Google'},
+    {'model_name': 'deepseek/deepseek-r1', 'display_name': 'Deepseek R1', 'description': 'Deepseek R1 reasoning model.', 'owned_by': 'Deepseek AI'},
     {'model_name': 'deepseek-ai/deepseek-coder-33b-instruct', 'display_name': 'Deepseek Coder 33B Instruct', 'description': 'A powerful coding model from Deepseek AI.', 'owned_by': 'Deepseek AI'},
 ]
 
@@ -73,6 +72,119 @@ class NovitaAIBinding(LollmsLLMBinding):
         if frequency_penalty is not None: params['frequency_penalty'] = frequency_penalty
         return params
 
+    def generate_text(self,
+                     prompt: str,
+                     images: Optional[List[str]] = None,
+                     system_prompt: str = "",
+                     n_predict: Optional[int] = 2048,
+                     stream: Optional[bool] = False,
+                     temperature: float = 0.7,
+                     top_k: int = 50, # Not supported by Novita API
+                     top_p: float = 0.9,
+                     repeat_penalty: float = 1.1, # maps to frequency_penalty
+                     repeat_last_n: int = 64,   # Not supported
+                     seed: Optional[int] = None, # Not supported
+                     n_threads: Optional[int] = None, # Not applicable
+                     ctx_size: int | None = None, # Determined by model
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, 
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
+                     think: Optional[bool] = False,
+                     reasoning_effort: Optional[str] = "low", # low, medium, high
+                     reasoning_summary: Optional[bool] = False, # auto
+                     ) -> Union[str, dict]:
+        """
+        Generate text using Novita AI.
+        """
+        # Build messages
+        messages = []
+        if system_prompt and system_prompt.strip():
+            messages.append({"role": "system", "content": system_prompt})
+        
+        if split:
+            # Simple split logic to support history if provided in prompt string
+            # This is a basic fallback; usually chat() is preferred for history
+            msgs = self.split_discussion(prompt, user_keyword, ai_keyword)
+            messages.extend(msgs)
+        else:
+            messages.append({"role": "user", "content": prompt})
+
+        if images:
+            ASCIIColors.warning("Novita AI API does not support images in this binding yet. They will be ignored.")
+
+        # Construct parameters
+        # Map repeat_penalty to frequency_penalty loosely if needed, or just pass as is if supported
+        # Novita supports standard OpenAI params
+        api_params = self._construct_parameters(
+            temperature, top_p, n_predict, 0.0, repeat_penalty
+        )
+
+        payload = {
+            "model": self.model_name,
+            "messages": messages,
+            "stream": stream,
+            **api_params
+        }
+        
+        url = f"{API_BASE_URL}/v1/chat/completions"
+        full_response_text = ""
+
+        try:
+            if stream:
+                with requests.post(url, headers=self.headers, json=payload, stream=True) as response:
+                    response.raise_for_status()
+                    for line in response.iter_lines():
+                        if line:
+                            decoded_line = line.decode('utf-8')
+                            if decoded_line.startswith("data:"):
+                                content = decoded_line[len("data: "):].strip()
+                                if content == "[DONE]":
+                                    break
+                                try:
+                                    chunk = json.loads(content)
+                                    delta = chunk.get("choices", [{}])[0].get("delta", {})
+                                    text_chunk = delta.get("content", "")
+                                    # Deepseek R1 might output thinking in content or reasoning_content field
+                                    # Standard OpenAI compatible R1 usually puts thought in <think> tags or reasoning_content
+                                    reasoning_chunk = delta.get("reasoning_content", "")
+                                    
+                                    if reasoning_chunk:
+                                         # If we get reasoning content field, wrap it in <think> for lollms UI if think is enabled
+                                         if think:
+                                             formatted_reasoning = f"<think>{reasoning_chunk}</think>" # Naive streaming wrap, might be broken tags
+                                             # Better to just stream it if UI handles it, or just text
+                                             if streaming_callback:
+                                                streaming_callback(reasoning_chunk, MSG_TYPE.MSG_TYPE_CHUNK)
+                                         else:
+                                             # If think disabled, we might skip reasoning or just show it?
+                                             # Typically we want to show it.
+                                             pass
+
+                                    if text_chunk:
+                                        full_response_text += text_chunk
+                                        if streaming_callback:
+                                            if not streaming_callback(text_chunk, MSG_TYPE.MSG_TYPE_CHUNK):
+                                                break
+                                except json.JSONDecodeError:
+                                    continue
+                return full_response_text
+            else:
+                response = requests.post(url, headers=self.headers, json=payload)
+                response.raise_for_status()
+                data = response.json()
+                choice = data["choices"][0]["message"]
+                content = choice.get("content", "")
+                reasoning = choice.get("reasoning_content", "")
+                
+                if think and reasoning:
+                    return f"<think>\n{reasoning}\n</think>\n{content}"
+                return content
+                
+        except Exception as e:
+            trace_exception(e)
+            return {"status": False, "error": str(e)}
+
     def chat(self,
              discussion: LollmsDiscussion,
              branch_tip_id: Optional[str] = None,
@@ -86,7 +198,10 @@ class NovitaAIBinding(LollmsLLMBinding):
              seed: Optional[int] = None, # Not supported
              n_threads: Optional[int] = None, # Not applicable
              ctx_size: Optional[int] = None, # Determined by model
-             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             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
              ) -> Union[str, dict]:
         """
         Conduct a chat session with a Novita AI model using a LollmsDiscussion object.
@@ -139,6 +254,19 @@ class NovitaAIBinding(LollmsLLMBinding):
                                     chunk = json.loads(content)
                                     delta = chunk.get("choices", [{}])[0].get("delta", {})
                                     text_chunk = delta.get("content", "")
+                                    
+                                    # Support for reasoning content if provided (e.g. Deepseek R1)
+                                    reasoning_chunk = delta.get("reasoning_content", "")
+                                    if reasoning_chunk and think:
+                                        # Simple handling: stream it as regular chunk or specific type if supported
+                                        # Lollms typically expects <think> tags in the text if it's mixed
+                                        # Since we can't easily inject tags in a stream without state, 
+                                        # we assume the model output might contain them or we just output reasoning.
+                                        # For now, append to text.
+                                        if streaming_callback:
+                                            # We could prefix with <think> if it's the start, but that's complex in stateless loop
+                                            streaming_callback(reasoning_chunk, MSG_TYPE.MSG_TYPE_CHUNK)
+
                                     if text_chunk:
                                         full_response_text += text_chunk
                                         if streaming_callback:
@@ -152,7 +280,15 @@ class NovitaAIBinding(LollmsLLMBinding):
                 response = requests.post(url, headers=self.headers, json=payload)
                 response.raise_for_status()
                 data = response.json()
-                return data["choices"][0]["message"]["content"]
+                choice = data["choices"][0]["message"]
+                content = choice.get("content", "")
+                reasoning = choice.get("reasoning_content", "")
+                
+                if think and reasoning:
+                    return f"<think>\n{reasoning}\n</think>\n{content}"
+                    
+                return content
+
         except requests.exceptions.HTTPError as e:
             try:
                 error_details = e.response.json()
@@ -211,7 +347,7 @@ class NovitaAIBinding(LollmsLLMBinding):
             "supports_vision": False
         }
 
-    def listModels(self) -> List[Dict[str, str]]:
+    def list_models(self) -> List[Dict[str, str]]:
         """
         Lists available models. Novita AI API does not have a models endpoint,
         so a hardcoded list from their documentation is returned.
@@ -242,7 +378,7 @@ if __name__ == '__main__':
 
         # --- List Models ---
         ASCIIColors.cyan("\n--- Listing Models (static list) ---")
-        models = binding.listModels()
+        models = binding.list_models()
         if models:
             ASCIIColors.green(f"Found {len(models)} models.")
             for m in models: