lollms-client 0.24.2__py3-none-any.whl → 0.27.0__py3-none-any.whl

lollms_client/lollms_discussion.py

@@ -29,6 +29,8 @@ if False:
     from lollms_client import LollmsClient
     from lollms_personality import LollmsPersonality
 
+from lollms_client.lollms_utilities import build_image_dicts, robust_json_parser
+from ascii_colors import ASCIIColors, trace_exception
 
 class EncryptedString(TypeDecorator):
     """A SQLAlchemy TypeDecorator for field-level database encryption.
@@ -372,7 +374,9 @@ class LollmsDiscussion:
         object.__setattr__(self, '_message_index', None)
         object.__setattr__(self, '_messages_to_delete_from_db', set())
         object.__setattr__(self, '_is_db_backed', db_manager is not None)
-
+        
+        object.__setattr__(self, '_system_prompt', None)
+        
         if self._is_db_backed:
             if not db_discussion_obj and not discussion_id:
                 raise ValueError("Either discussion_id or db_discussion_obj must be provided for DB-backed discussions.")
@@ -421,6 +425,31 @@ class LollmsDiscussion:
         else:
             return cls(lollmsClient=lollms_client, discussion_id=kwargs.get('id'), **init_args)
 
+    def get_messages(self, branch_id: Optional[str] = None) -> Optional[List[LollmsMessage]]:
+        """
+        Returns a list of messages forming a branch, from root to a specific leaf.
+
+        - If no branch_id is provided, it returns the full message list of the
+          currently active branch.
+        - If a branch_id is provided, it returns the list of all messages from the
+          root up to (and including) the message with that ID.
+
+        Args:
+            branch_id: The ID of the leaf message of the desired branch.
+                       If None, the active branch's leaf is used.
+
+        Returns:
+            A list of LollmsMessage objects for the specified branch, ordered
+            from root to leaf, or None if the branch_id does not exist.
+        """
+        # Determine which leaf message ID to use
+        leaf_id = branch_id if branch_id is not None else self.active_branch_id
+
+        # Return the full branch leading to that leaf
+        # We assume self.get_branch() correctly handles non-existent IDs by returning None or an empty list.
+        return self.get_branch(leaf_id)
+
+
     def __getattr__(self, name: str) -> Any:
         """Proxies attribute getting to the underlying discussion object."""
         if name == 'metadata':
@@ -564,11 +593,13 @@ class LollmsDiscussion:
         self,
         user_message: str,
         personality: Optional['LollmsPersonality'] = None,
+        branch_tip_id: Optional[str | None] = None,
         use_mcps: Union[None, bool, List[str]] = None,
         use_data_store: Union[None, Dict[str, Callable]] = None,
         add_user_message: bool = True,
-        max_reasoning_steps: int = 10,
+        max_reasoning_steps: int = 20,
         images: Optional[List[str]] = None,
+        debug: bool = False,
         **kwargs
     ) -> Dict[str, 'LollmsMessage']:
         """Main interaction method that can invoke the dynamic, multi-modal agent.
@@ -597,6 +628,7 @@ class LollmsDiscussion:
                                  before it must provide a final answer.
             images: A list of base64-encoded images provided by the user, which will
                     be passed to the agent or a multi-modal LLM.
+            debug: If True, prints full prompts and raw AI responses to the console.
             **kwargs: Additional keyword arguments passed to the underlying generation
                       methods, such as 'streaming_callback'.
 
