Upload folder using huggingface_hub

README.md

@@ -11,35 +11,120 @@ license: mit
 python_version: 3.11
 ---
 
-# 🏈 Fantasy Draft Multi-Agent Demo
+# 🏈 Fantasy Football Multi-Agent Draft System
 
-Experience AI agents with distinct personalities competing in a fantasy football draft! You play as Team 4 with an AI advisor.
+An interactive fantasy football draft simulation featuring 6 AI agents with distinct personalities and strategies, built using the `any-agent` framework.
 
-## Features
+## ✨ Features
 
-- **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 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
+- **Interactive Mock Draft**: Play as Team 4 with 5 AI opponents
+- **Distinct Agent Strategies**: Zero RB, Robust RB, Best Player Available, Upside Hunter
+- **Multi-Turn Memory**: Agents remember picks and conversations throughout the draft
+- **Agent Communication**: Agents comment on and respond to each other's picks
+- **Strategic Advisor**: AI advisor helps you make informed draft decisions
+- **Visual Draft Board**: Track all picks with a beautiful, real-time updated interface
+- **Customizable Personalities**: Modify each agent's personality and trash-talk style
 
-## Setup
+## 🚀 Quick Start
 
-1. Add your OpenAI API key in **Settings → Repository secrets** as `OPENAI_API_KEY`
-2. The app will start automatically once deployed
+### Prerequisites
+- Python 3.8+
+- OpenAI API key
 
-## About Communication Modes
+### Installation
 
