requirements update for llm compat

app.py

@@ -286,148 +286,138 @@ class BasicAgent:
         
         logger.info("BasicAgent initialized with fallback LLM support.")
     
-    @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 with retry logic and fallback support."""
-        try:
-            messages = state["messages"]
-            logger.info("\n=== Model Input ===")
-            log_message(self.sys_msg, "  ")
-            for msg in messages:
-                log_message(msg, "  ")
-            
-            # Try primary LLM first
+    def _call_model_with_retry(self, state: AgentState) -> AgentState:
+        """Internal method to handle retries for model calls."""
+        max_retries = 3
+        retry_count = 0
+        last_error = None
+        
+        while retry_count < max_retries:
             try:
-                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"]
-                        }
-                    }}]
-                )
-            except Exception as e:
-                error_str = str(e)
-                if "429" in error_str:
-                    if "GenerateRequestsPerDayPerProjectPerModel-FreeTier" in error_str:
-                        logger.warning("Daily quota limit reached for primary LLM, trying fallback")
-                        if hasattr(self, 'fallback_llm') and self.fallback_llm is not None:
-                            try:
-                                response = self.fallback_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"]
-                                        }
-                                    }}]
-                                )
-                                logger.info("Successfully used fallback LLM")
-                            except Exception as fallback_error:
-                                logger.error(f"Fallback LLM also failed: {str(fallback_error)}")
+                messages = state["messages"]
+                logger.info("\n=== Model Input ===")
+                log_message(self.sys_msg, "  ")
+                for msg in messages:
+                    log_message(msg, "  ")
+                
+                # Try primary LLM first
+                try:
+                    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"]
+                            }
+                        }}]
+                    )
+                except Exception as e:
+                    error_str = str(e)
+                    if "429" in error_str:
+                        if "GenerateRequestsPerDayPerProjectPerModel-FreeTier" in error_str:
+                            logger.warning("Daily quota limit reached for primary LLM, trying fallback")
+                            if hasattr(self, 'fallback_llm') and self.fallback_llm is not None:
+                                try:
+                                    response = self.fallback_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"]
+                                            }
+                                        }}]
+                                    )
+                                    logger.info("Successfully used fallback LLM")
+                                except Exception as fallback_error:
+                                    logger.error(f"Fallback LLM also failed: {str(fallback_error)}")
+                                    return {
+                                        "messages": [AIMessage(content="All LLM services are currently unavailable. Please try again later.")], 
+                                        "next": END
+                                    }
+                            else:
+                                logger.warning("No fallback LLM available")
                                 return {
-                                    "messages": [AIMessage(content="All LLM services are currently unavailable. Please try again later.")], 
+                                    "messages": [AIMessage(content="I've reached my daily limit for processing requests. Please try again tomorrow or contact support for assistance.")], 
                                     "next": END
                                 }
                         else:
-                            logger.warning("No fallback LLM available")
-                            return {
-                                "messages": [AIMessage(content="I've reached my daily limit for processing requests. Please try again tomorrow or contact support for assistance.")], 
-                                "next": END
-                            }
+                            # For other rate limits, wait and retry
+                            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
                     else:
-                        # For other rate limits, wait and retry
-                        wait_time = 60
-                        logger.warning(f"Rate limit hit, waiting {wait_time} seconds before retry...")
-                        time.sleep(wait_time)
-                        raise  # Re-raise to trigger retry
-                else:
-                    raise
-            
-            logger.info("\n=== Model Output ===")
-            log_message(response, "  ")
-            
-            if not response or not response.content:
-                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"}
-            else:
-                # If no tool call, check if it's a final answer
-                content = response.content.strip()
+                        raise
                 
-                # Clean up the content to ensure it's in the correct format
-                if content.startswith("**Final Answer**: "):
-                    content = content.replace("**Final Answer**: ", "").strip()
+                logger.info("\n=== Model Output ===")
+                log_message(response, "  ")
                 
-                # 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)))
+                if not response or not response.content:
+                    logger.error("Empty response from model")
+                    raise ValueError("Empty response from model")
                 
-                # 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}
+                # Check if the response contains a tool call
+                if hasattr(response, 'tool_calls') and response.tool_calls:
+                    return {"messages": [response], "next": "tools"}
                 else:
-                    # If not a final answer, continue the conversation
-                    return {"messages": [response], "next": "agent"}
+                    # If no tool call, check if it's a final answer
+                    content = response.content.strip()
                     
-        except Exception as e:
-            logger.error(f"Error in call_model: {str(e)}")
-            error_str = str(e)
-            if "429" in error_str:
-                if "GenerateRequestsPerDayPerProjectPerModel-FreeTier" in error_str:
-                    logger.warning("Daily quota limit reached, trying fallback")
-                    if hasattr(self, 'fallback_llm') and self.fallback_llm is not None:
-                        try:
-                            response = self.fallback_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"]
-                                    }
-                                }}]
-                            )
-                            return {"messages": [response], "next": "tools"}
-                        except Exception as fallback_error:
-                            logger.error(f"Fallback LLM also failed: {str(fallback_error)}")
-                            return {"messages": [AIMessage(content="All LLM services are currently unavailable. Please try again later.")], "next": END}
+                    # 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:
-                        return {"messages": [AIMessage(content="I've reached my daily limit for processing requests. Please try again tomorrow or contact support for assistance.")], "next": END}
+                        # If not a final answer, continue the conversation
+                        return {"messages": [response], "next": "agent"}
+                        
+            except Exception as e:
+                last_error = e
+                retry_count += 1
+                logger.error(f"Error in processing, retry {retry_count}/{max_retries}: {str(e)}")
+                if retry_count < max_retries:
+                    wait_time = 5 * retry_count  # Simple backoff
+                    time.sleep(wait_time)
                 else:
-                    logger.warning("Rate limit hit, waiting before retry...")
-                    time.sleep(60)  # Wait for 60 seconds before retry
-                    raise  # Re-raise to trigger retry
-            raise  # Re-raise other exceptions to trigger retry
+                    logger.error(f"All retries failed. Last error: {str(last_error)}")
+                    return {
+                        "messages": [AIMessage(content="Unable to generate answer after multiple attempts. Please try again later.")],
+                        "next": END
+                    }
+        
+        return {
+            "messages": [AIMessage(content="Unable to generate answer after multiple attempts. Please try again later.")],
+            "next": END
+        }
+
+    def call_model(self, state: AgentState) -> AgentState:
+        """Call the model to generate a response with retry logic and fallback support."""
+        return self._call_model_with_retry(state)
     
     def call_tools(self, state: AgentState) -> AgentState:
         """Call the tools based on the model's response."""
