lollms-client 1.1.3__py3-none-any.whl → 1.3.1__py3-none-any.whl

lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "1.1.3" # Updated version
+__version__ = "1.3.1" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/llm_bindings/lollms/__init__.py

@@ -9,7 +9,7 @@ from lollms_client.lollms_discussion import LollmsDiscussion
 from typing import Optional, Callable, List, Union
 from ascii_colors import ASCIIColors, trace_exception
 from typing import List, Dict
-
+import httpx
 import pipmaster as pm
 
 pm.ensure_packages(["openai","tiktoken"])
@@ -49,7 +49,7 @@ class LollmsBinding(LollmsLLMBinding):
 
         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)
+        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))
         self.completion_format = ELF_COMPLETION_FORMAT.Chat
 
     def lollms_listMountedPersonalities(self, host_address:str|None=None):

lollms_client/llm_bindings/ollama/__init__.py

@@ -1,4 +1,4 @@
-# bindings/ollama/binding.py
+# bindings/ollama/__init__.py
 import requests
 import json
 from lollms_client.lollms_llm_binding import LollmsLLMBinding
@@ -13,7 +13,7 @@ from ascii_colors import ASCIIColors, trace_exception
 import pipmaster as pm
 from lollms_client.lollms_utilities import ImageTokenizer
 pm.ensure_packages(["ollama","pillow","tiktoken"])
-
+import re
 
 import ollama
 import tiktoken
@@ -256,22 +256,22 @@ class OllamaBinding(LollmsLLMBinding):
             return {"status": False, "error": error_message}
 
     def generate_from_messages(self,
-                     messages: List[Dict],
-                     n_predict: Optional[int] = None,
-                     stream: Optional[bool] = None,
-                     temperature: Optional[float] = None,
-                     top_k: Optional[int] = None,
-                     top_p: Optional[float] = None,
-                     repeat_penalty: Optional[float] = None,
-                     repeat_last_n: Optional[int] = None,
-                     seed: Optional[int] = None,
-                     n_threads: Optional[int] = None,
-                     ctx_size: int | None = None,
-                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
-                     **kwargs
-                     ) -> Union[str, dict]:
+                        messages: List[Dict],
+                        n_predict: Optional[int] = None,
+                        stream: Optional[bool] = None,
+                        temperature: Optional[float] = None,
+                        top_k: Optional[int] = None,
+                        top_p: Optional[float] = None,
+                        repeat_penalty: Optional[float] = None,
+                        repeat_last_n: Optional[int] = None,
+                        seed: Optional[int] = None,
+                        n_threads: Optional[int] = None,
+                        ctx_size: int | None = None,
+                        streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                        **kwargs
+                        ) -> Union[str, dict]:
         if not self.ollama_client:
-             return {"status": False, "error": "Ollama client not initialized."}
+            return {"status": False, "error": "Ollama client not initialized."}
 
         options = {}
         if n_predict is not None: options['num_predict'] = n_predict
@@ -283,34 +283,91 @@ class OllamaBinding(LollmsLLMBinding):
         if seed is not None: options['seed'] = seed
         if n_threads is not None: options['num_thread'] = n_threads
         if ctx_size is not None: options['num_ctx'] = ctx_size
-        
+
+        def normalize_message(msg: Dict) -> Dict:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            text_parts = []
+            images = []
+
+            if isinstance(content, str):
+                text_parts.append(content)
+            elif isinstance(content, list):
+                for item in content:
+                    if item.get("type") == "text":
+                        text_parts.append(item.get("text", ""))
+                    elif item.get("type") == "image_url":
+                        base64_data = item.get("image_url", {}).get("base64")
+                        url = item.get("image_url", {}).get("url")
+                        if base64_data:
+                            # ⚠️ remove prefix "data:image/...;base64,"
+                            cleaned = re.sub(r"^data:image/[^;]+;base64,", "", base64_data)
+                            images.append(cleaned)
+                        elif url:
+                            images.append(url)
+
+            return {
+                "role": role,
+                "content": "\n".join([p for p in text_parts if p.strip()]),
+                "images": images if images else None
+            }
+
+        ollama_messages = []
+        for m in messages:
+            nm = normalize_message(m)
+            if nm["images"]:
+                ollama_messages.append({
+                    "role": nm["role"],
+                    "content": nm["content"],
+                    "images": nm["images"]
+                })
+            else:
+                ollama_messages.append({
+                    "role": nm["role"],
+                    "content": nm["content"]
+                })
+
         full_response_text = ""
 
         try:
             if stream:
                 response_stream = self.ollama_client.chat(
                     model=self.model_name,
-                    messages=messages,
+                    messages=ollama_messages,
                     stream=True,
                     options=options if options else None
                 )
                 for chunk_dict in response_stream:
                     chunk_content = chunk_dict.get('message', {}).get('content', '')
-                    if chunk_content: # Ensure there is content to process
+                    if chunk_content:
                         full_response_text += chunk_content
                         if streaming_callback:
                             if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
-                                break # Callback requested stop
+                                break
                 return full_response_text
-            else: # Not streaming
+            else:
                 response_dict = self.ollama_client.chat(
                     model=self.model_name,
-                    messages=messages,
+                    messages=ollama_messages,
                     stream=False,
                     options=options if options else None
                 )
                 return response_dict.get('message', {}).get('content', '')
 
+        except ollama.ResponseError as e:
+            error_message = f"Ollama API ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message, "status_code": e.status_code}
+        except ollama.RequestError as e:
+            error_message = f"Ollama API RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
+
+
         except ollama.ResponseError as e:
             error_message = f"Ollama API ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
             ASCIIColors.error(error_message)

lollms_client/llm_bindings/openai/__init__.py

@@ -10,7 +10,7 @@ from typing import Optional, Callable, List, Union
 from ascii_colors import ASCIIColors, trace_exception
 from typing import List, Dict
 import math
-
+import httpx
 import pipmaster as pm
 
 pm.ensure_packages(["openai","tiktoken"])
@@ -47,7 +47,7 @@ class OpenAIBinding(LollmsLLMBinding):
 
         if not self.service_key:
             self.service_key = os.getenv("OPENAI_API_KEY", self.service_key)
-        self.client = openai.OpenAI(api_key=self.service_key, base_url=None if self.host_address is None else self.host_address if len(self.host_address)>0 else None)
+        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))
         self.completion_format = ELF_COMPLETION_FORMAT.Chat
 
     def _build_openai_params(self, messages: list, **kwargs) -> dict:
@@ -668,4 +668,4 @@ class OpenAIBinding(LollmsLLMBinding):
         """
         self.model = model_name
         self.model_name = model_name
-        return True
+        return True