Upload folder using huggingface_hub

README.md

@@ -20,7 +20,7 @@ Experience AI agents with distinct personalities competing in a fantasy football
 - **6 AI Agents** with unique strategies (Zero RB, Best Player Available, Robust RB, etc.)
 - **Two Communication Modes**:
   - **Basic Multiagent**: Fast, single-process execution
-  - **A2A Mode**: Distributed agents on HTTP servers (limited on free tier)
+  - **A2A Mode**: Distributed agents with automatic fallback (Full → Lightweight → Simulated)
 - **Interactive Participation**: Draft alongside AI with strategic advice
 - **Real-time Communication**: Agents comment and react to picks
 - **Multi-User Support**: Each user gets their own draft session
@@ -32,8 +32,11 @@ Experience AI agents with distinct personalities competing in a fantasy football
 
 ## About Communication Modes
 
-- **Basic Multiagent (Recommended)**: Works perfectly on HF Spaces! All agents run in a single process with fast, reliable communication.
-- **A2A Mode (Experimental)**: Distributed agents on separate servers. Due to dependency issues with `a2a-sdk` on HF Spaces, this mode may not work. Basic Multiagent provides the same great experience!
+- **Basic Multiagent (Recommended)**: Works perfectly everywhere! All agents run in a single process with fast, reliable communication.
+- **A2A Mode (Adaptive)**: Automatically selects the best distributed mode:
+  - **Full A2A**: Complete protocol with gRPC (when available)
+  - **Lightweight A2A**: HTTP-only servers (works on HF Spaces!)
+  - **Simulated A2A**: Mock distributed experience (fallback)
 
 ## About
 

app.py

@@ -17,10 +17,18 @@ if os.getenv("SPACE_ID"):
         # Test the specific imports that fail
         import a2a  # This is what usually fails
         from any_agent.serving import A2AServingConfig
-        print("✅ Surprisingly, A2A dependencies are available! You can try A2A mode.")
+        print("✅ Surprisingly, full A2A dependencies are available! You can try A2A mode.")
     except ImportError as e:
-        print(f"⚠️ A2A dependencies not available: {e}")
-        print("✅ No problem! Basic Multiagent mode works perfectly and is recommended.")
+        print(f"⚠️ Full A2A dependencies not available: {e}")
+        # Check if lightweight A2A can work
+        try:
+            import httpx
+            import fastapi
+            import uvicorn
+            print("✅ Lightweight A2A dependencies available! A2A mode will work using HTTP-only.")
+            os.environ["A2A_MODE"] = "lightweight"
+        except ImportError:
+            print("✅ No problem! Basic Multiagent mode works perfectly and is recommended.")
 
 # Import and run the enhanced app
 from apps.app_enhanced import main

apps/app_enhanced.py

@@ -76,10 +76,28 @@ class EnhancedFantasyDraftApp:
             try:
                 global DynamicA2AAgentManager, cleanup_session
                 from core.dynamic_a2a_manager import DynamicA2AAgentManager, cleanup_session
+                self.real_a2a = True
+                self.a2a_type = "full"
             except ImportError as e:
-                self.a2a_status = f"❌ A2A mode not available: {str(e)}. Please use Basic Multiagent mode."
-                self.use_real_a2a = False
-                return self.a2a_status
+                # Try lightweight A2A for HF Spaces (no grpcio)
+                try:
+                    from core.lightweight_a2a_manager import LightweightA2AAgentManager, cleanup_session
+                    DynamicA2AAgentManager = LightweightA2AAgentManager
+                    self.real_a2a = True
+                    self.a2a_type = "lightweight"
+                    print("Using lightweight A2A mode (HTTP-only, no grpcio)")
+                except ImportError as e2:
+                    # Fall back to simulated A2A
+                    try:
+                        from core.simulated_a2a_manager import SimulatedA2AAgentManager, cleanup_session
+                        DynamicA2AAgentManager = SimulatedA2AAgentManager
+                        self.real_a2a = False
+                        self.a2a_type = "simulated"
+                        print("Using simulated A2A mode (real A2A not available)")
+                    except ImportError as e3:
+                        self.a2a_status = f"❌ A2A mode not available: {str(e)}. Please use Basic Multiagent mode."
+                        self.use_real_a2a = False
+                        return self.a2a_status
             
             # Generate unique session ID if needed
             if not self.session_id:
@@ -92,7 +110,15 @@ class EnhancedFantasyDraftApp:
             try:
                 await self.a2a_manager.start_agents()
                 ports = self.a2a_manager.allocated_ports
-                self.a2a_status = f"✅ A2A Mode Active (Session: {self.session_id}, Ports: {ports[0]}-{ports[-1]})"
+                if hasattr(self, 'a2a_type'):
+                    if self.a2a_type == "full":
+                        self.a2a_status = f"✅ Full A2A Mode Active (Session: {self.session_id}, Ports: {ports[0]}-{ports[-1]})"
+                    elif self.a2a_type == "lightweight":
+                        self.a2a_status = f"✅ Lightweight A2A Mode Active (Session: {self.session_id}, HTTP Ports: {ports[0]}-{ports[-1]})"
+                    else:  # simulated
+                        self.a2a_status = f"✅ Simulated A2A Mode Active (Session: {self.session_id}, Mock Ports: {ports[0]}-{ports[-1]})"
+                else:
+                    self.a2a_status = f"✅ A2A Mode Active (Session: {self.session_id}, Ports: {ports[0]}-{ports[-1]})"
             except RuntimeError as e:
                 # Failed to allocate ports or start agents
                 self.a2a_status = f"❌ Failed to start A2A: {str(e)}"
@@ -146,9 +172,18 @@ class EnhancedFantasyDraftApp:
         self.draft_output = "# 🏈 Mock Draft with A2A Communication\n\n"
         
         # Welcome message
+        if hasattr(self, 'a2a_type'):
+            if self.a2a_type == "full":
+                welcome_msg = "Welcome to the A2A-powered draft! Each agent is running on its own server with full A2A protocol."
+            elif self.a2a_type == "lightweight":
+                welcome_msg = "Welcome to the lightweight A2A draft! Each agent runs on its own HTTP server (no grpcio needed)."
+            else:  # simulated
+                welcome_msg = "Welcome to the simulated A2A draft! Agents communicate using mock HTTP calls."
+        else:
+            welcome_msg = "Welcome to the A2A-powered draft! Each agent is running on its own server."
         self.draft_output += format_agent_message(
             "commissioner", "ALL",
-            "Welcome to the A2A-powered draft! Each agent is running on its own server."
+            welcome_msg
         )
         yield self.draft_output
         
@@ -560,10 +595,13 @@ def create_gradio_interface():
                             )
                             mode_info = gr.Markdown(
                                 """
-                                **Basic Multiagent** (Recommended for HF Spaces): Fast, single-process execution (✅ Multi-user safe)
-                                **A2A**: Distributed agents with dynamic ports (Experimental on HF Spaces)
+                                **Basic Multiagent** (Recommended): Fast, single-process execution (✅ Multi-user safe)
+                                **A2A**: Distributed agents mode with automatic fallback:
+                                - Full A2A: gRPC + HTTP protocol (requires grpcio)
+                                - Lightweight A2A: HTTP-only (works on HF Spaces!)
+                                - Simulated A2A: Mock HTTP calls (fallback)
                                 
-                                *If A2A mode fails to start, please use Basic Multiagent mode instead.*
+                                *A2A mode will automatically select the best available option.*
                                 """
                             )
                             
@@ -856,74 +894,139 @@ def create_gradio_interface():
         def test_a2a_functionality():
             """Test A2A dependencies and port availability."""
             import socket
+            import subprocess
+            import importlib.util
+            import site
+            
             test_results = []
             
-            # Test imports
-            test_results.append("=== Testing A2A Dependencies ===")
+            # 1. Python Environment
+            test_results.append("=== Python Environment ===")
+            test_results.append(f"Python: {sys.version.split()[0]}")
+            test_results.append(f"Platform: {sys.platform}")
+            test_results.append(f"SPACE_ID: {os.getenv('SPACE_ID', 'Not on HF Spaces')}")
+            
+            # 2. Check a2a-sdk installation
+            test_results.append("\n=== Package Installation ===")
             try:
-                import any_agent
-                test_results.append("✅ any_agent imported")
-                
-                # Test the critical a2a module first
+                result = subprocess.run([sys.executable, "-m", "pip", "show", "a2a-sdk"], 
+                                      capture_output=True, text=True, timeout=5)
+                if result.returncode == 0:
+                    version_line = [line for line in result.stdout.split('\n') if line.startswith('Version:')]
+                    location_line = [line for line in result.stdout.split('\n') if line.startswith('Location:')]
+                    test_results.append(f"✅ a2a-sdk installed: {version_line[0] if version_line else 'Unknown version'}")
+                    if location_line:
+                        test_results.append(f"   {location_line[0]}")
+                else:
+                    test_results.append("❌ a2a-sdk NOT installed according to pip")
+            except Exception as e:
+                test_results.append(f"❌ Error checking pip: {e}")
+            
+            # 3. Module search
+            test_results.append("\n=== Module Search ===")
+            a2a_spec = importlib.util.find_spec("a2a")
+            if a2a_spec:
+                test_results.append(f"✅ a2a module found at: {a2a_spec.origin}")
+            else:
+                test_results.append("❌ a2a module NOT found by importlib")
+                # Manual search
+                for path in site.getsitepackages():
+                    if os.path.exists(path):
+                        a2a_path = os.path.join(path, "a2a")
+                        if os.path.exists(a2a_path):
+                            test_results.append(f"   Found a2a directory at: {a2a_path}")
+            
+            # 4. Import tests
+            test_results.append("\n=== Import Tests ===")
+            
+            # Basic a2a import
+            try:
+                import a2a
+                test_results.append(f"✅ import a2a: Success")
                 try:
-                    import a2a
-                    test_results.append("✅ a2a module found (from a2a-sdk)")
+                    import a2a.types
+                    test_results.append("✅ import a2a.types: Success")
                     try:
-                        import a2a.types
-                        test_results.append("✅ a2a.types imported")
+                        from a2a.types import AgentSkill
+                        test_results.append("✅ from a2a.types import AgentSkill: Success")
                     except ImportError as e:
-                        test_results.append(f"❌ a2a.types failed: {e}")
-                except ImportError:
-                    test_results.append("❌ a2a module NOT found - this is why A2A fails!")
-                    test_results.append("   The a2a-sdk package should provide the 'a2a' module")
-                
-                try:
-                    from any_agent.serving import A2AServingConfig
-                    from any_agent.tools import a2a_tool_async
-                    test_results.append("✅ A2A components imported successfully!")
+                        test_results.append(f"❌ AgentSkill import: {e}")
                 except ImportError as e:
-                    test_results.append(f"❌ A2A components import failed: {e}")
+                    test_results.append(f"❌ a2a.types import: {e}")
             except ImportError as e:
-                test_results.append(f"❌ any_agent not found: {e}")
+                test_results.append(f"❌ a2a import failed: {e}")
             
-            # Test ports
-            test_results.append("\n=== Testing Port Availability ===")
-            test_ports = [5001, 5002, 5003, 8001, 8002, 8080, 8888]
+            # any_agent A2A imports
+            try:
+                from any_agent.serving import A2AServingConfig
+                from any_agent.tools import a2a_tool_async
+                test_results.append("✅ any_agent A2A components: Success!")
+            except ImportError as e:
+                test_results.append(f"❌ any_agent A2A import: {e}")
+            
+            # 5. Port availability
+            test_results.append("\n=== Port Availability ===")
+            test_ports = [5001, 5002, 5003, 5004, 5005, 5006]
             available_count = 0
             
             for port in test_ports:
                 try:
                     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-                    
-                    # Try different addresses
-                    bound = False
-                    for addr in ['127.0.0.1', 'localhost', '0.0.0.0']:
-                        try:
-                            sock.bind((addr, port))
-                            test_results.append(f"✅ Port {port} available on {addr}")
-                            bound = True
-                            available_count += 1
-                            break
-                        except:
-                            continue
-                    
-                    if not bound:
-                        test_results.append(f"❌ Port {port} not available")
-                    
+                    sock.bind(('127.0.0.1', port))
+                    test_results.append(f"✅ Port {port} available")
+                    available_count += 1
                     sock.close()
-                except Exception as e:
-                    test_results.append(f"❌ Port {port} error: {e}")
+                except Exception:
+                    test_results.append(f"❌ Port {port} not available")
             
             test_results.append(f"\n📊 Summary: {available_count}/{len(test_ports)} ports available")
             
