fix: improve Drummond agent import handling and add debug endpoint

- Use TYPE_CHECKING to avoid runtime import in factory
- Move CommunicationAgent import to inside get_drummond_agent function
- Add /debug/drummond-status endpoint for diagnostics
- Better error handling and logging for import failures

app.py

@@ -641,6 +641,48 @@ async def cache_stats():
         "ttl_seconds": api_cache.default_ttl
     }
 
+# Debug endpoint for Drummond issue
+@app.get("/debug/drummond-status")
+async def debug_drummond_status():
+    """Debug endpoint to check Drummond agent status."""
+    import traceback
+    
+    result = {
+        "python_version": sys.version,
+        "checks": {}
+    }
+    
+    # Check if we can import CommunicationAgent
+    try:
+        from src.agents.drummond import CommunicationAgent
+        abstract_methods = getattr(CommunicationAgent, '__abstractmethods__', set())
+        result["checks"]["import"] = {
+            "status": "success",
+            "abstract_methods": list(abstract_methods) if abstract_methods else "none",
+            "has_shutdown": hasattr(CommunicationAgent, 'shutdown'),
+            "has_initialize": hasattr(CommunicationAgent, 'initialize'),
+            "has_process": hasattr(CommunicationAgent, 'process')
+        }
+        
+        # Try to instantiate
+        try:
+            agent = CommunicationAgent()
+            result["checks"]["instantiation"] = {"status": "success", "agent_name": agent.name}
+        except Exception as e:
+            result["checks"]["instantiation"] = {
+                "status": "failed",
+                "error": str(e),
+                "error_type": type(e).__name__
+            }
+    except Exception as e:
+        result["checks"]["import"] = {
+            "status": "failed",
+            "error": str(e),
+            "traceback": traceback.format_exc()[:500]  # Limit traceback size
+        }
+    
+    return result
+
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
     logger.info(f"🚀 Starting Enhanced Cidadão.AI Backend on port {port}")

debug_drummond_import.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Debug script to trace Drummond import issues.
+"""
+
+import sys
+import traceback
+
+def test_import_chain():
+    """Test the import chain to find where the error occurs."""
+    
+    print("=== DRUMMOND IMPORT DEBUG ===")
+    print(f"Python version: {sys.version}")
+    print(f"Python path: {sys.path}")
+    print()
+    
+    # Test 1: Import BaseAgent
+    print("1. Testing BaseAgent import...")
+    try:
+        from src.agents.deodoro import BaseAgent
+        print("   ✓ BaseAgent imported successfully")
+        
+        # Check if shutdown is abstract
+        import inspect
+        methods = inspect.getmembers(BaseAgent, predicate=inspect.ismethod)
+        for name, method in methods:
+            if name == 'shutdown':
+                print(f"   - shutdown method found: {method}")
+                if hasattr(method, '__isabstractmethod__'):
+                    print(f"   - Is abstract: {method.__isabstractmethod__}")
+    except Exception as e:
+        print(f"   ✗ Failed to import BaseAgent: {e}")
+        traceback.print_exc()
+        return
+    
+    # Test 2: Import CommunicationAgent directly
+    print("\n2. Testing CommunicationAgent import...")
+    try:
+        from src.agents.drummond import CommunicationAgent
+        print("   ✓ CommunicationAgent imported successfully")
+        
+        # Check if shutdown is implemented
+        if hasattr(CommunicationAgent, 'shutdown'):
+            print("   ✓ shutdown method exists in CommunicationAgent")
+            
+            # Check method resolution order
+            print(f"   - MRO: {[c.__name__ for c in CommunicationAgent.__mro__]}")
+            
+            # Check abstract methods
+            abstract_methods = getattr(CommunicationAgent, '__abstractmethods__', set())
+            print(f"   - Abstract methods: {abstract_methods}")
+            
+    except Exception as e:
+        print(f"   ✗ Failed to import CommunicationAgent: {e}")
+        traceback.print_exc()
+        return
+    
+    # Test 3: Try to instantiate
+    print("\n3. Testing CommunicationAgent instantiation...")
+    try:
+        agent = CommunicationAgent()
+        print("   ✓ CommunicationAgent instantiated successfully")
+    except Exception as e:
+        print(f"   ✗ Failed to instantiate CommunicationAgent: {e}")
+        traceback.print_exc()
+        
+        # Additional diagnostics
+        print("\n   Additional diagnostics:")
+        try:
+            from src.agents.drummond import CommunicationAgent
+            print(f"   - Class type: {type(CommunicationAgent)}")
+            print(f"   - Base classes: {CommunicationAgent.__bases__}")
+            
+            # List all methods
+            print("   - All methods:")
+            for attr in dir(CommunicationAgent):
+                if not attr.startswith('_'):
+                    obj = getattr(CommunicationAgent, attr)
+                    if callable(obj):
+                        print(f"     * {attr}: {type(obj)}")
+                        
+        except Exception as e2:
+            print(f"   - Failed diagnostics: {e2}")
+    
+    # Test 4: Test the factory
+    print("\n4. Testing chat_drummond_factory...")
+    try:
+        from src.api.routes.chat_drummond_factory import get_drummond_agent
+        print("   ✓ Factory imported successfully")
+    except Exception as e:
+        print(f"   ✗ Failed to import factory: {e}")
+        traceback.print_exc()
+    
+    print("\n=== END DEBUG ===")
+
+if __name__ == "__main__":
+    test_import_chain()

src/api/routes/chat_drummond_factory.py

@@ -2,26 +2,34 @@
 Factory for Drummond agent to avoid import-time instantiation issues.
 """
 
