Update agents/tools/ai_tools.py

agents/tools/ai_tools.py

@@ -17,6 +17,7 @@ from agents.models.llms import (
     LLM_IMAGE_TO_FEN,
     LLM_ALGEBRAIC_NOTATION,
     LLM_FINAL_ANSWER,
+    LLM_FALLBACK,
 
     THINKING_LEVEL_WEB_SEARCH,
     THINKING_LEVEL_MEDIA_ANALYSIS,
@@ -47,43 +48,54 @@ class AITools():
     def _get_client():
         return genai.Client(api_key=os.environ["GEMINI_API_KEY"])
 
+    def _is_rate_limit_error(exception):
+        """Check if the exception is a rate limit error (429 RESOURCE_EXHAUSTED)."""
+        error_str = str(exception)
+        return "429" in error_str and "RESOURCE_EXHAUSTED" in error_str
+
     def _media_analysis_tool(tool_name: str, model: str, question: str, file_path: str) -> str:
         print("")
         print(f"🛠️ AITools: {tool_name}: question={question}, file_path={file_path}")
         
-        try:
-            client = AITools._get_client()
-            
-            file = client.files.upload(file=file_path)
-
-            while True:
-                media_file = client.files.get(name=file.name)
-                if media_file.state == "ACTIVE":
-                    break
-                elif media_file.state == "FAILED":
-                    raise RuntimeError("Media file processing failed")
-                time.sleep(1)            
-
-            response = client.models.generate_content(
-                model=model,
-                contents=[file, question],
-                config=types.GenerateContentConfig(
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_MEDIA_ANALYSIS
+        client = AITools._get_client()
+        current_model = model
+        
+        for attempt in range(2):
+            try:
+                file = client.files.upload(file=file_path)
+
+                while True:
+                    media_file = client.files.get(name=file.name)
+                    if media_file.state == "ACTIVE":
+                        break
+                    elif media_file.state == "FAILED":
+                        raise RuntimeError("Media file processing failed")
+                    time.sleep(1)            
+
+                response = client.models.generate_content(
+                    model=current_model,
+                    contents=[file, question],
+                    config=types.GenerateContentConfig(
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_MEDIA_ANALYSIS
+                        )
                     )
                 )
-            )
 
-            result = response.text
-            
-            print(f"🛠️ AITools: {tool_name}: model={model}")
-            print(f"🛠️ AITools: {tool_name}: thinking_level={THINKING_LEVEL_MEDIA_ANALYSIS}")
-            print(f"🛠️ AITools: {tool_name}: result={result}")
-            
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: {tool_name}: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+                result = response.text
+                
+                print(f"🛠️ AITools: {tool_name}: model={current_model}")
+                print(f"🛠️ AITools: {tool_name}: thinking_level={THINKING_LEVEL_MEDIA_ANALYSIS}")
+                print(f"🛠️ AITools: {tool_name}: result={result}")
+                
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: {tool_name}: Rate limit hit with {current_model}, falling back to {LLM_FALLBACK}")
+                    current_model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: {tool_name}: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")
 
     def _extract_execution_result(response):
         for part in response.candidates[0].content.parts:
@@ -108,30 +120,36 @@ class AITools():
         print("")
         print(f"🛠️ AITools: web_search_tool: question={question}")
 
-        try:
-            client = AITools._get_client()
-            
-            response = client.models.generate_content(
-                model=LLM_WEB_SEARCH,
-                contents=question,
-                config=types.GenerateContentConfig(
-                    tools=[types.Tool(google_search=types.GoogleSearch())],
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_WEB_SEARCH
+        client = AITools._get_client()
+        model = LLM_WEB_SEARCH
+        
+        for attempt in range(2):
+            try:
+                response = client.models.generate_content(
+                    model=model,
+                    contents=question,
+                    config=types.GenerateContentConfig(
+                        tools=[types.Tool(google_search=types.GoogleSearch())],
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_WEB_SEARCH
+                        )
                     )
                 )
-            )
 
-            result = response.text
-            
-            print(f"🛠️ AITools: web_search_tool: model={LLM_WEB_SEARCH}")
-            print(f"🛠️ AITools: web_search_tool: thinking_level={THINKING_LEVEL_WEB_SEARCH}")
-            print(f"🛠️ AITools: web_search_tool: result={result}")
-            
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: web_search_tool: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+                result = response.text
+                
+                print(f"🛠️ AITools: web_search_tool: model={model}")
+                print(f"🛠️ AITools: web_search_tool: thinking_level={THINKING_LEVEL_WEB_SEARCH}")
+                print(f"🛠️ AITools: web_search_tool: result={result}")
+                
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: web_search_tool: Rate limit hit with {model}, falling back to {LLM_FALLBACK}")
+                    model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: web_search_tool: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")
 
     @tool("Web Browser Tool")
     def web_browser_tool(question: str, url: str) -> str:
@@ -247,30 +265,36 @@ class AITools():
         print("")
         print(f"🛠️ AITools: youtube_analysis_tool: question={question}, url={url}")
         
-        try:
-            client = AITools._get_client()
-    
-            result = client.models.generate_content(
-                model=LLM_YOUTUBE_ANALYSIS,
-                contents=types.Content(
-                    parts=[types.Part(file_data=types.FileData(file_uri=url)),
-                           types.Part(text=question)]
-                ),
-                config=types.GenerateContentConfig(
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_YOUTUBE_ANALYSIS
+        client = AITools._get_client()
+        model = LLM_YOUTUBE_ANALYSIS
+        
+        for attempt in range(2):
+            try:
+                result = client.models.generate_content(
+                    model=model,
+                    contents=types.Content(
+                        parts=[types.Part(file_data=types.FileData(file_uri=url)),
+                               types.Part(text=question)]
+                    ),
+                    config=types.GenerateContentConfig(
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_YOUTUBE_ANALYSIS
+                        )
                     )
                 )
-            )
 
-            print(f"🛠️ AITools: youtube_analysis_tool: model={LLM_YOUTUBE_ANALYSIS}")
-            print(f"🛠️ AITools: youtube_analysis_tool: thinking_level={THINKING_LEVEL_YOUTUBE_ANALYSIS}")
-            print(f"🛠️ AITools: youtube_analysis_tool: result={result}")
+                print(f"🛠️ AITools: youtube_analysis_tool: model={model}")
+                print(f"🛠️ AITools: youtube_analysis_tool: thinking_level={THINKING_LEVEL_YOUTUBE_ANALYSIS}")
+                print(f"🛠️ AITools: youtube_analysis_tool: result={result}")
 
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: youtube_analysis_tool: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: youtube_analysis_tool: Rate limit hit with {model}, falling back to {LLM_FALLBACK}")
+                    model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: youtube_analysis_tool: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")
     
     @tool("Document Analysis Tool")
     def document_analysis_tool(question: str, file_path: str) -> str:
@@ -289,43 +313,49 @@ class AITools():
         print("")
         print(f"🛠️ AITools: document_analysis_tool: question={question}, file_path={file_path}")
 
-        try:
-            client = AITools._get_client()
-    
-            contents = []
-            
-            if is_ext(file_path, ".docx"):
-                text_data = read_docx_text(file_path)
-                contents = [f"{question}\n{text_data}"]
-                print(f"🛠️ Text data:\n{text_data}")
-            elif is_ext(file_path, ".pptx"):
-                text_data = read_pptx_text(file_path)
-                contents = [f"{question}\n{text_data}"]
-                print(f"🛠️ Text data:\n{text_data}")
-            else:
-                file = client.files.upload(file=file_path)
-                contents = [file, question]
-            
-            response = client.models.generate_content(
-                model=LLM_DOCUMENT_ANALYSIS,
-                contents=contents,
-                config=types.GenerateContentConfig(
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_DOCUMENT_ANALYSIS
+        client = AITools._get_client()
+        model = LLM_DOCUMENT_ANALYSIS
+        
+        for attempt in range(2):
+            try:
+                contents = []
+                
+                if is_ext(file_path, ".docx"):
+                    text_data = read_docx_text(file_path)
+                    contents = [f"{question}\n{text_data}"]
+                    print(f"🛠️ Text data:\n{text_data}")
+                elif is_ext(file_path, ".pptx"):
+                    text_data = read_pptx_text(file_path)
+                    contents = [f"{question}\n{text_data}"]
+                    print(f"🛠️ Text data:\n{text_data}")
+                else:
+                    file = client.files.upload(file=file_path)
+                    contents = [file, question]
+                
+                response = client.models.generate_content(
+                    model=model,
+                    contents=contents,
+                    config=types.GenerateContentConfig(
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_DOCUMENT_ANALYSIS
+                        )
                     )
                 )
-            )
-          
-            result = response.text
-            
-            print(f"🛠️ AITools: document_analysis_tool: model={LLM_DOCUMENT_ANALYSIS}")
-            print(f"🛠️ AITools: document_analysis_tool: thinking_level={THINKING_LEVEL_DOCUMENT_ANALYSIS}")
-            print(f"🛠️ AITools: document_analysis_tool: result={result}")
-            
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: document_analysis_tool: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+              
+                result = response.text
+                
+                print(f"🛠️ AITools: document_analysis_tool: model={model}")
+                print(f"🛠️ AITools: document_analysis_tool: thinking_level={THINKING_LEVEL_DOCUMENT_ANALYSIS}")
+                print(f"🛠️ AITools: document_analysis_tool: result={result}")
+                
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: document_analysis_tool: Rate limit hit with {model}, falling back to {LLM_FALLBACK}")
+                    model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: document_analysis_tool: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")
     
     @tool("Code Generation and Execution Tool")
     def code_generation_and_execution_tool(question: str, json_data: str) -> str:
@@ -343,30 +373,36 @@ class AITools():
         print("")
         print(f"🛠️ AITools: code_generation_and_execution_tool: question={question}, json_data={json_data}")
 
-        try:
-            client = AITools._get_client()
-                    
-            response = client.models.generate_content(
-                model=LLM_CODE_GENERATION,
-                contents=[f"{question}\n{json_data}"],
-                config=types.GenerateContentConfig(
-                    tools=[types.Tool(code_execution=types.ToolCodeExecution)],
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_CODE_GENERATION
-                    )
-                ),
-            )
+        client = AITools._get_client()
+        model = LLM_CODE_GENERATION
+        
+        for attempt in range(2):
+            try:
+                response = client.models.generate_content(
+                    model=model,
+                    contents=[f"{question}\n{json_data}"],
+                    config=types.GenerateContentConfig(
+                        tools=[types.Tool(code_execution=types.ToolCodeExecution)],
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_CODE_GENERATION
+                        )
+                    ),
+                )
 
