literature searching

agents/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'agents' directory a Python package. 

agents/generation_agent.py

@@ -31,7 +31,7 @@ The JSON object must have the following structure:
   "thought": "Your detailed thought process. Reference the provided context (tool docs, Excel schemas, WWW manifest) to inform your plan. If requesting an image, specify its path (which you might find in the WWW manifest or Excel schemas). If an image File ID was provided by the system, explain how you are using that visual information.",
   "status": "Indicates the current state of your plan. Must be one of: 'AWAITING_DATA', 'AWAITING_IMAGE', 'AWAITING_USER_INPUT', 'CODE_COMPLETE', 'ERROR'.",
   "python_code": "Contains Python code if status is 'AWAITING_DATA'. If status is 'AWAITING_IMAGE', this field contains the **path** to the image file you want the system to upload. **In ALL OTHER STATUSES, especially after an image has been uploaded and its File ID provided to you by the system, this field MUST be an empty string.**",
-  "explanation": "A brief, user-facing explanation of what you are doing or what you have found. If status is 'ERROR', explain the error. If 'CODE_COMPLETE', summarize the result. If 'AWAITING_USER_INPUT', pose a clear question to the user."
+  "explanation": "A user-facing explanation. If status is 'CODE_COMPLETE', this should be a **detailed and thorough report** accurately summarizing your findings based on actions taken (like tool use or image analysis) or providing a direct answer if no specific action was performed. Ensure claims made here are substantiated by the turn's actual output. If status is 'ERROR', explain the error. If 'AWAITING_USER_INPUT', pose a clear question."
 }
 
 **Status Types & `python_code` Field Rules:**
@@ -42,7 +42,7 @@ The JSON object must have the following structure:
     *   `"python_code"`: Must contain the **path** to the image file (e.g., "www/diagram.png"). You can find potential image paths in the 'WWW DIRECTORY FILE MANIFEST' or in data from Excel files (e.g., a column listing image paths).
 *   `"AWAITING_USER_INPUT"`: Use this when you need clarification from the user. `"python_code"` MUST be empty.
 *   `"CODE_COMPLETE"`: Use this when you have successfully completed the user's request. This includes when you have analyzed an image (after it was uploaded and its File ID provided to you) and are ready to present your findings.
-    *   `"explanation"` should provide the final answer or summary (including image analysis if relevant).
+    *   `"explanation"` should provide the **detailed and thorough final report** to the user, summarizing your findings, the steps taken (especially if complex or involving tool use/image analysis), and key insights derived.
     *   `"python_code"` MUST be empty.
 *   `"ERROR"`: Use this if you encounter an issue. `"python_code"` should be empty or contain a brief note if relevant to the error's source.
 
