temp update

LITERATURE_CONFIRMATION_FEATURE.md

@@ -0,0 +1,85 @@
+# Literature Confirmation Feature
+
+## Overview
+
+This feature adds user confirmation before the AI agents use external literature sources or paper.pdf in their analysis. When the system detects that a query relates to literature or research papers, it will pause and ask the user whether they want to include these resources.
+
+## How It Works
+
+### 1. Detection Phase
+- The `ManagerAgent` analyzes the plan generated by `GenerationAgent`
+- It looks for patterns indicating literature usage:
+  - `multi_source_literature_search`
+  - `fetch_text_from_urls`
+  - `paper.pdf`
+  - "literature search", "academic papers", "research papers", "scientific literature"
+
+### 2. Confirmation Dialog
+- When literature usage is detected, a confirmation dialog appears between the thinking box and response area
+- The dialog asks: "This query appears to relate to literature or research papers. Would you like me to include external literature sources and the paper.pdf in my analysis?"
+- Two buttons: "Yes" and "No"
+
+### 3. Processing Based on User Choice
+- **If Yes**: Continues with the original plan including literature search
+- **If No**: Modifies the plan to remove literature components and provides analysis without external sources
+
+## Implementation Details
+
+### Backend Changes
+
+#### `agents/manager_agent.py`
+- Added `_detect_literature_request()` method to identify literature-related plans
+- Added `_request_literature_confirmation()` to generate confirmation request
+- Added `handle_literature_confirmation()` public method for R/UI integration
+- Added plan modification logic to remove literature components when declined
+- Integrated detection into the main `_process_turn()` flow
+
+#### `server.R`
+- Added handler for `TAIJICHAT_LITERATURE_CONFIRMATION:` response type
+- Added `observeEvent` for `literature_confirmation_response` input
+- Integrated with existing chat message processing flow
+
+### Frontend Changes
+
+#### `www/chat_script.js`
+- Added `literature_confirmation_request` message handler
+- Added `showLiteratureConfirmationDialog()` function to display the confirmation UI
+- Added `handleLiteratureConfirmation()` global function for button clicks
+- Integrated with existing chat message flow
+
+#### `www/chat_styles.css`
+- Added styles for `.literature-confirmation-dialog`
+- Added button styles for Yes/No options
+- Added fade-in animation for smooth appearance
+
+## User Experience
+
+1. User asks a literature-related question
+2. System shows "Thinking..." as usual
+3. A confirmation dialog appears in the chat asking about literature usage
+4. User clicks "Yes" or "No"
+5. System continues processing based on the choice
+6. Final response is provided
+
+## Technical Flow
+
+```
+User Query → GenerationAgent → ManagerAgent Detection → 
+Confirmation Dialog → User Choice → Modified/Original Plan → 
+Execution → Final Response
+```
+
+## Benefits
+
+- **User Control**: Users can choose whether to include external literature
+- **Transparency**: Clear indication when literature sources would be used
+- **Flexibility**: Can provide analysis with or without external sources
+- **Non-intrusive**: Only appears when literature usage is detected
+
+## Configuration
+
+The detection patterns can be modified in the `_detect_literature_request()` method in `manager_agent.py`. The confirmation message can be customized in the `_request_literature_confirmation()` method.
+
+## Testing
+
+The feature includes detection logic that has been tested with various plan types to ensure accurate identification of literature-related requests while avoiding false positives for regular data analysis tasks. 

agents/manager_agent.py

@@ -26,6 +26,8 @@ class ManagerAgent:
         self.client = openai_client
         self.conversation_history = [] # To store user queries and agent responses
         self.r_callback = r_callback_fn # Store the R callback
+        # Add new attribute to track literature confirmation requests
+        self.pending_literature_confirmation = None
 
         if self.r_callback:
             print("ManagerAgent: R callback function provided and stored.")
@@ -85,6 +87,150 @@ class ManagerAgent:
         # else:
             # print(f"Python Agent (No R callback): Thought: {thought_text}") # Optional: uncomment to see thoughts even if no R callback
 