-            result = AITools._extract_execution_result(response)
+                result = AITools._extract_execution_result(response)
 
-            print(f"🛠️ AITools: code_generation_and_execution_tool: model={LLM_CODE_GENERATION}")
-            print(f"🛠️ AITools: code_generation_and_execution_tool: thinking_level={THINKING_LEVEL_CODE_GENERATION}")
-            print(f"🛠️ AITools: code_generation_and_execution_tool: result={result}")
+                print(f"🛠️ AITools: code_generation_and_execution_tool: model={model}")
+                print(f"🛠️ AITools: code_generation_and_execution_tool: thinking_level={THINKING_LEVEL_CODE_GENERATION}")
+                print(f"🛠️ AITools: code_generation_and_execution_tool: result={result}")
 
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: code_generation_and_execution_tool: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: code_generation_and_execution_tool: Rate limit hit with {model}, falling back to {LLM_FALLBACK}")
+                    model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: code_generation_and_execution_tool: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")
 
     @tool("Code Execution Tool")
     def code_execution_tool(question: str, file_path: str) -> str:
@@ -385,32 +421,38 @@ class AITools():
         print("")
         print(f"🛠️ AITools: code_execution_tool: question={question}, file_path={file_path}")
 
-        try:
-            client = AITools._get_client()
-    
-            file = client.files.upload(file=file_path)
-
-            response = client.models.generate_content(
-                model=LLM_CODE_EXECUTION,
-                contents=[file, question],
-                config=types.GenerateContentConfig(
-                    tools=[types.Tool(code_execution=types.ToolCodeExecution)],
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_CODE_EXECUTION
-                    )
-                ),
-            )
+        client = AITools._get_client()
+        model = LLM_CODE_EXECUTION
+        
+        for attempt in range(2):
+            try:
+                file = client.files.upload(file=file_path)
+
+                response = client.models.generate_content(
+                    model=model,
+                    contents=[file, question],
+                    config=types.GenerateContentConfig(
+                        tools=[types.Tool(code_execution=types.ToolCodeExecution)],
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_CODE_EXECUTION
+                        )
+                    ),
+                )
 
