Update app.py

app.py

@@ -1,16 +1,14 @@
 import os
 DEMO_MODE = False
-MEMORY_STORAGE_TYPE = "RAM" 
+MEMORY_STORAGE_TYPE = "RAM"
 
 HF_DATASET_MEMORY_REPO = "broadfield-dev/ai-brain"
 HF_DATASET_RULES_REPO = "broadfield-dev/ai-rules"
 
-# Set environment variables based on the toggles above BEFORE importing other modules
 os.environ['STORAGE_BACKEND'] = MEMORY_STORAGE_TYPE
 if MEMORY_STORAGE_TYPE == "HF_DATASET":
     os.environ['HF_MEMORY_DATASET_REPO'] = HF_DATASET_MEMORY_REPO
     os.environ['HF_RULES_DATASET_REPO'] = HF_DATASET_RULES_REPO
-# --- END CONFIGURATION ---
 
 
 import json
@@ -22,8 +20,6 @@ import gradio as gr
 import time
 import tempfile
 import xml.etree.ElementTree as ET
-
-# --- New Imports for Image KV Functionality ---
 import io
 import struct
 import numpy as np
@@ -32,16 +28,15 @@ from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 from cryptography.hazmat.primitives import hashes
 from cryptography.exceptions import InvalidTag
-# --- End New Imports ---
 import random
 
-load_dotenv() # Load .env file, but our settings above will take precedence if set.
+load_dotenv()
 
 from model_logic import (
     get_available_providers, get_model_display_names_for_provider,
     get_default_model_display_name_for_provider, call_model_stream, MODELS_BY_PROVIDER
 )
