requirements update for llm compat

app.py

@@ -209,23 +209,24 @@ def log_message(message: BaseMessage, prefix: str = ""):
 
 class BasicAgent:
     def __init__(self):
-        # Initialize primary LLM (Gemini)
-        self.primary_llm = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash-preview-05-20",
-            max_tokens=8192,
-            temperature=0,
-            convert_system_message_to_human=True  # Enable system message conversion
-        )
-        
-        # Initialize fallback LLM (if available)
-        self.fallback_llm = None
+        # Initialize primary LLM (OpenAI)
         if os.getenv("OPENAI_API_KEY"):
             from langchain_openai import ChatOpenAI
-            self.fallback_llm = ChatOpenAI(
+            self.primary_llm = ChatOpenAI(
                 model="gpt-3.5-turbo",
                 temperature=0,
                 max_tokens=4096
             )
+        else:
+            self.primary_llm = None
+            
+        # Initialize fallback LLM (Gemini)
+        self.fallback_llm = ChatGoogleGenerativeAI(
+            model="gemini-2.5-flash-preview-05-20",
+            max_tokens=8192,
+            temperature=0,
+            convert_system_message_to_human=True  # Enable system message conversion
+        )
         
         # Create tool executor
         self.tools = {
@@ -301,42 +302,82 @@ class BasicAgent:
                 for msg in messages:
                     log_message(msg, "  ")
                 
-                # Try primary LLM first
+                # Try primary LLM first (OpenAI)
                 try:
-                    # Convert system message to human message for Gemini
-                    if isinstance(self.sys_msg, SystemMessage):
-                        system_content = f"System Instructions: {self.sys_msg.content}"
-                        messages_with_system = [HumanMessage(content=system_content)] + messages
-                    else:
-                        messages_with_system = [self.sys_msg] + messages
-                    
-                    # Create tool configuration for Gemini
-                    genai_tool = {
-                        "function_declarations": [{
-                            "name": "google_search",
-                            "description": "Search for information on the web",
-                            "parameters": {
-                                "type": "object",
-                                "properties": {
-                                    "query": {
-                                        "type": "string",
-                                        "description": "The search query"
-                                    }
-                                },
-                                "required": ["query"]
+                    if self.primary_llm is None:
+                        raise ValueError("Primary LLM not initialized")
+                        
+                    logger.info("Attempting to use primary LLM (OpenAI)")
+                    # For OpenAI, we can use the system message directly
+                    response = self.primary_llm.invoke(
+                        [self.sys_msg] + messages,
+                        tools=[{
+                            "type": "function",
+                            "function": {
+                                "name": "google_search",
+                                "description": "Search for information on the web",
+                                "parameters": {
+                                    "type": "object",
+                                    "properties": {
+                                        "query": {
+                                            "type": "string",
+                                            "description": "The search query"
+                                        }
+                                    },
+                                    "required": ["query"]
+                                }
                             }
                         }]
-                    }
+                    )
+                    
+                    if not response or not hasattr(response, 'content'):
+                        raise ValueError("Invalid response format from OpenAI")
+                        
+                    # Check if response contains tool call
+                    if hasattr(response, 'tool_calls') and response.tool_calls:
+                        logger.info("Successfully used primary LLM with tools")
+                        return {"messages": [response], "next": "tools"}
+                    else:
+                        # If no tool call, try without tools
+                        response = self.primary_llm.invoke([self.sys_msg] + messages)
+                        if not response or not hasattr(response, 'content'):
+                            raise ValueError("Invalid response format from OpenAI")
+                        logger.info("Successfully used primary LLM without tools")
+                        
+                except Exception as e:
+                    error_str = str(e)
+                    logger.error(f"Primary LLM error: {error_str}")
                     
-                    logger.info("Attempting to use primary LLM (Gemini)")
+                    # Try fallback LLM (Gemini)
                     try:
-                        # First try with explicit tool usage prompt
-                        messages_with_tool_prompt = messages_with_system + [
-                            HumanMessage(content="Please use the google_search tool to find information about Mercedes Sosa's studio albums between 2000 and 2009.")
-                        ]
+                        logger.info("Attempting to use fallback LLM (Gemini)")
+                        # Convert system message to human message for Gemini
+                        if isinstance(self.sys_msg, SystemMessage):
+                            system_content = f"System Instructions: {self.sys_msg.content}"
+                            messages_with_system = [HumanMessage(content=system_content)] + messages
+                        else:
+                            messages_with_system = [self.sys_msg] + messages
+                        
+                        # Create tool configuration for Gemini
+                        genai_tool = {
+                            "function_declarations": [{
+                                "name": "google_search",
+                                "description": "Search for information on the web",
+                                "parameters": {
+                                    "type": "object",
+                                    "properties": {
+                                        "query": {
+                                            "type": "string",
+                                            "description": "The search query"
+                                        }
+                                    },
+                                    "required": ["query"]
+                                }
+                            }]
+                        }
                         
-                        response = self.primary_llm.invoke(
-                            messages_with_tool_prompt,
+                        response = self.fallback_llm.invoke(
+                            messages_with_system,
                             tools=[genai_tool]
                         )
                         
@@ -344,99 +385,28 @@ class BasicAgent:
                             raise ValueError("Invalid response format from Gemini")
                             
                         # Check if response contains tool call
-                        if not hasattr(response, 'tool_calls') or not response.tool_calls:
-                            # If no tool call, try without tools
-                            response = self.primary_llm.invoke(messages_with_tool_prompt)
-                            if not response or not hasattr(response, 'content'):
-                                raise ValueError("Invalid response format from Gemini")
-                            logger.info("Successfully used primary LLM without tools")
+                        if hasattr(response, 'tool_calls') and response.tool_calls:
+                            logger.info("Successfully used fallback LLM with tools")
+                            return {"messages": [response], "next": "tools"}
                         else:
-                            logger.info("Successfully used primary LLM with tools")
-                            
-                    except Exception as e:
-                        error_str = str(e)
-                        if "429" in error_str:
-                            # Handle rate limit
-                            logger.warning("Rate limit hit for Gemini, waiting before retry...")
-                            time.sleep(60)  # Wait 60 seconds before retry
-                            raise
-                        elif "list index out of range" in error_str:
-                            # Try without tools if tool configuration fails
-                            response = self.primary_llm.invoke(messages_with_system)
+                            # If no tool call, try without tools
+                            response = self.fallback_llm.invoke(messages_with_system)
                             if not response or not hasattr(response, 'content'):
                                 raise ValueError("Invalid response format from Gemini")
-                            logger.info("Successfully used primary LLM without tools")
-                        else:
-                            raise
-                    
-                except Exception as e:
-                    error_str = str(e)
-                    logger.error(f"Primary LLM error: {error_str}")
-                    
-                    # Check if we should try fallback
-                    if hasattr(self, 'fallback_llm') and self.fallback_llm is not None:
-                        try:
-                            logger.info("Attempting to use fallback LLM (OpenAI)")
-                            # Add explicit tool usage prompt
-                            messages_with_tool_prompt = [self.sys_msg] + messages + [
-                                HumanMessage(content="Please use the google_search tool to find information about Mercedes Sosa's studio albums between 2000 and 2009.")
-                            ]
+                            logger.info("Successfully used fallback LLM without tools")
                             
-                            # For OpenAI, we can use the system message directly
-                            response = self.fallback_llm.invoke(
-                                messages_with_tool_prompt,
-                                tools=[{
-                                    "type": "function",
-                                    "function": {
-                                        "name": "google_search",
-                                        "description": "Search for information on the web",
-                                        "parameters": {
-                                            "type": "object",
-                                            "properties": {
-                                                "query": {
-                                                    "type": "string",
-                                                    "description": "The search query"
-                                                }
-                                            },
-                                            "required": ["query"]
-                                        }
-                                    }
-                                }]
-                            )
-                            
-                            if not response or not hasattr(response, 'content'):
-                                raise ValueError("Invalid response format from fallback LLM")
-                                
-                            # Check if response contains tool call
-                            if not hasattr(response, 'tool_calls') or not response.tool_calls:
-                                # If no tool call, try without tools
-                                response = self.fallback_llm.invoke(messages_with_tool_prompt)
-                                if not response or not hasattr(response, 'content'):
-                                    raise ValueError("Invalid response format from fallback LLM")
-                                logger.info("Successfully used fallback LLM without tools")
-                            else:
-                                logger.info("Successfully used fallback LLM with tools")
-                        except Exception as fallback_error:
-                            logger.error(f"Fallback LLM error: {str(fallback_error)}")
-                            if "429" in str(fallback_error):
-                                return {
-                                    "messages": [AIMessage(content="All LLM services are currently rate limited. Please try again later.")], 
-                                    "next": END
-                                }
-                            else:
-                                return {
-                                    "messages": [AIMessage(content="All LLM services are currently unavailable. Please try again later.")], 
-                                    "next": END
-                                }
-                    else:
-                        # If no fallback available or error not related to rate limits
-                        if "429" in error_str:
-                            wait_time = 60 * (retry_count + 1)  # Exponential backoff
-                            logger.warning(f"Rate limit hit, waiting {wait_time} seconds before retry...")
-                            time.sleep(wait_time)
-                            raise  # Re-raise to trigger retry
+                    except Exception as fallback_error:
+                        logger.error(f"Fallback LLM error: {str(fallback_error)}")
+                        if "429" in str(fallback_error):
+                            return {
+                                "messages": [AIMessage(content="All LLM services are currently rate limited. Please try again later.")], 
+                                "next": END
+                            }
                         else:
-                            raise
+                            return {
+                                "messages": [AIMessage(content="All LLM services are currently unavailable. Please try again later.")], 
+                                "next": END
+                            }
                 
                 logger.info("\n=== Model Output ===")
                 log_message(response, "  ")
@@ -445,41 +415,37 @@ class BasicAgent:
                     logger.error("Empty response from model")
                     raise ValueError("Empty response from model")
                 
-                # Check if the response contains a tool call
-                if hasattr(response, 'tool_calls') and response.tool_calls:
-                    return {"messages": [response], "next": "tools"}
+                # Process the response content
+                content = response.content.strip()
+                
+                # If the model is just acknowledging or explaining, prompt it to use the tool
+                if any(phrase in content.lower() for phrase in ["let me", "i'll", "i will", "sure", "okay", "alright"]):
+                    logger.info("Model provided acknowledgment instead of tool call, prompting for search")
+                    return {
+                        "messages": messages + [
+                            AIMessage(content="Please use the google_search tool to find the information."),
+                            HumanMessage(content="Please search for the information using the google_search tool.")
+                        ],
+                        "next": "agent"
+                    }
+                
+                # Clean up the content to ensure it's in the correct format
+                if content.startswith("**Final Answer**: "):
+                    content = content.replace("**Final Answer**: ", "").strip()
+                
+                # For numbers, ensure they're in the correct format
+                if content.replace(".", "").isdigit():
+                    # Remove any decimal places for whole numbers
+                    if float(content).is_integer():
+                        content = str(int(float(content)))
+                
+                # Check if the content is a valid final answer
+                if content.isdigit() or (content.startswith('[') and content.endswith(']')):
+                    return {"messages": [AIMessage(content=content)], "next": END}
                 else:
-                    # If no tool call, check if it's a final answer
-                    content = response.content.strip()
-                    
-                    # If the model is just acknowledging or explaining, prompt it to use the tool
-                    if any(phrase in content.lower() for phrase in ["let me", "i'll", "i will", "sure", "okay", "alright"]):
-                        logger.info("Model provided acknowledgment instead of tool call, prompting for search")
-                        return {
-                            "messages": messages + [
-                                AIMessage(content="Please use the google_search tool to find the information."),
-                                HumanMessage(content="Please search for the information using the google_search tool.")
-                            ],
-                            "next": "agent"
-                        }
+                    # If not a final answer, continue the conversation
+                    return {"messages": [response], "next": "agent"}
                     
-                    # Clean up the content to ensure it's in the correct format
-                    if content.startswith("**Final Answer**: "):
-                        content = content.replace("**Final Answer**: ", "").strip()
-                    
-                    # For numbers, ensure they're in the correct format
-                    if content.replace(".", "").isdigit():
-                        # Remove any decimal places for whole numbers
-                        if float(content).is_integer():
-                            content = str(int(float(content)))
-                    
-                    # Check if the content is a valid final answer
-                    if content.isdigit() or (content.startswith('[') and content.endswith(']')):
-                        return {"messages": [AIMessage(content=content)], "next": END}
-                    else:
-                        # If not a final answer, continue the conversation
-                        return {"messages": [response], "next": "agent"}
-                        
             except Exception as e:
                 last_error = e
                 retry_count += 1