-from typing import Optional
-from src.agents.drummond import CommunicationAgent
+from typing import Optional, TYPE_CHECKING
 from src.core import get_logger
 
+# Use TYPE_CHECKING to avoid import at runtime
+if TYPE_CHECKING:
+    from src.agents.drummond import CommunicationAgent
+
 logger = get_logger(__name__)
 
 # Global instance cache
-_drummond_instance: Optional[CommunicationAgent] = None
+_drummond_instance: Optional['CommunicationAgent'] = None
 _initialized = False
+_import_error = None
 
 
-async def get_drummond_agent() -> Optional[CommunicationAgent]:
+async def get_drummond_agent() -> Optional['CommunicationAgent']:
     """
     Get or create Drummond agent instance.
     This function handles lazy initialization to avoid import-time issues.
     """
-    global _drummond_instance, _initialized
+    global _drummond_instance, _initialized, _import_error
     
     if not _initialized:
         try:
+            # Lazy import to avoid module-level import errors
+            logger.info("Attempting to import CommunicationAgent...")
+            from src.agents.drummond import CommunicationAgent
+            
             logger.info("Creating Drummond agent instance...")
             _drummond_instance = CommunicationAgent()
             
@@ -31,11 +39,20 @@ async def get_drummond_agent() -> Optional[CommunicationAgent]:
             _initialized = True
             logger.info("Drummond agent ready")
             
+        except ImportError as e:
+            logger.error(f"Import error for Drummond agent: {e}")
+            import traceback
+            logger.error(f"Import traceback: {traceback.format_exc()}")
+            _drummond_instance = None
+            _initialized = False
+            _import_error = str(e)
+            
         except Exception as e:
             logger.error(f"Failed to create/initialize Drummond: {e}")
             import traceback
             logger.error(f"Traceback: {traceback.format_exc()}")
             _drummond_instance = None
             _initialized = False
+            _import_error = str(e)
             
     return _drummond_instance

src/api/routes/debug.py

