Update utils/response_manager.py

utils/response_manager.py

@@ -76,19 +76,16 @@ class ResponseManager:
         logging.info(f"Meta prompt loaded successfully from '{meta_prompt_file}'.")
         return meta_prompt
 
-    def create_response(self, query: str, 
-                        model: Optional[str] = None,
-                        temperature: Optional[float] = None,
-                        max_output_tokens: Optional[int] = None,
-                        max_num_results: Optional[int] = None) -> str:
+    def generate_response(self, query: str, history: list) -> list:
         """
-        Create a response to a user query using the OpenAI API.
-        :param query: The user query to respond to.
-        :param model: The OpenAI model to use (default is "gpt-4o-mini").
-        :param temperature: The temperature for the response (default is 0).
-        :param max_output_tokens: The maximum number of output tokens (default is 800).
-        :param max_num_results: The maximum number of search results to return (default is 15).
-        :return: The response text from the OpenAI API.
+        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.
+        It supports optional parameters for model configuration and handles errors gracefully.
+        Args:
+            query (str): The user query to respond to.
+            history (list): The conversation history from the chatbot.
+        Returns:
+            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 self.previous_response_id is None else []
@@ -99,80 +96,31 @@ 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 input_data
-        
-        # Set default values for optional parameters
-        model = model or self.DEFAULT_MODEL
-        temperature = temperature if temperature is not None else self.DEFAULT_TEMPERATURE
-        max_output_tokens = max_output_tokens if max_output_tokens is not None else self.DEFAULT_MAX_OUTPUT_TOKENS
-        max_num_results = max_num_results if max_num_results is not None else self.DEFAULT_MAX_NUM_RESULTS
+            return history + input_data
 
         try:
             logging.info("Sending request to OpenAI API...")
             response = self.client.responses.create(
-                model=model,
+                model=self.DEFAULT_MODEL,
                 previous_response_id=self.previous_response_id,
                 input=input_data,
                 tools=[{
                     "type": "file_search",
                     "vector_store_ids": [self.vector_store_id],
-                    "max_num_results": max_num_results
+                    "max_num_results": self.DEFAULT_MAX_NUM_RESULTS
                 }],
-                temperature=temperature,
-                max_output_tokens=max_output_tokens
+                temperature=self.DEFAULT_TEMPERATURE,
+                max_output_tokens=self.DEFAULT_MAX_OUTPUT_TOKENS
             )
             self.previous_response_id = response.id
             logging.info("Response received successfully.")
             input_data.append({"role": "assistant", "content": response.output_text})
-            return input_data
+            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 input_data
+            return history + input_data
 
-    def conversation(self, query: str, history: list,
-                     model: Optional[str] = None,
-                     temperature: Optional[float] = None, 
-                     max_output_tokens: Optional[int] = None,
-                     max_num_results: Optional[int] = None
-                     ) -> list:
-        """
-        Function to handle the chatbot interaction and maintain conversation history.
-        :param query: The user query to respond to.
-        :param model: The OpenAI model to use (default is "gpt-4o-mini").
-        :param temperature: The temperature for the response (default is 0).
-        :param max_output_tokens: The maximum number of output tokens (default is 800).
-        :param max_num_results: The maximum number of search results to return (default is 15).
-        :param history: The conversation history (list of [input, output] pairs).
-        :return: Updated conversation history.
-        """
-        logging.info("Received query: %s", query)
-
-        try:
-            # Set default values for optional parameters
-            model = model or self.DEFAULT_MODEL
-            temperature = temperature if temperature is not None else self.DEFAULT_TEMPERATURE
-            max_output_tokens = max_output_tokens if max_output_tokens is not None else self.DEFAULT_MAX_OUTPUT_TOKENS
-            max_num_results = max_num_results if max_num_results is not None else self.DEFAULT_MAX_NUM_RESULTS
-
-            # Generate a response using the create_response method
-            logging.info("Generating response for the query...")
-            response = self.create_response(
-                query=query,
-                model=model,
-                temperature=temperature,
-                max_output_tokens=max_output_tokens,
-                max_num_results=max_num_results
-            )
-            # Append the user query and response to the conversation history
-            history += response
-            return history
-
-        except Exception as e:
-            # Log the error and append it to the conversation history
-            logging.error("An error occurred while generating a response: %s", str(e))
-            # history.append((query, f"An error occurred: {str(e)}"))
-            return history