Update app.py

app.py

@@ -1670,21 +1670,21 @@ def openai_call(prompt: str, messages: list = None, model: str = "o3-mini",
         params = {
             "model": model,
             "messages": messages,
+            "temperature": temperature
         }
         # Note: Adjust token names based on the model
         if model == "o3-mini":
             params["max_completion_tokens"] = max_tokens_param
         else:
             params["max_tokens"] = max_tokens_param
-            params["temperature"] = temperature
         response = client.chat.completions.create(**params)
-        result = response.choices[0].message.content.strip()
+        result = response.choices[0].message.content
+        result = result.strip().strip("json").strip("```").strip()
         
         if not result:
             logging.error("Empty response from LLM for prompt: " + prompt)
             return "Error: empty response"
         
-        result = result.strip().strip("json").strip("```").strip()
         logging.info(f"openai_call completed with model {model}. Response preview: {result}")
         return result
     except Exception as e:
@@ -2324,26 +2324,24 @@ Thet list of engines selected is the following:
 
 Now generate the result.
     """
-    messages = []  # Use prompt directly in openai_call, messages is handled there.
-    llm_response = openai_call(prompt=prompt, messages=messages, model="o3-mini", temperature=0, max_tokens_param=50)
+    messages = []
+    llm_response = openai_call(prompt=prompt, model="o3-mini", temperature=0, max_tokens_param=50)
     logging.info(f"Generated query tree: {llm_response}")
-    cleaned_response = llm_response.strip()
-    if cleaned_response.startswith("```"):
-        cleaned_response = cleaned_response.strip("`").strip()
+    cleaned_response = llm_response.strip().strip("`").strip()
     try:
         queries = json.loads(cleaned_response)['queries']
-        final_queries = queries[:min(len(queries), breadth)]  # Ensures the output respect the breadth parameter.
+        final_queries = queries[:min(len(queries), breadth)]
     except (json.JSONDecodeError, KeyError, TypeError) as e:
         logging.error(f"Error parsing LLM response in generate_query_tree: {e}")
         final_queries = []  # Return empty list if parsing fails
         return final_queries
 
-    logging.info(f"generate_query_tree: Generated queries: {final_queries}")
     return final_queries
 
 def generate_serp_queries(context: str, breadth: int, depth: int, initial_query: str,
                           selected_engines=None, results_per_query: int = 10) -> list:
     queries = generate_query_tree(context, breadth, depth, selected_engines)
+    logging.info(f"Queries generated from generate_query_tree:{queries}")
     prompt = f"""The research topic is: "{initial_query}".
 Based on this query and the overall context: "{context}", suggest one or several languages (other than English) that might be relevant.
 
@@ -2369,6 +2367,8 @@ Which are most relevant? Output a comma separated list (e.g., "google,baidu").
 If none are found, output "google".
 """
         identified_engines = openai_call(prompt_engines, model="o3-mini", temperature=0, max_tokens_param=50)
+        logging.info(f"Identified engines are:{identified_engines}")
+
         # Split and strip engines; if result is empty (or all empty strings), default to ["google"]
         selected_engines = [e.strip() for e in identified_engines.split(",") if e.strip()]
         if not selected_engines: