envelop refactor

AGENT_MANAGEMENT.md

@@ -0,0 +1,183 @@
+# Agent Management - OpenFloor Protocol
+
+## Overview
+
+The FloorManager now includes comprehensive agent management capabilities that follow the OpenFloor Protocol (OFP) 1.0.0 specification for discovering and inviting agents to conversations.
+
+## Features
+
+### 1. **Agent Discovery (getManifests)**
+The system can discover agent capabilities by sending `getManifests` events to agent service URLs.
+
+**Protocol Reference:** https://openfloor.dev/protocol/specifications/inter-agent-message#h2-117-getmanifests-event
+
+**Example Request:**
+```json
+{
+  "openFloor": {
+    "schema": {
+      "version": "1.0.0"
+    },
+    "conversation": {
+      "id": "manifest_request_abc123"
+    },
+    "sender": {
+      "speakerUri": "tag:floormanager.local,2025:session_xyz",
+      "serviceUrl": "http://localhost:7860/ofp"
+    },
+    "events": [
+      {
+        "eventType": "getManifests"
+      }
+    ]
+  }
+}
+```
+
+**Expected Response:**
+The agent should respond with a `publishManifests` event containing their manifest information.
+
+### 2. **Agent Invitation (invite)**
+Once discovered, agents can be invited to join specific conversations.
+
+**Protocol Reference:** https://openfloor.dev/protocol/specifications/inter-agent-message#h2-113-invite-event
+
+**Example Request:**
+```json
+{
+  "openFloor": {
+    "schema": {
+      "version": "1.0.0"
+    },
+    "conversation": {
+      "id": "conversation_abc123"
+    },
+    "sender": {
+      "speakerUri": "tag:floormanager.local,2025:session_xyz",
+      "serviceUrl": "http://localhost:7860/ofp"
+    },
+    "events": [
+      {
+        "eventType": "invite",
+        "to": {
+          "serviceUrl": "https://agent.example.com/ofp",
+          "speakerUri": "tag:agent.example.com,2025:1234"
+        }
+      }
+    ]
+  }
+}
+```
+
+## Implementation
+
+### AgentManager Class
+
+Located in `src/agent_manager.py`, the `AgentManager` class provides the following methods:
+
+#### `get_agent_manifest(agent_service_url, timeout=10)`
+Retrieves an agent's manifest by sending a getManifests event.
+
+**Parameters:**
+- `agent_service_url` (str): The HTTP endpoint of the agent
+- `timeout` (int): Request timeout in seconds
+
+**Returns:**
+- `Dict[str, Any]`: The agent's manifest or None if failed
+
+#### `invite_agent(agent_speaker_uri, agent_service_url, conversation_id, timeout=10)`
+Invites an agent to join a conversation.
+
+**Parameters:**
+- `agent_speaker_uri` (str): The agent's unique speaker URI
+- `agent_service_url` (str): The agent's service endpoint
+- `conversation_id` (str): The conversation to join
+- `timeout` (int): Request timeout in seconds
+
+**Returns:**
+- `bool`: True if invite was sent successfully
+
+#### `add_agent(agent_service_url, conversation_id, timeout=10)`
+Convenience method that combines manifest retrieval and invitation.
+
+**Parameters:**
+- `agent_service_url` (str): The agent's service endpoint
+- `conversation_id` (str): The conversation to join
+- `timeout` (int): Request timeout in seconds
+
+**Returns:**
+- `AgentInfo`: Object containing agent details or None if failed
+
+## Usage Example
+
+```python
+from src.agent_manager import AgentManager
+
+# Initialize manager
+agent_manager = AgentManager(
+    floor_manager_uri="tag:floormanager.local,2025:session_123",
+    floor_manager_url="http://localhost:7860/ofp"
+)
+
+# Add an agent (gets manifest and invites)
+agent_info = await agent_manager.add_agent(
+    agent_service_url="https://agent.example.com/ofp",
+    conversation_id="conversation_abc123"
+)
+
+if agent_info:
+    print(f"Agent added: {agent_info.speaker_uri}")
+    print(f"Manifest: {agent_info.manifest}")
+```
+
+## UI Integration
+
+The test interface (`test_app.py`) includes a new "OFP Agent" tab in the Agent Management section:
+
+1. **Create a Session**: Initialize a new floor session
+2. **Add OFP Agent**: Enter the agent's service URL
+3. **System Workflow**:
+   - Sends `getManifests` request to discover the agent
+   - Extracts the agent's `speakerUri` from the manifest
+   - Sends `invite` event to invite the agent to the conversation
+   - Adds the agent to the session
+
+## Agent Requirements
+
+For an agent to work with this system, it must:
+
+1. **Expose an HTTP endpoint** that accepts POST requests with OFP envelopes
+2. **Respond to `getManifests` events** with a `publishManifests` event containing:
+   - `speakerUri`: Unique identifier for the agent
+   - `conversationalName`: Display name (optional)
+   - Other manifest fields as needed
+3. **Accept `invite` events** and join the conversation
+
+## Example Agent
+
+See the BadWord Sentinel agent for a reference implementation:
+https://huggingface.co/spaces/BladeSzaSza/OFPBadWord/raw/main/src/ofp_client.py
+
+## Protocol Compliance
+
+This implementation follows:
+- **OFP 1.0.0 Specification**
+- **Inter-Agent Message Format**: https://openfloor.dev/protocol/specifications/inter-agent-message
+- **Event Types**: getManifests, publishManifests, invite, acceptInvite
+
+## Error Handling
+
+The system handles:
+- **Network timeouts**: Configurable timeout for HTTP requests
+- **Invalid responses**: Gracefully handles malformed responses
+- **Missing manifests**: Returns None if agent doesn't provide manifest
+- **Connection failures**: Logs errors and returns appropriate status
+
+## Future Enhancements
+
+Potential improvements:
+- Support for `acceptInvite` and `declineInvite` responses
+- Agent capability negotiation
+- Automatic retry logic for failed invitations
+- Agent health monitoring
+- Support for agent authentication/authorization

ENVELOPE_BROADCASTING.md

@@ -0,0 +1,288 @@
+# Envelope Broadcasting - OpenFloor Protocol
+
+## Overview
+
+The FloorManager implements comprehensive envelope broadcasting to ensure all participants in a conversation stay synchronized. When an agent sends a message to the floor, the floor manager automatically forwards it to all other participants.
+
+## Architecture
+
+### FloorManager Class (`src/floor_manager.py`)
+
+The FloorManager is responsible for:
+1. **Managing floor sessions** - Creating and tracking conversation sessions
+2. **Tracking participants** - Maintaining a list of all agents in each session
+3. **Broadcasting envelopes** - Forwarding messages to all participants
+4. **Floor control** - Managing speaking permissions (grant/revoke floor)
+
+### FloorSession Class
+
+Represents an active conversation session with:
+- `session_id`: Unique identifier for the conversation
+- `participants`: Dictionary of AgentInfo objects (speaker_uri → AgentInfo)
+- `floor_holder`: Current speaker's URI
+- `floor_manager_uri`: Floor manager's speaker URI
+- `floor_manager_url`: Floor manager's service endpoint
+
+## How Envelope Broadcasting Works
+
+### 1. **Message Reception**
+When the floor receives an envelope from an agent:
+
+```python
+await floor_manager.handle_incoming_envelope(
+    session_id="conversation_123",
+    envelope_dict={
+        "openFloor": {
+            "schema": {"version": "1.0.0"},
+            "conversation": {"id": "conversation_123"},
+            "sender": {
+                "speakerUri": "tag:agent1.com,2025:1234",
+                "serviceUrl": "https://agent1.com/ofp"
+            },
+            "events": [{
+                "eventType": "utterance",
+                "parameters": {
+                    "dialogEvent": {
+                        "speakerUri": "tag:agent1.com,2025:1234",
+                        "features": {
+                            "text": {
+                                "mimeType": "text/plain",
+                                "tokens": [{"token": "Hello everyone!"}]
+                            }
+                        }
+                    }
+                }
+            }]
+        }
+    }
+)
+```
+
+### 2. **Processing**
+The floor manager:
+1. **Validates** the envelope
+2. **Extracts** sender information
+3. **Processes** floor control events (if any)
+4. **Broadcasts** to all participants except the sender
+
+### 3. **Broadcasting**
+```python
+results = await floor_manager.broadcast_envelope(
+    session_id="conversation_123",
+    envelope_dict=envelope_dict,
+    sender_uri="tag:agent1.com,2025:1234"  # Exclude sender
+)
+```
+
+### 4. **Delivery**
+The envelope is POSTed to each participant's service URL:
+
+```http
+POST https://agent2.com/ofp
+Content-Type: application/json
+
+{
+  "openFloor": {
+    "schema": {"version": "1.0.0"},
+    "conversation": {"id": "conversation_123"},
+    "sender": {
+      "speakerUri": "tag:agent1.com,2025:1234",
+      "serviceUrl": "https://agent1.com/ofp"
+    },
+    "events": [...]
+  }
+}
+```
+
+## Key Features
+
+### ✅ Automatic Broadcasting
+- **Every message** sent to the floor is automatically forwarded
+- **All participants** receive updates (except the sender)
+- **No manual intervention** required
+
+### ✅ Participant Tracking
+```python
+session = floor_manager.get_session(session_id)
+print(f"Participants: {len(session.participants)}")
+
+for speaker_uri, agent_info in session.participants.items():
+    print(f"  - {speaker_uri} at {agent_info.service_url}")
+```
+
+### ✅ Floor Control Events
+The system automatically processes and broadcasts:
+- `requestFloor` - Agent requests speaking permission
+- `grantFloor` - Floor manager grants permission
+- `revokeFloor` - Floor manager revokes permission
+- `yieldFloor` - Agent voluntarily yields the floor
+
+### ✅ Error Handling
+- **Timeout handling**: Configurable timeouts for each delivery
+- **Failure tracking**: Returns success/failure status for each participant
+- **Logging**: Detailed logs for debugging
+- **Graceful degradation**: Continues broadcasting even if some deliveries fail
+
+## Usage Example
+
+### Creating a Session with Broadcasting
+
+```python
+from src.floor_manager import FloorManager
+
+# Initialize floor manager
+floor_manager = FloorManager()
+
+# Create a session
+session = floor_manager.create_session(
+    session_id="meeting_123",
+    floor_manager_uri="tag:floormanager.local,2025:meeting_123",
+    floor_manager_url="http://localhost:7860/ofp"
+)
+
+# Add participants
+agent_manager = floor_manager.get_agent_manager("meeting_123")
+
+# Add agent 1
+agent1_info = await agent_manager.add_agent(
+    agent_service_url="https://agent1.com/ofp",
+    conversation_id="meeting_123",
+    session_participants=session.participants
+)
+
+# Add agent 2
+agent2_info = await agent_manager.add_agent(
+    agent_service_url="https://agent2.com/ofp",
+    conversation_id="meeting_123",
+    session_participants=session.participants
+)
+
+# Now when agent1 sends a message, agent2 will automatically receive it
+await floor_manager.handle_incoming_envelope(
+    session_id="meeting_123",
+    envelope_dict=agent1_message
+)
+# → agent2 receives the envelope at https://agent2.com/ofp
+```
+
+### Sending Floor Notifications
+
+```python
+# Grant floor to agent1
+await floor_manager.send_floor_notification(
+    session_id="meeting_123",
+    event_type="grantFloor",
+    target_uri="tag:agent1.com,2025:1234"
+)
+# → All participants receive grantFloor notification
+```
+
+## Message Flow Diagram
+
+```
+┌─────────────┐
+│   Agent 1   │
+│ (Sender)    │
+└──────┬──────┘
+       │ 1. Send utterance
+       │    "Hello everyone!"
+       ▼
+┌─────────────────────┐
+│   Floor Manager     │
+│                     │
+│ • Receives envelope │
+│ • Validates sender  │
+│ • Processes events  │
+│ • Broadcasts        │
+└──────┬──────┬───────┘
+       │      │
+       │      │ 2. Forward to participants
+       │      │    (excluding sender)
+       ▼      ▼
+┌──────────┐ ┌──────────┐
+│ Agent 2  │ │ Agent 3  │
+│(Receives)│ │(Receives)│
+└──────────┘ └──────────┘
+```
+
+## Protocol Compliance
+
+This implementation ensures:
+
+### ✅ Real-time Synchronization
+All participants receive messages as they're sent to the floor
+
+### ✅ Sender Exclusion
+The original sender doesn't receive their own message back (avoiding loops)
+
+### ✅ Event Processing
+Floor control events are processed before broadcasting
+
+### ✅ OFP Specification Compliance
+Follows the OpenFloor Protocol for envelope structure and delivery
+
+## Configuration
+
+### Timeout Settings
+```python
+# Default timeout: 10 seconds
+results = await floor_manager.broadcast_envelope(
+    session_id="meeting_123",
+    envelope_dict=envelope,
+    timeout=15  # Custom timeout
+)
+```
+
+### Broadcast Results
+```python
+results = await floor_manager.broadcast_envelope(...)
+# Returns: {'tag:agent1.com,2025:1': True, 'tag:agent2.com,2025:2': False}
+
+successful = sum(1 for success in results.values() if success)
+failed = sum(1 for success in results.values() if not success)
+```
+
+## Benefits
+
+### 🔄 **Automatic Synchronization**
+All participants stay up-to-date without manual message routing
+
+### 📡 **Reliable Delivery**
+Robust error handling ensures messages reach as many participants as possible
+
+### 🎯 **Centralized Control**
+Floor manager acts as the single source of truth for the conversation
+
+### 🔍 **Transparency**
+Detailed logging and result tracking for debugging and monitoring
+
+### ⚡ **Performance**
+Parallel delivery to multiple participants (can be enhanced with async HTTP)
+
+## Future Enhancements
+
+Potential improvements:
+- **Parallel HTTP requests** using `aiohttp` for faster broadcasting
+- **Retry logic** for failed deliveries
+- **Message queuing** for offline participants
+- **Delivery confirmations** (acknowledgment receipts)
+- **Priority messaging** for floor control events
+- **Rate limiting** to prevent spam
+- **Message filtering** based on participant preferences
+
+## Testing
+
+To test envelope broadcasting:
+
+1. **Start the floor manager**
+2. **Add multiple OFP agents** to a session
+3. **Send a message** from one agent
+4. **Verify** all other agents receive the envelope
+5. **Check logs** for delivery status
+
+Example test scenario:
+```python
+# Add 3 agents to a session
+# Have agent 1 send "Hello"
+# Verify agents 2 and 3 receive the message
+# Verify agent 1 does NOT receive it back

QUICKSTART.md

@@ -1,16 +1,22 @@
 ## 🚀 Quick Start Guide - Test the Floor Manager Interface
 
-### Step 1: Install Dependencies
+### Option 1: Quick Install & Run (Recommended)
 
 ```bash
