latest requirements

app.py

@@ -16,6 +16,8 @@ import operator
 from langgraph.prebuilt import ToolExecutor
 from langchain_core.tools import tool
 from utilities import get_file
+import time
+from tenacity import retry, stop_after_attempt, wait_exponential
 
 # Constants
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
@@ -144,45 +146,93 @@ class BasicAgent:
         
         print("BasicAgent initialized.")
     
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=60))
     def call_model(self, state: AgentState) -> AgentState:
-        """Call the model to generate a response."""
-        messages = state["messages"]
-        response = self.llm.invoke([self.sys_msg] + messages)
-        return {"messages": [response], "next": "tools"}
+        """Call the model to generate a response with retry logic."""
+        try:
+            messages = state["messages"]
+            response = self.llm.invoke([self.sys_msg] + messages)
+            
+            if not response or not response.content:
+                print("Empty response from model, retrying...")
+                raise ValueError("Empty response from model")
+                
+            return {"messages": [response], "next": "tools"}
+        except Exception as e:
+            print(f"Error in call_model: {str(e)}")
+            if "429" in str(e):
+                print("Rate limit hit, waiting before retry...")
+                time.sleep(60)  # Wait for 60 seconds before retry
+            raise
     
     def call_tools(self, state: AgentState) -> AgentState:
         """Call the tools based on the model's response."""
-        messages = state["messages"]
-        last_message = messages[-1]
-        
-        if isinstance(last_message, AIMessage):
-            # Extract tool calls from the message
-            tool_calls = last_message.tool_calls
-            if tool_calls:
-                for tool_call in tool_calls:
-                    tool_name = tool_call.name
-                    tool_args = tool_call.args
-                    result = self.tool_executor.invoke(tool_name, tool_args)
-                    messages.append(AIMessage(content=f"Tool result: {result}"))
-        
-        return {"messages": messages, "next": "agent"}
+        try:
+            messages = state["messages"]
+            last_message = messages[-1]
+            
+            if isinstance(last_message, AIMessage):
+                # Extract tool calls from the message
+                tool_calls = last_message.tool_calls
+                if tool_calls:
+                    for tool_call in tool_calls:
+                        try:
+                            tool_name = tool_call.name
+                            tool_args = tool_call.args
+                            result = self.tool_executor.invoke(tool_name, tool_args)
+                            messages.append(AIMessage(content=f"Tool result: {result}"))
+                        except Exception as e:
+                            print(f"Error executing tool {tool_name}: {str(e)}")
+                            messages.append(AIMessage(content=f"Tool error: {str(e)}"))
+            
+            return {"messages": messages, "next": "agent"}
+        except Exception as e:
+            print(f"Error in call_tools: {str(e)}")
+            return {"messages": messages, "next": "agent"}
     
     async def __call__(self, question: str, task_id: str) -> str:
-        """Process a question and return the answer."""
+        """Process a question and return the answer with error handling."""
         print(f"Agent received question (first 50 chars): {question[:50]}...")
         
-        # Create initial state
-        initial_state = {
-            "messages": [HumanMessage(content=f'Task id: {task_id}\n {question}')],
-            "next": "agent"
-        }
-        
-        # Process through the graph
-        result = self.app.invoke(initial_state)
-        
-        # Extract the final answer
-        final_message = result["messages"][-1]
-        return final_message.content if isinstance(final_message, AIMessage) else "No answer generated."
+        try:
+            # Create initial state
+            initial_state = {
+                "messages": [HumanMessage(content=f'Task id: {task_id}\n {question}')],
+                "next": "agent"
+            }
+            
+            # Process through the graph with retry logic
+            max_retries = 3
+            retry_count = 0
+            last_error = None
+            
+            while retry_count < max_retries:
+                try:
+                    result = self.app.invoke(initial_state)
+                    final_message = result["messages"][-1]
+                    
+                    if isinstance(final_message, AIMessage) and final_message.content:
+                        return final_message.content
+                    else:
+                        raise ValueError("Empty or invalid response")
+                        
+                except Exception as e:
+                    last_error = e
+                    retry_count += 1
+                    if "429" in str(e):
+                        wait_time = 60 * retry_count
+                        print(f"Rate limit hit, waiting {wait_time} seconds before retry {retry_count}/{max_retries}")
+                        await asyncio.sleep(wait_time)
+                    else:
+                        print(f"Error in processing, retry {retry_count}/{max_retries}: {str(e)}")
+                        await asyncio.sleep(5)
+            
+            print(f"All retries failed. Last error: {str(last_error)}")
+            return "Unable to generate answer after multiple attempts"
+            
+        except Exception as e:
+            print(f"Fatal error in agent: {str(e)}")
+            return f"Error: {str(e)}"
 
 def run_and_submit_all(profile):
     """

requirements.txt

@@ -11,4 +11,5 @@ pytube
 google
 google-generativeai>=0.3.1
 duckduckgo-search
-pandas
+pandas
+tenacity>=8.0.1