Rename utils/session_history2.py to utils/session_history3.py

utils/{session_history2.py → session_history3.py}

@@ -40,7 +40,7 @@ class ResponseManager:
 
         # Initialize other attributes
         self.meta_prompt_file = meta_prompt_file or 'config/meta_prompt.txt'
-        # self.previous_response_id = None
+        self.previous_response_id = None
 
         # Initialize the OpenAI client
         self.client = openai.OpenAI(api_key=self.api_key)
@@ -54,6 +54,12 @@ class ResponseManager:
         self.max_output_tokens = max_output_tokens
         self.max_num_results = max_num_results
 
+    def reset_conversation(self):
+        """
+        Reset the conversation state internally maintained by OpenAI Response API.
+        """
+        self.previous_response_id = None
+
     def _load_meta_prompt(self, meta_prompt_file: str) -> str:
         """
         Load the meta prompt from the specified file.
@@ -68,7 +74,7 @@ class ResponseManager:
         logging.info(f"Meta prompt loaded successfully from '{meta_prompt_file}'.")
         return meta_prompt
 
-    def generate_response(self, query: str, history: list, previous_response_id: Optional[str] = None) -> list:
+    def generate_response(self, query: str, history: list) -> list:
         """
         Generate a response to a user query using the OpenAI API.
         This method interacts with the OpenAI API to create a response based on the user's query.
