Update app.py

app.py

@@ -123,60 +123,42 @@ def process_user_interaction_gradio(user_input: str, provider_name: str, model_d
     user_input_lower = user_input.lower()
     time_before_tool_decision = time.time()
 
-    # --- 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(1, "search_duckduckgo_and_report")
             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', ' ')
-
         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}
 
-Based on the query and the action descriptions, select the single best action to take. Output the corresponding JSON object.
+Based on the query and the action descriptions, select the single best action. Output the corresponding JSON.
 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_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:
             try:
                 logger.info(f"PUI_GRADIO [{request_id}]: Tool decision LLM: {tool_provider}/{tool_model_display}")
@@ -191,15 +173,13 @@ Example for memory recall: {{"action": "answer_using_conversation_memory", "acti
                     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. Defaulting to quick_respond. Raw: {tool_resp_raw}")
-                    action_type = "quick_respond" # Fallback
+                    action_type = "quick_respond"
             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
+                action_type = "quick_respond"
         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 ---
+            action_type = "quick_respond"
 
     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>"
@@ -208,17 +188,46 @@ Example for memory recall: {{"action": "answer_using_conversation_memory", "acti
     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=3)
+        # --- MODIFIED: Query Transformation Step ---
+        yield "status", "<i>[Optimizing query for long-term memory search...]</i>"
+        
+        # 1. Ask an LLM to generate a better search query
+        optimized_query = user_input # Fallback
+        try:
+            query_gen_system_prompt = "You are an expert at reformulating a user's question into a concise, effective search query for a vector database. Given the conversation history and the user's latest query, extract the key topics and entities to create a self-contained query. The query should be a short phrase or question. Output ONLY the query text, nothing else."
+            query_gen_user_prompt = f"Conversation History:\n{history_str_for_prompt}\n\nUser's Latest Query: \"{user_input}\"\n\nOptimized Search Query:"
+            query_gen_messages = [{"role":"system", "content":query_gen_system_prompt}, {"role":"user", "content":query_gen_user_prompt}]
+            
+            # Use the same fast model as the tool decider
+            query_gen_chunks = list(call_model_stream(provider=tool_provider, model_display_name=tool_model_display, messages=query_gen_messages, temperature=0.0, max_tokens=50))
+            generated_query = "".join(query_gen_chunks).strip()
+
+            if generated_query:
+                optimized_query = generated_query.replace('"', '') # Clean up quotes
+                logger.info(f"PUI_GRADIO [{request_id}]: Original query: '{user_input}'. Optimized memory search query: '{optimized_query}'")
+            else:
+                logger.warning(f"PUI_GRADIO [{request_id}]: Query generation returned empty. Using original input.")
+        except Exception as e:
+            logger.error(f"PUI_GRADIO [{request_id}]: Error during query generation: {e}. Using original input.")
+
+        # 2. Use the optimized query to search the unified memory
+        yield "status", f"<i>[Searching all memories with query: '{optimized_query[:40]}...']</i>"
+        retrieved_mems = retrieve_memories_semantic(optimized_query, k=3)
+        
+        # 3. Build the context for the final response
         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):"
+        # --- END OF MODIFICATION ---
+
     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: