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

lollms_client/__init__.py

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

lollms_client/llm_bindings/lollms/__init__.py

@@ -4,6 +4,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 ascii_colors import ASCIIColors, trace_exception
 from typing import Optional, Callable, List, Union
 import json

lollms_client/llm_bindings/openai/__init__.py

@@ -30,7 +30,8 @@ class OpenAIBinding(LollmsLLMBinding):
                  model_name: str = "",
                  service_key: str = None,
                  verify_ssl_certificate: bool = True,
-                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat):
+                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat,
+                 **kwargs):
         """
         Initialize the OpenAI binding.
 
@@ -52,7 +53,7 @@ class OpenAIBinding(LollmsLLMBinding):
 
         if not self.service_key:
             self.service_key = os.getenv("OPENAI_API_KEY", self.service_key)
-        self.client = openai.OpenAI(api_key=self.service_key, base_url=host_address)
+        self.client = openai.OpenAI(api_key=self.service_key, base_url=None if host_address is None else host_address if len(host_address)>0 else None)
         self.completion_format = ELF_COMPLETION_FORMAT.Chat
 
     
@@ -103,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:
@@ -150,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

@@ -13,6 +13,8 @@ from lollms_client.lollms_ttm_binding import LollmsTTMBinding, LollmsTTMBindingM
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 
 from lollms_client.lollms_discussion import LollmsDiscussion
+
+from lollms_client.lollms_utilities import build_image_dicts, dict_to_markdown
 import json, re
 from enum import Enum
 import base64
@@ -846,7 +848,7 @@ Don't forget encapsulate the code inside a html code tag. This is mandatory.
             "2.  **Check for a Single-Step Solution:** Scrutinize the available tools. Can a single tool call directly achieve the user's current goal? \n"
             "3.  **Formulate a Plan:** Based on your analysis, create a concise, numbered list of steps to achieve the goal. If the goal is simple, this may be only one step. If it is complex or multi-turn, it may be several steps.\n\n"
             "**CRITICAL RULES:**\n"
-            "*   **MANDATORY: NEVER add steps the user did not ask for.** Do not embellish or add 'nice-to-have' features.\n"
+            "*   **MANDATORY: Be helpful, curious and creative.\n"
             "*   **Focus on the Goal:** Your plan should directly address the user's request as it stands now in the conversation.\n\n"
             "---\n"
             "**Available Tools:**\n"
@@ -1078,7 +1080,7 @@ Provide your response as a single JSON object with one key, "query".
 """
             try:
                 raw_initial_query_response = self.generate_code(initial_query_gen_prompt, system_prompt="You are a query generation expert.", temperature=0.0)
-                initial_plan = json.loads(raw_initial_query_response)
+                initial_plan = robust_json_parser(raw_initial_query_response)
                 current_query_for_rag = initial_plan.get("query")
                 if not current_query_for_rag:
                     raise ValueError("LLM returned an empty initial query.")
@@ -1434,7 +1436,6 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         new_scratchpad_text = self.generate_text(prompt=synthesis_prompt, n_predict=1024, temperature=0.0)
         return self.remove_thinking_blocks(new_scratchpad_text).strip()
 
-# In lollms_client/lollms_discussion.py -> LollmsClient class
 
     def generate_with_mcp_rag(
         self,
@@ -1442,15 +1443,16 @@ 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 = 10,
-        decision_temperature: float = 0.0,
+        max_reasoning_steps: int = None,
+        decision_temperature: float = None,
         final_answer_temperature: float = None,
         streaming_callback: Optional[Callable[[str, 'MSG_TYPE', Optional[Dict], Optional[List]], bool]] = None,
-        rag_top_k: int = 5,
-        rag_min_similarity_percent: float = 70.0,
-        output_summarization_threshold: int = 500, # In tokens
+        rag_top_k: int = None,
+        rag_min_similarity_percent: float = None,
+        output_summarization_threshold: int = None, # In tokens
+        debug: bool = False,
         **llm_generation_kwargs
     ) -> Dict[str, Any]:
         """Generates a response using a dynamic agent with stateful, ID-based step tracking.
@@ -1483,6 +1485,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             rag_min_similarity_percent: Minimum similarity for RAG results.
             output_summarization_threshold: The token count that triggers automatic
                                             summarization of a tool's text output.
+            debug : If true, we'll report the detailed promptin and response information
             **llm_generation_kwargs: Additional keyword arguments for LLM calls.
 
         Returns:
@@ -1490,12 +1493,28 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             answer, the complete internal scratchpad, a log of tool calls,
             any retrieved RAG sources, and other metadata.
         """
