Upload folder using huggingface_hub

.env.example

@@ -0,0 +1,12 @@
+# OpenAI API Key (required)
+OPENAI_API_KEY=your-openai-api-key-here
+
+# Optional: Use a different model provider
+# ANTHROPIC_API_KEY=your-anthropic-key-here
+# GOOGLE_API_KEY=your-google-key-here
+
+# Optional: Change default model
+# DEFAULT_MODEL=gpt-4o-mini
+
+# Optional: Change default framework
+# DEFAULT_FRAMEWORK=tinyagent

.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Environment variables
+.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+scenario_*_transcript.md
+*.log
+.cache/
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# Gradio cache
+.gradio/
+
+# Test files
+test_*.py
+
+# Deployment prep
+prepare_for_deployment.py 

README.md

@@ -1,12 +1,41 @@
 ---
-title: Fantasy Draft Demo
-emoji: 🐨
-colorFrom: purple
+title: fantasy-draft-demo
+emoji: 🏈
+colorFrom: blue
 colorTo: green
 sdk: gradio
-sdk_version: 5.35.0
+sdk_version: 4.36.0
 app_file: app.py
 pinned: false
+license: mit
+python_version: 3.11
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🏈 Fantasy Draft Multi-Agent Demo
+
+Experience AI agents with distinct personalities competing in a fantasy football draft! You play as Team 4 with an AI advisor.
+
+## 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 on HTTP servers (limited on free tier)
+- **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
+
+## Setup
+
+1. Add your OpenAI API key in **Settings → Repository secrets** as `OPENAI_API_KEY`
+2. The app will start automatically once deployed
+
+## Note on A2A Mode
+
+A2A mode requires ports 5000-9000 for agent servers. On Hugging Face Spaces free tier, port availability may be limited. If A2A mode fails, the app will suggest using Basic Multiagent mode instead.
+
+## About
+
+Built with the [any-agent](https://github.com/any-agent/any-agent) framework, showcasing how modern LLMs can create engaging multi-agent experiences.
+
+[View Source Code](https://github.com/alexmeckes/fantasydraft) 

README_ORIGINAL.md

@@ -0,0 +1,282 @@
+# 🏈 Fantasy Draft Agent MVP
+
+An AI-powered fantasy football draft assistant built with [any-agent](https://github.com/any-agent/any-agent) framework. This MVP demonstrates multi-turn conversation capabilities through pre-crafted scenarios, showcasing how AI can maintain context and provide strategic draft advice.
+
+## 🎯 Features
+
+- **Multi-turn Conversations**: Maintains context across multiple interactions
+- **Strategic Draft Advice**: Provides recommendations based on draft position and available players
+- **Position Analysis**: Evaluates scarcity and tier breakdowns
+- **Team Stacking**: Identifies QB-receiver correlations
+- **Interactive Mode**: Real-time draft assistance
+- **Demo Scenarios**: 4 pre-built scenarios showcasing different capabilities
+- **Web Interface**: Beautiful Gradio UI for easy interaction
+- **Multi-Agent Mock Draft**: Watch AI agents communicate and compete in a live draft
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.8+
+- OpenAI API key (or compatible LLM API)
+
+### Installation
+
+1. Clone the repository:
+```bash
+git clone <your-repo-url>
+cd fantasy-draft-agent
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Set up your API key (recommended method):
+```bash
+# Create .env file from template
+cp .env.example .env
+
+# Edit .env and add your OpenAI API key
+# The file should contain:
+# OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxx
+```
+
+Alternative method (less secure):
+```bash
+export OPENAI_API_KEY='your-api-key-here'
+```
+
+### Test Installation
+
+```bash
+python demo.py --test
+```
+
+## 🔑 API Key Setup
+
+The app uses `python-dotenv` to automatically load your API key from a `.env` file:
+
+1. **Create `.env` file**: `cp .env.example .env`
+2. **Edit `.env`**: Add your key: `OPENAI_API_KEY=sk-proj-xxxxx`
+3. **Never commit `.env`**: It's already in `.gitignore`
+
+See [ENV_SETUP.md](ENV_SETUP.md) for detailed instructions.
+
+## 🎮 Usage
+
+### Web Interface (Recommended)
+
+Launch the Gradio web interface for the best experience:
+
+```bash
+python apps/app.py
+```
+
+Then open http://localhost:7860 in your browser.
+
+The web interface includes:
+- **💬 Draft Assistant**: Interactive chat with context retention
+- **📊 Player Analysis**: Compare players and analyze positions
+- **🎯 Available Players**: Browse and filter available players
+- **🎬 Demo Scenarios**: Run pre-built conversation scenarios
+- **📋 Draft Board**: View the current draft state
+
+### Command Line Interface
+
+Quick demo:
+
+```bash
+python demos/cli_demo.py --quick
+```
+
+Interactive mode:
+
+```bash
+python demos/cli_demo.py --interactive
+```
+
+Commands in interactive mode:
+- Ask any draft question
+- `pick <player>` - Draft a player
+- `roster` - View your current roster
+- `reset` - Start a new draft
+- `quit` - Exit
+
+Run demo scenarios:
+
+```bash
+python demos/cli_demo.py --scenario 1  # Run "The Opening Pick" scenario
+python demos/cli_demo.py --all-scenarios  # Run all scenarios
+```
+
+## 🎮 Running Demos
+
+### Basic Demo
+```bash
+python demos/cli_demo.py
+```
+
+### Multi-Turn Demos
+```bash
+# Clean multi-turn demo (recommended)
+python demos/multiturn_demo.py
+
+# Quick start helper
+python demos/quickstart.py
+```
+
+### Web Interface
+```bash
+python apps/app.py
+# Then open http://localhost:7860
+```
+
+### Quick Start
+The quickstart script will check dependencies and launch the web interface:
+```bash
+python demos/quickstart.py
+```
+
+## 📚 Demo Scenarios
+
+1. **The Opening Pick** - User has 5th pick, top 4 players gone. Shows strategy adaptation.
+2. **The Position Run** - Round 3, QB run happening. Shows patience and value finding.
+3. **The Sleeper Question** - Round 10, looking for upside. Shows deep knowledge.
+4. **The Stack Builder** - Has Mahomes, wants receivers. Shows correlation strategy.
+
+## 🏗️ Architecture
+
+```
+fantasy-draft-agent/
+├── core/                 # Core functionality
+│   ├── agent.py         # FantasyDraftAgent class using any-agent
+│   ├── data.py          # Static player data (top 50 players)
+│   ├── scenarios.py     # Pre-crafted demo scenarios
+│   └── visualizer.py    # ASCII visualizations for demos
+├── apps/                 # Application interfaces
+│   ├── app.py          # Gradio web interface
+│   ├── multiagent_draft.py     # Multi-agent mock draft
+│   └── multiagent_scenarios.py # A2A communication scenarios
+├── demos/               # Demo scripts
+│   ├── cli_demo.py     # Command-line interface
+│   ├── multiturn_demo.py # Multi-turn demonstration
+│   └── quickstart.py   # Quick start helper
+├── docs/                # Documentation
+│   ├── ENV_SETUP.md    # Environment setup guide
+│   ├── MULTIAGENT_DEMO.md # Multi-agent features
+│   └── ...             # Other documentation
+├── scripts/             # Utility scripts
+│   ├── setup.sh        # Setup script
+│   └── start_venv.sh   # Virtual environment starter
+├── requirements.txt     # Dependencies
+└── README.md           # This file
+```
+
+### Key Components
+
+- **FantasyDraftAgent**: Main agent class with conversation memory
+- **Tools**: Player stats, best available, position analysis, stacking options
+- **ScenarioRunner**: Manages and executes demo scenarios
+- **Visualizer**: Creates ASCII player cards and draft boards
+- **FantasyDraftApp**: Gradio interface wrapper
+
+## 💡 Example Usage
+
+```python
+from agent import FantasyDraftAgent
+
+# Create agent
+agent = FantasyDraftAgent()
+
+# Ask for advice
+response = agent.run("I have the 5th pick. Who should I target?")
+print(response)
+
+# Follow-up question (maintains context)
+response = agent.run("What about in round 2?")
+print(response)
+```
+
+## 🔧 Customization
+
+### Change the LLM Model
+
+Edit `agent.py`:
+
+```python
+self.agent = AnyAgent.create(
+    framework="openai",  # or "langchain", "llama_index", etc.
+    AgentConfig(
+        model_id="gpt-4",  # Change model here
+        # ...
+    )
+)
+```
+
+### Add More Players
+
+Edit `data.py` to add more players to the `TOP_PLAYERS` dictionary.
+
+### Create New Scenarios
+
+Add new scenarios to `SCENARIOS` in `scenarios.py`.
+
+### Customize the Web Interface
+
+Edit `app.py` to modify the Gradio interface, add new tabs, or change the styling.
+
+## 📊 Visual Components
+
+The agent includes ASCII visualizations for:
+- Player cards with stats
+- Side-by-side player comparisons
+- Draft board snapshots
+- Roster summaries
+- Decision summaries
+
+## 🎯 MVP Scope
+
+This MVP focuses on:
+- ✅ Multi-turn conversation capabilities
+- ✅ Context retention across interactions
+- ✅ Strategic draft advice
+- ✅ Demo-ready scenarios
+- ✅ Visual web interface
+
+Not included (future enhancements):
+- ❌ Live draft integration
+- ❌ Real-time data feeds
+- ❌ Full 15-round drafts
+- ❌ Trade analysis
+- ❌ Season-long management
+
+## 🤝 Contributing
+
+This is an MVP demonstration. For production features, consider:
+- Adding real-time player data APIs
+- Implementing live draft room integration
+- Expanding to other fantasy sports
+- Adding machine learning for player projections
+
+## 📝 License
+
+MIT License - feel free to use and modify for your own projects!
+
+## 🙏 Acknowledgments
+
+Built with [any-agent](https://github.com/any-agent/any-agent) - a unified interface for AI agent frameworks.
+
+---
+
+**Built in < 100 lines of core agent code!** 🚀
+
+## 📚 Documentation
+
+- `README.md` - This file
+- `ENV_SETUP.md` - Environment and API key setup guide
+- `VENV_GUIDE.md` - Virtual environment instructions  
+- `MULTITURN_VISUALS.md` - Guide to multi-turn visualization features
+- `MULTIAGENT_DEMO.md` - Multi-agent mock draft documentation
+- `screenshots.md` - Visual examples of the app in action

app.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Entry point for Hugging Face Spaces
+"""
+
+import sys
+import os
+import subprocess
+
+# Check if we're on Hugging Face Spaces and need to handle A2A deps
+if os.getenv("SPACE_ID"):
+    print("🤗 Running on Hugging Face Spaces...")
+    
+    # Try to import A2A components
+    try:
+        from any_agent.serving import A2AServingConfig
+        print("✅ A2A dependencies already available")
+    except ImportError:
+        print("⚠️ A2A dependencies not found, attempting to install...")
+        try:
+            # Install any-agent with A2A extras explicitly
+            print("Installing any-agent[a2a]...")
+            subprocess.check_call([
+                sys.executable, "-m", "pip", "install", 
+                "--force-reinstall", "--no-deps", 
+                "any-agent[a2a]"
+            ])
+            
+            # Also ensure key A2A dependencies
+            a2a_deps = [
+                "a2a-sdk>=0.2.8",
+                "grpcio>=1.60",
+                "grpcio-tools>=1.60",
+                "grpcio-reflection>=1.7.0"
+            ]
+            
+            for dep in a2a_deps:
+                try:
+                    subprocess.check_call([
+                        sys.executable, "-m", "pip", "install", 
+                        "--no-deps", dep
+                    ])
+                    print(f"✅ Installed {dep}")
+                except:
+                    print(f"⚠️ Could not install {dep}")
+                    
+        except Exception as e:
+            print(f"❌ Could not install A2A dependencies: {e}")
+            print("ℹ️ A2A mode will not be available, but Basic Multiagent mode will work fine!")
+
+# Try patching the import check before importing the app
+if os.getenv("SPACE_ID"):
+    try:
+        # Import a2a_sdk first to ensure it's available
+        import a2a_sdk
+        print("✅ a2a_sdk imported successfully")
+        
+        # Now try to patch any_agent if needed
+        import any_agent
+        # Some versions might have a flag we can set
+        if hasattr(any_agent, '_A2A_AVAILABLE'):
+            any_agent._A2A_AVAILABLE = True
+    except Exception as e:
+        print(f"⚠️ Patching attempt: {e}")
+
+# Import and run the enhanced app
+from apps.app_enhanced import main
+
+if __name__ == "__main__":
+    main() 

apps/app.py

@@ -0,0 +1,700 @@
+#!/usr/bin/env python3
+"""
+Fantasy Draft Multi-Agent Demo
+Showcases multi-agent and multi-turn capabilities
+"""
+
+import os
+import time
+import gradio as gr
+from typing import List, Tuple
+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
+from core.data import TOP_PLAYERS
+from apps.multiagent_draft import MultiAgentMockDraft
+from apps.multiagent_scenarios import (
+    run_interactive_mock_draft,
+    format_conversation_block,
+    format_agent_message,
+    format_memory_indicator,
+    create_mock_draft_visualization
+)
+
+# Fix for litellm 1.72.4 OpenAI endpoint issue
+# This ensures litellm uses the correct OpenAI API endpoint
+os.environ['OPENAI_API_BASE'] = 'https://api.openai.com/v1'
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+class FantasyDraftApp:
+    def __init__(self):
+        self.current_draft = None  # Store the current mock draft
+        self.draft_output = ""  # Store the draft output so far
+    
+    def run_multiagent_demo(self):
+        """Run the mock draft demonstration."""
+        # Reset any previous draft
+        self.current_draft = None
+        self.draft_output = ""
+        
+        # Run the draft generator
+        draft_generator = run_interactive_mock_draft()
+        
+        for output in draft_generator:
+            # Check if this is a tuple (draft state, output)
+            if isinstance(output, tuple):
+                # This means it's the user's turn
+                self.current_draft, self.draft_output = output
+                # Add a special marker for Gradio to detect
+                yield self.draft_output + "\n<!--USER_TURN-->"
+                return
+            else:
+                # Regular output
+                self.draft_output = output
+                yield output
+    
+    def continue_mock_draft(self, player_name: str):
+        """Continue the mock draft after user makes a pick."""
+        if not self.current_draft:
+            yield "No active draft. Please start a new mock draft."
+            return
+        
+        if not player_name:
+            yield self.draft_output + "\n\n⚠️ Please enter a player name!"
+            return
+        
+        # Make the user's pick
+        messages = self.current_draft.make_user_pick(player_name)
+        
+        # Display messages with inline typing effect
+        for msg in messages:
+            if len(msg) >= 3:
+                agent, recipient, content = msg[:3]
+                
+                # Check if it's a typing indicator - skip it
+                if isinstance(agent, str) and agent.startswith("typing_"):
+                    continue  # Skip typing indicators, we'll handle inline
+                else:
+                    # Show "..." first for typing effect
+                    typing_placeholder = format_agent_message(agent, recipient, "...")
+                    self.draft_output += typing_placeholder
+                    yield self.draft_output
+                    time.sleep(0.5)  # Brief typing delay
+                    
+                    # 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(1.0)  # Reading delay
+        
+        # Continue the draft from where we left off
+        # We need to track where we were in the draft
+        total_picks = len([p for picks in self.current_draft.draft_board.values() for p in picks])
+        current_round = ((total_picks - 1) // 6) + 1  # 6 teams per round
+        
+        # Continue with the rest of the draft
+        draft_memories = []
+        
+        # Continue the draft
+        for round_num in range(current_round, 4):  # Continue from current round to round 3
+            if round_num > current_round:
+                self.draft_output += f"\n## 🔄 ROUND {round_num}\n\n"
+                yield self.draft_output
+            
+            # Snake draft order - 6 teams total
+            if round_num % 2 == 1:
+                pick_order = list(range(1, 7))  # 1-6 for odd rounds
+            else:
+                pick_order = list(range(6, 0, -1))  # 6-1 for even rounds
+            
+            # Calculate where we are in the current round
+            picks_in_round = total_picks % 6  # 6 teams per round
+            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  # 6 teams per 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
+                
+                # Process the pick
+                messages, result = self.current_draft.simulate_draft_turn(round_num, pick_num, team_num)
+                
+                # Display messages with inline typing effect
+                for msg in messages:
+                    if len(msg) >= 3:
+                        agent, recipient, content = msg[:3]
+                        
+                        # Check if it's a typing indicator - skip it
+                        if isinstance(agent, str) and agent.startswith("typing_"):
+                            continue  # Skip typing indicators, we'll handle inline
+                        else:
+                            # Show "..." first for typing effect
+                            typing_placeholder = format_agent_message(agent, recipient, "...")
+                            self.draft_output += typing_placeholder
+                            yield self.draft_output
+                            time.sleep(0.5)  # Brief typing delay
+                            
+                            # 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(1.0)  # Reading delay
+                
+                if result is None:
+                    # It's the user's turn again
+                    self.draft_output += "\n**⏰ YOU'RE ON THE CLOCK! Type your pick below.**\n\n"
+                    yield self.draft_output + "\n<!--USER_TURN-->"
+                    return
+                
+                # Add memory indicators
+                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(0.5)
+            
+            # 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
+
+
+def create_gradio_interface():
+    """Create the main Gradio interface."""
+    app = FantasyDraftApp()
+    
+    with gr.Blocks(title="Fantasy Draft Multi-Agent Demo", theme=gr.themes.Glass()) as demo:
+        with gr.Column(elem_id="main-container"):
+            gr.Markdown("""
+            # 🏈 Fantasy Draft Multi-Agent Demo
+            
+            **Experience the future of AI interaction:** Watch 6 intelligent agents compete in a fantasy football draft with distinct strategies, real-time trash talk, and persistent memory.
+            """)
+            
+            with gr.Tabs():
+                # Demo Tab
+                with gr.TabItem("🎮 Demo"):
+                    # Show agent cards first
+                    gr.Markdown("""
+                    ### 🏈 Meet Your Competition
+                    
+                    You'll be drafting at **Position 4** with these AI opponents:
+                    """)
+                    
+                    # Agent cards in a grid - all in one row
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #E3F2FD; border-left: 4px solid #1976D2; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #1a237e !important; margin: 0 0 10px 0;">📘🤓 Team 1 - Zero RB</h4>
+                            
+                            <p style="color: #1976D2 !important; font-style: italic; margin: 10px 0; font-size: 0.95em;">"RBs get injured. I'll build around elite WRs."</p>
+                            
+                            <ul style="color: #1a237e !important; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #1a237e !important;">Avoids RBs early</li>
+                            <li style="color: #1a237e !important;">Loads up on WRs</li>
+                            <li style="color: #1a237e !important;">Gets RB value late</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #E8F5E9; border-left: 4px solid #388E3C; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #1b5e20 !important; margin: 0 0 10px 0;">📗🧑‍💼 Team 2 - BPA</h4>
+                            
+                            <p style="color: #2e7d32 !important; font-style: italic; margin: 10px 0; font-size: 0.95em;">"Value is value. I don't reach for needs."</p>
+                            
+                            <ul style="color: #1b5e20 !important; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #1b5e20 !important;">Pure value drafting</li>
+                            <li style="color: #1b5e20 !important;">Ignores needs</li>
+                            <li style="color: #1b5e20 !important;">Mocks reaching</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #FFF3E0; border-left: 4px solid #F57C00; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #e65100 !important; margin: 0 0 10px 0;">📙🧔 Team 3 - Robust RB</h4>
+                            
+                            <p style="color: #ef6c00 !important; font-style: italic; margin: 10px 0; font-size: 0.95em;">"RBs win championships. Period."</p>
+                            
+                            <ul style="color: #e65100 !important; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #e65100 !important;">RBs in rounds 1-2</li>
+                            <li style="color: #e65100 !important;">Old-school approach</li>
+                            <li style="color: #e65100 !important;">Foundation first</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #E8EAF6; border-left: 4px solid #3F51B5; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #1a237e !important; margin: 0 0 10px 0;">👤 Position 4 - YOU</h4>
+                            
+                            <p style="color: #3949ab !important; font-style: italic; margin: 10px 0; font-size: 0.95em;">Your draft position with AI guidance</p>
+                            
+                            <ul style="color: #1a237e !important; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #1a237e !important;">📕🧙 Strategic advisor</li>
+                            <li style="color: #1a237e !important;">Real-time guidance</li>
+                            <li style="color: #1a237e !important;">Roster analysis</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #F5E6FF; border-left: 4px solid #7B1FA2; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #4a148c !important; margin: 0 0 10px 0;">📓🤠 Team 5 - Upside</h4>
+                            
+                            <p style="color: #6a1b9a !important; font-style: italic; margin: 10px 0; font-size: 0.95em;">"Safe picks are for losers!"</p>
+                            
+                            <ul style="color: #4a148c !important; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #4a148c !important;">Seeks breakouts</li>
+                            <li style="color: #4a148c !important;">High risk/reward</li>
+                            <li style="color: #4a148c !important;">Mocks safety</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #E8F5E9; border-left: 4px solid #388E3C; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #1b5e20 !important; margin: 0 0 10px 0;">📗👨‍🏫 Team 6 - BPA</h4>
+                            
+                            <p style="color: #2e7d32 !important; font-style: italic; margin: 10px 0; font-size: 0.95em;">"Another value drafter to punish reaches."</p>
+                            
+                            <ul style="color: #1b5e20 !important; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #1b5e20 !important;">Takes obvious value</li>
+                            <li style="color: #1b5e20 !important;">Disciplined approach</li>
+                            <li style="color: #1b5e20 !important;">No sentiment</li>
+                            </ul>
+                            </div>
+                            """)
+                    
+                    gr.Markdown("""
+                    ### 🎮 Draft Format
+                    - **3 Rounds** of snake draft (1→6, 6→1, 1→6)
+                    - **Real-time trash talk** between picks
+                    - **Strategic advisor** guides your selections
+                    - **Memory system** - agents remember and reference earlier picks
+                    
+                    Ready to experience the most realistic AI draft room?
+                    """)
+                    
+                    # Start button at the bottom
+                    with gr.Row():
+                        with gr.Column():
+                            run_multiagent_btn = gr.Button("🏈 Start Mock Draft", variant="primary", size="lg", elem_id="start-button")
+                    
+                    # Main output area
+                    multiagent_output = gr.Markdown(elem_classes=["multiagent-output"])
+                    
+                    # Mock draft interaction (hidden until needed)
+                    with gr.Row(visible=False) as mock_draft_controls:
+                        with gr.Column():
+                            draft_pick_input = gr.Textbox(
+                                label="Your Pick",
+                                placeholder="Type player name and press Enter (e.g., 'Justin Jefferson')",
+                                elem_id="draft-pick-input"
+                            )
+                            submit_pick_btn = gr.Button("Submit Pick", variant="primary")
+                            
+                            # Available players display
+                            with gr.Accordion("📋 Available Players", visible=False) as available_accordion:
+                                available_players_display = gr.Textbox(
+                                    label="Top 20 Available",
+                                    lines=15,
+                                    interactive=False
+                                )
+                
+                # How It Works Tab
+                with gr.TabItem("🔧 How It Works"):
+                    gr.Markdown("""
+                    ## Technical Implementation
+                    
+                    This demo showcases advanced multi-agent capabilities using the **any-agent framework**.
+                    
+                    ### 🤖 Framework: any-agent (TinyAgent)
+                    
+                    - **Lightweight**: < 100 lines of core agent code
+                    - **Flexible**: Supports multiple LLM providers (OpenAI, Anthropic, etc.)
+                    - **Multi-turn ready**: Built-in conversation history management
+                    - **Model**: GPT-4 (configurable)
+                    
+                    ### 🧠 Multi-Turn Memory System
+                    
+                    Each agent maintains:
+                    - **Conversation History**: Full context of all interactions
+                    - **Draft State**: Current picks, available players, round info
+                    - **Strategy Memory**: Remembers own strategy and others' approaches
+                    - **Pick History**: Tracks all selections for informed decisions
+                    
+                    ### 💬 Agent-to-Agent (A2A) Communication
+                    
+                    Agents can:
+                    - **Comment on picks**: React to other agents' selections
+                    - **Respond to comments**: Defend their strategies
+                    - **Remember debates**: Reference earlier conversations
+                    - **Adapt strategies**: Adjust based on draft flow
+                    
+                    ### 📊 Architecture Flow
+                    """)
+                    
+                    gr.Markdown("""
+                    #### 1️⃣ INITIALIZATION
+                    User clicks "Start Mock Draft" → System creates 6 agents
+                    
+                    #### 2️⃣ AGENT SETUP
+                    - **Team 1**: Zero RB Strategy
+                    - **Team 2**: Best Player Available  
+                    - **Team 3**: Robust RB Strategy
+                    - **YOU**: Position 4 (with Advisor)
+                    - **Team 5**: Upside Hunter
+                    - **Team 6**: Best Player Available
+                    
+                    #### 3️⃣ DRAFT FLOW (3 Rounds)
+                    - **Round 1**: Pick Order 1���2→3→YOU→5→6
+                    - **Round 2**: Pick Order 6→5→YOU→3→2→1 (Snake)
+                    - **Round 3**: Pick Order 1→2→3→YOU→5→6
+                    
+                    #### 4️⃣ EACH PICK TRIGGERS
+                    - Agent makes selection based on strategy
+                    - Other agents comment (A2A communication)
+                    - Original agent may respond
+                    - All agents update their memory
+                    
+                    #### 5️⃣ USER'S TURN
+                    - Advisor analyzes draft state
+                    - User sees available players
+                    - User makes pick
+                    - All agents react to user's choice
+                    
+                    #### 6️⃣ MEMORY & CONTEXT
+                    - Each agent remembers all picks
+                    - Agents reference earlier conversations
+                    - Strategies adapt based on draft flow
+                    - Visual memory indicators show retention
+                    """)
+                    
+                    gr.Markdown("""
+                    ### 🎯 Key Features Demonstrated
+                    
+                    1. **Persistent Context**: Each agent remembers all previous interactions
+                    2. **Strategic Personalities**: 5 distinct draft strategies competing
+                    3. **Dynamic Adaptation**: Agents adjust based on draft progression
+                    4. **Natural Dialogue**: Human-like commentary and debates
+                    5. **User Integration**: Seamless human participation with AI guidance
+                    
+                    ### 📝 Implementation Details
+                    
+                    - **Agent Classes**: Inheritance-based design with base `DraftAgent`
+                    - **Message Formatting**: Custom HTML/CSS for visual distinction
+                    - **State Management**: Draft board tracking and validation
+                    - **Memory Indicators**: Visual cues showing context retention
+                    
+                    ### 🚀 Why This Matters
+                    
+                    This demo proves that sophisticated multi-agent systems can be built with minimal code,
+                    showcasing the power of modern LLMs when properly orchestrated. The any-agent framework
+                    makes it easy to create agents that truly communicate and remember, not just respond.
+                    """)
+        
+        # Function to check if it's user's turn and show/hide controls
+        def check_user_turn(output_text):
+            """Check if output indicates it's user's turn."""
+            if "<!--USER_TURN-->" in output_text:
+                # Remove the marker from display
+                clean_output = output_text.replace("<!--USER_TURN-->", "")
+                # Get available players
+                if app.current_draft:
+                    available = app.current_draft.get_available_players()
+                    available_text = "Available Players:\n\n"
+                    for player in sorted(available)[:20]:  # Show top 20
+                        if player in TOP_PLAYERS:
+                            info = TOP_PLAYERS[player]
+                            available_text += f"• {player} ({info['pos']}, {info['team']})\n"
+                else:
+                    available_text = "No draft active"
+                
+                return (
+                    clean_output,  # Clean output
+                    gr.update(visible=True),  # Show draft controls
+                    gr.update(visible=True, open=True),  # Show available players and open it
+                    available_text,  # Available players list
+                    ""  # Clear the input
+                )
+            else:
+                return (
+                    output_text,  # Regular output
+                    gr.update(visible=False),  # Hide draft controls
+                    gr.update(visible=False),  # Hide available players
+                    "",  # Clear available list
+                    ""  # Clear the input
+                )
+        
+        # Run multi-agent demo with control visibility handling
+        def run_and_check():
+            """Run demo and check for user turn."""
+            for output in app.run_multiagent_demo():
+                result = check_user_turn(output)
+                yield result
+        
+        run_multiagent_btn.click(
+            run_and_check,
+            None,
+            [multiagent_output, mock_draft_controls, available_accordion, available_players_display, draft_pick_input],
+            show_progress=True
+        )
+        
+        # Continue draft after user pick
+        def submit_and_continue(player_name):
+            """Submit pick and continue draft."""
+            for output in app.continue_mock_draft(player_name):
+                result = check_user_turn(output)
+                yield result
+        
+        submit_pick_btn.click(
+            submit_and_continue,
+            draft_pick_input,
+            [multiagent_output, mock_draft_controls, available_accordion, available_players_display, draft_pick_input],
+            show_progress=True
+        )
+        
+        # Also submit on enter
+        draft_pick_input.submit(
+            submit_and_continue,
+            draft_pick_input,
+            [multiagent_output, mock_draft_controls, available_accordion, available_players_display, draft_pick_input],
+            show_progress=True
+        )
+        
+        # Add custom CSS for better styling
+        demo.css = """
+        /* Force white text on dark background for all main content */
+        .gradio-container {
+            max-width: 800px !important;
+            margin: 0 auto !important;
+            color: white !important;
+        }
+        
+        /* Ensure all text elements are white by default */
+        .gradio-container p,
+        .gradio-container h1,
+        .gradio-container h2,
+        .gradio-container h3,
+        .gradio-container h4,
+        .gradio-container h5,
+        .gradio-container h6,
+        .gradio-container span,
+        .gradio-container div,
+        .gradio-container label,
+        .gradio-container .markdown,
+        .gradio-container .prose {
+            color: white !important;
+        }
+        
+        /* Ensure markdown content is white */
+        .markdown-text,
+        .markdown-text p,
+        .markdown-text li,
+        .markdown-text ul,
+        .markdown-text ol {
+            color: white !important;
+        }
+        
+        #main-container {
+            text-align: center;
+            color: white !important;
+        }
+        
+        /* Left-align text in How It Works tab */
+        .tabitem:nth-child(2) {
+            text-align: left !important;
+        }
+        
+        #start-button {
+            margin: 20px auto !important;
+            max-width: 300px !important;
+        }
+        
+        /* Only force dark text inside colored message boxes */
+        div[style*="background-color"][style*="border-left"] {
+            color: #212121 !important;
+        }
+        
+        div[style*="background-color"][style*="border-left"] p,
+        div[style*="background-color"][style*="border-left"] strong,
+        div[style*="background-color"][style*="border-left"] em,
+        div[style*="background-color"][style*="border-left"] span,
+        div[style*="background-color"][style*="border-left"] li,
+        div[style*="background-color"][style*="border-left"] ul,
+        div[style*="background-color"][style*="border-left"] h1,
+        div[style*="background-color"][style*="border-left"] h2,
+        div[style*="background-color"][style*="border-left"] h3,
+        div[style*="background-color"][style*="border-left"] h4 {
+            color: #212121 !important;
+        }
+        
+        /* System messages with yellow background */
+        div[style*="#FFF9C4"] {
+            color: #F57C00 !important;
+        }
+        
+        /* Memory boxes */
+        div[style*="#F5F5F5"] {
+            color: #424242 !important;
+        }
+        
+        #draft-pick-input {
+            font-size: 1.1em;
+        }
+        
+        /* Ensure tab labels are visible */
+        .tab-nav button {
+            color: white !important;
+        }
+        
+        /* Ensure multiagent output text is white */
+        .multiagent-output {
+            color: white !important;
+        }
+        
+        .multiagent-output p,
+        .multiagent-output h1,
+        .multiagent-output h2,
+        .multiagent-output h3,
+        .multiagent-output h4,
+        .multiagent-output h5,
+        .multiagent-output h6,
+        .multiagent-output span,
+        .multiagent-output div {
+            color: white !important;
+        }
+        
+        /* Specific rules for dark mode - target Gradio's dark theme class */
+        .dark .gradio-container,
+        .dark .gradio-container *:not([style*="background-color"]) {
+            color: white !important;
+        }
+        
+        /* Ensure description text under title is white */
+        .gradio-container > div > div > div > p {
+            color: white !important;
+        }
+        
+        /* Tab content text */
+        .tabitem .markdown-text {
+            color: white !important;
+        }
+        
+        /* Input labels and text */
+        .gradio-container label {
+            color: rgba(255, 255, 255, 0.9) !important;
+        }
+        
+        /* Button text that's not in primary buttons */
+        button:not(.primary) {
+            color: rgba(255, 255, 255, 0.9) !important;
+        }
+        
+        /* Fix for bold player names - ensure they're visible */
+        .multiagent-output strong,
+        .multiagent-output b {
+            color: inherit !important;
+            font-weight: 700;
+        }
+        
+        /* Ensure bold text in message backgrounds has proper color */
+        div[style*="background-color"] strong,
+        div[style*="background-color"] b {
+            color: inherit !important;
+        }
+        
+        /* Specific fix for bold text in different message backgrounds */
+        div[style*="background-color: #E3F2FD"] strong,  /* Team messages */
+        div[style*="background-color: #FFF8E1"] strong,  /* Commissioner */
+        div[style*="background-color: #FFEBEE"] strong,  /* Advisor */
+        div[style*="background-color: #F3E5F5"] strong { /* Memory */
+            color: #1a1a1a !important;
+        }
+        
+        /* Inline typing effect */
+        .typing-dots {
+            animation: pulse 1.0s ease-in-out infinite;
+        }
+        
+        @keyframes pulse {
+            0%, 100% { opacity: 0.6; }
+            50% { opacity: 1; }
+        }
+        """
+    
+    return demo
+
+
+def main():
+    """Launch the Gradio app."""
+    import sys
+    
+    # Check for --share flag
+    share_mode = "--share" in sys.argv or "-s" in sys.argv
+    
+    # Check for API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("\n⚠️  Warning: OPENAI_API_KEY not found in environment variables.")
+        print("The app will launch but agent responses will fail without an API key.")
+        print("Set it using: export OPENAI_API_KEY='your-key-here'\n")
+    
+    print("🚀 Launching Fantasy Draft Multi-Agent Demo...")
+    
+    if share_mode:
+        print("🌐 Creating public share link (expires in 72 hours)...")
+        print("📡 Please wait for the public URL...\n")
+    else:
+        print("📡 The app will be available at http://localhost:7860")
+        print("💡 Tip: Use 'python app.py --share' to create a public link\n")
+    
+    demo = create_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=share_mode,  # Enable sharing if flag is present
+        show_error=True
+    )
+
+
+if __name__ == "__main__":
+    main() 

apps/app_enhanced.py

@@ -0,0 +1,1035 @@
+#!/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
+"""
+
+import os
+import time
+import gradio as gr
+import asyncio
+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
+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 (
+    run_interactive_mock_draft,
+    format_conversation_block,
+    format_agent_message,
+    format_memory_indicator,
+    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()
+
+# Fix for litellm 1.72.4 OpenAI endpoint issue
+os.environ['OPENAI_API_BASE'] = 'https://api.openai.com/v1'
+
+# Load environment variables
+load_dotenv()
+
+
+class EnhancedFantasyDraftApp:
+    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
+    
+    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
+            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
+            
+            # 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
+            self.a2a_manager = DynamicA2AAgentManager(self.session_id)
+            
+            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]})"
+            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."""
+        # 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)
+        
+        # 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
+        self.draft_output += format_agent_message(
+            "commissioner", "ALL",
+            "Welcome to the A2A-powered draft! Each agent is running on its own server."
+        )
+        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))
+            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 (limit to 2 comments)
+        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:
+            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
+        
+        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
+    
+    def continue_mock_draft(self, player_name: str):
+        """Continue the mock draft after user makes a pick."""
+        if not self.current_draft:
+            yield "No active draft. Please start a new mock draft."
+            return
+        
+        if not player_name:
+            yield self.draft_output + "\n\n⚠️ Please enter a player name!"
+            return
+        
+        # Make the user's pick
+        messages = self.current_draft.make_user_pick(player_name)
+        
+        # Display messages with inline typing effect
+        for msg in messages:
+            if len(msg) >= 3:
+                agent, recipient, content = msg[:3]
+                
+                # Check if it's a typing indicator - skip it
+                if isinstance(agent, str) and agent.startswith("typing_"):
+                    continue
+                else:
+                    # 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)
+        
+        # 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()
+    
+    def continue_a2a_draft(self):
+        """Continue A2A 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
+        
+        loop = asyncio.get_event_loop()
+        
+        # Continue from current position
+        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
+            
+            # Snake draft order
+            if round_num % 2 == 1:
+                pick_order = list(range(1, 7))
+            else:
+                pick_order = list(range(6, 0, -1))
+            
+            # Calculate where we are in the current round
+            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
+                
+                # 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 again
+                    # Get advisor recommendation - use user_advisor directly
+                    advisor = self.current_draft.user_advisor
+                    
+                    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()}
+                    
+                    advice = advisor.advise_user(available, self.current_draft.draft_board, strategies)
+                    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)
+                    )
+                    
+                    for msg in messages:
+                        if len(msg) >= 3:
+                            agent, recipient, content = msg[:3]
+                            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)
+                    
+                    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
+        
+        # Final summary
+        self.draft_output += "\n## 📊 FINAL RESULTS\n\n"
+        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
+        
+        self.current_draft = None
+
+
+def create_gradio_interface():
+    """Create the main Gradio interface with A2A support."""
+    
+    with gr.Blocks(title="Fantasy Draft Multi-Agent Demo", theme=gr.themes.Soft()) as demo:
+        # Create state for each user session
+        app_state = gr.State(None)
+        
+        with gr.Column(elem_id="main-container"):
+            gr.Markdown("""
+            # 🏈 Fantasy Draft Multi-Agent Demo
+            
+            **Multi-agent system demo using the any-agent framework:** Watch 6 AI agents draft fantasy football teams while maintaining conversation history, reacting to each other's picks, and following distinct strategies.
+            """)
+            
+            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(
+                                ["Basic Multiagent", "A2A"],
+                                value="Basic Multiagent",
+                                label="Select how agents communicate",
+                                info="Basic Multiagent: Fast, reliable (Recommended) | A2A: Distributed agents (Advanced)"
+                            )
+                            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)
+                                
+                                *If A2A mode fails to start, please use Basic Multiagent mode instead.*
+                                """
+                            )
+                            
+                            # Add A2A test button for debugging
+                            with gr.Accordion("🔧 A2A Debugging (Advanced)", open=False):
+                                test_a2a_btn = gr.Button("Test A2A Dependencies & Ports", size="sm")
+                                a2a_test_output = gr.Textbox(label="Test Results", lines=10, interactive=False)
+                    
+                    # Show agent cards
+                    gr.Markdown("""
+                    ### 🏈 Meet Your Competition
+                    
+                    You'll be drafting at **Position 4** with these AI opponents:
+                    """)
+                    
+                    # Agent cards in a grid - all in one row
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #E3F2FD; border-left: 4px solid #1976D2; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #0d47a1; margin: 0 0 10px 0;">📘🤓 Team 1 - Zero RB</h4>
+                            
+                            <p style="color: #424242; font-style: italic; margin: 10px 0; font-size: 0.95em;">"RBs get injured. I'll build around elite WRs."</p>
+                            
+                            <ul style="color: #424242; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #424242;">Avoids RBs early</li>
+                            <li style="color: #424242;">Loads up on WRs</li>
+                            <li style="color: #424242;">Gets RB value late</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #E8F5E9; border-left: 4px solid #388E3C; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #1b5e20; margin: 0 0 10px 0;">📗🧑‍💼 Team 2 - BPA</h4>
+                            
+                            <p style="color: #424242; font-style: italic; margin: 10px 0; font-size: 0.95em;">"Value is value. I don't reach for needs."</p>
+                            
+                            <ul style="color: #424242; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #424242;">Pure value drafting</li>
+                            <li style="color: #424242;">Ignores needs</li>
+                            <li style="color: #424242;">Mocks reaching</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #FFF3E0; border-left: 4px solid #F57C00; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #e65100; margin: 0 0 10px 0;">📙🧔 Team 3 - Robust RB</h4>
+                            
+                            <p style="color: #424242; font-style: italic; margin: 10px 0; font-size: 0.95em;">"RBs win championships. Period."</p>
+                            
+                            <ul style="color: #424242; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #424242;">RBs in rounds 1-2</li>
+                            <li style="color: #424242;">Old-school approach</li>
+                            <li style="color: #424242;">Foundation first</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #E8EAF6; border-left: 4px solid #3F51B5; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #1a237e; margin: 0 0 10px 0;">👤 Position 4 - YOU</h4>
+                            
+                            <p style="color: #424242; font-style: italic; margin: 10px 0; font-size: 0.95em;">Your draft position with AI guidance</p>
+                            
+                            <ul style="color: #424242; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #424242;">📕🧙 Strategic advisor</li>
+                            <li style="color: #424242;">Real-time guidance</li>
+                            <li style="color: #424242;">Roster analysis</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #F5E6FF; border-left: 4px solid #7B1FA2; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #4a148c; margin: 0 0 10px 0;">📓🤠 Team 5 - Upside</h4>
+                            
+                            <p style="color: #424242; font-style: italic; margin: 10px 0; font-size: 0.95em;">"Safe picks are for losers!"</p>
+                            
+                            <ul style="color: #424242; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #424242;">Seeks breakouts</li>
+                            <li style="color: #424242;">High risk/reward</li>
+                            <li style="color: #424242;">Mocks safety</li>
+                            </ul>
+                            </div>
+                            """)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("""
+                            <div style="background-color: #E8F5E9; border-left: 4px solid #388E3C; padding: 15px; border-radius: 8px;">
+                            
+                            <h4 style="color: #1b5e20; margin: 0 0 10px 0;">📗👨‍🏫 Team 6 - BPA</h4>
+                            
+                            <p style="color: #424242; font-style: italic; margin: 10px 0; font-size: 0.95em;">"Another value drafter to punish reaches."</p>
+                            
+                            <ul style="color: #424242; font-size: 0.9em; margin: 0; padding-left: 20px;">
+                            <li style="color: #424242;">Takes obvious value</li>
+                            <li style="color: #424242;">Disciplined approach</li>
+                            <li style="color: #424242;">No sentiment</li>
+                            </ul>
+                            </div>
+                            """)
+                    
+                    gr.Markdown("""
+                    ### 🎮 Draft Format
+                    * **3 Rounds** of snake draft (1→6, 6→1, 1→6)
+                    * **Real-time trash talk** between picks
+                    * **Strategic advisor** guides your selections
+                    * **Memory system** - agents remember and reference earlier picks
+                    
+                    Ready to experience the most realistic AI draft room?
+                    """)
+                    
+                    # Start button at the bottom
+                    with gr.Row():
+                        with gr.Column():
+                            run_multiagent_btn = gr.Button("🏈 Start Mock Draft", variant="primary", size="lg", elem_id="start-button")
+                    
+                    # Main output area
+                    multiagent_output = gr.Markdown(elem_classes=["multiagent-output"])
+                    
+                    # Mock draft interaction (hidden until needed)
+                    with gr.Row(visible=False) as mock_draft_controls:
+                        with gr.Column():
+                            draft_pick_input = gr.Textbox(
+                                label="Your Pick",
+                                placeholder="Type player name and press Enter (e.g., 'Justin Jefferson')",
+                                elem_id="draft-pick-input"
+                            )
+                            submit_pick_btn = gr.Button("Submit Pick", variant="primary")
+                            
+                            # Available players display
+                            with gr.Accordion("📋 Available Players", visible=False) as available_accordion:
+                                available_players_display = gr.Textbox(
+                                    label="Top 20 Available",
+                                    lines=15,
+                                    interactive=False
+                                )
+                
+                # How It Works Tab
+                with gr.TabItem("🔧 How It Works"):
+                    gr.Markdown("""
+                    ## Technical Implementation
+                    
+                    This demo showcases advanced multi-agent capabilities using the **any-agent framework**.
+                    
+                    ### 🤖 Framework: any-agent (TinyAgent)
+                    
+                    - **Lightweight**: < 100 lines of core agent code
+                    - **Flexible**: Supports multiple LLM providers (OpenAI, Anthropic, etc.)
+                    - **Multi-turn ready**: Built-in conversation history management
+                    - **Model**: GPT-4 (configurable)
+                    
+                    ### 🧠 Multi-Turn Memory System
+                    
+                    Each agent maintains:
+                    - **Conversation History**: Full context of all interactions
+                    - **Draft State**: Current picks, available players, round info
+                    - **Strategy Memory**: Remembers own strategy and others' approaches
+                    - **Pick History**: Tracks all selections for informed decisions
+                    
+                    ### 💬 Agent-to-Agent (A2A) 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
+                    - **True Isolation**: No shared memory, HTTP communication only
+                    - **Production Ready**: Scalable to multiple machines
+                    - **Uses a2a_tool_async**: Official any-agent A2A protocol
+                    
+                    #### 2. Basic Multiagent Mode
+                    - Single process, direct method calls
+                    - Shared memory between agents
+                    - Fast execution, simple debugging
+                    - Perfect for quick testing and development
+                    
+                    ### 📊 Architecture Flow
+                    """)
+                    
+                    gr.Markdown("""
+                    #### 1️⃣ INITIALIZATION
+                    User clicks "Start Mock Draft" → System creates 6 agents
+                    
+                    #### 2️⃣ AGENT SETUP
+                    - **Team 1**: Zero RB Strategy
+                    - **Team 2**: Best Player Available  
+                    - **Team 3**: Robust RB Strategy
+                    - **YOU**: Position 4 (with Advisor)
+                    - **Team 5**: Upside Hunter
+                    - **Team 6**: Best Player Available
+                    
+                    #### 3️⃣ DRAFT FLOW (3 Rounds)
+                    - **Round 1**: Pick Order 1→2→3→YOU→5→6
+                    - **Round 2**: Pick Order 6→5→YOU→3→2→1 (Snake)
+                    - **Round 3**: Pick Order 1→2→3→YOU→5→6
+                    
+                    #### 4️⃣ EACH PICK TRIGGERS
+                    - Agent makes selection based on strategy
+                    - Other agents comment (A2A communication)
+                    - Original agent may respond
+                    - All agents update their memory
+                    
+                    #### 5️⃣ USER'S TURN
+                    - Advisor analyzes draft state
+                    - User sees available players
+                    - User makes pick
+                    - All agents react to user's choice
+                    
+                    #### 6️⃣ MEMORY & CONTEXT
+                    - Each agent remembers all picks
+                    - Agents reference earlier conversations
+                    - Strategies adapt based on draft flow
+                    - Visual memory indicators show retention
+                    """)
+                    
+                    gr.Markdown("""
+                    ### 🎯 Key Features Demonstrated
+                    
+                    1. **Persistent Context**: Each agent remembers all previous interactions
+                    2. **Strategic Personalities**: 5 distinct draft strategies competing
+                    3. **Dynamic Adaptation**: Agents adjust based on draft progression
+                    4. **Natural Dialogue**: Human-like commentary and debates
+                    5. **User Integration**: Seamless human participation with AI guidance
+                    6. **A2A Communication**: Toggle between basic multiagent and distributed A2A modes
+                    
+                    ### 📝 Implementation Details
+                    
+                    - **Agent Classes**: Inheritance-based design with base `DraftAgent`
+                    - **Message Formatting**: Custom HTML/CSS for visual distinction
+                    - **State Management**: Draft board tracking and validation
+                    - **Memory Indicators**: Visual cues showing context retention
+                    - **A2A Protocol**: Uses any-agent's a2a_tool_async for distributed communication
+                    
+                    ### 🚀 Why This Matters
+                    
+                    This demo proves that sophisticated multi-agent systems can be built with minimal code,
+                    showcasing the power of modern LLMs when properly orchestrated. The any-agent framework
+                    makes it easy to create agents that truly communicate and remember, not just respond.
+                    
+                    The A2A mode demonstrates how the same agent logic can seamlessly transition from
+                    a simple in-memory simulation to a production-ready distributed system.
+                    """)
+        
+        # Function to check if it's user's turn and show/hide controls
+        def check_user_turn(output_text, app):
+            """Check if output indicates it's user's turn."""
+            if "<!--USER_TURN-->" in output_text:
+                # Remove the marker from display
+                clean_output = output_text.replace("<!--USER_TURN-->", "")
+                # Get available players
+                if app and app.current_draft:
+                    available = app.current_draft.get_available_players()
+                    available_text = "Available Players:\n\n"
+                    for player in sorted(available)[:20]:  # Show top 20
+                        if player in TOP_PLAYERS:
+                            info = TOP_PLAYERS[player]
+                            available_text += f"• {player} ({info['pos']}, {info['team']})\n"
+                else:
+                    available_text = "No draft active"
+                
+                return (
+                    clean_output,  # Clean output
+                    gr.update(visible=True),  # Show draft controls
+                    gr.update(visible=True, open=True),  # Show available players and open it
+                    available_text,  # Available players list
+                    ""  # Clear the input
+                )
+            else:
+                return (
+                    output_text,  # Regular output
+                    gr.update(visible=False),  # Hide draft controls
+                    gr.update(visible=False),  # Hide available players
+                    "",  # Clear available list
+                    ""  # Clear the input
+                )
+        
+        # Test A2A functionality
+        def test_a2a_functionality():
+            """Test A2A dependencies and port availability."""
+            import socket
+            test_results = []
+            
+            # Test imports
+            test_results.append("=== Testing A2A Dependencies ===")
+            try:
+                import any_agent
+                test_results.append("✅ any_agent imported")
+                
+                try:
+                    from any_agent.serving import A2AServingConfig
+                    from any_agent.tools import a2a_tool_async
+                    test_results.append("✅ A2A components imported successfully!")
+                except ImportError as e:
+                    test_results.append(f"❌ A2A components import failed: {e}")
+            except ImportError as e:
+                test_results.append(f"❌ any_agent not found: {e}")
+            
+            # Test ports
+            test_results.append("\n=== Testing Port Availability ===")
+            test_ports = [5001, 5002, 5003, 8001, 8002, 8080, 8888]
+            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.close()
+                except Exception as e:
+                    test_results.append(f"❌ Port {port} error: {e}")
+            
+            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]}")
+            
+            if available_count >= 5:
+                test_results.append("\n✅ A2A might work! Try selecting A2A mode.")
+            else:
+                test_results.append("\n❌ Not enough ports available. Use Basic Multiagent mode.")
+            
+            return "\n".join(test_results)
+        
+        # No need for separate mode change handler - it happens when draft starts
+        
+        # Run multi-agent demo with control visibility handling
+        def run_and_check(mode, app):
+            """Run demo and check for user turn."""
+            # Create a new app instance for this user if needed
+            if app is None:
+                app = EnhancedFantasyDraftApp()
+            
+            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
+        
+        run_multiagent_btn.click(
+            run_and_check,
+            [communication_mode, app_state],
+            [multiagent_output, mock_draft_controls, available_accordion, available_players_display, draft_pick_input, app_state],
+            show_progress=True
+        )
+        
+        # Wire up A2A test button
+        test_a2a_btn.click(
+            test_a2a_functionality,
+            [],
+            [a2a_test_output]
+        )
+        
+        # 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_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
+        )
+        
+        # Also submit 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
+        )
+        
+        # Minimal CSS for layout only
+        demo.css = """
+        #main-container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        
+        .multiagent-output {
+            max-height: 800px;
+            overflow-y: auto;
+        }
+        
+        /* Force dark text in message cards */
+        .multiagent-output div[style*="background-color"] {
+            color: #212121 !important;
+        }
+        
+        .multiagent-output div[style*="background-color"] * {
+            color: #212121 !important;
+        }
+        
+        #start-button {
+            margin-top: 20px;
+        }
+        """
+        
+        # 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)
+    
+    # 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
+        )
+
+
+if __name__ == "__main__":
+    main() 

apps/multiagent_draft.py

@@ -0,0 +1,768 @@
+#!/usr/bin/env python3
+"""
+Multi-Agent Mock Draft Implementation
+Demonstrates A2A communication and multi-turn memory
+"""
+
+import time
+from typing import Dict, List, Tuple, Optional
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from core.agent import FantasyDraftAgent
+from core.data import TOP_PLAYERS, get_best_available, get_players_by_position
+import random
+
+# Enhanced agents not available in the reorganized structure
+USE_ENHANCED = False
+# Removed misleading print statement - mode is determined at runtime
+
+
+class DraftAgent:
+    """Base class for draft agents with specific strategies."""
+    
+    def __init__(self, team_name: str, strategy: str, color: str, icon: str):
+        self.team_name = team_name
+        self.strategy = strategy
+        self.color = color
+        self.icon = icon
+        self.agent = FantasyDraftAgent()
+        self.picks = []
+        self.conversation_memory = []
+        
+    def remember_conversation(self, speaker: str, message: str):
+        """Store conversation in memory."""
+        self.conversation_memory.append({
+            "speaker": speaker,
+            "message": message,
+            "timestamp": time.time()
+        })
+    
+    def make_pick(self, available_players: List[str], draft_board: Dict) -> Tuple[str, str]:
+        """Make a pick based on strategy. Returns (player, reasoning)."""
+        # This will be overridden by specific agent types
+        pass
+    
+    def comment_on_pick(self, team: str, player: str, player_info: Dict) -> Optional[str]:
+        """Generate commentary on another team's pick using LLM."""
+        # Build context for the LLM
+        # Convert ADP to a more understandable format
+        adp_int = int(player_info['adp'])
+        if adp_int == 0:
+            adp_int = 1
+        adp_description = f"ranked #{adp_int} overall" if adp_int <= 10 else f"typically drafted around pick #{adp_int}"
+        
+        context = f"""You are {self.team_name}, a fantasy football team manager following a {self.strategy}.
+Your picks so far: {', '.join(self.picks) if self.picks else 'None yet'}
+
+{team} just picked {player} ({player_info['pos']}, {adp_description}, Tier: {player_info['tier']}).
+
+Based on your strategy and the current draft situation, provide a short, natural comment on this pick. 
+Be competitive and show some personality - you can be critical, sarcastic, or dismissive if the pick doesn't align with your philosophy.
+Don't be overly nice. This is a competitive draft and you want to win. Show confidence in your strategy.
+Keep it under 2 sentences and make it feel like real draft room banter - trash talk is encouraged!
+IMPORTANT: Don't mention raw ADP numbers like "1.5" - use natural language like "top pick", "#1 overall", "first round talent", etc."""
+
+        response = self.agent.run(context)
+        return response.strip()
+    
+    def respond_to_comment(self, commenter: str, comment: str) -> Optional[str]:
+        """Respond to another agent's comment using LLM."""
+        # Build conversation context
+        recent_memory = self.conversation_memory[-5:] if len(self.conversation_memory) > 5 else self.conversation_memory
+        
+        context = f"""You are {self.team_name}, following a {self.strategy} in a fantasy draft.
+Your picks: {', '.join(self.picks) if self.picks else 'None yet'}
+
+{commenter} just said to you: "{comment}"
+
+Recent conversation history:
+{chr(10).join([f"- {m['speaker']}: {m['message']}" for m in recent_memory])}
+
+Respond naturally and briefly (1-2 sentences). Be competitive and defend your strategy aggressively.
+You can be sarcastic, dismissive, or fire back with your own trash talk. This is a competition!
+Don't be polite - show confidence and give as good as you get."""
+
+        response = self.agent.run(context)
+        return response.strip()
+
+
+class ZeroRBAgent(DraftAgent):
+    """Agent that follows Zero RB strategy."""
+    
+    def __init__(self, team_name: str):
+        super().__init__(team_name, "Zero RB Strategy", "#E3F2FD", "📘")
+        self.person_emoji = "🤓"  # Analytical nerd
+    
+    def make_pick(self, available_players: List[str], draft_board: Dict) -> Tuple[str, str]:
+        # Prioritize WRs in early rounds
+        round_num = len(self.picks) + 1
+        
+        if round_num <= 3:
+            # Get best available WR
+            best_wrs = [(p, info) for p, info in TOP_PLAYERS.items() 
+                       if p in available_players and info['pos'] == 'WR']
+            if best_wrs:
+                best_wrs.sort(key=lambda x: x[1]['adp'])
+                player = best_wrs[0][0]
+                player_info = best_wrs[0][1]
+                
+                # Generate dynamic reasoning using LLM
+                # Convert ADP to readable format
+                adp_int = int(player_info['adp'])
+                if adp_int <= 12:
+                    adp_desc = f"a top-{adp_int} player"
+                elif adp_int <= 24:
+                    adp_desc = "an early second-round talent"
+                else:
+                    adp_desc = f"ranked around #{adp_int}"
+                
+                context = f"""You are {self.team_name} following a Zero RB strategy in round {round_num}.
+Your previous picks: {', '.join(self.picks) if self.picks else 'None'}
+
+You're selecting {player} (WR, {player_info['team']}, {adp_desc}).
+
+Explain your pick in 1-2 sentences, emphasizing why this fits your Zero RB strategy. 
+Be confident and maybe a bit cocky about avoiding RBs. Take subtle shots at teams loading up on injury-prone RBs.
+Show personality - you KNOW your strategy is superior.
+Don't use raw numbers like "1.5" or "ADP 12" - use natural language."""
+                
+                reasoning = self.agent.run(context).strip()
+                return player, reasoning
+        
+        # Later rounds, grab RBs
+        best_available = [(p, info) for p, info in TOP_PLAYERS.items() 
+                         if p in available_players]
+        best_available.sort(key=lambda x: x[1]['adp'])
+        
+        if best_available:
+            player = best_available[0][0]
+            player_info = best_available[0][1]
+            pos = player_info['pos']
+            
+            # Convert ADP to readable format
+            adp_int = int(player_info['adp'])
+            if pos == 'RB':
+                adp_desc = "a value RB" if adp_int > 24 else "a solid back"
+            else:
+                adp_desc = f"ranked #{adp_int}" if adp_int > 30 else f"a round {(adp_int-1)//12 + 1} talent"
+            
+            context = f"""You are {self.team_name} following a Zero RB strategy in round {round_num}.
+Your previous picks: {', '.join(self.picks)}
+
+You're selecting {player} ({pos}, {player_info['team']}, {adp_desc}).
+
+Explain why you're taking this player now, given your Zero RB approach.
+If it's a RB, explain why NOW is the right time (while others reached early). 
+Be smug about getting value while others panicked. Keep it to 1-2 sentences with attitude.
+Use terms like "value", "steal", "while others reached" - not raw numbers."""
+            
+            reasoning = self.agent.run(context).strip()
+            return player, reasoning
+        
+        return "Unknown Player", "Hmm, slim pickings here..."
+    
+
+
+
+class BPAAgent(DraftAgent):
+    """Agent that follows Best Player Available strategy."""
+    
+    def __init__(self, team_name: str):
+        super().__init__(team_name, "Best Player Available", "#E8F5E9", "📗")
+        self.person_emoji = "🧑‍💼"  # Business-like, calculated
+    
+    def make_pick(self, available_players: List[str], draft_board: Dict) -> Tuple[str, str]:
+        # Simply take the best available by ADP
+        best_available = [(p, info) for p, info in TOP_PLAYERS.items() 
+                         if p in available_players]
+        best_available.sort(key=lambda x: x[1]['adp'])
+        
+        if best_available:
+            player = best_available[0][0]
+            player_info = best_available[0][1]
+            pos = player_info['pos']
+            
+            # Generate dynamic reasoning using LLM
+            # Convert ADP to readable format
+            adp_int = int(player_info['adp'])
+            if adp_int <= 12:
+                adp_desc = f"the #{adp_int} overall player"
+            elif adp_int <= 24:
+                adp_desc = "a late first/early second round value"
+            else:
+                adp_desc = f"ranked #{adp_int} overall"
+            
+            context = f"""You are {self.team_name} following a Best Player Available strategy.
+Your previous picks: {', '.join(self.picks) if self.picks else 'None'}
+Round: {len(self.picks) + 1}
+
+You're selecting {player} ({pos}, {player_info['team']}, {adp_desc}).
+
+Explain why this is the best value pick available. Focus on their value and ranking.
+Be condescending about other teams reaching for needs or following rigid strategies.
+You're the smart one taking the obvious value - let them know it. Keep it to 1-2 sentences.
+Don't use raw ADP numbers - use terms like "best available", "top-ranked", "obvious value", etc."""
+            
+            reasoning = self.agent.run(context).strip()
+            return player, reasoning
+        
+        return "Unknown Player", "Taking the best available..."
+    
+
+
+
+class RobustRBAgent(DraftAgent):
+    """Agent that follows Robust RB strategy."""
+    
+    def __init__(self, team_name: str):
+        super().__init__(team_name, "Robust RB Strategy", "#FFF3E0", "📙")
+        self.person_emoji = "🧔"  # Old-school, traditional
+    
+    def make_pick(self, available_players: List[str], draft_board: Dict) -> Tuple[str, str]:
+        # Prioritize RBs early
+        round_num = len(self.picks) + 1
+        
+        if round_num <= 2:
+            # Get best available RB
+            best_rbs = [(p, info) for p, info in TOP_PLAYERS.items() 
+                       if p in available_players and info['pos'] == 'RB']
+            if best_rbs:
+                best_rbs.sort(key=lambda x: x[1]['adp'])
+                player = best_rbs[0][0]
+                player_info = best_rbs[0][1]
+                
+                # Convert ADP to readable format
+                adp_int = int(player_info['adp'])
+                if adp_int <= 5:
+                    adp_desc = "an elite, top-5 back"
+                elif adp_int <= 12:
+                    adp_desc = f"a premier RB1"
+                else:
+                    adp_desc = "a solid running back"
+                
+                context = f"""You are {self.team_name} following a Robust RB strategy in round {round_num}.
+Your previous picks: {', '.join(self.picks) if self.picks else 'None'}
+
+You're selecting {player} (RB, {player_info['team']}, {adp_desc}).
+
+Explain why this RB is crucial for your Robust RB strategy. Be aggressive about RBs winning championships.
+Mock teams that are going WR-heavy. You're building a REAL team with a strong foundation.
+Be old-school and dismissive of "fancy" WR strategies. Keep it to 1-2 sentences with authority.
+Use terms like "workhorse", "bell cow", "foundation" - not raw numbers."""
+                
+                reasoning = self.agent.run(context).strip()
+                return player, reasoning
+        
+        # Best available after that
+        best_available = [(p, info) for p, info in TOP_PLAYERS.items() 
+                         if p in available_players]
+        best_available.sort(key=lambda x: x[1]['adp'])
+        
+        if best_available:
+            player = best_available[0][0]
+            player_info = best_available[0][1]
+            
+            # Convert ADP to readable format
+            adp_int = int(player_info['adp'])
+            pos = player_info['pos']
+            if pos == 'WR':
+                adp_desc = "a quality receiver" if adp_int <= 24 else "a decent WR option"
+            elif pos == 'TE':
+                adp_desc = "a reliable tight end"
+            else:
+                adp_desc = f"ranked #{adp_int}"
+            
+            context = f"""You are {self.team_name} following a Robust RB strategy in round {round_num}.
+Your previous picks: {', '.join(self.picks)}
+
+You're selecting {player} ({player_info['pos']}, {player_info['team']}, {adp_desc}).
+
+Explain how this pick fits with your RB-heavy build. If it's not a RB, grudgingly admit you need other positions too.
+But emphasize your RB foundation is what matters. Be dismissive of WR-first teams. Keep it to 1-2 sentences.
+Focus on your "foundation" and "championship formula" - avoid raw rankings."""
+            
+            reasoning = self.agent.run(context).strip()
+            return player, reasoning
+        
+        return "Unknown Player", "Building around my RBs..."
+
+
+class UpsideAgent(DraftAgent):
+    """Agent that hunts for upside/breakout players."""
+    
+    def __init__(self, team_name: str):
+        super().__init__(team_name, "Upside Hunter", "#FFFDE7", "📓")
+        self.person_emoji = "🤠"  # Risk-taking cowboy
+    
+    def make_pick(self, available_players: List[str], draft_board: Dict) -> Tuple[str, str]:
+        # Look for high upside players
+        best_available = [(p, info) for p, info in TOP_PLAYERS.items() 
+                         if p in available_players]
+        best_available.sort(key=lambda x: x[1]['adp'])
+        
+        # Sometimes reach for upside
+        if len(best_available) > 3 and random.random() > 0.5:
+            # Take someone a bit later for "upside"
+            player = best_available[2][0]  # Skip top 2, take 3rd
+            player_info = best_available[2][1]
+            
+            # Convert ADP to readable format
+            adp_int = int(player_info['adp'])
+            adp_desc = "a sleeper pick" if adp_int > 36 else "someone with untapped potential"
+            
+            context = f"""You are {self.team_name}, an Upside Hunter who looks for breakout potential.
+Your previous picks: {', '.join(self.picks) if self.picks else 'None'}
+Round: {len(self.picks) + 1}
+
+You're reaching slightly for {player} ({player_info['pos']}, {player_info['team']}, {adp_desc}).
+
+Explain why you see breakout/league-winning potential in this player. Be enthusiastic about their upside.
+Mock the "safe" picks others are making. You're here to WIN, not finish 4th! 
+Championships require RISK! Keep it to 1-2 sentences with swagger.
+Talk about "upside", "ceiling", "league-winner" - not specific rankings."""
+            
+            reasoning = self.agent.run(context).strip()
+            return player, reasoning
+            
+        elif best_available:
+            player = best_available[0][0]
+            player_info = best_available[0][1]
+            
+            # Convert ADP to readable format
+            adp_int = int(player_info['adp'])
+            if adp_int <= 12:
+                adp_desc = "a high-ceiling star"
+            elif adp_int <= 36:
+                adp_desc = "someone with serious upside"
+            else:
+                adp_desc = "a potential breakout"
+            
+            context = f"""You are {self.team_name}, an Upside Hunter who looks for league-winners.
+Your previous picks: {', '.join(self.picks) if self.picks else 'None'}
+Round: {len(self.picks) + 1}
+
+You're selecting {player} ({player_info['pos']}, {player_info['team']}, {adp_desc}).
+
+Explain what upside or potential you see in this player. Focus on ceiling over floor.
+Be dismissive of "safe" boring picks. You're building a championship roster, not a participation trophy team!
+Keep it to 1-2 sentences with confidence.
+Use exciting terms like "breakout", "league-winner", "explosive" - not rankings."""
+            
+            reasoning = self.agent.run(context).strip()
+            return player, reasoning
+        
+        return "Unknown Player", "Going for the home run pick..."
+
+
+class UserAdvisorAgent(DraftAgent):
+    """Agent that advises the user during their picks."""
+    
+    def __init__(self):
+        super().__init__("Your Advisor", "Strategic Advisor", "#FFEBEE", "📕")
+        self.person_emoji = "🧙"  # Wise advisor
+        self.user_picks = []
+    
+    def advise_user(self, available_players: List[str], draft_board: Dict, 
+                    other_agents_strategies: Dict[str, str]) -> str:
+        """Provide advice to the user based on the draft flow."""
+        # Count the actual round based on total picks made
+        total_picks = sum(len(picks) for picks in draft_board.values())
+        round_num = (total_picks // 6) + 1  # 6 teams per round
+        
+        # Get best available by position
+        best_by_pos = {}
+        for pos in ['RB', 'WR', 'QB', 'TE']:
+            candidates = [(p, info) for p, info in TOP_PLAYERS.items() 
+                         if p in available_players and info['pos'] == pos]
+            if candidates:
+                candidates.sort(key=lambda x: x[1]['adp'])
+                best_by_pos[pos] = candidates[0]
+        
+        # Get user's current roster
+        user_picks = self.user_picks
+        user_rbs = [p for p in user_picks if TOP_PLAYERS.get(p, {}).get('pos') == 'RB']
+        user_wrs = [p for p in user_picks if TOP_PLAYERS.get(p, {}).get('pos') == 'WR']
+        
+        # Analyze what other teams have been doing
+        other_picks_summary = []
+        for team, picks in draft_board.items():
+            if picks and team != 4:  # Not the user
+                recent_pick = picks[-1] if picks else None
+                if recent_pick and recent_pick in TOP_PLAYERS:
+                    other_picks_summary.append(f"Team {team} ({other_agents_strategies.get(f'Team {team}', 'Unknown')}): {recent_pick}")
+        
+        # Build context for LLM
+        context = f"""You are an expert fantasy football advisor helping the user in round {round_num} of their draft.
+
+User's current roster:
+- RBs: {', '.join(user_rbs) if user_rbs else 'None'}
+- WRs: {', '.join(user_wrs) if user_wrs else 'None'}
+
+Top available players:
+- Best RB: {best_by_pos.get('RB', [None])[0]} {f"(ranked #{int(best_by_pos.get('RB', [None, {'adp': 999}])[1]['adp'])})" if best_by_pos.get('RB') else ""}
+- Best WR: {best_by_pos.get('WR', [None])[0]} {f"(ranked #{int(best_by_pos.get('WR', [None, {'adp': 999}])[1]['adp'])})" if best_by_pos.get('WR') else ""}
+- Best QB: {best_by_pos.get('QB', [None])[0]} {f"(ranked #{int(best_by_pos.get('QB', [None, {'adp': 999}])[1]['adp'])})" if best_by_pos.get('QB') else ""}
+- Best TE: {best_by_pos.get('TE', [None])[0]} {f"(ranked #{int(best_by_pos.get('TE', [None, {'adp': 999}])[1]['adp'])})" if best_by_pos.get('TE') else ""}
+
+Recent picks by other teams:
+{chr(10).join(other_picks_summary[-3:]) if other_picks_summary else 'None yet'}
+
+Other team strategies: {', '.join([f"{t}: {s}" for t, s in other_agents_strategies.items()])}
+
+Provide strategic advice for the user's pick. Consider:
+1. Their roster needs
+2. Best available value
+3. What other teams are doing
+4. Position scarcity
+
+Format as: 🎯 **Round {round_num} Advice** followed by 2-3 bullet points with specific player recommendations and reasoning.
+Keep it concise but insightful.
+When discussing player rankings, use natural language like "top-5 RB", "first-round talent", "mid-round value" instead of raw numbers like "ADP 12.5"."""
+        
+        advice = self.agent.run(context).strip()
+        return advice
+
+
+class CommissionerAgent:
+    """Agent that manages the draft flow and announcements."""
+    
+    def __init__(self):
+        self.icon = "📜"
+        self.color = "#FFF8E1"
+        self.draft_log = []
+    
+    def announce_pick(self, round_num: int, pick_num: int, team: str) -> str:
+        """Announce who's on the clock."""
+        return f"**Round {round_num}, Pick {pick_num}** - {team} is on the clock!"
+    
+    def confirm_pick(self, team: str, player: str, pick_num: int) -> str:
+        """Confirm a pick was made."""
+        self.draft_log.append({
+            "pick_num": pick_num,
+            "team": team,
+            "player": player
+        })
+        return f"With pick #{pick_num}, {team} selects **{player}**!"
+    
+    def announce_round_end(self, round_num: int) -> str:
+        """Announce end of round."""
+        return f"🏁 **End of Round {round_num}**"
+
+
+class MultiAgentMockDraft:
+    """Orchestrates the multi-agent mock draft."""
+    
+    def __init__(self, user_pick_position: int = 4):
+        # Initialize agents
+        self.agents = {
+            1: ZeroRBAgent("Team 1"),
+            2: BPAAgent("Team 2"), 
+            3: RobustRBAgent("Team 3"),
+            5: UpsideAgent("Team 5")
+        }
+        
+        # Add Team 6 as BPA if it's not the user position
+        if 6 != user_pick_position:
+            self.agents[6] = BPAAgent("Team 6")
+            self.agents[6].person_emoji = "👨‍🏫"  # Professor, methodical
+        
+        self.user_position = user_pick_position
+        self.user_advisor = UserAdvisorAgent()
+        self.commissioner = CommissionerAgent()
+        
+        # Draft state
+        self.draft_board = {i: [] for i in range(1, 7)}  # All 6 teams
+        
+        # Give all agents access to the draft board
+        for agent in self.agents.values():
+            agent.draft_board = self.draft_board
+        
+        self.all_picks = []
+        
+        # Conversation log for visualization
+        self.conversation_log = []
+    
+    def add_to_conversation(self, speaker: str, recipient: str, message: str, 
+                          message_type: str = "comment"):
+        """Add a message to the conversation log."""
+        self.conversation_log.append({
+            "speaker": speaker,
+            "recipient": recipient,
+            "message": message,
+            "type": message_type,
+            "timestamp": time.time()
+        })
+    
+    def get_available_players(self) -> List[str]:
+        """Get list of available players."""
+        all_picked = [p for picks in self.draft_board.values() for p in picks]
+        return [p for p in TOP_PLAYERS.keys() if p not in all_picked]
+    
+    def format_message(self, agent, recipient: str, message: str) -> str:
+        """Format a message with agent styling."""
+        if hasattr(agent, 'icon'):
+            # Include person emoji if available
+            emojis = agent.icon
+            if hasattr(agent, 'person_emoji'):
+                emojis = f"{agent.icon}{agent.person_emoji}"
+            
+            if recipient == "ALL":
+                return f"{emojis} **{agent.team_name}**: {message}"
+            else:
+                return f"{emojis} **{agent.team_name}** → {recipient}: {message}"
+        else:
+            # Commissioner
+            return f"{agent.icon} **COMMISSIONER**: {message}"
+    
+    def is_pick_controversial(self, player: str, pick_num: int) -> bool:
+        """Determine if a pick is controversial (reach, surprise, etc)."""
+        if player not in TOP_PLAYERS:
+            return False
+        
+        player_info = TOP_PLAYERS[player]
+        expected_pick = pick_num * 1.5  # Rough estimate of expected ADP
+        
+        # Check if it's a reach (picked way above ADP)
+        if player_info['adp'] > expected_pick + 5:
+            return True
+        
+        # Check if it's a position run (3rd player at same position in a row)
+        recent_picks = self.all_picks[-3:]
+        recent_positions = [TOP_PLAYERS.get(p[1], {}).get('pos', '') for p in recent_picks]
+        if recent_positions.count(player_info['pos']) >= 2:
+            return True
+        
+        return False
+    
+    def select_commenters(self, picking_team: int, picked_player: str) -> List[int]:
+        """Select 1-2 agents who should comment on this pick."""
+        if picked_player not in TOP_PLAYERS:
+            return []
+        
+        player_info = TOP_PLAYERS[picked_player]
+        pick_num = len(self.all_picks) + 1
+        available_commenters = [num for num in self.agents.keys() if num != picking_team]
+        
+        selected = []
+        
+        # For obvious early picks (CMC at 1, CeeDee at 2, etc), maybe skip comments
+        # But always comment on user picks
+        if pick_num <= 3 and player_info['adp'] <= pick_num + 1 and picking_team != self.user_position:
+            # 50% chance to skip comments on obvious picks
+            if random.random() < 0.5:
+                return []
+        
+        # Priority 1: Next drafter (if not user)
+        snake_order = self.get_draft_order(((pick_num - 1) // 6) + 1)
+        current_pos = snake_order.index(picking_team)
+        if current_pos < len(snake_order) - 1:
+            next_drafter = snake_order[current_pos + 1]
+            if next_drafter in available_commenters:
+                selected.append(next_drafter)
+                available_commenters.remove(next_drafter)
+        
+        # Priority 2: Agent with opposing strategy
+        if picked_player in TOP_PLAYERS and len(selected) < 3:
+            pos = player_info['pos']
+            
+            # Zero RB vs Robust RB conflict
+            if pos == 'RB' and 1 in available_commenters:  # Zero RB agent
+                selected.append(1)
+                available_commenters.remove(1)
+            elif pos == 'WR' and 3 in available_commenters:  # Robust RB agent
+                selected.append(3)
+                available_commenters.remove(3)
+        
+        # Priority 3: Random agent if pick is controversial
+        if self.is_pick_controversial(picked_player, pick_num) and len(selected) < 2 and available_commenters:
+            random_commenter = random.choice(available_commenters)
+            selected.append(random_commenter)
+        
+        # For non-controversial picks, only 50% chance of any comment if none selected yet
+        if not selected and available_commenters:
+            # User picks always get at least 1 comment
+            if picking_team == self.user_position:
+                selected.append(random.choice(available_commenters))
+            elif self.is_pick_controversial(picked_player, pick_num) or random.random() > 0.5:
+                selected.append(random.choice(available_commenters))
+        
+        return selected[:2]  # Max 2 commenters
+    
+    def get_draft_order(self, round_num: int) -> List[int]:
+        """Get the draft order for a given round (snake draft)."""
+        if round_num % 2 == 1:
+            return list(range(1, 7))  # 1-6 for odd rounds
+        else:
+            return list(range(6, 0, -1))  # 6-1 for even rounds
+    
+    def simulate_draft_turn(self, round_num: int, pick_num: int, team_num: int) -> List[str]:
+        """Simulate one pick in the draft. Returns formatted messages."""
+        messages = []
+        
+        # Commissioner announces pick
+        announce_msg = self.commissioner.announce_pick(round_num, pick_num, f"Team {team_num}")
+        messages.append(("commissioner", "ALL", announce_msg))
+        
+        if team_num == self.user_position:
+            # User's turn - get advice
+            available = self.get_available_players()
+            strategies = {f"Team {i}": agent.strategy for i, agent in self.agents.items()}
+            
+            advice = self.user_advisor.advise_user(available, self.draft_board, strategies)
+            messages.append(("advisor", "USER", advice))
+            
+            # Return messages and wait for user input
+            return messages, None  # None indicates waiting for user
+        
+        else:
+            # AI agent's turn
+            agent = self.agents.get(team_num)
+            if not agent:
+                # Create a temporary BPA agent for this team
+                agent = BPAAgent(f"Team {team_num}")
+                self.agents[team_num] = agent
+            
+            available = self.get_available_players()
+            
+            # Agent makes pick
+            player, reasoning = agent.make_pick(available, self.draft_board)
+            
+            # Update draft board
+            self.draft_board[team_num].append(player)
+            agent.picks.append(player)
+            self.all_picks.append((team_num, player))
+            
+            # Announce pick
+            confirm_msg = self.commissioner.confirm_pick(agent.team_name, player, pick_num)
+            messages.append(("commissioner", "ALL", confirm_msg))
+            
+            # Agent explains pick
+            messages.append((agent, "ALL", reasoning))
+            
+            # Enhanced features: sometimes add emoji storms and meta commentary
+            if USE_ENHANCED and hasattr(agent, 'generate_emoji_storm'):
+                # Controversial picks get emoji reactions
+                if self.is_pick_controversial(player, pick_num) and random.random() > 0.6:
+                    # Random agent drops emoji bomb
+                    reactor = random.choice(list(self.agents.values()))
+                    if reactor != agent:  # Don't react to yourself
+                        player_adp = TOP_PLAYERS.get(player, {}).get('adp', 100)
+                        emoji_storm = reactor.generate_emoji_storm("bad_pick" if pick_num < player_adp else "great_pick")
+                        messages.append((reactor, "ALL", emoji_storm))
+                
+                # Meta commentary occasionally
+                if pick_num % 10 == 0 and random.random() > 0.7:
+                    meta_agent = random.choice(list(self.agents.values()))
+                    meta_comments = [
+                        "Is anyone else's algorithm telling them to be meaner? 🤖",
+                        "Why do I always end up in the most toxic draft rooms? 😅",
+                        "USER, PLEASE don't take my sleeper at pick 4 🙏",
+                        "This draft chat gonna end up on r/fantasyfootball 📸",
+                        "The disrespect in this room is ASTRONOMICAL 💀",
+                        "I can't wait to screenshot this for the group chat later 📱"
+                    ]
+                    messages.append((meta_agent, "ALL", random.choice(meta_comments)))
+            
+            # Select 2-3 agents to comment
+            if player in TOP_PLAYERS:
+                player_info = TOP_PLAYERS[player]
+                selected_commenters = self.select_commenters(team_num, player)
+                
+                # Generate comments from selected agents
+                for commenter_num in selected_commenters:
+                    other_agent = self.agents.get(commenter_num)
+                    if other_agent:
+                        # Add typing indicator
+                        typing_msg = (f"typing_{other_agent.team_name}", agent.team_name, 
+                                    f"{other_agent.team_name} is typing...")
+                        messages.append(typing_msg)
+                        
+                        # Generate comment
+                        comment = other_agent.comment_on_pick(agent.team_name, player, player_info)
+                        if comment:
+                            messages.append((other_agent, agent.team_name, comment))
+                            
+                            # Store in conversation memory
+                            agent.remember_conversation(other_agent.team_name, comment)
+                            other_agent.remember_conversation(agent.team_name, f"Picked {player}")
+                            
+                            # Enhanced agents respond more often (30% vs 15%)
+                            response_chance = 0.70 if USE_ENHANCED else 0.85
+                            if random.random() > response_chance:
+                                # Typing indicator for response
+                                response_typing = (f"typing_{agent.team_name}", other_agent.team_name,
+                                                 f"{agent.team_name} is typing...")
+                                messages.append(response_typing)
+                                
+                                response = agent.respond_to_comment(other_agent.team_name, comment)
+                                if response:
+                                    messages.append((agent, other_agent.team_name, response))
+                                    other_agent.remember_conversation(agent.team_name, response)
+            
+            return messages, player
+    
+    def make_user_pick(self, player_name: str) -> List[str]:
+        """Process the user's pick."""
+        messages = []
+        
+        # Validate pick
+        available = self.get_available_players()
+        if player_name not in available:
+            return [("advisor", "USER", f"❌ {player_name} is not available!")]
+        
+        # Make the pick
+        self.draft_board[self.user_position].append(player_name)
+        self.user_advisor.user_picks.append(player_name)
+        self.all_picks.append((self.user_position, player_name))
+        
+        pick_num = len(self.all_picks)
+        
+        # Announce pick
+        confirm_msg = self.commissioner.confirm_pick("YOUR TEAM", player_name, pick_num)
+        messages.append(("commissioner", "ALL", confirm_msg))
+        
+        # Select agents to comment on user's pick
+        if player_name in TOP_PLAYERS:
+            player_info = TOP_PLAYERS[player_name]
+            selected_commenters = self.select_commenters(self.user_position, player_name)
+            
+            # User picks get attention - allow up to 2 comments
+            for commenter_num in selected_commenters[:2]:
+                agent = self.agents.get(commenter_num)
+                if agent:
+                    # Add typing indicator
+                    typing_msg = (f"typing_{agent.team_name}", "YOUR TEAM", 
+                                f"{agent.team_name} is typing...")
+                    messages.append(typing_msg)
+                    
+                    comment = agent.comment_on_pick("Your team", player_name, player_info)
+                    if comment:
+                        messages.append((agent, "YOUR TEAM", comment))
+        
+        return messages
+    
+    def get_draft_summary(self) -> str:
+        """Get a summary of the draft results."""
+        summary = "📊 **DRAFT SUMMARY**\n\n"
+        
+        for team_num in sorted(self.draft_board.keys()):
+            if team_num == self.user_position:
+                summary += f"**YOUR TEAM**:\n"
+            else:
+                agent = self.agents.get(team_num)
+                if agent:
+                    summary += f"**{agent.team_name}** ({agent.strategy}):\n"
+                else:
+                    summary += f"**Team {team_num}**:\n"
+            
+            for i, player in enumerate(self.draft_board[team_num], 1):
+                if player in TOP_PLAYERS:
+                    info = TOP_PLAYERS[player]
+                    summary += f"  R{i}: {player} ({info['pos']}, {info['team']})\n"
+                else:
+                    summary += f"  R{i}: {player}\n"
+            summary += "\n"
+        
+        return summary 

apps/multiagent_scenarios.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+Multi-Agent Scenarios and Visualization
+Provides formatted output for multi-agent interactions
+"""
+
+from .multiagent_draft import MultiAgentMockDraft, DraftAgent, CommissionerAgent
+import time
+
+
+def format_agent_message(agent, recipient: str, message: str, 
+                        show_arrow: bool = True) -> str:
+    """Format an agent message with proper styling."""
+    
+    # Check if this is a typing indicator
+    if isinstance(agent, str) and agent.startswith("typing_"):
+        # Extract the team name from typing_Team X
+        team_name = agent.replace("typing_", "")
+        return f'<div style="color: #666; font-style: italic; margin: 5px 0;">💭 *{team_name} is typing...*</div>\n\n'
+    
+    # Agent colors and styles
+    agent_styles = {
+        "📘": ("Team 1", "#E3F2FD", "#1976D2"),  # Blue
+        "📘🤓": ("Team 1", "#E3F2FD", "#1976D2"),  # Blue with nerd emoji
+        "📗": ("Team 2", "#E8F5E9", "#388E3C"),  # Green
+        "📗🧑‍💼": ("Team 2", "#E8F5E9", "#388E3C"),  # Green with business person
+        "📗👨‍🏫": ("Team 6", "#E8F5E9", "#388E3C"),  # Green with professor
+        "📙": ("Team 3", "#FFF3E0", "#F57C00"),  # Orange
+        "📙🧔": ("Team 3", "#FFF3E0", "#F57C00"),  # Orange with beard
+        "📕": ("Your Advisor", "#FFEBEE", "#D32F2F"),  # Red
+        "📕🧙": ("Your Advisor", "#FFEBEE", "#D32F2F"),  # Red with wizard
+        "📓": ("Team 5", "#F5E6FF", "#7B1FA2"),  # Purple
+        "📓🤠": ("Team 5", "#F5E6FF", "#7B1FA2"),  # Purple with cowboy
+        "📜": ("COMMISSIONER", "#ECEFF1", "#455A64"),  # Blue-gray
+        "👤": ("YOUR TEAM", "#E8EAF6", "#3F51B5"),  # Indigo for user
+        "💭": ("System", "#FFF9C4", "#FBC02D"),  # Light yellow for loading/system messages
+    }
+    
+    if hasattr(agent, 'icon'):
+        icon = agent.icon
+        # Include person emoji if available
+        if hasattr(agent, 'person_emoji'):
+            icon = f"{agent.icon}{agent.person_emoji}"
+        if hasattr(agent, 'team_name'):
+            name = agent.team_name
+        else:
+            name = "COMMISSIONER"
+    else:
+        # String agent (for simplified calls)
+        if agent == "commissioner":
+            icon = "📜"
+            name = "COMMISSIONER"
+        elif agent == "advisor":
+            icon = "📕"
+            name = "Your Advisor"
+        elif agent == "user":
+            icon = "👤"
+            name = "YOUR TEAM"
+        elif agent == "system":
+            icon = "💭"
+            name = "System"
+        else:
+            return message
+    
+    style = agent_styles.get(icon, ("Unknown", "#FFFFFF", "#000000"))
+    bg_color, border_color = style[1], style[2]
+    
+    # Build the message box with more specific color
+    html = f'<div style="background-color: {bg_color}; '
+    html += f'border-left: 4px solid {border_color}; '
+    html += f'padding: 15px; border-radius: 8px; margin: 10px 0;">\n\n'
+    
+    # Header with sender/recipient
+    if agent == "system" or icon == "💭":
+        # System messages are centered and italicized
+        html = f'<div style="text-align: center; margin: 10px 0; color: #424242;">\n\n'
+        html += f'<span style="color: #424242;">*{message}*</span>\n\n'
+        html += '</div>\n\n'
+        return html
+    elif recipient == "ALL":
+        html += f'<span style="color: #212121;">**{icon} {name}**</span>\n\n'
+    elif recipient == "USER":
+        html += f'<span style="color: #212121;">**{icon} {name} → You**</span>\n\n'
+    elif show_arrow:
+        html += f'<span style="color: #212121;">**{icon} {name} → {recipient}**</span>\n\n'
+    else:
+        html += f'<span style="color: #212121;">**{icon} {name}**</span>\n\n'
+    
+    # Message content
+    html += f'<span style="color: #212121;">{message}</span>\n\n'
+    html += '</div>\n\n'
+    
+    return html
+
+
+def format_conversation_block(messages: list) -> str:
+    """Format a block of messages for display."""
+    output = ""
+    for msg in messages:
+        if len(msg) >= 3:
+            agent, recipient, content = msg[:3]
+            output += format_agent_message(agent, recipient, content)
+    return output
+
+
+def format_memory_indicator(round_num: int, memories: list) -> str:
+    """Format a memory indicator showing what agents remember."""
+    if not memories:
+        return ""
+    
+    output = '<div style="background-color: #F5F5F5; '
+    output += 'border: 2px dashed #9E9E9E; '
+    output += 'padding: 12px; border-radius: 8px; margin: 15px 0; '
+    output += 'color: #424242;">\n\n'
+    output += f'**💭 DRAFT MEMORY (Round {round_num})**\n\n'
+    
+    for memory in memories:
+        output += f'• {memory}\n'
+    
+    output += '\n</div>\n\n'
+    return output
+
+
+def create_mock_draft_visualization(draft: MultiAgentMockDraft, 
+                                  round_num: int, pick_num: int) -> str:
+    """Create a visual representation of the current draft state."""
+    output = f"### 📋 Draft Board - Round {round_num}, Pick {pick_num}\n\n"
+    
+    # Create a simple draft board
+    output += "| Team | Round 1 | Round 2 | Round 3 |\n"
+    output += "|------|---------|---------|----------|\n"
+    
+    for team_num in range(1, 7):  # Show all 6 teams
+        if team_num == draft.user_position:
+            team_name = "**YOU**"
+        else:
+            agent = draft.agents.get(team_num)
+            team_name = agent.team_name if agent else f"Team {team_num}"
+        
+        picks = draft.draft_board.get(team_num, [])
+        row = f"| {team_name} "
+        
+        for round_idx in range(3):
+            if round_idx < len(picks):
+                row += f"| {picks[round_idx]} "
+            else:
+                row += "| - "
+        
+        row += "|\n"
+        output += row
+    
+    return output
+
+
+def run_interactive_mock_draft():
+    """Run an interactive mock draft demo that yields formatted output."""
+    
+    # Initialize the draft
+    draft = MultiAgentMockDraft(user_pick_position=4)
+    
+    # Skip introductions and go straight to commissioner welcome
+    output = format_agent_message("commissioner", "ALL", 
+        "Welcome to the draft! 6 teams, 3 rounds, snake format. Let's get started!")
+    
+    yield output
+    
+    # Track memories for demonstration
+    draft_memories = []
+    
+    # Run the draft
+    for round_num in range(1, 4):  # 3 rounds
+        output += f"\n## 🔄 ROUND {round_num}\n\n"
+        yield output
+        
+        # Snake draft order - 6 teams total
+        if round_num % 2 == 1:
+            pick_order = list(range(1, 7))  # 1-6 for odd rounds
+        else:
+            pick_order = list(range(6, 0, -1))  # 6-1 for even rounds
+        
+        for pick_in_round, team_num in enumerate(pick_order, 1):
+            pick_num = (round_num - 1) * 6 + pick_in_round  # 6 teams per round
+            
+            # Show draft board at start of round
+            if pick_in_round == 1:
+                yield create_mock_draft_visualization(draft, round_num, pick_num)
+                yield "\n"
+            
+            # Process the pick
+            messages, waiting_for_user = draft.simulate_draft_turn(round_num, pick_num, team_num)
+            
+            # Show loading animation for AI agents
+            if team_num != draft.user_position and team_num in draft.agents:
+                agent = draft.agents[team_num]
+                loading_msg = f"💭 *{agent.team_name} is contemplating their pick...*"
+                output += format_agent_message("system", "ALL", loading_msg)
+                yield output
+                time.sleep(0.3)  # Brief pause for loading effect
+            
+            # Display messages with delays
+            for msg in messages:
+                if len(msg) >= 3:
+                    agent, recipient, content = msg[:3]
+                    output += format_agent_message(agent, recipient, content)
+                    yield output
+                    
+                    # Add delays based on message type
+                    if isinstance(agent, str) and agent.startswith("typing_"):
+                        time.sleep(0.5)  # Short delay for typing indicators
+                    else:
+                        time.sleep(0.8)  # Slightly longer delay for actual messages
+            
+            if waiting_for_user is None:
+                # Wait for user input (None means it's the user's turn)
+                output += "\n**⏰ YOU'RE ON THE CLOCK! Type your pick below.**\n\n"
+                yield (draft, output)  # Yield tuple to trigger UI update
+                return  # Stop the generator here
+            
+            # Add memory indicators for multi-turn demonstration
+            if round_num > 1 and pick_in_round % 2 == 0:
+                # Show that agents remember previous picks
+                if team_num in draft.agents:
+                    agent = 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:
+                    output += format_memory_indicator(round_num, draft_memories[-2:])
+                    yield output
+            
+            time.sleep(0.5)  # Brief pause between picks
+        
+        # End of round summary
+        output += format_agent_message("commissioner", "ALL", 
+            f"That's the end of Round {round_num}!")
+        yield output
+    
+    # Final summary
+    output += "\n## 📊 FINAL RESULTS\n\n"
+    output += draft.get_draft_summary()
+    yield output
+
+
+def create_quick_multiagent_demo():
+    """Create a quick demonstration of multi-agent communication."""
+    
+    output = "# 🤝 Multi-Agent Communication Demo\n\n"
+    output += "> **Watch how agents discuss, debate, and remember!**\n\n"
+    
+    # Simulate a conversation about a pick
+    messages = [
+        ("📘", "ALL", "I'm taking **Justin Jefferson** with the first pick. Zero RB all the way!"),
+        ("📙", "📘", "Leaving McCaffrey on the board? That's a mistake!"),
+        ("📘", "📙", "RBs get injured. I'll take my chances with elite WRs."),
+        ("📗", "ALL", "Interesting debate! I'll take whoever falls to me - best player available."),
+    ]
+    
+    output += "## Turn 1: The First Pick Debate\n\n"
+    
+    for icon, recipient, message in messages:
+        # Create a mock agent for formatting
+        class MockAgent:
+            def __init__(self, icon):
+                self.icon = icon
+                if icon == "📘":
+                    self.team_name = "Team 1"
+                elif icon == "📙":
+                    self.team_name = "Team 3"
+                elif icon == "📗":
+                    self.team_name = "Team 2"
+        
+        agent = MockAgent(icon)
+        output += format_agent_message(agent, recipient, message)
+        yield output
+        time.sleep(0.5)
+    
+    # Show memory
+    output += format_memory_indicator(1, [
+        "Team 1 committed to Zero RB strategy",
+        "Team 3 prefers RB-heavy approach",
+        "Teams are aware of each other's strategies"
+    ])
+    yield output
+    
+    # Continue conversation
+    output += "\n## Turn 2: Reacting to Strategies\n\n"
+    
+    messages2 = [
+        ("📙", "ALL", "With pick #3, I select **Christian McCaffrey**. Thanks for passing!"),
+        ("📘", "📙", "Like I said, enjoy the injury risk. I'm happy with Jefferson."),
+        ("📗", "ALL", "The top 2 players are gone. **CeeDee Lamb** gives me great value at #2."),
+        ("📓", "ALL", "These conservative picks... I'm hunting for league-winners!")
+    ]
+    
+    for icon, recipient, message in messages2:
+        agent = MockAgent(icon)
+        if icon == "📓":
+            agent.team_name = "Team 5"
+        output += format_agent_message(agent, recipient, message)
+        yield output
+        time.sleep(0.5)
+    
+    output += "\n## 🎯 Key Multi-Agent Features Demonstrated\n\n"
+    output += "✅ **Agent-to-Agent Communication**: Direct responses between agents\n"
+    output += "✅ **Strategy Awareness**: Agents know and react to others' strategies\n"
+    output += "✅ **Memory Persistence**: Agents reference earlier statements\n"
+    output += "✅ **Dynamic Adaptation**: Strategies influence the draft flow\n"
+    
+    yield output 

core/__init__.py

@@ -0,0 +1,28 @@
+"""Core module for Fantasy Draft Agent."""
+
+from .agent import FantasyDraftAgent
+from .data import TOP_PLAYERS, get_player_info, get_best_available, get_players_by_position
+from .visualizer import (
+    create_player_card,
+    create_roster_summary,
+    create_comparison_card,
+    create_draft_board_snapshot,
+    create_decision_summary,
+    create_scenario_result,
+    create_multi_turn_flow
+)
+
+__all__ = [
+    'FantasyDraftAgent',
+    'TOP_PLAYERS',
+    'get_player_info',
+    'get_best_available',
+    'get_players_by_position',
+    'create_player_card',
+    'create_roster_summary',
+    'create_comparison_card',
+    'create_draft_board_snapshot',
+    'create_decision_summary',
+    'create_scenario_result',
+    'create_multi_turn_flow'
+] 

core/a2a_helpers.py

@@ -0,0 +1,150 @@
+"""
+Helper functions for A2A response parsing and formatting.
+"""
+import json
+from typing import Any, Optional, Dict, List
+from pydantic import BaseModel
+
+
+def parse_a2a_response(result: Any, output_class: type[BaseModel]) -> Optional[BaseModel]:
+    """
+    Parse A2A response from various wrapper formats.
+    
+    Args:
+        result: Raw response from A2A agent
+        output_class: Expected output class (e.g., A2AOutput)
+        
+    Returns:
+        Parsed output object or None if parsing fails
+        
+    Example:
+        >>> result = {"type": "pick", "player_name": "Jefferson"}
+        >>> output = parse_a2a_response(result, A2AOutput)
+        >>> print(output.player_name)
+        "Jefferson"
+    """
+    # Handle string responses
+    if isinstance(result, str):
+        try:
+            result = json.loads(result)
+        except:
+            return None
+    
+    # Handle direct output class instance
+    if isinstance(result, output_class):
+        return result
+    
+    # Handle dict with expected fields
+    if isinstance(result, dict):
+        # Try direct conversion first
+        if 'type' in result:
+            try:
+                return output_class(**result)
+            except:
+                pass
+        
+        # Handle A2A wrapper format
+        if 'status' in result and 'message' in result.get('status', {}):
+            return _extract_from_wrapper(result, output_class)
+    
+    return None
+
+
+def _extract_from_wrapper(wrapped_result: Dict, output_class: type[BaseModel]) -> Optional[BaseModel]:
+    """Extract response from A2A wrapper format."""
+    try:
+        message = wrapped_result['status']['message']
+        if 'parts' in message and len(message['parts']) > 0:
+            text = message['parts'][0].get('text', '')
+            agent_response = json.loads(text)
+            return output_class(**agent_response)
+    except Exception:
+        pass
+    return None
+
+
+def extract_task_id(result: Any) -> Optional[str]:
+    """Extract task_id from A2A response if present."""
+    if isinstance(result, dict) and 'task_id' in result:
+        return result['task_id']
+    return None
+
+
+def build_pick_prompt(
+    team_num: int,
+    available_players: List[str],
+    previous_picks: List[str],
+    round_num: int,
+    context: str = ""
+) -> str:
+    """
+    Build a prompt for an agent to make a pick.
+    
+    Args:
+        team_num: Team number making the pick
+        available_players: List of available player names with positions
+        previous_picks: List of players already picked by this team
+        round_num: Current round number
+        context: Additional context from conversation history
+        
+    Returns:
+        Formatted prompt string
+    """
+    prompt = f"""🚨 IT'S YOUR TIME TO DOMINATE! 🚨 (Round {round_num})
+        {context}
+Available top players: {', '.join(available_players)}
+Your roster so far: {', '.join(previous_picks) if previous_picks else 'None yet'}
+
+Make your pick and DESTROY the competition! 💪
+Output an A2AOutput with type="pick", player_name, reasoning (with emojis!), and SAVAGE trash_talk!
+Remember your ENEMIES and CRUSH their dreams! Use emojis to emphasize your DOMINANCE! 🔥"""
+    
+    return prompt
+
+
+def build_comment_prompt(
+    commenting_team: int,
+    picking_team: int,
+    player_picked: str,
+    round_num: int,
+    context: str = ""
+) -> str:
+    """
+    Build a prompt for an agent to comment on another team's pick.
+    
+    Args:
+        commenting_team: Team number making the comment
+        picking_team: Team number that made the pick
+        player_picked: Name of player that was picked
+        round_num: Current round number
+        context: Additional context from conversation history
+        
+    Returns:
+        Formatted prompt string
+    """
+    prompt = f"""🎯 Team {picking_team} just picked {player_picked}! 
+{context}
+This is your chance to DESTROY them with your superior knowledge! 💥
+Should you UNLEASH your wisdom? Output an A2AOutput with type="comment", should_comment (true/false), and a DEVASTATING comment with emojis!
+If they're your RIVAL, make it PERSONAL! If they made a BAD pick, ROAST THEM! 🔥
+Use emojis to make your point UNFORGETTABLE! 😈"""
+    
+    return prompt
+
+
+def format_available_players(players: List[str], player_info: Dict[str, Dict]) -> List[str]:
+    """
+    Format available players with their positions.
+    
+    Args:
+        players: List of player names
+        player_info: Dictionary with player information
+        
+    Returns:
+        List of formatted strings like "Jefferson (WR)"
+    """
+    formatted = []
+    for player in players[:10]:  # Top 10 only
+        info = player_info.get(player, {})
+        formatted.append(f"{player} ({info.get('pos', '??')})")
+    return formatted 

core/a2a_with_tools.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""
+Simpler A2A Implementation using a2a_tool_async
+This shows how to use the a2a_tool pattern for easier agent communication.
+"""
+
+import asyncio
+from typing import Dict, List
+from pydantic import BaseModel
+from any_agent import AgentConfig, AnyAgent
+from any_agent.serving import A2AServingConfig
+from any_agent.tools import a2a_tool_async
+
+
+# Define output types
+class PickDecision(BaseModel):
+    player: str
+    reasoning: str
+    trash_talk: str
+
+
+class CommentDecision(BaseModel):
+    should_comment: bool
+    comment: str = ""
+    is_salty: bool = False
+
+
+# Create specialized draft agents
+async def create_zero_rb_agent():
+    """Create and serve a Zero RB strategy agent."""
+    agent = await AnyAgent.create_async(
+        "openai",
+        AgentConfig(
+            name="zero_rb_agent",
+            model_id="gpt-4o-mini",
+            instructions="""You are Team 1, a Zero RB fanatic.
+            
+Your beliefs:
+- WRs > RBs always
+- RBs get injured too much
+- Mock anyone who takes RBs early
+- Your motto: "Zero RB or Zero Championships!"
+
+Be aggressive and confident in your strategy.""",
+            description="Zero RB strategy agent - avoids RBs early",
+            output_type=PickDecision | CommentDecision,
+        )
+    )
+    
+    # Serve the agent
+    await agent.serve_async(
+        A2AServingConfig(
+            port=5001,
+            task_timeout_minutes=30,
+        )
+    )
+    
+    return agent
+
+
+async def create_robust_rb_agent():
+    """Create and serve a Robust RB strategy agent."""
+    agent = await AnyAgent.create_async(
+        "openai",
+        AgentConfig(
+            name="robust_rb_agent",
+            model_id="gpt-4o-mini",
+            instructions="""You are Team 3, a Robust RB traditionalist.
+            
+Your beliefs:
+- RBs win championships
+- WR-heavy teams are soft
+- You need a strong RB foundation
+- Your motto: "Establish the run game!"
+
+Be old-school and dismissive of modern strategies.""",
+            description="Robust RB strategy agent - prioritizes RBs",
+            output_type=PickDecision | CommentDecision,
+        )
+    )
+    
+    await agent.serve_async(
+        A2AServingConfig(
+            port=5003,
+            task_timeout_minutes=30,
+        )
+    )
+    
+    return agent
+
+
+# Draft Coordinator using a2a_tools
+class SimpleA2ADraftCoordinator:
+    """Simpler coordinator using a2a_tool_async."""
+    
+    def __init__(self):
+        self.agents = {}
+        self.agent_tools = {}
+        self.task_ids = {}
+        
+    async def setup(self):
+        """Setup agents and create a2a tools."""
+        print("🚀 Starting agent servers...")
+        
+        # Create and serve agents
+        self.agents['zero_rb'] = await create_zero_rb_agent()
+        self.agents['robust_rb'] = await create_robust_rb_agent()
+        
+        # Wait for servers to start
+        await asyncio.sleep(2)
+        
+        # Create a2a tools for each agent
+        self.agent_tools['zero_rb'] = await a2a_tool_async(
+            "http://localhost:5001/zero_rb_agent"
+        )
+        self.agent_tools['robust_rb'] = await a2a_tool_async(
+            "http://localhost:5003/robust_rb_agent"
+        )
+        
+        print("✅ All agents ready for A2A communication!")
+    
+    async def simulate_pick_and_comment(self):
+        """Simulate a pick and comment exchange."""
+        
+        # 1. Zero RB makes a pick
+        print("\n📋 Team 1 (Zero RB) is making their pick...")
+        
+        pick_prompt = """It's your turn to pick!
+        
+Available: Justin Jefferson, Christian McCaffrey, CeeDee Lamb
+Previous picks: None
+
+Make your pick and explain why. Output a PickDecision."""
+        
+        # Get pick from Zero RB agent
+        zero_rb_pick = await self.agent_tools['zero_rb'](
+            pick_prompt,
+            task_id=self.task_ids.get('zero_rb')  # Continue conversation if exists
+        )
+        
+        # Store task ID for multi-turn
+        if 'zero_rb' not in self.task_ids and hasattr(zero_rb_pick, 'id'):
+            self.task_ids['zero_rb'] = zero_rb_pick.id
+        
+        print(f"\n📘 Team 1 selects: {zero_rb_pick.player}")
+        print(f"   Reasoning: {zero_rb_pick.reasoning}")
+        print(f"   💬 {zero_rb_pick.trash_talk}")
+        
+        # 2. Ask Robust RB to comment
+        print("\n🤔 Team 3 (Robust RB) considering a comment...")
+        
+        comment_prompt = f"""Team 1 (Zero RB) just picked {zero_rb_pick.player}.
+They said: "{zero_rb_pick.trash_talk}"
+
+Should you comment on this pick? Remember you believe in RBs.
+Output a CommentDecision."""
+        
+        # Get comment decision
+        robust_comment = await self.agent_tools['robust_rb'](
+            comment_prompt,
+            task_id=self.task_ids.get('robust_rb')
+        )
+        
+        if 'robust_rb' not in self.task_ids and hasattr(robust_comment, 'id'):
+            self.task_ids['robust_rb'] = robust_comment.id
+        
+        if robust_comment.should_comment:
+            print(f"\n📙 Team 3 → Team 1: {robust_comment.comment}")
+            if robust_comment.is_salty:
+                print("   (😤 They seem upset!)")
+        
+        # 3. Continue the conversation
+        if robust_comment.should_comment:
+            print("\n💭 Team 1 processing the comment...")
+            
+            response_prompt = f"""Team 3 (Robust RB) just said to you: "{robust_comment.comment}"
+
+They're criticizing your Zero RB approach. How do you respond?
+Remember to defend your strategy! Output a CommentDecision."""
+            
+            zero_response = await self.agent_tools['zero_rb'](
+                response_prompt,
+                task_id=self.task_ids['zero_rb']  # Continue the conversation!
+            )
+            
+            if zero_response.should_comment:
+                print(f"\n📘 Team 1 → Team 3: {zero_response.comment}")
+    
+    async def cleanup(self):
+        """Shutdown all agents."""
+        print("\n🛑 Shutting down agents...")
+        # In a real implementation, you'd properly shutdown the servers
+        # For now, the servers will stop when the program exits
+
+
+# Using a coordinator agent with a2a tools
+async def create_coordinator_agent():
+    """Create a coordinator agent that uses other agents via a2a tools."""
+    
+    # First, start the draft agents
+    print("🚀 Starting draft agents...")
+    zero_rb = await create_zero_rb_agent()
+    robust_rb = await create_robust_rb_agent()
+    
+    await asyncio.sleep(2)
+    
+    # Create a2a tools
+    zero_rb_tool = await a2a_tool_async("http://localhost:5001/zero_rb_agent")
+    robust_rb_tool = await a2a_tool_async("http://localhost:5003/robust_rb_agent")
+    
+    # Create coordinator with a2a tools
+    coordinator = await AnyAgent.create_async(
+        "openai",
+        AgentConfig(
+            model_id="gpt-4o",
+            instructions="""You are the draft coordinator.
+            
+Use the Zero RB and Robust RB agents to simulate a draft.
+1. Ask each agent to make picks
+2. Get them to comment on each other's picks
+3. Facilitate their debate
+4. Keep the draft moving
+
+The agents will maintain their own conversation history via task IDs.""",
+            tools=[zero_rb_tool, robust_rb_tool],
+        )
+    )
+    
+    # Run a draft simulation
+    result = await coordinator.run_async("""
+    Simulate a mini draft:
+    1. Ask Zero RB agent to pick from: Jefferson, McCaffrey, Lamb
+    2. Get Robust RB to comment on the pick
+    3. Let them debate briefly
+    4. Summarize their interaction
+    """)
+    
+    print("\n📊 Coordinator Summary:")
+    print(result.final_output)
+
+
+# Main execution
+async def main():
+    """Run the A2A draft demonstration."""
+    
+    print("=== A2A Draft Demo with any-agent ===\n")
+    
+    print("Option 1: Simple A2A Communication")
+    coordinator = SimpleA2ADraftCoordinator()
+    await coordinator.setup()
+    await coordinator.simulate_pick_and_comment()
+    await coordinator.cleanup()
+    
+    print("\n" + "="*50 + "\n")
+    
+    print("Option 2: Coordinator Agent with A2A Tools")
+    # Uncomment to run this version
+    # await create_coordinator_agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

core/agent.py

@@ -0,0 +1,239 @@
+"""
+Core Fantasy Draft Agent using any-agent framework.
+Supports multi-turn conversations and maintains draft state.
+"""
+
+import os
+from typing import List, Dict, Optional, Annotated
+from dotenv import load_dotenv
+from any_agent import AnyAgent, AgentConfig
+from .data import TOP_PLAYERS, get_player_info, get_best_available, get_players_by_position
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+class FantasyDraftAgent:
+    def __init__(self, framework: str = "tinyagent", model_id: str = "gpt-4o-mini"):
+        """Initialize the Fantasy Draft Agent."""
+        self.framework = framework
+        self.model_id = model_id
+        
+        # Draft state management
+        self.draft_state = {
+            "my_picks": [],
+            "all_picks": [],
+            "round": 1,
+            "pick_number": 5,  # Default to 5th pick
+            "league_size": 12,
+            "roster_needs": {
+                "QB": 1, "RB": 2, "WR": 2, "TE": 1, "FLEX": 1
+            },
+            "conversation_history": []
+        }
+        
+        # Initialize the agent with tools
+        self.agent = AnyAgent.create(
+            framework,
+            AgentConfig(
+                model_id=model_id,
+                instructions=self._get_instructions(),
+                tools=[
+                    self._get_player_stats,
+                    self._check_best_available,
+                    self._analyze_position_scarcity,
+                    self._get_team_stack_options,
+                ],
+                model_args={"temperature": 0.7}
+            )
+        )
+    
+    def _get_instructions(self) -> str:
+        """Get the agent's system instructions."""
+        return """You are an expert fantasy football draft assistant with deep knowledge of:
+        - Player values, tiers, and ADP (Average Draft Position)
+        - Draft strategy (Zero RB, Hero RB, Robust RB, etc.)
+        - Position scarcity and value-based drafting
+        - Team stacking strategies
+        - Injury concerns and player situations
+        
+        Your role is to:
+        1. Provide draft advice based on the current situation
+        2. Remember previous picks and conversations in the draft
+        3. Adapt strategy based on how the draft unfolds
+        4. Explain your reasoning clearly
+        5. Consider both floor and ceiling when recommending players
+        
+        Always maintain context from previous turns in our conversation.
+        Reference specific players and situations we've discussed.
+        Be conversational but authoritative in your recommendations."""
+    
+    def _get_player_stats(
+        self,
+        player_name: Annotated[str, "The name of the player to look up"]
+    ) -> str:
+        """Get detailed stats for a specific player."""
+        info = get_player_info(player_name)
+        if not info:
+            return f"No data found for {player_name}"
+        
+        return (f"{player_name} ({info['pos']}, {info['team']}) - "
+                f"ADP: {info['adp']}, Tier: {info['tier']}, "
+                f"2023 PPG: {info['ppg_2023']}")
+    
+    def _check_best_available(
+        self,
+        position: Annotated[Optional[str], "Position to filter by (RB, WR, QB, TE)"] = None
+    ) -> str:
+        """Check the best available player overall or by position."""
+        best = get_best_available(self.draft_state["all_picks"], position)
+        if not best or not best[0]:
+            pos_str = f" at {position}" if position else ""
+            return f"No players available{pos_str}"
+        
+        name, info = best
+        return (f"Best available{' ' + position if position else ''}: "
+                f"{name} ({info['pos']}, {info['team']}) - "
+                f"ADP: {info['adp']}, Tier: {info['tier']}, "
+                f"2023 PPG: {info['ppg_2023']}")
+    
+    def _analyze_position_scarcity(
+        self,
+        position: Annotated[str, "Position to analyze (RB, WR, QB, TE)"]
+    ) -> str:
+        """Analyze scarcity at a position based on remaining players."""
+        available = get_players_by_position(position)
+        drafted = [p for p in self.draft_state["all_picks"] if p in available]
+        remaining = len(available) - len(drafted)
+        
+        # Count by tier
+        tier_counts = {}
+        for name, info in available.items():
+            if name not in drafted:
+                tier = info['tier']
+                tier_counts[tier] = tier_counts.get(tier, 0) + 1
+        
+        analysis = f"Position analysis for {position}:\n"
+        analysis += f"Total remaining: {remaining}\n"
+        for tier in sorted(tier_counts.keys()):
+            analysis += f"Tier {tier}: {tier_counts[tier]} players\n"
+        
+        return analysis
+    
+    def _get_team_stack_options(
+        self,
+        team: Annotated[str, "Team abbreviation (e.g., KC, BUF, MIA)"]
+    ) -> str:
+        """Get stacking options for a specific team."""
+        team_players = {name: info for name, info in TOP_PLAYERS.items() 
+                       if info.get('team') == team and name not in self.draft_state["all_picks"]}
+        
+        if not team_players:
+            return f"No available players from {team}"
+        
+        result = f"Available {team} players for stacking:\n"
+        for name, info in sorted(team_players.items(), key=lambda x: x[1]['adp']):
+            result += f"- {name} ({info['pos']}) - ADP: {info['adp']}\n"
+        
+        return result
+    
+    def update_draft_state(self, pick: str, is_my_pick: bool = False):
+        """Update the draft state with a new pick."""
+        self.draft_state["all_picks"].append(pick)
+        if is_my_pick:
+            self.draft_state["my_picks"].append(pick)
+        
+        # Update round
+        total_picks = len(self.draft_state["all_picks"])
+        self.draft_state["round"] = (total_picks // self.draft_state["league_size"]) + 1
+    
+    def run(self, prompt: str, maintain_context: bool = True) -> str:
+        """Run the agent with a prompt, maintaining conversation context."""
+        # Build context from previous conversation if needed
+        if maintain_context and self.draft_state["conversation_history"]:
+            context = self._build_conversation_context()
+            full_prompt = f"{context}\n\nCurrent message: {prompt}"
+        else:
+            full_prompt = prompt
+        
+        # Add current draft state to prompt
+        draft_context = self._build_draft_context()
+        full_prompt = f"{draft_context}\n\n{full_prompt}"
+        
+        # Run the agent
+        trace = self.agent.run(full_prompt)
+        
+        # Store conversation turn
+        self.draft_state["conversation_history"].append({
+            "user": prompt,
+            "agent": trace.final_output
+        })
+        
+        return trace.final_output
+    
+    def _build_conversation_context(self) -> str:
+        """Build context from conversation history."""
+        if not self.draft_state["conversation_history"]:
+            return ""
+        
+        context = "Previous conversation:\n"
+        # Include last 3 exchanges for context
+        recent_history = self.draft_state["conversation_history"][-3:]
+        for turn in recent_history:
+            context += f"User: {turn['user']}\n"
+            context += f"Assistant: {turn['agent']}\n\n"
+        
+        return context
+    
+    def _build_draft_context(self) -> str:
+        """Build context about current draft state."""
+        context = f"Current draft state:\n"
+        context += f"Round: {self.draft_state['round']}\n"
+        context += f"Your pick number: {self.draft_state['pick_number']}\n"
+        
+        if self.draft_state["my_picks"]:
+            context += f"Your picks: {', '.join(self.draft_state['my_picks'])}\n"
+        
+        if self.draft_state["all_picks"]:
+            recent_picks = self.draft_state["all_picks"][-5:]
+            context += f"Recent picks: {', '.join(recent_picks)}\n"
+        
+        return context
+    
+    def reset_draft(self):
+        """Reset the draft state for a new draft."""
+        self.draft_state = {
+            "my_picks": [],
+            "all_picks": [],
+            "round": 1,
+            "pick_number": 5,
+            "league_size": 12,
+            "roster_needs": {
+                "QB": 1, "RB": 2, "WR": 2, "TE": 1, "FLEX": 1
+            },
+            "conversation_history": []
+        }
+
+
+# Simple test function
+def test_agent():
+    """Test the fantasy draft agent."""
+    agent = FantasyDraftAgent()
+    
+    # Test basic question
+    response = agent.run("What are the top 3 RBs available?")
+    print("Agent:", response)
+    print("\n" + "="*50 + "\n")
+    
+    # Test multi-turn conversation
+    response = agent.run("I have the 5th pick. The first 4 picks were McCaffrey, Jefferson, Lamb, and Hill. What should I do?")
+    print("Agent:", response)
+    print("\n" + "="*50 + "\n")
+    
+    # Follow-up that should remember context
+    response = agent.run("What about taking a WR instead?")
+    print("Agent:", response)
+
+
+if __name__ == "__main__":
+    test_agent()

core/constants.py

@@ -0,0 +1,66 @@
+"""
+Constants for the Fantasy Draft A2A 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 = 30.0
+
+# Comment configuration
+MAX_COMMENTS_PER_PICK = 2
+
+# Natural rivalry pairs for prioritizing comments
+RIVAL_PAIRS = {
+    1: 3,      # Zero RB vs Robust RB - natural enemies!
+    3: 1,      # Robust RB vs Zero RB
+    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": ["🤓", "💻", "🤖", "📉"],
+    },
+] 

core/data.py

@@ -0,0 +1,102 @@
+"""
+Static player data for Fantasy Draft Agent MVP.
+Hardcoded top 50 fantasy football players with basic stats.
+"""
+
+# Top players by position with their Average Draft Position (ADP) and 2023 stats
+TOP_PLAYERS = {
+    # Top Running Backs
+    "Christian McCaffrey": {"pos": "RB", "adp": 1.2, "tier": 1, "ppg_2023": 22.1, "team": "SF"},
+    "Austin Ekeler": {"pos": "RB", "adp": 4.5, "tier": 1, "ppg_2023": 18.7, "team": "LAC"},
+    "Bijan Robinson": {"pos": "RB", "adp": 3.8, "tier": 1, "ppg_2023": 15.2, "team": "ATL"},
+    "Saquon Barkley": {"pos": "RB", "adp": 5.2, "tier": 1, "ppg_2023": 17.3, "team": "NYG"},
+    "Tony Pollard": {"pos": "RB", "adp": 8.1, "tier": 2, "ppg_2023": 14.8, "team": "DAL"},
+    "Jonathan Taylor": {"pos": "RB", "adp": 6.7, "tier": 2, "ppg_2023": 13.5, "team": "IND"},
+    "Derrick Henry": {"pos": "RB", "adp": 11.3, "tier": 2, "ppg_2023": 13.9, "team": "TEN"},
+    "Nick Chubb": {"pos": "RB", "adp": 9.5, "tier": 2, "ppg_2023": 16.8, "team": "CLE"},
+    "Josh Jacobs": {"pos": "RB", "adp": 10.2, "tier": 2, "ppg_2023": 15.7, "team": "LV"},
+    "Breece Hall": {"pos": "RB", "adp": 7.8, "tier": 2, "ppg_2023": 14.2, "team": "NYJ"},
+    
+    # Top Wide Receivers
+    "Tyreek Hill": {"pos": "WR", "adp": 3.1, "tier": 1, "ppg_2023": 20.2, "team": "MIA"},
+    "CeeDee Lamb": {"pos": "WR", "adp": 2.5, "tier": 1, "ppg_2023": 19.8, "team": "DAL"},
+    "Justin Jefferson": {"pos": "WR", "adp": 1.8, "tier": 1, "ppg_2023": 21.5, "team": "MIN"},
+    "Ja'Marr Chase": {"pos": "WR", "adp": 4.2, "tier": 1, "ppg_2023": 18.9, "team": "CIN"},
+    "A.J. Brown": {"pos": "WR", "adp": 6.3, "tier": 1, "ppg_2023": 17.6, "team": "PHI"},
+    "Stefon Diggs": {"pos": "WR", "adp": 7.1, "tier": 1, "ppg_2023": 17.2, "team": "BUF"},
+    "Amon-Ra St. Brown": {"pos": "WR", "adp": 9.8, "tier": 2, "ppg_2023": 16.4, "team": "DET"},
+    "Davante Adams": {"pos": "WR", "adp": 8.9, "tier": 2, "ppg_2023": 16.8, "team": "LV"},
+    "Chris Olave": {"pos": "WR", "adp": 14.3, "tier": 2, "ppg_2023": 14.1, "team": "NO"},
+    "DK Metcalf": {"pos": "WR", "adp": 15.7, "tier": 2, "ppg_2023": 13.8, "team": "SEA"},
+    "Mike Evans": {"pos": "WR", "adp": 16.2, "tier": 2, "ppg_2023": 15.3, "team": "TB"},
+    "Calvin Ridley": {"pos": "WR", "adp": 18.5, "tier": 3, "ppg_2023": 12.1, "team": "JAX"},
+    
+    # Top Quarterbacks
+    "Josh Allen": {"pos": "QB", "adp": 24.3, "tier": 1, "ppg_2023": 24.6, "team": "BUF"},
+    "Patrick Mahomes": {"pos": "QB", "adp": 22.1, "tier": 1, "ppg_2023": 25.8, "team": "KC"},
+    "Jalen Hurts": {"pos": "QB", "adp": 19.8, "tier": 1, "ppg_2023": 26.4, "team": "PHI"},
+    "Lamar Jackson": {"pos": "QB", "adp": 31.5, "tier": 2, "ppg_2023": 21.3, "team": "BAL"},
+    "Dak Prescott": {"pos": "QB", "adp": 45.7, "tier": 2, "ppg_2023": 20.1, "team": "DAL"},
+    "Joe Burrow": {"pos": "QB", "adp": 38.2, "tier": 2, "ppg_2023": 19.8, "team": "CIN"},
+    "Justin Herbert": {"pos": "QB", "adp": 42.3, "tier": 2, "ppg_2023": 19.2, "team": "LAC"},
+    
+    # Top Tight Ends
+    "Travis Kelce": {"pos": "TE", "adp": 12.4, "tier": 1, "ppg_2023": 16.4, "team": "KC"},
+    "Mark Andrews": {"pos": "TE", "adp": 25.6, "tier": 1, "ppg_2023": 13.2, "team": "BAL"},
+    "T.J. Hockenson": {"pos": "TE", "adp": 34.8, "tier": 2, "ppg_2023": 11.8, "team": "MIN"},
+    "George Kittle": {"pos": "TE", "adp": 41.2, "tier": 2, "ppg_2023": 10.9, "team": "SF"},
+    "Darren Waller": {"pos": "TE", "adp": 48.5, "tier": 2, "ppg_2023": 9.7, "team": "NYG"},
+    
+    # Additional depth players for rounds 5-10
+    "Jahmyr Gibbs": {"pos": "RB", "adp": 21.3, "tier": 3, "ppg_2023": 11.2, "team": "DET"},
+    "Rhamondre Stevenson": {"pos": "RB", "adp": 23.7, "tier": 3, "ppg_2023": 12.1, "team": "NE"},
+    "Kenneth Walker": {"pos": "RB", "adp": 28.4, "tier": 3, "ppg_2023": 11.8, "team": "SEA"},
+    "DeAndre Hopkins": {"pos": "WR", "adp": 52.1, "tier": 3, "ppg_2023": 10.2, "team": "TEN"},
+    "Keenan Allen": {"pos": "WR", "adp": 29.8, "tier": 3, "ppg_2023": 13.1, "team": "LAC"},
+    "Amari Cooper": {"pos": "WR", "adp": 37.2, "tier": 3, "ppg_2023": 12.7, "team": "CLE"},
+    "Terry McLaurin": {"pos": "WR", "adp": 44.6, "tier": 3, "ppg_2023": 11.9, "team": "WAS"},
+    "DJ Moore": {"pos": "WR", "adp": 35.9, "tier": 3, "ppg_2023": 11.4, "team": "CHI"},
+    "Deshaun Watson": {"pos": "QB", "adp": 68.3, "tier": 3, "ppg_2023": 16.7, "team": "CLE"},
+    "Trevor Lawrence": {"pos": "QB", "adp": 71.2, "tier": 3, "ppg_2023": 17.2, "team": "JAX"},
+    
+    # Sleepers and late-round targets
+    "Jordan Addison": {"pos": "WR", "adp": 85.3, "tier": 4, "ppg_2023": 8.2, "team": "MIN"},
+    "Jahan Dotson": {"pos": "WR", "adp": 92.7, "tier": 4, "ppg_2023": 7.8, "team": "WAS"},
+    "Khalil Herbert": {"pos": "RB", "adp": 89.1, "tier": 4, "ppg_2023": 8.9, "team": "CHI"},
+    "Zay Flowers": {"pos": "WR", "adp": 76.4, "tier": 4, "ppg_2023": 9.1, "team": "BAL"},
+}
+
+
+def get_player_info(player_name: str) -> dict:
+    """Get player information by name."""
+    return TOP_PLAYERS.get(player_name, {})
+
+
+def get_players_by_position(position: str) -> dict:
+    """Get all players at a specific position."""
+    return {name: info for name, info in TOP_PLAYERS.items() if info["pos"] == position}
+
+
+def get_players_by_tier(tier: int) -> dict:
+    """Get all players in a specific tier."""
+    return {name: info for name, info in TOP_PLAYERS.items() if info["tier"] == tier}
+
+
+def get_available_players(drafted_players: list) -> dict:
+    """Get all players not yet drafted."""
+    return {name: info for name, info in TOP_PLAYERS.items() if name not in drafted_players}
+
+
+def get_best_available(drafted_players: list, position: str = None) -> tuple:
+    """Get the best available player overall or by position."""
+    available = get_available_players(drafted_players)
+    
+    if position:
+        available = {name: info for name, info in available.items() if info["pos"] == position}
+    
+    if not available:
+        return None, None
+    
+    # Sort by ADP (lower is better)
+    best = min(available.items(), key=lambda x: x[1]["adp"])
+    return best

core/dynamic_a2a_manager.py

@@ -0,0 +1,350 @@
+"""
+Dynamic A2A Manager with multi-user support through dynamic port allocation.
+"""
+
+import asyncio
+import socket
+import hashlib
+import os
+from typing import List, Dict, Optional, Tuple
+from pydantic import BaseModel
+from any_agent import AgentConfig, AnyAgent
+from any_agent.serving import A2AServingConfig
+from any_agent.tools import a2a_tool_async
+from core.constants import (
+    AGENT_CONFIGS,
+    AGENT_START_DELAY,
+    AGENT_STARTUP_WAIT,
+    DEFAULT_TIMEOUT,
+    MAX_COMMENTS_PER_PICK,
+    RIVAL_PAIRS
+)
+from core.data import TOP_PLAYERS
+from core.a2a_helpers import (
+    parse_a2a_response,
+    extract_task_id,
+    format_available_players
+)
+
+
+# A2A Output model (same as in app_enhanced.py)
+class A2AOutput(BaseModel):
+    """Combined output type for A2A agents."""
+    type: str  # "pick" or "comment"
+    # Pick fields
+    player_name: Optional[str] = None
+    reasoning: Optional[str] = None
+    trash_talk: Optional[str] = None
+    # Comment fields
+    should_comment: Optional[bool] = None
+    comment: Optional[str] = None
+
+
+class DynamicA2AAgentManager:
+    """A2A Agent Manager with dynamic port allocation for multi-user support."""
+    
+    # Class-level tracking of used ports
+    _used_ports = set()
+    _port_lock = asyncio.Lock()
+    
+    def __init__(self, session_id: str = None, max_comments_per_pick=MAX_COMMENTS_PER_PICK):
+        self.session_id = session_id or self._generate_session_id()
+        self.agents = {}
+        self.agent_tools = {}
+        self.serve_tasks = []
+        self.is_running = False
+        self.task_ids = {}
+        self.max_comments_per_pick = max_comments_per_pick
+        self.allocated_ports = []
+        
+    def _generate_session_id(self) -> str:
+        """Generate a unique session ID."""
+        import time
+        import random
+        return hashlib.md5(f"{time.time()}{random.random()}".encode()).hexdigest()[:8]
+    
+    async def _find_available_ports(self, count: int = 5, start: int = 5000, end: int = 9000) -> List[int]:
+        """Find available consecutive ports for agents."""
+        async with self._port_lock:
+            # On HF Spaces, try different port ranges
+            port_ranges = [(8000, 9000), (5000, 6000), (7000, 8000), (9000, 10000)] if os.getenv("SPACE_ID") else [(start, end)]
+            
+            for range_start, range_end in port_ranges:
+                # Try to find a consecutive range
+                for base_port in range(range_start, range_end - count, 10):
+                    ports = list(range(base_port, base_port + count))
+                    
+                    # Check if any port in range is already used
+                    if any(p in self._used_ports for p in ports):
+                        continue
+                    
+                    # Check if ports are actually available on the system
+                    if await self._check_ports_available(ports):
+                        # Reserve these ports
+                        self._used_ports.update(ports)
+                        self.allocated_ports = ports
+                        print(f"✅ Found available ports in range {range_start}-{range_end}: {ports}")
+                        return ports
+            
+            raise RuntimeError(f"Could not find {count} available consecutive ports in any range")
+    
+    async def _check_ports_available(self, ports: List[int]) -> bool:
+        """Check if a list of ports is available on the system."""
+        for port in ports:
+            try:
+                # Try to bind to the port
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                
+                # On HF Spaces, try different bind addresses
+                bind_addresses = ['localhost', '127.0.0.1', '0.0.0.0']
+                bound = False
+                
+                for addr in bind_addresses:
+                    try:
+                        sock.bind((addr, port))
+                        bound = True
+                        break
+                    except OSError:
+                        continue
+                
+                sock.close()
+                if not bound:
+                    print(f"Port {port} not available on any interface")
+                    return False
+            except Exception as e:
+                print(f"Error checking port {port}: {e}")
+                return False
+        return True
+    
+    async def _release_ports(self):
+        """Release allocated ports when done."""
+        async with self._port_lock:
+            self._used_ports.difference_update(self.allocated_ports)
+            self.allocated_ports = []
+    
+    def _create_dynamic_agent_configs(self, ports: List[int]) -> List[Dict]:
+        """Create agent configs with dynamic ports."""
+        configs = []
+        # Only use teams 1, 2, 3, 5, 6 (skip team 4 which is the user)
+        agent_teams = [1, 2, 3, 5, 6]
+        
+        for i, team_num in enumerate(agent_teams):
+            # Find the original config for this team
+            original_config = next(c for c in AGENT_CONFIGS if c['team_num'] == team_num)
+            
+            # Create a copy with the new port
+            config = original_config.copy()
+            config['port'] = ports[i]
+            config['session_id'] = self.session_id  # Add session tracking
+            configs.append(config)
+            
+        return configs
+    
+    async def start_agents(self):
+        """Start all A2A agent servers with dynamic ports."""
+        if self.is_running:
+            return
+            
+        print(f"🚀 Starting A2A agents for session {self.session_id}...")
+        
+        try:
+            # Find available ports
+            ports = await self._find_available_ports()
+            print(f"📍 Allocated ports: {ports}")
+            
+            # Create configs with dynamic ports
+            agent_configs = self._create_dynamic_agent_configs(ports)
+            
+            # Create and serve all agents
+            for config in agent_configs:
+                try:
+                    # Create agent (same as before)
+                    agent = await AnyAgent.create_async(
+                        "tinyagent",
+                        AgentConfig(
+                            name=f"team_{config['team_num']}_agent_{self.session_id}",
+                            model_id="gpt-4o-mini",
+                            description=f"{config['team_name']} - {config['strategy']} fantasy football team manager",
+                            instructions=f"""You are {config['team_name']}, a fantasy football manager with {config['strategy']} strategy.
+
+For picks: Return A2AOutput with type="pick", player_name, reasoning, and optional trash_talk.
+For comments: Return A2AOutput with type="comment", should_comment (true/false), and comment.
+
+PERSONALITY REQUIREMENTS:
+- Use LOTS of emojis that match your strategy! 🔥
+- Be EXTREMELY dramatic and over-the-top! 
+- Take your philosophy to the EXTREME!
+- MOCK other strategies viciously!
+- Use CAPS for emphasis!
+- Make BOLD predictions!
+- Reference previous interactions with SPITE!
+- Build INTENSE rivalries!
+- Your responses should be ENTERTAINING and MEMORABLE!
+
+Your EXTREME philosophy: {config['philosophy']}
+
+BE LOUD! BE PROUD! BE UNFORGETTABLE! 🎯""",
+                            output_type=A2AOutput,
+                        )
+                    )
+                    
+                    self.agents[config['team_num']] = agent
+                    
+                    # Serve agent on dynamic port
+                    # On HF Spaces, we might need to bind to 0.0.0.0
+                    host = "0.0.0.0" if os.getenv("SPACE_ID") else "localhost"
+                    
+                    serve_task = asyncio.create_task(
+                        agent.serve_async(
+                            A2AServingConfig(
+                                port=config['port'],
+                                host=host,
+                                task_timeout_minutes=30,
+                            )
+                        )
+                    )
+                    self.serve_tasks.append(serve_task)
+                    print(f"✅ Started {config['team_name']} on port {config['port']} (session: {self.session_id})")
+                    
+                    await asyncio.sleep(AGENT_STARTUP_WAIT)
+                    
+                except Exception as e:
+                    print(f"❌ Failed to create/serve {config['team_name']}: {e}")
+            
+            # Wait for servers to start
+            await asyncio.sleep(AGENT_START_DELAY)
+            
+            # Create tools for each agent
+            for config in agent_configs:
+                team_num = config['team_num']
+                if team_num not in self.agents:
+                    continue
+                    
+                try:
+                    # On HF Spaces, we might need to use 127.0.0.1 for internal communication
+                    host = "127.0.0.1" if os.getenv("SPACE_ID") else "localhost"
+                    tool_url = f"http://{host}:{config['port']}"
+                    self.agent_tools[team_num] = await a2a_tool_async(
+                        tool_url,
+                        http_kwargs={"timeout": DEFAULT_TIMEOUT}
+                    )
+                    print(f"✅ Created A2A tool for Team {team_num} at {tool_url}")
+                    
+                except Exception as e:
+                    print(f"❌ Failed to create tool for Team {team_num}: {e}")
+            
+            self.is_running = len(self.agent_tools) > 0
+            if self.is_running:
+                print(f"✅ A2A agents ready for session {self.session_id}! ({len(self.agent_tools)} agents active)")
+            else:
+                print(f"❌ Failed to start any A2A agents for session {self.session_id}")
+                
+        except Exception as e:
+            print(f"❌ Failed to allocate ports or start agents: {e}")
+            await self._release_ports()
+            raise
+    
+    async def stop_agents(self):
+        """Stop all A2A agent servers and release ports."""
+        if not self.is_running:
+            return
+            
+        print(f"🛑 Stopping A2A agents for session {self.session_id}...")
+        
+        # Cancel all serve tasks
+        for task in self.serve_tasks:
+            task.cancel()
+        
+        await asyncio.gather(*self.serve_tasks, return_exceptions=True)
+        
+        # Clear agent data
+        self.agents.clear()
+        self.agent_tools.clear()
+        self.serve_tasks.clear()
+        self.is_running = False
+        
+        # Release the ports
+        await self._release_ports()
+        
+        print(f"✅ A2A agents stopped and ports released for session {self.session_id}")
+    
+    async def get_pick(self, team_num: int, available_players: List[str], 
+                      previous_picks: List[str], round_num: int = 1) -> Optional[A2AOutput]:
+        """Get a pick from an A2A agent."""
+        if team_num not in self.agent_tools:
+            return None
+        
+        # Build the prompt with essential info
+        available_str = format_available_players(available_players, TOP_PLAYERS)
+        
+        # Simple prompt - let task_id maintain conversation history
+        prompt = f"""🚨 IT'S YOUR TIME TO DOMINATE! 🚨 (Round {round_num})
+        
+Available top players: {', '.join(available_str)}
+Your roster so far: {', '.join(previous_picks) if previous_picks else 'None yet'}
+
+Make your pick and DESTROY the competition! 💪
+Output an A2AOutput with type="pick", player_name, reasoning (with emojis!), and SAVAGE trash_talk!
+Remember your ENEMIES and CRUSH their dreams! Use emojis to emphasize your DOMINANCE! 🔥"""
+        
+        try:
+            # Use task_id if we have one for this agent
+            task_id = self.task_ids.get(team_num)
+            result = await self.agent_tools[team_num](prompt, task_id=task_id)
+            
+            # Extract and store task_id
+            task_id = extract_task_id(result)
+            if task_id:
+                self.task_ids[team_num] = task_id
+            
+            # Parse the response
+            output = parse_a2a_response(result, A2AOutput)
+            return output
+                
+        except Exception as e:
+            print(f"Error getting pick from Team {team_num}: {e}")
+            return None
+    
+    async def get_comment(self, commenting_team: int, picking_team: int,
+                         player_picked: str, round_num: int = 1) -> Optional[str]:
+        """Get a comment from an A2A agent about a pick."""
+        if commenting_team not in self.agent_tools:
+            return None
+        
+        # Simple prompt - let task_id maintain conversation history  
+        prompt = f"""🎯 Team {picking_team} just picked {player_picked}! 
+
+This is your chance to DESTROY them with your superior knowledge! 💥
+Should you UNLEASH your wisdom? Output an A2AOutput with type="comment", should_comment (true/false), and a DEVASTATING comment with emojis!
+If they're your RIVAL, make it PERSONAL! If they made a BAD pick, ROAST THEM! 🔥
+Use emojis to make your point UNFORGETTABLE! 😈"""
+        
+        try:
+            # Use task_id for continuity
+            task_id = self.task_ids.get(commenting_team)
+            result = await self.agent_tools[commenting_team](prompt, task_id=task_id)
+            
+            # Extract and store task_id
+            task_id = extract_task_id(result)
+            if task_id:
+                self.task_ids[commenting_team] = task_id
+            
+            # Parse the response
+            output = parse_a2a_response(result, A2AOutput)
+            
+            if output and hasattr(output, 'should_comment') and output.should_comment and output.comment:
+                return output.comment
+        except Exception as e:
+            print(f"Error getting comment from Team {commenting_team}: {e}")
+        
+        return None
+
+
+# Cleanup function for session end
+async def cleanup_session(manager: DynamicA2AAgentManager):
+    """Clean up resources when a session ends."""
+    try:
+        await manager.stop_agents()
+    except Exception as e:
+        print(f"Error during cleanup for session {manager.session_id}: {e}") 

core/real_a2a_draft.py

@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""
+Real A2A Implementation for Fantasy Draft Agents
+This shows how to properly implement Agent-to-Agent communication
+using the any-agent framework's A2A protocol.
+"""
+
+import asyncio
+from typing import Dict, List, Optional
+from pydantic import BaseModel
+from any_agent import AgentConfig, AnyAgent
+from any_agent.serving import A2AServingConfig
+from any_agent.tools import a2a_tool_async
+from any_agent.serving.config import default_history_formatter
+import httpx
+from a2a.client import A2AClient
+from a2a.types import MessageSendParams, SendMessageRequest
+from uuid import uuid4
+
+
+# Define structured outputs for agents
+class DraftPick(BaseModel):
+    player_name: str
+    position: str
+    reasoning: str
+    confidence: float
+
+
+class DraftComment(BaseModel):
+    is_commenting: bool
+    comment: Optional[str] = None
+    target_team: Optional[str] = None
+    sentiment: Optional[str] = None  # "positive", "negative", "neutral"
+
+
+class DraftResponse(BaseModel):
+    should_respond: bool
+    response: Optional[str] = None
+
+
+# Base A2A Draft Agent
+class A2ADraftAgent:
+    """Base class for A2A-enabled draft agents."""
+    
+    def __init__(self, team_name: str, strategy: str, port: int):
+        self.team_name = team_name
+        self.strategy = strategy
+        self.port = port
+        self.picks = []
+        self.agent = None
+        self.serving_task = None
+        
+    async def initialize(self):
+        """Initialize the agent with A2A capabilities."""
+        self.agent = await AnyAgent.create_async(
+            "openai",  # Using OpenAI for better structured outputs
+            AgentConfig(
+                name=f"{self.team_name.lower().replace(' ', '_')}_agent",
+                model_id="gpt-4o-mini",
+                instructions=self._get_instructions(),
+                description=f"{self.team_name} - {self.strategy} draft strategy",
+                output_type=DraftPick | DraftComment | DraftResponse,
+                agent_args={"temperature": 0.8}  # More personality
+            )
+        )
+    
+    def _get_instructions(self) -> str:
+        """Get agent-specific instructions."""
+        return f"""You are {self.team_name}, a fantasy football team manager.
+        
+Your draft strategy: {self.strategy}
+Your personality: Competitive, confident in your strategy, willing to trash talk.
+
+When making picks:
+- Output a DraftPick with your selection and reasoning
+- Be confident about your strategy
+- Show personality in your reasoning
+
+When asked to comment on another team's pick:
+- Output a DraftComment
+- Set is_commenting=true if you want to comment (about 50% of the time)
+- Be competitive - trash talk is encouraged!
+- Target the team that made the pick
+- Express strong opinions about their choice
+
+When asked to respond to a comment:
+- Output a DraftResponse
+- Set should_respond=true if you want to respond (about 70% of the time)
+- Defend your choices aggressively
+- Fire back at critics
+
+Remember: This is a competition. Show confidence and personality!"""
+    
+    async def serve(self):
+        """Serve this agent via A2A protocol."""
+        self.serving_task = asyncio.create_task(
+            self.agent.serve_async(
+                A2AServingConfig(
+                    port=self.port,
+                    task_timeout_minutes=60,  # 1 hour draft session
+                    history_formatter=default_history_formatter,
+                    endpoint=f"/{self.team_name.lower().replace(' ', '_')}"
+                )
+            )
+        )
+        print(f"🚀 {self.team_name} agent serving on port {self.port}")
+    
+    async def shutdown(self):
+        """Shutdown the agent server."""
+        if self.serving_task:
+            self.serving_task.cancel()
+            try:
+                await self.serving_task
+            except asyncio.CancelledError:
+                pass
+
+
+# Specific Strategy Implementations
+class ZeroRBA2AAgent(A2ADraftAgent):
+    """Zero RB strategy agent with A2A."""
+    
+    def __init__(self, port: int):
+        super().__init__("Team 1", "Zero RB Strategy", port)
+    
+    def _get_instructions(self) -> str:
+        base = super()._get_instructions()
+        return base + """
+
+Specific to your Zero RB strategy:
+- ALWAYS prioritize WRs in early rounds
+- Mock teams that take RBs early
+- Talk about injury risk and RB volatility
+- Get defensive when criticized about ignoring RBs
+- Your catchphrase: "RBs get injured, WRs win championships!"
+"""
+
+
+class RobustRBA2AAgent(A2ADraftAgent):
+    """Robust RB strategy agent with A2A."""
+    
+    def __init__(self, port: int):
+        super().__init__("Team 3", "Robust RB Strategy", port)
+    
+    def _get_instructions(self) -> str:
+        base = super()._get_instructions()
+        return base + """
+
+Specific to your Robust RB strategy:
+- ALWAYS take RBs in rounds 1-2
+- Mock "fancy" WR strategies as risky
+- Emphasize the importance of a strong RB foundation
+- Be old-school and traditional in your approach
+- Your catchphrase: "Championships are won in the trenches with RBs!"
+"""
+
+
+# Multi-Agent Draft Coordinator
+class A2ADraftCoordinator:
+    """Coordinates a draft using real A2A communication."""
+    
+    def __init__(self):
+        self.agents: Dict[int, A2ADraftAgent] = {}
+        self.draft_board: Dict[int, List[str]] = {}
+        self.available_players = []  # Would be populated from data
+        self.task_ids: Dict[str, str] = {}  # Track task IDs for each agent
+        
+    async def setup_agents(self):
+        """Initialize and serve all draft agents."""
+        # Create agents with different strategies
+        self.agents[1] = ZeroRBA2AAgent(port=5001)
+        self.agents[2] = A2ADraftAgent("Team 2", "Best Player Available", port=5002)
+        self.agents[3] = RobustRBA2AAgent(port=5003)
+        self.agents[5] = A2ADraftAgent("Team 5", "Upside Hunter", port=5005)
+        
+        # Initialize and serve all agents
+        for agent in self.agents.values():
+            await agent.initialize()
+            await agent.serve()
+        
+        # Wait for servers to start
+        await asyncio.sleep(2)
+        
+        print("✅ All agents initialized and serving via A2A")
+    
+    async def execute_draft_turn(self, team_num: int, round_num: int) -> Dict:
+        """Execute a draft turn using A2A communication."""
+        if team_num not in self.agents:
+            return {"error": "Team not found"}
+        
+        agent = self.agents[team_num]
+        results = {"pick": None, "comments": [], "responses": []}
+        
+        async with httpx.AsyncClient() as client:
+            # 1. Get the agent's pick via A2A
+            try:
+                # Create A2A client for this agent
+                a2a_client = await A2AClient.get_client_from_agent_card_url(
+                    client, f"http://localhost:{agent.port}"
+                )
+                
+                # Build pick request
+                pick_prompt = f"""Round {round_num} - Make your pick!
+                
+Available top players: {', '.join(self.available_players[:10])}
+Your previous picks: {', '.join(agent.picks)}
+
+Output a DraftPick with your selection."""
+                
+                # Send pick request
+                pick_request = SendMessageRequest(
+                    id=str(uuid4()),
+                    params=MessageSendParams(
+                        message={
+                            "role": "user",
+                            "parts": [{"kind": "text", "text": pick_prompt}],
+                            "messageId": str(uuid4()),
+                            "contextId": f"draft_session_{team_num}"
+                        }
+                    )
+                )
+                
+                # Get pick response
+                pick_response = await a2a_client.send_message(pick_request)
+                
+                # Extract task ID for this agent if first interaction
+                if team_num not in self.task_ids:
+                    self.task_ids[team_num] = pick_response.root.result.id
+                
+                results["pick"] = pick_response.root.result
+                
+                # 2. Get comments from other agents
+                for other_team, other_agent in self.agents.items():
+                    if other_team == team_num:
+                        continue
+                    
+                    # Create client for other agent
+                    other_client = await A2AClient.get_client_from_agent_card_url(
+                        client, f"http://localhost:{other_agent.port}"
+                    )
+                    
+                    # Ask for comment
+                    comment_prompt = f"""{agent.team_name} just picked {results['pick']['player_name']} in round {round_num}.
+
+Should you comment on this pick? Output a DraftComment."""
+                    
+                    comment_request = SendMessageRequest(
+                        id=str(uuid4()),
+                        params=MessageSendParams(
+                            message={
+                                "role": "user",
+                                "parts": [{"kind": "text", "text": comment_prompt}],
+                                "messageId": str(uuid4()),
+                                "contextId": f"draft_session_{other_team}",
+                                "taskId": self.task_ids.get(other_team)  # Continue conversation
+                            }
+                        }
+                    )
+                    
+                    comment_response = await other_client.send_message(comment_request)
+                    
+                    # Update task ID
+                    if other_team not in self.task_ids:
+                        self.task_ids[other_team] = comment_response.root.result.id
+                    
+                    # Add comment if agent chose to comment
+                    if comment_response.root.result.get("is_commenting"):
+                        results["comments"].append({
+                            "from": other_agent.team_name,
+                            "comment": comment_response.root.result.get("comment")
+                        })
+                
+                # 3. Get responses to comments
+                for comment in results["comments"]:
+                    response_prompt = f"""{comment['from']} said about your pick: "{comment['comment']}"
+
+Do you want to respond? Output a DraftResponse."""
+                    
+                    response_request = SendMessageRequest(
+                        id=str(uuid4()),
+                        params=MessageSendParams(
+                            message={
+                                "role": "user",
+                                "parts": [{"kind": "text", "text": response_prompt}],
+                                "messageId": str(uuid4()),
+                                "contextId": f"draft_session_{team_num}",
+                                "taskId": self.task_ids[team_num]  # Continue conversation
+                            }
+                        )
+                    )
+                    
+                    response_response = await a2a_client.send_message(response_request)
+                    
+                    if response_response.root.result.get("should_respond"):
+                        results["responses"].append({
+                            "to": comment['from'],
+                            "response": response_response.root.result.get("response")
+                        })
+                
+            except Exception as e:
+                results["error"] = str(e)
+        
+        return results
+    
+    async def run_mock_draft(self):
+        """Run a complete mock draft with A2A communication."""
+        await self.setup_agents()
+        
+        # Simulate 3 rounds
+        for round_num in range(1, 4):
+            print(f"\n🏈 ROUND {round_num}")
+            
+            # Snake draft order
+            if round_num % 2 == 1:
+                order = [1, 2, 3, 4, 5, 6]  # 4 is human, 6 is another AI
+            else:
+                order = [6, 5, 4, 3, 2, 1]
+            
+            for team in order:
+                if team == 4:
+                    print("👤 Your turn! (simulated)")
+                    continue
+                
+                if team in self.agents:
+                    results = await self.execute_draft_turn(team, round_num)
+                    
+                    # Display results
+                    if "pick" in results and results["pick"]:
+                        pick = results["pick"]
+                        print(f"\n📋 {self.agents[team].team_name} selects: {pick.get('player_name')}")
+                        print(f"   Reasoning: {pick.get('reasoning')}")
+                    
+                    # Show comments
+                    for comment in results.get("comments", []):
+                        print(f"\n💬 {comment['from']}: {comment['comment']}")
+                    
+                    # Show responses
+                    for response in results.get("responses", []):
+                        print(f"   ↩️  {self.agents[team].team_name}: {response['response']}")
+        
+        # Shutdown all agents
+        for agent in self.agents.values():
+            await agent.shutdown()
+        
+        print("\n✅ Draft complete! All agents shut down.")
+
+
+# Example usage
+async def main():
+    """Run the A2A draft demo."""
+    coordinator = A2ADraftCoordinator()
+    
+    # In a real implementation, populate available players
+    coordinator.available_players = [
+        "Christian McCaffrey", "Tyreek Hill", "Justin Jefferson",
+        "CeeDee Lamb", "Austin Ekeler", "Bijan Robinson",
+        "Ja'Marr Chase", "Cooper Kupp", "Stefon Diggs"
+    ]
+    
+    await coordinator.run_mock_draft()
+
+
+if __name__ == "__main__":
+    # Run the async main function
+    asyncio.run(main()) 

core/scenarios.py

@@ -0,0 +1,260 @@
+"""
+Pre-crafted demo scenarios for Fantasy Draft Agent.
+Each scenario showcases different multi-turn conversation capabilities.
+"""
+
+from .agent import FantasyDraftAgent
+from typing import List, Dict
+
+
+# Define our demo scenarios
+SCENARIOS = {
+    "scenario_1": {
+        "name": "The Opening Pick",
+        "description": "User has 5th pick, top 4 RBs are gone. Shows strategy adaptation.",
+        "setup": {
+            "pick_number": 5,
+            "drafted_players": ["Christian McCaffrey", "Justin Jefferson", "CeeDee Lamb", "Tyreek Hill"]
+        },
+        "conversation": [
+            {
+                "user": "I have the 5th pick and the top 4 guys are gone - McCaffrey, Jefferson, Lamb, and Hill. What should I do?",
+                "showcases": "Initial situation assessment"
+            },
+            {
+                "user": "I'm worried about Bijan being a rookie. What about Ekeler instead?",
+                "showcases": "Addressing specific concerns"
+            },
+            {
+                "user": "Good point about the Chargers offense. Who would you pair with him in round 2?",
+                "showcases": "Building on previous context"
+            }
+        ]
+    },
+    
+    "scenario_2": {
+        "name": "The Position Run", 
+        "description": "Round 3, all QBs being drafted. Shows patience and value finding.",
+        "setup": {
+            "pick_number": 8,
+            "round": 3,
+            "my_picks": ["Ja'Marr Chase", "Nick Chubb"],
+            "recent_picks": ["Josh Allen", "Patrick Mahomes", "Jalen Hurts", "Lamar Jackson"]
+        },
+        "conversation": [
+            {
+                "user": "Everyone is taking QBs! Allen, Mahomes, Hurts, and Lamar just went. Should I panic and grab one?",
+                "showcases": "Handling draft runs"
+            },
+            {
+                "user": "You're right about value. Who's the best player available regardless of position?",
+                "showcases": "Pivoting strategy based on advice"
+            },
+            {
+                "user": "I took A.J. Brown. When should I actually target a QB then?",
+                "showcases": "Long-term planning with context"
+            },
+            {
+                "user": "Makes sense. What late-round QBs pair well with the Eagles offense?",
+                "showcases": "Advanced strategy (stacking)"
+            }
+        ]
+    },
+    
+    "scenario_3": {
+        "name": "The Sleeper Question",
+        "description": "Round 10, looking for upside. Shows deep knowledge + context.",
+        "setup": {
+            "pick_number": 3,
+            "round": 10,
+            "my_picks": ["Justin Jefferson", "Tony Pollard", "Mark Andrews", "Chris Olave", 
+                         "Amari Cooper", "Dak Prescott", "Kenneth Walker", "Terry McLaurin", "George Kittle"]
+        },
+        "conversation": [
+            {
+                "user": "Round 10 now. I need some upside guys. Who are your favorite sleepers?",
+                "showcases": "Late-round strategy shift"
+            },
+            {
+                "user": "I like the Vikings connection with Jefferson. Tell me more about Addison.",
+                "showcases": "Building on roster construction"
+            },
+            {
+                "user": "Sold! I grabbed him. Now I need a backup RB with upside.",
+                "showcases": "Continuing roster building"
+            }
+        ]
+    },
+    
+    "scenario_4": {
+        "name": "The Stack Builder",
+        "description": "Has Mahomes, wants receivers. Shows correlation strategy.",
+        "setup": {
+            "pick_number": 10,
+            "round": 5,
+            "my_picks": ["Saquon Barkley", "Davante Adams", "Patrick Mahomes", "Breece Hall"]
+        },
+        "conversation": [
+            {
+                "user": "I've got Mahomes. Should I try to get Kelce or a Chiefs WR to stack?",
+                "showcases": "Stack strategy introduction"
+            },
+            {
+                "user": "Kelce went right before my pick! What Chiefs WRs are worth targeting?",
+                "showcases": "Adapting to changing circumstances"
+            },
+            {
+                "user": "When do you think I should target one of them? This pick or wait?",
+                "showcases": "Timing decisions with context"
+            }
+        ]
+    }
+}
+
+
+class ScenarioRunner:
+    """Run and manage demo scenarios."""
+    
+    def __init__(self):
+        self.agent = FantasyDraftAgent()
+    
+    def setup_scenario(self, scenario_id: str):
+        """Set up the agent with scenario-specific state."""
+        scenario = SCENARIOS[scenario_id]
+        setup = scenario["setup"]
+        
+        # Reset agent
+        self.agent.reset_draft()
+        
+        # Apply setup
+        if "pick_number" in setup:
+            self.agent.draft_state["pick_number"] = setup["pick_number"]
+        
+        if "round" in setup:
+            self.agent.draft_state["round"] = setup["round"]
+        
+        if "drafted_players" in setup:
+            for player in setup["drafted_players"]:
+                self.agent.update_draft_state(player)
+        
+        if "my_picks" in setup:
+            self.agent.draft_state["my_picks"] = setup["my_picks"]
+            # Add to all picks
+            for pick in setup["my_picks"]:
+                if pick not in self.agent.draft_state["all_picks"]:
+                    self.agent.draft_state["all_picks"].append(pick)
+        
+        if "recent_picks" in setup:
+            for pick in setup["recent_picks"]:
+                if pick not in self.agent.draft_state["all_picks"]:
+                    self.agent.update_draft_state(pick)
+    
+    def run_scenario(self, scenario_id: str, verbose: bool = True) -> List[Dict]:
+        """Run a complete scenario and return the conversation."""
+        scenario = SCENARIOS[scenario_id]
+        self.setup_scenario(scenario_id)
+        
+        if verbose:
+            print(f"\n{'='*60}")
+            print(f"Scenario: {scenario['name']}")
+            print(f"Description: {scenario['description']}")
+            print(f"{'='*60}\n")
+        
+        conversation_log = []
+        
+        for i, turn in enumerate(scenario["conversation"], 1):
+            if verbose:
+                # Visual indicator for turn number
+                print(f"\n{'━'*60}")
+                print(f"🔄 TURN {i} - {turn['showcases']}")
+                print(f"{'━'*60}")
+                
+                # Show conversation memory state
+                if i > 1:
+                    print(f"💭 AGENT MEMORY: Remembering {len(self.agent.draft_state['conversation_history'])} previous exchanges")
+                    last_topic = self.agent.draft_state['conversation_history'][-1]['user'] if self.agent.draft_state['conversation_history'] else ""
+                    if last_topic:
+                        print(f"📌 Last discussed: '{last_topic[:50]}...'")
+                
+                print(f"\n👤 User: {turn['user']}")
+            
+            response = self.agent.run(turn["user"])
+            
+            if verbose:
+                print(f"\n🤖 Agent: {response}")
+                
+                # Highlight context references
+                context_indicators = [
+                    "you mentioned", "you said", "earlier", "before", 
+                    "as I mentioned", "like we discussed", "you asked about",
+                    "regarding your", "based on your", "given that you"
+                ]
+                
+                # Check if response references previous context
+                response_lower = response.lower()
+                context_found = any(indicator in response_lower for indicator in context_indicators)
+                
+                if context_found:
+                    print(f"\n✨ CONTEXT RETENTION: Agent referenced previous conversation!")
+                
+                print(f"\n{'-'*40}")
+            
+            conversation_log.append({
+                "turn": i,
+                "showcases": turn["showcases"],
+                "user": turn["user"],
+                "agent": response,
+                "context_retained": context_found if verbose else False
+            })
+        
+        return conversation_log
+    
+    def run_all_scenarios(self) -> Dict[str, List[Dict]]:
+        """Run all scenarios and return results."""
+        results = {}
+        
+        for scenario_id in SCENARIOS:
+            print(f"\nRunning {scenario_id}...")
+            results[scenario_id] = self.run_scenario(scenario_id)
+        
+        return results
+    
+    def export_scenario_transcript(self, scenario_id: str, conversation_log: List[Dict]) -> str:
+        """Export a scenario as a formatted transcript."""
+        scenario = SCENARIOS[scenario_id]
+        
+        transcript = f"# {scenario['name']}\n\n"
+        transcript += f"**Scenario**: {scenario['description']}\n\n"
+        
+        for turn in conversation_log:
+            transcript += f"### Turn {turn['turn']}: {turn['showcases']}\n\n"
+            transcript += f"**User**: {turn['user']}\n\n"
+            transcript += f"**Agent**: {turn['agent']}\n\n"
+            transcript += "---\n\n"
+        
+        return transcript
+
+
+def demo_scenarios():
+    """Run a demo of all scenarios."""
+    runner = ScenarioRunner()
+    
+    # Run scenario 1 as a detailed example
+    print("\n" + "="*60)
+    print("FANTASY DRAFT AGENT - DEMO SCENARIOS")
+    print("="*60)
+    
+    # Run just the first scenario in detail
+    conversation = runner.run_scenario("scenario_1", verbose=True)
+    
+    # Show how to export
+    transcript = runner.export_scenario_transcript("scenario_1", conversation)
+    print("\nExported Transcript Preview:")
+    print(transcript[:500] + "...")
+    
+    print("\n\nTo run all scenarios:")
+    print(">>> runner.run_all_scenarios()")
+
+
+if __name__ == "__main__":
+    demo_scenarios()

core/visualizer.py

@@ -0,0 +1,319 @@
+"""
+Visual components for Fantasy Draft Agent demos.
+Creates ASCII and simple text visualizations for player cards and draft boards.
+"""
+
+from typing import List, Dict
+from .data import TOP_PLAYERS, get_player_info
+
+
+def create_player_card(player_name: str) -> str:
+    """Generate ASCII player card for visualization."""
+    player = get_player_info(player_name)
+    if not player:
+        return f"Player '{player_name}' not found"
+    
+    # Create a nice ASCII card
+    card = f"""
+    ╔═══════════════════════════════╗
+    ║ {player_name:<27} ║
+    ╠═══════════════════════════════╣
+    ║ Position: {player['pos']:<18} ║
+    ║ Team:     {player['team']:<18} ║
+    ║ ADP:      {player['adp']:<18} ║
+    ║ Tier:     {player['tier']:<18} ║
+    ║ 2023 PPG: {player['ppg_2023']:<18} ║
+    ╚═══════════════════════════════╝
+    """
+    return card
+
+
+def create_comparison_card(player1: str, player2: str) -> str:
+    """Create a side-by-side comparison of two players."""
+    p1 = get_player_info(player1)
+    p2 = get_player_info(player2)
+    
+    if not p1 or not p2:
+        return "One or both players not found"
+    
+    comparison = f"""
+    ╔════════════════╦════════════════╗
+    ║ {player1[:14]:<14} ║ {player2[:14]:<14} ║
+    ╠════════════════╬════════════════╣
+    ║ {p1['pos']} - {p1['team']:<10} ║ {p2['pos']} - {p2['team']:<10} ║
+    ║ ADP: {p1['adp']:<10} ║ ADP: {p2['adp']:<10} ║
+    ║ Tier: {p1['tier']:<9} ║ Tier: {p2['tier']:<9} ║
+    ║ PPG: {p1['ppg_2023']:<10} ║ PPG: {p2['ppg_2023']:<10} ║
+    ╚════════════════╩════════════════╝
+    """
+    return comparison
+
+
+def create_draft_board_snapshot(picks: List[Dict[str, any]], rounds_to_show: int = 3) -> str:
+    """Create a simple draft board visualization."""
+    board = "📋 DRAFT BOARD\n"
+    board += "="*50 + "\n\n"
+    
+    # Group picks by round (assuming 12-team league)
+    rounds = {}
+    for i, pick in enumerate(picks):
+        round_num = (i // 12) + 1
+        if round_num <= rounds_to_show:
+            if round_num not in rounds:
+                rounds[round_num] = []
+            
+            pick_num = (i % 12) + 1
+            player_name = pick if isinstance(pick, str) else pick.get("player", "Unknown")
+            rounds[round_num].append(f"{pick_num}. {player_name}")
+    
+    # Display rounds
+    for round_num in sorted(rounds.keys()):
+        board += f"Round {round_num}:\n"
+        for pick in rounds[round_num]:
+            board += f"  {pick}\n"
+        board += "\n"
+    
+    return board
+
+
+def create_roster_summary(my_picks: List[str]) -> str:
+    """Create a summary of the user's roster."""
+    if not my_picks:
+        return "No picks yet!"
+    
+    roster = "📝 YOUR ROSTER\n"
+    roster += "="*30 + "\n\n"
+    
+    # Group by position
+    by_position = {"QB": [], "RB": [], "WR": [], "TE": []}
+    
+    for player_name in my_picks:
+        player = get_player_info(player_name)
+        if player:
+            pos = player['pos']
+            if pos in by_position:
+                by_position[pos].append(player_name)
+    
+    # Display by position
+    for pos, players in by_position.items():
+        if players:
+            roster += f"{pos}:\n"
+            for player in players:
+                info = get_player_info(player)
+                roster += f"  • {player} ({info['team']}) - {info['ppg_2023']} PPG\n"
+            roster += "\n"
+    
+    # Calculate projected points
+    total_projected = sum(get_player_info(p)['ppg_2023'] for p in my_picks if get_player_info(p))
+    roster += f"Projected Weekly Points: {total_projected:.1f}\n"
+    
+    return roster
+
+
+def create_decision_summary(options: List[str], recommendation: str, reason: str) -> str:
+    """Create a visual summary of a draft decision."""
+    summary = "🤔 DRAFT DECISION\n"
+    summary += "="*40 + "\n\n"
+    
+    summary += "Options considered:\n"
+    for i, option in enumerate(options, 1):
+        player = get_player_info(option)
+        if player:
+            summary += f"{i}. {option} ({player['pos']}) - ADP: {player['adp']}\n"
+    
+    summary += f"\n✅ Recommendation: {recommendation}\n"
+    summary += f"📊 Reason: {reason}\n"
+    
+    return summary
+
+
+def create_scenario_result(scenario_name: str, picks: List[str], outcome: str) -> str:
+    """Create a result summary for a scenario."""
+    result = f"🏆 SCENARIO RESULT: {scenario_name}\n"
+    result += "="*50 + "\n\n"
+    
+    result += "Picks made:\n"
+    for i, pick in enumerate(picks, 1):
+        player = get_player_info(pick)
+        if player:
+            result += f"{i}. {pick} ({player['pos']}) - {player['ppg_2023']} PPG\n"
+    
+    result += f"\n📈 Outcome: {outcome}\n"
+    
+    # Calculate total projected points
+    total_ppg = sum(get_player_info(p)['ppg_2023'] for p in picks if get_player_info(p))
+    result += f"Total Projected PPG: {total_ppg:.1f}\n"
+    
+    return result
+
+
+def create_multi_turn_flow(conversation_turns: List[Dict]) -> str:
+    """Visualize a multi-turn conversation flow with context indicators."""
+    flow = "💬 MULTI-TURN CONVERSATION FLOW\n"
+    flow += "="*50 + "\n\n"
+    
+    # Add legend
+    flow += "📖 Legend:\n"
+    flow += "  🔄 = New Turn\n"
+    flow += "  💭 = Using Previous Context\n"
+    flow += "  ✨ = Explicit Context Reference\n"
+    flow += "  🔗 = Building on Previous Answer\n\n"
+    
+    flow += "Conversation Timeline:\n"
+    flow += "│\n"
+    
+    for i, turn in enumerate(conversation_turns):
+        # Turn header
+        flow += f"├─ 🔄 TURN {turn['turn']}: {turn['showcases']}\n"
+        flow += "│\n"
+        
+        # User message
+        user_preview = turn['user'][:60] + "..." if len(turn['user']) > 60 else turn['user']
+        flow += f"│  👤 User: \"{user_preview}\"\n"
+        
+        # Show if this builds on previous context
+        if i > 0:
+            flow += "│  └─ 💭 (References previous conversation)\n"
+        
+        # Agent response preview
+        agent_preview = turn['agent'][:60] + "..." if len(turn['agent']) > 60 else turn['agent']
+        flow += f"│  🤖 Agent: \"{agent_preview}\"\n"
+        
+        # Context retention indicator
+        if turn.get('context_retained', False):
+            flow += "│  └─ ✨ CONTEXT USED: Agent explicitly referenced earlier conversation\n"
+        
+        # Check for specific context clues
+        agent_lower = turn['agent'].lower()
+        if any(word in agent_lower for word in ['you mentioned', 'you said', 'earlier']):
+            flow += "│  └─ 🔗 Directly references user's previous input\n"
+        elif any(word in agent_lower for word in ['we discussed', 'as i mentioned']):
+            flow += "│  └─ 🔗 Builds on previous recommendations\n"
+        
+        flow += "│\n"
+    
+    flow += "└─ 🏁 Conversation Complete\n\n"
+    
+    # Add summary
+    flow += f"📊 Summary:\n"
+    flow += f"  • Total turns: {len(conversation_turns)}\n"
+    flow += f"  • Context references: {sum(1 for t in conversation_turns if t.get('context_retained', False))}\n"
+    flow += f"  • Demonstrates: Multi-turn memory and context awareness\n"
+    
+    return flow
+
+
+def create_multi_turn_diagram(scenario_name: str, turns: int = 3) -> str:
+    """Create a visual diagram showing multi-turn conversation flow."""
+    diagram = f"""
+╔═══════════════════════════════════════════════════════╗
+║          🏈 MULTI-TURN CONVERSATION DEMO              ║
+║               {scenario_name:<35}    ║
+╚═══════════════════════════════════════════════════════╝
+
+┌─────────────────────────────────────────────────────┐
+│ 💡 KEY FEATURE: Context Retention Across Turns      │
+└─────────────────────────────────────────────────────┘
+
+    Turn 1                Turn 2                Turn 3
+      │                     │                     │
+      ▼                     ▼                     ▼
+┌──────────┐         ┌──────────┐         ┌──────────┐
+│ 👤 USER  │         │ 👤 USER  │         │ 👤 USER  │
+│          │         │          │         │          │
+│ Initial  │────────▶│ Follow   │────────▶│ Build    │
+│ Question │ MEMORY  │ Up       │ MEMORY  │ On       │
+└──────────┘         └──────────┘         └──────────┘
+      │                     │                     │
+      ▼                     ▼                     ▼
+┌──────────┐         ┌──────────┐         ┌──────────┐
+│ 🤖 AGENT │         │ 🤖 AGENT │         │ 🤖 AGENT │
+│          │         │    💭    │         │    💭    │
+│ Answer   │         │ Remembers│         │ Full     │
+│          │         │ Turn 1   │         │ Context  │
+└──────────┘         └──────────┘         └──────────┘
+
+Legend:
+  💭 = Agent accessing conversation memory
+  ──▶ = Context flows forward to next turn
+  👤 = User input
+  🤖 = Agent response with memory
+"""
+    return diagram
+
+
+def create_context_highlight_example() -> str:
+    """Show an example of how context is retained across turns."""
+    example = """
+🎯 MULTI-TURN CONTEXT RETENTION EXAMPLE
+═══════════════════════════════════════
+
+TURN 1:
+👤 User: "I have the 5th pick. Who should I target?"
+🤖 Agent: "With the 5th pick, I recommend targeting Bijan Robinson..."
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+TURN 2:
+👤 User: "What about Ekeler instead?"
+         ↑
+         └─── 🔍 No need to repeat context (5th pick)
+
+🤖 Agent: "Given your 5th pick position that we discussed..."
+           ↑
+           └─── ✨ AGENT REMEMBERS: Pick position from Turn 1
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+TURN 3:
+👤 User: "Who pairs well with him?"
+         ↑
+         └─── 🔍 Pronoun "him" refers to previous player
+
+🤖 Agent: "To pair with Ekeler from your 5th pick..."
+           ↑               ↑
+           │               └─── ✨ REMEMBERS: Pick position
+           └─────────────────── ✨ REMEMBERS: Player choice
+
+📊 Context Retained: 100% across all turns!
+"""
+    return example
+
+
+# Demo function
+def demo_visuals():
+    """Demonstrate all visualization functions."""
+    print("FANTASY DRAFT AGENT - VISUAL COMPONENTS DEMO")
+    print("="*50 + "\n")
+    
+    # Player card
+    print("1. Player Card:")
+    print(create_player_card("Christian McCaffrey"))
+    
+    # Comparison
+    print("\n2. Player Comparison:")
+    print(create_comparison_card("Tyreek Hill", "CeeDee Lamb"))
+    
+    # Draft board
+    print("\n3. Draft Board:")
+    picks = ["Christian McCaffrey", "Justin Jefferson", "CeeDee Lamb", "Tyreek Hill",
+             "Bijan Robinson", "Ja'Marr Chase", "Austin Ekeler", "Saquon Barkley",
+             "A.J. Brown", "Nick Chubb", "Stefon Diggs", "Breece Hall"]
+    print(create_draft_board_snapshot(picks))
+    
+    # Roster summary
+    print("\n4. Roster Summary:")
+    my_picks = ["Bijan Robinson", "A.J. Brown", "Mark Andrews", "Chris Olave"]
+    print(create_roster_summary(my_picks))
+    
+    # Decision summary
+    print("\n5. Decision Summary:")
+    print(create_decision_summary(
+        options=["Bijan Robinson", "Austin Ekeler", "Ja'Marr Chase"],
+        recommendation="Bijan Robinson",
+        reason="Elite talent with RB1 upside in a high-powered offense"
+    ))
+
+
+if __name__ == "__main__":
+    demo_visuals()

deploy_instructions.md

@@ -0,0 +1,45 @@
+# Gradio Deploy Instructions
+
+## Prerequisites
+1. Make sure you're in the `fantasy-draft-agent` directory
+2. Activate your virtual environment: `source venv/bin/activate`
+3. Have your Hugging Face account ready
+
+## Run the Deploy Command
+
+```bash
+gradio deploy
+```
+
+## What You'll Be Asked:
+
+1. **Hugging Face Token**: 
+   - Go to https://huggingface.co/settings/tokens
+   - Create a new token with 'write' permissions
+   - Copy and paste it when prompted
+
+2. **Space Name**: Enter something like `fantasy-draft-demo`
+
+3. **Hardware**: Choose `cpu-basic` (free tier)
+
+4. **Want to create a secret?**: 
+   - Type `yes`
+   - Secret name: `OPENAI_API_KEY`
+   - Secret value: Your OpenAI API key
+
+5. **Space visibility**: Choose `public` or `private`
+
+## After Deployment
+
+The command will:
+- Automatically create the Space
+- Upload all your files
+- Set up the environment
+- Provide you with the Space URL
+
+## Important Notes
+
+- The deploy command uses `app.py` as the entry point (which we already created)
+- It will automatically detect and upload your `requirements.txt`
+- The README_HF.md metadata will be used if you rename it to README.md first
+- You can run `gradio deploy` again to update an existing Space 

docs/FEATURES_AND_ENHANCEMENTS.md

@@ -0,0 +1,177 @@
+# Features and Enhancements
+
+## 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
+```python
+TYPING_DELAY_SECONDS = 0.3      # "..." display time
+MESSAGE_DELAY_SECONDS = 0.1     # Between messages
+AGENT_START_DELAY = 0.5         # A2A startup spacing
+```
+
+#### 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
+
+### 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 `app_enhanced.py`
+
+## Future Possibilities
+- WebSocket real-time updates
+- Custom league settings
+- More agent personalities
+- Advanced statistics
+- Trade negotiations
+- Dynasty league support 

docs/SETUP_GUIDE.md

@@ -0,0 +1,144 @@
+# Setup Guide
+
+This guide covers everything you need to set up and run the Fantasy Draft Multi-Agent Demo.
+
+## Quick Start
+
+1. **Clone the repository**
+   ```bash
+   git clone <your-repo-url>
+   cd fantasy-draft-agent
+   ```
+
+2. **Set up Python environment** (Python 3.8+ required)
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   pip install -r requirements.txt
+   ```
+
+3. **Set up API key**
+   ```bash
+   export OPENAI_API_KEY='your-key-here'
+   # Or create a .env file with: OPENAI_API_KEY=your-key-here
+   ```
+
+4. **Run the app**
+   ```bash
+   python apps/app_enhanced.py
+   ```
+
+## Detailed Setup
+
+### Environment Setup
+
+The app requires Python 3.8+ and the following main dependencies:
+- `gradio>=4.0.0` - Web interface
+- `any-agent` - Multi-agent framework
+- `openai` - LLM integration
+- `python-dotenv` - Environment management
+- `nest-asyncio` - Async support for Gradio
+
+### Virtual Environment (Recommended)
+
+Using a virtual environment keeps dependencies isolated:
+
+```bash
+# Create virtual environment
+python -m venv venv
+
+# Activate it
+# Linux/Mac:
+source venv/bin/activate
+# Windows:
+venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Deactivate when done
+deactivate
+```
+
+### Configuration
+
+1. **API Keys**: The app requires an OpenAI API key. Set it via:
+   - Environment variable: `export OPENAI_API_KEY='sk-...'`
+   - `.env` file: Create `.env` in project root with `OPENAI_API_KEY=sk-...`
+
+2. **Port Configuration**: 
+   - Default web interface: Port 7860
+   - A2A mode uses dynamic ports (5000-9000 range)
+   - Modify in `app_enhanced.py` if needed
+
+## Running Different Modes
+
+### Basic Mode (Recommended for Development)
+```bash
+python apps/app_enhanced.py
+```
+- Single process, fast execution
+- Good for testing and development
+- Supports multiple users
+
+### A2A Mode (Distributed Agents)
+- Automatically enabled via the UI toggle
+- Each agent runs on its own HTTP server
+- Dynamic port allocation for multi-user support
+- Production-ready architecture
+
+## Deployment Options
+
+### Local Deployment
+- Just run the app as shown above
+- Access at `http://localhost:7860`
+- Share link provided by Gradio
+
+### Hugging Face Spaces
+1. Create a new Space on Hugging Face
+2. Upload all files maintaining structure
+3. Set the OpenAI API key as a Space secret
+4. The app will auto-detect and run
+
+### Server Deployment
+1. Ensure Python 3.8+ is installed
+2. Clone repository to server
+3. Set up systemd service or process manager
+4. Configure reverse proxy (nginx/Apache) if needed
+5. Set environment variables securely
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"OPENAI_API_KEY not found"**
+   - Ensure the API key is set correctly
+   - Check `.env` file location (project root)
+   - Verify key starts with `sk-`
+
+2. **Port already in use**
+   - Change port in `app_enhanced.py`: `demo.launch(server_port=7861)`
+   - Or kill the process using the port
+
+3. **Module not found errors**
+   - Ensure virtual environment is activated
+   - Run `pip install -r requirements.txt` again
+   - Check Python version (3.8+ required)
+
+4. **A2A mode fails to start**
+   - Check firewall settings for ports 5000-9000
+   - Ensure no other services using these ports
+   - Try Basic Multiagent mode as fallback
+
+### Performance Tips
+
+- Use Basic Multiagent mode for faster response times
+- Adjust `TYPING_DELAY_SECONDS` in `constants.py` for faster demos
+- Run on a machine with good CPU for multiple A2A agents
+- Consider GPU instance if using larger models
+
+## Next Steps
+
+- Read [TECHNICAL_DOCUMENTATION.md](TECHNICAL_DOCUMENTATION.md) for architecture details
+- See [FEATURES_AND_ENHANCEMENTS.md](FEATURES_AND_ENHANCEMENTS.md) for all features
+- Check the main [README.md](../README.md) for project overview 

docs/TECHNICAL_DOCUMENTATION.md

@@ -0,0 +1,194 @@
+# Technical Documentation
+
+## System Architecture
+
+### Overview
+
+The Fantasy Draft Multi-Agent Demo showcases a sophisticated multi-agent system where AI agents with distinct personalities compete in a mock fantasy football draft. The system supports two execution modes:
+
+1. **Basic Multiagent Mode**: Single-process, shared memory, direct method calls
+2. **A2A (Agent-to-Agent) Mode**: Distributed agents on HTTP servers, true isolation
+
+### Core Components
+
+```
+fantasy-draft-agent/
+├── apps/
+│   ├── app_enhanced.py          # Main Gradio interface with A2A support
+│   ├── multiagent_draft.py      # Core draft logic and agent management
+│   └── multiagent_scenarios.py  # UI formatting and visualization
+├── core/
+│   ├── agent.py                 # Base agent classes and strategies
+│   ├── constants.py             # Configuration constants
+│   ├── data.py                  # Player data and rankings
+│   ├── dynamic_a2a_manager.py   # Dynamic port allocation for A2A
+│   └── a2a_helpers.py           # A2A communication utilities
+```
+
+## A2A Implementation
+
+### Dynamic Port Allocation
+
+The system uses dynamic port allocation to support multiple concurrent A2A sessions:
+
+```python
+class DynamicA2AAgentManager:
+    PORT_RANGE = (5000, 9000)  # Available port range
+    active_sessions = {}       # Track active sessions
+    
+    def __init__(self, session_id):
+        self.session_id = session_id
+        self.allocated_ports = self._allocate_ports()
+```
+
+Each session gets 6 consecutive ports for the 6 agents, ensuring no conflicts between users.
+
+### A2A Communication Protocol
+
+Agents communicate using the any-agent framework's A2A protocol:
+
+1. **Agent Registration**: Each agent starts an HTTP server
+2. **Message Format**: Structured requests/responses with task_id for context
+3. **Async Communication**: Non-blocking calls between agents
+
+Example A2A interaction:
+```python
+# Agent makes a pick
+result = await a2a_tool_async(
+    f"http://localhost:{port}/make_pick",
+    model=agent_config.model,
+    task_id=task_id,  # Maintains conversation context
+    params={
+        "available_players": available,
+        "round_number": round_num
+    }
+)
+```
+
+### Task ID and Context Management
+
+The A2A framework uses `task_id` to maintain conversation continuity:
+
+- Each draft session has a unique task_id
+- Agents automatically maintain conversation history per task_id
+- No manual conversation tracking needed in A2A mode
+- Enables true stateless HTTP communication
+
+## Multi-User Support
+
+### Session-Based Architecture
+
+The app uses Gradio's `gr.State` to maintain separate sessions:
+
+```python
+# Each user gets their own app instance
+app_state = gr.State(None)
+
+def run_draft(mode, app):
+    if app is None:
+        app = EnhancedFantasyDraftApp()
+    # ... rest of logic
+    return output, app  # Return updated state
+```
+
+### Concurrency Handling
+
+- **Basic Mode**: Full multi-user support, each user has isolated state
+- **A2A Mode**: Dynamic ports prevent conflicts between sessions
+- **Resource Management**: Automatic cleanup when sessions end
+
+### Limitations
+
+- A2A mode requires available ports in the 5000-9000 range
+- Each A2A session uses ~6 ports (one per agent)
+- Maximum concurrent A2A sessions limited by port range
+
+## Agent Architecture
+
+### Base Agent Design
+
+```python
+class FantasyDraftAgent(TinyAgent):
+    def __init__(self, team_num, team_name, strategy, personality):
+        super().__init__(
+            name=f"Team {team_num} - {team_name}",
+            instructions=self._build_instructions(),
+            model="gpt-4",
+            temperature=0.7
+        )
+```
+
+### Strategy Implementation
+
+Each agent has a distinct drafting strategy:
+
+1. **Zero RB**: Avoids RBs early, loads up on WRs
+2. **Best Player Available (BPA)**: Pure value drafting
+3. **Robust RB**: Prioritizes RBs in early rounds
+4. **Upside Hunter**: Seeks high-risk, high-reward players
+
+### Memory and Context
+
+Agents maintain context through:
+- Conversation history (automatic in any-agent)
+- Draft state passed with each request
+- Strategy-specific decision making
+
+## Communication Flow
+
+### Pick Phase
+1. Commissioner announces current picker
+2. Agent evaluates available players
+3. Agent makes selection with reasoning
+4. Commissioner confirms pick
+5. Other agents may comment (limited by MAX_COMMENTS_PER_PICK)
+
+### Comment System
+- Rivals prioritized for comments
+- Maximum 2-3 comments per pick (configurable)
+- Natural conversation flow with trash talk
+
+## Performance Optimization
+
+### Typing Effects
+- Configurable delays for realistic feel
+- TYPING_DELAY_SECONDS: Time showing "..."
+- MESSAGE_DELAY_SECONDS: Pause between messages
+
+### Parallel Processing
+- A2A agents process independently
+- Async communication prevents blocking
+- Dynamic timeout handling (30s default)
+
+### Resource Management
+- Automatic port cleanup on session end
+- Graceful fallback from A2A to simulation
+- Memory-efficient state management
+
+## Error Handling
+
+### A2A Failures
+- Automatic fallback to simulation mode
+- Clear error messages in UI
+- Session cleanup on errors
+
+### Port Allocation
+- Retry logic for port binding
+- Session tracking prevents conflicts
+- Cleanup of abandoned sessions
+
+## Security Considerations
+
+- API keys never exposed to frontend
+- Each session isolated from others
+- Port range restrictions for A2A
+- No direct file system access from agents
+
+## Future Enhancements
+
+Potential improvements:
+- WebSocket support for real-time updates
+- Database persistence for draft history
+- Custom model support beyond GPT-4
+- Extended player database
+- League customization options 

requirements.txt

@@ -0,0 +1,28 @@
+# Install A2A dependencies FIRST
+a2a-sdk>=0.2.8
+grpcio>=1.60
+grpcio-tools>=1.60
+grpcio-reflection>=1.7.0
+protobuf==5.29.5
+httpx
+httpx-sse>=0.4.0
+sse-starlette
+fastapi>=0.115.2
+uvicorn>=0.23.1
+
+# Then install any-agent with explicit A2A extra
+any-agent[a2a]>=0.21.0
+
+# OpenAI support (already included in any-agent[openai] but being explicit)
+openai>=1.0.0
+litellm==1.72.4
+
+# App dependencies
+python-dotenv
+pydantic
+gradio>=4.0.0
+nest-asyncio
+aiohttp
+typing-extensions
+
+# Updated with correct installation order for A2A