@@ -0,0 +1,119 @@
+"""
+Debug routes for diagnosing issues in production.
+"""
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+import sys
+import os
+import importlib
+import traceback
+from typing import Dict, Any
+
+router = APIRouter(
+    prefix="/debug",
+    tags=["debug"]
+)
+
+
+@router.get("/drummond-status")
+async def drummond_status() -> Dict[str, Any]:
+    """Check the status of Drummond agent and diagnose import issues."""
+    
+    result = {
+        "python_version": sys.version,
+        "working_dir": os.getcwd(),
+        "sys_path": sys.path[:5],  # First 5 paths
+        "checks": {}
+    }
+    
+    # Check 1: Can we import BaseAgent?
+    try:
+        from src.agents.deodoro import BaseAgent
+        result["checks"]["base_agent_import"] = {
+            "status": "success",
+            "abstract_methods": list(getattr(BaseAgent, '__abstractmethods__', []))
+        }
+    except Exception as e:
+        result["checks"]["base_agent_import"] = {
+            "status": "failed",
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+    
+    # Check 2: Can we import CommunicationAgent?
+    try:
+        from src.agents.drummond import CommunicationAgent
+        abstract_methods = getattr(CommunicationAgent, '__abstractmethods__', set())
+        result["checks"]["communication_agent_import"] = {
+            "status": "success",
+            "type": str(type(CommunicationAgent)),
+            "base_classes": [str(base) for base in CommunicationAgent.__bases__],
+            "abstract_methods": list(abstract_methods) if abstract_methods else "none",
+            "has_shutdown": hasattr(CommunicationAgent, 'shutdown'),
+            "has_initialize": hasattr(CommunicationAgent, 'initialize'),
+            "has_process": hasattr(CommunicationAgent, 'process')
+        }
+    except Exception as e:
+        result["checks"]["communication_agent_import"] = {
+            "status": "failed", 
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+    
+    # Check 3: Can we instantiate?
+    try:
+        from src.agents.drummond import CommunicationAgent
+        agent = CommunicationAgent()
+        result["checks"]["instantiation"] = {
+            "status": "success",
+            "agent_name": agent.name
+        }
+    except Exception as e:
+        result["checks"]["instantiation"] = {
+            "status": "failed",
+            "error": str(e),
+            "error_type": type(e).__name__,
+            "traceback": traceback.format_exc()
+        }
+    
+    # Check 4: Factory status
+    try:
+        from src.api.routes.chat_drummond_factory import get_drummond_agent, _initialized, _import_error
+        agent = await get_drummond_agent()
+        result["checks"]["factory"] = {
+            "status": "success" if agent else "failed",
+            "initialized": _initialized,
+            "import_error": _import_error,
+            "agent_available": agent is not None
+        }
+    except Exception as e:
+        result["checks"]["factory"] = {
+            "status": "failed",
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+    
+    return result
+
+
+@router.get("/module-info/{module_path}")
+async def module_info(module_path: str) -> Dict[str, Any]:
+    """Get information about a specific module."""
+    
+    try:
+        module = importlib.import_module(module_path)
+        
+        return {
+            "module": module_path,
+            "file": getattr(module, '__file__', 'unknown'),
+            "attributes": [attr for attr in dir(module) if not attr.startswith('_')],
+            "status": "loaded"
+        }
+    except Exception as e:
+        return {
+            "module": module_path,
+            "status": "error",
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }

test_drummond_minimal.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""
+Minimal test to verify CommunicationAgent can be imported and instantiated.
+This simulates what happens on HuggingFace Spaces.
+"""
+
+import sys
+import os
+
+# Add src to path like HuggingFace does
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+def test_minimal_import():
+    print("=== MINIMAL DRUMMOND TEST ===")
+    
+    # Step 1: Try importing just the class
+    try:
+        print("1. Importing CommunicationAgent class...")
+        from src.agents.drummond import CommunicationAgent
+        print("   ✓ Import successful")
+    except Exception as e:
+        print(f"   ✗ Import failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+    
+    # Step 2: Check if it's a proper class
+    print("\n2. Checking class structure...")
+    print(f"   - Type: {type(CommunicationAgent)}")
+    print(f"   - Base classes: {CommunicationAgent.__bases__}")
+    print(f"   - Module: {CommunicationAgent.__module__}")
+    
+    # Check abstract methods
+    abstract_methods = getattr(CommunicationAgent, '__abstractmethods__', None)
+    if abstract_methods:
+        print(f"   - Abstract methods remaining: {abstract_methods}")
+    else:
+        print("   - No abstract methods remaining")
+    
+    # Step 3: Try instantiation without any dependencies
+    print("\n3. Testing instantiation...")
+    try:
+        # Mock the logger to avoid dependency issues
+        import logging
+        logging.basicConfig(level=logging.INFO)
+        
+        # Try to create instance
+        agent = CommunicationAgent()
+        print("   ✓ Instantiation successful")
+        return True
+    except Exception as e:
+        print(f"   ✗ Instantiation failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    success = test_minimal_import()
+    print(f"\n=== TEST {'PASSED' if success else 'FAILED'} ===")
+    sys.exit(0 if success else 1)