+        reasoning_step_id = None
         if not self.binding:
             return {"final_answer": "", "tool_calls": [], "sources": [], "error": "LLM binding not initialized."}
 
+        if not max_reasoning_steps:
+            max_reasoning_steps= 10
+        if not rag_min_similarity_percent:
+            rag_min_similarity_percent= 50
+        if not rag_top_k:
+            rag_top_k = 5
+        if not decision_temperature:
+            decision_temperature = 0.7
+        if not output_summarization_threshold:
+            output_summarization_threshold = 500
+
+        events = []
+            
+            
         # --- Initialize Agent State ---
         sources_this_turn: List[Dict[str, Any]] = []
         tool_calls_this_turn: List[Dict[str, Any]] = []
+        generated_code_store: Dict[str, str] = {} # NEW: Store for UUID -> code
         original_user_prompt = prompt
         
         initial_state_parts = [
@@ -1507,41 +1526,50 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             initial_state_parts.append(f"- The user has provided {len(images)} image(s) for context.")
         current_scratchpad = "\n".join(initial_state_parts)
 
-        # --- Define Inner Helper Function for Stateful Step Logging ---
-        def log_step(
+        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 ---
+        def log_event(
             description: str,
-            step_type: str,
+            event_type: MSG_TYPE = MSG_TYPE.MSG_TYPE_CHUNK,
             metadata: Optional[Dict] = None,
-            is_start: bool = True
+            event_id=None
         ) -> Optional[str]:
-            """
-            Logs a step start or end, generating a unique ID for correlation.
-            This is an inner function that has access to the `streaming_callback`.
-            
-            Returns the ID for start events so it can be used for the end event.
-            """
-            if not streaming_callback:
-                return None
-
-            event_id = str(uuid.uuid4()) if is_start else None
-            
-            params = {"type": step_type, "description": description, **(metadata or {})}
-            
-            if is_start:
-                params["id"] = event_id
-                streaming_callback(description, MSG_TYPE.MSG_TYPE_STEP_START, params)
-                return event_id
-            else:
-                if 'id' in params:
-                    streaming_callback(description, MSG_TYPE.MSG_TYPE_STEP_END, params)
-                else: # Fallback for simple, non-duration steps
-                    streaming_callback(description, MSG_TYPE.MSG_TYPE_STEP, params)
-                return None
+            if not streaming_callback: return None
+            event_id = str(uuid.uuid4()) if event_type==MSG_TYPE.MSG_TYPE_STEP_START else event_id
+            params = {"type": event_type, "description": description, **(metadata or {})}
+            params["id"] = event_id
+            streaming_callback(description, event_type, params)
+            return event_id
+
+        def _substitute_code_uuids_recursive(data: Any, code_store: Dict[str, str]):
+            """Recursively finds and replaces code UUIDs in tool parameters."""
+            if isinstance(data, dict):
+                for key, value in data.items():
+                    if isinstance(value, str) and value in code_store:
+                        data[key] = code_store[value]
+                    else:
+                        _substitute_code_uuids_recursive(value, code_store)
+            elif isinstance(data, list):
+                for i, item in enumerate(data):
+                    if isinstance(item, str) and item in code_store:
+                        data[i] = code_store[item]
+                    else:
+                        _substitute_code_uuids_recursive(item, code_store)
 
+        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:
-            available_tools.extend(self.mcp.discover_tools(force_refresh=True))
+            discovered_tools = self.mcp.discover_tools(force_refresh=True)
+            if isinstance(use_mcps, list):
+                available_tools.extend([t for t in discovered_tools if t["name"] in use_mcps])
+            
         if use_data_store:
             for store_name in use_data_store:
                 available_tools.append({
@@ -1550,20 +1578,33 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     "input_schema": {"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]}
                 })
         
-        formatted_tools_list = "\n".join([f"- {t['name']}: {t['description']}" for t in available_tools])
-        formatted_tools_list += "\n- request_clarification: Use if the user's request is ambiguous."
-        formatted_tools_list += "\n- final_answer: Use when you are ready to respond to the user."
+        # Add the new put_code_in_buffer tool definition
+        available_tools.append({
+            "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({
+            "name": "refactor_scratchpad",
+            "description": "Rewrites the scratchpad content to clean it and reorganize it. Only use if the scratchpad is messy or contains too much information compared to what you need.",
+            "input_schema": {"type": "object", "properties": {}}
+        })
+
+        formatted_tools_list = "\n".join([f"**{t['name']}**:\n{t['description']}\ninput schema:\n{json.dumps(t['input_schema'])}" for t in available_tools])
+        formatted_tools_list += "\n**request_clarification**:\nUse if the user's request is ambiguous and you can not infer a clear idea of his intent. this tool has no parameters."
+        formatted_tools_list += "\n**final_answer**:\nUse when you are ready to respond to the user. this tool has no parameters."
+
+        if discovery_step_id: log_event("Discovering tools",MSG_TYPE.MSG_TYPE_STEP_END, event_id=discovery_step_id)
 
         # --- 2. Dynamic Reasoning Loop ---
         for i in range(max_reasoning_steps):
-            reasoning_step_id = log_step(f"Reasoning Step {i+1}/{max_reasoning_steps}", "reasoning_step", is_start=True)
-
-            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.
-
+            try:
+                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"""
 --- AVAILABLE TOOLS ---
 {formatted_tools_list}
 --- CONTEXT ---
@@ -1577,122 +1618,152 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 2.  **THINK:**
     - Does the latest observation completely fulfill the user's original request?
     - If YES, your next action MUST be to use the `final_answer` tool.
-    - If NO, what is the single next logical step needed?
+    - If NO, what is the single next logical step needed? This may involve writing code first with `put_code_in_buffer`, then using another tool.
     - If you are stuck or the request is ambiguous, use `request_clarification`.
 3.  **ACT:** Formulate your decision as a JSON object.
 """
-            action_template = {
-                "thought": "My detailed analysis of the last observation and my reasoning for the next action.",
-                "action": {
-                    "tool_name": "The single tool to use (e.g., 'time_machine::get_current_time', 'final_answer').",
-                    "tool_params": {"param1": "value1"},
-                    "clarification_question": "(string, ONLY if tool_name is 'request_clarification')"
+                action_template = {
+                    "thought": "My detailed analysis of the last observation and my reasoning for the next action and how it integrates with my global plan.",
+                    "action": {
+                        "tool_name": "The single tool to use (e.g., 'put_code_in_buffer', 'time_machine::get_current_time', 'final_answer').",
+                        "tool_params": {"param1": "value1"},
+                        "clarification_question": "(string, ONLY if tool_name is 'request_clarification')"
+                    }
                 }
-            }
-            
-            structured_action_response = self.generate_code(
-                prompt=reasoning_prompt_template,
-                template=json.dumps(action_template, indent=2),
-                system_prompt=reasoning_system_prompt,
-                temperature=decision_temperature,
-                images=images if i == 0 else None
-            )
-
-            try:
-                action_data = json.loads(structured_action_response)
-                thought = action_data.get("thought", "No thought was generated.")
-                action = action_data.get("action", {})
-                tool_name = action.get("tool_name")
-                tool_params = action.get("tool_params", {})
-            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_step(f"\n\n### Step {i+1} Failure\n- **Error:** Failed to generate a valid JSON action: {e}", "scratchpad", is_start=False)
-                if reasoning_step_id:
-                    log_step(f"Reasoning Step {i+1}/{max_reasoning_steps}", "reasoning_step", metadata={"id": reasoning_step_id, "error": str(e)}, is_start=False)
-                break
+                if debug: log_prompt(reasoning_prompt_template, f"REASONING PROMPT (Step {i+1})")
+                structured_action_response = self.generate_code(
+                    prompt=reasoning_prompt_template, template=json.dumps(action_template, indent=2),
+                    system_prompt=reasoning_system_prompt, temperature=decision_temperature,
+                    images=images if i == 0 else None
+                )
+                if debug: log_prompt(structured_action_response, f"RAW REASONING RESPONSE (Step {i+1})")
 
-            current_scratchpad += f"\n\n### Step {i+1}: Thought\n{thought}"
-            log_step(f"\n\n### Step {i+1}: Thought\n{thought}", "scratchpad", is_start=False)
+                try:
+                    action_data = robust_json_parser(structured_action_response)
+                    thought = action_data.get("thought", "No thought was generated.")
+                    action = action_data.get("action", {})
+                    if isinstance(action,str):
+                        tool_name = action
+                        tool_params = {}
+                    else:   
+                        tool_name = action.get("tool_name")
+                        tool_params = action.get("tool_params", {})
+                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 not tool_name:
-                current_scratchpad += f"\n\n### Step {i+1} Failure\n- **Error:** Did not specify a tool name."
-                log_step(f"\n\n### Step {i+1} Failure\n- **Error:** Did not specify a tool name.", "scratchpad", is_start=False)
-                if reasoning_step_id:
-                    log_step(f"Reasoning Step {i+1}/{max_reasoning_steps}", "reasoning_step", metadata={"id": reasoning_step_id}, is_start=False)
-                break
+                current_scratchpad += f"\n\n### Step {i+1}: Thought\n{thought}"
+                log_event(f"Thought: {thought}", MSG_TYPE.MSG_TYPE_THOUGHT_CONTENT)
 
-            if tool_name == "request_clarification":
-                clarification_question = action.get("clarification_question", "Could you please provide more details?")
-                current_scratchpad += f"\n\n### Step {i+1}: Action\n- **Action:** Decided to request clarification.\n- **Question:** {clarification_question}"
-                log_step(f"\n\n### Step {i+1}: Action\n- **Action:** Decided to request clarification.\n- **Question:** {clarification_question}", "scratchpad", is_start=False)
-                if reasoning_step_id:
-                    log_step(f"Reasoning Step {i+1}/{max_reasoning_steps}", "reasoning_step", metadata={"id": reasoning_step_id}, is_start=False)
-                return {"final_answer": clarification_question, "final_scratchpad": current_scratchpad, "tool_calls": tool_calls_this_turn, "sources": sources_this_turn, "clarification_required": True, "error": None}
-
-            if tool_name == "final_answer":
-                current_scratchpad += f"\n\n### Step {i+1}: Action\n- **Action:** Decided to formulate the final answer."
-                log_step(f"\n\n### Step {i+1}: Action\n- **Action:** Decided to formulate the final answer.", "scratchpad", is_start=False)
-                if reasoning_step_id:
-                    log_step(f"Reasoning Step {i+1}/{max_reasoning_steps}", "reasoning_step", metadata={"id": reasoning_step_id}, is_start=False)
-                break
+                if not tool_name:
+                    # Handle error...
+                    break
+                
+                # --- Handle special, non-executing tools ---
+                if tool_name == "request_clarification":
+                    # Handle clarification...
+                    return {"final_answer": action.get("clarification_question", "Could you please provide more details?"), "final_scratchpad": current_scratchpad, "tool_calls": tool_calls_this_turn, "sources": sources_this_turn, "clarification_required": True, "error": None}
+
+                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)
+                    break
 
-            tool_call_id = log_step(f"Executing tool: {tool_name}", "tool_call", metadata={"name": tool_name, "parameters": tool_params}, is_start=True)
-            tool_result = None
-            try:
-                if tool_name.startswith("research::") and use_data_store:
-                    store_name = tool_name.split("::")[1]
-                    rag_callable = use_data_store.get(store_name, {}).get("callable")
-                    query = tool_params.get("query", "")
-                    retrieved_chunks = rag_callable(query, rag_top_k=rag_top_k, rag_min_similarity_percent=rag_min_similarity_percent)
-                    if retrieved_chunks:
-                        sources_this_turn.extend(retrieved_chunks)
-                        tool_result = {"status": "success", "summary": f"Found {len(retrieved_chunks)} relevant chunks.", "chunks": retrieved_chunks}
+                # --- Handle the `put_code_in_buffer` tool specifically ---
+                if tool_name == 'put_code_in_buffer':
+                    code_gen_id = log_event(f"Generating code...", MSG_TYPE.MSG_TYPE_STEP_START, metadata={"name": "put_code_in_buffer", "id": "gencode"})
+                    code_prompt = tool_params.get("prompt", "Generate the requested code.")
+                    
+                    # Use a specific system prompt to get raw code
+                    code_generation_system_prompt = "You are a code generation assistant. Generate ONLY the raw code based on the user's request. Do not add any explanations, markdown code fences, or other text outside of the code itself."
+                    generated_code = self.generate_code(prompt=code_prompt, system_prompt=code_generation_system_prompt + "\n----\n" + reasoning_prompt_template, **llm_generation_kwargs)
+                    
+                    code_uuid = str(uuid.uuid4())
+                    generated_code_store[code_uuid] = generated_code
+                    
+                    tool_result = {"status": "success", "code_id": code_uuid, "summary": f"Code generated successfully. Use this ID in the next tool call that requires code."}
+                    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)
+                    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)
+                    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.
+--- YOUR INTERNAL SCRATCHPAD (Work History & Analysis) ---
+{current_scratchpad}
+--- END OF SCRATCHPAD ---"""
+                    current_scratchpad = self.generate_text(scratchpad_cleaning_prompt)
+                    log_event(f"New scratchpad:\n{current_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)
+                _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_result = None
+                try:
+                    if tool_name.startswith("research::") and use_data_store:
+                        store_name = tool_name.split("::")[1]
+                        rag_callable = use_data_store.get(store_name, {}).get("callable")
+                        query = tool_params.get("query", "")
+                        retrieved_chunks = rag_callable(query, rag_top_k=rag_top_k, rag_min_similarity_percent=rag_min_similarity_percent)
+                        if retrieved_chunks:
+                            sources_this_turn.extend(retrieved_chunks)
+                            tool_result = {"status": "success", "summary": f"Found {len(retrieved_chunks)} relevant chunks.", "chunks": retrieved_chunks}
+                        else:
+                            tool_result = {"status": "success", "summary": "No relevant documents found."}
+                    elif use_mcps and self.mcp:
+                        mcp_result = self.mcp.execute_tool(tool_name, tool_params, lollms_client_instance=self)
+                        tool_result = {"status": "success", "output": mcp_result} if not (isinstance(mcp_result, dict) and "error" in mcp_result) else {"status": "failure", **mcp_result}
                     else:
-                        tool_result = {"status": "success", "summary": "No relevant documents found."}
-                elif use_mcps and self.mcp:
-                    mcp_result = self.mcp.execute_tool(tool_name, tool_params, lollms_client_instance=self)
-                    tool_result = {"status": "success", "output": mcp_result} if not (isinstance(mcp_result, dict) and "error" in mcp_result) else {"status": "failure", **mcp_result}
+                        tool_result = {"status": "failure", "error": f"Tool '{tool_name}' not found."}
+                except Exception as e:
+                    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)
+
+                observation_text = ""
+                sanitized_result = {}
+                if isinstance(tool_result, dict):
+                    sanitized_result = tool_result.copy()
+                    summarized_fields = {}
+                    for key, value in tool_result.items():
+                        if isinstance(value, str) and key.endswith("_base64") and len(value) > 256:
+                            sanitized_result[key] = f"[Image was generated. Size: {len(value)} bytes]"
+                            continue
+                        if isinstance(value, str) and len(self.tokenize(value)) > output_summarization_threshold:
+                            if streaming_callback: streaming_callback(f"Summarizing long output from field '{key}'...", MSG_TYPE.MSG_TYPE_STEP, {"type": "summarization"})
+                            summary = self.sequential_summarize(text=value, chunk_processing_prompt=f"Summarize key info from this chunk of '{key}'.", callback=streaming_callback)
+                            summarized_fields[key] = summary
+                            sanitized_result[key] = f"[Content summarized, see summary below. Original length: {len(value)} chars]"
+                    observation_text = f"```json\n{json.dumps(sanitized_result, indent=2)}\n```"
+                    if summarized_fields:
+                        observation_text += "\n\n**Summaries of Long Outputs:**"
+                        for key, summary in summarized_fields.items():
+                            observation_text += f"\n- **Summary of '{key}':**\n{summary}"
                 else:
-                    tool_result = {"status": "failure", "error": f"Tool '{tool_name}' not found."}
-            except Exception as e:
-                trace_exception(e)
-                tool_result = {"status": "failure", "error": f"Exception executing tool: {str(e)}"}
-            
-            if tool_call_id:
-                log_step(f"Executing tool: {tool_name}", "tool_call", metadata={"id": tool_call_id, "result": tool_result}, is_start=False)
-
-            observation_text = ""
-            if isinstance(tool_result, dict):
-                sanitized_result = tool_result.copy()
-                summarized_fields = {}
-                for key, value in tool_result.items():
-                    if isinstance(value, str) and key.endswith("_base64") and len(value) > 256:
-                        sanitized_result[key] = f"[Image was generated. Size: {len(value)} bytes]"
-                        continue
-                    if isinstance(value, str) and len(self.tokenize(value)) > output_summarization_threshold:
-                        if streaming_callback: streaming_callback(f"Summarizing long output from field '{key}'...", MSG_TYPE.MSG_TYPE_STEP, {"type": "summarization"})
-                        summary = self.sequential_summarize(text=value, chunk_processing_prompt=f"Summarize key info from this chunk of '{key}'.", callback=streaming_callback)
-                        summarized_fields[key] = summary
-                        sanitized_result[key] = f"[Content summarized, see summary below. Original length: {len(value)} chars]"
-                observation_text = f"```json\n{json.dumps(sanitized_result, indent=2)}\n```"
-                if summarized_fields:
-                    observation_text += "\n\n**Summaries of Long Outputs:**"
-                    for key, summary in summarized_fields.items():
-                        observation_text += f"\n- **Summary of '{key}':**\n{summary}"
-            else:
-                observation_text = f"Tool returned non-dictionary output: {str(tool_result)}"
-
-            tool_calls_this_turn.append({"name": tool_name, "params": tool_params, "result": tool_result})
-            current_scratchpad += f"\n\n### Step {i+1}: Observation\n- **Action:** Called `{tool_name}`\n- **Result:**\n{observation_text}"
-            log_step(f"### Step {i+1}: Observation\n- **Action:** Called `{tool_name}`\n", "scratchpad", is_start=False)
-            
-            if reasoning_step_id:
-                log_step(f"Reasoning Step {i+1}/{max_reasoning_steps}", "reasoning_step", metadata={"id": reasoning_step_id}, is_start=False)
-
+                    observation_text = f"Tool returned non-dictionary output: {str(tool_result)}"
+                
+                tool_calls_this_turn.append({"name": tool_name, "params": tool_params, "result": tool_result})
+                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)
+            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)
+                
         # --- Final Answer Synthesis ---
-        synthesis_id = log_step("Synthesizing final answer...", "final_answer_synthesis", is_start=True)
+        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) ---
@@ -1702,11 +1773,14 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 - If images were provided by the user, incorporate your analysis of them into the answer.
 - 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)
         final_answer = self.remove_thinking_blocks(final_answer_text)
+        if debug: log_prompt(final_answer_text, "FINAL ANSWER RESPONSE")
 
-        if synthesis_id:
-            log_step("Synthesizing final answer...", "final_answer_synthesis", metadata={"id": synthesis_id}, is_start=False)
+        if synthesis_id: log_event("Synthesizing final answer...", MSG_TYPE.MSG_TYPE_STEP_END, event_id= synthesis_id)
 
         return {
             "final_answer": final_answer,
@@ -1716,7 +1790,6 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             "clarification_required": False,
             "error": None
         }
-    
     def generate_code(
                         self,
                         prompt,
@@ -1795,7 +1868,7 @@ Do not split the code in multiple tags.
             while not last_code["is_complete"] and retries < max_retries:
                 retries += 1
                 ASCIIColors.info(f"Code block seems incomplete. Attempting continuation ({retries}/{max_retries})...")
-                continuation_prompt = f"{full_prompt}{code_content}\n\n{self.user_full_header}The previous code block was incomplete. Continue the code exactly from where it left off. Do not repeat the previous part. Only provide the continuation inside a single {code_tag_format} code tag.\n{self.ai_full_header}"
+                continuation_prompt = f"{prompt}\n\nAssistant:\n{code_content}\n\n{self.user_full_header}The previous code block was incomplete. Continue the code exactly from where it left off. Do not repeat the previous part. Only provide the continuation inside a single {code_tag_format} code tag.\n{self.ai_full_header}"
 
                 continuation_response = self.generate_text(
                     continuation_prompt,
@@ -2065,7 +2138,7 @@ Do not split the code in multiple tags.
             response_json_str = re.sub(r",\s*}", "}", response_json_str)
             response_json_str = re.sub(r",\s*]", "]", response_json_str)
 
-            parsed_response = json.loads(response_json_str)
+            parsed_response = robust_json_parser(response_json_str)
             answer = parsed_response.get("answer")
             explanation = parsed_response.get("explanation", "")
 
@@ -2159,7 +2232,7 @@ Do not split the code in multiple tags.
             response_json_str = re.sub(r",\s*}", "}", response_json_str)
             response_json_str = re.sub(r",\s*]", "]", response_json_str)
 
-            result = json.loads(response_json_str)
+            result = robust_json_parser(response_json_str)
             index = result.get("index")
             explanation = result.get("explanation", "")
 
@@ -2232,7 +2305,7 @@ Do not split the code in multiple tags.
             response_json_str = re.sub(r",\s*}", "}", response_json_str)
             response_json_str = re.sub(r",\s*]", "]", response_json_str)
 
-            result = json.loads(response_json_str)
+            result = robust_json_parser(response_json_str)
             ranking = result.get("ranking")
             explanations = result.get("explanations", []) if return_explanation else None
 
@@ -2856,5 +2929,3 @@ def chunk_text(text, tokenizer, detokenizer, chunk_size, overlap, use_separators
                 break
 
     return chunks
-
-

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.
@@ -421,6 +423,10 @@ class LollmsDiscussion:
         else:
             return cls(lollmsClient=lollms_client, discussion_id=kwargs.get('id'), **init_args)
 
+    def get_messages(self):
+        """Returns the list of messages"""
+        return self._db_discussion.messages
+
     def __getattr__(self, name: str) -> Any:
         """Proxies attribute getting to the underlying discussion object."""
         if name == 'metadata':
@@ -564,11 +570,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 +605,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'.
 
@@ -640,12 +649,21 @@ 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,
+                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 +672,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 +730,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 +742,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 +765,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 +841,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,15 +849,15 @@ 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
         participants = self.participants or {}
@@ -829,14 +869,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 +886,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 +893,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 +907,21 @@ 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})
-        
+
         for msg in branch:
             if msg.sender_type == 'user':
                 role = participants.get(msg.sender, "user")
@@ -897,6 +929,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 +942,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 +1011,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_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
+            })

{lollms_client-0.24.2.dist-info → lollms_client-0.25.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.24.2
+Version: 0.25.1
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License

{lollms_client-0.24.2.dist-info → lollms_client-0.25.1.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=ug-FkqdmbfZKMvmsAJhRZv9KepwPrqjRDT7ssn_o-gE,1047
+lollms_client/__init__.py,sha256=Vt2zeJ4Ekn2UWxfSKbn_pjE-QGL7uwoTnbTFuFIOyUk,1047
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=oOZz-k-dFh2-XC31oS7TD1W2M0J74tyqMWF_10BXzu4,152519
-lollms_client/lollms_discussion.py,sha256=e0lfbkj3Bh-1YbC1JncjO0Dvkx9maFXprAwLLiXxSFc,44578
+lollms_client/lollms_core.py,sha256=m_qfzybasY61KgAPVa84tdkqJWIog9iuIZc88pQQ-vw,158842
+lollms_client/lollms_discussion.py,sha256=JqKx--a6YMzL6ec6N9OD0B9oRlmkSV_KDKXjqP8291Y,47636
 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
@@ -40,13 +40,13 @@ lollms_client/lollms_tti_binding.py,sha256=afO0-d-Kqsmh8UHTijTvy6dZAt-XDB6R-IHmd
 lollms_client/lollms_ttm_binding.py,sha256=FjVVSNXOZXK1qvcKEfxdiX6l2b4XdGOSNnZ0utAsbDg,4167
 lollms_client/lollms_tts_binding.py,sha256=5cJYECj8PYLJAyB6SEH7_fhHYK3Om-Y3arkygCnZ24o,4342
 lollms_client/lollms_ttv_binding.py,sha256=KkTaHLBhEEdt4sSVBlbwr5i_g_TlhcrwrT-7DjOsjWQ,4131
-lollms_client/lollms_types.py,sha256=c2vkdmyCU5aCyOCfWmfJE-q74T8w1vHMzFoMy8453jY,3108
-lollms_client/lollms_utilities.py,sha256=qK5iNmrFD7NGaEVW3nCWT6AtEhLIVHCXMzEpYxG_M5w,11293
+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/llamacpp/__init__.py,sha256=Qj5RvsgPeHGNfb5AEwZSzFwAp4BOWjyxmm9qBNtstrc,63716
-lollms_client/llm_bindings/lollms/__init__.py,sha256=17TwGMDJMxRPjZjZZSysR8AwjMXZeRfDBy8RqWWuaIY,17769
+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=ay_2JJi4La258Eg3alUhnh6Y5IRyOWnHaFLXqvN_4ao,19144
+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 +57,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=_wtrwq5_kRV3Of2lB-45G7BZQVR_fYvacHYc_s6q9fk,16615
+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 +79,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.24.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.24.2.dist-info/METADATA,sha256=J8Cz-Gg5uQWVkVK7tnc3wtG5Aed78FLRj-NMN6mg9e8,13401
-lollms_client-0.24.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.24.2.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.24.2.dist-info/RECORD,,
+lollms_client-0.25.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.25.1.dist-info/METADATA,sha256=4yR9ohOc_JjNnJeDRTdbzfYbKkmMpl0wbw0Y9D2P0gc,13401
+lollms_client-0.25.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.25.1.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.25.1.dist-info/RECORD,,