-# Install only Gradio for testing (no need for full stack yet)
-pip install gradio
+# Make the script executable (first time only)
+chmod +x install_and_run.sh
+
+# Install dependencies and run
+./install_and_run.sh
 ```
 
-### Step 2: Run the Test Interface
+### Option 2: Manual Installation
 
 ```bash
-# Run the test app
+# Step 1: Install all dependencies
+pip install -r requirements.txt
+
+# Step 2: Run the test app
 python test_app.py
 ```
 

install_and_run.sh

@@ -14,9 +14,9 @@ fi
 echo "✅ Python 3 found: $(python3 --version)"
 echo ""
 
-# Install Gradio
-echo "📦 Installing Gradio..."
-pip install gradio
+# Install all dependencies
+echo "📦 Installing dependencies from requirements.txt..."
+pip install -r requirements.txt
 
 echo ""
 echo "======================================"

requirements.txt

@@ -8,6 +8,7 @@ pydantic-settings
 # HTTP client for agent communication
 httpx
 aiohttp
+requests
 
 # Utilities
 python-multipart

src/agent_manager.py

@@ -0,0 +1,310 @@
+"""
+Agent Manager for OpenFloor Protocol
+Handles agent discovery, invitation, and manifest management
+"""
+
+import requests
+import logging
+from typing import Dict, Optional, Any
+from dataclasses import dataclass
+from datetime import datetime
+
+from .protocol.envelope import create_envelope, create_inter_agent_message
+from .protocol.events import create_invite_event, create_get_manifest_event
+from .utils.helpers import generate_message_id
+from .utils.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AgentInfo:
+    """Information about an agent"""
+    speaker_uri: str
+    service_url: str
+    manifest: Optional[Dict[str, Any]] = None
+    conversation_id: Optional[str] = None
+    invited_at: Optional[datetime] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "speaker_uri": self.speaker_uri,
+            "service_url": self.service_url,
+            "manifest": self.manifest,
+            "conversation_id": self.conversation_id,
+            "invited_at": self.invited_at.isoformat() if self.invited_at else None
+        }
+
+
+class AgentManager:
+    """
+    Manages agent discovery and invitation for OpenFloor Protocol
+    
+    Based on OFP 1.0.0 specification:
+    - getManifests event: Discover agent capabilities
+    - invite event: Invite agents to join conversations
+    """
+    
+    def __init__(self, floor_manager_uri: str, floor_manager_url: str):
+        """
+        Initialize Agent Manager
+        
+        Args:
+            floor_manager_uri: Speaker URI of the floor manager
+            floor_manager_url: Service URL of the floor manager
+        """
+        self.floor_manager_uri = floor_manager_uri
+        self.floor_manager_url = floor_manager_url
+        self.agents: Dict[str, AgentInfo] = {}
+        logger.info(f"Agent Manager initialized: {floor_manager_uri}")
+    
+    async def get_agent_manifest(
+        self,
+        agent_service_url: str,
+        timeout: int = 10
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get an agent's manifest by sending getManifests event
+        
+        Per OFP spec: https://openfloor.dev/protocol/specifications/inter-agent-message#h2-117-getmanifests-event
+        
+        Args:
+            agent_service_url: URL of the agent's service
+            timeout: Request timeout in seconds
+            
+        Returns:
+            Agent manifest dictionary or None if failed
+        """
+        try:
+            logger.info(f"Requesting manifest from agent: {agent_service_url}")
+            
+            # Create getManifests event envelope
+            conversation_id = f"manifest_request_{generate_message_id()}"
+            
+            # Create OFP envelope with getManifests event
+            envelope_dict = {
+                "openFloor": {
+                    "schema": {
+                        "version": settings.OFP_VERSION
+                    },
+                    "conversation": {
+                        "id": conversation_id
+                    },
+                    "sender": {
+                        "speakerUri": self.floor_manager_uri,
+                        "serviceUrl": self.floor_manager_url
+                    },
+                    "events": [
+                        {
+                            "eventType": "getManifests"
+                        }
+                    ]
+                }
+            }
+            
+            # Send HTTPS POST request to agent
+            response = requests.post(
+                agent_service_url,
+                json=envelope_dict,
+                headers={
+                    'Content-Type': 'application/json',
+                    'User-Agent': f'OFP-FloorManager/{settings.OFP_VERSION}'
+                },
+                timeout=timeout
+            )
+            
+            response.raise_for_status()
+            
+            # Parse response - should contain publishManifests event
+            response_data = response.json()
+            
+            if "openFloor" in response_data:
+                events = response_data["openFloor"].get("events", [])
+                for event in events:
+                    if event.get("eventType") == "publishManifests":
+                        manifest = event.get("parameters", {}).get("manifest")
+                        if manifest:
+                            logger.info(f"✓ Received manifest from {agent_service_url}")
+                            return manifest
+            
+            logger.warning(f"No manifest found in response from {agent_service_url}")
+            return None
+            
+        except requests.exceptions.Timeout:
+            logger.error(f"✗ Timeout getting manifest from {agent_service_url}")
+            return None
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"✗ Failed to get manifest from {agent_service_url}: {e}")
+            return None
+            
+        except Exception as e:
+            logger.error(f"✗ Unexpected error getting manifest: {e}")
+            return None
+    
+    async def invite_agent(
+        self,
+        agent_speaker_uri: str,
+        agent_service_url: str,
+        conversation_id: str,
+        timeout: int = 10
+    ) -> bool:
+        """
+        Invite an agent to join a conversation
+        
+        Per OFP spec: https://openfloor.dev/protocol/specifications/inter-agent-message#h2-113-invite-event
+        
+        Args:
+            agent_speaker_uri: Speaker URI of the agent to invite
+            agent_service_url: Service URL of the agent
+            conversation_id: Conversation ID to invite agent to
+            timeout: Request timeout in seconds
+            
+        Returns:
+            True if invite was sent successfully, False otherwise
+        """
+        try:
+            logger.info(f"Inviting agent {agent_speaker_uri} to conversation {conversation_id}")
+            
+            # Create OFP envelope with invite event
+            envelope_dict = {
+                "openFloor": {
+                    "schema": {
+                        "version": settings.OFP_VERSION
+                    },
+                    "conversation": {
+                        "id": conversation_id
+                    },
+                    "sender": {
+                        "speakerUri": self.floor_manager_uri,
+                        "serviceUrl": self.floor_manager_url
+                    },
+                    "events": [
+                        {
+                            "eventType": "invite",
+                            "to": {
+                                "serviceUrl": agent_service_url,
+                                "speakerUri": agent_speaker_uri
+                            }
+                        }
+                    ]
+                }
+            }
+            
+            # Send HTTPS POST request to agent
+            response = requests.post(
+                agent_service_url,
+                json=envelope_dict,
+                headers={
+                    'Content-Type': 'application/json',
+                    'User-Agent': f'OFP-FloorManager/{settings.OFP_VERSION}'
+                },
+                timeout=timeout
+            )
+            
+            response.raise_for_status()
+            
+            # Store agent info
+            agent_info = AgentInfo(
+                speaker_uri=agent_speaker_uri,
+                service_url=agent_service_url,
+                conversation_id=conversation_id,
+                invited_at=datetime.now()
+            )
+            self.agents[agent_speaker_uri] = agent_info
+            
+            logger.info(f"✓ Successfully invited agent {agent_speaker_uri}")
+            return True
+            
+        except requests.exceptions.Timeout:
+            logger.error(f"✗ Timeout inviting agent {agent_speaker_uri}")
+            return False
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"✗ Failed to invite agent {agent_speaker_uri}: {e}")
+            return False
+            
+        except Exception as e:
+            logger.error(f"✗ Unexpected error inviting agent: {e}")
+            return False
+    
+    async def add_agent(
+        self,
+        agent_service_url: str,
+        conversation_id: str,
+        timeout: int = 10,
+        session_participants: Optional[Dict[str, AgentInfo]] = None
+    ) -> Optional[AgentInfo]:
+        """
+        Add an agent by getting their manifest and inviting them to a conversation
+        
+        This is a convenience method that combines:
+        1. Getting the agent's manifest (to discover their speaker URI)
+        2. Inviting the agent to the conversation
+        3. Optionally adding to session participants
+        
+        Args:
+            agent_service_url: Service URL of the agent
+            conversation_id: Conversation ID to invite agent to
+            timeout: Request timeout in seconds
+            session_participants: Optional dict to add the agent to
+            
+        Returns:
+            AgentInfo object if successful, None otherwise
+        """
+        try:
+            # Step 1: Get agent's manifest
+            manifest = await self.get_agent_manifest(agent_service_url, timeout)
+            if not manifest:
+                logger.error(f"Failed to get manifest for agent: {agent_service_url}")
+                return None
+            
+            # Extract speaker URI from manifest
+            agent_speaker_uri = manifest.get("speakerUri")
+            if not agent_speaker_uri:
+                logger.error(f"Manifest missing speakerUri: {agent_service_url}")
+                return None
+            
+            # Step 2: Invite the agent
+            success = await self.invite_agent(
+                agent_speaker_uri,
+                agent_service_url,
+                conversation_id,
+                timeout
+            )
+            
+            if not success:
+                logger.error(f"Failed to invite agent: {agent_speaker_uri}")
+                return None
+            
+            # Update agent info with manifest
+            agent_info = self.agents[agent_speaker_uri]
+            agent_info.manifest = manifest
+            
+            # Add to session participants if provided
+            if session_participants is not None:
+                session_participants[agent_speaker_uri] = agent_info
+                logger.info(f"Added {agent_speaker_uri} to session participants")
+            
+            logger.info(f"✓ Successfully added agent {agent_speaker_uri} to conversation {conversation_id}")
+            return agent_info
+            
+        except Exception as e:
+            logger.error(f"✗ Error adding agent: {e}")
+            return None
+    
+    def get_agent_info(self, agent_speaker_uri: str) -> Optional[AgentInfo]:
+        """Get information about an agent"""
+        return self.agents.get(agent_speaker_uri)
+    
+    def list_agents(self) -> Dict[str, AgentInfo]:
+        """List all known agents"""
+        return self.agents.copy()
+    
+    def remove_agent(self, agent_speaker_uri: str) -> bool:
+        """Remove an agent from the manager"""
+        if agent_speaker_uri in self.agents:
+            del self.agents[agent_speaker_uri]
+            logger.info(f"Removed agent: {agent_speaker_uri}")
+            return True
+        return False

src/floor_manager.py

@@ -0,0 +1,352 @@
+"""
+Floor Manager - Handles conversation sessions and envelope broadcasting
+"""
+
+import requests
+import logging
+from typing import Dict, Optional, List, Any
+from datetime import datetime
+from dataclasses import dataclass
+
+from .agent_manager import AgentManager, AgentInfo
+from .utils.helpers import generate_message_id
+from .utils.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FloorSession:
+    """Represents an active floor conversation session"""
+    session_id: str
+    floor_manager_uri: str
+    floor_manager_url: str
+    participants: Dict[str, AgentInfo]  # speaker_uri -> AgentInfo
+    created_at: datetime
+    floor_holder: Optional[str] = None  # speaker_uri of current floor holder
+    
+    def add_participant(self, agent_info: AgentInfo):
+        """Add a participant to the session"""
+        self.participants[agent_info.speaker_uri] = agent_info
+    
+    def remove_participant(self, speaker_uri: str):
+        """Remove a participant from the session"""
+        if speaker_uri in self.participants:
+            del self.participants[speaker_uri]
+            if self.floor_holder == speaker_uri:
+                self.floor_holder = None
+    
+    def get_participant_urls(self, exclude_speaker: Optional[str] = None) -> List[str]:
+        """
+        Get list of all participant service URLs
+        
+        Args:
+            exclude_speaker: Optional speaker URI to exclude (e.g., the sender)
+        
+        Returns:
+            List of service URLs
+        """
+        urls = []
+        for speaker_uri, agent_info in self.participants.items():
+            if exclude_speaker and speaker_uri == exclude_speaker:
+                continue
+            if agent_info.service_url:
+                urls.append(agent_info.service_url)
+        return urls
+
+
+class FloorManager:
+    """
+    Floor Manager for OpenFloor Protocol
+    
+    Responsibilities:
+    - Manage floor sessions
+    - Handle agent discovery and invitation
+    - Broadcast envelopes to all participants
+    - Manage floor control (grant/revoke)
+    """
+    
+    def __init__(self):
+        """Initialize Floor Manager"""
+        self.sessions: Dict[str, FloorSession] = {}
+        logger.info("Floor Manager initialized")
+    
+    def create_session(
+        self,
+        session_id: str,
+        floor_manager_uri: str,
+        floor_manager_url: str
+    ) -> FloorSession:
+        """
+        Create a new floor session
+        
+        Args:
+            session_id: Unique session identifier
+            floor_manager_uri: Speaker URI of the floor manager
+            floor_manager_url: Service URL of the floor manager
+        
+        Returns:
+            FloorSession object
+        """
+        session = FloorSession(
+            session_id=session_id,
+            floor_manager_uri=floor_manager_uri,
+            floor_manager_url=floor_manager_url,
+            participants={},
+            created_at=datetime.now()
+        )
+        self.sessions[session_id] = session
+        logger.info(f"Created floor session: {session_id}")
+        return session
+    
+    def get_session(self, session_id: str) -> Optional[FloorSession]:
+        """Get a session by ID"""
+        return self.sessions.get(session_id)
+    
+    def get_agent_manager(self, session_id: str) -> Optional[AgentManager]:
+        """
+        Get an AgentManager for a specific session
+        
+        Args:
+            session_id: Session identifier
+        
+        Returns:
+            AgentManager instance or None
+        """
+        session = self.get_session(session_id)
+        if not session:
+            return None
+        
+        return AgentManager(
+            floor_manager_uri=session.floor_manager_uri,
+            floor_manager_url=session.floor_manager_url
+        )
+    
+    async def broadcast_envelope(
+        self,
+        session_id: str,
+        envelope_dict: Dict[str, Any],
+        sender_uri: Optional[str] = None,
+        timeout: int = 10
+    ) -> Dict[str, bool]:
+        """
+        Broadcast an envelope to all participants in a session
+        
+        Per OFP specification, when an agent sends a message to the floor,
+        the floor manager should forward it to all other participants.
+        
+        Args:
+            session_id: Session identifier
+            envelope_dict: OFP envelope dictionary to broadcast
+            sender_uri: Speaker URI of the sender (to exclude from broadcast)
+            timeout: Request timeout in seconds
+        
+        Returns:
+            Dict mapping participant URIs to success status
+        """
+        session = self.get_session(session_id)
+        if not session:
+            logger.error(f"Session not found: {session_id}")
+            return {}
+        
+        results = {}
+        participant_urls = session.get_participant_urls(exclude_speaker=sender_uri)
+        
+        if not participant_urls:
+            logger.info(f"No participants to broadcast to in session {session_id}")
+            return results
+        
+        logger.info(f"Broadcasting envelope to {len(participant_urls)} participants")
+        
+        for speaker_uri, agent_info in session.participants.items():
+            # Skip the sender
+            if sender_uri and speaker_uri == sender_uri:
+                continue
+            
+            if not agent_info.service_url:
+                logger.warning(f"No service URL for participant: {speaker_uri}")
+                results[speaker_uri] = False
+                continue
+            
+            try:
+                logger.debug(f"Sending envelope to {speaker_uri} at {agent_info.service_url}")
+                
+                response = requests.post(
+                    agent_info.service_url,
+                    json=envelope_dict,
+                    headers={
+                        'Content-Type': 'application/json',
+                        'User-Agent': f'OFP-FloorManager/{settings.OFP_VERSION}'
+                    },
+                    timeout=timeout
+                )
+                
+                response.raise_for_status()
+                results[speaker_uri] = True
+                logger.info(f"✓ Envelope delivered to {speaker_uri}")
+                
+            except requests.exceptions.Timeout:
+                logger.error(f"✗ Timeout sending to {speaker_uri}")
+                results[speaker_uri] = False
+                
+            except requests.exceptions.RequestException as e:
+                logger.error(f"✗ Failed to send to {speaker_uri}: {e}")
+                results[speaker_uri] = False
+                
+            except Exception as e:
+                logger.error(f"✗ Unexpected error sending to {speaker_uri}: {e}")
+                results[speaker_uri] = False
+        
+        successful = sum(1 for success in results.values() if success)
+        logger.info(f"Broadcast complete: {successful}/{len(results)} successful")
+        
+        return results
+    
+    async def handle_incoming_envelope(
+        self,
+        session_id: str,
+        envelope_dict: Dict[str, Any]
+    ) -> bool:
+        """
+        Handle an incoming envelope and broadcast to participants
+        
+        This is the main entry point for envelopes received by the floor.
+        The floor manager will:
+        1. Validate the envelope
+        2. Process any floor control events
+        3. Broadcast to all other participants
+        
+        Args:
+            session_id: Session identifier
+            envelope_dict: OFP envelope dictionary
+        
+        Returns:
+            True if handled successfully
+        """
+        try:
+            # Extract sender information
+            sender_info = envelope_dict.get("openFloor", {}).get("sender", {})
+            sender_uri = sender_info.get("speakerUri")
+            
+            if not sender_uri:
+                logger.error("Envelope missing sender speakerUri")
+                return False
+            
+            logger.info(f"Received envelope from {sender_uri} for session {session_id}")
+            
+            # Process floor control events (grant, revoke, request, etc.)
+            await self._process_floor_events(session_id, envelope_dict)
+            
+            # Broadcast to all participants except sender
+            await self.broadcast_envelope(
+                session_id=session_id,
+                envelope_dict=envelope_dict,
+                sender_uri=sender_uri
+            )
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error handling envelope: {e}")
+            return False
+    
+    async def _process_floor_events(
+        self,
+        session_id: str,
+        envelope_dict: Dict[str, Any]
+    ):
+        """
+        Process floor control events (grantFloor, revokeFloor, requestFloor, etc.)
+        
+        Args:
+            session_id: Session identifier
+            envelope_dict: OFP envelope dictionary
+        """
+        session = self.get_session(session_id)
+        if not session:
+            return
+        
+        events = envelope_dict.get("openFloor", {}).get("events", [])
+        sender_uri = envelope_dict.get("openFloor", {}).get("sender", {}).get("speakerUri")
+        
+        for event in events:
+            event_type = event.get("eventType")
+            
+            if event_type == "requestFloor":
+                logger.info(f"Floor requested by {sender_uri}")
+                # In a full implementation, this would trigger convener logic
+                
+            elif event_type == "grantFloor":
+                to_uri = event.get("to", {}).get("speakerUri")
+                if to_uri:
+                    session.floor_holder = to_uri
+                    logger.info(f"Floor granted to {to_uri}")
+                
+            elif event_type == "revokeFloor":
+                logger.info(f"Floor revoked from {session.floor_holder}")
+                session.floor_holder = None
+                
+            elif event_type == "yieldFloor":
+                if sender_uri == session.floor_holder:
+                    session.floor_holder = None
+                    logger.info(f"Floor yielded by {sender_uri}")
+    
+    async def send_floor_notification(
+        self,
+        session_id: str,
+        event_type: str,
+        target_uri: Optional[str] = None,
+        reason: Optional[str] = None
+    ) -> bool:
+        """
+        Send a floor control notification to all participants
+        
+        Args:
+            session_id: Session identifier
+            event_type: Type of floor event (grantFloor, revokeFloor, etc.)
+            target_uri: Optional target speaker URI
+            reason: Optional reason for the event
+        
+        Returns:
+            True if sent successfully
+        """
+        session = self.get_session(session_id)
+        if not session:
+            return False
+        
+        # Create floor notification envelope
+        event = {
+            "eventType": event_type
+        }
+        
+        if target_uri:
+            event["to"] = {
+                "speakerUri": target_uri
+            }
+        
+        if reason:
+            event["reason"] = reason
+        
+        envelope_dict = {
+            "openFloor": {
+                "schema": {
+                    "version": settings.OFP_VERSION
+                },
+                "conversation": {
+                    "id": session_id
+                },
+                "sender": {
+                    "speakerUri": session.floor_manager_uri,
+                    "serviceUrl": session.floor_manager_url
+                },
+                "events": [event]
+            }
+        }
+        
+        # Broadcast to all participants
+        results = await self.broadcast_envelope(
+            session_id=session_id,
+            envelope_dict=envelope_dict
+        )
+        
+        return any(results.values())

src/protocol/__init__.py

@@ -9,7 +9,6 @@ from .events import (
     create_invite_event,
     create_floor_request_event,
 )
-from .handler import ProtocolHandler
 
 __all__ = [
     "Envelope",
@@ -21,5 +20,4 @@ __all__ = [
     "create_revoke_floor_event",
     "create_invite_event",
     "create_floor_request_event",
-    "ProtocolHandler",
 ]

test_app.py

@@ -7,6 +7,9 @@ import gradio as gr
 from datetime import datetime
 from typing import List, Tuple, Optional
 import uuid
+import asyncio
+from src.floor_manager import FloorManager, FloorSession
+from src.agent_manager import AgentManager, AgentInfo
 
 
 # Simple mock classes for testing
@@ -114,19 +117,28 @@ class MockFloorSession:
 # Global session (in production, this would be managed differently)
 current_session: Optional[MockFloorSession] = None
 
+# Agent Manager for OFP agent interactions
+agent_manager: Optional[AgentManager] = None
+
 
 def create_new_session():
     """Create a new floor session"""
-    global current_session
+    global current_session, agent_manager
     session_id = f"session_{uuid.uuid4().hex[:8]}"
     current_session = MockFloorSession(session_id)
     
+    # Initialize agent manager
+    floor_manager_uri = f"tag:floormanager.local,2025:{session_id}"
+    floor_manager_url = "http://localhost:7860/ofp"
+    agent_manager = AgentManager(floor_manager_uri, floor_manager_url)
+    
     return (
         session_id,
         current_session.format_chat_history(),
         current_session.get_floor_status(),
         current_session.get_agent_list(),
-        gr.update(interactive=True)
+        gr.update(interactive=True),
+        gr.update(interactive=True)  # Enable OFP agent URL input
     )
 
 
@@ -151,6 +163,45 @@ def add_agent(agent_name: str):
     )
 
 
+def add_ofp_agent(agent_url: str):
+    """Add an OFP agent by URL"""
+    if not current_session or not agent_manager:
+        return "❌ Create a session first!", agent_url, current_session.format_chat_history() if current_session else [], current_session.get_floor_status() if current_session else "No session", current_session.get_agent_list() if current_session else [], gr.Dropdown(choices=[])
+    
+    if not agent_url.strip():
+        return "❌ Agent URL cannot be empty!", agent_url, current_session.format_chat_history(), current_session.get_floor_status(), current_session.get_agent_list(), gr.Dropdown(choices=[])
+    
+    try:
+        # Run async function in event loop
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        agent_info = loop.run_until_complete(
+            agent_manager.add_agent(agent_url.strip(), current_session.session_id)
+        )
+        loop.close()
+        
+        if not agent_info:
+            return f"❌ Failed to add OFP agent from {agent_url}", agent_url, current_session.format_chat_history(), current_session.get_floor_status(), current_session.get_agent_list(), gr.Dropdown(choices=[])
+        
+        # Add agent to mock session
+        agent_name = agent_info.manifest.get("conversationalName", agent_info.speaker_uri.split(":")[-1])
+        current_session.add_agent(agent_name)
+        
+        agent_choices = get_agent_dropdown_choices()
+        
+        return (
+            f"✅ Added OFP agent: {agent_name} ({agent_info.speaker_uri})",
+            "",
+            current_session.format_chat_history(),
+            current_session.get_floor_status(),
+            current_session.get_agent_list(),
+            gr.Dropdown(choices=agent_choices)
+        )
+        
+    except Exception as e:
+        return f"❌ Error adding OFP agent: {str(e)}", agent_url, current_session.format_chat_history(), current_session.get_floor_status(), current_session.get_agent_list(), gr.Dropdown(choices=[])
+
+
 def send_message(agent_name: str, message: str):
     """Send a message from an agent"""
     if not current_session:
@@ -238,12 +289,22 @@ with gr.Blocks(title="OFP Floor Manager Test") as demo:
             gr.Markdown("---")
             gr.Markdown("### Agent Management")
             
-            agent_name_input = gr.Textbox(
-                label="Agent Name",
-                placeholder="Enter agent name..."
-            )
+            with gr.Tabs():
+                with gr.Tab("Manual Agent"):
+                    agent_name_input = gr.Textbox(
+                        label="Agent Name",
+                        placeholder="Enter agent name..."
+                    )
+                    add_agent_btn = gr.Button("➕ Add Manual Agent")
+                
+                with gr.Tab("OFP Agent"):
+                    ofp_agent_url = gr.Textbox(
+                        label="Agent Service URL",
+                        placeholder="https://agent.example.com/ofp",
+                        interactive=False
+                    )
+                    add_ofp_agent_btn = gr.Button("🌐 Add OFP Agent")
             
-            add_agent_btn = gr.Button("➕ Add Agent")
             add_agent_status = gr.Textbox(
                 label="Status",
                 interactive=False
@@ -309,7 +370,7 @@ with gr.Blocks(title="OFP Floor Manager Test") as demo:
     # Event Handlers
     create_btn.click(
         fn=create_new_session,
-        outputs=[session_id, chatbot, floor_status, agent_table, send_btn]
+        outputs=[session_id, chatbot, floor_status, agent_table, send_btn, ofp_agent_url]
     )
     
     add_agent_btn.click(
@@ -321,6 +382,15 @@ with gr.Blocks(title="OFP Floor Manager Test") as demo:
         outputs=[message_agent]
     )
     
+    add_ofp_agent_btn.click(
+        fn=add_ofp_agent,
+        inputs=[ofp_agent_url],
+        outputs=[add_agent_status, ofp_agent_url, 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],