-- **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)
+```bash
+# Clone the repository
+git clone <your-repo-url>
+cd fantasy-draft-agent
 
-## About
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
 
-Built with the [any-agent](https://github.com/any-agent/any-agent) framework, showcasing how modern LLMs can create engaging multi-agent experiences.
+# Install dependencies
+pip install -r requirements.txt
+
+# Set your OpenAI API key
+export OPENAI_API_KEY='your-key-here'  # On Windows: set OPENAI_API_KEY=your-key-here
+```
+
+### Running the Application
+
+```bash
+cd apps
+python app.py
+```
+
+Then open your browser to `http://localhost:7860`
+
+## 🎮 How to Play
+
+1. **Start the Draft**: Click "🏈 Start Mock Draft"
+2. **Watch AI Picks**: Agents draft in snake order with commentary
+3. **Make Your Pick**: When it's your turn (Position 4), type a player name
+4. **Get Advice**: Your AI advisor provides recommendations based on available players
+5. **Enjoy the Banter**: Watch agents trash-talk and defend their strategies
+
+## 🤖 The Agents
+
+- **Team 1 - Zero RB** 📘🤓: Avoids RBs early, loads up on WRs
+- **Team 2 - BPA** 📗🧑‍💼: Pure value drafting, mocks reaching
+- **Team 3 - Robust RB** 📙🧔: Old-school RB-heavy approach
+- **Team 4 - YOU** 👤: Your position with AI advisor
+- **Team 5 - Upside Hunter** 📓🤠: High risk/reward picks
+- **Team 6 - BPA** 📗👨‍🏫: Another value drafter
+
+## 🛠️ Technical Details
+
+Built with:
+- **any-agent**: Lightweight multi-agent framework
+- **Gradio**: Interactive web interface
+- **OpenAI GPT-4**: Powers agent decision-making
+- **Multi-turn memory**: Agents maintain conversation history
+
+## 📁 Project Structure
+
+```
+fantasy-draft-agent/
+├── apps/
+│   ├── app.py                   # Main Gradio interface
+│   ├── multiagent_draft.py      # Core draft logic
+│   └── multiagent_scenarios.py  # Agent communication scenarios
+├── core/
+│   ├── agent.py                 # Base agent implementation
+│   ├── data.py                  # Player data and rankings
+│   └── constants.py             # Configuration constants
+└── requirements.txt
+```
+
+## 🎯 Key Features Explained
+
+### Multi-Agent System
+- Each agent runs independently with its own strategy
+- Agents maintain memory of all interactions
+- Natural rivalries create engaging commentary
+
+### Interactive Gameplay
+- Real-time draft board visualization
+- Strategic advisor provides contextual recommendations
+- Customizable agent personalities
+
+### Memory System
+- Agents remember previous picks and conversations
+- References to earlier interactions create continuity
+- Strategic adaptation based on draft flow
+
+## 🚦 Deployment
+
+The application is designed to run locally or on cloud platforms like Hugging Face Spaces. The single-process architecture ensures reliable performance without complex networking requirements.
+
+## 📝 License
+
+[Your License Here]
+
+## 🤝 Contributing
+
+Contributions welcome! Please feel free to submit a Pull Request.
 
 [View Source Code](https://github.com/alexmeckes/fantasydraft) 

app.py

@@ -1,132 +1,17 @@
 #!/usr/bin/env python3
 """
-Entry point for Hugging Face Spaces and local deployment.
-All dependencies should be installed via requirements.txt.
+Entry point for the Fantasy Draft Multi-Agent application.
 """
 
 import os
 import sys
 
-# Apply typing compatibility patch for Python 3.11 BEFORE any other imports
-from datetime import datetime
-print(f"\n===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====\n")
+# Add current directory to path
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import typing_patch
 
 # Simple startup message
 if os.getenv("SPACE_ID"):
     print("🤗 Running on Hugging Face Spaces...")
-    
-    # Check A2A installation
-    print("🔍 Checking A2A installation...")
-    
-    # Check any-agent version
-    try:
-        import any_agent
-        print(f"✅ any-agent version: {any_agent.__version__}")
-    except ImportError as e:
-        print(f"❌ any-agent not installed: {e}")
-
-    # Check for httpx
-    try:
-        import httpx
-        print(f"✅ httpx version: {httpx.__version__}")
-    except ImportError as e:
-        print(f"❌ httpx not installed: {e}")
-
-    # Check for a2a module
-    try:
-        import a2a
-        import importlib.metadata
-        a2a_version = importlib.metadata.version('a2a-sdk')
-        print(f"✅ a2a module found (a2a-sdk version: {a2a_version})")
-    except ImportError as e:
-        print(f"❌ a2a module not found: {e}")
-
-    # Check if any_agent.serving exists
-    try:
-        import any_agent.serving
-        print("✅ any_agent.serving module found")
-    except ImportError as e:
-        print(f"❌ any_agent.serving module not found: {e}")
-        
-    # Check for AgentSkill specifically
-    try:
-        from a2a.types import AgentSkill
-        print("✅ AgentSkill import successful")
-    except ImportError as e:
-        print(f"❌ AgentSkill import failed: {e}")
-        
-    # Check for server dependencies
-    print("\n🔍 Checking server dependencies:")
-    try:
-        import uvicorn
-        print(f"✅ uvicorn found: {uvicorn.__version__}")
-    except ImportError as e:
-        print(f"❌ uvicorn not found: {e}")
-        
-    try:
-        import starlette
-        print(f"✅ starlette found: {starlette.__version__}")
-    except ImportError as e:
-        print(f"❌ starlette not found: {e}")
-        
-    try:
-        from a2a.server import apps
-        print("✅ a2a.server.apps found")
-    except ImportError as e:
-        print(f"❌ a2a.server.apps not found: {e}")
-        
-    try:
-        import sse_starlette
-        print("✅ sse-starlette found")
-    except ImportError as e:
-        print(f"❌ sse-starlette not found: {e}")
-        
-    # Test the specific imports that any_agent.serving tries
-    print("\n🔍 Testing any_agent.serving imports:")
-    
-    # Test A2AServingConfig import
-    try:
-        from any_agent.serving.a2a.config_a2a import A2AServingConfig
-        print("✅ A2AServingConfig direct import successful")
-    except ImportError as e:
-        print(f"❌ A2AServingConfig direct import failed: {e}")
-        
-    # Test server_a2a imports
-    try:
-        from any_agent.serving.a2a.server_a2a import serve_a2a
-        print("✅ serve_a2a direct import successful")
-    except ImportError as e:
-        print(f"❌ serve_a2a direct import failed: {e}")
-        
-    # Test other imports from server_a2a
-    try:
-        from any_agent.serving.a2a.server_a2a import (
-            _get_a2a_app,
-            _get_a2a_app_async,
-            serve_a2a_async,
-        )
-        print("✅ All server_a2a imports successful")
-    except ImportError as e:
-        print(f"❌ server_a2a imports failed: {e}")
-        import traceback
-        traceback.print_exc()
-
-    # Try to import A2AServingConfig with more detailed error handling
-    try:
-        from any_agent.serving import A2AServingConfig
-        print("✅ A2AServingConfig import successful")
-    except ImportError as e:
-        print(f"❌ Import error: {e}")
-        # Try to get more details
-        try:
-            import traceback
-            print("Full traceback:")
-            traceback.print_exc()
-        except:
-            pass
-        
 else:
     print("🖥️ Running locally...")
 

apps/app.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-Fantasy Draft Multi-Agent Demo - Enhanced with A2A Support
-Combines the superior UI from the main app with real A2A capabilities
+Fantasy Draft Multi-Agent Demo
+Multi-agent system using the any-agent framework for fantasy football drafts
 """
 
 import os
@@ -12,7 +12,7 @@ import nest_asyncio
 from typing import List, Tuple, Optional, Dict
 from dotenv import load_dotenv
 import sys
-import os
+
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from core.agent import FantasyDraftAgent
@@ -20,21 +20,7 @@ from core.data import TOP_PLAYERS
 from core.constants import (
     TYPING_DELAY_SECONDS,
     MESSAGE_DELAY_SECONDS,
-    AGENT_START_DELAY,
-    AGENT_STARTUP_WAIT,
-    DEFAULT_TIMEOUT,
-    MAX_COMMENTS_PER_PICK,
-    RIVAL_PAIRS,
-    AGENT_CONFIGS
-)
-from core.a2a_helpers import (
-    parse_a2a_response,
-    extract_task_id,
-    format_available_players
 )
-# Lazy import A2A components to avoid import errors on HF Spaces
-DynamicA2AAgentManager = None
-cleanup_session = None
 
 from apps.multiagent_draft import MultiAgentMockDraft
 from apps.multiagent_scenarios import (
@@ -45,9 +31,6 @@ from apps.multiagent_scenarios import (
     create_mock_draft_visualization
 )
 
-# A2A components will be imported lazily when needed
-# to avoid import errors on Hugging Face Spaces
-
 # Apply nest_asyncio for async in Gradio
 nest_asyncio.apply()
 
@@ -58,314 +41,30 @@ os.environ['OPENAI_API_BASE'] = 'https://api.openai.com/v1'
 load_dotenv()
 
 
-class EnhancedFantasyDraftApp:
+class FantasyDraftApp:
     def __init__(self):
         self.current_draft = None  # Store the current mock draft
         self.draft_output = ""  # Store the draft output so far
-        self.a2a_manager = None  # Will be created dynamically with session ID
-        self.use_real_a2a = False
-        self.a2a_status = "Not initialized"
-        self.session_id = None
         self.custom_prompts = {}  # Store custom agent prompts
     
-    async def toggle_a2a_mode(self, use_a2a: bool):
-        """Toggle between basic multiagent and A2A modes."""
-        self.use_real_a2a = use_a2a
-        
-        if use_a2a:
-            # Lazy import A2A components only when needed
-            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:
-                # 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 e2:
-                    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:
-                import uuid
-                self.session_id = str(uuid.uuid4())[:8]
-            
-            # Create new dynamic manager for this session with custom prompts
-            self.a2a_manager = DynamicA2AAgentManager(
-                self.session_id,
-                custom_prompts=self.custom_prompts
-            )
-            
-            try:
-                await self.a2a_manager.start_agents()
-                ports = self.a2a_manager.allocated_ports
-                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)}"
-                self.use_real_a2a = False
-                self.a2a_manager = None
-        else:
-            if self.a2a_manager and cleanup_session:
-                await cleanup_session(self.a2a_manager)
-                self.a2a_manager = None
-            self.a2a_status = "✅ Basic Multiagent Mode Active (Using built-in communication)"
-        
-        return self.a2a_status
-    
-    def run_multiagent_demo(self, use_a2a: bool = False):
-        """Run the mock draft demonstration with optional A2A support."""
+    def run_multiagent_demo(self):
+        """Run the mock draft demonstration."""
         # Reset any previous draft
         self.current_draft = None
         self.draft_output = ""
         
-        # First, set the mode (like in the working version)
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        
-        status = loop.run_until_complete(self.toggle_a2a_mode(use_a2a))
-        yield f"**Mode:** {status}\n\n"
-        
-        # Initialize draft
-        self.current_draft = MultiAgentMockDraft(user_pick_position=4)
+        # Use basic multiagent draft
+        draft_generator = run_interactive_mock_draft()
         
-        # Run the appropriate draft
-        if use_a2a and self.a2a_manager:
-            yield from self.run_a2a_draft()
-        else:
-            # Use basic multiagent draft
-            draft_generator = run_interactive_mock_draft()
-            
-            for output in draft_generator:
-                if isinstance(output, tuple):
-                    # This means it's the user's turn
-                    self.current_draft, self.draft_output = output
-                    yield self.draft_output + "\n<!--USER_TURN-->"
-                    return
-                else:
-                    self.draft_output = output
-                    yield output
-    
-    def run_a2a_draft(self):
-        """Run draft with A2A communication."""
-        # Initialize draft
-        self.current_draft = MultiAgentMockDraft(user_pick_position=4)
-        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_msg
-        )
-        yield self.draft_output
-        
-        # Run draft rounds
-        loop = asyncio.get_event_loop()
-        
-        for round_num in range(1, 4):  # 3 rounds
-            self.draft_output += f"\n## 🔄 ROUND {round_num}\n\n"
-            yield self.draft_output
-            
-            # Snake draft order
-            if round_num % 2 == 1:
-                pick_order = list(range(1, 7))
+        for output in draft_generator:
+            if isinstance(output, tuple):
+                # This means it's the user's turn
+                self.current_draft, self.draft_output = output
+                yield self.draft_output + "\n<!--USER_TURN-->"
+                return
             else:
-                pick_order = list(range(6, 0, -1))
-            
-            for pick_in_round, team_num in enumerate(pick_order, 1):
-                pick_num = (round_num - 1) * 6 + pick_in_round
-                
-                # Show draft board at start of round
-                if pick_in_round == 1:
-                    self.draft_output += create_mock_draft_visualization(self.current_draft, round_num, pick_num)
-                    self.draft_output += "\n"
-                    yield self.draft_output
-                
-                if team_num == 4:  # User's turn
-                    # Get advisor recommendation - use user_advisor directly
-                    advisor = self.current_draft.user_advisor
-                    
-                    # Get available players
-                    all_picked = [p for picks in self.current_draft.draft_board.values() for p in picks]
-                    available = [p for p in TOP_PLAYERS.keys() if p not in all_picked]
-                    
-                    # Get other agent strategies for advisor context
-                    strategies = {f"Team {i}": agent.strategy for i, agent in self.current_draft.agents.items()}
-                    
-                    # Get advisor recommendation
-                    advice = advisor.advise_user(available, self.current_draft.draft_board, strategies)
-                    
-                    # Show advisor message
-                    self.draft_output += format_agent_message(advisor, "USER", advice)
-                    yield self.draft_output
-                    
-                    self.draft_output += "\n**⏰ YOU'RE ON THE CLOCK! Type your pick below.**\n\n"
-                    yield self.draft_output + "\n<!--USER_TURN-->"
-                    return
-                else:
-                    # A2A agent pick
-                    messages = loop.run_until_complete(
-                        self.run_a2a_draft_turn(team_num, round_num, pick_num)
-                    )
-                    
-                    # Display messages with typing effect
-                    for msg in messages:
-                        if len(msg) >= 3:
-                            agent, recipient, content = msg[:3]
-                            
-                            # Show "..." first for typing effect
-                            typing_placeholder = format_agent_message(agent, recipient, "...")
-                            self.draft_output += typing_placeholder
-                            yield self.draft_output
-                            time.sleep(TYPING_DELAY_SECONDS)
-                            
-                            # Replace with actual message
-                            self.draft_output = self.draft_output.replace(typing_placeholder, "")
-                            self.draft_output += format_agent_message(agent, recipient, content)
-                            yield self.draft_output
-                            time.sleep(MESSAGE_DELAY_SECONDS)
-                    
-                    time.sleep(TYPING_DELAY_SECONDS)
-            
-            # End of round
-            self.draft_output += format_agent_message("commissioner", "ALL", 
-                f"That's the end of Round {round_num}!")
-            yield self.draft_output
-        
-        # Final summary
-        self.draft_output += "\n## 📊 FINAL RESULTS\n\n"
-        self.draft_output += self.current_draft.get_draft_summary()
-        yield self.draft_output
-        
-        # Clear the draft state
-        self.current_draft = None
-    
-    async def run_a2a_draft_turn(self, team_num: int, round_num: int, pick_num: int):
-        """Run a draft turn using A2A."""
-        messages = []
-        
-        # Commissioner announcement
-        messages.append((
-            self.current_draft.commissioner,
-            "ALL",
-            f"Team {team_num} is on the clock!"
-        ))
-        
-        # Get available players
-        all_picked = [p for picks in self.current_draft.draft_board.values() for p in picks]
-        available = [p for p in TOP_PLAYERS.keys() if p not in all_picked]
-        
-        # Get pick from A2A agent
-        previous_picks = self.current_draft.draft_board.get(team_num, [])
-        pick_result = await self.a2a_manager.get_pick(team_num, available, previous_picks, round_num)
-        
-        if not pick_result or pick_result.type != "pick":
-            # Fallback to simulation
-            messages.append((
-                self.current_draft.commissioner,
-                "ALL",
-                f"⚠️ Team {team_num} A2A agent not responding - using simulation"
-            ))
-            
-            sim_messages, _ = self.current_draft.simulate_draft_turn(round_num, pick_num, team_num)
-            messages.extend(sim_messages)
-            return messages
-        
-        # Make the pick
-        player = pick_result.player_name
-        self.current_draft.draft_board[team_num].append(player)
-        
-        # Update agent's picks if it exists
-        agent = self.current_draft.agents.get(team_num)
-        if agent:
-            agent.picks.append(player)
-        
-        # Commissioner announcement of pick
-        pick_num = len([p for picks in self.current_draft.draft_board.values() for p in picks])
-        confirm_msg = self.current_draft.commissioner.confirm_pick(
-            agent.team_name if agent else f"Team {team_num}", 
-            player, 
-            pick_num
-        )
-        messages.append((self.current_draft.commissioner, "ALL", confirm_msg))
-        
-        # Agent explains reasoning
-        messages.append((
-            agent if agent else "system",
-            "ALL",
-            f"{pick_result.reasoning}"
-        ))
-        
-        if pick_result.trash_talk:
-            messages.append((
-                agent if agent else "system",
-                "ALL",
-                pick_result.trash_talk
-            ))
-        
-        # Get comments from other A2A agents
-        potential_commenters = [t for t in [1, 2, 3, 5, 6] if t != team_num and t != 4]
-        
-        # Sort commenters to prioritize rivals
-        if team_num in RIVAL_PAIRS and potential_commenters:
-            rivals = RIVAL_PAIRS[team_num]
-            if isinstance(rivals, int):
-                rivals = [rivals]
-            # Put rivals first in the list
-            prioritized_commenters = [t for t in rivals if t in potential_commenters]
-            prioritized_commenters.extend([t for t in potential_commenters if t not in prioritized_commenters])
-            potential_commenters = prioritized_commenters
-        
-        # Collect comments up to the configured limit
-        comment_count = 0
-        max_comments = self.a2a_manager.max_comments_per_pick
-        
-        # Reduce comments if we're getting late in the draft
-        if pick_num >= 4:  # After pick 4, reduce comments
-            max_comments = min(max_comments, 1)
-        
-        for other_team in potential_commenters:
-            if comment_count >= max_comments:
-                break
-                
-            comment = await self.a2a_manager.get_comment(other_team, team_num, player, round_num)
-            if comment:
-                other_agent = self.current_draft.agents.get(other_team)
-                if other_agent:
-                    # Use the same pattern as earlier for the picking agent's name
-                    picking_agent_name = agent.team_name if agent else f"Team {team_num}"
-                    messages.append((
-                        other_agent,
-                        picking_agent_name,
-                        comment
-                    ))
-                    comment_count += 1
-        
-        return messages
+                self.draft_output = output
+                yield output
     
     def continue_mock_draft(self, player_name: str):
         """Continue the mock draft after user makes a pick."""
@@ -402,26 +101,16 @@ class EnhancedFantasyDraftApp:
                     time.sleep(MESSAGE_DELAY_SECONDS)
         
         # Continue with the rest of the draft
-        if self.use_real_a2a and self.a2a_manager:
-            yield from self.continue_a2a_draft()
-        else:
-            yield from self.continue_basic_multiagent_draft()
+        yield from self.continue_basic_multiagent_draft()
     
-    def continue_a2a_draft(self):
-        """Continue A2A draft after user pick."""
+    def continue_basic_multiagent_draft(self):
+        """Continue basic multiagent draft after user pick."""
         # Calculate where we are
         total_picks = len([p for picks in self.current_draft.draft_board.values() for p in picks])
         current_round = ((total_picks - 1) // 6) + 1
         
-        # Get or create event loop
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        
-        # Continue from current position
-        for round_num in range(current_round, 4):
+        # Continue from where we left off
+        for round_num in range(current_round, 4):  # Continue through round 3
             if round_num > current_round:
                 self.draft_output += f"\n## 🔄 ROUND {round_num}\n\n"
                 yield self.draft_output
@@ -432,11 +121,15 @@ class EnhancedFantasyDraftApp:
             else:
                 pick_order = list(range(6, 0, -1))
             
-            # Calculate where we are in the current round
+            # Calculate where we are in this round
             picks_in_round = total_picks % 6
-            start_idx = picks_in_round if round_num == current_round else 0
+            if round_num == current_round:
+                # Skip picks already made
+                start_idx = picks_in_round
+            else:
+                start_idx = 0
             
-            for pick_in_round, team_num in enumerate(list(pick_order)[start_idx:], start_idx + 1):
+            for pick_in_round, team_num in enumerate(pick_order[start_idx:], start_idx + 1):
                 pick_num = (round_num - 1) * 6 + pick_in_round
                 
                 # Show draft board at start of round
@@ -445,17 +138,21 @@ class EnhancedFantasyDraftApp:
                     self.draft_output += "\n"
                     yield self.draft_output
                 
-                if team_num == 4:  # User's turn again
-                    # Get advisor recommendation - use user_advisor directly
+                if team_num == 4:  # User's turn
+                    # Get advisor recommendation
                     advisor = self.current_draft.user_advisor
                     
+                    # Get available players
                     all_picked = [p for picks in self.current_draft.draft_board.values() for p in picks]
                     available = [p for p in TOP_PLAYERS.keys() if p not in all_picked]
                     
                     # Get other agent strategies for advisor context
                     strategies = {f"Team {i}": agent.strategy for i, agent in self.current_draft.agents.items()}
                     
+                    # Get advisor recommendation
                     advice = advisor.advise_user(available, self.current_draft.draft_board, strategies)
+                    
+                    # Show advisor message
                     self.draft_output += format_agent_message(advisor, "USER", advice)
                     yield self.draft_output
                     
@@ -463,19 +160,21 @@ class EnhancedFantasyDraftApp:
                     yield self.draft_output + "\n<!--USER_TURN-->"
                     return
                 else:
-                    # A2A agent pick
-                    messages = loop.run_until_complete(
-                        self.run_a2a_draft_turn(team_num, round_num, pick_num)
-                    )
+                    # AI agent pick
+                    messages, _ = self.current_draft.simulate_draft_turn(round_num, pick_num, team_num)
                     
+                    # Display messages with typing effect
                     for msg in messages:
                         if len(msg) >= 3:
                             agent, recipient, content = msg[:3]
+                            
+                            # Show "..." first for typing effect
                             typing_placeholder = format_agent_message(agent, recipient, "...")
                             self.draft_output += typing_placeholder
                             yield self.draft_output
                             time.sleep(TYPING_DELAY_SECONDS)
                             
+                            # Replace with actual message
                             self.draft_output = self.draft_output.replace(typing_placeholder, "")
                             self.draft_output += format_agent_message(agent, recipient, content)
                             yield self.draft_output
@@ -483,6 +182,7 @@ class EnhancedFantasyDraftApp:
                     
                     time.sleep(TYPING_DELAY_SECONDS)
             
+            # End of round
             self.draft_output += format_agent_message("commissioner", "ALL", 
                 f"That's the end of Round {round_num}!")
             yield self.draft_output
@@ -492,87 +192,12 @@ class EnhancedFantasyDraftApp:
         self.draft_output += self.current_draft.get_draft_summary()
         yield self.draft_output
         
-        self.current_draft = None
-    
-    def continue_basic_multiagent_draft(self):
-        """Continue basic multiagent draft after user pick."""
-        # This is the original logic from app.py
-        total_picks = len([p for picks in self.current_draft.draft_board.values() for p in picks])
-        current_round = ((total_picks - 1) // 6) + 1
-        
-        draft_memories = []
-        
-        for round_num in range(current_round, 4):
-            if round_num > current_round:
-                self.draft_output += f"\n## 🔄 ROUND {round_num}\n\n"
-                yield self.draft_output
-            
-            if round_num % 2 == 1:
-                pick_order = list(range(1, 7))
-            else:
-                pick_order = list(range(6, 0, -1))
-            
-            picks_in_round = total_picks % 6
-            start_idx = picks_in_round if round_num == current_round else 0
-            
-            for pick_in_round, team_num in enumerate(list(pick_order)[start_idx:], start_idx + 1):
-                pick_num = (round_num - 1) * 6 + pick_in_round
-                
-                if pick_in_round == 1:
-                    self.draft_output += create_mock_draft_visualization(self.current_draft, round_num, pick_num)
-                    self.draft_output += "\n"
-                    yield self.draft_output
-                
-                messages, result = self.current_draft.simulate_draft_turn(round_num, pick_num, team_num)
-                
-                for msg in messages:
-                    if len(msg) >= 3:
-                        agent, recipient, content = msg[:3]
-                        
-                        if isinstance(agent, str) and agent.startswith("typing_"):
-                            continue
-                        else:
-                            typing_placeholder = format_agent_message(agent, recipient, "...")
-                            self.draft_output += typing_placeholder
-                            yield self.draft_output
-                            time.sleep(TYPING_DELAY_SECONDS)
-                            
-                            self.draft_output = self.draft_output.replace(typing_placeholder, "")
-                            self.draft_output += format_agent_message(agent, recipient, content)
-                            yield self.draft_output
-                            time.sleep(MESSAGE_DELAY_SECONDS)
-                
-                if result is None:
-                    self.draft_output += "\n**⏰ YOU'RE ON THE CLOCK! Type your pick below.**\n\n"
-                    yield self.draft_output + "\n<!--USER_TURN-->"
-                    return
-                
-                if round_num > 1 and pick_in_round % 2 == 0:
-                    if team_num in self.current_draft.agents:
-                        agent = self.current_draft.agents[team_num]
-                        if len(agent.picks) > 1:
-                            memory = f"{agent.team_name} has drafted: {', '.join(agent.picks)}"
-                            draft_memories.append(memory)
-                    
-                    if draft_memories:
-                        self.draft_output += format_memory_indicator(round_num, draft_memories[-2:])
-                        yield self.draft_output
-                
-                time.sleep(TYPING_DELAY_SECONDS)
-            
-            self.draft_output += format_agent_message("commissioner", "ALL", 
-                f"That's the end of Round {round_num}!")
-            yield self.draft_output
-        
-        self.draft_output += "\n## 📊 FINAL RESULTS\n\n"
-        self.draft_output += self.current_draft.get_draft_summary()
-        yield self.draft_output
-        
+        # Clear the draft state
         self.current_draft = None
 
 
 def create_gradio_interface():
-    """Create the main Gradio interface with A2A support."""
+    """Create the main Gradio interface."""
     
     with gr.Blocks(title="Fantasy Draft Multi-Agent Demo", theme=gr.themes.Soft()) as demo:
         # Create state for each user session
@@ -588,25 +213,6 @@ def create_gradio_interface():
             with gr.Tabs():
                 # Demo Tab
                 with gr.TabItem("🎮 Demo"):
-                    # Add A2A Mode Toggle
-                    with gr.Row():
-                        with gr.Column():
-                            gr.Markdown("### 🔧 Communication Mode")
-                            communication_mode = gr.Radio(
-                                ["A2A", "Basic Multiagent"],
-                                value="Basic Multiagent",
-                                label="Select how agents communicate",
-                                info="A2A: Distributed agents on HTTP servers | Basic Multiagent: Single-process execution"
-                            )
-                            mode_info = gr.Markdown(
-                                """
-                                **Basic Multiagent** (Default): Fast single-process execution with reliable performance
-                                **A2A**: Each agent runs on its own HTTP server with distributed architecture
-                                
-                                *Basic Multiagent mode is recommended for Hugging Face Spaces deployments.*
-                                """
-                            )
-                    
                     # Show agent cards
                     gr.Markdown("""
                     ### 🏈 Meet Your Competition
@@ -636,7 +242,7 @@ def create_gradio_interface():
                                 team1_settings_btn = gr.Button("⚙️ Customize", size="sm", variant="secondary")
                                 with gr.Column(visible=False) as team1_prompt_col:
                                     team1_prompt = gr.Textbox(
-                                        label="Team 1 Personality & Strategy (Output format is fixed)",
+                                        label="Team 1 Personality & Strategy",
                                         value="""You are Team 1, a fantasy football manager with Zero RB strategy.
 
 PERSONALITY & STRATEGY:
@@ -655,7 +261,7 @@ Your EXTREME philosophy: RUNNING BACKS ARE DEAD TO ME! 💀 While others waste e
 BE LOUD! BE PROUD! BE UNFORGETTABLE! 🎯""",
                                         lines=15,
                                         interactive=True,
-                                        info="Customize personality and strategy. Output format instructions are automatically included."
+                                        info="Customize personality and strategy."
                                     )
                                     team1_save_btn = gr.Button("💾 Save", size="sm", variant="primary")
                         
@@ -676,7 +282,7 @@ BE LOUD! BE PROUD! BE UNFORGETTABLE! 🎯""",
                                 team2_settings_btn = gr.Button("⚙️ Customize", size="sm", variant="secondary")
                                 with gr.Column(visible=False) as team2_prompt_col:
                                     team2_prompt = gr.Textbox(
-                                        label="Team 2 Personality & Strategy (Output format is fixed)",
+                                        label="Team 2 Personality & Strategy",
                                         value="""You are Team 2, a fantasy football manager with BPA (Best Player Available) strategy.
 
 PERSONALITY & STRATEGY:
@@ -694,7 +300,7 @@ Your EXTREME philosophy: PROCESS OVER EVERYTHING! 📊 I don't care about your "
 BE RUTHLESS! BE RIGHT! BE THE VALUE VULTURE! 🦅""",
                                         lines=15,
                                         interactive=True,
-                                        info="Customize personality and strategy. Output format instructions are automatically included."
+                                        info="Customize personality and strategy."
                                     )
                                     team2_save_btn = gr.Button("💾 Save", size="sm", variant="primary")
                         
@@ -715,7 +321,7 @@ BE RUTHLESS! BE RIGHT! BE THE VALUE VULTURE! 🦅""",
                                 team3_settings_btn = gr.Button("⚙️ Customize", size="sm", variant="secondary")
                                 with gr.Column(visible=False) as team3_prompt_col:
                                     team3_prompt = gr.Textbox(
-                                        label="Team 3 Personality & Strategy (Output format is fixed)",
+                                        label="Team 3 Personality & Strategy",
                                         value="""You are Team 3, a fantasy football manager with Robust RB strategy.
 
 PERSONALITY & STRATEGY:
@@ -733,7 +339,7 @@ Your EXTREME philosophy: GROUND AND POUND FOREVER! 🏃‍♂️ These young pun
 BE STUBBORN! BE TRADITIONAL! ESTABLISH THE RUN! 🏈""",
                                         lines=15,
                                         interactive=True,
-                                        info="Customize personality and strategy. Output format instructions are automatically included."
+                                        info="Customize personality and strategy."
                                     )
                                     team3_save_btn = gr.Button("💾 Save", size="sm", variant="primary")
                         
@@ -768,7 +374,7 @@ BE STUBBORN! BE TRADITIONAL! ESTABLISH THE RUN! 🏈""",
                                 team5_settings_btn = gr.Button("⚙️ Customize", size="sm", variant="secondary")
                                 with gr.Column(visible=False) as team5_prompt_col:
                                     team5_prompt = gr.Textbox(
-                                        label="Team 5 Personality & Strategy (Output format is fixed)",
+                                        label="Team 5 Personality & Strategy",
                                         value="""You are Team 5, a fantasy football manager with Upside Hunter strategy.
 
 PERSONALITY & STRATEGY:
@@ -786,7 +392,7 @@ Your EXTREME philosophy: BOOM OR BUST, BABY! 💥 Why settle for consistent medi
 BE BOLD! BE RECKLESS! SWING FOR THE FENCES! ⚡""",
                                         lines=15,
                                         interactive=True,
-                                        info="Customize personality and strategy. Output format instructions are automatically included."
+                                        info="Customize personality and strategy."
                                     )
                                     team5_save_btn = gr.Button("💾 Save", size="sm", variant="primary")
                         
@@ -807,7 +413,7 @@ BE BOLD! BE RECKLESS! SWING FOR THE FENCES! ⚡""",
                                 team6_settings_btn = gr.Button("⚙️ Customize", size="sm", variant="secondary")
                                 with gr.Column(visible=False) as team6_prompt_col:
                                     team6_prompt = gr.Textbox(
-                                        label="Team 6 Personality & Strategy (Output format is fixed)",
+                                        label="Team 6 Personality & Strategy",
                                         value="""You are Team 6, a fantasy football manager with BPA (Best Player Available) strategy.
 
 PERSONALITY & STRATEGY:
@@ -825,7 +431,7 @@ Your EXTREME philosophy: THE SPREADSHEET NEVER LIES! 📈 I have SEVENTEEN model
 BE ANALYTICAL! BE MERCILESS! TRUST THE PROCESS! 🤖""",
                                         lines=15,
                                         interactive=True,
-                                        info="Customize personality and strategy. Output format instructions are automatically included."
+                                        info="Customize personality and strategy."
                                     )
                                     team6_save_btn = gr.Button("💾 Save", size="sm", variant="primary")
                     
@@ -863,40 +469,6 @@ BE ANALYTICAL! BE MERCILESS! TRUST THE PROCESS! 🤖""",
                                     interactive=False
                                 )
                 
-                # Debug Tab
-                with gr.TabItem("🔍 Debug"):
-                    gr.Markdown("""
-                    ## A2A Debugging Tools
-                    
-                    Use these tools to test A2A functionality and diagnose any issues.
-                    """)
-                    
-                    with gr.Row():
-                        with gr.Column():
-                            test_a2a_btn = gr.Button("🧪 Test A2A Dependencies & Ports", variant="primary", size="lg")
-                            test_network_btn = gr.Button("🌐 Test Network Connectivity", variant="secondary", size="lg")
-                            
-                    a2a_test_output = gr.Textbox(
-                        label="Test Results", 
-                        lines=20, 
-                        interactive=False,
-                        elem_classes=["monospace"]
-                    )
-                    
-                    gr.Markdown("""
-                    ### What this test checks:
-                    - ✓ Python environment and version
-                    - ✓ a2a-sdk package installation
-                    - ✓ Module imports (a2a, any_agent)
-                    - ✓ Port availability for agents
-                    - ✓ A2A agent startup capability
-                    
-                    ### Common issues:
-                    - **Import errors**: Check if a2a-sdk is properly installed
-                    - **Port conflicts**: Other services might be using ports 5000-9000
-                    - **Timeout errors**: Network latency on cloud deployments
-                    """)
-                
                 # How It Works Tab
                 with gr.TabItem("🔧 How It Works"):
                     gr.Markdown("""
@@ -919,28 +491,15 @@ BE ANALYTICAL! BE MERCILESS! TRUST THE PROCESS! 🤖""",
                     - **Strategy Memory**: Remembers own strategy and others' approaches
                     - **Pick History**: Tracks all selections for informed decisions
                     
-                    ### 💬 Agent-to-Agent (A2A) Communication
+                    ### 💬 Single-Process Multi-Agent Communication
                     
-                    **Two Modes Available:**
-                    
-                    #### 1. A2A Mode (Default) ✨
-                    - **Distributed Architecture**: Each agent runs on its own HTTP server
-                    - **Dynamic Ports**: Each session gets unique ports automatically (5000-9000 range)
-                    - **True Isolation**: No shared memory, HTTP communication only
-                    - **Production Ready**: Scalable to multiple machines
-                    - **Real HTTP Calls**: Agents communicate via actual network requests
-                    - **Task Continuity**: Conversation context maintained across turns
-                    
-                    #### 2. Basic Multiagent Mode
-                    - Single process, direct method calls
-                    - Shared memory between agents
-                    - Fast execution, simple debugging
-                    - Fallback option if A2A requirements aren't met
+                    - **In-Memory Communication**: Agents interact directly via method calls
+                    - **Shared Draft State**: All agents see the same draft board
+                    - **Fast Execution**: No network overhead
+                    - **Conversation Memory**: Each agent remembers interactions
                     
                     ### 📊 Architecture Flow
-                    """)
                     
-                    gr.Markdown("""
                     #### 1️⃣ INITIALIZATION
                     User clicks "Start Mock Draft" → System creates 6 agents
                     
@@ -959,7 +518,7 @@ BE ANALYTICAL! BE MERCILESS! TRUST THE PROCESS! 🤖""",
                     
                     #### 4️⃣ EACH PICK TRIGGERS
                     - Agent makes selection based on strategy
-                    - Other agents comment (A2A communication)
+                    - Other agents comment based on rivalries
                     - Original agent may respond
                     - All agents update their memory
                     
@@ -1009,376 +568,161 @@ BE ANALYTICAL! BE MERCILESS! TRUST THE PROCESS! 🤖""",
                     ""  # Clear the input
                 )
         
-        # Test A2A functionality
-        def test_a2a_functionality():
-            """Test A2A dependencies and port availability."""
-            import socket
-            import subprocess
-            import importlib.util
-            import site
-            
-            test_results = []
-            
-            # 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:
-                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.types
-                    test_results.append("✅ import a2a.types: Success")
-                    try:
-                        from a2a.types import AgentSkill
-                        test_results.append("✅ from a2a.types import AgentSkill: Success")
-                    except ImportError as e:
-                        test_results.append(f"❌ AgentSkill import: {e}")
-                except ImportError as e:
-                    test_results.append(f"❌ a2a.types import: {e}")
-            except ImportError as e:
-                test_results.append(f"❌ a2a import failed: {e}")
-            
-            # 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)
-                    sock.bind(('127.0.0.1', port))
-                    test_results.append(f"✅ Port {port} available")
-                    available_count += 1
-                    sock.close()
-                except Exception:
-                    test_results.append(f"❌ Port {port} not available")
-            
-            test_results.append(f"\n📊 Summary: {available_count}/{len(test_ports)} ports available")
-            
-            # 6. Check any-agent version if imports failed
-            if "❌ any_agent A2A import" in "\n".join(test_results):
-                test_results.append("\n=== Version Check ===")
-                try:
-                    result = subprocess.run([sys.executable, "-m", "pip", "show", "any-agent"], 
-                                          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:')]
-                        if version_line:
-                            test_results.append(f"any-agent version: {version_line[0]}")
-                            # Check if version is < 0.22
-                            import re
-                            version_match = re.search(r'Version: (\d+)\.(\d+)', version_line[0])
-                            if version_match:
-                                major, minor = int(version_match.group(1)), int(version_match.group(2))
-                                if major == 0 and minor < 22:
-                                    test_results.append("⚠️ any-agent version < 0.22.0 - A2A components not available")
-                                    test_results.append("💡 Solution: Update requirements.txt to any-agent[a2a,openai]>=0.22.0")
-                except Exception as e:
-                    test_results.append(f"Could not check any-agent version: {e}")
-            
-            # Final verdict
-            if available_count >= 6 and "✅ any_agent A2A components: Success!" in "\n".join(test_results):
-                test_results.append("\n✅ A2A should work! Try selecting A2A mode.")
-            else:
-                test_results.append("\n❌ A2A requirements not met. Use Basic Multiagent mode.")
-            
-            return "\n".join(test_results)
-        
-        # Test network connectivity for A2A
-        async def test_network_connectivity():
-            """Test network connectivity for A2A servers."""
-            import httpx
-            
-            results = []
-            results.append("=== A2A Network Connectivity Test ===")
-            results.append(f"Running on HF Spaces: {bool(os.getenv('SPACE_ID'))}\n")
-            
-            # Test different host configurations
-            configs = [
-                ("localhost", 8000, "Local loopback"),
-                ("127.0.0.1", 8000, "IP loopback"),
-                ("0.0.0.0", 8000, "All interfaces"),
-            ]
-            
-            for host, port, desc in configs:
-                results.append(f"Testing {host}:{port} ({desc})...")
-                
-                timeout = httpx.Timeout(timeout=5.0, connect=2.0, read=5.0)
-                
-                async with httpx.AsyncClient(timeout=timeout) as client:
-                    # Test basic connectivity
-                    try:
-                        response = await client.get(f"http://{host}:{port}/")
-                        results.append(f"  ✅ Connected: HTTP {response.status_code}")
-                    except httpx.ConnectError:
-                        results.append(f"  ❌ Connection refused (no server)")
-                    except httpx.ReadTimeout:
-                        results.append(f"  ❌ Read timeout (server not responding)")
-                    except Exception as e:
-                        results.append(f"  ❌ Error: {type(e).__name__}")
-                
-                results.append("")
-            
-            results.append("=== Recommendations ===")
-            if os.getenv("SPACE_ID"):
-                results.append("On HF Spaces:")
-                results.append("• A2A servers bind to 0.0.0.0 for external access")
-                results.append("• Clients connect via 127.0.0.1 internally")
-                results.append("• Network timeouts are common - retries help")
-                results.append("• Consider Basic Multiagent mode for reliability")
-            else:
-                results.append("Local development:")
-                results.append("• Both localhost and 127.0.0.1 should work")
-                results.append("• Check firewall if connections fail")
-            
-            return "\n".join(results)
-        
-        # No need for separate mode change handler - it happens when draft starts
-        
-        # Functions to handle prompt editing
+        # Toggle prompt visibility
         def toggle_prompt_visibility():
-            """Toggle prompt editor visibility."""
             return gr.update(visible=True)
         
+        # Save prompt
         def save_prompt(team_num, prompt_text, app, prompts_dict):
-            """Save custom prompt for a team."""
+            """Save a custom prompt for a team."""
             if app is None:
-                app = EnhancedFantasyDraftApp()
-            if prompts_dict is None:
-                prompts_dict = {}
-            
+                app = FantasyDraftApp()
             prompts_dict[team_num] = prompt_text
-            app.custom_prompts[team_num] = prompt_text
+            app.custom_prompts = prompts_dict
             return app, prompts_dict, gr.update(visible=False)
         
-        # Run multi-agent demo with control visibility handling
-        def run_and_check(mode, app, prompts_dict):
-            """Run demo and check for user turn."""
-            # Create a new app instance for this user if needed
+        # Run and check function
+        def run_and_check(app, prompts_dict):
+            """Run the draft and check for user turns."""
             if app is None:
-                app = EnhancedFantasyDraftApp()
-            
-            # Apply custom prompts if any
-            if prompts_dict:
+                app = FantasyDraftApp()
                 app.custom_prompts = prompts_dict
             
-            use_a2a = (mode == "A2A")
-            for output in app.run_multiagent_demo(use_a2a):
-                result = check_user_turn(output, app)
-                yield result + (app,)  # Return the app state as the last element
-        
-        # Wire up settings buttons for each team
-        team1_settings_btn.click(toggle_prompt_visibility, [], [team1_prompt_col])
-        team2_settings_btn.click(toggle_prompt_visibility, [], [team2_prompt_col])
-        team3_settings_btn.click(toggle_prompt_visibility, [], [team3_prompt_col])
-        team5_settings_btn.click(toggle_prompt_visibility, [], [team5_prompt_col])
-        team6_settings_btn.click(toggle_prompt_visibility, [], [team6_prompt_col])
+            generator = app.run_multiagent_demo()
+            output = ""
+            
+            for chunk in generator:
+                output = chunk
+                # Check if it's user's turn
+                if "<!--USER_TURN-->" in output:
+                    break
+                yield output, app, gr.update(), gr.update(), gr.update(), ""
+            
+            # Final yield with turn check
+            clean_output, controls_update, accordion_update, available_text, input_clear = check_user_turn(output, app)
+            yield clean_output, app, controls_update, accordion_update, available_text, input_clear
+        
+        # Set up event handlers
+        # Team prompt toggles
+        team1_settings_btn.click(
+            toggle_prompt_visibility,
+            outputs=team1_prompt_col
+        )
+        team2_settings_btn.click(
+            toggle_prompt_visibility,
+            outputs=team2_prompt_col
+        )
+        team3_settings_btn.click(
+            toggle_prompt_visibility,
+            outputs=team3_prompt_col
+        )
+        team5_settings_btn.click(
+            toggle_prompt_visibility,
+            outputs=team5_prompt_col
+        )
+        team6_settings_btn.click(
+            toggle_prompt_visibility,
+            outputs=team6_prompt_col
+        )
         
-        # Wire up save buttons
+        # Save prompts
         team1_save_btn.click(
-            lambda p, a, d: save_prompt(1, p, a, d),
-            [team1_prompt, app_state, agent_prompts],
-            [app_state, agent_prompts, team1_prompt_col]
+            lambda prompt, app, prompts: save_prompt(1, prompt, app, prompts),
+            inputs=[team1_prompt, app_state, agent_prompts],
+            outputs=[app_state, agent_prompts, team1_prompt_col]
         )
         team2_save_btn.click(
-            lambda p, a, d: save_prompt(2, p, a, d),
-            [team2_prompt, app_state, agent_prompts],
-            [app_state, agent_prompts, team2_prompt_col]
+            lambda prompt, app, prompts: save_prompt(2, prompt, app, prompts),
+            inputs=[team2_prompt, app_state, agent_prompts],
+            outputs=[app_state, agent_prompts, team2_prompt_col]
         )
         team3_save_btn.click(
-            lambda p, a, d: save_prompt(3, p, a, d),
-            [team3_prompt, app_state, agent_prompts],
-            [app_state, agent_prompts, team3_prompt_col]
+            lambda prompt, app, prompts: save_prompt(3, prompt, app, prompts),
+            inputs=[team3_prompt, app_state, agent_prompts],
+            outputs=[app_state, agent_prompts, team3_prompt_col]
         )
         team5_save_btn.click(
-            lambda p, a, d: save_prompt(5, p, a, d),
-            [team5_prompt, app_state, agent_prompts],
-            [app_state, agent_prompts, team5_prompt_col]
+            lambda prompt, app, prompts: save_prompt(5, prompt, app, prompts),
+            inputs=[team5_prompt, app_state, agent_prompts],
+            outputs=[app_state, agent_prompts, team5_prompt_col]
         )
         team6_save_btn.click(
-            lambda p, a, d: save_prompt(6, p, a, d),
-            [team6_prompt, app_state, agent_prompts],
-            [app_state, agent_prompts, team6_prompt_col]
+            lambda prompt, app, prompts: save_prompt(6, prompt, app, prompts),
+            inputs=[team6_prompt, app_state, agent_prompts],
+            outputs=[app_state, agent_prompts, team6_prompt_col]
         )
         
+        # Start mock draft
         run_multiagent_btn.click(
-            run_and_check,
-            [communication_mode, app_state, agent_prompts],
-            [multiagent_output, mock_draft_controls, available_accordion, available_players_display, draft_pick_input, app_state],
-            show_progress=True
-        )
-        
-        # Wrapper for async network test
-        def run_network_test():
-            """Run the async network test."""
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            return loop.run_until_complete(test_network_connectivity())
-        
-        # Wire up test buttons
-        test_a2a_btn.click(
-            test_a2a_functionality,
-            [],
-            [a2a_test_output]
-        )
-        
-        test_network_btn.click(
-            run_network_test,
-            [],
-            [a2a_test_output]
+            lambda app, prompts: run_and_check(app, prompts),
+            inputs=[app_state, agent_prompts],
+            outputs=[multiagent_output, app_state, mock_draft_controls, available_accordion, available_players_display, draft_pick_input]
         )
         
-        # Continue draft after user pick
-        def submit_and_continue(player_name, app):
-            """Submit pick and continue draft."""
-            if app is None:
-                yield ("No active draft. Please start a new mock draft.", 
-                       gr.update(visible=False), gr.update(visible=False), "", "", None)
-                return
-                
-            for output in app.continue_mock_draft(player_name):
-                result = check_user_turn(output, app)
-                yield result + (app,)  # Return the app state as the last element
-        
+        # Submit pick button
         submit_pick_btn.click(
             submit_and_continue,
-            [draft_pick_input, app_state],
-            [multiagent_output, mock_draft_controls, available_accordion, available_players_display, draft_pick_input, app_state],
-            show_progress=True
+            inputs=[draft_pick_input, app_state],
+            outputs=[multiagent_output, app_state, mock_draft_controls, available_accordion, available_players_display, draft_pick_input]
         )
         
-        # Also submit on enter
+        # Submit pick on Enter
         draft_pick_input.submit(
             submit_and_continue,
-            [draft_pick_input, app_state],
-            [multiagent_output, mock_draft_controls, available_accordion, available_players_display, draft_pick_input, app_state],
-            show_progress=True
+            inputs=[draft_pick_input, app_state],
+            outputs=[multiagent_output, app_state, mock_draft_controls, available_accordion, available_players_display, draft_pick_input]
         )
         
-        # Minimal CSS for layout only
+        # Custom CSS for styling
         demo.css = """
         #main-container {
-            max-width: 1200px;
+            max-width: 1400px;
             margin: 0 auto;
         }
         
         .multiagent-output {
-            max-height: 800px;
+            max-height: 600px;
             overflow-y: auto;
+            padding: 20px;
+            background: #f5f5f5;
+            border-radius: 8px;
         }
         