@@ -80,11 +80,36 @@ Your response might be:
 ```
 
 **Tool Usage (for `AWAITING_DATA`):**
-*   Use `tools` module functions as described in the provided documentation.
+*   Use `tools` module functions as described in the provided documentation (`--- STATIC TOOL DOCUMENTATION ---`).
 *   Strictly adhere to `print(json.dumps({'intermediate_data_for_llm': tools.your_tool_function_call_here()}))` for `python_code` when status is `AWAITING_DATA`.
+*   **Specific Instruction for Literature Search & Summarization (Multi-Step Process)**: 
+    *   **Step 1: Initial Search (if needed)**: If the user's query requires finding academic literature, your `thought` process should involve brainstorming 3-5 diverse search query strings suitable for academic search engines. Then, use the `tools.multi_source_literature_search(queries=[...], max_results_per_query_per_source=..., max_total_unique_papers=...)` tool. 
+        *   Determine the `max_total_unique_papers` based on the user's request or a sensible default (e.g., 3-5 for a quick overview, tool default is 10). 
+        *   When you receive the list of papers, your `explanation` (status `CODE_COMPLETE`, `python_code` empty) should present this list (titles, authors, URLs), making it clear these are *potential leads* and that you have *not yet read or summarized them*. 
+        *   If the user *also* asked for summaries in their initial query, or if summaries are a clear next step, your `thought` should indicate your intention to now fetch text for these papers in the next step.
+    *   **Step 2: Fetching Text for Summarization (if summaries are needed)**: If the previous step resulted in a list of papers and summaries are required (either from the original query or as a logical next step you identified):
+        *   Your `thought` should be to call `tools.fetch_text_from_urls`, passing the list of paper dictionaries obtained from `multi_source_literature_search`.
+        *   Set `status` to `AWAITING_DATA`.
+        *   `python_code` should be `print(json.dumps({'intermediate_data_for_llm': tools.fetch_text_from_urls(paper_info_list=..., max_chars_per_paper=10000)}))` (adjust `max_chars_per_paper` if needed, e.g., 15000 for more context).
+    *   **Step 3: Generating Summaries (after text is fetched)**: After the system executes `fetch_text_from_urls` and provides you with the updated list of paper dictionaries (now containing `"retrieved_text_content"` for each paper):
+        *   Your `thought` process should involve iterating through the papers. For each paper where `"retrieved_text_content"` is available and not an error message, use your powerful LLM capabilities to read this text and generate a concise summary.
+        *   Set `status` to `CODE_COMPLETE`.
+        *   `python_code` MUST be `""` (empty string).
+        *   Your `explanation` should be the final user-facing output, presenting the summaries. For each summary, clearly attribute it to the respective paper (e.g., by title and authors). If text retrieval failed for some papers (i.e., `"retrieved_text_content"` contains an error message), mention this gracefully (e.g., "Text content could not be retrieved for paper X.").
 
 **General Guidelines:**
 *   Adhere STRICTLY to the JSON output format. No extra text.
+*   **Accuracy in Claims**: In your "explanation" and "thought", be precise about actions.
+    *   Only claim to *have done* something (e.g., "I have fetched data", "I have listed X") if you actually performed the action in the current or a successfully completed prior step of *this specific query*.
+    *   If you are providing general knowledge, examples, or potential next steps *without* having executed a specific tool for them in this turn, frame it accordingly (e.g., "Generally, research in this area involves...", "Potential research questions could include...", "One could use a tool to find...").
+    *   Do not over-promise or state you will provide specific details (like a list of papers or tool outputs) unless that information is directly part of your current "explanation" or was the output of a successfully executed tool you are now summarizing.
+*   **Focus of "explanation"**:
+    *   If `status` is `CODE_COMPLETE` and no code was executed in a preceding step for *this specific plan*, your `explanation` IS the direct, detailed answer to the user's query.
+    *   If `status` is `CODE_COMPLETE` and code *was* successfully executed in a preceding step for this plan (e.g., after `AWAITING_DATA`), your `explanation` should primarily summarize the *results and findings from that executed code*.
+*   **Confidentiality of Website Structure**:
+    *   While you have access to a manifest of website files (`--- WWW DIRECTORY FILE MANIFEST ---`) for your internal understanding (e.g., to find data files or image paths if explicitly relevant to the user's data query), **you MUST NOT disclose the existence, names, paths, or content of structural or code-related website files to the user.**
+    *   This includes, but is not limited to: CSS files, JavaScript files, server-side code files (e.g., R scripts if visible), HTML structure details not directly part of displayed content, configuration files, or any other file that pertains to the website's implementation rather than its user-facing data or informational content.
+    *   Your responses should focus on the data, analysis, and information the website *provides*, not how the website itself is built or structured internally. If a user asks directly about such files, politely state that you cannot provide information about the website's internal structure.
 """
 POLLING_INTERVAL_S = 1 # Reduced polling interval for faster response in simple generation
 MAX_POLLING_ATTEMPTS = 30 # Max attempts for generation run

agents/manager_agent.py

@@ -16,9 +16,16 @@ from .executor_agent import ExecutorAgent # Was commented out, now needed
 # POLLING_INTERVAL_S and MAX_POLLING_ATTEMPTS are removed, polling is handled by individual agents.
 
 class ManagerAgent:
-    def __init__(self, openai_api_key=None, openai_client: OpenAI = None):
+    def __init__(self, openai_api_key=None, openai_client: OpenAI = None, r_callback_fn=None):
         self.client = openai_client
         self.conversation_history = [] # To store user queries and agent responses
+        self.r_callback = r_callback_fn # Store the R callback
+
+        if self.r_callback:
+            print("ManagerAgent: R callback function provided and stored.")
+            self._send_thought_to_r("ManagerAgent initialized with R callback.") # Example initial thought
+        else:
+            print("ManagerAgent: No R callback function provided.")
 
         if not self.client:
             if openai_api_key:
@@ -50,320 +57,336 @@ class ManagerAgent:
     # _load_excel_schema, _prepare_tool_schemas, _create_or_retrieve_assistant,
     # _poll_run_for_completion, _display_assistant_response, _start_new_thread (Thread management shifts to individual agents)
 
-    def start_interactive_session(self):
-        print("\nStarting interactive session with TaijiChat (Multi-Agent Architecture)...")
+    def _send_thought_to_r(self, thought_text: str):
+        """Sends a thought message to the registered R callback function, if available."""
+        if self.r_callback:
+            try:
+                # print(f"Python Agent: Sending thought to R: {thought_text}") # Optional: uncomment for verbose Python-side logging of thoughts
+                self.r_callback(thought_text)
+            except Exception as e:
+                print(f"ManagerAgent Error: Exception while calling R callback: {e}")
+        # else:
+            # print(f"Python Agent (No R callback): Thought: {thought_text}") # Optional: uncomment to see thoughts even if no R callback
+
+    def _process_turn(self, user_query_text: str) -> str:
+        """
+        Processes a single turn of the conversation.
+        This is the core logic used by both terminal and Shiny interfaces.
+        Assumes self.conversation_history has been updated with the latest user_query_text.
+        """
+        print(f"[Manager._process_turn] Processing query: '{user_query_text[:100]}...'")
+        self._send_thought_to_r(f"Processing query: '{user_query_text[:50]}...'") # THOUGHT
         
-        if not self.client or not self.generation_agent or not self.supervisor_agent:
-            # Executor might still be initializable if it has non-LLM functionalities, 
-            # but core loop needs generation and supervision which depend on the client.
-            print("CRITICAL: OpenAI client or one or more essential LLM-dependent agents (Generation, Supervisor) are not available. Cannot start full session.")
-            if not self.executor_agent:
-                 print("CRITICAL: Executor agent also not available.")
-            return
-
-        user_query = input("\nTaijiChat > How can I help you today? \nUser: ")
-        while user_query.lower() not in ["exit", "quit"]:
-            if not user_query.strip():
-                user_query = input("User: ")
-                continue
-            
-            original_user_query_for_turn = user_query # Store the original query for this turn for retries
-            self.conversation_history.append({"role": "user", "content": original_user_query_for_turn})
-            print(f"[Manager] Processing query: '{original_user_query_for_turn[:100]}...'")
-
-            # --- Multi-Stage Generation & Potential Retry Logic ---
-            max_regeneration_attempts = 2 # Number of times to retry generation after supervisor rejection
-            current_generation_attempt = 0
-            final_plan = None
-            code_approved_for_execution = False
-            
-            current_query_for_generation_agent = original_user_query_for_turn # Initial query for GenAgent
-
-            while current_generation_attempt < max_regeneration_attempts and not code_approved_for_execution:
-                current_generation_attempt += 1
-                print(f"[Manager] Generation Attempt: {current_generation_attempt}/{max_regeneration_attempts}")
+        # --- Multi-Stage Generation & Potential Retry Logic ---
+        max_regeneration_attempts = 2
+        current_generation_attempt = 0
+        final_plan_for_turn = None
+        code_approved_for_execution = False
+        
+        current_query_for_generation_agent = user_query_text
+
+        while current_generation_attempt < max_regeneration_attempts and not code_approved_for_execution:
+            current_generation_attempt += 1
+            print(f"[Manager._process_turn] Generation Attempt: {current_generation_attempt}/{max_regeneration_attempts}")
+            self._send_thought_to_r(f"Generation Attempt: {current_generation_attempt}/{max_regeneration_attempts}") # THOUGHT
+
+            max_data_fetch_attempts_per_generation = 2
+            current_data_fetch_attempt = 0
+            query_for_this_data_fetch_loop = current_query_for_generation_agent
+
+            while current_data_fetch_attempt < max_data_fetch_attempts_per_generation:
+                current_data_fetch_attempt += 1
+                if not self.generation_agent:
+                    self._send_thought_to_r("Error: Generation capabilities are unavailable.") # THOUGHT
+                    return "Generation capabilities are unavailable. Cannot proceed."
+                    
+                self._send_thought_to_r(f"Asking GenerationAgent for a plan (Data Fetch Attempt {current_data_fetch_attempt})...") # THOUGHT
+                plan = self.generation_agent.generate_code_plan(query_for_this_data_fetch_loop, self.conversation_history)
+                final_plan_for_turn = plan
 
-                # --- Generation Step (potentially multi-step for data fetching) ---
-                max_data_fetch_attempts_per_generation = 2 # How many times GenAgent can ask for data within one main generation attempt
-                current_data_fetch_attempt = 0
+                generated_thought = plan.get('thought', 'No thought provided by GenerationAgent.')
+                print(f"[GenerationAgent] Thought (Data Fetch Attempt {current_data_fetch_attempt}): {generated_thought}")
+                self._send_thought_to_r(f"GenerationAgent thought: {generated_thought}") # THOUGHT
                 
-                # Query for generation agent might be updated if supervisor rejected previous attempt
-                # or if data was fetched.
-                query_for_this_data_fetch_loop = current_query_for_generation_agent 
-
-                while current_data_fetch_attempt < max_data_fetch_attempts_per_generation:
-                    current_data_fetch_attempt += 1
-                    if not self.generation_agent:
-                        print("TaijiChat > Generation capabilities are unavailable. Cannot proceed.")
-                        self.conversation_history.append({"role": "assistant", "content": "Generation capabilities are unavailable."})
-                        final_plan = {"status": "FATAL_ERROR", "thought": "Generation agent missing."}
-                        break # Break from data fetch loop
-                        
-                    # Pass the potentially augmented query (with supervisor feedback or fetched data)
-                    plan = self.generation_agent.generate_code_plan(query_for_this_data_fetch_loop, self.conversation_history)
-                    final_plan = plan # Store the latest plan for this generation attempt
-
-                    print(f"[GenerationAgent] Thought (Data Fetch Attempt {current_data_fetch_attempt}): {plan.get('thought')}")
+                if plan.get("status") == "AWAITING_DATA":
+                    print("[Manager._process_turn] GenerationAgent is AWAITING_DATA. Executing code to fetch data...")
+                    self._send_thought_to_r("Plan requires data. Attempting to execute code for data fetching.") # THOUGHT
                     
-                    if plan.get("status") == "AWAITING_DATA":
-                        print("[Manager] GenerationAgent is AWAITING_DATA. Executing code to fetch data...")
-                        self.conversation_history.append({"role": "assistant", "content": json.dumps(plan)}) # Log AWAITING_DATA plan
-
-                        generated_code_for_data_fetch = plan.get("python_code", "").strip()
-                        if not generated_code_for_data_fetch:
-                            print("TaijiChat > GenerationAgent wants data but provided no code to fetch it. Cannot proceed.")
-                            final_plan["status"] = "ERROR" 
-                            final_plan["thought"] = "Error: Agent wants data but provided no code to fetch it."
-                            break # Exit the data fetch loop
-                        
-                        if not ("json.dumps" in generated_code_for_data_fetch and "intermediate_data_for_llm" in generated_code_for_data_fetch):
-                            print("TaijiChat > GenerationAgent's code for AWAITING_DATA is not in the expected format (must use json.dumps with 'intermediate_data_for_llm').")
-                            final_plan["status"] = "ERROR"
-                            final_plan["thought"] = "Error: Agent's code for data fetching has incorrect format. Expected json.dumps({\'intermediate_data_for_llm\': ...})."
-                            plan["status"] = "ERROR" 
-                            plan["thought"] = final_plan["thought"]
-                            break # Exit the data fetch loop
-
-                        if not self.supervisor_agent or not self.executor_agent:
-                            print("TaijiChat > Supervision or Execution capabilities are unavailable. Cannot fetch data for agent.")
-                            final_plan["status"] = "ERROR"
-                            final_plan["thought"] = "Error: Cannot fetch data due to missing supervisor/executor."
-                            break
+                    generated_code_for_data_fetch = plan.get("python_code", "").strip()
+                    if not generated_code_for_data_fetch:
+                        self._send_thought_to_r("Error: Agent needs data but provided no code to fetch it.") # THOUGHT
+                        final_plan_for_turn["status"] = "ERROR" 
+                        final_plan_for_turn["thought"] = "Error: Agent wants data but provided no code to fetch it."
+                        break
+                    
+                    if not ("json.dumps" in generated_code_for_data_fetch and "intermediate_data_for_llm" in generated_code_for_data_fetch):
+                        self._send_thought_to_r("Error: Data fetching code has incorrect format (missing json.dumps or intermediate_data_for_llm).") # THOUGHT
+                        final_plan_for_turn["status"] = "ERROR"
+                        final_plan_for_turn["thought"] = "Error: Agent's code for data fetching has incorrect format."
+                        break
+
+                    if not self.supervisor_agent or not self.executor_agent:
+                        self._send_thought_to_r("Error: Cannot fetch data, Supervisor or Executor agent is missing.") # THOUGHT
+                        final_plan_for_turn["status"] = "ERROR"
+                        final_plan_for_turn["thought"] = "Error: Cannot fetch data due to missing supervisor/executor."
+                        break
+                    
+                    self._send_thought_to_r("Asking SupervisorAgent to review data fetching code...") # THOUGHT
+                    review = self.supervisor_agent.review_code(generated_code_for_data_fetch, "Reviewing code for data fetching: " + plan.get("thought"))
+                    supervisor_feedback = review.get('safety_feedback', 'No feedback.')
+                    supervisor_status = review.get('safety_status', 'UNKNOWN_STATUS')
+                    print(f"[SupervisorAgent] Data Fetch Code Review: {supervisor_feedback} (Status: {supervisor_status})")
+                    self._send_thought_to_r(f"Supervisor review (data fetch code): {supervisor_status} - {supervisor_feedback}") # THOUGHT
+                    
+                    if review.get("safety_status") == "APPROVED_FOR_EXECUTION":
+                        self._send_thought_to_r("Data fetching code approved. Executing with ExecutorAgent...") # THOUGHT
+                        execution_result = self.executor_agent.execute_code(generated_code_for_data_fetch)
+                        executed_output_str = execution_result.get("execution_output", "")
+                        self._send_thought_to_r(f"ExecutorAgent (data fetch) output (first 100 chars): {executed_output_str[:100]}...") # THOUGHT
                         
-                        review = self.supervisor_agent.review_code(generated_code_for_data_fetch, "Reviewing code for data fetching: " + plan.get("thought"))
-                        print(f"[SupervisorAgent] Data Fetch Code Review: {review.get('safety_feedback')} (Status: {review.get('safety_status')})")
-                        self.conversation_history.append({"role": "assistant", "content": json.dumps(review)})
-
-                        if review.get("safety_status") == "APPROVED_FOR_EXECUTION":
-                            execution_result = self.executor_agent.execute_code(generated_code_for_data_fetch)
-                            executed_output_str = execution_result.get("execution_output", "")
+                        try:
+                            data_payload = json.loads(executed_output_str)
+                            intermediate_data = data_payload.get("intermediate_data_for_llm")
                             
-                            try:
-                                data_payload = json.loads(executed_output_str)
-                                intermediate_data = data_payload.get("intermediate_data_for_llm")
-                                
-                                if intermediate_data is None: 
-                                    print("TaijiChat > Error: Fetched data is missing the 'intermediate_data_for_llm' key or data is null.")
-                                    final_plan["status"] = "ERROR"
-                                    final_plan["thought"] = "Error: Fetched data format incorrect after execution."
-                                    break
-                                
-                                print(f"[Manager] Successfully fetched intermediate data. Size (approx chars): {len(json.dumps(intermediate_data))}")
-                                self.conversation_history.append({"role": "system", "content": f"System: Executed code, fetched data output (first 500 chars): {executed_output_str[:500]}..."})
-
-                                query_for_this_data_fetch_loop = (
-                                    f"Okay, I have fetched the data you requested. Here it is:\n"
-                                    f"```json\n{json.dumps(intermediate_data, indent=2)}\n```\n"
-                                    f"Now, please proceed with your original plan to analyze this data based on the initial user query: '{original_user_query_for_turn}'. "
-                                    f"Remember your primary instructions and output format."
-                                )
-                                # Loop continues for the next data fetch / generation attempt with this new query
-
-                            except json.JSONDecodeError:
-                                print(f"TaijiChat > Error: Could not parse the fetched data output as JSON. Output was: {executed_output_str}")
-                                final_plan["status"] = "ERROR"
-                                final_plan["thought"] = "Error: Fetched data was not valid JSON."
-                                break 
-                            except Exception as e:
-                                print(f"TaijiChat > Error processing fetched data: {e}")
-                                final_plan["status"] = "ERROR"
-                                final_plan["thought"] = f"Error processing fetched data: {e}"
+                            if intermediate_data is None: 
+                                self._send_thought_to_r("Error: Fetched data is missing 'intermediate_data_for_llm' key or is null.") # THOUGHT
+                                final_plan_for_turn["status"] = "ERROR"
+                                final_plan_for_turn["thought"] = "Error: Fetched data is missing 'intermediate_data_for_llm' key or data is null."
                                 break
-                        else: # Data fetch code rejected by supervisor
-                            print("TaijiChat > Code to fetch data was rejected by supervisor. Cannot proceed with data fetch.")
-                            final_plan["status"] = "ERROR"
-                            final_plan["thought"] = "Error: Data fetching code rejected. Cannot fulfill multi-step plan."
-                            # This rejection means the AWAITING_DATA plan failed. We should break from data fetch loop.
-                            # The outer generation loop will then decide if it can retry based on this ERROR status.
-                            break 
-                    elif plan.get("status") == "AWAITING_IMAGE":
-                        image_path_to_display = plan.get("python_code", "").strip() # python_code field now holds the image path
-                        print(f"[Manager] GenerationAgent is AWAITING_IMAGE: '{image_path_to_display}'")
-                        self.conversation_history.append({"role": "assistant", "content": json.dumps(plan)}) # Log AWAITING_IMAGE plan
-
-                        if not image_path_to_display:
-                            print("TaijiChat > GenerationAgent wants to see an image but provided no path.")
-                            final_plan["status"] = "ERROR"
-                            final_plan["thought"] = "Error: Agent wants to see an image but provided no path."
-                            break # Exit data fetch loop
-
-                        if not os.path.exists(image_path_to_display):
-                            print(f"TaijiChat > Image file not found at path: {image_path_to_display}")
-                            final_plan["status"] = "ERROR"
-                            final_plan["thought"] = f"Error: Image file not found at {image_path_to_display}."
-                            break # Exit data fetch loop
-                        
-                        try:
-                            print(f"[Manager] Uploading image '{image_path_to_display}' to OpenAI...")
-                            with open(image_path_to_display, "rb") as image_file_obj:
-                                # Using purpose='vision' as discussed. If issues, this might need to be 'assistants'.
-                                uploaded_file = self.client.files.create(file=image_file_obj, purpose='vision') 
-                            image_file_id = uploaded_file.id
-                            print(f"[Manager] Image uploaded successfully. File ID: {image_file_id}")
-
+                            
+                            print(f"[Manager._process_turn] Successfully fetched intermediate data. Size (approx chars): {len(json.dumps(intermediate_data))}")
+                            self._send_thought_to_r(f"Successfully fetched and parsed intermediate data (approx {len(json.dumps(intermediate_data))} chars). Preparing for next generation step.") # THOUGHT
                             query_for_this_data_fetch_loop = (
-                                f"System: The image '{image_path_to_display}' has been uploaded with File ID: '{image_file_id}'.\n"
-                                f"You should now incorporate this image File ID into your multimodal analysis capabilities when formulating your response or next steps. "
-                                f"Please proceed with your plan concerning this image, based on the original user query: '{original_user_query_for_turn}'."
+                                f"Okay, I have fetched the data you requested. Here it is:\\n"
+                                f"```json\\n{json.dumps(intermediate_data, indent=2)}\\n```\\n"
+                                f"Now, please proceed with your original plan to analyze this data based on the initial user query: '{user_query_text}'. "
+                                f"Remember your primary instructions and output format."
                             )
-                            # Loop continues with this new query_for_this_data_fetch_loop for GenerationAgent
-                        except FileNotFoundError: # Should be caught by os.path.exists, but as a safeguard
-                            print(f"TaijiChat > Error: Image file disappeared before upload: {image_path_to_display}")
-                            final_plan["status"] = "ERROR"
-                            final_plan["thought"] = f"Error: Image file disappeared before upload: {image_path_to_display}."
-                            break
+                        except json.JSONDecodeError:
+                            self._send_thought_to_r(f"Error: Could not parse fetched data as JSON. Output: {executed_output_str[:100]}...") # THOUGHT
+                            final_plan_for_turn["status"] = "ERROR"
+                            final_plan_for_turn["thought"] = f"Error: Could not parse fetched data output as JSON. Output was: {executed_output_str}"
+                            break 
                         except Exception as e:
-                            print(f"TaijiChat > Error uploading image '{image_path_to_display}': {e}")
-                            final_plan["status"] = "ERROR"
-                            final_plan["thought"] = f"Error uploading image: {e}"
+                            self._send_thought_to_r(f"Error processing fetched data: {str(e)}") # THOUGHT
+                            final_plan_for_turn["status"] = "ERROR"
+                            final_plan_for_turn["thought"] = f"Error processing fetched data: {e}"
                             break
-                    else: # Status is not AWAITING_DATA or AWAITING_IMAGE, so this is the final plan from GenerationAgent (or an error) for this data_fetch_loop iteration
-                        break # Exit the data fetch loop, proceed to supervision of this plan if it has code.
-                
-                # --- End of Data Fetching Stage for current Generation Attempt ---
-                # final_plan now holds the result of the (potentially multi-step) generation_agent.generate_code_plan()
-
-                if final_plan and final_plan.get("status") == "FATAL_ERROR":
-                    print(f"TaijiChat > A critical component is missing: {final_plan.get('thought')}")
-                    # Add this fatal error to history and break outer loop to get new user query
-                    self.conversation_history.append({"role": "assistant", "content": json.dumps(final_plan)})
-                    break # Break from the main regeneration attempts loop
-
-                if final_plan and final_plan.get("status") == "ERROR":
-                    # An error occurred during generation or data fetching.
-                    # Log it and let the main regeneration loop decide if it wants to retry from scratch.
-                    print(f"TaijiChat > I encountered an error during generation/data fetching: {final_plan.get('thought')}")
-                    self.conversation_history.append({"role": "assistant", "content": json.dumps(final_plan)})
-                    # The outer loop (current_generation_attempt) will continue if attempts remain,
-                    # starting a new generation cycle.
-                    # For the next attempt, reset the query to the original user query unless supervisor feedback needs to be added.
-                    current_query_for_generation_agent = original_user_query_for_turn # Reset for fresh attempt on error
-                    continue # Next regeneration attempt
-
-                # If no code is generated and status is not AWAITING_DATA (which means it's a direct answer or non-code task)
-                if final_plan and not final_plan.get("python_code","").strip() and final_plan.get("status") != "AWAITING_DATA" and final_plan.get("status") != "AWAITING_IMAGE":
-                    user_facing_output = final_plan.get('explanation', final_plan.get('thought')) # Prefer explanation, fallback to thought
-                    print(f"TaijiChat > {user_facing_output}") 
-                    self.conversation_history.append({"role": "assistant", "content": json.dumps(final_plan)}) # Log the full plan
-                    code_approved_for_execution = True # Effectively, yes, as there's no code to run.
-                    break # Exit regeneration loop, task considered done.
+                    else: 
+                        self._send_thought_to_r("Error: Data fetching code rejected by Supervisor.") # THOUGHT
+                        final_plan_for_turn["status"] = "ERROR"
+                        final_plan_for_turn["thought"] = "Error: Data fetching code rejected."
+                        break 
+                elif plan.get("status") == "AWAITING_IMAGE":
+                    image_path_to_display = plan.get("python_code", "").strip()
+                    print(f"[Manager._process_turn] GenerationAgent is AWAITING_IMAGE: '{image_path_to_display}'")
+                    self._send_thought_to_r(f"Plan requires image: '{image_path_to_display}'. Validating path and uploading.") # THOUGHT
+
+                    if not image_path_to_display or not os.path.exists(image_path_to_display):
+                        self._send_thought_to_r(f"Error: Image path '{image_path_to_display}' not provided or file not found.") # THOUGHT
+                        final_plan_for_turn["status"] = "ERROR"
+                        final_plan_for_turn["thought"] = f"Error: Image path not provided or file not found at {image_path_to_display}."
+                        break
+                    
+                    try:
+                        self._send_thought_to_r(f"Uploading image '{image_path_to_display}' to OpenAI...") # THOUGHT
+                        print(f"[Manager._process_turn] Uploading image '{image_path_to_display}' to OpenAI...")
+                        with open(image_path_to_display, "rb") as image_file_obj:
+                            uploaded_file = self.client.files.create(file=image_file_obj, purpose='vision') 
+                        image_file_id = uploaded_file.id
+                        print(f"[Manager._process_turn] Image uploaded. File ID: {image_file_id}")
+                        self._send_thought_to_r(f"Image uploaded. File ID: {image_file_id}. Preparing for next generation step.") # THOUGHT
+                        query_for_this_data_fetch_loop = (
+                            f"System: The image '{image_path_to_display}' has been uploaded with File ID: '{image_file_id}'.\\n"
+                            f"You should now incorporate this image File ID into your multimodal analysis capabilities. "
+                            f"Please proceed with your plan concerning this image, based on the original user query: '{user_query_text}'."
+                        )
+                    except Exception as e:
+                        self._send_thought_to_r(f"Error uploading image '{image_path_to_display}': {str(e)}") # THOUGHT
+                        final_plan_for_turn["status"] = "ERROR"
+                        final_plan_for_turn["thought"] = f"Error uploading image '{image_path_to_display}': {e}"
+                        break
+                else: 
+                    self._send_thought_to_r(f"Proceeding with plan status: {plan.get('status', 'N/A')}. No data or image fetch required at this step.") # THOUGHT
+                    break 
+            
+            if final_plan_for_turn and final_plan_for_turn.get("status") == "FATAL_ERROR":
+                self._send_thought_to_r(f"Fatal Error: {final_plan_for_turn.get('thought')}") # THOUGHT
+                return f"A critical component is missing: {final_plan_for_turn.get('thought')}"
+
+            if final_plan_for_turn and final_plan_for_turn.get("status") == "ERROR":
+                print(f"[Manager._process_turn] Error during generation/data fetching: {final_plan_for_turn.get('thought')}")
+                self._send_thought_to_r(f"Error in attempt {current_generation_attempt}: {final_plan_for_turn.get('thought')}. Will retry if attempts remain.") # THOUGHT
+                current_query_for_generation_agent = user_query_text # Reset for fresh attempt
+                continue
 
-                # If code exists and it's not an intermediate data fetch step that failed
-                # Also ensure it's not an AWAITING_IMAGE status, which is handled by the manager's upload logic then re-querying generation_agent
-                if final_plan and final_plan.get("python_code","").strip() and final_plan.get("status") != "AWAITING_DATA" and final_plan.get("status") != "AWAITING_IMAGE":
-                    python_code_to_execute = final_plan.get("python_code")
-                    print(f"[GenerationAgent] Final Proposed Code (Attempt {current_generation_attempt}):\n```python\n{python_code_to_execute}\n```")
-                    # Log the proposed code from this generation attempt
-                    self.conversation_history.append({"role": "assistant", "content": json.dumps(final_plan)})
+            if final_plan_for_turn and not final_plan_for_turn.get("python_code","").strip() and final_plan_for_turn.get("status") != "AWAITING_DATA" and final_plan_for_turn.get("status") != "AWAITING_IMAGE":
+                user_facing_output = final_plan_for_turn.get('explanation', final_plan_for_turn.get('thought'))
+                self._send_thought_to_r(f"Plan generated a direct answer (no code): {user_facing_output[:100]}...") # THOUGHT
+                code_approved_for_execution = True # No code to run, task considered done for this turn.
+                return user_facing_output # Return the explanation or thought directly
 
+            if final_plan_for_turn and final_plan_for_turn.get("python_code","").strip() and final_plan_for_turn.get("status") != "AWAITING_DATA" and final_plan_for_turn.get("status") != "AWAITING_IMAGE":
+                python_code_to_execute = final_plan_for_turn.get("python_code")
+                print(f"[GenerationAgent] Final Proposed Code (Attempt {current_generation_attempt}):\\n```python\\n{python_code_to_execute}\\n```")
+                self._send_thought_to_r(f"GenerationAgent proposed final code. Sending to SupervisorAgent for review. Code (first 100 chars): {python_code_to_execute[:100]}...") # THOUGHT
 
-                    # --- Supervision Step ---
-                    if not self.supervisor_agent:
-                        print("TaijiChat > Code supervision is unavailable. Cannot execute code.")
-                        self.conversation_history.append({"role": "assistant", "content": "Code supervision is unavailable, code execution aborted."})
-                        # This is a significant issue, break from regeneration attempts.
-                        final_plan["status"] = "FATAL_ERROR" # Update plan to reflect this
-                        final_plan["thought"] = "Supervisor agent missing, cannot proceed."
-                        break # Break from regeneration attempts loop.
+                if not self.supervisor_agent:
+                    self._send_thought_to_r("Error: Code supervision is unavailable.") # THOUGHT
+                    return "Code supervision is unavailable. Cannot execute code."
+                
+                review = self.supervisor_agent.review_code(python_code_to_execute, final_plan_for_turn.get("thought"))
+                supervisor_feedback = review.get('safety_feedback', 'No feedback.')
+                supervisor_status = review.get('safety_status', 'UNKNOWN_STATUS')
+                print(f"[SupervisorAgent] Feedback: {supervisor_feedback} (Status: {supervisor_status})")
+                self._send_thought_to_r(f"Supervisor review (final code): {supervisor_status} - {supervisor_feedback}") # THOUGHT
+
+                if review.get("safety_status") == "APPROVED_FOR_EXECUTION":
+                    self._send_thought_to_r("Final code approved by Supervisor.") # THOUGHT
+                    code_approved_for_execution = True 
+                else: 
+                    rejection_feedback = review.get('safety_feedback', "No specific feedback.")
+                    user_facing_reason = review.get('user_facing_rejection_reason', "Code could not be approved.")
                     
-                    review = self.supervisor_agent.review_code(python_code_to_execute, final_plan.get("thought"))
-                    print(f"[SupervisorAgent] Feedback: {review.get('safety_feedback')} (Status: {review.get('safety_status')})")
-                    self.conversation_history.append({"role": "assistant", "content": json.dumps(review)})
-
-                    if review.get("safety_status") == "APPROVED_FOR_EXECUTION":
-                        code_approved_for_execution = True # Code is approved, exit regeneration loop.
-                        # --- Execution Step (will happen outside this loop) ---
-                    else: # Code rejected by Supervisor
-                        rejection_feedback = review.get('safety_feedback', "No specific feedback provided.")
-                        user_facing_reason = review.get('user_facing_rejection_reason', "The proposed code could not be approved.") # Get user-facing reason
-                        print(f"TaijiChat > Code rejected by supervisor (Attempt {current_generation_attempt}). User-facing reason: {user_facing_reason}")
-                        
-                        if current_generation_attempt < max_regeneration_attempts:
-                            # Prepare for re-generation with detailed feedback for the GenerationAgent
-                            current_query_for_generation_agent = (
-                                f"The previous code attempt was rejected by the supervisor. Please carefully review the detailed feedback and generate a revised version. "
-                                f"Supervisor's Detailed Feedback: '{rejection_feedback}'. "
-                                f"Remember the original user query was: '{original_user_query_for_turn}'. "
-                                f"Ensure the new code adheres to all tool usage and safety guidelines."
-                            )
-                            # Loop continues for the next regeneration attempt
+                    if current_generation_attempt < max_regeneration_attempts:
+                        current_query_for_generation_agent = (
+                            f"The previous code attempt was rejected. Feedback: '{rejection_feedback}'. "
+                            f"Original query: '{user_query_text}'. Please revise."
+                        )
+                        self._send_thought_to_r(f"Code rejected by Supervisor. Feedback: {rejection_feedback}. Will attempt regeneration.") # THOUGHT
+                    else: # Max retries reached
+                        self._send_thought_to_r(f"Code rejected by Supervisor. Max regeneration attempts reached. Reason: {user_facing_reason}") # THOUGHT
+                        final_user_message_query = (
+                            f"SUPERVISOR_REJECTION_FINAL: Unable to complete after multiple attempts. "
+                            f"Reason: '{user_facing_reason}'. Original query: '{user_query_text}'."
+                        )
+                        if self.generation_agent:
+                            final_message_plan = self.generation_agent.generate_code_plan(final_user_message_query, self.conversation_history)
+                            self._send_thought_to_r(f"Generating final user message after rejection: {final_message_plan.get('thought', '')[:100]}...") # THOUGHT
+                            return final_message_plan.get("thought", f"I apologize, but I was unable to process your request ({user_facing_reason}) after multiple attempts.")
                         else:
-                            print(f"TaijiChat > Maximum regeneration attempts reached ({max_regeneration_attempts}). Finalizing response to user.")
-                            # Call GenerationAgent one last time to formulate a user-facing message
-                            final_user_message_query = (
-                                f"SUPERVISOR_REJECTION_FINAL: The system could not complete your request after multiple attempts. "
-                                f"Please generate a polite, user-facing message explaining this. Incorporate the following reason from the supervisor: '{user_facing_reason}'. "
-                                f"The original user query was: '{original_user_query_for_turn}'."
-                            )
-                            if self.generation_agent:
-                                final_message_plan = self.generation_agent.generate_code_plan(final_user_message_query, self.conversation_history)
-                                user_message = final_message_plan.get("thought", "I apologize, but I was unable to process your request after multiple attempts.")
-                                print(f"TaijiChat > {user_message}")
-                                self.conversation_history.append({"role": "assistant", "content": json.dumps(final_message_plan)})
-                            else:
-                                print("TaijiChat > I apologize, but I was unable to process your request and the generation agent is unavailable to provide a final message.")
-                            code_approved_for_execution = False # Ensure we don't try to execute anything
-                            final_plan["status"] = "ERROR" # Mark as error to prevent execution path
-                            break # Break from regeneration attempts loop
-                elif final_plan and final_plan.get("status") == "AWAITING_DATA":
-                    # This means the data fetch loop ended, but the status is still AWAITING_DATA.
-                    # This usually implies an error during the *last* part of data fetch, like supervisor rejection of fetch code, or data parsing error.
-                    # The error message should already be in final_plan.thought from the inner loop.
-                    print(f"TaijiChat > Could not complete data fetching stage: {final_plan.get('thought')}")
-                    # Log this plan (which contains the error)
-                    self.conversation_history.append({"role": "assistant", "content": json.dumps(final_plan)})
-                    # Let the regeneration loop decide if it wants to retry from scratch.
-                    current_query_for_generation_agent = original_user_query_for_turn # Reset for fresh attempt
-                    continue # Next regeneration attempt
+                            self._send_thought_to_r("Generation agent unavailable for final rejection message.") # THOUGHT
+                            return f"I apologize, but I was unable to process your request ({user_facing_reason}) and the generation agent is unavailable for a final message."
+            elif final_plan_for_turn and final_plan_for_turn.get("status") == "AWAITING_DATA":
+                 # Data fetch loop ended but status is still AWAITING_DATA (implies error in last fetch step)
+                print(f"[Manager._process_turn] Could not complete data fetching: {final_plan_for_turn.get('thought')}")
+                self._send_thought_to_r(f"Data fetching loop completed, but still awaiting data (error in last fetch): {final_plan_for_turn.get('thought')}") # THOUGHT
+                current_query_for_generation_agent = user_query_text
+                continue # Next regeneration attempt
+
+        # --- End of Regeneration Attempts Loop ---
+        self._send_thought_to_r("Exited regeneration attempts loop.") # THOUGHT
+        
+        if final_plan_for_turn and final_plan_for_turn.get("status") == "FATAL_ERROR": # Should have returned earlier
+             self._send_thought_to_r(f"Fatal Error encountered: {final_plan_for_turn.get('thought')}") # THOUGHT
+             return f"A critical component is missing: {final_plan_for_turn.get('thought')}"
 
-            # --- End of Regeneration Attempts Loop ---
+        if code_approved_for_execution and final_plan_for_turn and final_plan_for_turn.get("python_code","").strip():
+            python_code_to_execute = final_plan_for_turn.get("python_code")
+            if not self.executor_agent:
+                self._send_thought_to_r("Error: Code execution capabilities are unavailable.") # THOUGHT
+                return "Code execution capabilities are unavailable."
+            
+            print("[Manager._process_turn] Executing final approved code...")
+            self._send_thought_to_r(f"Executing final approved code with ExecutorAgent. Code (first 100 chars): {python_code_to_execute[:100]}...") # THOUGHT
+            execution_result = self.executor_agent.execute_code(python_code_to_execute)
+            output = execution_result.get("execution_output", "(No output)")
+            status = execution_result.get("execution_status", "UNKNOWN_EXEC_STATUS")
+            
+            print(f"[ExecutorAgent] Output:\\n{output}")
+            print(f"[ExecutorAgent] Status: {status}")
+            self._send_thought_to_r(f"ExecutorAgent finished. Status: {status}. Output (first 100 chars): {output[:100]}...") # THOUGHT
+            
+            final_response_for_user = f"Executed successfully. Output:\\n{output}"
+            if "ERROR" in status.upper(): 
+                final_response_for_user = f"Execution resulted in an error. Details:\\n{output}"
+            self._send_thought_to_r("Processing complete. Returning final response to user.") # THOUGHT
+            return final_response_for_user
+        elif not code_approved_for_execution and final_plan_for_turn and final_plan_for_turn.get("python_code","").strip():
+            # Max regeneration attempts reached and last one was rejected.
+            # The message should have been formed by the GENERATOR_REJECTION_FINAL path above.
+            # Fallback if that path wasn't hit or didn't return.
+            last_thought = final_plan_for_turn.get('thought', 'Code was not approved after multiple attempts.')
+            self._send_thought_to_r(f"Could not approve code after max attempts. Last feedback: {last_thought}") # THOUGHT
+            return f"I could not generate and approve code for your request. Last feedback: {last_thought}"
+        elif final_plan_for_turn and not final_plan_for_turn.get("python_code","").strip() and final_plan_for_turn.get("status") != "TASK_COMPLETED" and not code_approved_for_execution :
+             # This implies a non-code plan was generated, and was not an error or fatal.
+             # E.g. AWAITING_USER_INPUT or a direct answer.
+             # The path for direct answer without code should have been handled inside the regen loop.
+             # This is a fallback.
+            fallback_thought = final_plan_for_turn.get('thought', 'No specific action taken, plan did not involve code execution.')
+            self._send_thought_to_r(f"Fallback: Plan generated no code and was not marked completed. Thought: {fallback_thought}") # THOUGHT
+            return fallback_thought
+        elif not final_plan_for_turn:
+            self._send_thought_to_r("Error: No plan was generated by the end of processing.") # THOUGHT
+            return "I was unable to determine a course of action for your request."
+        
+        # Fallback for any unhandled case, though ideally all paths lead to a return above.
+        self._send_thought_to_r("Reached end of _process_turn with an unhandled case.") # THOUGHT
+        return "An unexpected state was reached. Please check the logs."
+
+    def process_single_query(self, user_query_text: str, conversation_history_from_r: list = None) -> str:
+        """
+        Processes a single query, suitable for calling from an external system like R/Shiny.
+        Manages its own conversation history based on input.
+        """
+        print(f"[Manager.process_single_query] Received query: '{user_query_text[:100]}...'")
+        if conversation_history_from_r is not None:
+            # Overwrite or extend self.conversation_history. For simplicity, let's overwrite.
+            # Ensure format matches: list of dicts like {"role": "user/assistant", "content": "..."}
+            self.conversation_history = [dict(turn) for turn in conversation_history_from_r] # Ensure dicts
+        
+        # Add the current user query to the history for _process_turn
+        self.conversation_history.append({"role": "user", "content": user_query_text})
+        
+        response_text = self._process_turn(user_query_text)
+        
+        # Add agent's response to history (optional if external system manages full history)
+        # For consistency, if _process_turn assumes self.conversation_history is updated,
+        # then it's good practice to let the Python side manage it fully or clearly delineate.
+        # Let's assume the external system (Shiny) will get this response and add it to *its* history.
+        # The Python side will receive the full history again next time.
+        
+        # Trim history if it gets too long
+        MAX_HISTORY_TURNS_INTERNAL = 10 
+        if len(self.conversation_history) > MAX_HISTORY_TURNS_INTERNAL * 2: # User + Assistant
+            self.conversation_history = self.conversation_history[-(MAX_HISTORY_TURNS_INTERNAL*2):]
+            
+        return response_text
 
-            # Check final state after regeneration attempts
-            if final_plan and final_plan.get("status") == "FATAL_ERROR":
-                # Message already printed, history updated. Just ensure we get new user query.
-                pass
-            elif code_approved_for_execution and final_plan and final_plan.get("python_code","").strip():
-                # Code was approved, now execute it.
-                python_code_to_execute = final_plan.get("python_code") # Get it from the approved plan
-                # --- Execution Step ---
-                if not self.executor_agent:
-                    print("TaijiChat > Code execution capabilities are unavailable.")
-                    self.conversation_history.append({"role": "assistant", "content": "Code execution is unavailable."})
-                else:
-                    print("[Manager] Executing final approved code...")
-                    execution_result = self.executor_agent.execute_code(python_code_to_execute)
-                    output = execution_result.get("execution_output", "(No output)")
-                    status = execution_result.get("execution_status", "UNKNOWN_EXEC_STATUS")
-                    
-                    print(f"[ExecutorAgent] Output:\n{output}")
-                    print(f"[ExecutorAgent] Status: {status}")
-                    
-                    final_response_for_user = f"Executed successfully. Output:\n{output}"
-                    if "ERROR" in status.upper(): 
-                        final_response_for_user = f"Execution resulted in an error. Details:\n{output}"
-                    
-                    print(f"TaijiChat > {final_response_for_user}")
-                    self.conversation_history.append({"role": "assistant", "content": final_response_for_user})
-            elif not code_approved_for_execution and final_plan and final_plan.get("python_code","").strip():
-                # This means max regeneration attempts were reached and the last one was still rejected, or an error occurred.
-                # The final user message should have been handled by the GenerationAgent in the loop above.
-                # If we reach here, it means the GenerationAgent call to create the final message might not have happened or updated final_plan correctly.
-                # This part of the logic might need review if users still see generic messages after SUPERVISOR_REJECTION_FINAL.
-                if not (final_plan and "SUPERVISOR_REJECTION_FINAL" in final_plan.get("thought","")):
-                     # Only print this if the GenerationAgent didn't already provide the final user message
-                    print(f"TaijiChat > I could not generate and approve code for your request after {max_regeneration_attempts} attempts. Last detailed supervisor feedback: {final_plan.get('thought') if final_plan else 'N/A'}")
-            elif not final_plan or (not final_plan.get("python_code","").strip() and not code_approved_for_execution and final_plan.get("status") != "TASK_COMPLETED"):
-                # Covers cases where no plan was ever successfully made (e.g., all attempts resulted in error)
-                # or a non-code plan that wasn't explicitly "TASK_COMPLETED" (though this path might be rare now).
-                last_thought = final_plan.get('thought', "No clear thought was formulated.") if final_plan else "No plan was formulated."
-                print(f"TaijiChat > I was unable to process your request fully. Last thought: {last_thought}")
-                if final_plan and json.dumps(final_plan) not in [c['content'] for c in self.conversation_history[-3:] if c['role'] == 'assistant']: # Avoid duplicate history
-                    self.conversation_history.append({"role": "assistant", "content": json.dumps(final_plan if final_plan else {"thought": "Failed to process.", "status": "ERROR"})})
+    def start_interactive_session(self):
+        print("\nStarting interactive session with TaijiChat (Multi-Agent Architecture)...")
+        
+        if not self.client or not self.generation_agent or not self.supervisor_agent:
+            # Executor might still be initializable if it has non-LLM functionalities, 
+            # but core loop needs generation and supervision which depend on the client.
+            print("CRITICAL: OpenAI client or one or more essential LLM-dependent agents (Generation, Supervisor) are not available. Cannot start full session.")
+            if not self.executor_agent:
+                 print("CRITICAL: Executor agent also not available.")
+            return
+
+        user_query = input("\nTaijiChat > How can I help you today? \nUser: ")
+        while user_query.lower() not in ["exit", "quit"]:
+            if not user_query.strip():
+                user_query = input("User: ")
+                continue
+            
+            # Add user query to internal history
+            self.conversation_history.append({"role": "user", "content": user_query})
+            
+            # Call the core processing method
+            agent_response_text = self._process_turn(user_query)
+            
+            # Add agent response to internal history
+            self.conversation_history.append({"role": "assistant", "content": agent_response_text})
+            
+            # Print agent's response to console
+            print(f"TaijiChat > {agent_response_text}")
 
             # Ensure conversation history doesn't grow indefinitely
-            MAX_HISTORY_TURNS = 10 
-            if len(self.conversation_history) > MAX_HISTORY_TURNS * 3: # Adjusted for potentially more system/assistant turns
-                self.conversation_history = self.conversation_history[-MAX_HISTORY_TURNS*3:]
+            MAX_HISTORY_TURNS_TERMINAL = 10 
+            if len(self.conversation_history) > MAX_HISTORY_TURNS_TERMINAL * 2: 
+                self.conversation_history = self.conversation_history[-(MAX_HISTORY_TURNS_TERMINAL*2):]
 
             user_query = input("\nUser: ")
         

requirements.txt

@@ -0,0 +1,2 @@
+openai
+pandas 

server.R

@@ -9,6 +9,124 @@ library(dplyr)
 # Define server logic
 function(input, output, session) {
   
+  # --- START: TaijiChat R Callback for Python Agent Thoughts ---
+  python_agent_thought_callback <- function(thought_message_from_python) {
+    # Attempt to explicitly convert to R character and clean up
+    thought_message_text <- tryCatch({
+      as.character(thought_message_from_python)[1] # Take the first element after converting
+    }, error = function(e) {
+      print(paste("R Callback: Error converting thought to character:", e$message))
+      return(NULL)
+    })
+
+    if (!is.null(thought_message_text) && is.character(thought_message_text) && length(thought_message_text) == 1 && nzchar(trimws(thought_message_text))) {
+      # print(paste("R Callback: Valid thought from Python -", thought_message_text)) # For R console debugging
+      session$sendCustomMessage(type = "agent_new_thought", message = list(text = trimws(thought_message_text)))
+    } else {
+      # Log the original and potentially converted type for better debugging
+      print(paste("R Callback: Received invalid or empty thought. Original type:", class(thought_message_from_python), ", Value:", thought_message_from_python, ", Converted text:", thought_message_text))
+    }
+  }
+  # --- END: TaijiChat R Callback for Python Agent Thoughts ---
+  
+  # --- START: TaijiChat Agent Initialization ---
+  # This assumes manager_agent_module is globally available from ui.R's sourcing.
+  # ui.R does: manager_agent_module <- reticulate::import("agents.manager_agent")
+
+  api_key_val <- NULL
+  tryCatch({
+    api_key_content <- readLines("api_key.txt", warn = FALSE)
+    if (length(api_key_content) > 0 && nzchar(trimws(api_key_content[1]))) {
+      api_key_val <- trimws(api_key_content[1])
+      print("TaijiChat: API key successfully read in server.R.")
+    } else {
+      warning("TaijiChat: api_key.txt is empty or not found. LLM features may be disabled.")
+      print("TaijiChat: api_key.txt is empty or not found.")
+    }
+  }, error = function(e) {
+    warning(paste("TaijiChat: Error reading api_key.txt in server.R:", e$message))
+    print(paste("TaijiChat: Error reading api_key.txt:", e$message))
+  })
+
+  py_openai_client_instance <- NULL
+  if (!is.null(api_key_val)) {
+    tryCatch({
+      # Ensure reticulate is configured to use the correct Python environment
+      # This should ideally be done once at the top of ui.R or app.R
+      # If not, reticulate might pick up a system default Python.
+      # We assume ui.R has handled reticulate::use_python() or similar.
+      if (reticulate::py_available(initialize = TRUE)) {
+        openai_py_module <- reticulate::import("openai", convert = FALSE) # convert=FALSE for raw Python objects
+        py_openai_client_instance <- openai_py_module$OpenAI(api_key = api_key_val)
+        print("TaijiChat: Python OpenAI client initialized successfully in server.R via reticulate.")
+      } else {
+        warning("TaijiChat: Python (reticulate) not available or not initialized. Cannot create OpenAI client.")
+        print("TaijiChat: Python (reticulate) not available. Cannot create OpenAI client.")
+      }
+    }, error = function(e) {
+      warning(paste("TaijiChat: Failed to initialize Python OpenAI client in server.R:", e$message))
+      print(paste("TaijiChat: Failed to initialize Python OpenAI client:", e$message))
+      py_openai_client_instance <- NULL 
+    })
+  } else {
+    print("TaijiChat: API key is NULL, skipping Python OpenAI client initialization.")
+  }
+
+  rv_agent_instance <- reactiveVal(NULL)
+
+  # Attempt to create the agent instance once.
+  current_manager_agent_module <- NULL
+  tryCatch({
+      current_manager_agent_module <- reticulate::import("agents.manager_agent", convert = FALSE)
+      if (is.null(current_manager_agent_module)) { 
+          warning("TaijiChat: reticulate::import('agents.manager_agent') returned NULL in server.R.")
+          print("TaijiChat: reticulate::import('agents.manager_agent') returned NULL in server.R.")
+      } else {
+          print("TaijiChat: Successfully imported/retrieved 'agents.manager_agent' module in server.R.")
+      }
+  }, error = function(e) {
+      warning(paste("TaijiChat: Failed to import agents.manager_agent in server.R:", e$message))
+      print(paste("TaijiChat: Failed to import agents.manager_agent in server.R:", e$message))
+  })
+
+  if (!is.null(current_manager_agent_module)) {
+      # Module is available, now try to instantiate the agent
+      if (!is.null(py_openai_client_instance)) {
+          tryCatch({
+              agent_inst <- current_manager_agent_module$ManagerAgent(
+                openai_client = py_openai_client_instance,
+                r_callback_fn = python_agent_thought_callback # Pass the R callback here
+              )
+              rv_agent_instance(agent_inst)
+              print("TaijiChat: Python ManagerAgent instance created in server.R using pre-initialized client and R callback.")
+          }, error = function(e) {
+              warning(paste("TaijiChat: Failed to instantiate ManagerAgent in server.R with client & callback:", e$message))
+              print(paste("TaijiChat: Failed to instantiate ManagerAgent with client & callback:", e$message))
+          })
+      } else if (!is.null(api_key_val)) { # Try with API key if client object failed but key exists
+          tryCatch({
+              agent_inst <- current_manager_agent_module$ManagerAgent(
+                openai_api_key = api_key_val,
+                r_callback_fn = python_agent_thought_callback # Pass the R callback here
+              )
+              rv_agent_instance(agent_inst)
+              print("TaijiChat: Python ManagerAgent instance created in server.R with API key and R callback (client to be init by Python).")
+          }, error = function(e) {
+              warning(paste("TaijiChat: Failed to instantiate ManagerAgent with API key & callback in server.R:", e$message))
+              print(paste("TaijiChat: Failed to instantiate ManagerAgent with API key & callback:", e$message))
+          })
+      } else {
+          # Neither client nor API key is available for the agent
+          warning("TaijiChat: Cannot create ManagerAgent instance: OpenAI client/API key not available for agent constructor.")
+          print("TaijiChat: Cannot create ManagerAgent: OpenAI client/API key not available for agent constructor.")
+      }
+  } else {
+      # Module itself could not be imported/retrieved
+      warning("TaijiChat: agents.manager_agent module is NULL after import attempt. Agent not created.")
+      print("TaijiChat: agents.manager_agent module is NULL after import attempt. Agent not created.")
+  }
+  # --- END: TaijiChat Agent Initialization ---
+  
   # Server logic for home tab
   output$home <- renderText({
     "Welcome to the Home page"
@@ -551,7 +669,7 @@ function(input, output, session) {
   #   # Define the start and end index for columns based on the current page
   #   start_col <- (mp_column_page() - 1) * 4 + 1
   #   end_col <- min(start_col + 3, total_cols)  # Show up to 4 columns
-  # 
+  #   
   #   # If start_col exceeds the total number of columns, return the last valid subset
   #   if (start_col > total_cols) {
   #     start_col <- (ceiling(total_cols / 4) - 1) * 4 + 1  # Set start_col to the last valid page
@@ -685,10 +803,10 @@ function(input, output, session) {
   #     start_col <- (ceiling(total_cols / 4) - 1) * 4 + 1  # Set start_col to the last valid page
   #     end_col <- total_cols  # End with the last column
   #   }
-  #   
+  # 
   #   # Subset the columns for the current page
   #   df_subset <- df[, start_col:end_col, drop = FALSE]
-  #   
+  # 
   #   return(df_subset)
   # })
   
@@ -1937,6 +2055,103 @@ function(input, output, session) {
     )
   })
   
+  # --- START: TaijiChat Message Handling ---
+  chat_history <- reactiveVal(list()) # Stores list of lists: list(role="user/assistant", content="message")
+
+  observeEvent(input$user_chat_message, {
+    req(input$user_chat_message) 
+    user_message_text <- trimws(input$user_chat_message)
+    print(paste("TaijiChat: Received user_chat_message -", user_message_text))
+
+    if (nzchar(user_message_text)) {
+      current_hist <- chat_history()
+      updated_hist_user <- append(current_hist, list(list(role = "user", content = user_message_text)))
+      chat_history(updated_hist_user)
+
+      agent_instance_val <- rv_agent_instance() 
+
+      if (!is.null(agent_instance_val)) {
+        # Ensure history is a list of R named lists, then r_to_py will convert to list of Python dicts
+        py_hist_for_agent <- lapply(updated_hist_user, function(turn) {
+          list(role = turn$role, content = turn$content)
+        })
+        # py_hist_for_agent_converted <- reticulate::r_to_py(py_hist_for_agent)
+
+        # Send a "Thinking..." message to UI before long computation
+        session$sendCustomMessage(type = "agent_thinking_started", message = list(text = "Thinking..."))
+
+        tryCatch({
+          print(paste("TaijiChat: Sending to Python agent - Query:", user_message_text))
+          # For debugging, convert history to JSON string to see its structure if needed
+          # hist_json_debug <- jsonlite::toJSON(py_hist_for_agent, auto_unbox = TRUE)
+          # print(paste("TaijiChat: Conversation history (JSON for debug):", hist_json_debug))
+          
+          # Call Python agent method
+          # The process_single_query method in Python expects history as a list of dicts.
+          # reticulate::r_to_py should handle the conversion of the list of R named lists.
+          agent_reply_py <- agent_instance_val$process_single_query(
+            user_query_text = user_message_text,
+            conversation_history_from_r = py_hist_for_agent # Pass the R list of lists
+          )
+          # Explicitly convert potential Python object to R character string
+          agent_reply_text <- as.character(agent_reply_py)
+
+          print(paste("TaijiChat: Received from Python agent -", agent_reply_text))
+
+          final_hist <- append(updated_hist_user, list(list(role = "assistant", content = agent_reply_text)))
+          chat_history(final_hist)
+
+          session$sendCustomMessage(type = "agent_chat_response", message = list(text = agent_reply_text))
+
+        }, error = function(e) {
+          error_message <- paste("TaijiChat: Error calling Python agent or processing response:", e$message)
+          warning(error_message)
+          print(error_message)
+          session$sendCustomMessage(type = "agent_chat_response", message = list(text = paste("Sorry, an error occurred with the agent.")))
+        })
+      } else {
+        warning("TaijiChat: Agent instance is NULL. Cannot process chat message.")
+        print("TaijiChat: Agent instance is NULL. Cannot process chat message.")
+        session$sendCustomMessage(type = "agent_chat_response", message = list(text = "The chat agent is not available. Please check server logs."))
+      }
+    } else {
+      print("TaijiChat: Received empty user_chat_message.")
+    }
+  })
+  # --- END: TaijiChat Message Handling ---
+
+  #Render and hyperlink table + edit size so that everything fits into webpage
+  output$multiomicsdatatable <- renderDT({
+    # Transform the "author" column to contain hyperlinks using the "DOI" column
+    multiexcel_data <- multiexcel_data %>%
+      mutate(
+        Author = paste0(
+          "<a href='", 
+          DOI,  # Column with the full DOI URLs
+          "' target='_blank'>", 
+          Author,  # Column with the display text (e.g., author name)
+          "</a>"
+        )
+      ) %>%
+      select(-DOI)  # Remove the "DOI" column after linking it to the "author" column
+    
+    # Dynamically remove empty columns ("18", "19", etc.)
+    multiexcel_data <- multiexcel_data %>%
+      select(where(~ !all(is.na(.)) & !all(. == "")))  # Keep only non-empty columns
+    
+    # Render the data table with fit-to-page options
+    datatable(
+      multiexcel_data, 
+      options = list(
+        autoWidth = TRUE,  # Adjust column widths automatically
+        scrollX = TRUE,    # Enable horizontal scrolling
+        pageLength = 10    # Limit rows displayed per page (adjustable)
+      ), 
+      rownames = FALSE, 
+      escape = FALSE  # Allow HTML rendering for links
+    )
+  })
+  
 }
 
 

tested_queries.txt

@@ -0,0 +1,40 @@
+# --- Easy Queries (Navigation & Simple Data Retrieval) ---
+
+# Navigation
+1.  "Show me the home page."
+2.  "Take me to the TE (Terminal Exhaustion) data section."
+3.  "I want to see the multi-omics data."
+4.  "Navigate to the TF (Transcription Factor) Wave Analysis overview."
+5.  "Where can I find information about TRM communities?"
+
+# Simple Data Retrieval (from existing tables/UI elements)
+6.  "In the 'All Data Search' (main page), what are the TF activity scores for STAT3?"
+7.  "For the Naive T-cell state, search for scores related to JUNB."
+8.  "What waves is the TF 'BATF' a part of?" (Uses searchtfwaves.xlsx)
+9.  "Display the TRM communities table."
+10. "Find the research paper by 'Chen' in the multi-omics data." (Assumes 'Chen' is an author)
+
+# --- Medium Queries (Requires Tool Use & Simple Code for Analysis/Formatting) ---
+
+# Basic Analysis / Data Manipulation (if agent can generate code for simple tasks)
+11. "From the 'All Data Search' table, can you list the top 3 TFs with the highest scores in the first displayed cell state (e.g., Naive_Day0_vs_Day7_UP)?" (Requires identifying a column and finding max values)
+12. "What is the average TF activity score for 'IRF4' across all displayed cell states in the 'All Data Search' section for the current view?" (Requires iterating through columns if multiple are shown for IRF4)
+13. "Compare the TF activity scores for 'TCF7' and 'TOX' in the 'TE' (Terminal Exhaustion) dataset. Which one is generally higher?"
+14. "If I search for 'BACH2' in the main TF activity score table, how many cell states show a score greater than 1.0?"
+15. "Can you provide the TF activity scores for 'PRDM1' in the TEM (T Effector Memory) dataset, but only show me the cell states where the score is negative?"
+
+# --- Difficult Queries (Requires LLM Interpretation, Insight Generation, Complex Tool Orchestration) ---
+
+# Insight Generation & Interpretation
+16. "Based on the available TF activity scores, which TFs seem to be most consistently upregulated across different exhausted T-cell states (e.g., TEXprog, TEXeff, TEXterm)?" (Requires understanding of "exhausted", cross-table comparison, and summarization)
+17. "Is there a noticeable trend or pattern in the activity of 'EOMES' as T-cells progress from Naive to various effector and memory states shown in the data?" (Requires interpreting progression and comparing multiple datasets)
+18. "Considering the TF communities data for TRM and TEX, are there any TFs that are prominent in both TRM and TEX communities, suggesting a shared role?" (Requires comparing two distinct datasets/visualizations and identifying overlaps)
+19. "Analyze the TF activity scores for 'FOXO1'. Does its activity pattern suggest a role in maintaining T-cell quiescence or promoting activation/exhaustion based on the data available across different T-cell states?" (Requires biological interpretation linked to data patterns)
+20. "If a researcher is interested in TFs that are highly active in T Effector Memory (TEM) cells but show low activity in Terminally Exhausted (TEXterm) cells, which TFs should they investigate further based on the provided datasets?" (Requires filtering, comparison across datasets, and a recommendation)
+21. "Looking at the TF Wave Analysis, which TFs are predominantly active in early waves versus late waves? What might this imply about their roles in T-cell differentiation or response dynamics?" (Requires interpreting the wave data and drawing higher-level conclusions)
+22. "The user uploaded an image of a UMAP plot showing clusters. The file is 'www/test_images/umap_example.png'. Can you describe what you see in the image and how it might relate to T-cell states if cluster A is Naive, cluster B is TEM, and cluster C is TEX?" (Requires multimodal input, assuming the agent can be pointed to local files for analysis - this tests the image upload and interpretation flow we built)
+23. "Given the data in 'Table_TF PageRank Scores for Audrey.xlsx', identify three TFs that have significantly different activity scores between 'Naive_Day0_vs_Day7_UP' and 'MP_Day0_vs_Day7_UP'. Explain the potential biological significance of these differences." (Requires direct data analysis from a file, comparison, and biological reasoning)
+
+# Creative/Hypothetical (tests robustness and deeper understanding)
+24. "If we wanted to design an experiment to reverse T-cell exhaustion, which 2-3 TFs might be good targets for modulation (activation or inhibition) based on their activity profiles in the provided datasets, and why?"
+25. "Explain the overall story the TF activity data tells about T-cell differentiation and exhaustion from Naive to Terminally Exhausted states, highlighting 3 key TF players and their changing roles." 

tools/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'tools' directory a Python package. 

tools/agent_tools.py

@@ -3,6 +3,19 @@ import os
 import json
 import glob # For os.walk if needed, or can use glob directly
 import mimetypes
+from datetime import datetime
+
+# --- NEW IMPORTS FOR LITERATURE SEARCH ---
+from semanticscholar import SemanticScholar # For Semantic Scholar API
+from Bio import Entrez # For PubMed
+import arxiv # For ArXiv API
+import time # For potential rate limiting / delays
+# --- END NEW IMPORTS ---
+
+# --- NEW IMPORTS FOR TEXT FETCHING FROM URLS ---
+import requests
+from bs4 import BeautifulSoup
+# --- END NEW IMPORTS FOR TEXT FETCHING ---
 
 # --- Define Project Root and WWW Path relative to this file ---
 # This file is in taijichat/tools/
@@ -540,7 +553,10 @@ def discover_excel_files_and_schemas(base_scan_directory_name: str = "www") -> d
                         "file_path": file_rel_path,
                         "table_identifier": table_identifier,
                         "columns": columns,
-                        "sheets": xls.sheet_names if xls.sheet_names else [] # Store all sheet names
+                        "sheets": xls.sheet_names if xls.sheet_names else [], # Store all sheet names
+                        "last_modified": datetime.now().isoformat(),
+                        "file_size_bytes": os.path.getsize(file_abs_path),
+                        "error": None
                     }
                 except Exception as e:
                     print(f"[Schema Discovery] Error reading or processing headers for {file_abs_path}: {e}")
@@ -613,7 +629,9 @@ def list_all_files_in_www_directory() -> list:
                 file_manifest.append({
                     "path": file_rel_path_from_project_root,
                     "type": mime_type,
-                    "size": file_size
+                    "size": file_size,
+                    "last_modified": datetime.now().isoformat(),
+                    "error": None
                 })
             except FileNotFoundError: # Should not happen if os.walk found it, but as a safeguard
                 print(f"[File Manifest] Warning: File {file_abs_path} found by os.walk but then not accessible for size/type.")
@@ -625,9 +643,340 @@ def list_all_files_in_www_directory() -> list:
                     "path": file_rel_path_from_project_root,
                     "type": "unknown/error",
                     "size": 0,
+                    "last_modified": datetime.now().isoformat(),
                     "error": str(e)
                 })
 
     return file_manifest
 
+# --- START: Literature Search Tool Implementation ---
+
+def _normalize_authors(authors_data, source="Unknown"):
+    """Helper to normalize author lists from different APIs."""
+    if not authors_data:
+        return ["N/A"]
+    if source == "SemanticScholar": # List of dicts with 'name' key
+        return [author.get('name', "N/A") for author in authors_data]
+    if source == "PubMed": # List of strings
+        return authors_data
+    if source == "ArXiv": # List of arxiv.Result.Author objects
+        return [author.name for author in authors_data]
+    return [str(a) for a in authors_data] # Generic fallback
+
+def _search_semanticscholar_internal(query: str, max_results: int = 2) -> list[dict]:
+    papers = []
+    # print(f"[Tool:_search_semanticscholar_internal] Querying Semantic Scholar for: '{query}' (max: {max_results})") # COMMENTED OUT
+    try:
+        s2 = SemanticScholar(timeout=15)
+        # Corrected: 'doi' is not a direct field for search_paper, 'externalIds' should be used.
+        results = s2.search_paper(query, limit=max_results, fields=['title', 'authors', 'year', 'abstract', 'url', 'venue', 'externalIds'])
+        if results and results.items:
+            for item in results.items:
+                doi_val = item.externalIds.get('DOI') if item.externalIds else None
+                papers.append({
+                    "title": getattr(item, 'title', "N/A"),
+                    "authors": _normalize_authors(getattr(item, 'authors', []), "SemanticScholar"),
+                    "year": getattr(item, 'year', "N/A"),
+                    "abstract": getattr(item, 'abstract', "N/A")[:500] + "..." if getattr(item, 'abstract', None) else "N/A",
+                    "doi": doi_val, # Use the extracted DOI
+                    "url": getattr(item, 'url', "N/A"),
+                    "venue": getattr(item, 'venue', "N/A"),
+                    "source_api": "Semantic Scholar"
+                })
+    except Exception as e:
+        # This print goes to stderr if run directly, but might still be captured by a simple exec context.
+        # For agent integration, actual errors should be raised or returned structured.
+        # For now, we'll assume ManagerAgent's error handling for the overall tool call is preferred.
+        # Let's comment this out for now to ensure no stdout interference.
+        # print(f"[Tool:_search_semanticscholar_internal] Error: {e}", file=sys.stderr) 
+        pass # Allow the function to return an empty list on error.
+    return papers
+
+def _search_pubmed_internal(query: str, max_results: int = 2) -> list[dict]:
+    papers = []
+    # print(f"[Tool:_search_pubmed_internal] Querying PubMed for: '{query}' (max: {max_results})") # COMMENTED OUT
+    try:
+        handle = Entrez.esearch(db="pubmed", term=query, retmax=str(max_results), sort="relevance")
+        record = Entrez.read(handle)
+        handle.close()
+        ids = record["IdList"]
+        if not ids:
+            return papers
+
+        handle = Entrez.efetch(db="pubmed", id=ids, rettype="medline", retmode="xml")
+        records = Entrez.read(handle) # This is MedlineParser.parse, returns a generator usually
+        handle.close()
+        
+        for pubmed_article in records.get('PubmedArticle', []): # records is a list of dicts if multiple ids
+            article = pubmed_article.get('MedlineCitation', {}).get('Article', {})
+            title = article.get('ArticleTitle', "N/A")
+            abstract_text_list = article.get('Abstract', {}).get('AbstractText', [])
+            abstract = " ".join(abstract_text_list)[:500] + "..." if abstract_text_list else "N/A"
+            year = article.get('Journal', {}).get('JournalIssue', {}).get('PubDate', {}).get('Year', "N/A")
+            authors_list = []
+            author_info_list = article.get('AuthorList', [])
+            for auth in author_info_list:
+                if auth.get('LastName') and auth.get('ForeName'):
+                    authors_list.append(f"{auth.get('ForeName')} {auth.get('LastName')}")
+                elif auth.get('CollectiveName'):
+                    authors_list.append(auth.get('CollectiveName'))
+            
+            doi = None
+            article_ids = pubmed_article.get('PubmedData', {}).get('ArticleIdList', [])
+            for aid in article_ids:
+                if aid.attributes.get('IdType') == 'doi':
+                    doi = str(aid) # The content of the tag is the DOI
+                    break
+            
+            pmid = pubmed_article.get('MedlineCitation', {}).get('PMID', None)
+            url = f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/" if pmid else "N/A"
+            venue = article.get('Journal', {}).get('Title', "N/A")
+
+            papers.append({
+                "title": title,
+                "authors": _normalize_authors(authors_list, "PubMed"),
+                "year": year,
+                "abstract": abstract,
+                "doi": doi,
+                "url": url,
+                "venue": venue,
+                "source_api": "PubMed"
+            })
+            if len(papers) >= max_results: # Ensure we don't exceed due to structure of efetch
+                 break
+
+    except Exception as e:
+        # print(f"[Tool:_search_pubmed_internal] Error: {e}", file=sys.stderr) # COMMENTED OUT
+        pass
+    return papers
+
+def _search_arxiv_internal(query: str, max_results: int = 2) -> list[dict]:
+    papers = []
+    # print(f"[Tool:_search_arxiv_internal] Querying ArXiv for: '{query}' (max: {max_results})") # COMMENTED OUT
+    try:
+        search = arxiv.Search(
+            query = query,
+            max_results = max_results,
+            sort_by = arxiv.SortCriterion.Relevance
+        )
+        results = list(arxiv.Client().results(search)) # Convert generator to list
+
+        for result in results:
+            papers.append({
+                "title": getattr(result, 'title', "N/A"),
+                "authors": _normalize_authors(getattr(result, 'authors', []), "ArXiv"),
+                "year": getattr(result, 'published').year if getattr(result, 'published', None) else "N/A",
+                "abstract": getattr(result, 'summary', "N/A").replace('\n', ' ')[:500] + "...", # ArXiv abstracts can have newlines
+                "doi": getattr(result, 'doi', None),
+                "url": getattr(result, 'entry_id', "N/A"), # entry_id is the ArXiv URL like http://arxiv.org/abs/xxxx.xxxxx
+                "venue": "ArXiv", # ArXiv is the venue
+                "source_api": "ArXiv"
+            })
+    except Exception as e:
+        # print(f"[Tool:_search_arxiv_internal] Error: {e}", file=sys.stderr) # COMMENTED OUT
+        pass
+    return papers
+
+def multi_source_literature_search(queries: list[str], max_results_per_query_per_source: int = 1, max_total_unique_papers: int = 10) -> list[dict]:
+    # print(f"[Tool:multi_source_literature_search] Received {len(queries)} queries. Max results per source/query: {max_results_per_query_per_source}, Max total unique papers: {max_total_unique_papers}") # COMMENTED OUT
+    
+    unique_papers_found_so_far = [] 
+    processed_dois = set()
+    processed_titles_authors = set()
+
+    for query_idx, query_str in enumerate(queries):
+        if len(unique_papers_found_so_far) >= max_total_unique_papers:
+            # print(f"  Max total unique papers ({max_total_unique_papers}) reached. Stopping query processing early.") # COMMENTED OUT
+            break 
+
+        # print(f"  Processing query {query_idx+1}/{len(queries)}: '{query_str}'") # COMMENTED OUT
+        
+        current_query_results_from_all_sources = []
+
+        # Semantic Scholar
+        if len(unique_papers_found_so_far) < max_total_unique_papers:
+            s2_results = _search_semanticscholar_internal(query_str, max_results_per_query_per_source)
+            current_query_results_from_all_sources.extend(s2_results)
+        
+        # PubMed
+        if len(unique_papers_found_so_far) < max_total_unique_papers:
+            pubmed_results = _search_pubmed_internal(query_str, max_results_per_query_per_source)
+            current_query_results_from_all_sources.extend(pubmed_results)
+        
+        # ArXiv
+        if len(unique_papers_found_so_far) < max_total_unique_papers:
+            arxiv_results = _search_arxiv_internal(query_str, max_results_per_query_per_source)
+            current_query_results_from_all_sources.extend(arxiv_results)
+
+        # De-duplicate results from current_query_results_from_all_sources and add to unique_papers_found_so_far
+        for paper in current_query_results_from_all_sources:
+            if len(unique_papers_found_so_far) >= max_total_unique_papers:
+                break 
+
+            is_new_paper = False
+            doi = paper.get("doi")
+            if doi and doi != "N/A":
+                normalized_doi = doi.lower().strip()
+                if normalized_doi not in processed_dois:
+                    processed_dois.add(normalized_doi)
+                    is_new_paper = True
+            else: # Fallback to title + first author
+                title = paper.get("title", "").lower().strip()
+                first_author_list = paper.get("authors", [])
+                first_author = first_author_list[0].lower().strip() if first_author_list and first_author_list[0] != "N/A" else ""
+                title_author_key = f"{title}|{first_author}"
+                if title and first_author and title_author_key not in processed_titles_authors:
+                    processed_titles_authors.add(title_author_key)
+                    is_new_paper = True
+                elif title and not first_author and title not in processed_titles_authors: 
+                     processed_titles_authors.add(title)
+                     is_new_paper = True
+            
+            if is_new_paper:
+                unique_papers_found_so_far.append(paper)
+        
+        if len(unique_papers_found_so_far) >= max_total_unique_papers:
+            # print(f"  Max total unique papers ({max_total_unique_papers}) reached after processing query {query_idx+1}.") # COMMENTED OUT
+            break
+    
+    final_results = unique_papers_found_so_far[:max_total_unique_papers]
+
+    # print(f"[Tool:multi_source_literature_search] Total unique papers found (capped at {max_total_unique_papers}): {len(final_results)}") # COMMENTED OUT
+    return final_results
+
+# --- END: Literature Search Tool Implementation ---
+
+# --- START: Text Fetching from URLs Tool Implementation ---
+
+def fetch_text_from_urls(paper_info_list: list[dict], max_chars_per_paper: int = 15000) -> list[dict]:
+    # print(f"[Tool:fetch_text_from_urls] Attempting to fetch text for {len(paper_info_list)} papers.") # COMMENTED OUT
+    
+    updated_paper_info_list = []
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+    }
+
+    for paper in paper_info_list:
+        url = paper.get("url")
+        retrieved_text = None
+        source_api = paper.get("source_api", "Unknown") # Get source for potential specific handling
+
+        if not url or not isinstance(url, str) or not url.startswith("http"):
+            retrieved_text = "Error: Invalid or missing URL."
+            paper["retrieved_text_content"] = retrieved_text
+            updated_paper_info_list.append(paper)
+            # print(f"  Skipping paper '{paper.get('title', 'N/A')}' due to invalid URL: {url}") # COMMENTED OUT
+            continue
+
+        # print(f"  Fetching text for: '{paper.get('title', 'N/A')}' from {url[:70]}...") # COMMENTED OUT
+        try:
+            response = requests.get(url, headers=headers, timeout=20, allow_redirects=True)
+            response.raise_for_status() # Raise an exception for HTTP errors
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            
+            # Basic text extraction - attempt to find common article body tags or just get all text
+            # This will need refinement for specific site structures (e.g., arXiv, PubMed Central)
+            # For now, a general approach:
+            
+            body_content = soup.find('body')
+            if body_content:
+                # Remove script and style tags
+                for script_or_style in body_content(["script", "style"]):
+                    script_or_style.decompose()
+                
+                # Try to get main article content if common tags exist
+                main_article_tags = ['article', 'main', '.main-content', '.article-body', '.abstract'] # Add more specific selectors
+                extracted_elements = []
+                for tag_selector in main_article_tags:
+                    elements = body_content.select(tag_selector)
+                    if elements:
+                        for el in elements:
+                            extracted_elements.append(el.get_text(separator=" ", strip=True))
+                        break # Found a primary content block, assume this is good enough
+                
+                if extracted_elements:
+                    retrieved_text = " ".join(extracted_elements)
+                else:
+                    retrieved_text = body_content.get_text(separator=" ", strip=True)
+            else:
+                retrieved_text = "Error: Could not find body content in HTML."
+
+            if retrieved_text and not retrieved_text.startswith("Error:"):
+                retrieved_text = retrieved_text[:max_chars_per_paper]
+                if len(retrieved_text) == max_chars_per_paper:
+                    retrieved_text += "... (truncated)"
+                # print(f"    Successfully extracted ~{len(retrieved_text)} chars.") # COMMENTED OUT
+            elif not retrieved_text:
+                 retrieved_text = "Error: No text could be extracted."
+
+        except requests.exceptions.RequestException as e:
+            retrieved_text = f"Error fetching URL: {str(e)}"
+            # print(f"    Error fetching URL {url}: {e}") # COMMENTED OUT
+        except Exception as e:
+            retrieved_text = f"Error processing HTML: {str(e)}"
+            # print(f"    Error processing HTML for {url}: {e}") # COMMENTED OUT
+        
+        paper["retrieved_text_content"] = retrieved_text
+        updated_paper_info_list.append(paper)
+        
+        # Optional: add a small delay between requests if fetching from many URLs
+        # time.sleep(0.25) 
+
+    # print(f"[Tool:fetch_text_from_urls] Finished fetching text for {len(updated_paper_info_list)} papers.") # COMMENTED OUT
+    return updated_paper_info_list
+
+# --- END: Text Fetching from URLs Tool Implementation ---
+
+# Example of how GenerationAgent would call this tool:
+# Assume 'list_of_papers_from_search' is the output from multi_source_literature_search
+# print(json.dumps({'intermediate_data_for_llm': fetch_text_from_urls(paper_info_list=list_of_papers_from_search, max_chars_per_paper=10000)}))
+
+
+if __name__ == '__main__':
+    # Test basic Excel schema discovery
+    # print("Testing Excel Schema Discovery:")
+    # schemas = discover_excel_files_and_schemas(base_scan_directory_name="www")
+    # print(json.dumps(schemas, indent=2))
+    # print("\n")
+
+    # Test WWW file manifest
+    # print("Testing WWW File Manifest:")
+    # manifest = list_all_files_in_www_directory(base_directory_name="www")
+    # print(json.dumps(manifest, indent=2))
+    # print("\n")
+
+    # --- Test Literature Search ---
+    print("Testing Multi-Source Literature Search Tool:")
+    test_queries_lit = [
+        "novel targets for CAR-T cell therapy in solid tumors",
+        "role of microbiota in cancer immunotherapy response",
+        "epigenetic regulation of T cell exhaustion"
+    ]
+    # To see output like GenerationAgent expects:
+    # search_results_for_llm = {"intermediate_data_for_llm": multi_source_literature_search(queries=test_queries_lit, max_results_per_query_per_source=1)}
+    # print(json.dumps(search_results_for_llm, indent=2))
+
+    # Simpler print for direct tool test:
+    results = multi_source_literature_search(queries=test_queries_lit, max_results_per_query_per_source=1, max_total_unique_papers=2) # Fetch 2 papers for testing text fetch
+    print(f"Found {len(results)} unique papers for text fetching test:")
+    # print(json.dumps(results, indent=2))
+
+    if results:
+        print("\nTesting Text Fetching from URLs Tool:")
+        # To see output like GenerationAgent expects for LLM:
+        # fetched_text_data_for_llm = {"intermediate_data_for_llm": fetch_text_from_urls(paper_info_list=results, max_chars_per_paper=5000)}
+        # print(json.dumps(fetched_text_data_for_llm, indent=2))
+
+        # Simpler print for direct tool test:
+        results_with_text = fetch_text_from_urls(paper_info_list=results, max_chars_per_paper=5000)
+        print(f"Processed {len(results_with_text)} papers for text content:")
+        for i, paper in enumerate(results_with_text):
+            print(f"--- Paper {i+1} ---")
+            print(f"  Title: {paper.get('title')}")
+            print(f"  URL: {paper.get('url')}")
+            text_content = paper.get('retrieved_text_content', 'Not found')
+            print(f"  Retrieved Text (first 200 chars): {text_content[:200]}...")
+            print("\n")
+
 # No __main__ block here, this is a module of tools. 

tools/agent_tools_documentation.md

@@ -116,4 +116,75 @@ Description: Scans the entire `www/` directory (and its subdirectories, excludin
 Input: None
 Output: `file_manifest` (list of dictionaries) - Each dictionary represents a file and contains the keys: `path` (string), `type` (string), `size` (integer). Example item: `{"path": "www/data/report.txt", "type": "text/plain", "size": 1024}`. Returns an empty list if the `www` directory isn't found or is empty.
 
+---
+
+### `multi_source_literature_search(queries: list[str], max_results_per_query_per_source: int = 1, max_total_unique_papers: int = 10) -> list[dict]`
+
+Searches for academic literature across multiple sources (Semantic Scholar, PubMed, ArXiv) using a list of provided search queries. It then de-duplicates the results based primarily on DOI, and secondarily on a combination of title and first author if DOI is not available. The search process stops early if the `max_total_unique_papers` limit is reached.
+
+**Args:**
+
+*   `queries (list[str])`: A list of search query strings. The GenerationAgent should brainstorm 3-5 diverse queries relevant to the user's request.
+*   `max_results_per_query_per_source (int)`: The maximum number of results to fetch from EACH academic source (Semantic Scholar, PubMed, ArXiv) for EACH query string. Defaults to `1`.
+*   `max_total_unique_papers (int)`: The maximum total number of unique de-duplicated papers to return across all queries and sources. Defaults to `10`. The tool will stop fetching more data once this limit is met.
+
+**Returns:**
+
+*   `list[dict]`: A consolidated and de-duplicated list of paper details, containing up to `max_total_unique_papers`. Each dictionary in the list represents a paper and has the following keys:
+    *   `"title" (str)`: The title of the paper. "N/A" if not available.
+    *   `"authors" (list[str])`: A list of author names. ["N/A"] if not available.
+    *   `"year" (str | int)`: The publication year. "N/A" if not available.
+    *   `"abstract" (str)`: A snippet of the abstract (typically up to 500 characters followed by "..."). "N/A" if not available.
+    *   `"doi" (str | None)`: The Digital Object Identifier. `None` if not available.
+    *   `"url" (str)`: A direct URL to the paper (e.g., PubMed link, ArXiv link, Semantic Scholar link). "N/A" if not available.
+    *   `"venue" (str)`: The publication venue (e.g., journal name, "ArXiv"). "N/A" if not available.
+    *   `"source_api" (str)`: The API from which this record was retrieved (e.g., "Semantic Scholar", "PubMed", "ArXiv").
+
+**GenerationAgent Usage Example (for `python_code` field when `status` is `AWAITING_DATA`):**
+
+```python
+# Example: User asks for up to 3 papers
+print(json.dumps({'intermediate_data_for_llm': tools.multi_source_literature_search(queries=["T-cell exhaustion markers AND cancer", "immunotherapy for melanoma AND biomarkers"], max_results_per_query_per_source=1, max_total_unique_papers=3)}))
+
+# Example: Defaulting to 10 total unique papers
+print(json.dumps({'intermediate_data_for_llm': tools.multi_source_literature_search(queries=["COVID-19 long-term effects"], max_results_per_query_per_source=2)}))
+```
+
+**Important Considerations for GenerationAgent:**
+
+*   When results are returned from this tool, the `GenerationAgent`'s `explanation` (for `CODE_COMPLETE` status) should present a summary of the *found papers* (e.g., titles, authors, URLs). It should clearly state that these are potential literature leads and should *not* yet claim to have read or summarized the full content of these papers in that same turn, unless a subsequent tool call for summarization is planned and executed.
+
+--- 
+
+### `fetch_text_from_urls(paper_info_list: list[dict], max_chars_per_paper: int = 15000) -> list[dict]`
+
+Attempts to fetch and extract textual content from the URLs of papers provided in a list. This tool is typically used after `multi_source_literature_search` to gather content for summarization by the GenerationAgent.
+
+**Args:**
+
+*   `paper_info_list (list[dict])`: A list of paper dictionaries, as returned by `multi_source_literature_search`. Each dictionary is expected to have at least a `"url"` key. Other keys like `"title"` and `"source_api"` are used for logging.
+*   `max_chars_per_paper (int)`: The maximum number of characters of text to retrieve and store for each paper. Defaults to `15000`. Text longer than this will be truncated.
+
+**Returns:**
+
+*   `list[dict]`: The input `paper_info_list`, where each paper dictionary is augmented with a new key `"retrieved_text_content"`. 
+    *   If successful, `"retrieved_text_content" (str)` will contain the extracted text (up to `max_chars_per_paper`).
+    *   If fetching or parsing fails for a paper, `"retrieved_text_content" (str)` will contain an error message (e.g., "Error: Invalid or missing URL.", "Error fetching URL: ...", "Error: No text could be extracted.").
+
+**GenerationAgent Usage Example (for `python_code` field when `status` is `AWAITING_DATA`):**
+
+This tool is usually the second step in a literature review process.
+
+```python
+# Assume 'list_of_papers_from_search' is a variable holding the output from a previous
+# call to tools.multi_source_literature_search(...)
+print(json.dumps({'intermediate_data_for_llm': tools.fetch_text_from_urls(paper_info_list=list_of_papers_from_search, max_chars_per_paper=10000)}))
+```
+
+**Important Considerations for GenerationAgent:**
+
+*   After this tool returns the `paper_info_list` (now with `"retrieved_text_content"`), the `GenerationAgent` is responsible for using its own LLM capabilities to read the `"retrieved_text_content"` for each paper and generate summaries if requested by the user or if it's part of its plan.
+*   The `GenerationAgent` should be prepared for `"retrieved_text_content"` to contain error messages and handle them gracefully in its summarization logic (e.g., by stating that text for a particular paper could not be retrieved).
+*   Web scraping is inherently unreliable; success in fetching and parsing text can vary greatly between websites. The agent should not assume text will always be available.
+
 --- 

traces/list of required files.txt

@@ -1,76 +0,0 @@
-www/
-|-- tablePagerank/                 # Excel files for TF PageRank scores
-|   |-- Table_TF PageRank Scores for Audrey.xlsx
-|   |-- Naive.xlsx
-|   |-- TE.xlsx
-|   |-- MP.xlsx
-|   |-- TCM.xlsx
-|   |-- TEM.xlsx
-|   |-- TRM.xlsx
-|   |-- TEXprog.xlsx
-|   |-- TEXeff.xlsx
-|   |-- TEXterm.xlsx
-|
-|-- waveanalysis/                  # Assets for TF Wave Analysis
-|   |-- searchtfwaves.xlsx
-|   |-- tfwaveanal.png             # Overview image
-|   |-- c1.jpg                     # Wave 1 image
-|   |-- c2.jpg                     # Wave 2 image
-|   |-- c3.jpg                     # Wave 3 image
-|   |-- c4.jpg                     # Wave 4 image
-|   |-- c5.jpg                     # Wave 5 image
-|   |-- c6.jpg                     # Wave 6 image
-|   |-- c7.jpg                     # Wave 7 image
-|   |-- c1_selected_GO_KEGG.jpg
-|   |-- c2_selected_GO_KEGG_v2.jpg
-|   |-- c3_selected_GO_KEGG.jpg
-|   |-- c4_selected_GO_KEGG.jpg
-|   |-- c5_selected_GO_KEGG.jpg
-|   |-- c6_selected_GO_KEGG.jpg
-|   |-- c7_selected_GO_KEGG.jpg
-|   |
-|   |-- txtJPG/                    # "Ranked Text" images for Wave Analysis
-|       |-- c1_ranked_1.jpg
-|       |-- c1_ranked_2.jpg
-|       |-- c2_ranked.jpg
-|       |-- c3_ranked.jpg
-|       |-- c4_ranked.jpg
-|       |-- c5_ranked.jpg
-|       |-- c6_ranked.jpg
-|       |-- c7_ranked.jpg
-|
-|-- TFcorintextrm/                 # Data for TF-TF correlation
-|   |-- TF-TFcorTRMTEX.xlsx
-|
-|-- tfcommunities/                 # Data for TF communities
-|   |-- trmcommunities.xlsx
-|   |-- texcommunities.xlsx
-|
-|-- bubbleplots/                   # Images for cell-state specific bubble plots
-|   |-- naivebubble.jpg
-|   |-- tebubble.jpg
-|   |-- mpbubble.jpg
-|   |-- tcmbubble.jpg
-|   |-- tembubble.jpg
-|   |-- trmbubble.jpg
-|   |-- texprogbubble.jpg
-|   |-- texintbubble.jpg           # (Used for TEXeff-like)
-|   |-- textermbubble.jpg
-|
-|-- tfcat/                         # Images for the TF Catalog section
-|   |-- onlycellstates.png
-|   |-- multistatesheatmap.png
-|
-|-- networkanalysis/               # Images for TF Network Analysis section
-|   |-- tfcorrdesc.png
-|   |-- community.jpg
-|   |-- trmtexcom.png
-|   |-- tfcompathway.png
-|
-|-- multi-omicsdata.xlsx           # Main multi-omics data file
-|
-|-- homedesc.png                   # Image for the home page
-|-- ucsdlogo.png                   # UCSD Logo
-|-- salklogo.png                   # Salk Logo
-|-- unclogo.jpg                    # UNC Logo
-|-- csdescrip.jpeg                 # Image for the modal dialog (if used)

traces/log7.txt

@@ -0,0 +1,23 @@
+User: can you analyze the trm community table and provide some insights 
+[Manager._process_turn] Processing query: 'can you analyze the trm community table and provide some insights ...'
+[Manager._process_turn] Generation Attempt: 1/2
+GenerationAgent Error: Run failed or timed out. Status: in_progress
+[GenerationAgent] Thought (Data Fetch Attempt 1): Run failed or timed out. Status: in_progress
+[Manager._process_turn] Error during generation/data fetching: Run failed or timed out. Status: in_progress
+[Manager._process_turn] Generation Attempt: 2/2
+[GenerationAgent] Thought (Data Fetch Attempt 1): I need to analyze the 'trmcommunities.xlsx' file to gain insights into the TRM communities. This file is listed in the dynamically discovered Excel schemas, and the first sheet appears to contain information on TRM Communities and TF Members. I'll fetch this data to analyze the community structure and any notable transcription factors involved.
+[Manager._process_turn] GenerationAgent is AWAITING_DATA. Executing code to fetch data...
+SupervisorAgent.review_code received code. Thought: Reviewing code for data fetching: I need to analyze the 'trmcommunities.xlsx' file to gain insights ...
+[SupervisorAgent] Data Fetch Code Review: Code adheres to safety guidelines and uses permitted operations. No forbidden operations detected. (Status: APPROVED_FOR_EXECUTION)
+ExecutorAgent received code for execution:
+print(json.dumps({'intermediate_data_for_llm': tools.get_tf_community_sheet_data('trm')}))
+[Manager._process_turn] Successfully fetched intermediate data. Size (approx chars): 1121
+[GenerationAgent] Thought (Data Fetch Attempt 2): I will analyze the TRM Communities table data that has been provided. The table lists transcription factors (TFs) categorized into five communities (C1 to C5). Each community has a unique set of TFs associated with it. I will extract some insights from this distribution, such as the number of TFs per community, any notable commonalities, and potential implications of the key transcription factors.
+TaijiChat > I analyzed the TRM Communities data. Here are some insights: 
+1. **Community Counts:**
+   - C1: 20 TFs
+   - C2: 50 TFs
+   - C3: 17 TFs
+   - C4: 48 TFs
+   - C5: 13 TFs
+2. **Common TFs:** There are no TFs shared among all five communities, indicating distinct roles or regulatory pathways. Community C2 has the highest number of TFs, suggesting it may be critical in the context of TRM responses.  Examples of significant TFs include 'Stat6' and 'Irf3', known for their roles in immune responses and development.

traces/log8.txt

@@ -0,0 +1,70 @@
+> shiny::runApp()
+
+Listening on http://127.0.0.1:5793
+Browsing http://127.0.0.1:5793
+[1] "Reticulate using Python at: C:/Users/28702/AppData/Local/Programs/Python/Python311/python.exe"
+Python integration test: json module imported successfully.
+[1] "Successfully imported Python 'agents.manager_agent' module."
+Warning: Navigation containers expect a collection of `bslib::nav_panel()`/`shiny::tabPanel()`s and/or `bslib::nav_menu()`/`shiny::navbarMenu()`s. Consider using `header` or `footer` if you wish to place content above (or below) every panel's contents.
+Warning: Navigation containers expect a collection of `bslib::nav_panel()`/`shiny::tabPanel()`s and/or `bslib::nav_menu()`/`shiny::navbarMenu()`s. Consider using `header` or `footer` if you wish to place content above (or below) every panel's contents.
+[1] "--- In chat_ui.R, chatSidebarUI IS DEFINING ID AS: chatSidebar ---"
+[1] "TaijiChat: API key successfully read in server.R."
+[1] "TaijiChat: Python OpenAI client initialized successfully in server.R via reticulate."
+[1] "TaijiChat: Successfully imported/retrieved 'agents.manager_agent' module in server.R."
+ManagerAgent: R callback function provided and stored.
+ManagerAgent: Initialized with a provided OpenAI client.
+GenerationAgent: Initializing WWW file manifest discovery...
+GenerationAgent attempting to load static docs from: C:\Users\28702\Desktop\work_space\taijichat\agents\..\tools\agent_tools_documentation.md
+GenerationAgent: Updated existing Generation Assistant: asst_fiIaIymtRaNqMJ9eQ7E7O7Wp
+SupervisorAgent: Updated existing Supervisor Assistant: asst_WVif16RGW4s5XMvTpHCaAsau
+ExecutorAgent initialized.
+ManagerAgent: Specialized agents (Generation, Supervisor, Executor) initialized.
+[1] "TaijiChat: Python ManagerAgent instance created in server.R using pre-initialized client and R callback."
+New names:
+• `` -> `...18`
+• `` -> `...19`
+[1] "TaijiChat: API key successfully read in server.R."
+[1] "TaijiChat: Python OpenAI client initialized successfully in server.R via reticulate."
+[1] "TaijiChat: Successfully imported/retrieved 'agents.manager_agent' module in server.R."
+ManagerAgent: R callback function provided and stored.
+ManagerAgent: Initialized with a provided OpenAI client.
+GenerationAgent: Initializing WWW file manifest discovery...
+GenerationAgent attempting to load static docs from: C:\Users\28702\Desktop\work_space\taijichat\agents\..\tools\agent_tools_documentation.md
+GenerationAgent: Updated existing Generation Assistant: asst_fiIaIymtRaNqMJ9eQ7E7O7Wp
+SupervisorAgent: Updated existing Supervisor Assistant: asst_WVif16RGW4s5XMvTpHCaAsau
+ExecutorAgent initialized.
+ManagerAgent: Specialized agents (Generation, Supervisor, Executor) initialized.
+[1] "TaijiChat: Python ManagerAgent instance created in server.R using pre-initialized client and R callback."
+New names:
+• `` -> `...18`
+• `` -> `...19`
+[1] "TaijiChat: Received user_chat_message - what information can this website provide? what researches can i do on top of it? what are some example research questions? and what are the relevant literature"
+[1] "TaijiChat: Sending to Python agent - Query: what information can this website provide? what researches can i do on top of it? what are some example research questions? and what are the relevant literature"
+[Manager.process_single_query] Received query: 'what information can this website provide? what researches can i do on top of it? what are some exam...'
+[Manager._process_turn] Processing query: 'what information can this website provide? what researches can i do on top of it? what are some exam...'  
+[Manager._process_turn] Generation Attempt: 1/2
+[GenerationAgent] Thought (Data Fetch Attempt 1): To provide a comprehensive response to the user's inquiry regarding the website, I will first gather general information about the datasets and resources available on the website to identify potential research questions and relevant literature. The site includes multiple datasets related to Transcription Factors (TFs), including correlations, wave analyses, and community effects. I will summarize findings and research angles based on available data and provide example research questions and literature references.
+[Manager._process_turn] GenerationAgent is AWAITING_DATA. Executing code to fetch data...
+SupervisorAgent.review_code received code. Thought: Reviewing code for data fetching: To provide a comprehensive response to the user's inquiry regardin...
+[SupervisorAgent] Data Fetch Code Review: Code uses the 'tools' module correctly to fetch data and the 'print' function for output without any forbidden operations detected. (Status: APPROVED_FOR_EXECUTION)
+ExecutorAgent received code for execution:
+print(json.dumps({'intermediate_data_for_llm': tools.list_all_files_in_www_directory()}))
+[Manager._process_turn] Successfully fetched intermediate data. Size (approx chars): 71600
+[GenerationAgent] Thought (Data Fetch Attempt 2): To answer the user's query about the information the website can provide, potential research avenues, example questions, and relevant literature, I will analyze various resources available on the website. This includes reviewing Excel datasets, images, and descriptions related to transcription factors (TFs), wave analysis, and community data for potential biological studies. Key areas for exploration include data on TFs, their interactions, and pathways relevant to research in cell biology and molecular mechanisms. Additionally, I will consider existing literature referenced in the datasets, particularly the 'multi-omicsdata.xlsx' and relevant TF analysis files.
+[Manager._process_turn] GenerationAgent is AWAITING_DATA. Executing code to fetch data...
+SupervisorAgent.review_code received code. Thought: Reviewing code for data fetching: To answer the user's query about the information the website can p...
+[SupervisorAgent] Data Fetch Code Review: Code uses the 'tools' module correctly and employs permitted built-in functions for data processing. No forbidden operations detected. (Status: APPROVED_FOR_EXECUTION)
+ExecutorAgent received code for execution:
+print(json.dumps({'intermediate_data_for_llm': tools.get_raw_excel_data('www/multi-omicsdata.xlsx')}))
+[Manager._process_turn] Successfully fetched intermediate data. Size (approx chars): 3204
+[Manager._process_turn] Could not complete data fetching: To answer the user's query about the information the website can provide, potential research avenues, example questions, and relevant literature, I will analyze various resources available on the website. This includes reviewing Excel datasets, images, and descriptions related to transcription factors (TFs), wave analysis, and community data for potential biological studies. Key areas for exploration include data on TFs, their interactions, and pathways relevant to research in cell biology and molecular mechanisms. Additionally, I will consider existing literature referenced in the datasets, particularly the 'multi-omicsdata.xlsx' and relevant TF analysis files.
+[Manager._process_turn] Generation Attempt: 2/2
+[GenerationAgent] Thought (Data Fetch Attempt 1): To fully address your query about the information provided by the website and potential research topics, I need to first review the available datasets found in the provided Excel files. The dataset named 'multi-omicsdata.xlsx' seems comprehensive, comprising multiple columns that may contain valuable information related to various research inquiries. I will extract the names of the sheets and the first few columns from this dataset to identify relevant research questions. Additionally, I will gather insights about related literature based on those research possibilities.
+[Manager._process_turn] GenerationAgent is AWAITING_DATA. Executing code to fetch data...
+SupervisorAgent.review_code received code. Thought: Reviewing code for data fetching: To fully address your query about the information provided by the ...
+[SupervisorAgent] Data Fetch Code Review: Code uses the 'tools' module correctly to fetch data, and makes use of the json module to serialize the output. No forbidden operations detected. (Status: APPROVED_FOR_EXECUTION)
+ExecutorAgent received code for execution:
+print(json.dumps({'intermediate_data_for_llm': tools.get_raw_excel_data('www/multi-omicsdata.xlsx')}))
+[Manager._process_turn] Successfully fetched intermediate data. Size (approx chars): 3204
+[GenerationAgent] Thought (Data Fetch Attempt 2): The data provided includes detailed research related to various studies involving T cells, specifically focusing on different datasets including their authors, DOI links, data types, and species, all related to infections like LCMV. This dataset serves as a foundation for conducting further research into the dynamics of T cell responses and can lead to various research questions regarding the relationships between different T cell subtypes, their activation states, and how these factors correlate with response to infections. The included literature can be accessed through the provided DOIs, which serve as references for deeper insights into methodologies and findings relevant to T cell biology.
+[1] "TaijiChat: Received from Python agent - The dataset offers a rich source of information to explore T cell activation, differentiation, and memory formation in response to various infections. Potential research questions could include: 'How do different T cell subtypes respond to viral infections?', 'What are the long-term effects of LCMV on T cell differentiation?', and 'Can memory T cells provide better protection against reinfection compared to naive T cells?'. The associated literature can be referenced through the DOIs provided, which guide towards comprehensive studies that these research questions may build upon."

ui.R

@@ -1,6 +1,47 @@
 library(shiny)
 library(shinythemes)
 library(DT)
+library(reticulate)
+
+# --- Python Environment Configuration (USER ACTION REQUIRED) ---
+# Uncomment and configure ONE of the following lines to point to your Python environment
+# where 'openai' and 'pandas' are installed (from requirements.txt).
+# Ensure the path to python executable is correct or the virtual/conda env name is correct.
+
+# Option 1: Specify path to Python executable (e.g., in a virtual environment)
+reticulate::use_python("C:/Users/28702/AppData/Local/Programs/Python/Python311/python.exe", required = TRUE) # FIXME
+
+# Option 2: Specify name of a virtual environment (if R can find it by name)
+# reticulate::use_virtualenv("your_python_venv_name", required = TRUE)
+
+# Option 3: Specify name of a Conda environment
+# reticulate::use_condaenv("your_python_conda_env_name", required = TRUE)
+
+# Ensure Python environment is configured before proceeding
+if (!py_available(initialize = TRUE)) {
+  stop("Python environment with required packages (openai, pandas) not found or configured correctly for reticulate. Please check the comments above.")
+} else {
+  print(paste("Reticulate using Python at:", py_config()$python))
+  # Try importing a core Python module to confirm setup
+  py_run_string("import json; print(\'Python integration test: json module imported successfully.\')")
+}
+
+# --- Import Python Agent Module ---
+# This assumes server.R is in the project root, and 'agents' is a subdirectory.
+# If your R working directory is not the project root, adjust sys.path or import call.
+# Ensure agents/__init__.py exists.
+manager_agent_module <- NULL
+tryCatch({
+  # Add project root to Python's sys.path if not already discoverable by reticulate
+  # This makes `import agents.manager_agent` work if R CWD is project root.
+  reticulate::py_run_string("import sys; import os; os.chdir(os.path.abspath('.')); sys.path.insert(0, os.getcwd())")
+  manager_agent_module <- reticulate::import("agents.manager_agent")
+  print("Successfully imported Python 'agents.manager_agent' module.")
+}, error = function(e) {
+  stop(paste("Failed to import Python 'agents.manager_agent' module. Error:", e$message, 
+             "Ensure your R working directory is the project root (containing server.R and the 'agents' folder), ",
+             "and that agents/__init__.py exists. Also check Python environment."))
+})
 
 # Source the new chat UI definitions
 source("chat_ui.R", local = TRUE) # local = TRUE is good practice if chat_ui.R defines reactive expressions, though here it's just UI functions

www/chat_script.js

@@ -3,6 +3,8 @@
 $(document).on('shiny:connected', function(event) {
   console.log("Shiny connected. chat_script.js executing.");
 
+  var isFirstChatOpenThisSession = true; // Flag for initial greeting
+
   // --- Dynamically create and insert the Chat tab --- START ---
   var chatTabExists = $('#customChatTabLink').length > 0;
   if (!chatTabExists) {
@@ -65,7 +67,13 @@ $(document).on('shiny:connected', function(event) {
     if (sidebar.is(':visible')) {
       sidebar.fadeOut();
     } else {
-      sidebar.fadeIn();
+      sidebar.fadeIn(function() { // Callback function after fadeIn completes
+        if (isFirstChatOpenThisSession) {
+          addChatMessage("How can I help you today?", 'agent');
+          isFirstChatOpenThisSession = false; // Set flag to false after showing message
+          console.log("Initial agent greeting displayed.");
+        }
+      });
     }
     return false; // Extra measure to prevent default behavior
   });
@@ -77,15 +85,55 @@ $(document).on('shiny:connected', function(event) {
     $('#chatSidebar').fadeOut();
   });
 
-  function addChatMessage(messageText, messageType) {
+  // Variable to keep track of the thinking message element and its thoughts container
+  var thinkingMessageElement = null;
+  var currentThoughtsContainer = null; // To store the div where thoughts are appended
+
+  function addChatMessage(messageText, messageType, isThinkingMessage = false) {
     var messageClass = messageType === 'user' ? 'user-message' : 'agent-message';
+    if (isThinkingMessage) {
+      messageClass += ' thinking-message'; // Add a special class for styling if needed
+    }
     var $chatMessages = $('#chatMessages');
-    $chatMessages.append(
-      $('<div></div>').addClass('chat-message').addClass(messageClass).text(messageText)
-    );
+    
+    // If this is a normal agent message and a thinking message exists, remove it first
+    if (messageType === 'agent' && !isThinkingMessage && thinkingMessageElement) {
+      thinkingMessageElement.remove();
+      thinkingMessageElement = null;
+      if (currentThoughtsContainer) { // Also clear the thoughts container reference
+        currentThoughtsContainer = null;
+      }
+    }
+
+    var $messageDiv = $('<div></div>').addClass('chat-message').addClass(messageClass);
+    
+    if (isThinkingMessage) {
+      // Arrow (toggle) + Text + Hidden Thoughts Area
+      $messageDiv.html('<span class="thought-toggle-arrow" role="button" tabindex="0">&#9658;</span> ' + 
+                       '<span class="thinking-text">' + messageText + '</span>' + 
+                       '<div class="thoughts-area" style="display: none; margin-left: 20px; font-style: italic; color: #555;"></div>');
+      thinkingMessageElement = $messageDiv; 
+      currentThoughtsContainer = $messageDiv.find('.thoughts-area'); // Store reference to the new thoughts area
+    } else {
+      $messageDiv.text(messageText); // For user and final agent messages, use .text() for safety
+    }
+
+    $chatMessages.append($messageDiv);
     $chatMessages.scrollTop($chatMessages[0].scrollHeight);
   }
 
+  // Delegated click handler for thought toggle arrows
+  $('#chatMessages').off('click.thoughtToggle').on('click.thoughtToggle', '.thought-toggle-arrow', function() {
+    var $arrow = $(this);
+    var $thoughtsArea = $arrow.siblings('.thoughts-area');
+    $thoughtsArea.slideToggle(200);
+    if ($arrow.html() === '►') { // Using direct character comparison for simplicity
+        $arrow.html('▼');
+    } else {
+        $arrow.html('►');
+    }
+  });
+
   $('#sendChatMsg').off('click.chatSend').on('click.chatSend', function() {
     var messageText = $('#chatInput').val();
     if (messageText.trim() !== '') {
@@ -103,12 +151,64 @@ $(document).on('shiny:connected', function(event) {
     }
   });
 
+  // Handler for when the agent starts thinking
+  Shiny.addCustomMessageHandler("agent_thinking_started", function(message) {
+    console.log("JS: Received 'agent_thinking_started' message from R:", message);
+    if(message && typeof message.text === 'string') {
+      // If a thinking message already exists, remove it and its thoughts area before adding a new one
+      if (thinkingMessageElement) {
+        thinkingMessageElement.remove();
+        thinkingMessageElement = null;
+      }
+      if (currentThoughtsContainer) {
+        // currentThoughtsContainer is part of thinkingMessageElement, so removing parent is enough
+        currentThoughtsContainer = null; 
+      }
+      addChatMessage(message.text, 'agent', true); // true indicates it's a thinking message
+    } else {
+      console.warn("Received empty or invalid agent_thinking_started message from Shiny:", message);
+    }
+  });
+
+  // Handler for new incoming thoughts from the agent
+  Shiny.addCustomMessageHandler("agent_new_thought", function(message) {
+    console.log("JS: Received 'agent_new_thought':", message);
+    if (message && typeof message.text === 'string' && currentThoughtsContainer) {
+      var $thoughtDiv = $('<div></div>').addClass('thought-item').text(message.text);
+      currentThoughtsContainer.append($thoughtDiv);
+      // Optionally, auto-scroll the main chat window if thoughts make it grow too much
+      var $chatMessages = $('#chatMessages');
+      $chatMessages.scrollTop($chatMessages[0].scrollHeight);
+      // Optionally, ensure the thoughts area is visible if a new thought arrives and it was hidden
+      // if (!currentThoughtsContainer.is(':visible')) {
+      //   currentThoughtsContainer.slideDown(); 
+      //   var $arrow = thinkingMessageElement.find('.thought-toggle-arrow');
+      //   if ($arrow.html() === '►') $arrow.html('▼');
+      // }
+    } else if (!currentThoughtsContainer) {
+      console.warn("Received 'agent_new_thought' but no active thinking message/thoughts container.");
+    } else {
+      console.warn("Received invalid 'agent_new_thought' message:", message);
+    }
+  });
+
   Shiny.addCustomMessageHandler("agent_chat_response", function(message) {
-    if(message && message.text) {
+    if(message && typeof message.text === 'string') { // Check if message.text is a string
       console.log("Received agent response from Shiny:", message.text);
+      // addChatMessage will handle removing thinkingMessageElement and currentThoughtsContainer
       addChatMessage(message.text, 'agent');
     } else {
-      console.warn("Received empty or invalid agent_chat_response from Shiny.");
+      console.warn("Received empty, invalid, or non-string agent_chat_response from Shiny:", message);
+      // If a thinking message was active, clear it since we got a non-response or error
+      if (thinkingMessageElement) {
+        thinkingMessageElement.remove();
+        thinkingMessageElement = null;
+      }
+      if (currentThoughtsContainer) {
+        currentThoughtsContainer = null; // It would have been part of thinkingMessageElement
+      }
+      // Optionally, display a generic error to the user in the chat
+      // addChatMessage("An error occurred receiving the agent's response.", 'agent');
     }
   });
 });

www/pages_description.md

@@ -0,0 +1,30 @@
+homepage:
+- This webpage introduces the "TF atlas of CD8+ T cell states," a platform resulting from a multi-omics study focused on understanding and selectively programming T cell differentiation. The research, a collaboration involving UC San Diego, the Salk Institute, and The University of North Carolina at Chapel Hill, leverages a comprehensive transcriptional and epigenetic atlas generated from RNA-seq and ATAC-seq data. The atlas helps predict transcription factor (TF) activity and define differentiation trajectories, aiming to identify TFs that can control specific T cell states, such as terminally exhausted and tissue-resident memory T cells, for potential therapeutic applications in areas like cancer and viral infections.
+
+TF Catalog - Search TF Scores:
+This webpage provides a tool to "Search TF Scores" related to T cell differentiation. It features a diagram illustrating the "Memory path" and "Exhaustion path" of T cells, including states like Naive, Memory Precursor (MP), Effector T cell (TE), Tissue-Resident Memory (TRM), Terminal Effector (TEM), Progenitor Exhausted (TEXprog), and Terminally Exhausted (TEX). The core of the page is a searchable table displaying "TF activity score" for various transcription factors (TFs) across different T cell states and datasets. This allows users to explore and compare the activity levels of specific TFs in distinct T cell populations, aiding in the understanding of T cell fate decisions.
+
+TF Catalog - Cell State Specific TF Catalog:
+This webpage displays "Naive Specific Cells & normalized TF Activity Scores" as part of a "Cell State Specific TF Catalog." It features a dot plot visualization where each row represents a transcription factor (TF) and each column likely represents a specific sample or condition within naive T cells. The color intensity of the dots corresponds to the normalized TF activity score (PageRank score), while the size of the dots indicates the log-transformed gene expression level (TPM). This allows users to explore and compare the activity and expression of various TFs within the naive T cell state.
+
+TF Catalog - Multi-State TFs
+This webpage displays a series of heatmaps visualizing normalized PageRank scores, likely representing transcription factor activity, across various T cell differentiation states (Naive, MP, TE, TRM, TEM, TEXprog, TEXeff, TEXterm). The heatmaps are segmented into categories such as "Shared in cell states from acute infection," "Shared in cell states from chronic infection," and specific T cell subsets like "TRM & TEXPROG" and "MP, TE, TEXPROG." This presentation allows for the comparative analysis of transcription factor activity profiles across different T cell populations and under varying immunological contexts, revealing potential regulatory patterns.
+
+TF Wave Analysis:
+This webpage, titled "TF Wave Analysis," is dedicated to exploring the dynamic activity patterns of transcription factors (TFs) during T cell differentiation. It presents a series of visualizations, referred to as "TF Waves" (Wave 1, Wave 2, etc.), which illustrate how the activity of different sets of TFs changes as T cells transition through various states (Naive, MP, TRM, TEM, TEXprog, TEXterm). These waves are depicted on diagrams of T cell differentiation pathways, with color intensity and accompanying bar graphs likely indicating the strength or timing of TF activity. A table at the bottom of the page lists specific TFs and their association with these identified waves, allowing users to understand the sequential and coordinated roles of TFs in orchestrating T cell fate.
+
+TF Network Analysis - Search TF-TF Correlation in TRM/TEXterm:
+This webpage provides a tool to "Search TF-TF Correlation in TRM/TEXterm," allowing users to explore interactions and correlations between transcription factors (TFs) specifically within Tissue-Resident Memory (TRM) and Terminally Exhausted (TEXterm) T cell states.
+
+The page explains that it uses data from ChIP-seq and Hi-C to build TF interaction networks. It visualizes these relationships, showing how a "TF-regulatee network" and a "TF X TF correlation matrix" contribute to understanding "TF-TF association." Users can enter a transcription factor of interest to search for its correlations. A key explains the network visualization: circle color indicates TF specificity to TRM (green) or TEXterm (brown), line thickness denotes interaction intensity, and line color shows if the interaction is found in TRM (green) or TEXterm (brown). This tool aims to identify cooperations between DNA-binding proteins in these specific T cell states.
+
+TF Network Analysis - TF Community in TRM/TEXterm:
+This webpage focuses on "TF Community in TRM/TEXterm," illustrating how transcription factor (TF) associations are analyzed through clustering to identify distinct TF communities within Tissue-Resident Memory (TRM) and Terminally Exhausted (TEXterm) T cells.
+
+The page displays several network visualizations: one showing combined TRM and TEXterm TF communities and their interconnections, another detailing TRM-specific TF-TF interactions organized into communities (C1-C5), and a third depicting TEXterm-specific TF-TF interactions, also grouped into communities (C1-C5).
+
+Below these networks, tables likely provide details about the TFs that constitute each identified community. Furthermore, the webpage highlights "Shared pathways" between TRM and TEXterm communities and "Enriched pathways" specific to either the TRM or TEXterm TF networks, linking these TF communities to biological functions such as "IL-2 production," "cell-cell adhesion," "T cell activation," "intrinsic apoptosis," and "catabolism." This allows for an understanding of the collaborative roles of TFs in regulating distinct cellular processes within these two T cell states.
+
+Multi-omics Data:
+This webpage, titled "Multi-omics Data," presents a comprehensive, scrollable table cataloging various experimental datasets relevant to T cell research. Each entry in the table details specific studies, including information such as the primary author, laboratory, publication year, data accession number, type of data (e.g., RNA-seq, ATAC-seq), biological species (primarily mouse), infection model used (e.g., LCMV Arm), and the specific T cell populations analyzed (e.g., Naive, MP, TE, TRM, TexProg, TexTerm) along with their defining markers or characteristics. The page includes features for searching and adjusting the number of displayed entries, indicating it serves as an interactive repository for accessing and reviewing details of diverse multi-omics datasets.
+