Add retry

orchestrator-agent/agent.py

@@ -98,52 +98,90 @@ Always structure your response with:
         self,
         agent_name: str,
         payload: Dict[str, Any],
-        timeout: float = 120.0
+        timeout: float = 120.0,
+        max_retries: int = 3
     ) -> Dict[str, Any]:
         """
-        Call an agent via HTTP (workaround for bl_agent DNS issues)
+        Call an agent via HTTP with retry logic for empty responses
         
         Args:
             agent_name: Name of the agent (e.g., 'risk-assessment-agent')
             payload: Request payload
             timeout: Request timeout in seconds
+            max_retries: Maximum number of retry attempts (default: 3)
             
         Returns:
             Agent response as dictionary
             
         Raises:
-            Exception: If HTTP request fails
+            Exception: If HTTP request fails after all retries
         """
         agent_url = f"{self.base_url}/{agent_name}"
         
-        try:
-            headers = {"Content-Type": "application/json"}
-            if self.blaxel_api_key:
-                headers["Authorization"] = f"Bearer {self.blaxel_api_key}"
-            
-            logger.info(f"Calling {agent_name} via HTTP at {agent_url}")
-            self._update_progress(f"Calling {agent_name}...")
-            
-            async with httpx.AsyncClient(timeout=timeout) as client:
-                response = await client.post(
-                    agent_url,
-                    json=payload,
-                    headers=headers
-                )
-                response.raise_for_status()
-                result = response.json()
+        for attempt in range(1, max_retries + 1):
+            try:
+                headers = {"Content-Type": "application/json"}
+                if self.blaxel_api_key:
+                    headers["Authorization"] = f"Bearer {self.blaxel_api_key}"
                 
-                self._update_progress(f"{agent_name} completed successfully")
-                return result
+                attempt_msg = f" (attempt {attempt}/{max_retries})" if attempt > 1 else ""
+                logger.info(f"Calling {agent_name} via HTTP at {agent_url}{attempt_msg}")
+                self._update_progress(f"Calling {agent_name}...{attempt_msg}")
                 
-        except httpx.TimeoutException:
-            raise Exception(f"{agent_name} request timed out after {timeout}s")
-        except httpx.HTTPStatusError as e:
-            raise Exception(f"{agent_name} returned HTTP {e.response.status_code}: {e.response.text}")
-        except httpx.HTTPError as e:
-            raise Exception(f"{agent_name} HTTP error: {str(e)}")
-        except Exception as e:
-            raise Exception(f"{agent_name} call failed: {str(e)}")
+                async with httpx.AsyncClient(timeout=timeout) as client:
+                    response = await client.post(
+                        agent_url,
+                        json=payload,
+                        headers=headers
+                    )
+                    response.raise_for_status()
+                    result = response.json()
+                    
+                    # Check for empty or invalid response
+                    if not result or not isinstance(result, dict):
+                        raise Exception(f"Empty or invalid response from {agent_name}")
+                    
+                    # Check if response indicates success but has no data
+                    if result.get('success') and not any(key in result for key in ['data', 'facility_data', 'recommendations', 'cost_data', 'image_base64']):
+                        raise Exception(f"Empty data in successful response from {agent_name}")
+                    
+                    self._update_progress(f"{agent_name} completed successfully")
+                    return result
+                    
+            except httpx.TimeoutException as e:
+                error_msg = f"{agent_name} request timed out after {timeout}s"
+                if attempt < max_retries:
+                    logger.warning(f"{error_msg}, retrying...")
+                    await asyncio.sleep(2 * attempt)  # Exponential backoff
+                    continue
+                raise Exception(error_msg)
+                
+            except httpx.HTTPStatusError as e:
+                error_msg = f"{agent_name} returned HTTP {e.response.status_code}: {e.response.text}"
+                if attempt < max_retries and e.response.status_code >= 500:
+                    logger.warning(f"{error_msg}, retrying...")
+                    await asyncio.sleep(2 * attempt)
+                    continue
+                raise Exception(error_msg)
+                
+            except httpx.HTTPError as e:
+                error_msg = f"{agent_name} HTTP error: {str(e)}"
+                if attempt < max_retries:
+                    logger.warning(f"{error_msg}, retrying...")
+                    await asyncio.sleep(2 * attempt)
+                    continue
+                raise Exception(error_msg)
+                
+            except Exception as e:
+                error_msg = f"{agent_name} call failed: {str(e)}"
+                if attempt < max_retries:
+                    logger.warning(f"{error_msg}, retrying...")
+                    await asyncio.sleep(2 * attempt)
+                    continue
+                raise Exception(error_msg)
+        
+        # Should never reach here, but just in case
+        raise Exception(f"{agent_name} failed after {max_retries} attempts")
     
     async def process_construction_plan(
         self,