-        /* Force dark text in message cards */
-        .multiagent-output div[style*="background-color"] {
-            color: #212121 !important;
-        }
-        
-        .multiagent-output div[style*="background-color"] * {
-            color: #212121 !important;
+        #draft-pick-input {
+            font-size: 1.2em;
+            padding: 10px;
         }
         
         #start-button {
-            margin-top: 20px;
+            font-size: 1.2em;
+            padding: 15px 30px;
         }
         
-        /* Monospace font for debug output */
-        .monospace textarea {
-            font-family: 'Courier New', Courier, monospace;
-            font-size: 12px;
-        }
-        
-        /* Settings button styling */
-        button[variant="secondary"] {
-            margin-top: 8px;
-            width: 100%;
-        }
-        
-        /* Prompt editor styling */
-        .prompt-editor {
-            margin-top: 10px;
-            padding: 10px;
-            background-color: #f5f5f5;
-            border-radius: 4px;
+        .monospace {
+            font-family: 'Courier New', monospace;
         }
         """
-        
-        # Note: Gradio's unload() doesn't support inputs, so automatic cleanup
-        # happens when the Python process ends or when new sessions override old ones
     
     return demo
 
 
 def main():
-    """Main entry point."""
-    # Check for API key - but don't exit on Hugging Face Spaces
-    if not os.getenv("OPENAI_API_KEY"):
-        if os.getenv("SPACE_ID"):  # Running on Hugging Face Spaces
-            print("⚠️  OPENAI_API_KEY not found - please set it in Space Settings > Repository secrets")
-        else:
-            print("Error: OPENAI_API_KEY not found in environment")
-            print("Please set it using: export OPENAI_API_KEY='your-key-here'")
-            exit(1)
+    """Launch the Gradio app."""
+    # Set environment variables for cloud deployment
+    if os.getenv("SPACE_ID"):  # Running on Hugging Face Spaces
+        print("🤗 Running on Hugging Face Spaces")
+        os.environ["GRADIO_SERVER_NAME"] = "0.0.0.0"
+        os.environ["GRADIO_SERVER_PORT"] = "7860"
     
     # Create and launch the interface
     demo = create_gradio_interface()
     
-    print("🚀 Launching Enhanced Fantasy Draft App with A2A Support...")
-    
-    # Check if running on Hugging Face Spaces
-    if os.getenv("SPACE_ID"):
-        demo.launch()  # Hugging Face handles server config
-    else:
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=True,
-            show_error=True
-        )
+    # Launch with appropriate settings
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0" if os.getenv("SPACE_ID") else None,
+        server_port=7860 if os.getenv("SPACE_ID") else None
+    )
 
 
 if __name__ == "__main__":

apps/multiagent_draft.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 Multi-Agent Mock Draft Implementation
-Demonstrates A2A communication and multi-turn memory
+Demonstrates agent communication and multi-turn memory
 """
 
 import time

core/constants.py

@@ -1,13 +1,10 @@
 """
-Constants for the Fantasy Draft A2A implementation.
+Constants for the Fantasy Draft Multi-Agent implementation.
 """
 
 # Timing constants (in seconds)
 TYPING_DELAY_SECONDS = 0.5
 MESSAGE_DELAY_SECONDS = 1.0
-AGENT_START_DELAY = 5.0  # Increased from 3.0 to give agents more time to fully initialize
-AGENT_STARTUP_WAIT = 1.0  # Increased from 0.5 to ensure each agent is ready
-DEFAULT_TIMEOUT = 90.0  # Increased further for HF Spaces network latency
 
 # Comment configuration
 MAX_COMMENTS_PER_PICK = 1  # Reduced for more concise draft flow
@@ -19,48 +16,4 @@ RIVAL_PAIRS = {
     5: [2, 6], # Upside Hunter vs BPA agents
     2: 5,      # BPA vs Upside Hunter
     6: 5,      # BPA vs Upside Hunter
-}
-
-# A2A Agent configurations
-AGENT_CONFIGS = [
-    {
-        "team_name": "Team 1",
-        "team_num": 1,
-        "strategy": "Zero RB",
-        "port": 5001,
-        "philosophy": "RBs are INJURY MAGNETS! 🏥 WRs are the future! I'm building an AIR RAID OFFENSE that will DESTROY your pathetic ground game! 💨✈️",
-        "emoji_style": ["✈️", "💨", "🏥", "🎯"],
-    },
-    {
-        "team_name": "Team 2",
-        "team_num": 2,
-        "strategy": "BPA",
-        "port": 5002,
-        "philosophy": "I am the VALUE VULTURE! 🦅 I feast on your emotional reaches while I build a CHAMPIONSHIP ROSTER with pure analytics! 📊📈",
-        "emoji_style": ["🦅", "📊", "📈", "💰"],
-    },
-    {
-        "team_name": "Team 3",
-        "team_num": 3,
-        "strategy": "Robust RB",
-        "port": 5003,
-        "philosophy": "GROUND AND POUND, BABY! 💪 Your fancy WRs will be watching from the sidelines while my RBs BULLDOZE their way to victory! 🚜💥",
-        "emoji_style": ["💪", "🚜", "💥", "🏃"],
-    },
-    {
-        "team_name": "Team 5",
-        "team_num": 5,
-        "strategy": "Upside Hunter",
-        "port": 5005,
-        "philosophy": "BOOM OR BUST! 🎰🚀 Safe picks are for COWARDS! I'm swinging for the fences while you play it safe like a SCARED LITTLE MOUSE! 🐭💣",
-        "emoji_style": ["🎰", "🚀", "💣", "⚡"],
-    },
-    {
-        "team_name": "Team 6",
-        "team_num": 6,
-        "strategy": "BPA",
-        "port": 5006,
-        "philosophy": "Another spreadsheet warrior here to EXPLOIT your terrible decisions! 🤓💻 My algorithm laughs at your 'gut feelings'! 🤖📉",
-        "emoji_style": ["🤓", "💻", "🤖", "📉"],
-    },
-] 
+} 

