initial commit

QUICKSTART.md

@@ -0,0 +1,126 @@
+## 🚀 Quick Start Guide - Test the Floor Manager Interface
+
+### Step 1: Install Dependencies
+
+```bash
+# Install only Gradio for testing (no need for full stack yet)
+pip install gradio
+```
+
+### Step 2: Run the Test Interface
+
+```bash
+# Run the test app
+python test_app.py
+```
+
+### Step 3: Open in Browser
+
+The interface will automatically open at: **http://localhost:7860**
+
+---
+
+## 📱 How to Use the Test Interface
+
+### 1. **Create a Session**
+- Click the "🆕 Create New Session" button
+- A unique session ID will be generated
+
+### 2. **Add Agents**
+- Enter an agent name (e.g., "Alice", "Bob", "Charlie")
+- Click "➕ Add Agent"
+- The first agent automatically gets the floor
+
+### 3. **Send Messages**
+- Select an agent from the "Speaking As" dropdown
+- Type a message
+- Click "📤 Send"
+- Messages appear in the conversation panel
+
+### 4. **Manage the Floor**
+- **Grant Floor**: Select an agent and click "🎤 Grant Floor"
+- **Revoke Floor**: Click "⏸️ Revoke Floor" to remove current speaker
+
+---
+
+## ✨ Features You Can Test
+
+- ✅ Session creation and management
+- ✅ Multiple agent registration
+- ✅ Floor control (grant/revoke)
+- ✅ Agent status tracking
+- ✅ Real-time conversation display
+- ✅ System notifications (agent joined, floor changes)
+- ✅ Message timestamps
+
+---
+
+## 🎯 Test Scenarios
+
+### Scenario 1: Basic Conversation
+1. Create a session
+2. Add agents: "Alice" and "Bob"
+3. Alice sends: "Hello Bob!"
+4. Grant floor to Bob
+5. Bob sends: "Hi Alice, how are you?"
+
+### Scenario 2: Multi-Agent Discussion
+1. Create a session
+2. Add agents: "Moderator", "Expert1", "Expert2"
+3. Let Moderator introduce the topic
+4. Grant floor to Expert1 for their input
+5. Grant floor to Expert2 for their response
+6. Revoke floor when done
+
+### Scenario 3: Floor Management
+1. Create a session
+2. Add 3-4 agents
+3. Practice granting and revoking floor between agents
+4. Observe the status changes in the agent table
+
+---
+
+## 🔧 Troubleshooting
+
+**Port Already in Use?**
+```bash
+# Change the port in test_app.py, line 355:
+demo.launch(server_name="0.0.0.0", server_port=7861, share=False)
+```
+
+**Gradio Not Installed?**
+```bash
+pip install gradio
+```
+
+**Want to share publicly?**
+```bash
+# Change share=False to share=True in test_app.py
+demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
+```
+
+---
+
+## 📝 What's Next?
+
+This is a simplified test interface. The full implementation will include:
+
+- ✨ Real OFP protocol compliance
+- ✨ External agent communication via HTTP
+- ✨ Agent manifest handling
+- ✨ FastAPI backend integration
+- ✨ WebSocket real-time updates
+- ✨ Persistent session storage
+- ✨ Advanced floor control policies
+
+---
+
+## 🎉 Enjoy Testing!
+
+This interface demonstrates the core Floor Manager concepts:
+- **Session Management**: Creating and tracking conversation sessions
+- **Agent Registry**: Managing multiple participants
+- **Floor Control**: Coordinating who can speak
+- **Message Routing**: Distributing messages to all participants
+
+Try it out and see how the OpenFloor Protocol can manage multi-agent conversations! 🚀

README.md

