lollms-client 0.20.3__py3-none-any.whl → 0.20.6__py3-none-any.whl

lollms_client/llm_bindings/lollms/__init__.py

@@ -168,7 +168,108 @@ class LollmsLLMBinding(LollmsLLMBinding):
                     return {"status": False, "error": str(ex)}
             else:
                 return {"status": False, "error": response.text}
-    
+    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,
+             seed: Optional[int] = None,
+             n_threads: Optional[int] = None,
+             ctx_size: int | None = 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.
+
+        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) ...
+
+        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,
+            "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
+        }
+        if image_data:
+            data["images"] = image_data
+
+        # 4. Make the request (logic copied and adapted from generate_text)
+        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):
+                                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}"
+            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}    
     def tokenize(self, text: str) -> list:
         """
         Tokenize the input text into a list of tokens using the /lollms_tokenize endpoint.

lollms_client/llm_bindings/ollama/__init__.py

@@ -6,6 +6,7 @@ from lollms_client.lollms_types import MSG_TYPE
 # encode_image is not strictly needed if ollama-python handles paths, but kept for consistency if ever needed.
 # 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 typing import Optional, Callable, List, Union, Dict
 
 from ascii_colors import ASCIIColors, trace_exception
@@ -258,6 +259,104 @@ class OllamaBinding(LollmsLLMBinding):
             trace_exception(ex)
             return {"status": False, "error": error_message}
     
+    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]:
+        """
+        Conduct a chat session with the Ollama 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.
+            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.
+            top_p (float): Top-p sampling parameter.
+            repeat_penalty (float): Penalty for repeated tokens.
+            repeat_last_n (int): Number of previous tokens to consider for repeat penalty.
+            seed (Optional[int]): Random seed for generation.
+            n_threads (Optional[int]): Number of threads to use.
+            ctx_size (Optional[int]): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+
+        Returns:
+            Union[str, dict]: The generated text or an error dictionary.
+        """
+        if not self.ollama_client:
+             return {"status": "error", "message": "Ollama client not initialized."}
+
+        # 1. Export the discussion to the Ollama chat format
+        # This handles system prompts, user/assistant roles, and base64-encoded images.
+        messages = discussion.export("ollama_chat", branch_tip_id)
+
+        # 2. Build the generation options dictionary
+        options = {
+            'num_predict': n_predict,
+            'temperature': float(temperature),
+            'top_k': top_k,
+            'top_p': top_p,
+            'repeat_penalty': repeat_penalty,
+            'repeat_last_n': repeat_last_n,
+            'seed': seed,
+            'num_thread': n_threads,
+            'num_ctx': ctx_size,
+        }
+        # Remove None values, as ollama-python expects them to be absent
+        options = {k: v for k, v in options.items() if v is not None}
+
+        full_response_text = ""
+
+        try:
+            # 3. Call the Ollama API
+            if stream:
+                response_stream = self.ollama_client.chat(
+                    model=self.model_name,
+                    messages=messages,
+                    stream=True,
+                    options=options if options else None
+                )
+                for chunk in response_stream:
+                    chunk_content = chunk.get('message', {}).get('content', '')
+                    if chunk_content:
+                        full_response_text += chunk_content
+                        if streaming_callback:
+                            if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                return full_response_text
+            else: # Not streaming
+                response_dict = self.ollama_client.chat(
+                    model=self.model_name,
+                    messages=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": "error", "message": error_message}
+        except ollama.RequestError as e:
+            error_message = f"Ollama API RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            return {"status": "error", "message": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred: {str(ex)}"
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}    
     def tokenize(self, text: str) -> list:
         """
         Tokenize the input text into a list of characters.

lollms_client/llm_bindings/openai/__init__.py

@@ -5,6 +5,7 @@ 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 typing import Optional, Callable, List, Union
 from ascii_colors import ASCIIColors, trace_exception
 from typing import List, Dict
@@ -207,6 +208,114 @@ class OpenAIBinding(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]:
+        """
+        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.
+            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 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_p": top_p,
+            "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}
+        
+        output = ""
+        # 2. Call the API
+        try:
+            # 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
+                        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}
+            
+        return output    
     def tokenize(self, text: str) -> list:
         """
         Tokenize the input text into a list of characters.

lollms_client/lollms_core.py

@@ -12,6 +12,7 @@ from lollms_client.lollms_ttv_binding import LollmsTTVBinding, LollmsTTVBindingM
 from lollms_client.lollms_ttm_binding import LollmsTTMBinding, LollmsTTMBindingManager
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 
+from lollms_client.lollms_discussion import LollmsDiscussion
 import json, re
 from enum import Enum
 import base64
@@ -386,6 +387,7 @@ class LollmsClient():
                      split:Optional[bool]=False, # put to true if the prompt is a discussion
                      user_keyword:Optional[str]="!@>user:",
                      ai_keyword:Optional[str]="!@>assistant:",
+                     **kwargs
                      ) -> Union[str, dict]:
         """
         Generate text using the active LLM binding, using instance defaults if parameters are not provided.
@@ -434,6 +436,64 @@ class LollmsClient():
         raise RuntimeError("LLM binding not initialized.")
 
 
+    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,
+             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]:
+        """
+        High-level method to perform a chat generation using a LollmsDiscussion object.
+
+        This is the recommended method for conversational interactions. It uses the
+        discussion object to correctly format the context for the model, including
+        system prompts, roles, and multi-modal content.
+
+        Args:
+            discussion (LollmsDiscussion): The discussion object to use for context.
+            branch_tip_id (Optional[str]): The ID of the message to use as the end of the conversation branch. If None, the active branch is used.
+            n_predict (Optional[int]): Maximum number of tokens to generate. Uses instance default if None.
+            stream (Optional[bool]): Whether to stream the output. Uses instance default if None.
+            temperature (Optional[float]): Sampling temperature. Uses instance default if None.
+            top_k (Optional[int]): Top-k sampling parameter. Uses instance default if None.
+            top_p (Optional[float]): Top-p sampling parameter. Uses instance default if None.
+            repeat_penalty (Optional[float]): Penalty for repeated tokens. Uses instance default if None.
+            repeat_last_n (Optional[int]): Number of previous tokens to consider for repeat penalty. Uses instance default if None.
+            seed (Optional[int]): Random seed for generation. Uses instance default if None.
+            n_threads (Optional[int]): Number of threads to use. Uses instance default if None.
+            ctx_size (Optional[int]): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+
+        Returns:
+            Union[str, dict]: Generated text or an error dictionary if failed.
+        """
+        if self.binding:
+            return self.binding.chat(
+                discussion=discussion,
+                branch_tip_id=branch_tip_id,
+                n_predict=n_predict if n_predict is not None else self.default_n_predict,
+                stream=stream if stream is not None else self.default_stream,
+                temperature=temperature if temperature is not None else self.default_temperature,
+                top_k=top_k if top_k is not None else self.default_top_k,
+                top_p=top_p if top_p is not None else self.default_top_p,
+                repeat_penalty=repeat_penalty if repeat_penalty is not None else self.default_repeat_penalty,
+                repeat_last_n=repeat_last_n if repeat_last_n is not None else self.default_repeat_last_n,
+                seed=seed if seed is not None else self.default_seed,
+                n_threads=n_threads if n_threads is not None else self.default_n_threads,
+                ctx_size = ctx_size if ctx_size is not None else self.default_ctx_size,
+                streaming_callback=streaming_callback if streaming_callback is not None else self.default_streaming_callback
+            )
+        raise RuntimeError("LLM binding not initialized.")
+
     def embed(self, text, **kwargs):
         """
         Generate embeddings for the input text using the active LLM binding.