Update app.py

app.py

@@ -118,66 +118,108 @@ def process_user_interaction_gradio(user_input: str, provider_name: str, model_d
     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"])):
+
+    # --- REFACTORED TOOL-DECISION LOGIC ---
+
+    # Heuristic for simple interactions that don't need a tool-decision LLM call
+    is_simple_interaction = 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
+    
+    if is_simple_interaction:
+        action_type = "quick_respond"
+    else:
+        # For any non-trivial interaction, use an LLM to decide the best tool.
         yield "status", "<i>[LLM choosing best approach...]</i>"
+        
+        # 1. Define all possible tools and their descriptions
+        tool_definitions = {
+            "answer_using_conversation_memory": "Use if the user's query refers to a previous conversation, asks you to 'remember' or 'recall' something specific, or seems like it could be answered by a past interaction you've had. This tool searches a database of your past conversations.",
+            "search_duckduckgo_and_report": "Use for general knowledge questions, questions about current events, or when the user explicitly asks you to search the web for information.",
+            "scrape_url_and_report": "Use ONLY when the user provides a specific URL to read from.",
+            "quick_respond": "Use as a fallback for simple greetings, acknowledgements, or if the answer is obvious from the immediate context and requires no special tools."
+        }
+        
+        # 2. Build the list of available tools for this specific run
+        available_tool_names = ["quick_respond", "answer_using_conversation_memory"]
+        if WEB_SEARCH_ENABLED:
+            available_tool_names.insert(1, "search_duckduckgo_and_report") # Give search higher priority
+            available_tool_names.insert(2, "scrape_url_and_report")
+
+        # 3. Create the prompt with the dynamic list of tools and their descriptions
+        tool_descriptions_for_prompt = "\n".join(f'- "{name}": {tool_definitions[name]}' for name in available_tool_names)
+        
+        tool_sys_prompt = "You are a precise routing agent. Your job is to analyze the user's query and the conversation context, then select the single best action to provide an answer. Output ONLY a single, valid JSON object with 'action' and 'action_input' keys. Do not add any other text or explanations."
         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', ' ')
-        
-        # --- MODIFIED: Improved prompts for the tool-decision LLM ---
-        tool_sys_prompt = """You are a precise routing agent. Your job is to analyze the user's query and the conversation context, then select the single best action to provide an answer.
-Output ONLY a single, valid JSON object with "action" and "action_input" keys. Do not add any other text or explanations.
 
-Example: {"action": "search_duckduckgo_and_report", "action_input": {"search_engine_query": "latest AI research"}}
+        tool_user_prompt = f"""User Query: "{user_input}"
+
+Recent History:
+{history_snippet}
+
+Guidelines Snippet (for context):
+{guideline_snippet}
+
+Available Actions and their descriptions:
+{tool_descriptions_for_prompt}
 
-Here are the available actions with descriptions of when to use them:
-- "quick_respond": Use for simple greetings, acknowledgements, or if the answer is obvious from the immediate context and requires no special tools.
-- "answer_using_conversation_memory": Use if the user's query refers to a previous conversation, asks you to "remember" or "recall" something, or seems like it could be answered by a past interaction you've had. This tool searches a database of your past conversations for relevant information.
-- "search_duckduckgo_and_report": Use for general knowledge questions, questions about current events, or when the user explicitly asks you to search the web for information.
-- "scrape_url_and_report": Use ONLY when the user provides a specific URL to read from.
+Based on the query and the action descriptions, select the single best action to take. Output the corresponding JSON object.
+Example for web search: {{"action": "search_duckduckgo_and_report", "action_input": {{"search_engine_query": "latest AI research"}}}}
+Example for memory recall: {{"action": "answer_using_conversation_memory", "action_input": {{}}}}
 """
-        tool_user_prompt = f"User Query: \"{user_input}\"\n\nRecent History:\n{history_snippet}\n\nGuidelines Snippet (for context):\n{guideline_snippet}...\n\nBased on the query and the action descriptions provided in the system prompt, select the single best action to take. Output the corresponding JSON object."
+        
         tool_decision_messages = [{"role":"system", "content": tool_sys_prompt}, {"role":"user", "content": tool_user_prompt}]
-        # --- END OF MODIFICATION ---
         
         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:
             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_chunks = list(call_model_stream(provider=tool_provider, model_display_name=tool_model_display, messages=tool_decision_messages, temperature=0.0, max_tokens=200))
                 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", {})
+                    action_type = action_data.get("action", "quick_respond")
+                    action_input_dict = 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"
+                else:
+                    logger.warning(f"PUI_GRADIO [{request_id}]: Tool decision LLM non-JSON. Defaulting to quick_respond. Raw: {tool_resp_raw}")
+                    action_type = "quick_respond" # Fallback
+            except Exception as e:
+                logger.error(f"PUI_GRADIO [{request_id}]: Tool decision LLM error. Defaulting to quick_respond: {e}", exc_info=False)
+                action_type = "quick_respond" # Fallback
+        else:
+            logger.error(f"No model for tool decision provider {tool_provider}. Defaulting to quick_respond.")
+            action_type = "quick_respond" # Fallback
+            
+    # --- END OF REFACTORED LOGIC ---
+
     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"]:
+        retrieved_mems = retrieve_memories_semantic(f"User query: {user_input}\nContext:\n{history_str_for_prompt[-1000:]}", k=3)
+        if retrieved_mems:
+            logger.info(f"PUI_GRADIO [{request_id}]: Found {len(retrieved_mems)} relevant memories.")
+            memory_context = "Relevant Past Interactions (for your context only, do not repeat verbatim):\n" + "\n".join([f"- User asked: '{m.get('user_input','')}'. You responded: '{m.get('bot_response','')}'. (Key takeaway: {m.get('metrics',{}).get('takeaway','N/A')})" for m in retrieved_mems])
+        else:
+            logger.info(f"PUI_GRADIO [{request_id}]: No relevant memories found for the query.")
+            memory_context = "No relevant past interactions were found in the memory database."
+        final_system_prompt_str += " You MUST use the provided 'Memory Context' to inform your answer. Synthesize the information from the memory with the current conversation history to respond to the user's query."
+        final_user_prompt_content_str = f"History:\n{history_str_for_prompt}\n\nGuidelines:\n{initial_insights_ctx_str}\n\nMemory Context:\n{memory_context}\n\nUser's Query: \"{user_input}\"\n\nResponse (use the Memory Context to answer the query):"
+    elif 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)."
@@ -195,9 +237,10 @@ Here are the available actions with descriptions of when to use them:
             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:
+    else: # Fallback for unknown action
         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]}...")
@@ -212,6 +255,7 @@ Here are the available actions with descriptions of when to use them:
     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}
 
+# The rest of the app.py file remains the same...
 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):
     task_id = os.urandom(4).hex()
     logger.info(f"POST_INTERACTION_LEARNING [{task_id}]: START User='{user_input[:40]}...', Bot='{bot_response[:40]}...'")