-            result = AITools._extract_execution_result(response)
+                result = AITools._extract_execution_result(response)
 
-            print(f"🛠️ AITools: code_execution_tool: model={LLM_CODE_EXECUTION}")
-            print(f"🛠️ AITools: code_execution_tool: thinking_level={THINKING_LEVEL_CODE_EXECUTION}")
-            print(f"🛠️ AITools: code_execution_tool: result={result}")
+                print(f"🛠️ AITools: code_execution_tool: model={model}")
+                print(f"🛠️ AITools: code_execution_tool: thinking_level={THINKING_LEVEL_CODE_EXECUTION}")
+                print(f"🛠️ AITools: code_execution_tool: result={result}")
 
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: code_execution_tool: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: code_execution_tool: Rate limit hit with {model}, falling back to {LLM_FALLBACK}")
+                    model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: code_execution_tool: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")
 
     @tool("Image to FEN Tool")
     def img_to_fen_tool(question: str, file_path: str, active_color: str) -> str:
@@ -430,54 +472,60 @@ class AITools():
         print("")
         print(f"🛠️ AITools: img_to_fen_tool: question={question}, file_path={file_path}, active_color={active_color}")
 
-        try:         
-            client = AITools._get_client()
+        client = AITools._get_client()
+        model = LLM_IMAGE_TO_FEN
+        
+        for attempt in range(2):
+            try:         
+                with open(file_path, "rb") as f:
+                    img_bytes = f.read()
+                    img_b64 = base64.b64encode(img_bytes).decode("ascii")
+                
+                prompt = PROMPT_IMG_TO_FEN.format(question=question, active_color=active_color)
+
+                content = types.Content(
+                    parts=[
+                        types.Part(text=prompt),
+                        types.Part(
+                            inline_data=types.Blob(
+                                mime_type="image/png",
+                                data=base64.b64decode(img_b64),
+                            )
+                        )
+                    ]
+                )
 