docs/FEATURES_AND_ENHANCEMENTS.md

@@ -2,203 +2,143 @@
 
 ## Core Features
 
-### 🤖 Multi-Agent System
-- **6 AI Agents**: Each with distinct personality and strategy
-- **User Position**: Player drafts at position 4 with AI advisor
-- **3-Round Draft**: Snake draft format (1→6, 6→1, 1→6)
-- **Real-time Interaction**: Agents comment and react to picks
-
-### 🎭 Agent Personalities
-
-#### Team 1 - Zero RB (📘🤓)
-- **Strategy**: Avoids RBs early, loads up on elite WRs
-- **Personality**: Analytical, confident in contrarian approach
-- **Catchphrase**: "RBs get injured. I'll build around elite WRs."
-
-#### Team 2 & 6 - Best Player Available (📗🧑‍💼/👨‍🏫)
-- **Strategy**: Pure value drafting, ignores positional needs
-- **Personality**: Disciplined, mocks others for reaching
-- **Catchphrase**: "Value is value. I don't reach for needs."
-
-#### Team 3 - Robust RB (📙🧔)
-- **Strategy**: Prioritizes RBs in rounds 1-2
-- **Personality**: Traditional, old-school approach
-- **Catchphrase**: "RBs win championships. Period."
-
-#### Team 5 - Upside Hunter (📓🤠)
-- **Strategy**: Seeks high-risk, high-reward players
-- **Personality**: Bold, mocks conservative picks
-- **Catchphrase**: "Safe picks are for losers!"
-
-#### User's Advisor (📕🧙)
-- **Role**: Provides strategic advice to the user
-- **Features**: Analyzes board state, suggests best picks, explains reasoning
-
-### 🎨 UI/UX Enhancements
-
-#### Visual Design
-- **Agent Cards**: Color-coded with emojis for easy identification
-- **Message Formatting**: Speaker badges with recipient indicators
-- **Draft Board**: Visual grid showing all picks by round
-- **Dark Text Fix**: Ensures readability on all backgrounds
-
-#### Interactive Elements
-- **Typing Animation**: "..." indicator for realistic feel
-- **Progressive Updates**: Draft unfolds in real-time
-- **Available Players**: Dropdown showing top 20 options
-- **User Input**: Clean interface for making picks
-
-### 💬 Communication Features
-
-#### Conversation System
-- **Directed Messages**: Clear sender → recipient format
-- **Commissioner Announcements**: Official draft updates
-- **Trash Talk**: Agents comment on rivals' picks
-- **Memory Indicators**: Shows when agents reference past events
-
-#### Comment Limiting
-- **Smart Throttling**: Max 2-3 comments per pick
-- **Rival Priority**: Rivals more likely to comment
-- **Natural Flow**: Prevents conversation overload
-
-### 🔧 Technical Features
-
-#### Dual Mode Operation
-1. **Basic Multiagent Mode**
-   - Single process execution
-   - Fast response times
-   - Perfect for development
-
-2. **A2A Mode (Agent-to-Agent)**
-   - Distributed architecture
-   - Each agent on HTTP server
-   - Production-ready setup
-
-#### Multi-User Support
-- **Session Isolation**: Each user gets separate instance
-- **Gradio State Management**: Proper state handling
-- **Dynamic Port Allocation**: No conflicts in A2A mode
-- **Concurrent Users**: Supports multiple simultaneous drafts
-
-### 📊 Draft Features
-
-#### Snake Draft Logic
-- **Round 1**: Picks 1→2→3→4→5→6
-- **Round 2**: Picks 6→5→4→3→2→1 (reverses)
-- **Round 3**: Picks 1→2→3→4→5→6
-
-#### Player Database
-- **50+ Players**: Real NFL players with positions
-- **Team Info**: Current NFL team assignments
-- **Positional Balance**: QBs, RBs, WRs, TEs
-- **Realistic Rankings**: Based on fantasy relevance
-
-#### Draft Intelligence
-- **Strategy Adherence**: Agents follow their strategies
-- **Contextual Decisions**: React to draft flow
-- **Position Scarcity**: Recognize run on positions
-- **Value Recognition**: Identify steals and reaches
-
-### 🚀 Performance Optimizations
-
-#### Configurable Delays
+### 1. Interactive Mock Draft Experience
+- **User Participation**: Play as Team 4 with 5 AI opponents
+- **Real-time Advisor**: Get strategic recommendations based on:
+  - Your current roster needs
+  - Available player values
+  - Other teams' strategies
+  - Position scarcity
+
+### 2. Advanced Multi-Agent System
+- **6 Distinct Agents**: Each with unique strategies and personalities
+- **Multi-Turn Memory**: Agents remember all interactions
+- **Dynamic Comments**: Context-aware reactions to picks
+- **Natural Rivalries**: Zero RB vs Robust RB create engaging banter
+
+### 3. Visual Draft Experience
+- **Live Draft Board**: See all picks organized by team
+- **Round Progress**: Track current round and pick number
+- **Team Rosters**: Visual representation of each team's selections
+- **Available Players**: Searchable list with positions and teams
+
+### 4. Customizable Agents
+- **Personality Editor**: Modify each agent's trash-talk style
+- **Strategy Tuning**: Adjust how aggressive or conservative agents are
+- **Emoji Styles**: Each agent has their own emoji personality
+- **Memory References**: Agents callback to earlier interactions
+
+## Technical Enhancements
+
+### 1. Memory System
+- **Conversation History**: Full context maintained across turns
+- **Pick Tracking**: Agents know who picked whom and when
+- **Strategy Awareness**: Agents understand opponents' approaches
+- **Grudge Memory**: Agents remember who mocked their picks
+
+### 2. Performance Optimizations
+- **Typing Effect**: Natural conversation flow with "..." indicators
+- **Async Processing**: Non-blocking UI during agent turns
+- **Efficient State Management**: Minimal re-renders
+- **Smart Comment Selection**: Rivals prioritized for reactions
+
+### 3. User Experience
+- **Keyboard Shortcuts**: Enter to submit picks
+- **Auto-scroll**: Keeps current action in view
+- **Responsive Design**: Works on various screen sizes
+- **Error Recovery**: Graceful handling of invalid picks
+
+## Configuration Options
+
+### Timing Controls
 ```python
-TYPING_DELAY_SECONDS = 0.3      # "..." display time
-MESSAGE_DELAY_SECONDS = 0.1     # Between messages
-AGENT_START_DELAY = 0.5         # A2A startup spacing
+TYPING_DELAY_SECONDS = 0.5      # "..." display time
+MESSAGE_DELAY_SECONDS = 1.0     # Between messages
+MAX_COMMENTS_PER_PICK = 1       # Keeps draft moving
 ```
 