@@ -80,7 +86,7 @@ class ResponseManager:
             list: A list of dictionaries representing the conversation, including the generated response.
         """
         # Prepare the input for the API call
-        input_data = [{"role": "developer", "content": self.meta_prompt}] if previous_response_id is None else []#if self.previous_response_id is None else []
+        input_data = [{"role": "developer", "content": self.meta_prompt}] if self.previous_response_id is None else []
         input_data.append({"role": "user", "content": query})
         
         # Validate the query
@@ -88,13 +94,13 @@ class ResponseManager:
             logging.warning("Empty or invalid query received.")
             warning_message = "Please enter a valid query."
             input_data.append({"role": "assistant", "content": warning_message})
-            return history + input_data, previous_response_id
+            return history + input_data
 
         try:
             logging.info("Sending request to OpenAI API...")
             response = self.client.responses.create(
                 model=self.model,
-                previous_response_id=sprevious_response_id,#self.previous_response_id,
+                previous_response_id=self.previous_response_id,
                 input=input_data,
                 tools=[{
                     "type": "file_search",
@@ -108,13 +114,13 @@ class ResponseManager:
             self.previous_response_id = response.id
             logging.info("Response received successfully.")
             input_data.append({"role": "assistant", "content": response.output_text})
-            return history + input_data, previous_response_id
+            return history + input_data
 
         except Exception as e:
             logging.error(f"An error occurred while generating a response: {e}")
             error_message = "Sorry, I couldn't generate a response at this time. Please try again later."
             input_data.append({"role": "assistant", "content": error_message})
-            return history + input_data, previous_response_id 
+            return history + input_data
             
 import os
 import json
@@ -150,29 +156,15 @@ class ChatbotInterface:
         self.input_placeholder = self.config["chatbot_input_placeholder"]
         self.output_label = self.config["chatbot_output_label"]
 
-        # Initialize ResponseManager with custom parameters
-        try:
-            self.response_manager = ResponseManager(
-                model=model,
-                temperature=temperature,
-                max_output_tokens=max_output_tokens,
-                max_num_results=max_num_results,
-                vector_store_id=vector_store_id,
-                api_key=api_key,
-                meta_prompt_file=meta_prompt_file
-            ) 
-            
-            logging.info(
-                "ChatbotInterface initialized with the following parameters:\n"
-                f"  - Model: {model}\n"
-                f"  - Temperature: {temperature}\n"
-                f"  - Max Output Tokens: {max_output_tokens}\n"
-                f"  - Max Number of Results: {max_num_results}\n"
-            )
-            
-        except Exception as e:
-            logging.error(f"Failed to initialize ResponseManager: {e}")
-            raise
+        # Parameters for ResponseManager class 
+        self.model = model
+        self.temperature = temperature
+        self.max_output_tokens = max_output_tokens
+        self.max_num_results = max_num_results
+        self.vector_store_id = vector_store_id
+        self.api_key = api_key
+        self.meta_prompt_file = meta_prompt_file
+        
            
     @staticmethod
     def load_config(config_path: str) -> dict:
@@ -223,9 +215,9 @@ class ChatbotInterface:
             # # Session-specific state to store conversation history.
             # conversation_state = gr.State([])
 
-            # Create session states for history and previous_response_id
+            # Session-specific states
             conversation_state = gr.State([])
-            previous_response_id_state = gr.State(None)
+            response_manager_state = gr.State(None)
 
             # Use a gr.Row container as the input box with an integrated submit button.
             with gr.Row(elem_id="input-container", equal_height=True):
@@ -243,41 +235,62 @@ class ChatbotInterface:
                     size="lg"
                 )
 
-            # Define a local function to reset input  
-            def reset_output() -> list:
-                """
-                Reset the chatbot output.
-                :return: An empty list to reset the output.
-                """
-                return [], [], None, ""  # [chatbot_output, conversation_state, previous_response_id_state, cleared input]
+            # 🟢 Initialization function for session-specific response manager
+            def init_response_manager():
+                try:
+                    rm = ResponseManager(
+                            model=self.model,
+                            temperature=self.temperature,
+                            max_output_tokens=self.max_output_tokens,
+                            max_num_results=self.max_num_results,
+                            vector_store_id=self.vector_store_id,
+                            api_key=self.api_key,
+                            meta_prompt_file=self.meta_prompt_file
+                        )
                 
-            # Define a local function to process input
-            def process_input(user_message, chat_history, previous_response_id_state):
-                """
-                Call generate_response with the user's message and chat history.
-                Return a tuple with the updated chat history and an empty string to clear the input.
-                """
-                updated_history, new_previous_id = self.response_manager.generate_response(
-                    user_message, 
-                    chat_history, 
-                    previous_response_id
-                )
-                return updated_history, updated_history, new_previous_id, "" # [chatbot_output, conversation_state, previous_response_id_state, user_input]
-                # updated_history = self.response_manager.generate_response(user_message, chat_history)
-                # return updated_history, updated_history, ""  
+                    logging.info(
+                        "ChatbotInterface initialized with the following parameters:\n"
+                        f"  - Model: {self.model}\n"
+                        f"  - Temperature: {self.temperature}\n"
+                        f"  - Max Output Tokens: {self.max_output_tokens}\n"
+                        f"  - Max Number of Results: {self.max_num_results}\n"
+                    )
+                    
+                    rm.reset_conversation()
+                    return rm
+                except Exception as e:
+                    logging.error(f"Failed to initialize ResponseManager: {e}")
+                    raise
+
+            # 🟢 Reset function updated to reset ResponseManager
+            def reset_output():
+                response_manager = init_response_manager()
+                return [], response_manager, ""
+    
+            # 🟢 Process input now uses session-specific ResponseManager
+            def process_input(user_message, chat_history, response_manager):
+                updated_history = response_manager.generate_response(user_message, chat_history)
+                return updated_history, updated_history, response_manager, ""
+    
+            # Initialize ResponseManager on load
+            demo.load(
+                fn=init_response_manager,
+                inputs=None,
+                outputs=response_manager_state
+            )
+
             
-            # Bind the reset button click to the reset function
+
             reset.click(
                 fn=reset_output,
                 inputs=None,
-                outputs=[chatbot_output, conversation_state, previous_response_id_state, user_input]
+                outputs=[chatbot_output, response_manager_state, user_input]
             )
-            
-            # Bind the Enter key (textbox submit) to the same processing function
+    
             user_input.submit(
                 fn=process_input,
-                inputs=[user_input, conversation_state, previous_response_id_state],#[user_input, chatbot_output],
-                outputs=[chatbot_output, conversation_state, previous_response_id_state, user_input]
+                inputs=[user_input, conversation_state, response_manager_state],
+                outputs=[chatbot_output, conversation_state, response_manager_state, user_input]
             )
 
         logging.info("Gradio interface created successfully.")