@@ -476,38 +466,17 @@ class BasicAgent:
             }
             
             # Process through the graph with retry logic
-            max_retries = 3
-            retry_count = 0
-            last_error = None
-            
-            while retry_count < max_retries:
-                try:
-                    logger.info(f"\n=== Attempt {retry_count + 1}/{max_retries} ===")
-                    result = self.app.invoke(initial_state)
-                    final_message = result["messages"][-1]
-                    
-                    if isinstance(final_message, AIMessage) and final_message.content:
-                        logger.info(f"\n=== Final Answer ===")
-                        logger.info(f"Answer: {final_message.content}")
-                        return final_message.content
-                    else:
-                        logger.error("Empty or invalid response")
-                        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
-                        logger.warning(f"Rate limit hit, waiting {wait_time} seconds before retry {retry_count}/{max_retries}")
-                        await asyncio.sleep(wait_time)
-                    else:
-                        logger.error(f"Error in processing, retry {retry_count}/{max_retries}: {str(e)}")
-                        await asyncio.sleep(5)
-            
-            logger.error(f"All retries failed. Last error: {str(last_error)}")
-            return "Unable to generate answer after multiple attempts"
+            result = self.app.invoke(initial_state)
+            final_message = result["messages"][-1]
             
+            if isinstance(final_message, AIMessage) and final_message.content:
+                logger.info(f"\n=== Final Answer ===")
+                logger.info(f"Answer: {final_message.content}")
+                return final_message.content
+            else:
+                logger.error("Empty or invalid response")
+                raise ValueError("Empty or invalid response")
+                
         except Exception as e:
             logger.error(f"Fatal error in agent: {str(e)}")
             return f"Error: {str(e)}"