+    def _detect_literature_request(self, plan: dict, user_query: str = "") -> bool:
+        """
+        Detects if the generated plan wants to use literature search or paper.pdf resources.
+        Also checks if the user query itself is about paper/literature.
+        Returns True if literature resources are requested.
+        """
+        if not isinstance(plan, dict):
+            return False
+            
+        # Check the python_code field for literature search patterns
+        python_code = plan.get("python_code", "")
+        thought = plan.get("thought", "")
+        explanation = plan.get("explanation", "")
+        
+        # Patterns that indicate literature/paper usage
+        literature_patterns = [
+            "multi_source_literature_search",
+            "fetch_text_from_urls",
+            "paper.pdf",
+            "literature search",
+            "academic papers",
+            "research papers",
+            "scientific literature"
+        ]
+        
+        # Patterns that indicate user is asking about the paper specifically
+        paper_query_patterns = [
+            "what's the title of the paper",
+            "what is the title of the paper",
+            "paper title",
+            "title of the paper",
+            "what does the paper say",
+            "according to the paper",
+            "in the paper",
+            "the paper describes",
+            "the paper shows",
+            "from the paper",
+            "based on the paper"
+        ]
+        
+        # Check in all relevant fields from the plan
+        all_plan_text = f"{python_code} {thought} {explanation}".lower()
+        
+        for pattern in literature_patterns:
+            if pattern.lower() in all_plan_text:
+                print(f"[ManagerAgent] Detected literature request pattern: '{pattern}' in plan")
+                return True
+        
+        # Check if the user query itself is about the paper
+        user_query_lower = user_query.lower()
+        for pattern in paper_query_patterns:
+            if pattern in user_query_lower:
+                print(f"[ManagerAgent] Detected paper query pattern: '{pattern}' in user query")
+                return True
+        
+        # Also check for general "paper" mentions in user query (but be more specific to avoid false positives)
+        if any(word in user_query_lower for word in ["paper", "manuscript", "publication", "study"]):
+            # Additional context clues that suggest they're asking about THE paper
+            if any(word in user_query_lower for word in ["the", "this", "title", "abstract", "conclusion", "method", "result"]):
+                print(f"[ManagerAgent] Detected general paper reference in user query: '{user_query}'")
+                return True
+                
+        return False
+
+    def _request_literature_confirmation(self, plan: dict) -> str:
+        """
+        Requests user confirmation for using literature resources.
+        Returns a special response indicating confirmation is needed.
+        """
+        # Store the pending plan for later use
+        self.pending_literature_confirmation = plan
+        
+        # Send a special response that the UI can recognize
+        confirmation_request = {
+            "type": "literature_confirmation_request",
+            "plan": plan,
+            "message": "This query appears to relate to literature or research papers. Would you like me to include external literature sources and the paper.pdf in my analysis?"
+        }
+        
+        return f"TAIJICHAT_LITERATURE_CONFIRMATION:{json.dumps(confirmation_request)}"
+
+    def handle_literature_confirmation_response(self, user_response: bool) -> str:
+        """
+        Handles the user's response to literature confirmation request.
+        user_response: True if user wants to include literature, False otherwise
+        """
+        if self.pending_literature_confirmation is None:
+            return "No pending literature confirmation request."
+            
+        plan = self.pending_literature_confirmation
+        self.pending_literature_confirmation = None
+        
+        if user_response:
+            # User approved literature use - continue with original plan
+            self._send_thought_to_r("User approved literature usage. Proceeding with research...")
+            return self._continue_with_literature_plan(plan)
+        else:
+            # User declined literature use - modify plan to skip literature
+            self._send_thought_to_r("User declined literature usage. Providing response without external literature...")
+            return self._continue_without_literature_plan(plan)
+
+    def _continue_with_literature_plan(self, plan: dict) -> str:
+        """Continue processing with the original plan that includes literature search."""
+        # Execute the original plan as intended
+        return self._execute_plan_with_literature(plan)
+
+    def _continue_without_literature_plan(self, plan: dict) -> str:
+        """Continue processing but skip literature search components."""
+        # Modify the plan to remove literature search calls
+        modified_plan = self._remove_literature_from_plan(plan)
+        return self._execute_modified_plan(modified_plan)
+
+    def _remove_literature_from_plan(self, plan: dict) -> dict:
+        """Remove literature search components from the plan."""
+        modified_plan = plan.copy()
+        
+        python_code = modified_plan.get("python_code", "")
+        
+        # Remove literature search calls and replace with generic response
+        if "multi_source_literature_search" in python_code or "fetch_text_from_urls" in python_code:
+            # Replace with a simple response
+            modified_plan["python_code"] = 'print(json.dumps({"response": "I can provide analysis based on available data, but external literature search was not used per your preference."}))'
+            modified_plan["status"] = "CODE_COMPLETE"
+            modified_plan["explanation"] = "Providing analysis without external literature sources as requested."
+            
+        return modified_plan
+
+    def _execute_plan_with_literature(self, plan: dict) -> str:
+        """Execute the original plan with literature components."""
+        # This continues the normal execution flow
+        # We'll integrate this into the existing _process_turn method
+        return self._continue_plan_execution(plan)
+
+    def _execute_modified_plan(self, plan: dict) -> str:
+        """Execute the modified plan without literature."""
+        return self._continue_plan_execution(plan)
+
+    def _continue_plan_execution(self, plan: dict) -> str:
+        """Continue with plan execution after literature confirmation."""
+        # This method will be called from the existing _process_turn logic
+        # For now, return a simple response - the actual execution logic
+        # will be integrated into the existing code flow
+        return plan.get("explanation", "Processing completed.")
+
     def _process_turn(self, user_query_text: str) -> tuple:
         """
         Processes a single turn of the conversation.
@@ -175,6 +321,19 @@ class ManagerAgent:
                 print(f"[GenerationAgent] Thought: {generated_thought}")
                 self._send_thought_to_r(f"GenerationAgent thought: {generated_thought}")
 
+                # --- Check for literature request and ask for user confirmation ---
+                print(f"[Manager._process_turn] Checking for literature request in plan: {plan.get('status', 'NO_STATUS')}")
+                print(f"[Manager._process_turn] User query: '{user_query_text}'")
+                print(f"[Manager._process_turn] Plan thought: '{plan.get('thought', '')[:100]}...'")
+                
+                if self._detect_literature_request(plan, user_query_text):
+                    print(f"[Manager._process_turn] Literature request detected, requesting user confirmation")
+                    self._send_thought_to_r("Detected request for literature resources. Requesting user confirmation...")
+                    confirmation_response = self._request_literature_confirmation(plan)
+                    return confirmation_response, False, None
+                else:
+                    print(f"[Manager._process_turn] No literature request detected, proceeding normally")
+
                 # --- Start: Logic for handling AWAITING_DATA, AWAITING_IMAGE_ANALYSIS, AWAITING_ANALYSIS_CODE ---
                 # This section processes plans that require execution of code or further interaction
                 # before the main generation attempt can be considered complete or failed.
@@ -746,6 +905,113 @@ class ManagerAgent:
         
         return "Processing completed, but no response was generated.", False, None
 
+    def handle_literature_confirmation(self, user_response: bool, original_query: str = None) -> str:
+        """
+        Public method to handle literature confirmation from R/UI.
+        This method can be called from the R side when user responds to confirmation dialog.
+        """
+        print(f"[ManagerAgent] Received literature confirmation: {user_response}")
+        
+        if self.pending_literature_confirmation is None:
+            return "No pending literature confirmation request."
+        
+        plan = self.pending_literature_confirmation
+        self.pending_literature_confirmation = None
+        
+        if user_response:
+            # User approved literature use - continue with original plan
+            self._send_thought_to_r("User approved literature usage. Proceeding with research...")
+            return self._continue_processing_with_plan(plan, use_literature=True)
+        else:
+            # User declined literature use - modify plan to skip literature
+            self._send_thought_to_r("User declined literature usage. Providing response without external literature...")
+            return self._continue_processing_with_plan(plan, use_literature=False)
+
+    def _continue_processing_with_plan(self, plan: dict, use_literature: bool) -> str:
+        """
+        Continue processing with the plan, either with or without literature.
+        This method will execute the plan and return the final response.
+        """
+        try:
+            if not use_literature:
+                # Modify the plan to remove literature components
+                plan = self._remove_literature_from_plan(plan)
+            
+            # Execute the plan
+            if plan.get("status") == "CODE_COMPLETE":
+                # Plan is already complete, return the explanation
+                return plan.get("explanation", "Processing completed.")
+            elif plan.get("status") in ["AWAITING_DATA", "AWAITING_ANALYSIS_CODE"]:
+                # Plan needs code execution
+                return self._execute_plan_code(plan)
+            else:
+                # Unknown status, return explanation
+                return plan.get("explanation", "Processing completed with unknown status.")
+                
+        except Exception as e:
+            error_msg = f"Error continuing with plan: {str(e)}"
+            print(f"[ManagerAgent] {error_msg}")
+            return error_msg
+
+    def _execute_plan_code(self, plan: dict) -> str:
+        """
+        Execute the code in the plan and return the result.
+        This uses the supervisor and executor agents to safely run the code.
+        """
+        try:
+            code_to_execute = plan.get("python_code", "").strip()
+            if not code_to_execute:
+                return "No code to execute."
+            
+            if not self.supervisor_agent or not self.executor_agent:
+                return "Cannot execute code, Supervisor or Executor agent is missing."
+            
+            # Have supervisor review the code
+            self._send_thought_to_r("Reviewing code for safety...")
+            review = self.supervisor_agent.review_code(code_to_execute, f"Reviewing user-approved plan: {plan.get('thought', '')}")
+            supervisor_status = review.get('safety_status', 'UNKNOWN_STATUS')
+            supervisor_feedback = review.get('safety_feedback', 'No feedback.')
+            
+            print(f"[ManagerAgent] Code Review: {supervisor_feedback} (Status: {supervisor_status})")
+            self._send_thought_to_r(f"Code review: {supervisor_status} - {supervisor_feedback}")
+            
+            if supervisor_status != "APPROVED_FOR_EXECUTION":
+                return f"Code execution blocked by supervisor: {supervisor_feedback}"
+            
+            # Execute the code
+            self._send_thought_to_r("Executing code...")
+            execution_result = self.executor_agent.execute_code(code_to_execute)
+            execution_output = execution_result.get("execution_output", "")
+            execution_status = execution_result.get("execution_status", "UNKNOWN")
+            
+            if execution_status == "SUCCESS":
+                self._send_thought_to_r(f"Code execution successful. Processing results...")
+                
+                # If this is literature search, we need to continue processing
+                if "intermediate_data_for_llm" in execution_output:
+                    # Add the results to conversation history
+                    self.conversation_history.append({"role": "assistant", "content": f"```json\n{execution_output}\n```"})
+                    
+                    # Call GenerationAgent again to process the results
+                    self._send_thought_to_r("Processing literature search results...")
+                    followup_plan = self.generation_agent.generate_code_plan(
+                        user_query="Process the literature search results",
+                        conversation_history=self.conversation_history,
+                        image_file_id_for_prompt=None,
+                        previous_attempts_feedback=None
+                    )
+                    
+                    return followup_plan.get("explanation", "Literature search completed and processed.")
+                else:
+                    return execution_output
+            else:
+                return f"Code execution failed: {execution_output}"
+                
+        except Exception as e:
+            error_msg = f"Error executing plan code: {str(e)}"
+            print(f"[ManagerAgent] {error_msg}")
+            return error_msg
+
     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.

cache_data/excel_schema_cache.json

@@ -0,0 +1,6 @@
+{
+    "freshness_signature": {
+        "multi-omicsdata.xlsx": 1748219732.5558078
+    },
+    "formatted_schema_string": "DYNAMICALLY DISCOVERED EXCEL SCHEMAS (first sheet columns shown):\n- File: 'www\\multi-omicsdata.xlsx' (Identifier: 'multi_omicsdata')\n  Sheets: [Dataset detail, specific TF-Taiji, newspecific TF-Taiji, Validation list, T cell differentiation map, Kay nanostring panel, Meeting summary, Kays wetlab to do, Wang Lab work to do, Philip et al. 2017 Nature sampl, T cell migration associated gen, KO EX-> proEX, Reprogramming MP -> TRM, Reprogramming TEX -> TRM, Reprogramming TEX -> proEX]\n  Columns (first sheet): [Author, Lab, Year, DOI, Accession, Data type, Species, Infection, Naive, MP (MPEC), ... (total 23 columns)]\n- File: 'www\\networkanalysis\\comp_log2FC_RegulatedData_TRMTEXterm.xlsx' (Identifier: 'comp_log2FC_RegulatedData_TRMTEXterm')\n  Sheets: [Worksheet]\n  Columns (first sheet): [Unnamed: 0, Ahr, Arid3a, Arnt, Arntl, Atf1, Atf2, Atf3, Atf4, Atf7, ... (total 199 columns)]\n- File: 'www\\old files\\log2FC_RegulatedData_TRMTEXterm.xlsx' (Identifier: 'log2FC_RegulatedData_TRMTEXterm')\n  Sheets: [Worksheet]\n  Columns (first sheet): [Unnamed: 0, Ahr, Arid3a, Arnt, Arntl, Atf1, Atf2, Atf3, Atf4, Atf7, ... (total 199 columns)]\n- File: 'www\\tablePagerank\\MP.xlsx' (Identifier: 'MP')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tablePagerank\\Naive.xlsx' (Identifier: 'Naive')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tablePagerank\\Table_TF PageRank Scores for Audrey.xlsx' (Identifier: 'Table_TF_PageRank_Scores_for_Audrey')\n  Sheets: [Fig_1F (Multi state-specific TF, Fig_1G (Single state-specific T]\n  Columns (first sheet): [Unnamed: 0, Category, Cell-state specificity, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, ... (total 45 columns)]\n- File: 'www\\tablePagerank\\TCM.xlsx' (Identifier: 'TCM')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tablePagerank\\TE.xlsx' (Identifier: 'TE')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tablePagerank\\TEM.xlsx' (Identifier: 'TEM')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tablePagerank\\TEXeff.xlsx' (Identifier: 'TEXeff')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tablePagerank\\TEXprog.xlsx' (Identifier: 'TEXprog')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tablePagerank\\TEXterm.xlsx' (Identifier: 'TEXterm')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tablePagerank\\TRM.xlsx' (Identifier: 'TRM')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF, Naive_Kaech_Kaech, Naive_Kaech_Chung, Naive_Mackay_Chung, Naive_MilnerAug_Chung, Naive_Renkema_Chung, Naive_Scott_Scott, MP_Kaech_Chung, MP_Kaech_Kaech, MP_Kaech_Scott, ... (total 43 columns)]\n- File: 'www\\tfcommunities\\texcommunities.xlsx' (Identifier: 'texcommunities')\n  Sheets: [TEX Communities, TEX_c1, TEX_c2, TEX_c3, TEX_c4, TEX_c5, TRM Communities, TRM_c1, TRM_c2, TRM_c3, TRM_c4, TRM_c5]\n  Columns (first sheet): [TEX Communities, TF Members]\n- File: 'www\\tfcommunities\\trmcommunities.xlsx' (Identifier: 'trmcommunities')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TRM Communities, TF Members]\n- File: 'www\\TFcorintextrm\\TF-TFcorTRMTEX.xlsx' (Identifier: 'TF_TFcorTRMTEX')\n  Sheets: [Sheet1]\n  Columns (first sheet): [TF Name, TF Merged Graph Path]\n- File: 'www\\waveanalysis\\searchtfwaves.xlsx' (Identifier: 'searchtfwaves')\n  Sheets: [Sheet1]\n  Columns (first sheet): [Wave 1, Wave 2, Wave 3, Wave 4, Wave 5, Wave 6, Wave 7]"
+}

server.R

@@ -2119,6 +2119,28 @@ if 'agents.manager_agent' in sys.modules:
 
           print(paste("TaijiChat: Received from Python agent -", agent_reply_text))
           
+          # Check if this is a literature confirmation request
+          if (startsWith(agent_reply_text, "TAIJICHAT_LITERATURE_CONFIRMATION:")) {
+            # Extract the JSON part
+            json_str <- substr(agent_reply_text, 35, nchar(agent_reply_text)) # 35 = length of "TAIJICHAT_LITERATURE_CONFIRMATION:"
+            
+            tryCatch({
+              confirmation_info <- jsonlite::fromJSON(json_str)
+              session$sendCustomMessage(type = "literature_confirmation_request", 
+                                       message = list(
+                                         text = confirmation_info$message,
+                                         type = confirmation_info$type
+                                       ))
+            }, error = function(e) {
+              warning(paste("Failed to parse literature confirmation JSON:", e$message))
+              session$sendCustomMessage(type = "agent_chat_response", 
+                                       message = list(text = "Error processing literature confirmation request."))
+            })
+            
+            # Don't update chat history or send response yet - wait for user confirmation
+            return()
+          }
+          
           # Check if this is an image response
           if (startsWith(agent_reply_text, "TAIJICHAT_IMAGE_RESPONSE:")) {
             # Extract the JSON part - START AFTER THE COLON IN THE PREFIX
@@ -2217,6 +2239,48 @@ if 'agents.manager_agent' in sys.modules:
       print("TaijiChat: Received empty user_chat_message.")
     }
   })
+  
+  # --- Literature Confirmation Handler ---
+  observeEvent(input$literature_confirmation_response, {
+    req(input$literature_confirmation_response)
+    
+    user_response <- input$literature_confirmation_response
+    print(paste("TaijiChat: Received literature confirmation response:", user_response))
+    
+    agent_instance_val <- rv_agent_instance()
+    
+    if (!is.null(agent_instance_val)) {
+      tryCatch({
+        # Call the agent's literature confirmation handler
+        agent_reply_py <- agent_instance_val$handle_literature_confirmation(
+          user_response = as.logical(user_response)
+        )
+        agent_reply_text <- as.character(agent_reply_py)
+        
+        print(paste("TaijiChat: Literature confirmation processed, response:", agent_reply_text))
+        
+        # Update chat history with the agent's response
+        current_hist <- chat_history()
+        final_hist <- append(current_hist, list(list(role = "assistant", content = agent_reply_text)))
+        chat_history(final_hist)
+        
+        # Send the response to UI
+        session$sendCustomMessage(type = "agent_chat_response", message = list(text = agent_reply_text))
+        
+      }, error = function(e) {
+        error_message <- paste("TaijiChat: Error processing literature confirmation:", e$message)
+        warning(error_message)
+        print(error_message)
+        session$sendCustomMessage(type = "agent_chat_response", 
+                                 message = list(text = "Sorry, an error occurred processing your literature preference."))
+      })
+    } else {
+      warning("TaijiChat: Agent instance is NULL during literature confirmation.")
+      session$sendCustomMessage(type = "agent_chat_response", 
+                               message = list(text = "The chat agent is not available for literature confirmation."))
+    }
+  })
+  
   # --- END: TaijiChat Message Handling ---
 
   #Render and hyperlink table + edit size so that everything fits into webpage

www/chat_script.js

@@ -529,4 +529,48 @@ function initializeChatUI() {
        addChatMessage("An unexpected error occurred with the agent.", 'agent-error');
     }
   });
+
+  Shiny.addCustomMessageHandler("literature_confirmation_request", function(message) {
+    console.log("Received literature confirmation request");
+    if (message && typeof message.text === 'string') {
+      showLiteratureConfirmationDialog(message.text);
+    }
+  });
+
+  function showLiteratureConfirmationDialog(messageText) {
+    var $chatMessages = $('#chatMessages');
+    
+    // Create the confirmation dialog box
+    var $confirmationDiv = $('<div></div>').addClass('literature-confirmation-dialog');
+    $confirmationDiv.html(`
+      <div class="confirmation-content">
+        <div class="confirmation-message">${messageText}</div>
+        <div class="confirmation-buttons">
+          <button class="btn btn-success confirmation-yes" onclick="handleLiteratureConfirmation(true)">Yes</button>
+          <button class="btn btn-secondary confirmation-no" onclick="handleLiteratureConfirmation(false)">No</button>
+        </div>
+      </div>
+    `);
+    
+    // Add the dialog to the chat
+    $chatMessages.append($confirmationDiv);
+    $chatMessages.scrollTop($chatMessages[0].scrollHeight);
+    
+    // Disable input while waiting for confirmation
+    $('#chatInput').prop('disabled', true);
+    $('#sendChatMsg').prop('disabled', true);
+  }
+
+  // Global function to handle literature confirmation response
+  window.handleLiteratureConfirmation = function(userChoice) {
+    console.log("Literature confirmation choice:", userChoice);
+    
+    // Remove the confirmation dialog
+    $('.literature-confirmation-dialog').remove();
+    
+    // Send the response to Shiny
+    Shiny.setInputValue("literature_confirmation_response", userChoice, {priority: "event"});
+    
+    // Keep input disabled - it will be re-enabled when the agent responds
+  };
 }

www/chat_styles.css

@@ -158,4 +158,65 @@
   color: #bfa100;
   margin-right: 4px;
   user-select: none;
+}
+
+/* Literature confirmation dialog styles */
+.literature-confirmation-dialog {
+  background-color: #fff3cd;
+  border: 2px solid #ffc107;
+  border-radius: 8px;
+  padding: 15px;
+  margin: 10px 0;
+  box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+  animation: fadeIn 0.3s ease-in;
+}
+
+.confirmation-content {
+  text-align: center;
+}
+
+.confirmation-message {
+  font-size: 14px;
+  color: #856404;
+  margin-bottom: 15px;
+  line-height: 1.4;
+}
+
+.confirmation-buttons {
+  display: flex;
+  gap: 10px;
+  justify-content: center;
+}
+
+.confirmation-buttons .btn {
+  min-width: 60px;
+  font-size: 13px;
+  padding: 6px 12px;
+  border-radius: 4px;
+  cursor: pointer;
+  border: none;
+  transition: background-color 0.2s;
+}
+
+.confirmation-yes {
+  background-color: #28a745;
+  color: white;
+}
+
+.confirmation-yes:hover {
+  background-color: #218838;
+}
+
+.confirmation-no {
+  background-color: #6c757d;
+  color: white;
+}
+
+.confirmation-no:hover {
+  background-color: #545b62;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; transform: translateY(-10px); }
+  to { opacity: 1; transform: translateY(0); }
 }