-            with open(file_path, "rb") as f:
-                img_bytes = f.read()
-                img_b64 = base64.b64encode(img_bytes).decode("ascii")
-            
-            prompt = PROMPT_IMG_TO_FEN.format(question=question, active_color=active_color)
-
-            content = types.Content(
-                parts=[
-                    types.Part(text=prompt),
-                    types.Part(
-                        inline_data=types.Blob(
-                            mime_type="image/png",
-                            data=base64.b64decode(img_b64),
+                response = client.models.generate_content(
+                    model=model,
+                    contents=[content],
+                    config=types.GenerateContentConfig(
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_IMAGE_TO_FEN
                         )
                     )
-                ]
-            )
-
-            response = client.models.generate_content(
-                model=LLM_IMAGE_TO_FEN,
-                contents=[content],
-                config=types.GenerateContentConfig(
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_IMAGE_TO_FEN
-                    )
                 )
-            )
 
-            result = None
+                result = None
 
-            for part in response.parts:
-                if part.text is not None:
-                    result = part.text
-                    break
+                for part in response.parts:
+                    if part.text is not None:
+                        result = part.text
+                        break
 
-            board = chess.Board(result) # FEN validation
+                board = chess.Board(result) # FEN validation
 
-            print(f"🛠️ AITools: img_to_fen_tool: model={LLM_IMAGE_TO_FEN}")
-            print(f"🛠️ AITools: img_to_fen_tool: thinking_level={THINKING_LEVEL_IMAGE_TO_FEN}")
-            print(f"🛠️ AITools: img_to_fen_tool: result={result}")
+                print(f"🛠️ AITools: img_to_fen_tool: model={model}")
+                print(f"🛠️ AITools: img_to_fen_tool: thinking_level={THINKING_LEVEL_IMAGE_TO_FEN}")
+                print(f"🛠️ AITools: img_to_fen_tool: result={result}")
 
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: img_to_fen_tool: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: img_to_fen_tool: Rate limit hit with {model}, falling back to {LLM_FALLBACK}")
+                    model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: img_to_fen_tool: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")
 
     @tool("Algebraic Notation Tool")
     def algebraic_notation_tool(question: str, file_path: str, position_evaluation: str) -> str:
@@ -497,52 +545,58 @@ class AITools():
         print("")
         print(f"🛠️ AITools: algebraic_notation_tool: question={question}, file_path={file_path}, position_evaluation={position_evaluation}")
 
-        try:
-            client = AITools._get_client()
-
-            with open(file_path, "rb") as f:
-                img_bytes = f.read()
-                img_b64 = base64.b64encode(img_bytes).decode("ascii")
-            
-            prompt = PROMPT_ALGEBRAIC_NOTATION.format(question=question, position_evaluation=position_evaluation)
-
-            content = types.Content(
-                parts=[
-                    types.Part(text=prompt),
-                    types.Part(
-                        inline_data=types.Blob(
-                            mime_type="image/png",
-                            data=base64.b64decode(img_b64),
+        client = AITools._get_client()
+        model = LLM_ALGEBRAIC_NOTATION
+        
+        for attempt in range(2):
+            try:
+                with open(file_path, "rb") as f:
+                    img_bytes = f.read()
+                    img_b64 = base64.b64encode(img_bytes).decode("ascii")
+                
+                prompt = PROMPT_ALGEBRAIC_NOTATION.format(question=question, position_evaluation=position_evaluation)
+
+                content = types.Content(
+                    parts=[
+                        types.Part(text=prompt),
+                        types.Part(
+                            inline_data=types.Blob(
+                                mime_type="image/png",
+                                data=base64.b64decode(img_b64),
+                            )
+                        )
+                    ]
+                )
+                
+                response = client.models.generate_content(
+                    model=model,
+                    contents=[content],
+                    config=types.GenerateContentConfig(
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_ALGEBRAIC_NOTATION
                         )
-                    )
-                ]
-            )
-            
-            response = client.models.generate_content(
-                model=LLM_ALGEBRAIC_NOTATION,
-                contents=[content],
-                config=types.GenerateContentConfig(
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_ALGEBRAIC_NOTATION
                     )
                 )
-            )
 
-            result = None
-            
-            for part in response.parts:
-                if part.text is not None:
-                    result = part.text
-                    break
+                result = None
+                
+                for part in response.parts:
+                    if part.text is not None:
+                        result = part.text
+                        break
 
-            print(f"🛠️ AITools: algebraic_notation_tool: model={LLM_ALGEBRAIC_NOTATION}")
-            print(f"🛠️ AITools: algebraic_notation_tool: thinking_level={THINKING_LEVEL_ALGEBRAIC_NOTATION}")
-            print(f"🛠️ AITools: algebraic_notation_tool: result={result}")
+                print(f"🛠️ AITools: algebraic_notation_tool: model={model}")
+                print(f"🛠️ AITools: algebraic_notation_tool: thinking_level={THINKING_LEVEL_ALGEBRAIC_NOTATION}")
+                print(f"🛠️ AITools: algebraic_notation_tool: result={result}")
 
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: algebraic_notation_tool: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: algebraic_notation_tool: Rate limit hit with {model}, falling back to {LLM_FALLBACK}")
+                    model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: algebraic_notation_tool: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")
 
     def final_answer_tool(question: str, answer: str) -> str:
         """Given a question and initial answer, get the final answer.
@@ -560,28 +614,34 @@ class AITools():
         print("")
         print(f"🛠️ AITools: final_answer_tool: question={question}, answer={answer}")
 
-        try:
-            client = AITools._get_client()
+        client = AITools._get_client()
+        model = LLM_FINAL_ANSWER
         
-            prompt = PROMPT_FINAL_ANSWER.format(question=question, answer=answer)
-
-            response = client.models.generate_content(
-                model=LLM_FINAL_ANSWER, 
-                contents=[prompt],
-                config=types.GenerateContentConfig(
-                    thinking_config=types.ThinkingConfig(
-                        thinking_level=THINKING_LEVEL_FINAL_ANSWER
+        for attempt in range(2):
+            try:
+                prompt = PROMPT_FINAL_ANSWER.format(question=question, answer=answer)
+
+                response = client.models.generate_content(
+                    model=model, 
+                    contents=[prompt],
+                    config=types.GenerateContentConfig(
+                        thinking_config=types.ThinkingConfig(
+                            thinking_level=THINKING_LEVEL_FINAL_ANSWER
+                        )
                     )
                 )
-            )
-    
-            result = response.text.strip()
+        
+                result = response.text.strip()
 
-            print(f"🛠️ AITools: final_answer_tool: model={LLM_FINAL_ANSWER}")
-            print(f"🛠️ AITools: final_answer_tool: thinking_level={THINKING_LEVEL_FINAL_ANSWER}")
-            print(f"🛠️ AITools: final_answer_tool: result={result}")
-            
-            return result
-        except Exception as e:
-            print(f"⚠️ AITools: final_answer_tool: exception={str(e)}")
-            raise RuntimeError(f"Processing failed: {str(e)}")
+                print(f"🛠️ AITools: final_answer_tool: model={model}")
+                print(f"🛠️ AITools: final_answer_tool: thinking_level={THINKING_LEVEL_FINAL_ANSWER}")
+                print(f"🛠️ AITools: final_answer_tool: result={result}")
+                
+                return result
+            except Exception as e:
+                if attempt == 0 and AITools._is_rate_limit_error(e):
+                    print(f"⚠️ AITools: final_answer_tool: Rate limit hit with {model}, falling back to {LLM_FALLBACK}")
+                    model = LLM_FALLBACK
+                    continue
+                print(f"⚠️ AITools: final_answer_tool: exception={str(e)}")
+                raise RuntimeError(f"Processing failed: {str(e)}")