@@ -604,6 +636,9 @@ class LollmsDiscussion:
             A dictionary with 'user_message' and 'ai_message' LollmsMessage objects,
             where the 'ai_message' will contain rich metadata if an agentic turn was used.
         """
+        if personality is not None:
+            object.__setattr__(self, '_system_prompt', personality.system_prompt)
+            
         if self.max_context_size is not None:
             self.summarize_and_prune(self.max_context_size)
 
@@ -640,12 +675,22 @@ class LollmsDiscussion:
         # Step 3: Execute the appropriate generation logic.
         if is_agentic_turn:
             # --- AGENTIC TURN ---
+            prompt_for_agent = self.export("markdown", branch_tip_id if branch_tip_id else self.active_branch_id)
+            if debug:
+                ASCIIColors.cyan("\n" + "="*50)
+                ASCIIColors.cyan("--- DEBUG: AGENTIC TURN TRIGGERED ---")
+                ASCIIColors.cyan(f"--- PROMPT FOR AGENT (from discussion history) ---")
+                ASCIIColors.magenta(prompt_for_agent)
+                ASCIIColors.cyan("="*50 + "\n")
+
             agent_result = self.lollmsClient.generate_with_mcp_rag(
-                prompt=user_message,
+                prompt=prompt_for_agent,
                 use_mcps=use_mcps,
                 use_data_store=use_data_store,
                 max_reasoning_steps=max_reasoning_steps,
                 images=images,
+                system_prompt = self._system_prompt,
+                debug=debug, # Pass the debug flag down
                 **kwargs
             )
             final_content = agent_result.get("final_answer", "The agent did not produce a final answer.")
@@ -654,9 +699,27 @@ class LollmsDiscussion:
 
         else:
             # --- SIMPLE CHAT TURN ---
+            if debug:
+                prompt_for_chat = self.export("markdown", branch_tip_id if branch_tip_id else self.active_branch_id)
+                ASCIIColors.cyan("\n" + "="*50)
+                ASCIIColors.cyan("--- DEBUG: SIMPLE CHAT PROMPT ---")
+                ASCIIColors.magenta(prompt_for_chat)
+                ASCIIColors.cyan("="*50 + "\n")
+
             # For simple chat, we also need to consider images if the model is multi-modal
             final_raw_response = self.lollmsClient.chat(self, images=images, **kwargs) or ""
-            final_content = self.lollmsClient.remove_thinking_blocks(final_raw_response)
+            
+            if debug:
+                ASCIIColors.cyan("\n" + "="*50)
+                ASCIIColors.cyan("--- DEBUG: RAW SIMPLE CHAT RESPONSE ---")
+                ASCIIColors.magenta(final_raw_response)
+                ASCIIColors.cyan("="*50 + "\n")
+
+            if isinstance(final_raw_response, dict) and final_raw_response.get("status") == "error":
+                raise Exception(final_raw_response.get("message", "Unknown error from lollmsClient.chat"))
+            else:
+                final_content = self.lollmsClient.remove_thinking_blocks(final_raw_response)
+
             final_scratchpad = None # No agentic scratchpad in a simple turn
 
         # Step 4: Post-generation processing and statistics.
@@ -694,7 +757,7 @@ class LollmsDiscussion:
             
         return {"user_message": user_msg, "ai_message": ai_message_obj}
 
-    def regenerate_branch(self, **kwargs) -> Dict[str, 'LollmsMessage']:
+    def regenerate_branch(self, branch_tip_id=None, **kwargs) -> Dict[str, 'LollmsMessage']:
         """Regenerates the last AI response in the active branch.
 
         It deletes the previous AI response and calls chat() again with the
@@ -706,8 +769,15 @@ class LollmsDiscussion:
         Returns:
             A dictionary with the user and the newly generated AI message.
         """
+        if not branch_tip_id:
+            branch_tip_id = self.active_branch_id
         if not self.active_branch_id or self.active_branch_id not in self._message_index:
-            raise ValueError("No active message to regenerate from.")
+            if len(self._message_index)>0:
+                ASCIIColors.warning("No active message to regenerate from.\n")
+                ASCIIColors.warning(f"Using last available message:{list(self._message_index.keys())[-1]}\n")
+            else:
+                branch_tip_id = list(self._message_index.keys())[-1]
+                raise ValueError("No active message to regenerate from.")
         
         last_message_orm = self._message_index[self.active_branch_id]
         
@@ -722,11 +792,8 @@ class LollmsDiscussion:
             if self._is_db_backed:
                 self._messages_to_delete_from_db.add(last_message_id)
             
-            self.active_branch_id = parent_id
-            self.touch()
-
-        prompt_to_regenerate = self._message_index[self.active_branch_id].content
-        return self.chat(user_message=prompt_to_regenerate, add_user_message=False, **kwargs)
+        return self.chat(user_message="", add_user_message=False, branch_tip_id=branch_tip_id, **kwargs)
+    
     def delete_branch(self, message_id: str):
         """Deletes a message and its entire descendant branch.
 