-            # Environment info
-            test_results.append("\n=== Environment Info ===")
-            test_results.append(f"SPACE_ID: {os.getenv('SPACE_ID', 'Not on HF Spaces')}")
-            test_results.append(f"Python: {sys.version.split()[0]}")
+            # 6. Try fixing a2a if needed
+            if "❌ a2a import failed" in "\n".join(test_results):
+                test_results.append("\n=== Attempting Fix ===")
+                try:
+                    # Try reinstalling without deps
+                    result = subprocess.run(
+                        [sys.executable, "-m", "pip", "install", "a2a-sdk", "--no-deps", "--force-reinstall"],
+                        capture_output=True, text=True, timeout=10
+                    )
+                    if result.returncode == 0:
+                        test_results.append("✅ Reinstalled a2a-sdk")
+                        # Test import again
+                        try:
+                            import importlib
+                            if 'a2a' in sys.modules:
+                                del sys.modules['a2a']
+                            import a2a
+                            test_results.append("✅ Import after reinstall: Success!")
+                        except Exception as e:
+                            test_results.append(f"❌ Import after reinstall: {e}")
+                    else:
+                        test_results.append(f"❌ Reinstall failed: {result.stderr[:200]}")
+                except Exception as e:
+                    test_results.append(f"❌ Fix attempt error: {e}")
             
-            if available_count >= 5:
-                test_results.append("\n✅ A2A might work! Try selecting A2A mode.")
+            # Test lightweight A2A requirements
+            test_results.append("\n=== Lightweight A2A Test ===")
+            try:
+                import httpx
+                import fastapi
+                import uvicorn
+                test_results.append("✅ HTTP dependencies available (httpx, fastapi, uvicorn)")
+                lightweight_ready = True
+            except ImportError as e:
+                test_results.append(f"❌ Missing HTTP dependencies: {e}")
+                lightweight_ready = False
+            
+            # Final verdict
+            if available_count >= 6:
+                if "✅ any_agent A2A components: Success!" in "\n".join(test_results):
+                    test_results.append("\n✅ Full A2A available! A2A mode will use the complete protocol.")
+                elif lightweight_ready:
+                    test_results.append("\n✅ Lightweight A2A available! A2A mode will use HTTP-only servers.")
+                else:
+                    test_results.append("\n⚠️ Only Simulated A2A available. A2A mode will use mock communication.")
             else:
                 test_results.append("\n❌ Not enough ports available. Use Basic Multiagent mode.")
             

core/lightweight_a2a_manager.py