-    
+
 from memory_logic import (
     initialize_memory_system,
     add_memory_entry, retrieve_memories_semantic, get_all_memories_cached, clear_all_memory_data_backend,
@@ -57,8 +52,6 @@ for lib_name in ["urllib3", "requests", "huggingface_hub", "PIL.PngImagePlugin",
     if logging.getLogger(lib_name): logging.getLogger(lib_name).setLevel(logging.WARNING)
 
 WEB_SEARCH_ENABLED = os.getenv("WEB_SEARCH_ENABLED", "true").lower() == "true"
-TOOL_DECISION_PROVIDER_ENV = os.getenv("TOOL_DECISION_PROVIDER", "groq")
-TOOL_DECISION_MODEL_ID_ENV = os.getenv("TOOL_DECISION_MODEL", "llama3-8b-8192")
 MAX_HISTORY_TURNS = int(os.getenv("MAX_HISTORY_TURNS", 7))
 current_chat_session_history = []
 
@@ -67,24 +60,21 @@ DEFAULT_SYSTEM_PROMPT = os.getenv(
     "Your Name is Node. You are a Helpful AI Assistant, and your goal is to improve yourself, so that you can improve everybody elses life. Your job is to answer questions and perform research tasks accurately and thoroughly. You can use tools like web search and page browsing. When providing information from the web, cite your sources if possible. If asked to perform a task beyond your capabilities, explain politely. Be concise unless asked for detail."
 )
 
-# --- Startup Loading File Paths ---
 LOAD_RULES_FILE = os.getenv("LOAD_RULES_FILE")
 LOAD_MEMORIES_FILE = os.getenv("LOAD_MEMORIES_FILE")
-logger.info(f"App Config: WebSearch={WEB_SEARCH_ENABLED}, ToolDecisionProvider={TOOL_DECISION_PROVIDER_ENV}, ToolDecisionModelID={TOOL_DECISION_MODEL_ID_ENV}, MemoryBackend={MEMORY_STORAGE_BACKEND}")
+logger.info(f"App Config: WebSearch={WEB_SEARCH_ENABLED}, MemoryBackend={MEMORY_STORAGE_BACKEND}")
 logger.info(f"Startup loading: Rules from {LOAD_RULES_FILE or 'None'}, Memories from {LOAD_MEMORIES_FILE or 'None'}")
 
 
-# --- KV to Image Functions (Constants and Implementation) ---
 KEY_SIZE = 32
 SALT_SIZE = 16
 NONCE_SIZE = 12
 TAG_SIZE = 16
 PBKDF2_ITERATIONS = 480000
-LENGTH_HEADER_SIZE = 4  # struct.pack('>I') uses 4 bytes
+LENGTH_HEADER_SIZE = 4
 PREFERRED_FONTS = ["Arial", "Helvetica", "DejaVu Sans", "Verdana", "Calibri", "sans-serif"]
 MAX_KEYS_TO_DISPLAY_OVERLAY = 15
 def convert_pil_to_png_bytes(image: Image.Image) -> bytes:
-    """Saves a PIL image to an in-memory buffer as PNG and returns the raw bytes."""
     with io.BytesIO() as buffer:
         image.save(buffer, format="PNG")
         return buffer.getvalue()
@@ -165,78 +155,57 @@ def parse_kv_string_to_dict(kv_str:str)->dict:
     return dd
 
 def generate_brain_carrier_image(w=800, h=800) -> Image.Image:
-    """
-    Generates a high-quality carrier image with a multi-layered, procedural starfield
-    using NumPy for performance and visual appeal.
-    """
-    # --- 1. Create the Gradient Background with NumPy ---
     center_x, center_y = w / 2, h / 2
     y_coords, x_coords = np.mgrid[0:h, 0:w]
 
-    # Calculate distance of each pixel from the center
     distance = np.sqrt((x_coords - center_x)**2 + (y_coords - center_y)**2)
     max_distance = np.sqrt(center_x**2 + center_y**2)
-    
-    # Normalize distance to a 0-1 range
+
     distance_norm = distance / max_distance
-    
-    # Define colors and create the gradient array
-    bg_center_color = np.array([20, 25, 40])  # Deeper blue center
-    bg_outer_color = np.array([0, 0, 0])      # Black edges
-    
-    # Interpolate colors across all pixels at once (vectorized)
-    # The [..., np.newaxis] part is for broadcasting the color channels
+
+    bg_center_color = np.array([20, 25, 40])
+    bg_outer_color = np.array([0, 0, 0])
+
     gradient = bg_outer_color + (bg_center_color - bg_outer_color) * (1 - distance_norm[..., np.newaxis])
-    
-    # Convert the NumPy array to a PIL Image to start drawing on it
+
     img = Image.fromarray(gradient.astype(np.uint8), 'RGB')
     draw = ImageDraw.Draw(img)
 
-    # --- 2. Draw a Multi-Layered Starfield ---
-    
-    # Layer 1: Distant, tiny stars (for depth)
     num_distant_stars = int((w * h) / 200)
     for _ in range(num_distant_stars):
         x, y = random.randint(0, w - 1), random.randint(0, h - 1)
         brightness = random.randint(30, 90)
-        draw.point((x, y), fill=(brightness, brightness, int(brightness * 1.1))) # Slightly blue tint
+        draw.point((x, y), fill=(brightness, brightness, int(brightness * 1.1)))
 
-    # Layer 2: Main stars with glow, size, and color variation
     num_main_stars = int((w * h) / 1000)
     star_colors = [
-        (255, 255, 255),  # White
-        (220, 230, 255),  # Light Blue
-        (255, 240, 220),  # Faint Yellow
+        (255, 255, 255),
+        (220, 230, 255),
+        (255, 240, 220),
     ]
-    
+
     for _ in range(num_main_stars):
         x, y = random.randint(0, w - 1), random.randint(0, h - 1)
         dist_from_center = np.sqrt((x - center_x)**2 + (y - center_y)**2)
         dist_ratio = min(dist_from_center / max_distance, 1.0)
-        
-        # Base size and brightness increase with distance from center
+
         size = 0.5 + (2.5 * (dist_ratio ** 2))
         brightness = 120 + (135 * (dist_ratio ** 1.5))
-        
-        # Select a random base color
+
         color = random.choice(star_colors)
-        
-        # Apply brightness to the selected color
+
         final_color = tuple(int(c * (brightness / 255.0)) for c in color)
-        
-        # Simulate a soft glow by drawing a larger, dimmer circle first
+
         glow_size = size * 3
-        glow_color = tuple(int(c * 0.3) for c in final_color) # Much dimmer
+        glow_color = tuple(int(c * 0.3) for c in final_color)
         draw.ellipse([x - glow_size, y - glow_size, x + glow_size, y + glow_size], fill=glow_color)
 
-        # Simulate a "twinkle" effect for some stars by drawing a cross
-        if random.random() < 0.15: # 15% chance to twinkle
+        if random.random() < 0.15:
             draw.line([x-size, y, x+size, y], fill=final_color, width=1)
             draw.line([x, y-size, x, y+size], fill=final_color, width=1)
         else:
-            # Draw the main star on top of the glow
             draw.ellipse([x - size, y - size, x + size, y + size], fill=final_color)
-            
+
     return img
 
 
@@ -260,7 +229,6 @@ def _get_text_measurement(draw_obj, text_str, font_obj):
         except: return len(text_str) * 8, 10
 
 def draw_key_list_dropdown_overlay(image: Image.Image, keys: list[str] = None, title: str = "Data Embedded") -> Image.Image:
-    """Draws overlays on the image using the 'KeyLock' style."""
     img_overlayed = image.copy().convert("RGBA")
     draw = ImageDraw.Draw(img_overlayed, "RGBA")
     width, height = img_overlayed.size
@@ -288,7 +256,7 @@ def draw_key_list_dropdown_overlay(image: Image.Image, keys: list[str] = None, t
 
         draw.rectangle([20, box_y0, width - 20, height - 20], fill=overlay_color)
         current_y = box_y0 + box_padding
-        
+
         for i, key_text in enumerate(lines):
             draw.text((text_start_x, current_y), key_text, fill=key_color, font=font_regular)
             if i < len(line_heights):
@@ -296,11 +264,10 @@ def draw_key_list_dropdown_overlay(image: Image.Image, keys: list[str] = None, t
 
     final_image_rgb = Image.new("RGB", img_overlayed.size, (0, 0, 0))
     final_image_rgb.paste(img_overlayed, (0, 0), img_overlayed)
-    
+
     return final_image_rgb
 
 
-# --- Helper Functions ---
 def format_insights_for_prompt(retrieved_insights_list: list[str]) -> tuple[str, list[dict]]:
     if not retrieved_insights_list:
         return "No specific guiding principles or learned insights retrieved.", []
@@ -346,101 +313,210 @@ def generate_interaction_metrics(user_input: str, bot_response: str, provider: s
         logger.error(f"METRICS_GEN Error: {e}", exc_info=False)
         return {"takeaway": "N/A", "response_success_score": 0.5, "future_confidence_score": 0.5, "error": str(e)}
 
+def _generate_action_plan(
+    original_query: str, provider_name: str, model_display_name: str, ui_api_key_override: str | None, chat_history: list[dict]
+) -> dict:
+    history_str = "\n".join([f"{msg['role']}: {msg['content'][:150]}" for msg in chat_history[-4:]])
+
+    plan_sys_prompt = """You are a master planner AI. Your goal is to decide the most efficient path to answer a user's query. You have two choices:
+
+1.  **fast_response**: If the query is simple, conversational, or can be answered without external tools, choose this.
+2.  **multi_step_plan**: If the query requires research, data retrieval, or complex reasoning, create a plan.
+
+Your plan can use the following tools:
+- `web_search`: Use for finding current, public information. The `task` should be a clear research goal (e.g., "Find the population of Tokyo in 2023").
+- `memory_search`: Use for recalling past interactions or learned facts. The `task` should be a question to ask your memory (e.g., "What did the user previously say their name was?").
+- `think`: A step for internal reflection. Use it to analyze the data gathered so far and decide if the plan needs adjustment or if enough information is present to proceed to the final answer. The `task` should be a question to yourself (e.g., "Is the gathered information sufficient to answer the user's main question?").
+- `respond`: This should ALWAYS be the final step in a multi_step_plan. The `task` is always "Synthesize all information from the scratchpad and provide a comprehensive final answer to the user."
+
+**Output format MUST be a single, valid JSON object.**
+
+**Example for a simple query:**
+{"action_type": "fast_response", "reason": "The user is just saying hello."}
+
+**Example for a complex query:**
+{
+  "action_type": "multi_step_plan",
+  "plan": [
+    {"tool": "memory_search", "task": "What has the user previously expressed interest in regarding AI topics?"},
+    {"tool": "web_search", "task": "Find recent advancements in large language models since early 2023."},
+    {"tool": "web_scrape", "task": "https://example.com"},
+    {"tool": "think", "task": "Based on the user's interests and recent advancements, what are the key points to highlight?"},
+    {"tool": "respond", "task": "Synthesize all information from the scratchpad and provide a comprehensive final answer to the user."}
+  ]
+}
+"""
+    plan_user_prompt = f"Recent Conversation History:\n---\n{history_str}\n---\n\nUser Query: \"{original_query}\"\n\nBased on the query and history, what is the best action plan? Respond with JSON only."
+    plan_messages = [{"role": "system", "content": plan_sys_prompt}, {"role": "user", "content": plan_user_prompt}]
 
-def process_user_interaction_gradio(user_input: str, provider_name: str, model_display_name: str, chat_history_for_prompt: list[dict], custom_system_prompt: str = None, ui_api_key_override: str = None):
+    try:
+        response_chunks = list(call_model_stream(
+            provider=provider_name,
+            model_display_name=model_display_name,
+            messages=plan_messages,
+            api_key_override=ui_api_key_override,
+            temperature=0.0,
+            max_tokens=1000
+        ))
+        resp_str = "".join(response_chunks).strip()
+        json_match = re.search(r"\{.*\}", resp_str, re.DOTALL)
+        if json_match:
+            plan_data = json.loads(json_match.group(0))
+            return plan_data
+    except Exception as e:
+        logger.error(f"PLAN_GEN: Failed to generate or parse action plan: {e}")
+    
+    return {
+        "action_type": "multi_step_plan",
+        "plan": [
+            {"tool": "web_search", "task": original_query},
+            {"tool": "respond", "task": "Synthesize all information from the scratchpad and provide a comprehensive final answer to the user."}
+        ]
+    }
+
+def process_user_interaction_gradio(
+    user_input: str,
+    max_research_steps: int,
+    provider_name: str,
+    model_display_name: str,
+    chat_history: list[dict],
+    custom_system_prompt: str = None,
+    ui_api_key_override: str = None,
+):
     process_start_time = time.time()
     request_id = os.urandom(4).hex()
-    logger.info(f"PUI_GRADIO [{request_id}] Start. User: '{user_input[:50]}...' Provider: {provider_name}/{model_display_name} Hist_len:{len(chat_history_for_prompt)}")
-    history_str_for_prompt = "\n".join([f"{('User' if t_msg['role'] == 'user' else 'AI')}: {t_msg['content']}" for t_msg in chat_history_for_prompt[-(MAX_HISTORY_TURNS * 2):]])
-    yield "status", "<i>[Checking guidelines (semantic search)...]</i>"
-    initial_insights = retrieve_rules_semantic(f"{user_input}\n{history_str_for_prompt}", k=5)
-    initial_insights_ctx_str, parsed_initial_insights_list = format_insights_for_prompt(initial_insights)
-    logger.info(f"PUI_GRADIO [{request_id}]: Initial RAG (insights) found {len(initial_insights)}. Context: {initial_insights_ctx_str[:150]}...")
-    action_type, action_input_dict = "quick_respond", {}
-    user_input_lower = user_input.lower()
-    time_before_tool_decision = time.time()
-    if WEB_SEARCH_ENABLED and ("http://" in user_input or "https://" in user_input):
-        url_match = re.search(r'(https?://[^\s]+)', user_input)
-        if url_match: action_type, action_input_dict = "scrape_url_and_report", {"url": url_match.group(1)}
-    if action_type == "quick_respond" and len(user_input.split()) <= 3 and any(kw in user_input_lower for kw in ["hello", "hi", "thanks", "ok", "bye"]) and not "?" in user_input: pass
-    elif action_type == "quick_respond" and WEB_SEARCH_ENABLED and (len(user_input.split()) > 3 or "?" in user_input or any(w in user_input_lower for w in ["what is", "how to", "explain", "search for"])):
-        yield "status", "<i>[LLM choosing best approach...]</i>"
-        history_snippet = "\n".join([f"{msg['role']}: {msg['content'][:100]}" for msg in chat_history_for_prompt[-2:]])
-        guideline_snippet = initial_insights_ctx_str[:200].replace('\n', ' ')
-        tool_sys_prompt = "You are a precise routing agent... Output JSON only. Example: {\"action\": \"search_duckduckgo_and_report\", \"action_input\": {\"search_engine_query\": \"query\"}}"
-        tool_user_prompt = f"User Query: \"{user_input}\"\nRecent History:\n{history_snippet}\nGuidelines: {guideline_snippet}...\nAvailable Actions: quick_respond, answer_using_conversation_memory, search_duckduckgo_and_report, scrape_url_and_report.\nSelect one action and input. Output JSON."
-        tool_decision_messages = [{"role":"system", "content": tool_sys_prompt}, {"role":"user", "content": tool_user_prompt}]
-        tool_provider, tool_model_id = TOOL_DECISION_PROVIDER_ENV, TOOL_DECISION_MODEL_ID_ENV
-        tool_model_display = next((dn for dn, mid in MODELS_BY_PROVIDER.get(tool_provider.lower(), {}).get("models", {}).items() if mid == tool_model_id), None)
-        if not tool_model_display: tool_model_display = get_default_model_display_name_for_provider(tool_provider)
-        if tool_model_display:
+    logger.info(f"PUI_GRADIO [{request_id}] Start. User: '{user_input[:50]}...' Max Steps: {max_research_steps}")
+
+    yield "status", "<i>[Deciding on an action plan...]</i>"
+    action_plan_data = _generate_action_plan(user_input, provider_name, model_display_name, ui_api_key_override, chat_history)
+
+    action_type = action_plan_data.get("action_type")
+    
+    if action_type == "fast_response":
+        yield "status", "<i>[Executing fast response...]</i>"
+        yield "plan", [{"tool": "fast_response", "task": action_plan_data.get("reason", "Direct answer.")}]
+
+        now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        final_sys_prompt = custom_system_prompt or DEFAULT_SYSTEM_PROMPT
+        final_sys_prompt = f"Current Date/Time: {now_str}.\n\n" + final_sys_prompt
+        
+        messages_for_llm = [{"role": "system", "content": final_sys_prompt}] + chat_history + [{"role": "user", "content": user_input}]
+        
+        streamed_response = ""
+        try:
+            for chunk in call_model_stream(provider=provider_name, model_display_name=model_display_name, messages=messages_for_llm, api_key_override=ui_api_key_override, temperature=0.7, max_tokens=3000):
+                streamed_response += chunk
+                yield "response_chunk", chunk
+        except Exception as e:
+            streamed_response = f"\n\n(Error during fast response: {str(e)[:150]})"
+            yield "response_chunk", streamed_response
+            
+        final_bot_text = streamed_response.strip()
+        yield "final_response", {"response": final_bot_text}
+        return
+
+    plan = action_plan_data.get("plan", [])
+    if not plan:
+        plan = [{"tool": "web_search", "task": user_input}, {"tool": "respond", "task": "Synthesize a response."}]
+    
+    yield "plan", plan
+    
+    research_scratchpad = ""
+    now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+    for i, step_action in enumerate(plan):
+        tool = step_action.get("tool")
+        task = step_action.get("task")
+        
+        if tool == 'respond':
+            break
+
+        if i + 1 > max_research_steps:
+            research_scratchpad += f"\n\n---NOTE: Maximum research step budget of {max_research_steps} reached. Proceeding to final response.---\n"
+            logger.warning(f"PUI_GRADIO [{request_id}]: Max research steps ({max_research_steps}) reached.")
+            break
+
+        yield "status", f"<i>[Executing Step {i+1}/{len(plan)-1}: {tool} -> {task[:70]}...]</i>"
+        
+        step_findings = f"Step {i+1} ({tool}: '{task}'): "
+        
+        if tool == 'web_search':
             try:
-                logger.info(f"PUI_GRADIO [{request_id}]: Tool decision LLM: {tool_provider}/{tool_model_display}")
-                tool_resp_chunks = list(call_model_stream(provider=tool_provider, model_display_name=tool_model_display, messages=tool_decision_messages, temperature=0.0, max_tokens=150))
-                tool_resp_raw = "".join(tool_resp_chunks).strip()
-                json_match_tool = re.search(r"\{.*\}", tool_resp_raw, re.DOTALL)
-                if json_match_tool:
-                    action_data = json.loads(json_match_tool.group(0))
-                    action_type, action_input_dict = action_data.get("action", "quick_respond"), action_data.get("action_input", {})
-                    if not isinstance(action_input_dict, dict): action_input_dict = {}
-                    logger.info(f"PUI_GRADIO [{request_id}]: LLM Tool Decision: Action='{action_type}', Input='{action_input_dict}'")
-                else: logger.warning(f"PUI_GRADIO [{request_id}]: Tool decision LLM non-JSON. Raw: {tool_resp_raw}")
-            except Exception as e: logger.error(f"PUI_GRADIO [{request_id}]: Tool decision LLM error: {e}", exc_info=False)
-        else: logger.error(f"No model for tool decision provider {tool_provider}.")
-    elif action_type == "quick_respond" and not WEB_SEARCH_ENABLED and (len(user_input.split()) > 4 or "?" in user_input or any(w in user_input_lower for w in ["remember","recall"])):
-        action_type="answer_using_conversation_memory"
-    logger.info(f"PUI_GRADIO [{request_id}]: Tool decision logic took {time.time() - time_before_tool_decision:.3f}s. Action: {action_type}, Input: {action_input_dict}")
-    yield "status", f"<i>[Path: {action_type}. Preparing response...]</i>"
-    final_system_prompt_str, final_user_prompt_content_str = custom_system_prompt or DEFAULT_SYSTEM_PROMPT, ""
-    if action_type == "quick_respond":
-        final_system_prompt_str += " Respond directly using guidelines & history."
-        final_user_prompt_content_str = f"History:\n{history_str_for_prompt}\nGuidelines:\n{initial_insights_ctx_str}\nQuery: \"{user_input}\"\nResponse:"
-    elif action_type == "answer_using_conversation_memory":
-        yield "status", "<i>[Searching conversation memory (semantic)...]</i>"
-        retrieved_mems = retrieve_memories_semantic(f"User query: {user_input}\nContext:\n{history_str_for_prompt[-1000:]}", k=2)
-        memory_context = "Relevant Past Interactions:\n" + "\n".join([f"- User:{m.get('user_input','')}->AI:{m.get('bot_response','')} (Takeaway:{m.get('metrics',{}).get('takeaway','N/A')})" for m in retrieved_mems]) if retrieved_mems else "No relevant past interactions found."
-        final_system_prompt_str += " Respond using Memory Context, guidelines, & history."
-        final_user_prompt_content_str = f"History:\n{history_str_for_prompt}\nGuidelines:\n{initial_insights_ctx_str}\nMemory Context:\n{memory_context}\nQuery: \"{user_input}\"\nResponse (use memory context if relevant):"
-    elif WEB_SEARCH_ENABLED and action_type in ["search_duckduckgo_and_report", "scrape_url_and_report"]:
-        query_or_url = action_input_dict.get("search_engine_query") if "search" in action_type else action_input_dict.get("url")
-        if not query_or_url:
-            final_system_prompt_str += " Respond directly (web action failed: no input)."
-            final_user_prompt_content_str = f"History:\n{history_str_for_prompt}\nGuidelines:\n{initial_insights_ctx_str}\nQuery: \"{user_input}\"\nResponse:"
-        else:
-            yield "status", f"<i>[Web: '{query_or_url[:60]}'...]</i>"
-            web_results, max_results = [], 1 if action_type == "scrape_url_and_report" else 2
+                web_results = search_and_scrape_duckduckgo(task, num_results=2)
+                scraped_content = "\n".join([f"Source:\nURL:{r.get('url','N/A')}\nContent:\n{(r.get('content') or r.get('error') or 'N/A')[:1500]}\n---" for r in web_results]) if web_results else "No results found."
+                synthesis_prompt = f"Relevant web content for the task '{task}':\n\n{scraped_content}\n\nConcisely summarize the findings from the content."
+                summary = "".join(list(call_model_stream(provider=provider_name, model_display_name=model_display_name, messages=[{"role": "user", "content": synthesis_prompt}], api_key_override=ui_api_key_override, temperature=0.1, max_tokens=400)))
+                step_findings += summary
+            except Exception as e:
+                try:
+                    web_results = search_and_scrape_google(task, num_results=2)
+                    scraped_content = "\n".join([f"Source:\nURL:{r.get('url','N/A')}\nContent:\n{(r.get('content') or r.get('error') or 'N/A')[:1500]}\n---" for r in web_results]) if web_results else "No results found."
+                    synthesis_prompt = f"Relevant web content for the task '{task}':\n\n{scraped_content}\n\nConcisely summarize the findings from the content."
+                    summary = "".join(list(call_model_stream(provider=provider_name, model_display_name=model_display_name, messages=[{"role": "user", "content": synthesis_prompt}], api_key_override=ui_api_key_override, temperature=0.1, max_tokens=400)))
+                    step_findings += summary
+                except Exception as e:
+                    step_findings += f"Error during web search: {e}"
+
+        elif tool == 'web_scrape':
             try:
-                if action_type == "search_duckduckgo_and_report": web_results = search_and_scrape_duckduckgo(query_or_url, num_results=max_results)
-                elif action_type == "scrape_url_and_report":
-                    res = scrape_url(query_or_url)
-                    if res and (res.get("content") or res.get("error")): web_results = [res]
-            except Exception as e: web_results = [{"url": query_or_url, "title": "Tool Error", "error": str(e)}]
-            scraped_content = "\n".join([f"Source {i+1}:\nURL:{r.get('url','N/A')}\nTitle:{r.get('title','N/A')}\nContent:\n{(r.get('content') or r.get('error') or 'N/A')[:3500]}\n---" for i,r in enumerate(web_results)]) if web_results else f"No results from {action_type} for '{query_or_url}'."
-            yield "status", "<i>[Synthesizing web report...]</i>"
-            final_system_prompt_str += " Generate report/answer from web content, history, & guidelines. Cite URLs as [Source X]."
-            final_user_prompt_content_str = f"History:\n{history_str_for_prompt}\nGuidelines:\n{initial_insights_ctx_str}\nWeb Content:\n{scraped_content}\nQuery: \"{user_input}\"\nReport/Response (cite sources [Source X]):"
-    else:
-        final_system_prompt_str += " Respond directly (unknown action path)."
-        final_user_prompt_content_str = f"History:\n{history_str_for_prompt}\nGuidelines:\n{initial_insights_ctx_str}\nQuery: \"{user_input}\"\nResponse:"
-    final_llm_messages = [{"role": "system", "content": final_system_prompt_str}, {"role": "user", "content": final_user_prompt_content_str}]
-    logger.debug(f"PUI_GRADIO [{request_id}]: Final LLM System Prompt: {final_system_prompt_str[:200]}...")
-    logger.debug(f"PUI_GRADIO [{request_id}]: Final LLM User Prompt Start: {final_user_prompt_content_str[:200]}...")
-    streamed_response, time_before_llm = "", time.time()
+                web_results = scrape_url(task)
+                scraped_content = "\n".join([f"Source:\nURL:{r.get('url','N/A')}\nContent:\n{(r.get('content') or r.get('error') or 'N/A')[:1500]}\n---" for r in web_results]) if web_results else "No results found."
+                synthesis_prompt = f"Relevant web content for the task '{task}':\n\n{scraped_content}\n\nConcisely summarize the findings from the content."
+                summary = "".join(list(call_model_stream(provider=provider_name, model_display_name=model_display_name, messages=[{"role": "user", "content": synthesis_prompt}], api_key_override=ui_api_key_override, temperature=0.1, max_tokens=400)))
+                step_findings += summary
+            except Exception as e:
+                step_findings += f"Error during web search: {e}"
+
+        elif tool == 'memory_search':
+            try:
+                retrieved_mems = retrieve_memories_semantic(task, k=3)
+                if retrieved_mems:
+                    memory_context = "\n".join([f"- User: {m.get('user_input','')} -> AI: {m.get('bot_response','')} (Takeaway: {m.get('metrics',{}).get('takeaway','N/A')})" for m in retrieved_mems])
+                    step_findings += f"Found relevant memories:\n{memory_context}"
+                else:
+                    step_findings += "No relevant memories found."
+            except Exception as e:
+                step_findings += f"Error during memory search: {e}"
+
+        elif tool == 'think':
+            try:
+                think_prompt = f"Original Query: '{user_input}'\n\nResearch Scratchpad:\n```\n{research_scratchpad}\n```\n\nMy current thinking task is: '{task}'. Based on the scratchpad, what is the conclusion of this thinking step?"
+                thought = "".join(list(call_model_stream(provider=provider_name, model_display_name=model_display_name, messages=[{"role": "user", "content": think_prompt}], api_key_override=ui_api_key_override, temperature=0.3, max_tokens=500)))
+                step_findings += f"Conclusion: {thought}"
+            except Exception as e:
+                step_findings += f"Error during thinking step: {e}"
+        else:
+            step_findings += "Unknown tool specified in plan."
+
+        research_scratchpad += f"\n\n---\n{step_findings}\n---"
+        yield "step_result", {"step": i + 1, "tool": tool, "task": task, "result": step_findings}
+
+    yield "status", "<i>[Synthesizing final report...]</i>"
+
+    final_sys_prompt = custom_system_prompt or DEFAULT_SYSTEM_PROMPT
+    final_sys_prompt += f"\n\nCurrent Date/Time: {now_str}. You have just completed a research plan. Synthesize the information in the 'Research Scratchpad' into a final, comprehensive answer. Cite sources by including URLs if available."
+    final_user_prompt = f"Original user query: \"{user_input}\"\n\nResearch Scratchpad:\n```\n{research_scratchpad}\n```\n\nNow, provide the final, synthesized answer to the user."
+    final_messages = [{"role": "system", "content": final_sys_prompt}, {"role": "user", "content": final_user_prompt}]
+
+    streamed_response = ""
     try:
-        for chunk in call_model_stream(provider=provider_name, model_display_name=model_display_name, messages=final_llm_messages, api_key_override=ui_api_key_override, temperature=0.6, max_tokens=2500):
-            if isinstance(chunk, str) and chunk.startswith("Error:"): streamed_response += f"\n{chunk}\n"; yield "response_chunk", f"\n{chunk}\n"; break
-            streamed_response += chunk; yield "response_chunk", chunk
-    except Exception as e: streamed_response += f"\n\n(Error: {str(e)[:150]})"; yield "response_chunk", f"\n\n(Error: {str(e)[:150]})"
-    logger.info(f"PUI_GRADIO [{request_id}]: Main LLM stream took {time.time() - time_before_llm:.3f}s.")
-    final_bot_text = streamed_response.strip() or "(No response or error.)"
+        for chunk in call_model_stream(provider=provider_name, model_display_name=model_display_name, messages=final_messages, api_key_override=ui_api_key_override, temperature=0.6, max_tokens=3000):
+            streamed_response += chunk
+            yield "response_chunk", chunk
+    except Exception as e:
+        error_msg = f"\n\n(Error during final synthesis: {str(e)[:150]})"
+        streamed_response += error_msg
+        yield "response_chunk", error_msg
+
+    final_bot_text = streamed_response.strip() or "(No response or error during synthesis.)"
     logger.info(f"PUI_GRADIO [{request_id}]: Finished. Total: {time.time() - process_start_time:.2f}s. Resp len: {len(final_bot_text)}")
-    yield "final_response_and_insights", {"response": final_bot_text, "insights_used": parsed_initial_insights_list}
+    yield "final_response", {"response": final_bot_text}
 
-def perform_post_interaction_learning(user_input: str, bot_response: str, provider: str, model_disp_name: str, insights_reflected: list[dict], api_key_override: str = None):
+def perform_post_interaction_learning(user_input: str, bot_response: str, provider: str, model_disp_name: str, api_key_override: str = None):
     task_id = os.urandom(4).hex()
     logger.info(f"POST_INTERACTION_LEARNING [{task_id}]: START User='{user_input[:40]}...', Bot='{bot_response[:40]}...'")
     learning_start_time = time.time()
-    significant_learnings_summary = [] # To store summaries of new core learnings
+    significant_learnings_summary = []
 
     try:
         metrics = generate_interaction_metrics(user_input, bot_response, provider, model_disp_name, api_key_override)
@@ -457,13 +533,13 @@ If no operations are warranted, output an empty list: `<operations_list></operat
 ABSOLUTELY NO other text, explanations, or markdown should precede or follow this XML structure.
 Each `<operation>` element must contain the following child elements:
 1.  `<action>`: A string, either `"add"` (for entirely new rules) or `"update"` (to replace an existing rule with a better one).
-2.  `<insight>`: The full, refined insight text including its `[TYPE|SCORE]` prefix (e.g., `[CORE_RULE|1.0] My name is Lumina, an AI assistant.`). Multi-line insight text can be placed directly within this tag; XML handles newlines naturally.
+2.  `<insight>`: The full, refined insight text including its `[TYPE|SCORE]` prefix (e.g., `[CORE_RULE|1.0] My name is [Name], an AI assistant.`). Multi-line insight text can be placed directly within this tag; XML handles newlines naturally.
 3.  `<old_insight_to_replace>`: (ONLY for `"update"` action) The *exact, full text* of an existing insight that the new `<insight>` should replace. If action is `"add"`, this element should be omitted or empty.
 **XML Structure Example:**
 <operations_list>
   <operation>
     <action>update</action>
-    <insight>[CORE_RULE|1.0] I am Lumina, an AI assistant.
+    <insight>[CORE_RULE|1.0] I am [Name], an AI assistant.
 My purpose is to help with research.</insight>
     <old_insight_to_replace>[CORE_RULE|0.9] My name is Assistant.</old_insight_to_replace>
   </operation>
@@ -484,7 +560,6 @@ Provide details only when asked.</insight>
 """
         insight_user_prompt = f"""Interaction Summary:\n{summary}\n
 Potentially Relevant Existing Rules (Review these carefully. Your main goal is to consolidate CORE_RULEs and then identify other changes/additions based on the Interaction Summary and these existing rules):\n{existing_rules_ctx}\n
-Guiding principles that were considered during THIS interaction (these might offer clues for new rules or refinements):\n{json.dumps([p['original'] for p in insights_reflected if 'original' in p]) if insights_reflected else "None"}\n
 Task: Based on your three-step reflection process (Core Identity, New Learnings, Refinements):
 1.  **Consolidate CORE_RULEs:** Merge similar identity/purpose rules from "Potentially Relevant Existing Rules" into single, definitive statements using "update" operations. Replace multiple old versions with the new canonical one.
 2.  **Add New Learnings:** Identify and "add" any distinct new facts, skills, or important user preferences learned from the "Interaction Summary".
@@ -549,33 +624,24 @@ Combine all findings into a single, valid XML structure as specified in the syst
                     logger.warning(f"POST_INTERACTION_LEARNING [{task_id}]: Op {op_idx}: Skipped op due to invalid insight_text format from XML: '{insight_text[:100]}...'")
                     continue
 
-                rule_added_or_updated = False
                 if action == "add":
                     success, status_msg = add_rule_entry(insight_text)
                     if success:
                         processed_count +=1
-                        rule_added_or_updated = True
                         if insight_text.upper().startswith("[CORE_RULE"):
                             significant_learnings_summary.append(f"New Core Rule Added: {insight_text}")
                     else: logger.warning(f"POST_INTERACTION_LEARNING [{task_id}]: Op {op_idx} (add from XML): Failed to add rule '{insight_text[:50]}...'. Status: {status_msg}")
                 elif action == "update":
-                    removed_old = False
-                    if old_insight:
-                        if old_insight != insight_text:
-                            remove_success = remove_rule_entry(old_insight)
-                            if not remove_success:
-                                 logger.warning(f"POST_INTERACTION_LEARNING [{task_id}]: Op {op_idx} (update from XML): Failed to remove old rule '{old_insight[:50]}...' before adding new.")
-                            else:
-                                removed_old = True
-                        else:
-                             logger.info(f"POST_INTERACTION_LEARNING [{task_id}]: Op {op_idx} (update from XML): Old insight is identical to new insight. Skipping removal.")
+                    if old_insight and old_insight != insight_text:
+                        remove_success = remove_rule_entry(old_insight)
+                        if not remove_success:
+                             logger.warning(f"POST_INTERACTION_LEARNING [{task_id}]: Op {op_idx} (update from XML): Failed to remove old rule '{old_insight[:50]}...' before adding new.")
 
                     success, status_msg = add_rule_entry(insight_text)
                     if success:
                         processed_count +=1
-                        rule_added_or_updated = True
                         if insight_text.upper().startswith("[CORE_RULE"):
-                             significant_learnings_summary.append(f"Core Rule Updated (Old: {'Removed' if removed_old else 'Not removed/Same'}, New: {insight_text})")
+                             significant_learnings_summary.append(f"Core Rule Updated to: {insight_text}")
                     else: logger.warning(f"POST_INTERACTION_LEARNING [{task_id}]: Op {op_idx} (update from XML): Failed to add/update rule '{insight_text[:50]}...'. Status: {status_msg}")
                 else:
                     logger.warning(f"POST_INTERACTION_LEARNING [{task_id}]: Op {op_idx}: Skipped op due to unknown action '{action}' from XML.")
@@ -603,89 +669,108 @@ Combine all findings into a single, valid XML structure as specified in the syst
     logger.info(f"POST_INTERACTION_LEARNING [{task_id}]: END. Total: {time.time() - learning_start_time:.2f}s")
 
 
-def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_name: str, sel_model_disp_name: str, ui_api_key: str|None, cust_sys_prompt: str):
+def handle_gradio_chat_submit(user_msg_txt: str, max_research_steps: int, gr_hist_list: list, sel_prov_name: str, sel_model_disp_name: str, ui_api_key: str|None, cust_sys_prompt: str):
     global current_chat_session_history
     cleared_input, updated_gr_hist, status_txt = "", list(gr_hist_list), "Initializing..."
     updated_rules_text = ui_refresh_rules_display_fn()
     updated_mems_json = ui_refresh_memories_display_fn()
-    def_detect_out_md = gr.Markdown(visible=False)
-    def_fmt_out_txt = gr.Textbox(value="*Waiting...*", interactive=True, show_copy_button=True)
-    def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
-
+    plan_md_output = gr.Markdown(visible=False)
+    final_report_tb = gr.Textbox(value="*Waiting...*", interactive=True, show_copy_button=True)
+    dl_report_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
+    
     if not user_msg_txt.strip():
         status_txt = "Error: Empty message."
         updated_gr_hist.append((user_msg_txt or "(Empty)", status_txt))
-        yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn, updated_rules_text, updated_mems_json)
+        yield (cleared_input, updated_gr_hist, status_txt, plan_md_output, final_report_tb, dl_report_btn, updated_rules_text, updated_mems_json)
         return
 
     updated_gr_hist.append((user_msg_txt, "<i>Thinking...</i>"))
-    yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn, updated_rules_text, updated_mems_json)
+    yield (cleared_input, updated_gr_hist, status_txt, plan_md_output, final_report_tb, dl_report_btn, updated_rules_text, updated_mems_json)
 
-    internal_hist = list(current_chat_session_history); internal_hist.append({"role": "user", "content": user_msg_txt})
-    hist_len_check = MAX_HISTORY_TURNS * 2
-    if internal_hist and internal_hist[0]["role"] == "system": hist_len_check +=1
-    if len(internal_hist) > hist_len_check:
-         current_chat_session_history = ([internal_hist[0]] if internal_hist[0]["role"] == "system" else []) + internal_hist[-(MAX_HISTORY_TURNS * 2):]
-         internal_hist = list(current_chat_session_history)
+    internal_hist = list(current_chat_session_history)
 
-    final_bot_resp_acc, insights_used_parsed = "", []
+    final_bot_resp_acc = ""
     temp_dl_file_path = None
-
+    
     try:
-        processor_gen = process_user_interaction_gradio(user_input=user_msg_txt, provider_name=sel_prov_name, model_display_name=sel_model_disp_name, chat_history_for_prompt=internal_hist, custom_system_prompt=cust_sys_prompt.strip() or None, ui_api_key_override=ui_api_key.strip() if ui_api_key else None)
+        processor_gen = process_user_interaction_gradio(
+            user_input=user_msg_txt, 
+            max_research_steps=max_research_steps,
+            provider_name=sel_prov_name, 
+            model_display_name=sel_model_disp_name, 
+            chat_history=internal_hist,
+            custom_system_prompt=cust_sys_prompt.strip() or None, 
+            ui_api_key_override=ui_api_key.strip() if ui_api_key else None
+        )
+        
         curr_bot_disp_msg = ""
+        full_plan = []
+        step_results = {}
+
         for upd_type, upd_data in processor_gen:
             if upd_type == "status":
                 status_txt = upd_data
                 if updated_gr_hist and updated_gr_hist[-1][0] == user_msg_txt:
-                    updated_gr_hist[-1] = (user_msg_txt, f"{curr_bot_disp_msg} <i>{status_txt}</i>" if curr_bot_disp_msg else f"<i>{status_txt}</i>")
+                    updated_gr_hist[-1] = (user_msg_txt, f"<i>{status_txt}</i>")
+            elif upd_type == "plan":
+                full_plan = upd_data
+                plan_md = "### Action Plan\n" + "\n".join([f"**Step {i+1} ({step.get('tool')})**: {step.get('task')}" for i, step in enumerate(full_plan)])
+                plan_md_output = gr.Markdown(value=plan_md, visible=True)
+            elif upd_type == "step_result":
+                step_num = upd_data["step"]
+                step_results[step_num] = upd_data["result"]
+                results_so_far = "### Research Log\n"
+                for i in range(1, len(full_plan)):
+                    if i in step_results:
+                        results_so_far += f"**Step {i} ({full_plan[i-1].get('tool')})**: ✅ Completed\n"
+                    elif i <= len(step_results) + 1:
+                        results_so_far += f"**Step {i} ({full_plan[i-1].get('tool')})**: ⏳ In progress...\n"
+                    else:
+                        results_so_far += f"**Step {i} ({full_plan[i-1].get('tool')})**: - Pending\n"
+                
+                if updated_gr_hist and updated_gr_hist[-1][0] == user_msg_txt:
+                    updated_gr_hist[-1] = (user_msg_txt, results_so_far)
             elif upd_type == "response_chunk":
                 curr_bot_disp_msg += upd_data
                 if updated_gr_hist and updated_gr_hist[-1][0] == user_msg_txt:
                     updated_gr_hist[-1] = (user_msg_txt, curr_bot_disp_msg)
-            elif upd_type == "final_response_and_insights":
-                final_bot_resp_acc, insights_used_parsed = upd_data["response"], upd_data["insights_used"]
+            elif upd_type == "final_response":
+                final_bot_resp_acc = upd_data["response"]
                 status_txt = "Response generated. Processing learning..."
-                if not curr_bot_disp_msg and final_bot_resp_acc : curr_bot_disp_msg = final_bot_resp_acc
+                if not curr_bot_disp_msg and final_bot_resp_acc: curr_bot_disp_msg = final_bot_resp_acc
+                
                 if updated_gr_hist and updated_gr_hist[-1][0] == user_msg_txt:
                     updated_gr_hist[-1] = (user_msg_txt, curr_bot_disp_msg or "(No text)")
-
-                def_fmt_out_txt = gr.Textbox(value=curr_bot_disp_msg, interactive=True, show_copy_button=True)
+                final_report_tb = gr.Textbox(value=curr_bot_disp_msg, interactive=True, show_copy_button=True)
 
                 if curr_bot_disp_msg and not curr_bot_disp_msg.startswith("Error:"):
                     try:
                         with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".md", encoding='utf-8') as tmpfile:
                             tmpfile.write(curr_bot_disp_msg)
                             temp_dl_file_path = tmpfile.name
-                        def_dl_btn = gr.DownloadButton(value=temp_dl_file_path, visible=True, interactive=True)
+                        dl_report_btn = gr.DownloadButton(value=temp_dl_file_path, visible=True, interactive=True)
                     except Exception as e:
                         logger.error(f"Error creating temp file for download: {e}", exc_info=False)
-                        def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False, label="Download Error")
+                        dl_report_btn = gr.DownloadButton(interactive=False, value=None, visible=False, label="Download Error")
                 else:
-                    def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
-
-                insights_md_content = "### Insights Considered (Pre-Response):\n" + ("\n".join([f"- **[{i.get('type','N/A')}|{i.get('score','N/A')}]** {i.get('text','N/A')[:100]}..." for i in insights_used_parsed[:3]]) if insights_used_parsed else "*None specific.*")
-                def_detect_out_md = gr.Markdown(value=insights_md_content, visible=True if insights_used_parsed else False)
+                    dl_report_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
 
-            yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn, updated_rules_text, updated_mems_json)
+            yield (cleared_input, updated_gr_hist, status_txt, plan_md_output, final_report_tb, dl_report_btn, updated_rules_text, updated_mems_json)
 
-            if upd_type == "final_response_and_insights": break
+            if upd_type == "final_response": break
 
     except Exception as e:
-        logger.error(f"Chat handler error during main processing: {e}", exc_info=True); status_txt = f"Error: {str(e)[:100]}"
+        logger.error(f"Chat handler error during main processing: {e}", exc_info=True)
+        status_txt = f"Error: {str(e)[:100]}"
         error_message_for_chat = f"Sorry, an error occurred during response generation: {str(e)[:100]}"
         if updated_gr_hist and updated_gr_hist[-1][0] == user_msg_txt:
             updated_gr_hist[-1] = (user_msg_txt, error_message_for_chat)
-        else:
-            updated_gr_hist.append((user_msg_txt, error_message_for_chat))
-        def_fmt_out_txt = gr.Textbox(value=error_message_for_chat, interactive=True)
-        def_dl_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
-        def_detect_out_md = gr.Markdown(value="*Error processing request.*", visible=True)
-
+        final_report_tb = gr.Textbox(value=error_message_for_chat, interactive=True)
+        dl_report_btn = gr.DownloadButton(interactive=False, value=None, visible=False)
+        plan_md_output = gr.Markdown(value="*Error processing request.*", visible=True)
         current_rules_text_on_error = ui_refresh_rules_display_fn()
         current_mems_json_on_error = ui_refresh_memories_display_fn()
-
-        yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn, current_rules_text_on_error, current_mems_json_on_error)
+        yield (cleared_input, updated_gr_hist, status_txt, plan_md_output, final_report_tb, dl_report_btn, current_rules_text_on_error, current_mems_json_on_error)
         if temp_dl_file_path and os.path.exists(temp_dl_file_path):
             try: os.unlink(temp_dl_file_path)
             except Exception as e_unlink: logger.error(f"Error deleting temp download file {temp_dl_file_path} after error: {e_unlink}")
@@ -693,15 +778,11 @@ def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_na
 
     if final_bot_resp_acc and not final_bot_resp_acc.startswith("Error:"):
         current_chat_session_history.extend([{"role": "user", "content": user_msg_txt}, {"role": "assistant", "content": final_bot_resp_acc}])
-        hist_len_check = MAX_HISTORY_TURNS * 2
-        if current_chat_session_history and current_chat_session_history[0]["role"] == "system": hist_len_check +=1
-        if len(current_chat_session_history) > hist_len_check:
-            current_chat_session_history = ([current_chat_session_history[0]] if current_chat_session_history[0]["role"] == "system" else []) + current_chat_session_history[-(MAX_HISTORY_TURNS * 2):]
-
+        
         status_txt = "<i>[Performing post-interaction learning...]</i>"
         current_rules_text_before_learn = ui_refresh_rules_display_fn()
         current_mems_json_before_learn = ui_refresh_memories_display_fn()
-        yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn, current_rules_text_before_learn, current_mems_json_before_learn)
+        yield (cleared_input, updated_gr_hist, status_txt, plan_md_output, final_report_tb, dl_report_btn, current_rules_text_before_learn, current_mems_json_before_learn)
 
         try:
             perform_post_interaction_learning(
@@ -709,30 +790,25 @@ def handle_gradio_chat_submit(user_msg_txt: str, gr_hist_list: list, sel_prov_na
                 bot_response=final_bot_resp_acc,
                 provider=sel_prov_name,
                 model_disp_name=sel_model_disp_name,
-                insights_reflected=insights_used_parsed,
                 api_key_override=ui_api_key.strip() if ui_api_key else None
             )
             status_txt = "Response & Learning Complete."
         except Exception as e_learn:
             logger.error(f"Error during post-interaction learning: {e_learn}", exc_info=True)
             status_txt = "Response complete. Error during learning."
-
-    elif final_bot_resp_acc.startswith("Error:"):
-        status_txt = final_bot_resp_acc
     else:
-        status_txt = "Processing finished; no valid response or error occurred during main phase."
+        status_txt = "Processing finished; no valid response or error occurred."
 
     updated_rules_text = ui_refresh_rules_display_fn()
     updated_mems_json = ui_refresh_memories_display_fn()
 
-    yield (cleared_input, updated_gr_hist, status_txt, def_detect_out_md, def_fmt_out_txt, def_dl_btn, updated_rules_text, updated_mems_json)
+    yield (cleared_input, updated_gr_hist, status_txt, plan_md_output, final_report_tb, dl_report_btn, updated_rules_text, updated_mems_json)
 
     if temp_dl_file_path and os.path.exists(temp_dl_file_path):
         try: os.unlink(temp_dl_file_path)
         except Exception as e_unlink: logger.error(f"Error deleting temp download file {temp_dl_file_path}: {e_unlink}")
 
 
-# --- Startup Loading Functions ---
 def load_rules_from_file(filepath: str | None):
     if not filepath:
         logger.info("LOAD_RULES_FILE environment variable not set. Skipping rules loading from file.")
@@ -882,9 +958,7 @@ def load_memories_from_file(filepath: str | None):
     return added_count, format_error_count, save_error_count
 
 
-# --- UI Functions for Rules and Memories (Text and Image) ---
 def convert_kb_to_kv_string(rules: list[str], memories: list[dict], include_rules: bool, include_memories: bool) -> str:
-    """Serializes rules and/or memories into a single key-value string for image embedding based on user selection."""
     lines = ["# iLearn Knowledge Base Export", f"# Exported on: {datetime.utcnow().isoformat()}Z"]
     
     if include_rules:
@@ -1147,8 +1221,6 @@ def app_load_fn():
             gr.DownloadButton(interactive=False, value=None, visible=False))
 
 
-# --- Create a placeholder image for the examples ---
-# This makes the script self-contained and runnable without needing a separate file.
 placeholder_filename = "placeholder_image.png"
 try:
     if not os.path.exists(placeholder_filename):
@@ -1165,76 +1237,7 @@ except Exception as e:
     logger.error(f"Could not create placeholder image. The examples may not load correctly. Error: {e}")
 
 
-def ui_download_kb_as_image_fn(password: str, progress=gr.Progress()):
-    """
-    Generates a KB image and returns both the image object for display
-    and a file path for a download button.
-    """
-    progress(0, desc="Fetching knowledge base...")
-    rules, memories = get_all_rules_cached(), get_all_memories_cached()
-    if not rules and not memories:
-        gr.Warning("Knowledge base is empty. Nothing to create.")
-        # Return updates to hide the components if they were previously visible
-        return gr.update(value=None, visible=False), gr.update(value=None, visible=False), "Knowledge base is empty."
-
-    progress(0.2, desc="Serializing data...")
-    kv_string = convert_kb_to_kv_string(rules, memories)
-    data_bytes = kv_string.encode('utf-8')
-
-    if password and password.strip():
-        progress(0.4, desc="Encrypting data...")
-        try:
-            data_bytes = encrypt_data(data_bytes, password.strip())
-            gr.Info("Data encrypted successfully.")
-        except Exception as e:
-            logger.error(f"KB ImgDL: Encrypt failed: {e}")
-            gr.Error(f"Encryption failed: {e}")
-            return gr.update(value=None, visible=False), gr.update(value=None, visible=False), f"Error: {e}"
-
-    progress(0.6, desc="Generating carrier image...")
-    carrier_image = generate_brain_carrier_image(w=800, h=800, msg="iLearn Knowledge Base")
-
-    try:
-        progress(0.7, desc="Embedding data...")
-        embedded_image = embed_data_in_image(carrier_image, data_bytes)
-    except ValueError as e:
-        logger.error(f"KB ImgDL: Embed failed: {e}")
-        gr.Error(f"Data is too large for this image size: {e}")
-        return gr.update(value=None, visible=False), gr.update(value=None, visible=False), f"Error: {e}"
-
-    progress(0.8, desc="Adding visual overlay...")
-    keys_for_overlay = [f"Rule Count: {len(rules)}", f"Memory Count: {len(memories)}", "---"]
-    for r in rules[:5]:
-        match = re.search(r"\](.*)", r, re.DOTALL)
-        rule_content = match.group(1).strip() if match else r
-        keys_for_overlay.append(f"Rule: {rule_content[:40]}...")
-    if len(rules) > 5: keys_for_overlay.append("...")
-
-    title_overlay = "Encrypted Data" if password and password.strip() else "Embedded Data"
-    final_image = draw_key_list_dropdown_overlay(embedded_image, keys=keys_for_overlay, title=title_overlay)
-
-    progress(0.9, desc="Preparing final image and download file...")
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
-            final_image.save(tmpfile, format="PNG")
-            tmp_path = tmpfile.name
-
-        progress(1.0, desc="Image created!")
-        gr.Info("Image created and is ready for download or copy.")
-        # Return updates to show the components with the new data
-        return gr.update(value=final_image, visible=True), gr.update(value=tmp_path, visible=True), "Success! Image created."
-    except Exception as e:
-        logger.error(f"KB ImgDL: Save failed: {e}")
-        gr.Error(f"Failed to save final image: {e}")
-        return gr.update(value=None, visible=False), gr.update(value=None, visible=False), f"Error: {e}"
-
-
-
-
 def ui_create_kb_image_fn(password: str, content_to_include: list, progress=gr.Progress()):
-    """
-    Generates a KB image and returns a file path to both the display and download components.
-    """
     include_rules = "Include Rules" in content_to_include
     include_memories = "Include Memories" in content_to_include
     
@@ -1277,26 +1280,21 @@ def ui_create_kb_image_fn(password: str, content_to_include: list, progress=gr.P
     if include_rules: keys_for_overlay.append(f"Rule Count: {len(rules)}")
     if include_memories: keys_for_overlay.append(f"Memory Count: {len(memories)}")
     
-    title_overlay = "Encrypted Knowledge Base" if password and password.strip() else "iLearn Knowledge Base"
+    title_overlay = "Encrypted KB" if password and password.strip() else "iLearn KB"
     final_image = draw_key_list_dropdown_overlay(embedded_image, keys=keys_for_overlay, title=title_overlay)
 
     progress(0.9, desc="Preparing final image and download file...")
     try:
-        # Create a temporary file and save the image as a PNG.
         with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmpfile:
             final_image.save(tmpfile, format="PNG")
             tmp_path = tmpfile.name
         progress(1.0, desc="Image created!")
-        # Return the FILE PATH to both components.
         return gr.update(value=tmp_path, visible=True), gr.update(value=tmp_path, visible=True), "Success! Image created."
     except Exception as e:
         logger.error(f"KB ImgDL: Save failed: {e}")
         return gr.update(value=None, visible=False), gr.update(value=None, visible=False), f"Error: {e}"
 
 def ui_load_from_sources_fn(image_filepath: str, rules_file_obj: object, mems_file_obj: object, password: str, progress=gr.Progress()):
-    """
-    Loads data from one of the available sources with precedence: Image > Rules File > Memories File.
-    """
     if image_filepath:
         progress(0.1, desc="Image source detected. Starting image processing...")
         return ui_upload_kb_from_image_fn(image_filepath, password, progress)
@@ -1312,7 +1310,6 @@ def ui_load_from_sources_fn(image_filepath: str, rules_file_obj: object, mems_fi
     return "No file or image uploaded. Please provide a source file to load."
 
     
-# --- Gradio UI Definition ---
 with gr.Blocks(theme=gr.themes.Soft(), css=".gr-button { margin: 5px; } .gr-textbox, .gr-text-area, .gr-dropdown, .gr-json { border-radius: 8px; } .gr-group { border: 1px solid #e0e0e0; border-radius: 8px; padding: 10px; } .gr-row { gap: 10px; } .gr-tab { border-radius: 8px; } .status-text { font-size: 0.9em; color: #555; } .gr-json { max-height: 400px; overflow-y: auto; }") as demo:
 
     gr.Markdown(f"# 🤖 iLearn: An Autonomous Learning Agent {'(DEMO MODE)' if DEMO_MODE else ''}", elem_classes=["header"])
@@ -1332,6 +1329,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=".gr-button { margin: 5px; } .gr-text
             prov_sel_dd = gr.Dropdown(label="AI Provider", choices=available_providers, value=default_provider, interactive=True)
             default_model_display = get_default_model_display_name_for_provider(default_provider) if default_provider else None
             model_sel_dd = gr.Dropdown(label="AI Model", choices=get_model_display_names_for_provider(default_provider) if default_provider else [], value=default_model_display, interactive=True)
+            research_steps_slider = gr.Slider(label="Max Research Steps", minimum=1, maximum=10, step=1, value=3, interactive=True)
         with gr.Group():
             gr.Markdown("### System Prompt"); sys_prompt_tb = gr.Textbox(label="System Prompt Base", lines=8, value=DEFAULT_SYSTEM_PROMPT, interactive=True)
 
@@ -1344,13 +1342,12 @@ with gr.Blocks(theme=gr.themes.Soft(), css=".gr-button { margin: 5px; } .gr-text
                     with gr.Row(variant="compact"):
                         user_msg_tb = gr.Textbox(show_label=False, placeholder="Ask your research question...", scale=7, lines=1, max_lines=3)
                         send_btn = gr.Button("Send", variant="primary", scale=1, min_width=100)
-                    with gr.Accordion("📝 Detailed Response & Insights", open=False):
+                    with gr.Accordion("📝 Detailed Response & Plan", open=False):
+                        plan_display_md = gr.Markdown(visible=False)
                         fmt_report_tb = gr.Textbox(label="Full AI Response", lines=8, interactive=True, show_copy_button=True)
                         dl_report_btn = gr.DownloadButton("Download Report", value=None, interactive=False, visible=False)
-                        detect_out_md = gr.Markdown(visible=False)
 
         with gr.TabItem("🧠 Knowledge Base"):
-
             with gr.Tabs():
                 with gr.TabItem("🎛️ System"):
                     gr.Markdown("View and directly manage the current rules and memories in the system.")
@@ -1370,7 +1367,6 @@ with gr.Blocks(theme=gr.themes.Soft(), css=".gr-button { margin: 5px; } .gr-text
                     with gr.Row():
                         rules_stat_tb = gr.Textbox(label="Rules Status", interactive=False, lines=1, elem_classes=["status-text"])
                         mems_stat_tb = gr.Textbox(label="Memories Status", interactive=False, lines=1, elem_classes=["status-text"])
-
                     with gr.Row():
                         with gr.Column():
                             gr.Markdown("### Text File Export")
@@ -1378,15 +1374,12 @@ with gr.Blocks(theme=gr.themes.Soft(), css=".gr-button { margin: 5px; } .gr-text
                             dl_mems_btn = gr.DownloadButton("⬇️ Download Memories (.jsonl)", value=None)
                             gr.Row()
                             if MEMORY_STORAGE_BACKEND == "RAM": save_faiss_sidebar_btn = gr.Button("Save FAISS Indices", variant="secondary")
-
-
                         with gr.Column():
                             gr.Markdown("### Image Export")
                             with gr.Group():
                                 save_kb_password_tb = gr.Textbox(label="Password (optional for encryption)", type="password")
                                 save_kb_include_cbg = gr.CheckboxGroup(label="Content to Include", choices=["Include Rules", "Include Memories"], value=["Include Rules", "Include Memories"])
                                 create_kb_img_btn = gr.Button("✨ Create KB Image", variant="secondary")
-                            # Removed type="pil" to allow Gradio to handle the raw PNG bytes correctly
                             kb_image_display_output = gr.Image(label="Generated Image (Right-click to copy)", visible=False)
                             kb_image_download_output = gr.DownloadButton("⬇️ Download Image File", visible=False)
 
@@ -1394,44 +1387,35 @@ with gr.Blocks(theme=gr.themes.Soft(), css=".gr-button { margin: 5px; } .gr-text
                     gr.Markdown("Import rules, memories, or a full KB from local files or a portable PNG image.")
                     load_status_tb = gr.Textbox(label="Load Operation Status", interactive=False, lines=2)
                     load_kb_password_tb = gr.Textbox(label="Password (for decrypting images)", type="password")
-                    
                     with gr.Group():
                         gr.Markdown("#### Sources (Priority: Image > Rules File > Memories File)")
                         with gr.Row():
                              upload_kb_img_fobj = gr.Image(label="1. Image Source", type="filepath", sources=["upload", "clipboard"], interactive=not DEMO_MODE)
                              upload_rules_fobj = gr.File(label="2. Rules File Source (.txt/.jsonl)", file_types=[".txt", ".jsonl"], interactive=not DEMO_MODE)
                              upload_mems_fobj = gr.File(label="3. Memories File Source (.json/.jsonl)", file_types=[".jsonl", ".json"], interactive=not DEMO_MODE)
-                    
                     load_master_btn = gr.Button("⬆️ Load from Sources", variant="primary", interactive=not DEMO_MODE)
-                    gr.Examples( 
-
+                    gr.Examples(
                     examples=[
-                        ["./evolutions/e0.01.01.png", ""],
-                
+                        [placeholder_filename, ""],
                     ],
                     inputs=[upload_kb_img_fobj, load_kb_password_tb],
                     label="Click an Example to Load Data"
                     )
-    # --- Event Wiring ---
+
     def dyn_upd_model_dd(sel_prov_dyn: str):
         models_dyn = get_model_display_names_for_provider(sel_prov_dyn); def_model_dyn = get_default_model_display_name_for_provider(sel_prov_dyn)
         return gr.Dropdown(choices=models_dyn, value=def_model_dyn, interactive=True)
     prov_sel_dd.change(fn=dyn_upd_model_dd, inputs=prov_sel_dd, outputs=model_sel_dd)
 
-
-    
-    # Chat Tab
-    chat_ins = [user_msg_tb, main_chat_disp, prov_sel_dd, model_sel_dd, api_key_tb, sys_prompt_tb]
-    chat_outs = [user_msg_tb, main_chat_disp, agent_stat_tb, detect_out_md, fmt_report_tb, dl_report_btn, rules_disp_ta, mems_disp_json]
+    chat_ins = [user_msg_tb, research_steps_slider, main_chat_disp, prov_sel_dd, model_sel_dd, api_key_tb, sys_prompt_tb]
+    chat_outs = [user_msg_tb, main_chat_disp, agent_stat_tb, plan_display_md, fmt_report_tb, dl_report_btn, rules_disp_ta, mems_disp_json]
     chat_event_args = {"fn": handle_gradio_chat_submit, "inputs": chat_ins, "outputs": chat_outs}
     send_btn.click(**chat_event_args); user_msg_tb.submit(**chat_event_args)
 
-    # KB Tab -> System
     save_edited_rules_btn.click(fn=save_edited_rules_action_fn, inputs=[rules_disp_ta], outputs=[rules_stat_tb], show_progress="full").then(fn=ui_refresh_rules_display_fn, outputs=rules_disp_ta, show_progress=False)
     clear_rules_btn.click(fn=lambda: ("All rules cleared." if clear_all_rules_data_backend() else "Error clearing rules."), outputs=rules_stat_tb, show_progress=False).then(fn=ui_refresh_rules_display_fn, outputs=rules_disp_ta, show_progress=False)
     clear_mems_btn.click(fn=lambda: ("All memories cleared." if clear_all_memory_data_backend() else "Error clearing memories."), outputs=mems_stat_tb, show_progress=False).then(fn=ui_refresh_memories_display_fn, outputs=mems_disp_json, show_progress=False)
 
-    # KB Tab -> Save KB
     dl_rules_btn.click(fn=ui_download_rules_action_fn, inputs=None, outputs=dl_rules_btn, show_progress=False)
     dl_mems_btn.click(fn=ui_download_memories_action_fn, inputs=None, outputs=dl_mems_btn, show_progress=False)
     create_kb_img_btn.click(
@@ -1441,7 +1425,6 @@ with gr.Blocks(theme=gr.themes.Soft(), css=".gr-button { margin: 5px; } .gr-text
         show_progress="full"
     )
 
-    # KB Tab -> Load KB
     load_master_btn.click(
         fn=ui_load_from_sources_fn,
         inputs=[upload_kb_img_fobj, upload_rules_fobj, upload_mems_fobj, load_kb_password_tb],
@@ -1453,20 +1436,16 @@ with gr.Blocks(theme=gr.themes.Soft(), css=".gr-button { margin: 5px; } .gr-text
         fn=ui_refresh_memories_display_fn, outputs=mems_disp_json
     )
 
-    # Sidebar FAISS button
     if MEMORY_STORAGE_BACKEND == "RAM" and 'save_faiss_sidebar_btn' in locals():
         def save_faiss_action_with_feedback_sidebar_fn():
             try: save_faiss_indices_to_disk(); gr.Info("Attempted to save FAISS indices to disk.")
             except Exception as e: logger.error(f"Error saving FAISS indices: {e}", exc_info=True); gr.Error(f"Error saving FAISS indices: {e}")
         save_faiss_sidebar_btn.click(fn=save_faiss_action_with_feedback_sidebar_fn, inputs=None, outputs=None, show_progress=False)
 
-    # App Load
-    app_load_outputs = [agent_stat_tb, rules_disp_ta, mems_disp_json, detect_out_md, fmt_report_tb, dl_report_btn]
+    app_load_outputs = [agent_stat_tb, rules_disp_ta, mems_disp_json, plan_display_md, fmt_report_tb, dl_report_btn]
     demo.load(fn=app_load_fn, inputs=None, outputs=app_load_outputs, show_progress="full")
 
 
-
-
 if __name__ == "__main__":
     logger.info(f"Starting Gradio AI Research Mega Agent (v9.1 - Correct 1-Click JS Download, Memory: {MEMORY_STORAGE_BACKEND})...")
     app_port = int(os.getenv("GRADIO_PORT", 7860))
@@ -1474,5 +1453,5 @@ if __name__ == "__main__":
     app_debug = os.getenv("GRADIO_DEBUG", "False").lower() == "false"
     app_share = os.getenv("GRADIO_SHARE", "False").lower() == "true"
     logger.info(f"Launching Gradio server: http://{app_server}:{app_port}. Debug: {app_debug}, Share: {app_share}")
-    demo.queue().launch(server_name=app_server, server_port=app_port, debug=app_debug, share=app_share, mcp_server=True)
+    demo.queue().launch(server_name=app_server, server_port=app_port, debug=app_debug, share=app_share)
     logger.info("Gradio application shut down.")