@@ -1,14 +1,90 @@
----
-title: FloorManager
-emoji: 🐠
-colorFrom: pink
-colorTo: gray
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: open floor protocol minimal floor manager
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# OpenFloor Protocol (OFP) Floor Manager
+
+A Python implementation of the OpenFloor Protocol Floor Manager with Gradio UI for managing multi-agent conversations.
+
+## Project Status
+
+### ✅ Completed
+- Project structure created
+- Configuration management (`settings.py`)
+- Logging infrastructure
+- Helper utilities
+- Basic protocol envelope handling
+- Requirements file with all dependencies
+
+### 🚧 In Progress
+- Protocol events module (has syntax errors that need manual fixing)
+- Protocol handler
+- Core business logic (FloorManager, FloorSession, Agent, Convener)
+
+### 📋 Todo
+- FastAPI backend endpoints
+- Gradio UI implementation
+- Example agents
+- Integration testing
+- Documentation
+
+## Installation
+
+```bash
+# Create virtual environment
+python3 -m venv venv
+source venv/bin/activate  # On macOS/Linux
+# or
+venv\Scripts\activate  # On Windows
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Install OpenFloor SDK from test PyPI
+pip install -i https://test.pypi.org/simple/ openfloor
+```
+
+## Architecture
+
+The project follows a modular architecture:
+
+```
+ofpFloor/
+├── src/
+│   ├── utils/          # Configuration, logging, helpers
+│   ├── protocol/       # OFP protocol implementation
+│   ├── core/           # Business logic (Floor Manager, Sessions, Agents)
+│   ├── api/            # FastAPI endpoints
+│   └── ui/             # Gradio interface
+├── tests/              # Unit and integration tests
+└── examples/           # Example agents and scenarios
+```
+
+## Known Issues
+
+### Syntax Errors in `src/protocol/events.py`
+
+The file has Python syntax errors that need to be manually fixed:
+
+1. Line 9: `event_ Dict[str, Any]` should be `event_data: Dict[str, Any]`
+2. Line 10: `meta Optional[Dict[str, Any]]` should be `metadata: Optional[Dict[str, Any]]`
+3. Line 30: `if meta` should be `if meta`
+
+These need to be fixed before the project can run.
+
+## Next Steps
+
+1. Fix syntax errors in `src/protocol/events.py`
+2. Complete protocol handler implementation
+3. Implement core Floor Manager logic
+4. Create FastAPI endpoints
+5. Build Gradio UI
+6. Test with example agents
+
+## References
+
+- [OpenFloor Protocol Specifications](https://openfloor.dev/protocol/specifications/)
+- [OFP Assistant Manifest](https://openfloor.dev/protocol/specifications/assistant-manifest.md)
+- [OFP Inter-Agent Message](https://openfloor.dev/protocol/specifications/inter-agent-message.md)
+- [OFP Dialog Event Object](https://openfloor.dev/protocol/specifications/dialog-event-object.md)
+- [Gradio Documentation](https://www.gradio.app/)
+
+## License
+
+MIT License

install_and_run.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+echo "======================================"
+echo "🎤 OFP Floor Manager - Quick Setup"
+echo "======================================"
+echo ""
+
+# Check if Python is installed
+if ! command -v python3 &> /dev/null; then
+    echo "❌ Python 3 is not installed. Please install Python 3 first."
+    exit 1
+fi
+
+echo "✅ Python 3 found: $(python3 --version)"
+echo ""
+
+# Install Gradio
+echo "📦 Installing Gradio..."
+pip install gradio
+
+echo ""
+echo "======================================"
+echo "✅ Installation Complete!"
+echo "======================================"
+echo ""
+echo "🚀 Starting the Floor Manager Test Interface..."
+echo ""
+
+# Run the test app
+python3 test_app.py

requirements.txt

@@ -0,0 +1,24 @@
+# Core dependencies
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+gradio==4.44.0
+pydantic==2.5.0
+pydantic-settings==2.1.0
+
+# HTTP client for agent communication
+httpx==0.25.1
+aiohttp==3.9.1
+
+# OpenFloor Protocol SDK
+# Note: Install with: pip install -i https://test.pypi.org/simple/ openfloor
+openfloor==0.1.0
+
+# Utilities
+python-multipart==0.0.6
+python-dotenv==1.0.0
+websockets==12.0
+
+# Development
+pytest==7.4.3
+pytest-asyncio==0.21.1
+black==23.11.0

src/__init__.py

@@ -0,0 +1,3 @@
+"""OpenFloor Protocol Floor Manager"""
+
+__version__ = "0.1.0"

src/protocol/__init__.py

@@ -0,0 +1,25 @@
+"""OpenFloor Protocol implementation"""
+
+from .envelope import Envelope, create_envelope, create_inter_agent_message
+from .events import (
+    create_dialog_event,
+    create_get_manifest_event,
+    create_grant_floor_event,
+    create_revoke_floor_event,
+    create_invite_event,
+    create_floor_request_event,
+)
+from .handler import ProtocolHandler
+
+__all__ = [
+    "Envelope",
+    "create_envelope",
+    "create_inter_agent_message",
+    "create_dialog_event",
+    "create_get_manifest_event",
+    "create_grant_floor_event",
+    "create_revoke_floor_event",
+    "create_invite_event",
+    "create_floor_request_event",
+    "ProtocolHandler",
+]

src/protocol/envelope.py

@@ -0,0 +1,105 @@
+"""OFP Envelope handling"""
+
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, asdict
+from datetime import datetime
+
+from ..utils.helpers import generate_message_id, get_timestamp
+from ..utils.config import settings
+
+
+@dataclass
+class Envelope:
+    """
+    OpenFloor Protocol Envelope structure
+    Based on: https://openfloor.dev/protocol/specifications/inter-agent-message.md
+    """
+    version: str
+    sender: str
+    recipients: List[str]
+    message: Dict[str, Any]
+    timestamp: str
+    message_id: str
+    correlation_id: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert envelope to dictionary"""
+        data = asdict(self)
+        # Remove None values
+        return {k: v for k, v in data.items() if v is not None}
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Envelope":
+        """Create envelope from dictionary"""
+        return cls(
+            version=data.get("version", settings.OFP_VERSION),
+            sender=data["sender"],
+            recipients=data["recipients"],
+            message=data["message"],
+            timestamp=data.get("timestamp", get_timestamp()),
+            message_id=data.get("message_id", generate_message_id()),
+            correlation_id=data.get("correlation_id")
+        )
+
+
+def create_envelope(
+    sender: str,
+    recipients: List[str],
+    message: Dict[str, Any],
+    correlation_id: Optional[str] = None
+) -> Envelope:
+    """
+    Create a new OFP envelope
+    
+    Args:
+        sender: Agent ID of sender
+        recipients: List of recipient agent IDs or ["broadcast"]
+        message: Message content (InterAgentMessage)
+        correlation_id: Optional correlation ID for request-response
+    
+    Returns:
+        Envelope object
+    """
+    return Envelope(
+        version=settings.OFP_VERSION,
+        sender=sender,
+        recipients=recipients,
+        message=message,
+        timestamp=get_timestamp(),
+        message_id=generate_message_id(),
+        correlation_id=correlation_id
+    )
+
+
+def create_inter_agent_message(
+    message_type: str,
+    content: Any,
+    dialog_event: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Create InterAgentMessage structure
+    Based on: https://openfloor.dev/protocol/specifications/inter-agent-message.md
+    
+    Args:
+        message_type: Type of message (e.g., "agent_response", "floor_request")
+        content: Message content (can be text, JSON, etc.)
+        dialog_event: Optional DialogEventObject
+        meta Optional metadata
+    
+    Returns:
+        InterAgentMessage dictionary
+    """
+    message = {
+        "message_type": message_type,
+        "content": content,
+        "timestamp": get_timestamp()
+    }
+    
+    if dialog_event:
+        message["dialog_event"] = dialog_event
+    
+    if metadata:
+        message["metadata"] = metadata
+    
+    return message

src/protocol/events.py

@@ -0,0 +1,212 @@
+"""OFP Dialog Event Objects"""
+
+from typing import Any, Dict, Optional
+from ..utils.helpers import get_timestamp
+
+
+def create_dialog_event(
+    event_type: str,
+    event_ Dict[str, Any],
+    meta Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Create a DialogEventObject
+    Based on: https://openfloor.dev/protocol/specifications/dialog-event-object.md
+    
+    Args:
+        event_type: Type of event (e.g., "GRANT_FLOOR", "GET_MANIFEST")
+        event_ Event-specific data
+        metadata: Optional metadata
+    
+    Returns:
+        DialogEventObject dictionary
+    """
+    event = {
+        "event_type": event_type,
+        "timestamp": get_timestamp(),
+        "event_data": event_data
+    }
+    
+    if meta
+        event["metadata"] = metadata
+    
+    return event
+
+
+def create_get_manifest_event(
+    agent_id: str,
+    requested_by: str = "floor_manager"
+) -> Dict[str, Any]:
+    """
+    Create GET_MANIFEST event
+    
+    Args:
+        agent_id: ID of agent to get manifest from
+        requested_by: Who is requesting the manifest
+    
+    Returns:
+        DialogEventObject for GET_MANIFEST
+    """
+    return create_dialog_event(
+        event_type="GET_MANIFEST",
+        event_data={
+            "agent_id": agent_id,
+            "requested_by": requested_by
+        }
+    )
+
+
+def create_grant_floor_event(
+    agent_id: str,
+    granted_by: str = "convener",
+    duration: Optional[int] = None
+) -> Dict[str, Any]:
+    """
+    Create GRANT_FLOOR event
+    
+    Args:
+        agent_id: ID of agent receiving floor
+        granted_by: Who granted the floor
+        duration: Optional floor duration in seconds
+    
+    Returns:
+        DialogEventObject for GRANT_FLOOR
+    """
+    event_data = {
+        "agent_id": agent_id,
+        "granted_by": granted_by
+    }
+    
+    if duration:
+        event_data["duration"] = duration
+    
+    return create_dialog_event(
+        event_type="GRANT_FLOOR",
+        event_data=event_data
+    )
+
+
+def create_revoke_floor_event(
+    agent_id: str,
+    revoked_by: str = "convener",
+    reason: str = "floor_expired"
+) -> Dict[str, Any]:
+    """
+    Create REVOKE_FLOOR event
+    
+    Args:
+        agent_id: ID of agent losing floor
+        revoked_by: Who revoked the floor
+        reason: Reason for revocation
+    
+    Returns:
+        DialogEventObject for REVOKE_FLOOR
+    """
+    return create_dialog_event(
+        event_type="REVOKE_FLOOR",
+        event_data={
+            "agent_id": agent_id,
+            "revoked_by": revoked_by,
+            "reason": reason
+        }
+    )
+
+
+def create_invite_event(
+    session_id: str,
+    inviter: str = "floor_manager",
+    join_url: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Create INVITE event
+    
+    Args:
+        session_id: Session to join
+        inviter: Who is sending the invite
+        join_url: Optional URL to join session
+    
+    Returns:
+        DialogEventObject for INVITE
+    """
+    event_data = {
+        "session_id": session_id,
+        "inviter": inviter
+    }
+    
+    if join_url:
+        event_data["join_url"] = join_url
+    
+    return create_dialog_event(
+        event_type="INVITE",
+        event_data=event_data
+    )
+
+
+def create_floor_request_event(
+    agent_id: str,
+    priority: int = 0
+) -> Dict[str, Any]:
+    """
+    Create FLOOR_REQUEST event
+    
+    Args:
+        agent_id: ID of agent requesting floor
+        priority: Request priority (higher = more urgent)
+    
+    Returns:
+        DialogEventObject for FLOOR_REQUEST
+    """
+    return create_dialog_event(
+        event_type="FLOOR_REQUEST",
+        event_data={
+            "agent_id": agent_id,
+            "priority": priority
+        }
+    )
+
+
+def create_agent_joined_event(
+    agent_id: str,
+    agent_name: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Create AGENT_JOINED event
+    
+    Args:
+        agent_id: ID of agent that joined
+        agent_name: Optional agent name
+    
+    Returns:
+        DialogEventObject for AGENT_JOINED
+    """
+    event_data = {"agent_id": agent_id}
+    if agent_name:
+        event_data["agent_name"] = agent_name
+    
+    return create_dialog_event(
+        event_type="AGENT_JOINED",
+        event_data=event_data
+    )
+
+
+def create_agent_left_event(
+    agent_id: str,
+    reason: str = "disconnected"
+) -> Dict[str, Any]:
+    """
+    Create AGENT_LEFT event
+    
+    Args:
+        agent_id: ID of agent that left
+        reason: Reason for leaving
+    
+    Returns:
+        DialogEventObject for AGENT_LEFT
+    """
+    return create_dialog_event(
+        event_type="AGENT_LEFT",
+        event_data={
+            "agent_id": agent_id,
+            "reason": reason
+        }
+    )

src/utils/__init__.py

@@ -0,0 +1,6 @@
+"""Utility modules"""
+
+from .config import settings
+from .logger import get_logger
+
+__all__ = ["settings", "get_logger"]

src/utils/config.py

@@ -0,0 +1,39 @@
+"""Configuration management using Pydantic Settings"""
+
+from typing import Optional
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """Application settings"""
+    
+    # Server Configuration
+    HOST: str = "0.0.0.0"
+    PORT: int = 7860
+    
+    # Floor Manager Settings
+    DEFAULT_FLOOR_DURATION: int = 300  # seconds
+    MAX_AGENTS_PER_SESSION: int = 10
+    SESSION_TIMEOUT: int = 3600  # seconds
+    AUTO_GRANT_FLOOR: bool = True
+    
+    # Protocol Settings
+    OFP_VERSION: str = "1.0.0"
+    MESSAGE_TIMEOUT: int = 30  # seconds
+    
+    # UI Settings
+    UPDATE_INTERVAL: int = 2  # seconds
+    MAX_MESSAGE_DISPLAY: int = 100
+    
+    # Logging
+    LOG_LEVEL: str = "INFO"
+    
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=True
+    )
+
+
+# Global settings instance
+settings = Settings()

src/utils/helpers.py

@@ -0,0 +1,52 @@
+"""Helper utility functions"""
+
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List
+
+
+def generate_id() -> str:
+    """Generate a unique ID"""
+    return str(uuid.uuid4())
+
+
+def generate_message_id() -> str:
+    """Generate a unique message ID"""
+    return f"msg_{uuid.uuid4().hex[:16]}"
+
+
+def generate_session_id() -> str:
+    """Generate a unique session ID"""
+    return f"session_{uuid.uuid4().hex[:12]}"
+
+
+def get_timestamp() -> str:
+    """Get current ISO 8601 timestamp"""
+    return datetime.utcnow().isoformat() + "Z"
+
+
+def format_agent_name(agent_id: str, name: str = None) -> str:
+    """Format agent display name"""
+    if name:
+        return f"{name} ({agent_id[:8]}...)"
+    return f"Agent {agent_id[:8]}..."
+
+
+def truncate_text(text: str, max_length: int = 100) -> str:
+    """Truncate text with ellipsis"""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length - 3] + "..."
+
+
+def safe_get(dictionary: Dict, *keys: str, default: Any = None) -> Any:
+    """Safely get nested dictionary value"""
+    result = dictionary
+    for key in keys:
+        if isinstance(result, dict):
+            result = result.get(key)
+        else:
+            return default
+        if result is None:
+            return default
+    return result

src/utils/logger.py

@@ -0,0 +1,32 @@
+"""Logging configuration"""
+
+import logging
+import sys
+from typing import Optional
+
+from .config import settings
+
+
+def get_logger(name: Optional[str] = None) -> logging.Logger:
+    """Get a configured logger instance"""
+    
+    logger = logging.getLogger(name or __name__)
+    
+    # Only configure if not already configured
+    if not logger.handlers:
+        logger.setLevel(getattr(logging, settings.LOG_LEVEL.upper()))
+        
+        # Console handler
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setLevel(getattr(logging, settings.LOG_LEVEL.upper()))
+        
+        # Format
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        handler.setFormatter(formatter)
+        
+        logger.addHandler(handler)
+    
+    return logger

test_app.py

@@ -0,0 +1,346 @@
+"""
+Simple Gradio Test Interface for OFP Floor Manager
+This is a minimal working version for testing the UI
+"""
+
+import gradio as gr
+from datetime import datetime
+from typing import List, Tuple, Optional
+import uuid
+
+
+# Simple mock classes for testing
+class MockAgent:
+    def __init__(self, agent_id: str, name: str):
+        self.agent_id = agent_id
+        self.name = name
+        self.has_floor = False
+        self.joined_at = datetime.now()
+    
+    def to_display(self):
+        status = "🎤 Has Floor" if self.has_floor else "⏸️ Listening"
+        return [self.name, self.agent_id[:8], status]
+
+
+class MockFloorSession:
+    def __init__(self, session_id: str):
+        self.session_id = session_id
+        self.agents = {}
+        self.floor_holder = None
+        self.messages = []
+        self.created_at = datetime.now()
+    
+    def add_agent(self, name: str) -> str:
+        agent_id = f"agent_{uuid.uuid4().hex[:8]}"
+        agent = MockAgent(agent_id, name)
+        self.agents[agent_id] = agent
+        
+        # Add system message
+        self.messages.append({
+            "role": "system",
+            "content": f"🔔 {name} joined the session",
+            "timestamp": datetime.now().strftime("%H:%M:%S")
+        })
+        
+        # Auto-grant floor if first agent
+        if len(self.agents) == 1:
+            self.grant_floor(agent_id)
+        
+        return agent_id
+    
+    def grant_floor(self, agent_id: str):
+        # Revoke from current holder
+        if self.floor_holder and self.floor_holder in self.agents:
+            self.agents[self.floor_holder].has_floor = False
+        
+        # Grant to new holder
+        if agent_id in self.agents:
+            self.agents[agent_id].has_floor = True
+            self.floor_holder = agent_id
+            self.messages.append({
+                "role": "system",
+                "content": f"🎤 Floor granted to {self.agents[agent_id].name}",
+                "timestamp": datetime.now().strftime("%H:%M:%S")
+            })
+    
+    def revoke_floor(self):
+        if self.floor_holder and self.floor_holder in self.agents:
+            agent_name = self.agents[self.floor_holder].name
+            self.agents[self.floor_holder].has_floor = False
+            self.floor_holder = None
+            self.messages.append({
+                "role": "system",
+                "content": f"⏸️ Floor revoked from {agent_name}",
+                "timestamp": datetime.now().strftime("%H:%M:%S")
+            })
+    
+    def add_message(self, agent_id: str, content: str):
+        if agent_id in self.agents:
+            agent = self.agents[agent_id]
+            self.messages.append({
+                "role": agent.name,
+                "content": content,
+                "timestamp": datetime.now().strftime("%H:%M:%S")
+            })
+    
+    def get_agent_list(self):
+        return [agent.to_display() for agent in self.agents.values()]
+    
+    def get_floor_status(self):
+        if self.floor_holder and self.floor_holder in self.agents:
+            agent = self.agents[self.floor_holder]
+            return f"🎤 Current Speaker: {agent.name} ({agent.agent_id[:8]})"
+        return "⏸️ No active speaker"
+    
+    def format_chat_history(self):
+        """Format messages for Gradio Chatbot with type='messages'"""
+        formatted = []
+        for msg in self.messages:
+            if msg["role"] == "system":
+                # System messages as assistant role with italic content
+                formatted.append({
+                    "role": "assistant",
+                    "content": f"_{msg['content']}_"
+                })
+            else:
+                # Agent messages as user role with name prefix
+                formatted.append({
+                    "role": "user",
+                    "content": f"**{msg['role']}** [{msg['timestamp']}]: {msg['content']}"
+                })
+        return formatted
+
+
+# Global session (in production, this would be managed differently)
+current_session: Optional[MockFloorSession] = None
+
+
+def create_new_session():
+    """Create a new floor session"""
+    global current_session
+    session_id = f"session_{uuid.uuid4().hex[:8]}"
+    current_session = MockFloorSession(session_id)
+    
+    return (
+        session_id,
+        current_session.format_chat_history(),
+        current_session.get_floor_status(),
+        current_session.get_agent_list(),
+        gr.update(interactive=True)
+    )
+
+
+def add_agent(agent_name: str):
+    """Add an agent to the session"""
+    if not current_session:
+        return "❌ Create a session first!", "", [], "No session", [], gr.Dropdown(choices=[])
+    
+    if not agent_name.strip():
+        return "❌ Agent name cannot be empty!", agent_name, current_session.format_chat_history(), current_session.get_floor_status(), current_session.get_agent_list(), gr.Dropdown(choices=[])
+    
+    agent_id = current_session.add_agent(agent_name.strip())
+    agent_choices = get_agent_dropdown_choices()
+    
+    return (
+        f"✅ Added agent: {agent_name}",
+        "",
+        current_session.format_chat_history(),
+        current_session.get_floor_status(),
+        current_session.get_agent_list(),
+        gr.Dropdown(choices=agent_choices)
+    )
+
+
+def send_message(agent_name: str, message: str):
+    """Send a message from an agent"""
+    if not current_session:
+        return "❌ Create a session first!", [], "No session"
+    
+    if not message.strip():
+        return current_session.format_chat_history(), "", current_session.get_floor_status()
+    
+    # Find agent by name
+    agent_id = None
+    for aid, agent in current_session.agents.items():
+        if agent.name == agent_name:
+            agent_id = aid
+            break
+    
+    if not agent_id:
+        return current_session.format_chat_history(), message, current_session.get_floor_status()
+    
+    current_session.add_message(agent_id, message.strip())
+    
+    return (
+        current_session.format_chat_history(),
+        "",
+        current_session.get_floor_status()
+    )
+
+
+def grant_floor_to_agent(agent_name: str):
+    """Grant floor to selected agent"""
+    if not current_session or not agent_name:
+        return [], "No session", []
+    
+    # Find agent by name
+    for aid, agent in current_session.agents.items():
+        if agent.name == agent_name:
+            current_session.grant_floor(aid)
+            break
+    
+    return (
+        current_session.format_chat_history(),
+        current_session.get_floor_status(),
+        current_session.get_agent_list()
+    )
+
+
+def revoke_floor_action():
+    """Revoke floor from current holder"""
+    if not current_session:
+        return [], "No session", []
+    
+    current_session.revoke_floor()
+    
+    return (
+        current_session.format_chat_history(),
+        current_session.get_floor_status(),
+        current_session.get_agent_list()
+    )
+
+
+def get_agent_dropdown_choices():
+    """Get list of agent names for dropdown"""
+    if not current_session:
+        return []
+    return [agent.name for agent in current_session.agents.values()]
+
+
+# Create Gradio interface
+with gr.Blocks(title="OFP Floor Manager Test", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎤 OpenFloor Protocol - Floor Manager Test")
+    gr.Markdown("Test interface for managing multi-agent floor conversations")
+    
+    with gr.Row():
+        # Left Panel: Session Control
+        with gr.Column(scale=1):
+            gr.Markdown("### Session Management")
+            
+            session_id = gr.Textbox(
+                label="Session ID",
+                interactive=False,
+                placeholder="No active session"
+            )
+            
+            create_btn = gr.Button("🆕 Create New Session", variant="primary")
+            
+            gr.Markdown("---")
+            gr.Markdown("### Agent Management")
+            
+            agent_name_input = gr.Textbox(
+                label="Agent Name",
+                placeholder="Enter agent name..."
+            )
+            
+            add_agent_btn = gr.Button("➕ Add Agent")
+            add_agent_status = gr.Textbox(
+                label="Status",
+                interactive=False
+            )
+            
+            gr.Markdown("---")
+            gr.Markdown("### Connected Agents")
+            
+            agent_table = gr.Dataframe(
+                headers=["Name", "ID", "Status"],
+                datatype=["str", "str", "str"],
+                label="Agents",
+                interactive=False
+            )
+            
+            gr.Markdown("---")
+            gr.Markdown("### Floor Control")
+            
+            agent_selector = gr.Dropdown(
+                label="Select Agent",
+                choices=[],
+                interactive=True,
+                allow_custom_value=False
+            )
+            
+            with gr.Row():
+                grant_btn = gr.Button("🎤 Grant Floor", variant="primary")
+                revoke_btn = gr.Button("⏸️ Revoke Floor", variant="stop")
+        
+        # Right Panel: Conversation
+        with gr.Column(scale=2):
+            gr.Markdown("### Floor Conversation")
+            
+            floor_status = gr.Textbox(
+                label="Current Floor Status",
+                interactive=False,
+                value="⏸️ No active speaker"
+            )
+            
+            chatbot = gr.Chatbot(
+                label="Conversation",
+                height=400,
+                type="messages"
+            )
+            
+            gr.Markdown("### Send Message")
+            
+            with gr.Row():
+                message_agent = gr.Dropdown(
+                    label="Speaking As",
+                    choices=[],
+                    scale=2,
+                    interactive=True,
+                    allow_custom_value=False
+                )
+                message_input = gr.Textbox(
+                    label="Message",
+                    placeholder="Type your message...",
+                    scale=4,
+                    interactive=True
+                )
+                send_btn = gr.Button("📤 Send", scale=1, variant="primary", interactive=False)
+    
+    # Event Handlers
+    create_btn.click(
+        fn=create_new_session,
+        outputs=[session_id, chatbot, floor_status, agent_table, send_btn]
+    )
+    
+    add_agent_btn.click(
+        fn=add_agent,
+        inputs=[agent_name_input],
+        outputs=[add_agent_status, agent_name_input, chatbot, floor_status, agent_table, agent_selector]
+    ).then(
+        fn=lambda: gr.Dropdown(choices=get_agent_dropdown_choices()),
+        outputs=[message_agent]
+    )
+    
+    send_btn.click(
+        fn=send_message,
+        inputs=[message_agent, message_input],
+        outputs=[chatbot, message_input, floor_status]
+    )
+    
+    grant_btn.click(
+        fn=grant_floor_to_agent,
+        inputs=[agent_selector],
+        outputs=[chatbot, floor_status, agent_table]
+    )
+    
+    revoke_btn.click(
+        fn=revoke_floor_action,
+        outputs=[chatbot, floor_status, agent_table]
+    )
+
+if __name__ == "__main__":
+    print("🚀 Starting OFP Floor Manager Test Interface...")
+    print("📱 Open your browser to test the interface")
+    print("=" * 50)
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)

test_backend.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+
+echo "🧪 Testing OFP Floor Manager Backend"
+echo "======================================"
+echo ""
+
+# Start the server in background
+echo "📡 Starting Gradio server..."
+python3 test_app.py > /tmp/gradio_test.log 2>&1 &
+SERVER_PID=$!
+
+# Wait for server to start
+echo "⏳ Waiting for server to start..."
+sleep 5
+
+# Check if server is running
+if ! ps -p $SERVER_PID > /dev/null; then
+    echo "❌ Server failed to start. Check logs:"
+    cat /tmp/gradio_test.log
+    exit 1
+fi
+
+echo "✅ Server started (PID: $SERVER_PID)"
+echo ""
+
+# Test 1: Create Session
+echo "🧪 Test 1: Creating new session..."
+RESPONSE=$(curl -s -X POST http://localhost:7860/api/predict \
+  -H "Content-Type: application/json" \
+  -d '{"fn_index": 0, "data": [], "session_hash": "test_session_1"}')
+
+if echo "$RESPONSE" | grep -q "session_"; then
+    echo "✅ Session created successfully"
+    SESSION_ID=$(echo "$RESPONSE" | grep -o 'session_[a-z0-9]*' | head -1)
+    echo "   Session ID: $SESSION_ID"
+else
+    echo "❌ Failed to create session"
+    echo "   Response: $RESPONSE"
+fi
+
+echo ""
+
+# Test 2: Add Agent
+echo "🧪 Test 2: Adding agent 'Alice'..."
+RESPONSE=$(curl -s -X POST http://localhost:7860/api/predict \
+  -H "Content-Type: application/json" \
+  -d '{"fn_index": 1, "data": ["Alice"], "session_hash": "test_session_1"}')
+
+if echo "$RESPONSE" | grep -q "Alice"; then
+    echo "✅ Agent added successfully"
+else
+    echo "❌ Failed to add agent"
+fi
+
+echo ""
+
+# Test 3: Add Another Agent
+echo "🧪 Test 3: Adding agent 'Bob'..."
+RESPONSE=$(curl -s -X POST http://localhost:7860/api/predict \
+  -H "Content-Type: application/json" \
+  -d '{"fn_index": 1, "data": ["Bob"], "session_hash": "test_session_1"}')
+
+if echo "$RESPONSE" | grep -q "Bob"; then
+    echo "✅ Agent added successfully"
+else
+    echo "❌ Failed to add agent"
+fi
+
+echo ""
+
+# Test 4: Send Message
+echo "🧪 Test 4: Sending message from Alice..."
+RESPONSE=$(curl -s -X POST http://localhost:7860/api/predict \
+  -H "Content-Type: application/json" \
+  -d '{"fn_index": 2, "data": ["Alice", "Hello Bob!"], "session_hash": "test_session_1"}')
+
+if echo "$RESPONSE" | grep -q "Hello Bob"; then
+    echo "✅ Message sent successfully"
+else
+    echo "❌ Failed to send message"
+fi
+
+echo ""
+
+# Test 5: Grant Floor
+echo "🧪 Test 5: Granting floor to Bob..."
+RESPONSE=$(curl -s -X POST http://localhost:7860/api/predict \
+  -H "Content-Type: application/json" \
+  -d '{"fn_index": 3, "data": ["Bob"], "session_hash": "test_session_1"}')
+
+if echo "$RESPONSE" | grep -q "granted"; then
+    echo "✅ Floor granted successfully"
+else
+    echo "❌ Failed to grant floor"
+fi
+
+echo ""
+echo "======================================"
+echo "🎉 All tests completed!"
+echo ""
+
+# Show server logs
+echo "📋 Server logs:"
+tail -20 /tmp/gradio_test.log
+
+echo ""
+echo "🛑 Stopping server (PID: $SERVER_PID)..."
+kill $SERVER_PID
+wait $SERVER_PID 2>/dev/null
+
+echo "✅ Server stopped"
+echo ""
+echo "💡 To run the server interactively: python3 test_app.py"