Update app.py

app.py

@@ -293,6 +293,244 @@ class OpenFloorAgentServer:
         print(f"🚀 OpenFloor agent '{self.agent.manifest.identification.conversationalName}' started on port {self.port}")
         return True
 
+
+class OpenFloorManager:
+    """Central floor manager for coordinating all OpenFloor agents"""
+    
+    def __init__(self, port: int = 7860):
+        self.port = port
+        self.agent_registry = {}  # speakerUri -> agent info
+        self.active_conversations = {}  # conversation_id -> conversation state
+        self.visual_callback = None
+        
+    def register_agent(self, manifest: Manifest, agent_url: str):
+        """Register an agent with the floor manager"""
+        speaker_uri = manifest.identification.speakerUri
+        self.agent_registry[speaker_uri] = {
+            'manifest': manifest,
+            'url': agent_url,
+            'status': 'available',
+            'last_seen': datetime.now()
+        }
+        print(f"🏛️ Floor Manager: Registered agent {manifest.identification.conversationalName}")
+    
+    def discover_agents(self) -> List[Manifest]:
+        """Return manifests of all registered agents"""
+        return [info['manifest'] for info in self.agent_registry.values()]
+    
+    def create_conversation(self, initial_participants: List[str] = None) -> str:
+        """Create a new conversation with optional initial participants"""
+        conversation_id = f"conv:{uuid.uuid4()}"
+        
+        self.active_conversations[conversation_id] = {
+            'id': conversation_id,
+            'participants': initial_participants or [],
+            'messages': [],
+            'created_at': datetime.now(),
+            'status': 'active'
+        }
+        
+        print(f"🏛️ Floor Manager: Created conversation {conversation_id}")
+        return conversation_id
+    
+    def invite_agent_to_conversation(self, conversation_id: str, target_speaker_uri: str, 
+                                   inviting_speaker_uri: str) -> bool:
+        """Send InviteEvent to an agent"""
+        if conversation_id not in self.active_conversations:
+            return False
+            
+        if target_speaker_uri not in self.agent_registry:
+            return False
+        
+        conversation = self.active_conversations[conversation_id]
+        target_agent = self.agent_registry[target_speaker_uri]
+        
+        # Create proper InviteEvent
+        invite_envelope = Envelope(
+            conversation=Conversation(id=conversation_id),
+            sender=Sender(speakerUri=inviting_speaker_uri),
+            events=[
+                InviteEvent(
+                    to=To(speakerUri=target_speaker_uri),
+                    parameters={
+                        'conversation_id': conversation_id,
+                        'invited_by': inviting_speaker_uri,
+                        'invitation_message': f"You are invited to join the expert analysis discussion"
+                    }
+                )
+            ]
+        )
+        
+        # Send invitation to target agent
+        response = self._send_to_agent(target_agent['url'], invite_envelope)
+        
+        if response:
+            # Add to conversation participants
+            if target_speaker_uri not in conversation['participants']:
+                conversation['participants'].append(target_speaker_uri)
+                self._update_visual_state(conversation_id)
+            return True
+        
+        return False
+    
+    def route_message(self, envelope: Envelope) -> bool:
+        """Route message to appropriate recipients"""
+        conversation_id = envelope.conversation.id
+        
+        if conversation_id not in self.active_conversations:
+            return False
+        
+        conversation = self.active_conversations[conversation_id]
+        
+        # Process each event in the envelope
+        for event in envelope.events:
+            if hasattr(event, 'to') and event.to:
+                # Directed message - send to specific agent
+                target_uri = event.to.speakerUri
+                if target_uri in self.agent_registry:
+                    target_agent = self.agent_registry[target_uri]
+                    self._send_to_agent(target_agent['url'], envelope)
+            else:
+                # Broadcast to all conversation participants
+                for participant_uri in conversation['participants']:
+                    if participant_uri != envelope.sender.speakerUri:  # Don't echo back
+                        if participant_uri in self.agent_registry:
+                            participant_agent = self.agent_registry[participant_uri]
+                            self._send_to_agent(participant_agent['url'], envelope)
+        
+        # Store message in conversation history
+        conversation['messages'].append({
+            'envelope': envelope,
+            'timestamp': datetime.now()
+        })
+        
+        self._update_visual_state(conversation_id)
+        return True
+    
+    def _send_to_agent(self, agent_url: str, envelope: Envelope) -> bool:
+        """Send envelope to specific agent"""
+        try:
+            response = requests.post(
+                f"{agent_url}/openfloor/conversation",
+                json=json.loads(envelope.to_json()),
+                headers={'Content-Type': 'application/json'},
+                timeout=30
+            )
+            return response.status_code == 200
+        except Exception as e:
+            print(f"🏛️ Floor Manager: Error sending to {agent_url}: {e}")
+            return False
+    
+    def _update_visual_state(self, conversation_id: str):
+        """Update visual interface based on conversation state"""
+        if self.visual_callback and conversation_id in self.active_conversations:
+            conversation = self.active_conversations[conversation_id]
+            
+            # Convert to visual format
+            participants = []
+            messages = []
+            
+            for participant_uri in conversation['participants']:
+                if participant_uri in self.agent_registry:
+                    agent_info = self.agent_registry[participant_uri]
+                    participants.append(agent_info['manifest'].identification.conversationalName)
+            
+            for msg_info in conversation['messages']:
+                envelope = msg_info['envelope']
+                sender_uri = envelope.sender.speakerUri
+                
+                if sender_uri in self.agent_registry:
+                    sender_name = self.agent_registry[sender_uri]['manifest'].identification.conversationalName
+                    
+                    # Extract message content
+                    for event in envelope.events:
+                        if hasattr(event, 'eventType') and event.eventType == 'utterance':
+                            # Extract text from dialog event
+                            dialog_event = event.parameters.get('dialogEvent')
+                            if dialog_event:
+                                features = dialog_event.get('features', {})
+                                text_feature = features.get('text', {})
+                                tokens = text_feature.get('tokens', [])
+                                text = ' '.join([token.get('value', '') for token in tokens])
+                                
+                                messages.append({
+                                    'speaker': sender_name,
+                                    'text': text,
+                                    'timestamp': msg_info['timestamp'].strftime('%H:%M:%S')
+                                })
+            
+            self.visual_callback({
+                'participants': participants,
+                'messages': messages,
+                'currentSpeaker': None,
+                'thinking': [],
+                'showBubbles': participants,
+                'avatarImages': avatar_images
+            })
+    
+    def set_visual_callback(self, callback):
+        """Set callback for visual updates"""
+        self.visual_callback = callback
+    
+    def start_floor_manager_service(self):
+        """Start the floor manager HTTP service"""
+        from flask import Flask, request, jsonify
+        
+        app = Flask("openfloor-manager")
+        
+        @app.route('/openfloor/discover', methods=['GET'])
+        def discover_agents():
+            """Return list of available agent manifests"""
+            manifests = [json.loads(manifest.to_json()) for manifest in self.discover_agents()]
+            return jsonify(manifests)
+        
+        @app.route('/openfloor/conversation', methods=['POST'])
+        def handle_conversation():
+            """Handle incoming conversation messages"""
+            try:
+                envelope_data = request.get_json()
+                envelope = Envelope.from_json(json.dumps(envelope_data))
+                
+                success = self.route_message(envelope)
+                
+                if success:
+                    return jsonify({'status': 'routed'})
+                else:
+                    return jsonify({'error': 'Failed to route message'}), 400
+                    
+            except Exception as e:
+                return jsonify({'error': str(e)}), 500
+        
+        @app.route('/openfloor/invite', methods=['POST'])
+        def invite_agent():
+            """Handle agent invitation requests"""
+            try:
+                data = request.get_json()
+                conversation_id = data['conversation_id']
+                target_speaker_uri = data['target_speaker_uri']
+                inviting_speaker_uri = data['inviting_speaker_uri']
+                
+                success = self.invite_agent_to_conversation(
+                    conversation_id, target_speaker_uri, inviting_speaker_uri
+                )
+                
+                return jsonify({'success': success})
+                
+            except Exception as e:
+                return jsonify({'error': str(e)}), 500
+        
+        # Start server in background thread
+        import threading
+        server_thread = threading.Thread(
+            target=lambda: app.run(host='localhost', port=self.port + 100, debug=False)
+        )
+        server_thread.daemon = True
+        server_thread.start()
+        
+        print(f"🏛️ OpenFloor Manager started on port {self.port + 100}")
+        return True
+
+
 def get_session_id(request: gr.Request = None) -> str:
     """Generate or retrieve session ID"""
     if request and hasattr(request, 'session_hash'):