lollms-client 0.25.0__py3-none-any.whl → 0.25.5__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
 
 
-__version__ = "0.25.0" # Updated version
+__version__ = "0.25.5" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/llm_bindings/gemini/__init__.py

@@ -0,0 +1,501 @@
+# bindings/gemini/binding.py
+import base64
+import os
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, Callable, List, Union, Dict
+
+from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+
+import pipmaster as pm
+
+# Ensure the required packages are installed
+pm.ensure_packages(["google-generativeai", "pillow", "tiktoken", "protobuf"])
+
+import google.generativeai as genai
+from PIL import Image, ImageDraw # ImageDraw is used in the test script below
+import tiktoken
+
+BindingName = "GeminiBinding"
+
+# Helper to check if a string is a valid path to an image
+def is_image_path(path_str: str) -> bool:
+    try:
+        p = Path(path_str)
+        return p.is_file() and p.suffix.lower() in ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp']
+    except Exception:
+        return False
+
+class GeminiBinding(LollmsLLMBinding):
+    """Google Gemini-specific binding implementation."""
+
+    def __init__(self,
+                 host_address: str = None,  # Ignored, for compatibility
+                 model_name: str = "gemini-1.5-pro-latest",
+                 service_key: str = None,
+                 verify_ssl_certificate: bool = True, # Ignored, for compatibility
+                 **kwargs
+                 ):
+        """
+        Initialize the Gemini binding.
+
+        Args:
+            model_name (str): Name of the Gemini model to use.
+            service_key (str): Google AI Studio API key.
+        """
+        super().__init__(binding_name=BindingName)
+        self.model_name = model_name
+        self.service_key = service_key
+
+        if not self.service_key:
+            self.service_key = os.getenv("GOOGLE_API_KEY")
+        
+        if not self.service_key:
+            raise ValueError("Google API key is required. Please set it via the 'service_key' parameter or the GOOGLE_API_KEY environment variable.")
+
+        try:
+            genai.configure(api_key=self.service_key)
+            self.client = genai # Alias for consistency
+        except Exception as e:
+            ASCIIColors.error(f"Failed to configure Gemini client: {e}")
+            self.client = None
+            raise ConnectionError(f"Could not configure Gemini client: {e}") from e
+
+    def get_generation_config(self, 
+                              temperature: float, 
+                              top_p: float, 
+                              top_k: int, 
+                              n_predict: int) -> genai.types.GenerationConfig:
+        """Builds a GenerationConfig object from parameters."""
+        config = {}
+        if temperature is not None: config['temperature'] = float(temperature)
+        if top_p is not None: config['top_p'] = top_p
+        if top_k is not None: config['top_k'] = top_k
+        if n_predict is not None: config['max_output_tokens'] = n_predict
+        return genai.types.GenerationConfig(**config)
+
+    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 = 40,
+                     top_p: float = 0.9,
+                     repeat_penalty: float = 1.1, # Not directly supported by Gemini API
+                     repeat_last_n: int = 64,   # Not directly supported
+                     seed: Optional[int] = None,      # Not directly supported
+                     n_threads: Optional[int] = None, # Not applicable
+                     ctx_size: int | None = None,     # Determined by model, not settable per-call
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, 
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
+                     ) -> Union[str, dict]:
+        """
+        Generate text using the Gemini model.
+
+        Args:
+            prompt (str): The input prompt for text generation.
+            images (Optional[List[str]]): List of image file paths or base64 strings.
+            system_prompt (str): The system prompt to guide the model.
+            ... other LollmsLLMBinding parameters ...
+
+        Returns:
+            Union[str, dict]: Generated text or error dictionary.
+        """
+        if not self.client:
+            return {"status": False, "error": "Gemini client not initialized."}
+
+        # Gemini uses 'system_instruction' for GenerativeModel, not part of the regular message list.
+        model = self.client.GenerativeModel(
+            model_name=self.model_name,
+            system_instruction=system_prompt if system_prompt else None
+        )
+
+        generation_config = self.get_generation_config(temperature, top_p, top_k, n_predict)
+
+        # Prepare content for the API call
+        content_parts = []
+        if split:
+            # Note: The 'split' logic for Gemini should ideally build a multi-turn history,
+            # but for `generate_text`, we'll treat the last user part as the main prompt.
+            discussion_messages = self.split_discussion(prompt, user_keyword, ai_keyword)
+            if discussion_messages:
+                last_message = discussion_messages[-1]['content']
+                content_parts.append(last_message)
+            else:
+                content_parts.append(prompt)
+        else:
+            content_parts.append(prompt)
+
+        if images:
+            for image_data in images:
+                try:
+                    if is_image_path(image_data):
+                        img = Image.open(image_data)
+                    else: # Assume base64
+                        img = Image.open(BytesIO(base64.b64decode(image_data)))
+                    content_parts.append(img)
+                except Exception as e:
+                    error_msg = f"Failed to process image: {e}"
+                    ASCIIColors.error(error_msg)
+                    return {"status": False, "error": error_msg}
+
+        full_response_text = ""
+        try:
+            response = model.generate_content(
+                contents=content_parts,
+                generation_config=generation_config,
+                stream=stream
+            )
+
+            if stream:
+                for chunk in response:
+                    try:
+                        chunk_text = chunk.text
+                    except ValueError:
+                        # Handle potential empty parts in the stream
+                        chunk_text = ""
+
+                    if chunk_text:
+                        full_response_text += chunk_text
+                        if streaming_callback:
+                            if not streaming_callback(chunk_text, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break # Callback requested stop
+                return full_response_text
+            else:
+                # Check for safety blocks
+                if response.prompt_feedback.block_reason:
+                    error_msg = f"Content blocked due to: {response.prompt_feedback.block_reason.name}"
+                    ASCIIColors.warning(error_msg)
+                    return {"status": False, "error": error_msg}
+                return response.text
+
+        except Exception as ex:
+            error_message = f"An unexpected error occurred with Gemini API: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
+
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = 2048,
+             stream: Optional[bool] = False,
+             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 Gemini model using a LollmsDiscussion object.
+        """
+        if not self.client:
+             return {"status": "error", "message": "Gemini client not initialized."}
+
+        # 1. Manually export discussion to Gemini's format.
+        # Gemini uses 'user' and 'model' roles.
+        # The system prompt is handled separately at model initialization.
+        system_prompt = discussion.system_prompt
+        messages = discussion.get_messages(branch_tip_id)
+        
+        history = []
+        for msg in messages:
+            role = 'user' if msg.sender_type == "user" else 'assistant'
+            
+            # Handle multimodal content in the message
+            content_parts = []
+            if msg.content:
+                content_parts.append(msg.content)
+            
+            # Check for images associated with this message
+            if msg.images:
+                for file_path in msg.images:
+                     if is_image_path(file_path):
+                         try:
+                            content_parts.append(Image.open(file_path))
+                         except Exception as e:
+                            ASCIIColors.warning(f"Could not load image {file_path}: {e}")
+
+            if content_parts:
+                history.append({'role': role, 'parts': content_parts})
+        
+        model = self.client.GenerativeModel(
+            model_name=self.model_name,
+            system_instruction=system_prompt
+        )
+        
+        # History must not be empty and should not contain consecutive roles of the same type.
+        # We also need to separate the final prompt from the history.
+        if not history:
+            return {"status": "error", "message": "Cannot start chat with an empty discussion."}
+
+        chat_history = history[:-1] if len(history) > 1 else []
+        last_prompt_parts = history[-1]['parts']
+
+        # Ensure history is valid (no consecutive same roles)
+        valid_history = []
+        if chat_history:
+            valid_history.append(chat_history[0])
+            for i in range(1, len(chat_history)):
+                if chat_history[i]['role'] != chat_history[i-1]['role']:
+                    valid_history.append(chat_history[i])
+        
+        chat_session = model.start_chat(history=valid_history)
+        
+        generation_config = self.get_generation_config(temperature, top_p, top_k, n_predict)
+        
+        full_response_text = ""
+        try:
+            response = chat_session.send_message(
+                content=last_prompt_parts,
+                generation_config=generation_config,
+                stream=stream
+            )
+            
+            if stream:
+                for chunk in response:
+                    try:
+                        chunk_text = chunk.text
+                    except ValueError:
+                        chunk_text = ""
+                        
+                    if chunk_text:
+                        full_response_text += chunk_text
+                        if streaming_callback:
+                            if not streaming_callback(chunk_text, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                return full_response_text
+            else:
+                if response.prompt_feedback.block_reason:
+                    error_msg = f"Content blocked due to: {response.prompt_feedback.block_reason.name}"
+                    ASCIIColors.warning(error_msg)
+                    return {"status": "error", "message": error_msg}
+                return response.text
+
+        except Exception as ex:
+            error_message = f"An unexpected error occurred with Gemini API: {str(ex)}"
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}
+            
+    def tokenize(self, text: str) -> list:
+        """
+        Tokenize the input text.
+        Note: Gemini doesn't expose a public tokenizer API.
+        Using tiktoken for a rough estimate, NOT accurate for Gemini.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.encode(text)
+        except:
+            return list(text.encode('utf-8'))
+
+    def detokenize(self, tokens: list) -> str:
+        """
+        Detokenize a list of tokens.
+        Note: Based on the placeholder tokenizer.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.decode(tokens)
+        except:
+            return bytes(tokens).decode('utf-8', errors='ignore')
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text using the Gemini API.
+        """
+        if not self.client or not self.model_name:
+            ASCIIColors.warning("Cannot count tokens, Gemini client or model_name not set.")
+            return -1
+        try:
+            model = self.client.GenerativeModel(self.model_name)
+            return model.count_tokens(text).total_tokens
+        except Exception as e:
+            ASCIIColors.error(f"Failed to count tokens with Gemini API: {e}")
+            # Fallback to tiktoken for a rough estimate
+            return len(self.tokenize(text))
+
+    def embed(self, text: str, **kwargs) -> List[float]:
+        """
+        Get embeddings for the input text using Gemini API.
+        """
+        if not self.client:
+             raise Exception("Gemini client not initialized.")
+        
+        # Default to a known Gemini embedding model
+        model_to_use = kwargs.get("model", "models/embedding-001")
+        
+        try:
+            response = self.client.embed_content(
+                model=model_to_use,
+                content=text,
+                task_type="retrieval_document" # or "semantic_similarity", etc.
+            )
+            return response['embedding']
+        except Exception as ex:
+            trace_exception(ex)
+            raise Exception(f"Gemini embedding failed: {str(ex)}") from ex
+
+    def get_model_info(self) -> dict:
+        """Return information about the current Gemini model setup."""
+        return {
+            "name": self.binding_name,
+            "version": genai.__version__,
+            "host_address": "https://generativelanguage.googleapis.com",
+            "model_name": self.model_name,
+            "supports_structured_output": False,
+            "supports_vision": "vision" in self.model_name or "gemini-1.5" in self.model_name,
+        }
+
+    def listModels(self) -> List[Dict[str, str]]:
+        """Lists available generative models from the Gemini service."""
+        if not self.client:
+            ASCIIColors.error("Gemini client not initialized. Cannot list models.")
+            return []
+        try:
+            ASCIIColors.debug("Listing Gemini models...")
+            model_info_list = []
+            for m in self.client.list_models():
+                # We are interested in models that can generate content.
+                if 'generateContent' in m.supported_generation_methods:
+                    model_info_list.append({
+                        'model_name': m.name,
+                        'display_name': m.display_name,
+                        'description': m.description,
+                        'owned_by': 'Google' 
+                    })
+            return model_info_list
+        except Exception as ex:
+            trace_exception(ex)
+            return []
+
+    def load_model(self, model_name: str) -> bool:
+        """Set the model name for subsequent operations."""
+        self.model_name = model_name
+        ASCIIColors.info(f"Gemini model set to: {model_name}. It will be used on the next API call.")
+        return True
+
+if __name__ == '__main__':
+    # Example Usage (requires GOOGLE_API_KEY environment variable)
+    if 'GOOGLE_API_KEY' not in os.environ:
+        ASCIIColors.red("Error: GOOGLE_API_KEY environment variable not set.")
+        print("Please get your key from Google AI Studio and set it.")
+        exit(1)
+
+    ASCIIColors.yellow("--- Testing GeminiBinding ---")
+
+    # --- Configuration ---
+    test_model_name = "gemini-1.5-pro-latest"
+    test_vision_model_name = "gemini-1.5-pro-latest" # or gemini-pro-vision
+    test_embedding_model = "models/embedding-001"
+    
+    # This variable is global to the script's execution
+    full_streamed_text = ""
+
+    try:
+        # --- Initialization ---
+        ASCIIColors.cyan("\n--- Initializing Binding ---")
+        binding = GeminiBinding(model_name=test_model_name)
+        ASCIIColors.green("Binding initialized successfully.")
+        ASCIIColors.info(f"Using google-generativeai version: {genai.__version__}")
+
+        # --- List Models ---
+        ASCIIColors.cyan("\n--- Listing Models ---")
+        models = binding.listModels()
+        if models:
+            ASCIIColors.green(f"Found {len(models)} generative models. First 5:")
+            for m in models[:5]:
+                print(m['model_name'])
+        else:
+            ASCIIColors.warning("No models found or failed to list models.")
+
+        # --- Count Tokens ---
+        ASCIIColors.cyan("\n--- Counting Tokens ---")
+        sample_text = "Hello, world! This is a test."
+        token_count = binding.count_tokens(sample_text)
+        ASCIIColors.green(f"Token count for '{sample_text}': {token_count}")
+
+        # --- Text Generation (Non-Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Non-Streaming) ---")
+        prompt_text = "Explain the importance of bees in one paragraph."
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        generated_text = binding.generate_text(prompt_text, n_predict=100, stream=False)
+        if isinstance(generated_text, str):
+            ASCIIColors.green(f"Generated text:\n{generated_text}")
+        else:
+            ASCIIColors.error(f"Generation failed: {generated_text}")
+
+        # --- Text Generation (Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Streaming) ---")
+        
+        def stream_callback(chunk: str, msg_type: int):
+            # FIX: Use 'global' to modify the variable in the module's scope
+            global full_streamed_text
+            ASCIIColors.green(chunk, end="", flush=True)
+            full_streamed_text += chunk
+            return True
+        
+        # Reset for this test
+        full_streamed_text = ""
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        result = binding.generate_text(prompt_text, n_predict=150, stream=True, streaming_callback=stream_callback)
+        print("\n--- End of Stream ---")
+        # 'result' is the full text after streaming, which should match our captured text.
+        ASCIIColors.green(f"Full streamed text (for verification): {result}")
+
+        # --- Embeddings ---
+        ASCIIColors.cyan("\n--- Embeddings ---")
+        try:
+            embedding_text = "Lollms is a cool project."
+            embedding_vector = binding.embed(embedding_text, model=test_embedding_model)
+            ASCIIColors.green(f"Embedding for '{embedding_text}' (first 5 dims): {embedding_vector[:5]}...")
+            ASCIIColors.info(f"Embedding vector dimension: {len(embedding_vector)}")
+        except Exception as e:
+            ASCIIColors.warning(f"Could not get embedding: {e}")
+
+        # --- Vision Model Test ---
+        dummy_image_path = "gemini_dummy_test_image.png"
+        try:
+            img = Image.new('RGB', (200, 50), color = ('blue'))
+            d = ImageDraw.Draw(img)
+            d.text((10,10), "Test Image", fill=('yellow'))
+            img.save(dummy_image_path)
+            ASCIIColors.info(f"Created dummy image: {dummy_image_path}")
+
+            ASCIIColors.cyan(f"\n--- Vision Generation (using {test_vision_model_name}) ---")
+            binding.load_model(test_vision_model_name)
+            vision_prompt = "What color is the text and what does it say?"
+            ASCIIColors.info(f"Vision Prompt: {vision_prompt} with image {dummy_image_path}")
+            
+            vision_response = binding.generate_text(
+                prompt=vision_prompt,
+                images=[dummy_image_path],
+                n_predict=50,
+                stream=False
+            )
+            if isinstance(vision_response, str):
+                ASCIIColors.green(f"Vision model response: {vision_response}")
+            else:
+                ASCIIColors.error(f"Vision generation failed: {vision_response}")
+        except Exception as e:
+            ASCIIColors.error(f"Error during vision test: {e}")
+            trace_exception(e)
+        finally:
+            if os.path.exists(dummy_image_path):
+                os.remove(dummy_image_path)
+
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during testing: {e}")
+        trace_exception(e)
+
+    ASCIIColors.yellow("\nGeminiBinding test finished.")

lollms_client/llm_bindings/litellm/__init__.py

@@ -0,0 +1,201 @@
+# bindings/LiteLLM/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_discussion import LollmsDiscussion
+from lollms_client.lollms_utilities import encode_image
+from typing import Optional, Callable, List, Union, Dict
+from ascii_colors import ASCIIColors, trace_exception
+
+# Use pipmaster to ensure required packages are installed
+try:
+    import pipmaster as pm
+except ImportError:
+    print("Pipmaster not found. Please install it using 'pip install pipmaster'")
+    raise
+
+# Ensure requests and tiktoken are installed
+pm.ensure_packages(["requests", "tiktoken"])
+
+import tiktoken
+
+BindingName = "LiteLLMBinding"
+
+def get_icon_path(model_name: str) -> str:
+    model_name = model_name.lower()
+    if 'gpt' in model_name: return '/bindings/openai/logo.png'
+    if 'mistral' in model_name or 'mixtral' in model_name: return '/bindings/mistral/logo.png'
+    if 'claude' in model_name: return '/bindings/anthropic/logo.png'
+    return '/bindings/litellm/logo.png'
+
+class LiteLLMBinding(LollmsLLMBinding):
+    """
+    A binding for the LiteLLM proxy using direct HTTP requests.
+    This version includes detailed logging, a fallback for listing models,
+    and correct payload formatting for both streaming and non-streaming modes.
+    """
+    
+    def __init__(self, host_address: str, model_name: str, service_key: str = "anything", verify_ssl_certificate: bool = True, **kwargs):
+        super().__init__(binding_name="litellm")
+        self.host_address = host_address.rstrip('/')
+        self.model_name = model_name
+        self.service_key = service_key
+        self.verify_ssl_certificate = verify_ssl_certificate
+
+    def _perform_generation(self, messages: List[Dict], n_predict: Optional[int], stream: bool, temperature: float, top_p: float, repeat_penalty: float, seed: Optional[int], streaming_callback: Optional[Callable[[str, MSG_TYPE], None]]) -> Union[str, dict]:
+        url = f'{self.host_address}/v1/chat/completions'
+        headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {self.service_key}'}
+        payload = {
+            "model": self.model_name, "messages": messages, "max_tokens": n_predict,
+            "temperature": temperature, "top_p": top_p, "frequency_penalty": repeat_penalty,
+            "stream": stream
+        }
+        if seed is not None: payload["seed"] = seed
+        
+        payload = {k: v for k, v in payload.items() if v is not None}
+        output = ""
+        try:
+            response = requests.post(url, headers=headers, data=json.dumps(payload), stream=stream, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+
+            if stream:
+                for line in response.iter_lines():
+                    if line:
+                        decoded_line = line.decode('utf-8')
+                        if decoded_line.startswith('data: '):
+                            if '[DONE]' in decoded_line: break
+                            json_data_string = decoded_line[6:]
+                            try:
+                                chunk_data = json.loads(json_data_string)
+                                delta = chunk_data.get('choices', [{}])[0].get('delta', {})
+                                if 'content' in delta and delta['content'] is not None:
+                                    word = delta['content']
+                                    if streaming_callback and not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                                        return output
+                                    output += word
+                            except json.JSONDecodeError: continue
+            else:
+                full_response = response.json()
+                output = full_response['choices'][0]['message']['content']
+                if streaming_callback:
+                    streaming_callback(output, MSG_TYPE.MSG_TYPE_CHUNK)
+        except Exception as e:
+            error_message = f"An error occurred: {e}\nResponse: {response.text if 'response' in locals() else 'No response'}"
+            trace_exception(e)
+            if streaming_callback: streaming_callback(error_message, MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {"status": "error", "message": error_message}
+        return output
+
+    def generate_text(self, prompt: str, images: Optional[List[str]] = None, system_prompt: str = "", n_predict: Optional[int] = None, stream: Optional[bool] = None, temperature: float = 0.7, top_p: float = 0.9, repeat_penalty: float = 1.1, seed: Optional[int] = None, streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None, **kwargs) -> Union[str, dict]:
+        """Generates text from a prompt, correctly formatting for text-only and multi-modal cases."""
+        is_streaming = stream if stream is not None else (streaming_callback is not None)
+        
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        # --- THIS IS THE CRITICAL FIX ---
+        if images:
+            # If images are present, use the multi-modal list format for content
+            user_content = [{"type": "text", "text": prompt}]
+            for image_path in images:
+                base64_image = encode_image(image_path)
+                user_content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}})
+            messages.append({"role": "user", "content": user_content})
+        else:
+            # If no images, use a simple string for content to avoid the API error
+            messages.append({"role": "user", "content": prompt})
+        # --- END OF FIX ---
+
+        return self._perform_generation(messages, n_predict, is_streaming, temperature, top_p, repeat_penalty, seed, streaming_callback)
+
+    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_p: float = 0.9, repeat_penalty: float = 1.1, seed: Optional[int] = None, streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None, **kwargs) -> Union[str, dict]:
+        is_streaming = stream if stream is not None else (streaming_callback is not None)
+        messages = discussion.export("openai_chat", branch_tip_id)
+        return self._perform_generation(messages, n_predict, is_streaming, temperature, top_p, repeat_penalty, seed, streaming_callback)
+
+    def embed(self, text: str, **kwargs) -> List[float]:
+        url = f'{self.host_address}/v1/embeddings'
+        headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {self.service_key}'}
+        payload = {"model": self.model_name, "input": text}
+        try:
+            response = requests.post(url, headers=headers, data=json.dumps(payload), verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+            return response.json()['data'][0]['embedding']
+        except Exception as e:
+            trace_exception(e)
+            return []
+
+    def tokenize(self, text: str) -> list:
+        return tiktoken.model.encoding_for_model("gpt-3.5-turbo").encode(text)
+            
+    def detokenize(self, tokens: list) -> str:
+        return tiktoken.model.encoding_for_model("gpt-3.5-turbo").decode(tokens)
+
+    def count_tokens(self, text: str) -> int:
+        return len(self.tokenize(text))
+    
+    def _list_models_openai_fallback(self) -> List[Dict]:
+        ASCIIColors.warning("--- [LiteLLM Binding] Falling back to /v1/models endpoint. Rich metadata will be unavailable.")
+        url = f'{self.host_address}/v1/models'
+        headers = {'Authorization': f'Bearer {self.service_key}'}
+        entries = []
+        try:
+            response = requests.get(url, headers=headers, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+            models_data = response.json().get('data', [])
+            for model in models_data:
+                model_name = model.get('id')
+                entries.append({
+                    "category": "api", "datasets": "unknown", "icon": get_icon_path(model_name),
+                    "license": "unknown", "model_creator": model.get('owned_by', 'unknown'),
+                    "name": model_name, "provider": "litellm", "rank": "1.0", "type": "api",
+                    "variants": [{"name": model_name, "size": -1}]
+                })
+        except Exception as e:
+            ASCIIColors.error(f"--- [LiteLLM Binding] Fallback method failed: {e}")
+        return entries
+
+    def listModels(self) -> List[Dict]:
+        url = f'{self.host_address}/model/info'
+        headers = {'Authorization': f'Bearer {self.service_key}'}
+        entries = []
+        ASCIIColors.yellow(f"--- [LiteLLM Binding] Attempting to list models from: {url}")
+        try:
+            response = requests.get(url, headers=headers, verify=self.verify_ssl_certificate)
+            if response.status_code == 404:
+                ASCIIColors.warning("--- [LiteLLM Binding] /model/info endpoint not found (404).")
+                return self._list_models_openai_fallback()
+            response.raise_for_status()
+            models_data = response.json().get('data', [])
+            ASCIIColors.info(f"--- [LiteLLM Binding] Successfully parsed {len(models_data)} models from primary endpoint.")
+            for model in models_data:
+                model_name = model.get('model_name')
+                if not model_name: continue
+                model_info = model.get('model_info', {})
+                context_size = model_info.get('max_tokens', model_info.get('max_input_tokens', 4096))
+                entries.append({
+                    "category": "api", "datasets": "unknown", "icon": get_icon_path(model_name),
+                    "license": "unknown", "model_creator": model_info.get('owned_by', 'unknown'),
+                    "name": model_name, "provider": "litellm", "rank": "1.0", "type": "api",
+                    "variants": [{
+                        "name": model_name, "size": context_size,
+                        "input_cost_per_token": model_info.get('input_cost_per_token', 0),
+                        "output_cost_per_token": model_info.get('output_cost_per_token', 0),
+                        "max_output_tokens": model_info.get('max_output_tokens', 0),
+                    }]
+                })
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"--- [LiteLLM Binding] Network error when trying to list models: {e}")
+            if "404" in str(e): return self._list_models_openai_fallback()
+        except Exception as e:
+            ASCIIColors.error(f"--- [LiteLLM Binding] An unexpected error occurred while listing models: {e}")
+        return entries
+
+    def get_model_info(self) -> dict:
+        return {"name": "LiteLLM", "host_address": self.host_address, "model_name": self.model_name}
+
+    def load_model(self, model_name: str) -> bool:
+        self.model_name = model_name
+        return True

lollms_client/llm_bindings/openai/__init__.py

@@ -104,15 +104,15 @@ class OpenAIBinding(LollmsLLMBinding):
         """
         count = 0
         output = ""
+        messages = [
+            {
+                "role": "system",
+                "content": system_prompt or "You are a helpful assistant.",
+            }
+        ]
 
         # Prepare messages based on whether images are provided
         if images:
-            messages = [
-                {
-                    "role": "system",
-                    "content": system_prompt,
-                }
-            ]
             if split:
                 messages += self.split_discussion(prompt,user_keyword=user_keyword, ai_keyword=ai_keyword)
                 if images:
@@ -151,7 +151,27 @@ class OpenAIBinding(LollmsLLMBinding):
                 )
             
         else:
-            messages = [{"role": "user", "content": prompt}]
+            
+            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:

lollms_client/lollms_core.py

@@ -1443,7 +1443,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         use_mcps: Union[None, bool, List[str]] = None,
         use_data_store: Union[None, Dict[str, Callable]] = None,
         system_prompt: str = None,
-        reasoning_system_prompt: str = "You are a logical and adaptive AI assistant.",
+        reasoning_system_prompt: str = "You are a logical AI assistant. Your task is to achieve the user's goal by thinking step-by-step and using the available tools.",
         images: Optional[List[str]] = None,
         max_reasoning_steps: int = None,
         decision_temperature: float = None,
@@ -1529,6 +1529,8 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         def log_prompt(prompt, type="prompt"):
             ASCIIColors.cyan(f"** DEBUG: {type} **")
             ASCIIColors.magenta(prompt[-15000:])
+            prompt_size = self.count_tokens(prompt)
+            ASCIIColors.red(f"Prompt size:{prompt_size}/{self.default_ctx_size}")
             ASCIIColors.cyan(f"** DEBUG: DONE **")
 
         # --- Define Inner Helper Functions ---
@@ -1560,7 +1562,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     else:
                         _substitute_code_uuids_recursive(item, code_store)
 
-        discovery_step_id = log_event("Discovering tools",MSG_TYPE.MSG_TYPE_STEP_START)
+        discovery_step_id = log_event("**Discovering tools**",MSG_TYPE.MSG_TYPE_STEP_START)
         # --- 1. Discover Available Tools ---
         available_tools = []
         if use_mcps and self.mcp:
@@ -1578,9 +1580,9 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         
         # Add the new put_code_in_buffer tool definition
         available_tools.append({
-            "name": "put_code_in_buffer",
-            "description": "Generates a block of code (e.g., Python, SQL) to be used by another tool. It returns a unique 'code_id'. You must then use this 'code_id' as the value for the code parameter in the subsequent tool call. This **does not** execute the code. It only buffers it for future use. Only use it if another tool requires code.",
-            "input_schema": {"type": "object", "properties": {"prompt": {"type": "string", "description": "A detailed natural language description of the code's purpose and requirements."}}, "required": ["prompt"]}
+            "name": "generate_code",
+            "description": """Generates and stores code into a buffer to be used by another tool. You can put the uuid of the generated code into the fields that require long code among the tools. If no tool requires code as input do not use generate_code. generate_code do not execute the code nor does it audit it.""",
+            "input_schema": {"type": "object", "properties": {"prompt": {"type": "string", "description": "A detailed natural language description of the code's purpose and requirements."}, "language": {"type": "string", "description": "The programming language of the generated code. By default it uses python."}}, "required": ["prompt"]}
         })
         # Add the new refactor_scratchpad tool definition
         available_tools.append({
@@ -1598,12 +1600,11 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         # --- 2. Dynamic Reasoning Loop ---
         for i in range(max_reasoning_steps):
             try:
-                reasoning_step_id = log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_START)
+                reasoning_step_id = log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_START)
                 user_context = f'Original User Request: "{original_user_prompt}"'
                 if images: user_context += f'\n(Note: {len(images)} image(s) were provided with this request.)'
                 
-                reasoning_prompt_template = f"""You are a logical AI assistant. Your task is to achieve the user's goal by thinking step-by-step and using the available tools.
-
+                reasoning_prompt_template = f"""
 --- AVAILABLE TOOLS ---
 {formatted_tools_list}
 --- CONTEXT ---
@@ -1635,6 +1636,9 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     system_prompt=reasoning_system_prompt, temperature=decision_temperature,
                     images=images if i == 0 else None
                 )
+                if structured_action_response is None:
+                    log_event("**Error generating thought.** Retrying..", MSG_TYPE.MSG_TYPE_EXCEPTION)
+                    continue
                 if debug: log_prompt(structured_action_response, f"RAW REASONING RESPONSE (Step {i+1})")
 
                 try:
@@ -1650,11 +1654,11 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                 except (json.JSONDecodeError, TypeError) as e:
                     current_scratchpad += f"\n\n### Step {i+1} Failure\n- **Error:** Failed to generate a valid JSON action: {e}"
                     log_event(f"Step Failure: Invalid JSON action.", MSG_TYPE.MSG_TYPE_EXCEPTION, metadata={"details": str(e)})
-                    if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_END, metadata={"error": str(e)}, event_id=reasoning_step_id)
+                    if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, metadata={"error": str(e)}, event_id=reasoning_step_id)
                     
 
                 current_scratchpad += f"\n\n### Step {i+1}: Thought\n{thought}"
-                log_event(f"Thought: {thought}", MSG_TYPE.MSG_TYPE_THOUGHT_CONTENT)
+                log_event(f"**Thought**: {thought}", MSG_TYPE.MSG_TYPE_THOUGHT_CONTENT)
 
                 if not tool_name:
                     # Handle error...
@@ -1667,8 +1671,8 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 
                 if tool_name == "final_answer":
                     current_scratchpad += f"\n\n### Step {i+1}: Action\n- **Action:** Decided to formulate the final answer."
-                    log_event("Action: Formulate final answer.", MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK)
-                    if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}",MSG_TYPE.MSG_TYPE_STEP_END, event_id=reasoning_step_id)
+                    log_event("**Action**: Formulate final answer.", MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK)
+                    if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**",MSG_TYPE.MSG_TYPE_STEP_END, event_id=reasoning_step_id)
                     break
 
                 # --- Handle the `put_code_in_buffer` tool specifically ---
@@ -1687,9 +1691,9 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     tool_calls_this_turn.append({"name": "put_code_in_buffer", "params": tool_params, "result": tool_result})
                     observation_text = f"```json\n{json.dumps(tool_result, indent=2)}\n```"
                     current_scratchpad += f"\n\n### Step {i+1}: Observation\n- **Action:** Called `{tool_name}`\n- **Result:**\n{observation_text}"
-                    log_event(f"Observation: Code generated with ID: {code_uuid}", MSG_TYPE.MSG_TYPE_OBSERVATION)
+                    log_event(f"**Observation**:Code generated with ID: {code_uuid}", MSG_TYPE.MSG_TYPE_OBSERVATION)
                     if code_gen_id: log_event(f"Generating code...", MSG_TYPE.MSG_TYPE_TOOL_CALL, metadata={"id": code_gen_id, "result": tool_result})
-                    if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_END, event_id= reasoning_step_id)
+                    if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, event_id= reasoning_step_id)
                     continue # Go to the next reasoning step immediately
                 if tool_name == 'refactor_scratchpad':
                     scratchpad_cleaning_prompt = f"""Enhance this scratchpad content to be more organized and comprehensive. Keep relevant experience information and remove any useless redundancies. Try to log learned things from the context so that you won't make the same mistakes again. Do not remove the main objective information or any crucial information that may be useful for the next iterations. Answer directly with the new scratchpad content without any comments.
@@ -1697,13 +1701,13 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 {current_scratchpad}
 --- END OF SCRATCHPAD ---"""
                     current_scratchpad = self.generate_text(scratchpad_cleaning_prompt)
-                    log_event(f"New scratchpad:\n{current_scratchpad}")
+                    log_event(f"**New scratchpad**:\n{current_scratchpad}", MSG_TYPE.MSG_TYPE_SCRATCHPAD)
                     
                 # --- Substitute UUIDs and Execute Standard Tools ---
-                log_event(f"Calling tool: `{tool_name}` with params:\n{dict_to_markdown(tool_params)}", MSG_TYPE.MSG_TYPE_STEP)
+                log_event(f"**Calling tool**: `{tool_name}` with params:\n{dict_to_markdown(tool_params)}", MSG_TYPE.MSG_TYPE_TOOL_CALL)
                 _substitute_code_uuids_recursive(tool_params, generated_code_store)
                 
-                tool_call_id = log_event(f"Executing tool: {tool_name}",MSG_TYPE.MSG_TYPE_STEP_START, metadata={"name": tool_name, "parameters": tool_params, "id":"executing tool"})
+                tool_call_id = log_event(f"**Executing tool**: {tool_name}",MSG_TYPE.MSG_TYPE_STEP_START, metadata={"name": tool_name, "parameters": tool_params, "id":"executing tool"})
                 tool_result = None
                 try:
                     if tool_name.startswith("research::") and use_data_store:
@@ -1725,7 +1729,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     trace_exception(e)
                     tool_result = {"status": "failure", "error": f"Exception executing tool: {str(e)}"}
                 
-                if tool_call_id: log_event(f"Executing tool: {tool_name}", MSG_TYPE.MSG_TYPE_STEP_END, metadata={"result": tool_result}, event_id= tool_call_id)
+                if tool_call_id: log_event(f"**Executing tool**: {tool_name}", MSG_TYPE.MSG_TYPE_STEP_END, metadata={"result": tool_result}, event_id= tool_call_id)
 
                 observation_text = ""
                 sanitized_result = {}
@@ -1753,16 +1757,16 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                 current_scratchpad += f"\n\n### Step {i+1}: Observation\n- **Action:** Called `{tool_name}`\n- **Result:**\n{observation_text}"
                 log_event(f"Observation: Result from `{tool_name}`:\n{dict_to_markdown(sanitized_result)}", MSG_TYPE.MSG_TYPE_OBSERVATION)
                 
-                if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_END, event_id = reasoning_step_id)
+                if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, event_id = reasoning_step_id)
             except Exception as ex:
                 trace_exception(ex)
                 current_scratchpad += f"\n\n### Error : {ex}"
-                if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_END, event_id = reasoning_step_id)
+                if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, event_id = reasoning_step_id)
                 
         # --- Final Answer Synthesis ---
         synthesis_id = log_event("Synthesizing final answer...", MSG_TYPE.MSG_TYPE_STEP_START)
         
-        final_answer_prompt = f"""You are an AI assistant. Provide a final, comprehensive answer based on your work.
+        final_answer_prompt = f"""
 --- Original User Request ---
 "{original_user_prompt}"
 --- Your Internal Scratchpad (Actions Taken & Findings) ---
@@ -1773,7 +1777,20 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 - Do not talk about your internal process unless it's necessary to explain why you couldn't find an answer.
 """
         if debug: log_prompt(final_answer_prompt, "FINAL ANSWER SYNTHESIS PROMPT")
+
+            
         final_answer_text = self.generate_text(prompt=final_answer_prompt, system_prompt=system_prompt, images=images, stream=streaming_callback is not None, streaming_callback=streaming_callback, temperature=final_answer_temperature, **llm_generation_kwargs)
+        if type(final_answer_text) is dict:
+            if streaming_callback:
+                streaming_callback(final_answer_text["error"], MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {
+            "final_answer": "",
+            "final_scratchpad": current_scratchpad,
+            "tool_calls": tool_calls_this_turn,
+            "sources": sources_this_turn,
+            "clarification_required": False,
+            "error": final_answer_text["error"]
+        }
         final_answer = self.remove_thinking_blocks(final_answer_text)
         if debug: log_prompt(final_answer_text, "FINAL ANSWER RESPONSE")
 

lollms_client/lollms_discussion.py

@@ -423,6 +423,35 @@ class LollmsDiscussion:
         else:
             return cls(lollmsClient=lollms_client, discussion_id=kwargs.get('id'), **init_args)
 
+    def get_messages(self, branch_id: Optional[str] = None) -> Union[List[LollmsMessage], Optional[LollmsMessage]]:
+        """
+        Returns messages from the discussion with branch-aware logic.
+
+        - If no branch_id is provided, it returns a list of all messages
+          in the currently active branch, ordered from root to leaf.
+        - If a branch_id is provided, it returns the single message object
+          (the "leaf") corresponding to that ID.
+
+        Args:
+            branch_id: The ID of the leaf message. If provided, only this
+                       message is returned. If None, the full active branch is returned.
+
+        Returns:
+            A list of LollmsMessage objects for the active branch, or a single
+            LollmsMessage if a branch_id is specified, or None if the ID is not found.
+        """
+        if branch_id is None:
+            # Case 1: No ID, return the current active branch as a list of messages
+            leaf_id = self.active_branch_id
+            return self.get_branch(leaf_id)
+        else:
+            # Case 2: ID provided, return just the single leaf message
+            if branch_id in self._message_index:
+                return LollmsMessage(self, self._message_index[branch_id])
+            else:
+                return None
+
+
     def __getattr__(self, name: str) -> Any:
         """Proxies attribute getting to the underlying discussion object."""
         if name == 'metadata':

lollms_client/mcp_bindings/remote_mcp/__init__.py

@@ -119,7 +119,26 @@ class RemoteMCPBinding(LollmsMCPBinding):
         future = asyncio.run_coroutine_threadsafe(coro, self._loop)
         return future.result(timeout)
 
-    ### MODIFIED: Now operates on a specific server identified by alias
+    def _prepare_headers(self, alias: str) -> Dict[str, str]:
+        """Prepares the headers dictionary from the server's auth_config."""
+        server_info = self.servers[alias]
+        auth_config = server_info.get("auth_config", {})
+        headers = {}
+        auth_type = auth_config.get("type")
+        if auth_type == "api_key":
+            api_key = auth_config.get("key")
+            header_name = auth_config.get("header_name", "X-API-Key") # Default to X-API-Key
+            if api_key:
+                headers[header_name] = api_key
+                ASCIIColors.info(f"{self.binding_name}: Using API Key authentication for server '{alias}'.")
+
+        elif auth_type == "bearer": # <-- NEW BLOCK
+            token = auth_config.get("token")
+            if token:
+                headers["Authorization"] = f"Bearer {token}"
+                
+        return headers
+
     async def _initialize_connection_async(self, alias: str) -> bool:
         server_info = self.servers[alias]
         if server_info["initialized"]:
@@ -128,10 +147,13 @@ class RemoteMCPBinding(LollmsMCPBinding):
         server_url = server_info["url"]
         ASCIIColors.info(f"{self.binding_name}: Initializing connection to '{alias}' ({server_url})...")
         try:
+            # Prepare authentication headers
+            auth_headers = self._prepare_headers(alias)
+
             exit_stack = AsyncExitStack()
             
             client_streams = await exit_stack.enter_async_context(
-                streamablehttp_client(server_url)
+                streamablehttp_client(url=server_url, headers=auth_headers) # Pass the headers here
             )
             read_stream, write_stream, _ = client_streams
 
@@ -343,3 +365,59 @@ class RemoteMCPBinding(LollmsMCPBinding):
 
     def get_binding_config(self) -> Dict[str, Any]:
         return self.config
+    
+    
+    def set_auth_config(self, alias: str, auth_config: Dict[str, Any]):
+        """
+        Dynamically updates the authentication configuration for a specific server.
+
+        If a connection was already active for this server, it will be closed to force
+        a new connection with the new authentication details on the next call.
+
+        Args:
+            alias (str): The alias of the server to update (the key in servers_infos).
+            auth_config (Dict[str, Any]): The new authentication configuration dictionary.
+                Example: {"type": "bearer", "token": "new-token-here"}
+        """
+        ASCIIColors.info(f"{self.binding_name}: Updating auth_config for server '{alias}'.")
+        
+        server_info = self.servers.get(alias)
+        if not server_info:
+            raise ValueError(f"Server alias '{alias}' does not exist in the configuration.")
+
+        # Update the configuration in the binding's internal state
+        server_info["config"]["auth_config"] = auth_config
+
+        # If the server was already initialized, its connection is now obsolete.
+        # We must close it and mark it as uninitialized.
+        if server_info["initialized"]:
+            ASCIIColors.warning(f"{self.binding_name}: Existing connection for '{alias}' is outdated due to new authentication. It will be reset.")
+            try:
+                # Execute the close operation asynchronously on the event loop thread
+                self._run_async(self._close_connection_async(alias), timeout=10.0)
+            except Exception as e:
+                ASCIIColors.error(f"{self.binding_name}: Error while closing the outdated connection for '{alias}': {e}")
+                # Even on error, reset the state to force a new connection attempt
+                server_info.update({"session": None, "exit_stack": None, "initialized": False})
+
+
+    # --- NEW INTERNAL HELPER METHOD ---
+    async def _close_connection_async(self, alias: str):
+        """Cleanly closes the connection for a specific server alias."""
+        server_info = self.servers.get(alias)
+        if not server_info or not server_info.get("exit_stack"):
+            return # Nothing to do.
+
+        ASCIIColors.info(f"{self.binding_name}: Closing connection for '{alias}'...")
+        try:
+            await server_info["exit_stack"].aclose()
+        except Exception as e:
+            trace_exception(e)
+            ASCIIColors.error(f"{self.binding_name}: Exception while closing the exit_stack for '{alias}': {e}")
+        finally:
+            # Reset the state for this alias, no matter what.
+            server_info.update({
+                "session": None,
+                "exit_stack": None,
+                "initialized": False
+            })

{lollms_client-0.25.0.dist-info → lollms_client-0.25.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.25.0
+Version: 0.25.5
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License
@@ -186,7 +186,7 @@ graph LR
         LC -- Manages --> LLB[LLM Binding];
         LC -- Manages --> MCPB[MCP Binding];
         LC -- Orchestrates --> MCP_Interaction[generate_with_mcp];
-        LC -- Provides --> HighLevelOps[High-Level Ops<br>(summarize, deep_analyze etc.)];
+        LC -- Provides --> HighLevelOps["High-Level Ops(summarize, deep_analyze etc.)"];
         LC -- Provides Access To --> DM[DiscussionManager];
         LC -- Provides Access To --> ModalityBindings[TTS, TTI, STT etc.];
     end
@@ -195,16 +195,16 @@ graph LR
         LLB --> LollmsServer[LoLLMs Server];
         LLB --> OllamaServer[Ollama];
         LLB --> OpenAPIServer[OpenAI API];
-        LLB --> LocalGGUF[Local GGUF<br>(pythonllamacpp / llamacpp server)];
-        LLB --> LocalHF[Local HuggingFace<br>(transformers / vLLM)];
+        LLB --> LocalGGUF["Local GGUF<br>(pythonllamacpp / llamacpp server)"];
+        LLB --> LocalHF["Local HuggingFace<br>(transformers / vLLM)"];
     end
 
     MCP_Interaction --> MCPB;
-    MCPB --> LocalTools[Local Python Tools<br>(via local_mcp)];
-    MCPB --> RemoteTools[Remote MCP Tool Servers<br>(Future Potential)];
+    MCPB --> LocalTools["Local Python Tools<br>(via local_mcp)"];
+    MCPB --> RemoteTools["Remote MCP Tool Servers<br>(Future Potential)"];
 
 
-    ModalityBindings --> ModalityServices[Modality Services<br>(e.g., LoLLMs Server TTS/TTI, local Bark/XTTS)];
+    ModalityBindings --> ModalityServices["Modality Services<br>(e.g., LoLLMs Server TTS/TTI, local Bark/XTTS)"];
 ```
 
 *   **`LollmsClient`**: The central class for all interactions. It holds the currently active LLM binding, an optional MCP binding, and provides access to modality bindings and high-level operations.

{lollms_client-0.25.0.dist-info → lollms_client-0.25.5.dist-info}/RECORD

@@ -26,10 +26,10 @@ examples/mcp_examples/openai_mcp.py,sha256=7IEnPGPXZgYZyiES_VaUbQ6viQjenpcUxGiHE
 examples/mcp_examples/run_remote_mcp_example_v2.py,sha256=bbNn93NO_lKcFzfIsdvJJijGx2ePFTYfknofqZxMuRM,14626
 examples/mcp_examples/run_standard_mcp_example.py,sha256=GSZpaACPf3mDPsjA8esBQVUsIi7owI39ca5avsmvCxA,9419
 examples/test_local_models/local_chat.py,sha256=slakja2zaHOEAUsn2tn_VmI4kLx6luLBrPqAeaNsix8,456
-lollms_client/__init__.py,sha256=Oa7LTqicgM_xArVjSRh-oGxuAXBR5QimNkcCCvsO8qo,1047
+lollms_client/__init__.py,sha256=vcMMG6tsMKDwGHGJnTNKEnIs36LkG2muoLVSjf7_uK4,1047
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=J6lGDhUiIS0jqY81AsLp6Nv6pLJbqlDCgxZI-1J-MNc,158724
-lollms_client/lollms_discussion.py,sha256=9mpEFz8UWMXrbyZonnq2nt1u5jDEgQqddHghUhSy9Yc,47516
+lollms_client/lollms_core.py,sha256=tA3DLmUNUwzcJxUEOm4aDvEJWrUWQafnveeuMUNn1Pg,159602
+lollms_client/lollms_discussion.py,sha256=By_dN3GJ7AtInkOUdcrXuVhKliBirKd3ZxFkaRmt1yM,48843
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=Kpzhs5Jx8eAlaaUacYnKV7qIq2wbME5lOEtKSfJKbpg,12161
 lollms_client/lollms_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
@@ -43,10 +43,12 @@ lollms_client/lollms_ttv_binding.py,sha256=KkTaHLBhEEdt4sSVBlbwr5i_g_TlhcrwrT-7D
 lollms_client/lollms_types.py,sha256=0iSH1QHRRD-ddBqoL9EEKJ8wWCuwDUlN_FrfbCdg7Lw,3522
 lollms_client/lollms_utilities.py,sha256=zx1X4lAXQ2eCUM4jDpu_1QV5oMGdFkpaSEdTASmaiqE,13545
 lollms_client/llm_bindings/__init__.py,sha256=9sWGpmWSSj6KQ8H4lKGCjpLYwhnVdL_2N7gXCphPqh4,14
+lollms_client/llm_bindings/gemini/__init__.py,sha256=ZflZVwAkAa-GfctuehOWIav977oTCdXUisQy253PFsk,21611
+lollms_client/llm_bindings/litellm/__init__.py,sha256=xlTaKosxK1tKz1YJ6witK6wAJHIENTV6O7ZbfpUOdB4,11289
 lollms_client/llm_bindings/llamacpp/__init__.py,sha256=Qj5RvsgPeHGNfb5AEwZSzFwAp4BOWjyxmm9qBNtstrc,63716
 lollms_client/llm_bindings/lollms/__init__.py,sha256=jfiCGJqMensJ7RymeGDDJOsdokEdlORpw9ND_Q30GYc,17831
 lollms_client/llm_bindings/ollama/__init__.py,sha256=QufsYqak2VlA2XGbzks8u55yNJFeDH2V35NGeZABkm8,32554
-lollms_client/llm_bindings/openai/__init__.py,sha256=i4T-QncGhrloslIF3zTlf6ZGJNZA43KCeFyOixD3Ums,19239
+lollms_client/llm_bindings/openai/__init__.py,sha256=4Mk8eBdc9VScI0Sdh4g4p_0eU2afJeCEUEJnCQO-QkM,20014
 lollms_client/llm_bindings/openllm/__init__.py,sha256=xv2XDhJNCYe6NPnWBboDs24AQ1VJBOzsTuMcmuQ6xYY,29864
 lollms_client/llm_bindings/pythonllamacpp/__init__.py,sha256=7dM42TCGKh0eV0njNL1tc9cInhyvBRIXzN3dcy12Gl0,33551
 lollms_client/llm_bindings/tensor_rt/__init__.py,sha256=nPaNhGRd-bsG0UlYwcEqjd_UagCMEf5VEbBUW-GWu6A,32203
@@ -57,7 +59,7 @@ lollms_client/mcp_bindings/local_mcp/default_tools/file_writer/file_writer.py,sh
 lollms_client/mcp_bindings/local_mcp/default_tools/generate_image_from_prompt/generate_image_from_prompt.py,sha256=THtZsMxNnXZiBdkwoBlfbWY2C5hhDdmPtnM-8cSKN6s,9488
 lollms_client/mcp_bindings/local_mcp/default_tools/internet_search/internet_search.py,sha256=PLC31-D04QKTOTb1uuCHnrAlpysQjsk89yIJngK0VGc,4586
 lollms_client/mcp_bindings/local_mcp/default_tools/python_interpreter/python_interpreter.py,sha256=McDCBVoVrMDYgU7EYtyOY7mCk1uEeTea0PSD69QqDsQ,6228
-lollms_client/mcp_bindings/remote_mcp/__init__.py,sha256=NBhmk9g9iMrzoraxbQo7wacUTTB1a_azZekuRPS8SO8,16606
+lollms_client/mcp_bindings/remote_mcp/__init__.py,sha256=6ebENOqO-oUk3IpitVyiMGRICSl_X5DKKaGG52BdiT8,20388
 lollms_client/mcp_bindings/standard_mcp/__init__.py,sha256=zpF4h8cTUxoERI-xcVjmS_V772LK0V4jegjz2k1PK98,31658
 lollms_client/stt_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/stt_bindings/lollms/__init__.py,sha256=jBz3285atdPRqQe9ZRrb-AvjqKRB4f8tjLXjma0DLfE,6082
@@ -79,8 +81,8 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=0IEWG4zH3_sOkSb9WbZzkeV5
 lollms_client/tts_bindings/xtts/__init__.py,sha256=FgcdUH06X6ZR806WQe5ixaYx0QoxtAcOgYo87a2qxYc,18266
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-0.25.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.25.0.dist-info/METADATA,sha256=BEfNVx_C0xdqP-26V5UbPL-mCuhtGzxsgPAEv_XveD0,13401
-lollms_client-0.25.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.25.0.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.25.0.dist-info/RECORD,,
+lollms_client-0.25.5.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.25.5.dist-info/METADATA,sha256=b1ANzWpdCjxfGYajBcr6eTny8C1lFWVBRHwNw1Yp3vs,13409
+lollms_client-0.25.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.25.5.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.25.5.dist-info/RECORD,,