@@ -801,7 +868,7 @@ class LollmsDiscussion:
 
         Args:
             format_type: The target format. Can be "lollms_text", "openai_chat",
-                         or "ollama_chat".
+                         "ollama_chat", or "markdown".
             branch_tip_id: The ID of the message to use as the end of the context.
                            Defaults to the active branch ID.
             max_allowed_tokens: The maximum number of tokens the final prompt can contain.
@@ -809,17 +876,17 @@ class LollmsDiscussion:
 
         Returns:
             A string for "lollms_text" or a list of dictionaries for "openai_chat"
-            and "ollama_chat".
+            and "ollama_chat". For "markdown", returns a Markdown-formatted string.
 
         Raises:
             ValueError: If an unsupported format_type is provided.
         """
         branch_tip_id = branch_tip_id or self.active_branch_id
-        if not branch_tip_id and format_type in ["lollms_text", "openai_chat", "ollama_chat"]:
+        if not branch_tip_id and format_type in ["lollms_text", "openai_chat", "ollama_chat", "markdown"]:
             return "" if format_type == "lollms_text" else []
-        
+
         branch = self.get_branch(branch_tip_id)
-        full_system_prompt = self.system_prompt # Simplified for clarity
+        full_system_prompt = self._system_prompt # Simplified for clarity
         participants = self.participants or {}
 
         def get_full_content(msg: 'LollmsMessage') -> str:
@@ -829,14 +896,12 @@ class LollmsDiscussion:
 
         # --- NATIVE LOLLMS_TEXT FORMAT ---
         if format_type == "lollms_text":
-            # --- FIX STARTS HERE ---
             final_prompt_parts = []
             message_parts = [] # Temporary list for correctly ordered messages
-            
+
             current_tokens = 0
             messages_to_render = branch
 
-            # 1. Handle non-destructive pruning summary
             summary_text = ""
             if self.pruning_summary and self.pruning_point_id:
                 pruning_index = -1
@@ -848,7 +913,6 @@ class LollmsDiscussion:
                     messages_to_render = branch[pruning_index:]
                     summary_text = f"!@>system:\n--- Conversation Summary ---\n{self.pruning_summary.strip()}\n"
 
-            # 2. Add main system prompt to the final list
             sys_msg_text = ""
             if full_system_prompt:
                 sys_msg_text = f"!@>system:\n{full_system_prompt.strip()}\n"
@@ -856,15 +920,13 @@ class LollmsDiscussion:
                 if max_allowed_tokens is None or sys_tokens <= max_allowed_tokens:
                     final_prompt_parts.append(sys_msg_text)
                     current_tokens += sys_tokens
-            
-            # 3. Add pruning summary (if it exists) to the final list
+
             if summary_text:
                 summary_tokens = self.lollmsClient.count_tokens(summary_text)
                 if max_allowed_tokens is None or current_tokens + summary_tokens <= max_allowed_tokens:
                     final_prompt_parts.append(summary_text)
                     current_tokens += summary_tokens
 
-            # 4. Build the message list in correct order, respecting token limits
             for msg in reversed(messages_to_render):
                 sender_str = msg.sender.replace(':', '').replace('!@>', '')
                 content = get_full_content(msg)
@@ -872,24 +934,24 @@ class LollmsDiscussion:
                     content += f"\n({len(msg.images)} image(s) attached)"
                 msg_text = f"!@>{sender_str}:\n{content}\n"
                 msg_tokens = self.lollmsClient.count_tokens(msg_text)
-                
+
                 if max_allowed_tokens is not None and current_tokens + msg_tokens > max_allowed_tokens:
                     break
-                
-                # Always insert at the beginning of the temporary list
+
                 message_parts.insert(0, msg_text)
                 current_tokens += msg_tokens
-            
-            # 5. Combine system/summary prompts with the message parts
+
             final_prompt_parts.extend(message_parts)
             return "".join(final_prompt_parts).strip()
-            # --- FIX ENDS HERE ---
-        
-        # --- OPENAI & OLLAMA CHAT FORMATS (remains the same and is correct) ---
+
+        # --- OPENAI & OLLAMA CHAT FORMATS ---
         messages = []
         if full_system_prompt:
-            messages.append({"role": "system", "content": full_system_prompt})
-        
+            if format_type == "markdown":
+                messages.append(f"system: {full_system_prompt}")
+            else:
+                messages.append({"role": "system", "content": full_system_prompt})
+
         for msg in branch:
             if msg.sender_type == 'user':
                 role = participants.get(msg.sender, "user")
@@ -897,6 +959,8 @@ class LollmsDiscussion:
                 role = participants.get(msg.sender, "assistant")
 
             content, images = get_full_content(msg), msg.images or []
+            images = build_image_dicts(images)        
+
 
             if format_type == "openai_chat":
                 if images:
@@ -908,18 +972,29 @@ class LollmsDiscussion:
                     messages.append({"role": role, "content": content_parts})
                 else:
                     messages.append({"role": role, "content": content})
-            
+
             elif format_type == "ollama_chat":
                 message_dict = {"role": role, "content": content}
+                
                 base64_images = [img['data'] for img in images if img['type'] == 'base64']
                 if base64_images:
                     message_dict["images"] = base64_images
                 messages.append(message_dict)
 
+            elif format_type == "markdown":
+                # Create Markdown content based on the role and content
+                markdown_line = f"**{role.capitalize()}**: {content}\n"
+                if images:
+                    for img in images:
+                        img_data = img['data']
+                        url = f"![Image](data:image/jpeg;base64,{img_data})" if img['type'] == 'base64' else f"![Image]({img_data})"
+                        markdown_line += f"\n{url}\n"
+                messages.append(markdown_line)
+
             else:
                 raise ValueError(f"Unsupported export format_type: {format_type}")
-                
-        return messages
+
+        return "\n".join(messages) if format_type == "markdown" else messages
     
 
     def summarize_and_prune(self, max_tokens: int, preserve_last_n: int = 4):
@@ -966,4 +1041,27 @@ class LollmsDiscussion:
         self.pruning_point_id = pruning_point_message.id
         
         self.touch()
-        print(f"[INFO] Discussion auto-pruned. {len(messages_to_prune)} messages summarized. History preserved.")
+        print(f"[INFO] Discussion auto-pruned. {len(messages_to_prune)} messages summarized. History preserved.")
+
+    def switch_to_branch(self, branch_id):
+        self.active_branch_id = branch_id
+
+    def auto_title(self):
+        try:
+            if self.metadata is None:
+                self.metadata = {}
+            discussion = self.export("markdown")[0:1000]
+            prompt = f"""You are a title builder. Your oibjective is to build a title for the following discussion:
+{discussion}
+...
+"""
+            template = """{
+    "title": "An short but comprehensive discussion title"
+}"""
+            infos = self.lollmsClient.generate_code(prompt = prompt, template = template)
+            discussion_title = robust_json_parser(infos)["title"]
+            self.metadata['title'] = discussion_title
+            self.commit()
+            return discussion_title
+        except Exception as ex:
+            trace_exception(ex)

lollms_client/lollms_llm_binding.py

@@ -302,3 +302,7 @@ class LollmsLLMBindingManager:
             list[str]: List of binding names.
         """
         return [binding_dir.name for binding_dir in self.llm_bindings_dir.iterdir() if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+
+def get_available_bindings():
+    bindings_dir = Path(__file__).parent/"llm_bindings"
+    return [binding_dir.name for binding_dir in bindings_dir.iterdir() if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]

lollms_client/lollms_types.py

@@ -1,7 +1,7 @@
 from  enum import Enum
 class MSG_TYPE(Enum):
     # Messaging
-    MSG_TYPE_CHUNK                  = 0 # A chunk of a message (used for classical chat)
+    MSG_TYPE_CHUNK                      = 0 # A chunk of a message (used for classical chat)
     MSG_TYPE_CONTENT                   = 1 # A full message (for some personality the answer is sent in bulk)
     MSG_TYPE_CONTENT_INVISIBLE_TO_AI   = 2 # A full message (for some personality the answer is sent in bulk)
     MSG_TYPE_CONTENT_INVISIBLE_TO_USER = 3 # A full message (for some personality the answer is sent in bulk)
@@ -36,6 +36,14 @@ class MSG_TYPE(Enum):
     MSG_TYPE_TOOL_CALL              = 19# a tool call
     MSG_TYPE_TOOL_OUTPUT            = 20# the output of the tool
 
+    MSG_TYPE_REASONING              = 21# the ai shows its reasoning
+    MSG_TYPE_SCRATCHPAD             = 22# the ai shows its scratchpad
+    MSG_TYPE_OBSERVATION            = 23# the ai shows its reasoning
+
+    MSG_TYPE_ERROR                  = 24#a severe error hapened
+    MSG_TYPE_GENERATING_TITLE_START = 25#a severe error hapened
+    MSG_TYPE_GENERATING_TITLE_END   = 26#a severe error hapened
+
 
 class SENDER_TYPES(Enum):
     SENDER_TYPES_USER               = 0 # Sent by user

lollms_client/lollms_utilities.py

@@ -11,6 +11,74 @@ import numpy as np
 import json
 from ascii_colors import ASCIIColors, trace_exception
 
+def dict_to_markdown(d, indent=0):
+    """
+    Formats a dictionary (with potential nested lists and dicts) as a markdown list.
+
+    Args:
+        d (dict): The dictionary to format.
+        indent (int): Current indentation level (used recursively).
+
+    Returns:
+        str: The formatted markdown string.
+    """
+    lines = []
+    indent_str = ' ' * (indent * 2)
+    
+    for key, value in d.items():
+        if isinstance(value, dict):
+            # Recursively handle nested dictionary
+            lines.append(f"{indent_str}- {key}:")
+            lines.append(dict_to_markdown(value, indent + 1))
+        elif isinstance(value, list):
+            lines.append(f"{indent_str}- {key}:")
+            for item in value:
+                if isinstance(item, dict):
+                    # Render nested dicts in the list
+                    lines.append(dict_to_markdown(item, indent + 1))
+                else:
+                    # Render strings or other simple items in the list
+                    lines.append(f"{' ' * (indent + 1) * 2}- {item}")
+        else:
+            # Simple key-value pair
+            lines.append(f"{indent_str}- {key}: {value}")
+    
+    return "\n".join(lines)
+
+def is_base64(s):
+    """Check if the string is a valid base64 encoded string."""
+    try:
+        # Try to decode and then encode back to check for validity
+        import base64
+        base64.b64decode(s)
+        return True
+    except Exception as e:
+        return False
+
+def build_image_dicts(images):
+    """
+    Convert a list of image strings (base64 or URLs) into a list of dictionaries with type and data.
+
+    Args:
+        images (list): List of image strings (either base64-encoded or URLs).
+
+    Returns:
+        list: List of dictionaries in the format {'type': 'base64'/'url', 'data': <image string>}.
+    """
+    result = []
+
+    for img in images:
+        if isinstance(img, str):
+            if is_base64(img):
+                result.append({'type': 'base64', 'data': img})
+            else:
+                # Assuming it's a URL if not base64
+                result.append({'type': 'url', 'data': img})
+        else:
+            result.append(img)
+
+    return result
+
 def robust_json_parser(json_string: str) -> dict:
     """
     Parses a possibly malformed JSON string using a series of corrective strategies.

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
 
@@ -294,7 +316,7 @@ class RemoteMCPBinding(LollmsMCPBinding):
 
         try:
             # Ensure this specific server is connected before executing
-            self._ensure_initialized_sync(alias, timeout=min(timeout, 30.0))
+            self._ensure_initialized_sync(alias, timeout=timeout)
             return self._run_async(self._execute_tool_async(alias, actual_tool_name, params), timeout=timeout)
         except (ConnectionError, RuntimeError) as e:
             return {"error": f"{self.binding_name}: Connection issue for server '{alias}': {e}", "status_code": 503}
@@ -342,4 +364,60 @@ class RemoteMCPBinding(LollmsMCPBinding):
         ASCIIColors.info(f"{self.binding_name}: Remote connection binding closed.")
 
     def get_binding_config(self) -> Dict[str, Any]:
-        return self.config
+        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
+            })