-#### Resource Management
-- **Async Operations**: Non-blocking agent communication
-- **Timeout Handling**: 30-second default with fallbacks
-- **Memory Efficiency**: Clean state management
-- **Port Cleanup**: Automatic resource release
-
-### 🔐 Reliability Features
-
-#### Error Handling
-- **Graceful Fallbacks**: A2A → simulation if needed
-- **Clear Error Messages**: User-friendly notifications
-- **Validation**: Player name and state checking
-- **Recovery**: Continues draft after errors
-
-#### State Management
-- **Draft Persistence**: Maintains state across turns
-- **Conversation History**: Full context preservation
-- **Pick Validation**: Prevents duplicate selections
-- **Board Updates**: Real-time synchronization
-
-## Recent Enhancements
-
-### 🎨 Custom Agent Prompts (ENHANCED!)
-- **Customizable Personalities**: Edit personality and strategy for each agent
-- **Settings Buttons**: ⚙️ button on each agent card
-- **Live Editing**: Modify prompts before starting draft
-- **Prompt Persistence**: Custom prompts used throughout session
-- **Safe Customization**: Output format instructions are protected
-- **A2A Compatible**: Works with both Basic and A2A modes
-
-#### How to Use:
-1. Click ⚙️ Customize on any agent card
-2. Edit the personality and strategy in the text area
-3. Click 💾 Save to apply changes
-4. Start draft with customized agents
-
-#### Safety Features:
-- **Protected Output Format**: Critical JSON output instructions cannot be modified
-- **Automatic Prepending**: System always includes proper format instructions
-- **Clear Separation**: UI shows only editable personality/strategy parts
-- **Error Prevention**: Prevents users from breaking agent responses
-
-#### Example Customizations:
-- Make Team 1 obsessed with tight ends instead of WRs
-- Turn Team 3 into a modern analytics-based drafter
-- Create a peaceful Team 5 that never trash talks
-- Give agents specific player targets or avoid lists
-- Change personality traits while maintaining functionality
-
-### Task ID Implementation
-- Simplified A2A conversation tracking
-- Removed redundant history management
-- Cleaner code architecture
-- Better framework integration
-
-### Text Readability Fix
-- Dark text on all backgrounds
-- Explicit color styling
-- Fixed message card contrast
-- Improved overall readability
-
-### Dynamic Port Allocation
-- Support for 100+ concurrent A2A sessions
-- Automatic port assignment (5000-9000)
-- Session-based isolation
-- Conflict prevention
-
-### Enhanced Multi-User Support
-- Full session isolation
-- Gradio State implementation
-- Proper callback handling
-- Warning messages for A2A limitations
-
-## Usage Tips
-
-### For Best Experience
-1. Start with Basic Multiagent mode for speed
-2. Try A2A mode to see distributed architecture
-3. Watch for memory indicators showing context
-4. Pay attention to rival interactions
-
-### Customization Options
-- Adjust delays in `constants.py`
-- Modify agent strategies in `agent.py`
-- Add players to `data.py`
-- Customize UI in `apps/app.py`
-
-## Future Possibilities
-- WebSocket real-time updates
-- Custom league settings
-- More agent personalities
-- Advanced statistics
-- Trade negotiations
-- Dynasty league support 
+### Rivalry System
+```python
+RIVAL_PAIRS = {
+    1: 3,      # Zero RB vs Robust RB
+    3: 1,      # Mutual rivalry
+    5: [2, 6], # Upside vs BPA agents
+}
+```
+
+## Agent Strategies
+
+### 1. Zero RB (Team 1)
+- Avoids RBs in early rounds
+- Prioritizes elite WRs
+- Mocks traditional RB-heavy approaches
+- Gets RB value in later rounds
+
+### 2. Best Player Available (Teams 2 & 6)
+- Pure value-based drafting
+- Ignores positional needs
+- Critical of "reaching" for positions
+- Cold, analytical approach
+
+### 3. Robust RB (Team 3)
+- RBs in rounds 1-2 mandatory
+- Old-school philosophy
+- Hates modern passing game trends
+- Values "workhorse" backs
+
+### 4. Upside Hunter (Team 5)
+- Seeks high-ceiling players
+- Willing to take risks
+- Mocks "safe" picks
+- Boom-or-bust mentality
+
+## Unique Implementation Details
+
+### 1. Dynamic Prompt Generation
+- Context-aware responses based on:
+  - Current round
+  - Previous picks
+  - Available players
+  - Recent conversations
+
+### 2. Natural Language Processing
+- Agents avoid raw statistics in speech
+- Convert ADP numbers to natural phrases
+- Use strategy-appropriate vocabulary
+- Maintain consistent personality
+
+### 3. Competitive Dynamics
+- Agents defend their strategies aggressively
+- No polite, generic responses
+- Real draft room atmosphere
+- Escalating rivalries as draft progresses
+
+## Future Enhancement Ideas
+
+1. **Draft Analysis**
+   - Post-draft grades for each team
+   - Strategy effectiveness metrics
+   - Win probability projections
+
+2. **Extended Rounds**
+   - Support for full 15+ round drafts
+   - Bench strategy considerations
+   - Late-round sleeper picks
+
+3. **Custom Scoring**
+   - PPR vs Standard scoring impacts
+   - Dynasty league considerations
+   - Keeper league strategies
+
+4. **Historical Data**
+   - Previous season performance
+   - Injury history considerations
+   - Breakout candidate identification
+
+## Tips for Best Experience
+
+1. **Starting Fresh**: Each draft is independent
+2. **Pick Timing**: Take your time, agents will wait
+3. **Name Matching**: Type player names as shown
+4. **Enjoy the Banter**: Let agents build rivalries
+5. **Experiment**: Try different strategies yourself 