@@ -0,0 +1,293 @@
+"""
+Lightweight A2A Manager for HF Spaces - Real distributed agents using HTTP only.
+Works without grpcio dependencies by using httpx and FastAPI directly.
+"""
+
+import asyncio
+import httpx
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+import multiprocessing
+import time
+import socket
+from contextlib import closing
+from core.agent import FantasyDraftAgent
+from core.constants import AGENT_CONFIGS
+
+
+# Pydantic models for API
+class PickRequest(BaseModel):
+    available_players: List[str]
+    previous_picks: List[str]
+    round_num: int
+
+
+class PickResponse(BaseModel):
+    type: str = "pick"
+    player_name: str
+    reasoning: str
+    trash_talk: Optional[str] = None
+
+
+class CommentRequest(BaseModel):
+    picking_team: int
+    player: str
+    round_num: int
+
+
+class CommentResponse(BaseModel):
+    comment: Optional[str]
+
+
+class LightweightA2AAgent:
+    """Single agent server that runs in its own process"""
+    
+    def __init__(self, team_num: int, port: int):
+        self.team_num = team_num
+        self.port = port
+        self.app = FastAPI()
+        self.agent = None
+        self._setup_routes()
+    
+    def _setup_routes(self):
+        @self.app.on_event("startup")
+        async def startup():
+            config = AGENT_CONFIGS[self.team_num]
+            self.agent = FantasyDraftAgent(
+                team_name=config["team_name"],
+                strategy=config["strategy"],
+                traits=config["traits"],
+                rival_teams=config.get("rival_teams", [])
+            )
+            print(f"✅ Agent {self.team_num} initialized on port {self.port}")
+        
+        @self.app.get("/health")
+        async def health():
+            return {"status": "healthy", "team": self.team_num}
+        
+        @self.app.post("/pick", response_model=PickResponse)
+        async def make_pick(request: PickRequest):
+            if not self.agent:
+                raise HTTPException(status_code=500, detail="Agent not initialized")
+            
+            # Update agent's picks
+            self.agent.picks = request.previous_picks.copy()
+            
+            # Make pick
+            player = self.agent.make_pick(request.available_players, request.round_num)
+            reasoning = self.agent.explain_pick(player, request.round_num)
+            
+            # Optional trash talk
+            trash_talk = None
+            import random
+            if random.random() < 0.3:
+                trash_talk = random.choice([
+                    f"Can't believe {player} was still available!",
+                    f"{player} is going to be huge this year!",
+                    "Building a championship team here.",
+                    "Y'all sleeping on my picks!"
+                ])
+            
+            return PickResponse(
+                player_name=player,
+                reasoning=reasoning,
+                trash_talk=trash_talk
+            )
+        
+        @self.app.post("/comment", response_model=CommentResponse)
+        async def make_comment(request: CommentRequest):
+            if not self.agent:
+                raise HTTPException(status_code=500, detail="Agent not initialized")
+            
+            # Higher chance of comment for rivals
+            import random
+            if request.picking_team in self.agent.rival_teams:
+                if random.random() < 0.8:
+                    comment = self.agent.react_to_pick(
+                        f"Team {request.picking_team}",
+                        request.player,
+                        request.round_num
+                    )
+                    return CommentResponse(comment=comment)
+            else:
+                if random.random() < 0.3:
+                    comment = self.agent.react_to_pick(
+                        f"Team {request.picking_team}",
+                        request.player,
+                        request.round_num
+                    )
+                    return CommentResponse(comment=comment)
+            
+            return CommentResponse(comment=None)
+    
+    def run(self):
+        """Run the agent server"""
+        uvicorn.run(self.app, host="127.0.0.1", port=self.port, log_level="error")
+
+
+def _run_agent_server(team_num: int, port: int):
+    """Function to run in separate process"""
+    agent = LightweightA2AAgent(team_num, port)
+    agent.run()
+
+
+class LightweightA2AAgentManager:
+    """
+    Manages lightweight A2A agents using only HTTP (no grpcio).
+    Each agent runs as a FastAPI server in a separate process.
+    """
+    
+    def __init__(self, session_id: str = "lightweight"):
+        self.session_id = session_id
+        self.processes: Dict[int, multiprocessing.Process] = {}
+        self.allocated_ports: List[int] = []
+        self.base_port = 5001
+        self.running = False
+        self.max_comments_per_pick = 2
+        self.client = None
+    
+    def _find_free_port(self, start_port: int) -> int:
+        """Find a free port starting from start_port"""
+        for port in range(start_port, start_port + 100):
+            with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
+                try:
+                    sock.bind(('127.0.0.1', port))
+                    return port
+                except OSError:
+                    continue
+        raise RuntimeError(f"No free ports found starting from {start_port}")
+    
+    async def start_agents(self):
+        """Start all agent servers"""
+        print(f"🚀 Starting lightweight A2A agents for session {self.session_id}...")
+        
+        # Initialize HTTP client
+        self.client = httpx.AsyncClient(timeout=10.0)
+        
+        # Allocate ports and start processes
+        for team_num in [1, 2, 3, 5, 6]:
+            port = self._find_free_port(self.base_port + team_num - 1)
+            self.allocated_ports.append(port)
+            
+            # Start agent process
+            process = multiprocessing.Process(
+                target=_run_agent_server,
+                args=(team_num, port)
+            )
+            process.start()
+            self.processes[team_num] = process
+            
+            print(f"⏳ Starting agent {team_num} on port {port}...")
+        
+        # Wait for all agents to be ready
+        await self._wait_for_agents()
+        
+        self.running = True
+        print(f"✅ All lightweight A2A agents ready!")
+    
+    async def _wait_for_agents(self):
+        """Wait for all agents to respond to health checks"""
+        max_retries = 30
+        for team_num, port in zip([1, 2, 3, 5, 6], self.allocated_ports):
+            url = f"http://127.0.0.1:{port}/health"
+            for i in range(max_retries):
+                try:
+                    response = await self.client.get(url)
+                    if response.status_code == 200:
+                        print(f"✅ Agent {team_num} ready on port {port}")
+                        break
+                except:
+                    pass
+                await asyncio.sleep(0.5)
+            else:
+                raise RuntimeError(f"Agent {team_num} failed to start on port {port}")
+    
+    async def get_pick(self, team_num: int, available_players: List[str], 
+                      previous_picks: List[str], round_num: int) -> Optional[PickResponse]:
+        """Get pick from agent via HTTP"""
+        if team_num not in self.processes:
+            return None
+        
+        port_index = [1, 2, 3, 5, 6].index(team_num)
+        port = self.allocated_ports[port_index]
+        
+        try:
+            response = await self.client.post(
+                f"http://127.0.0.1:{port}/pick",
+                json={
+                    "available_players": available_players,
+                    "previous_picks": previous_picks,
+                    "round_num": round_num
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                return PickResponse(**data)
+            else:
+                print(f"Error from agent {team_num}: {response.status_code}")
+                return None
+        except Exception as e:
+            print(f"Failed to get pick from agent {team_num}: {e}")
+            return None
+    
+    async def get_comment(self, commenting_team: int, picking_team: int, 
+                         player: str, round_num: int) -> Optional[str]:
+        """Get comment from agent via HTTP"""
+        if commenting_team not in self.processes:
+            return None
+        
+        port_index = [1, 2, 3, 5, 6].index(commenting_team)
+        port = self.allocated_ports[port_index]
+        
+        try:
+            response = await self.client.post(
+                f"http://127.0.0.1:{port}/comment",
+                json={
+                    "picking_team": picking_team,
+                    "player": player,
+                    "round_num": round_num
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                return data.get("comment")
+            else:
+                return None
+        except Exception as e:
+            print(f"Failed to get comment from agent {commenting_team}: {e}")
+            return None
+    
+    async def cleanup(self):
+        """Stop all agent servers"""
+        if self.running:
+            print(f"🛑 Stopping lightweight A2A agents for session {self.session_id}...")
+            
+            # Close HTTP client
+            if self.client:
+                await self.client.aclose()
+            
+            # Terminate all processes
+            for team_num, process in self.processes.items():
+                if process.is_alive():
+                    process.terminate()
+                    process.join(timeout=2)
+                    if process.is_alive():
+                        process.kill()
+                        process.join()
+                print(f"✅ Agent {team_num} stopped")
+            
+            self.processes.clear()
+            self.allocated_ports.clear()
+            self.running = False
+            print(f"✅ Lightweight A2A session {self.session_id} cleaned up")
+
+
+# Provide same cleanup function interface
+async def cleanup_session(manager: LightweightA2AAgentManager):
+    """Clean up a lightweight A2A session"""
+    if manager:
+        await manager.cleanup() 

core/simulated_a2a_manager.py

@@ -0,0 +1,136 @@
+"""
+Simulated A2A Manager for environments where real A2A won't work (like HF Spaces).
+Provides the same interface and experience as real A2A but uses in-process communication.
+"""
+
+import asyncio
+import time
+import random
+from typing import Optional, List, Dict
+from core.agent import FantasyDraftAgent
+from core.constants import AGENT_CONFIGS
+
+
+class SimulatedA2AResponse:
+    """Simulated response that looks like an A2A response"""
+    def __init__(self, player_name: str, reasoning: str, trash_talk: Optional[str] = None):
+        self.type = "pick"
+        self.player_name = player_name
+        self.reasoning = reasoning
+        self.trash_talk = trash_talk
+
+
+class SimulatedA2AAgentManager:
+    """
+    Simulates A2A behavior without actual HTTP servers.
+    Provides the same interface as DynamicA2AAgentManager but runs in-process.
+    """
+    
+    def __init__(self, session_id: str = "sim"):
+        self.session_id = session_id
+        self.agents: Dict[int, FantasyDraftAgent] = {}
+        self.running = False
+        self.max_comments_per_pick = 2
+        # Simulate port allocation
+        self.allocated_ports = [5001, 5002, 5003, 5004, 5005, 5006]
+        
+    async def start_agents(self):
+        """Initialize agents (simulated startup)"""
+        print(f"🚀 Starting simulated A2A agents for session {self.session_id}...")
+        
+        # Simulate startup delay
+        await asyncio.sleep(0.5)
+        
+        # Create agents
+        for team_num in [1, 2, 3, 5, 6]:
+            config = AGENT_CONFIGS[team_num]
+            self.agents[team_num] = FantasyDraftAgent(
+                team_name=config["team_name"],
+                strategy=config["strategy"],
+                traits=config["traits"],
+                rival_teams=config.get("rival_teams", [])
+            )
+        
+        # Simulate server startup messages
+        for team_num, port in zip([1, 2, 3, 5, 6], self.allocated_ports):
+            await asyncio.sleep(0.1)
+            print(f"✅ Agent {team_num} ready on simulated port {port}")
+        
+        self.running = True
+        print(f"✅ All simulated A2A agents ready!")
+        
+    async def get_pick(self, team_num: int, available_players: List[str], 
+                      previous_picks: List[str], round_num: int) -> Optional[SimulatedA2AResponse]:
+        """Get pick from agent (simulated A2A call)"""
+        if team_num not in self.agents:
+            return None
+        
+        # Simulate network delay
+        await asyncio.sleep(random.uniform(0.2, 0.5))
+        
+        agent = self.agents[team_num]
+        
+        # Get pick decision
+        player = agent.make_pick(available_players, round_num)
+        
+        # Get reasoning
+        reasoning = agent.explain_pick(player, round_num)
+        
+        # Maybe add trash talk
+        trash_talk = None
+        if random.random() < 0.3:  # 30% chance of trash talk
+            responses = [
+                f"Easy choice. Can't believe {player} was still available!",
+                f"You all sleeping? {player} is a steal here!",
+                f"Building a championship team, one pick at a time.",
+                "This is how you draft, take notes everyone."
+            ]
+            trash_talk = random.choice(responses)
+        
+        return SimulatedA2AResponse(player, reasoning, trash_talk)
+        
+    async def get_comment(self, commenting_team: int, picking_team: int, 
+                         player: str, round_num: int) -> Optional[str]:
+        """Get comment from another agent (simulated A2A call)"""
+        if commenting_team not in self.agents:
+            return None
+        
+        # Simulate network delay
+        await asyncio.sleep(random.uniform(0.1, 0.3))
+        
+        agent = self.agents[commenting_team]
+        
+        # Higher chance of comment if they're rivals
+        if picking_team in agent.rival_teams:
+            if random.random() < 0.8:  # 80% chance for rivals
+                return agent.react_to_pick(
+                    self.agents[picking_team].team_name,
+                    player,
+                    round_num
+                )
+        else:
+            if random.random() < 0.3:  # 30% chance for non-rivals
+                return agent.react_to_pick(
+                    self.agents[picking_team].team_name,
+                    player,
+                    round_num
+                )
+        
+        return None
+        
+    async def cleanup(self):
+        """Cleanup simulated agents"""
+        if self.running:
+            print(f"🛑 Stopping simulated A2A agents for session {self.session_id}...")
+            # Simulate shutdown
+            await asyncio.sleep(0.2)
+            self.agents.clear()
+            self.running = False
+            print(f"✅ Simulated A2A session {self.session_id} cleaned up")
+
+
+# Provide same cleanup function interface
+async def cleanup_session(manager: SimulatedA2AAgentManager):
+    """Clean up a simulated A2A session"""
+    if manager:
+        await manager.cleanup() 

requirements_hf.txt

@@ -0,0 +1,22 @@
+# Special requirements for Hugging Face Spaces
+# Avoids grpcio dependencies that won't install properly
+
+# Install any-agent WITHOUT a2a extras
+any-agent[openai]>=0.21.0
+
+# Direct HTTP dependencies
+httpx>=0.24.0
+fastapi>=0.100.0
+uvicorn>=0.22.0
+sse-starlette>=1.6.0
+
+# App dependencies
+python-dotenv
+pydantic>=2.0.0
+gradio>=4.0.0
+nest-asyncio
+aiohttp
+typing-extensions
+
+# Note: We'll use httpx directly for A2A-like communication
+# without the heavyweight grpcio dependencies