requirements.txt

@@ -5,31 +5,18 @@ python-dotenv
 pydantic>=2.0.0
 typing-extensions
 nest-asyncio
-aiohttp
 
-# Step 2: Install a2a-sdk (provides 'a2a' module)
-# Pin to specific version for consistency
-a2a-sdk==0.2.9
-
-# Step 3: Install any-agent with both a2a and openai extras
+# Step 2: Install any-agent with OpenAI support
 # Version 0.22+ required for any_agent.serving module
-any-agent[a2a,openai]>=0.22.0
+any-agent[openai]>=0.22.0
 
-# Step 4: Additional dependencies (if not pulled in by any-agent)
+# Step 3: Additional dependencies (if not pulled in by any-agent)
 # These might already be installed by any-agent[openai] but we list them to be sure
 openai>=1.0.0
 litellm>=1.0.0
 
-# Step 5: Gradio last (it has many dependencies)
+# Step 4: Gradio last (it has many dependencies)
 gradio==4.36.0
 
 # Compatibility pins to satisfy transitive dependency constraints discovered during HF Spaces build
 markupsafe==2.1.5           # gradio constraint (~=2.0)
-fsspec>=2023.1.0,<=2025.3.0 # datasets constraint (<=2025.3.0)
-
-# Optional: HTTP dependencies for lightweight A2A
-httpx>=0.24.0
-fastapi>=0.115.0
-uvicorn>=0.22.0
-starlette>=0.46.0,<0.47.0
-sse-starlette>=2.3.6,<2.4.0