Update app.py

app.py

@@ -295,13 +295,14 @@ class OpenFloorAgentServer:
 
 
 class OpenFloorManager:
-    """Central floor manager for coordinating all OpenFloor agents"""
+    """Central floor manager for coordinating all OpenFloor agents - FIXED VERSION"""
     
     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
+        self.message_history = {}  # conversation_id -> message list
         
     def register_agent(self, manifest: Manifest, agent_url: str):
         """Register an agent with the floor manager"""
@@ -322,32 +323,52 @@ class OpenFloorManager:
         """Create a new conversation with optional initial participants"""
         conversation_id = f"conv:{uuid.uuid4()}"
         
+        # Create proper OpenFloor conversation structure
+        conversants = []
+        if initial_participants:
+            for participant_uri in initial_participants:
+                if participant_uri in self.agent_registry:
+                    manifest = self.agent_registry[participant_uri]['manifest']
+                    conversants.append(Conversant(
+                        identification=manifest.identification
+                    ))
+        
+        conversation = Conversation(
+            id=conversation_id,
+            conversants=conversants
+        )
+        
         self.active_conversations[conversation_id] = {
-            'id': conversation_id,
+            'conversation': conversation,
             'participants': initial_participants or [],
             'messages': [],
             'created_at': datetime.now(),
             'status': 'active'
         }
         
+        self.message_history[conversation_id] = []
+        
         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"""
+        """Send proper OpenFloor InviteEvent to an agent"""
         if conversation_id not in self.active_conversations:
+            print(f"🏛️ Floor Manager: Conversation {conversation_id} not found")
             return False
             
         if target_speaker_uri not in self.agent_registry:
+            print(f"🏛️ Floor Manager: Agent {target_speaker_uri} not registered")
             return False
         
-        conversation = self.active_conversations[conversation_id]
+        conversation_state = self.active_conversations[conversation_id]
+        conversation = conversation_state['conversation']
         target_agent = self.agent_registry[target_speaker_uri]
         
-        # Create proper InviteEvent
+        # Create proper OpenFloor InviteEvent
         invite_envelope = Envelope(
-            conversation=Conversation(id=conversation_id),
+            conversation=conversation,
             sender=Sender(speakerUri=inviting_speaker_uri),
             events=[
                 InviteEvent(
@@ -366,107 +387,190 @@ class OpenFloorManager:
         
         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)
+            if target_speaker_uri not in conversation_state['participants']:
+                conversation_state['participants'].append(target_speaker_uri)
+                
+                # Add to conversation conversants
+                target_manifest = target_agent['manifest']
+                conversation.conversants.append(Conversant(
+                    identification=target_manifest.identification
+                ))
+                
+            self._update_visual_state(conversation_id)
+            print(f"🏛️ Floor Manager: Successfully invited {target_speaker_uri} to {conversation_id}")
             return True
         
+        print(f"🏛️ Floor Manager: Failed to invite {target_speaker_uri}")
         return False
     
     def route_message(self, envelope: Envelope) -> bool:
-        """Route message to appropriate recipients"""
+        """Route message to appropriate recipients with proper OpenFloor semantics"""
         conversation_id = envelope.conversation.id
         
         if conversation_id not in self.active_conversations:
+            print(f"🏛️ Floor Manager: Cannot route - conversation {conversation_id} not found")
             return False
         
-        conversation = self.active_conversations[conversation_id]
+        conversation_state = self.active_conversations[conversation_id]
+        sender_uri = envelope.sender.speakerUri
+        
+        # Store message in conversation history
+        message_record = {
+            'envelope': envelope,
+            'timestamp': datetime.now(),
+            'sender': sender_uri
+        }
+        
+        conversation_state['messages'].append(message_record)
+        self.message_history[conversation_id].append(message_record)
         
         # Process each event in the envelope
+        routed_successfully = True
+        
         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:
+                if target_uri in self.agent_registry and target_uri != sender_uri:
                     target_agent = self.agent_registry[target_uri]
-                    self._send_to_agent(target_agent['url'], envelope)
+                    success = self._send_to_agent(target_agent['url'], envelope)
+                    if not success:
+                        routed_successfully = False
+                        print(f"🏛️ Floor Manager: Failed to route directed message to {target_uri}")
             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()
-        })
-        
+                # Broadcast to all conversation participants except sender
+                for participant_uri in conversation_state['participants']:
+                    if participant_uri != sender_uri and participant_uri in self.agent_registry:
+                        participant_agent = self.agent_registry[participant_uri]
+                        success = self._send_to_agent(participant_agent['url'], envelope)
+                        if not success:
+                            routed_successfully = False
+                            print(f"🏛️ Floor Manager: Failed to broadcast to {participant_uri}")
+        
+        # Update visual state after routing
         self._update_visual_state(conversation_id)
-        return True
+        
+        return routed_successfully
     
     def _send_to_agent(self, agent_url: str, envelope: Envelope) -> bool:
-        """Send envelope to specific agent"""
+        """Send envelope to specific agent via HTTP POST"""
+        if agent_url == "internal://ai-expert":
+            # Internal AI experts don't have HTTP endpoints
+            return True
+            
         try:
             response = requests.post(
-                f"{agent_url}/openfloor/conversation",
+                f"{agent_url}/conversation",
                 json=json.loads(envelope.to_json()),
                 headers={'Content-Type': 'application/json'},
                 timeout=30
             )
-            return response.status_code == 200
+            success = response.status_code == 200
+            if success:
+                print(f"🏛️ Floor Manager: Successfully sent message to {agent_url}")
+            else:
+                print(f"🏛️ Floor Manager: HTTP error {response.status_code} sending to {agent_url}")
+            return success
         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]
+        if not self.visual_callback or conversation_id not in self.active_conversations:
+            return
             
-            # Convert to visual format
-            participants = []
-            messages = []
+        conversation_state = self.active_conversations[conversation_id]
+        
+        # Convert to visual format
+        participants = []
+        messages = []
+        
+        # Get participant names
+        for participant_uri in conversation_state['participants']:
+            if participant_uri in self.agent_registry:
+                agent_info = self.agent_registry[participant_uri]
+                participants.append(agent_info['manifest'].identification.conversationalName)
+            else:
+                # Handle AI experts or other internal participants
+                participants.append(participant_uri.split(':')[-1] if ':' in participant_uri else participant_uri)
+        
+        # Convert messages
+        for msg_record in conversation_state['messages']:
+            envelope = msg_record['envelope']
+            sender_uri = envelope.sender.speakerUri
             
-            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)
+            # Get sender name
+            if sender_uri in self.agent_registry:
+                sender_name = self.agent_registry[sender_uri]['manifest'].identification.conversationalName
+            else:
+                sender_name = sender_uri.split(':')[-1] if ':' in sender_uri else sender_uri
             
-            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])
-                                
+            # Extract message content from events
+            for event in envelope.events:
+                if hasattr(event, 'eventType'):
+                    if event.eventType == 'utterance':
+                        # Extract text from utterance dialog event
+                        dialog_event = event.parameters.get('dialogEvent')
+                        if dialog_event:
+                            text = self._extract_text_from_dialog_event(dialog_event)
+                            if text:
                                 messages.append({
                                     'speaker': sender_name,
                                     'text': text,
-                                    'timestamp': msg_info['timestamp'].strftime('%H:%M:%S')
+                                    'timestamp': msg_record['timestamp'].strftime('%H:%M:%S'),
+                                    'type': 'utterance'
                                 })
-            
-            self.visual_callback({
-                'participants': participants,
-                'messages': messages,
-                'currentSpeaker': None,
-                'thinking': [],
-                'showBubbles': participants,
-                'avatarImages': avatar_images
-            })
+                    
+                    elif event.eventType == 'context':
+                        # Handle context events (like research results)
+                        context_params = event.parameters
+                        if 'research_function' in context_params:
+                            messages.append({
+                                'speaker': sender_name,
+                                'text': f"🔍 Research: {context_params.get('result', 'No result')}",
+                                'timestamp': msg_record['timestamp'].strftime('%H:%M:%S'),
+                                'type': 'research_result'
+                            })
+                    
+                    elif event.eventType == 'invite':
+                        messages.append({
+                            'speaker': sender_name,
+                            'text': f"📨 Invited agent to join conversation",
+                            'timestamp': msg_record['timestamp'].strftime('%H:%M:%S'),
+                            'type': 'system'
+                        })
+                    
+                    elif event.eventType == 'bye':
+                        messages.append({
+                            'speaker': sender_name,
+                            'text': f"👋 Left the conversation",
+                            'timestamp': msg_record['timestamp'].strftime('%H:%M:%S'),
+                            'type': 'system'
+                        })
+        
+        # Call visual callback
+        self.visual_callback({
+            'participants': participants,
+            'messages': messages,
+            'currentSpeaker': None,
+            'thinking': [],
+            'showBubbles': participants,
+            'avatarImages': avatar_images
+        })
+    
+    def _extract_text_from_dialog_event(self, dialog_event) -> str:
+        """Extract text from dialog event structure"""
+        try:
+            if isinstance(dialog_event, dict):
+                features = dialog_event.get('features', {})
+                text_feature = features.get('text', {})
+                tokens = text_feature.get('tokens', [])
+                return ' '.join([token.get('value', '') for token in tokens])
+            return ""
+        except Exception as e:
+            print(f"🏛️ Floor Manager: Error extracting text: {e}")
+            return ""
     
     def set_visual_callback(self, callback):
         """Set callback for visual updates"""
@@ -499,6 +603,7 @@ class OpenFloorManager:
                     return jsonify({'error': 'Failed to route message'}), 400
                     
             except Exception as e:
+                print(f"🏛️ Floor Manager: Error handling conversation: {e}")
                 return jsonify({'error': str(e)}), 500
         
         @app.route('/openfloor/invite', methods=['POST'])
@@ -517,6 +622,7 @@ class OpenFloorManager:
                 return jsonify({'success': success})
                 
             except Exception as e:
+                print(f"🏛️ Floor Manager: Error inviting agent: {e}")
                 return jsonify({'error': str(e)}), 500
         
         # Start server in background thread
@@ -590,7 +696,11 @@ class VisualConsensusEngine:
         self.moderator_model = moderator_model or MODERATOR_MODEL
         self.update_callback = update_callback
         self.session_id = session_id
-
+        
+        # Initialize OpenFloor Manager FIRST
+        self.floor_manager = OpenFloorManager(port=7860)
+        self.floor_manager.set_visual_callback(self.update_visual_state)
+        
         # Create OpenFloor research agents
         from research_tools import WebSearchTool, WikipediaSearchTool, ArxivSearchTool, GitHubSearchTool, SECSearchTool
         
@@ -602,8 +712,12 @@ class VisualConsensusEngine:
             'sec_edgar': OpenFloorResearchAgent(SECSearchTool(), port=8005)
         }
         
+        # Start research agents and register with floor manager
         self.start_openfloor_research_agents()
         
+        # Create a persistent conversation for this session
+        self.conversation_id = self.floor_manager.create_conversation([])
+        
         # Available research agents for discovery
         self.available_research_agents = list(self.research_agents.keys())
         
@@ -643,6 +757,12 @@ class VisualConsensusEngine:
             'sambanova': sambanova_key
         }
         
+        # Register AI experts with floor manager
+        self.register_ai_experts()
+        
+        # Start floor manager service
+        self.floor_manager.start_floor_manager_service()
+        
         # PROFESSIONAL: Strong, expert role definitions matched to decision protocols
         self.roles = {
             'standard': "Provide expert analysis with clear reasoning and evidence.",
@@ -683,8 +803,7 @@ class VisualConsensusEngine:
         }
 
     def start_openfloor_research_agents(self):
-        """Start all research agents as proper OpenFloor services"""
-        
+        """Start research agents and register them with the floor manager"""
         agent_ports = {
             'web_search': 8001,
             'wikipedia': 8002,
@@ -703,18 +822,178 @@ class VisualConsensusEngine:
                 self.agent_servers[agent_name] = {
                     'server': server,
                     'port': port,
-                    'url': f"http://localhost:{port}/openfloor/conversation",
+                    'url': f"http://localhost:{port}",
                     'manifest_url': f"http://localhost:{port}/openfloor/manifest"
                 }
+                
+                # Register with floor manager
+                manifest = agent.get_manifest()
+                self.floor_manager.register_agent(manifest, f"http://localhost:{port}")
             
             # Small delay between starting servers
             time.sleep(0.5)
+
+    def register_ai_experts(self):
+        """Register AI expert models as OpenFloor agents"""
+        for model_key, model_info in self.models.items():
+            if model_info['available']:
+                # Create manifest for AI expert
+                expert_manifest = Manifest(
+                    identification=Identification(
+                        speakerUri=f"tag:consilium.ai,2025:{model_key}",
+                        conversationalName=model_info['name'],
+                        role="AI Expert",
+                        organization="Consilium Expert Panel",
+                        synopsis=f"Expert AI model: {model_info['name']}"
+                    ),
+                    capabilities=[
+                        Capability(
+                            keyphrases=["analysis", "expertise", "reasoning", "decision"],
+                            descriptions=[f"Expert analysis and reasoning by {model_info['name']}"],
+                            languages=["en-us"]
+                        )
+                    ]
+                )
+                
+                # Register with floor manager (no URL since these are internal)
+                self.floor_manager.register_agent(expert_manifest, "internal://ai-expert")
     
     def update_visual_state(self, state_update: Dict[str, Any]):
         """Update the visual roundtable state for this session"""
         if self.update_callback:
             self.update_callback(state_update)
-    
+
+    def send_research_request_via_floor(self, function_name: str, query: str, requesting_expert: str) -> str:
+        """Send research request through proper OpenFloor messaging"""
+        
+        # Map function to research agent
+        function_to_agent = {
+            "search_web": "web_search",
+            "search_wikipedia": "wikipedia", 
+            "search_academic": "arxiv",
+            "search_technology_trends": "github",
+            "search_financial_data": "sec_edgar"
+        }
+        
+        if function_name not in function_to_agent:
+            return f"Unknown research function: {function_name}"
+        
+        agent_name = function_to_agent[function_name]
+        research_agent = self.research_agents[agent_name]
+        target_speaker_uri = research_agent.manifest.identification.speakerUri
+        requesting_speaker_uri = f"tag:consilium.ai,2025:{requesting_expert}"
+        
+        # Step 1: Invite research agent to conversation
+        success = self.floor_manager.invite_agent_to_conversation(
+            self.conversation_id, 
+            target_speaker_uri, 
+            requesting_speaker_uri
+        )
+        
+        if not success:
+            return f"Failed to invite {agent_name} to conversation"
+        
+        # Step 2: Send research request via floor manager
+        research_dialog = DialogEvent(
+            speakerUri=requesting_speaker_uri,
+            features={"text": TextFeature(values=[query])}
+        )
+        
+        research_envelope = Envelope(
+            conversation=Conversation(id=self.conversation_id),
+            sender=Sender(speakerUri=requesting_speaker_uri),
+            events=[
+                UtteranceEvent(
+                    dialogEvent=research_dialog,
+                    to=To(speakerUri=target_speaker_uri)
+                )
+            ]
+        )
+        
+        # Route through floor manager
+        routing_success = self.floor_manager.route_message(research_envelope)
+        
+        if not routing_success:
+            return f"Failed to route research request to {agent_name}"
+        
+        # Step 3: Wait for response and collect result
+        # In a real implementation, this would be asynchronous
+        # For now, we'll use the direct research call as fallback
+        try:
+            result = research_agent.tool.search(query)
+            
+            # Step 4: Send result back through floor as ContextEvent
+            result_envelope = Envelope(
+                conversation=Conversation(id=self.conversation_id),
+                sender=Sender(speakerUri=target_speaker_uri),
+                events=[
+                    ContextEvent(
+                        parameters={
+                            "research_function": function_name,
+                            "query": query,
+                            "requesting_expert": requesting_expert,
+                            "result": result
+                        }
+                    )
+                ]
+            )
+            
+            self.floor_manager.route_message(result_envelope)
+            
+            # Step 5: Remove research agent from conversation
+            self.dismiss_research_agent_via_floor(agent_name, requesting_expert)
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"Research error: {str(e)}"
+            
+            # Send error through floor
+            error_envelope = Envelope(
+                conversation=Conversation(id=self.conversation_id),
+                sender=Sender(speakerUri=target_speaker_uri),
+                events=[
+                    ContextEvent(
+                        parameters={
+                            "research_error": error_msg,
+                            "function": function_name,
+                            "query": query
+                        }
+                    )
+                ]
+            )
+            
+            self.floor_manager.route_message(error_envelope)
+            self.dismiss_research_agent_via_floor(agent_name, requesting_expert)
+            
+            return error_msg
+
+    def dismiss_research_agent_via_floor(self, agent_name: str, requesting_expert: str):
+        """Properly dismiss research agent via OpenFloor messaging"""
+        research_agent = self.research_agents[agent_name]
+        target_speaker_uri = research_agent.manifest.identification.speakerUri
+        
+        # Send bye event
+        bye_envelope = Envelope(
+            conversation=Conversation(id=self.conversation_id),
+            sender=Sender(speakerUri=target_speaker_uri),
+            events=[
+                ByeEvent(
+                    parameters={
+                        "message": "Research task completed. Leaving conversation."
+                    }
+                )
+            ]
+        )
+        
+        self.floor_manager.route_message(bye_envelope)
+        
+        # Remove from conversation participants
+        if self.conversation_id in self.floor_manager.active_conversations:
+            conversation_state = self.floor_manager.active_conversations[self.conversation_id]
+            if target_speaker_uri in conversation_state['participants']:
+                conversation_state['participants'].remove(target_speaker_uri)
+
     def handle_function_calls(self, completion, original_prompt: str, calling_model: str) -> str:
         """UNIFIED function call handler with enhanced research capabilities"""
         
@@ -870,131 +1149,34 @@ class VisualConsensusEngine:
             print(f"Error in follow-up completion for {calling_model}: {str(e)}")
             return message.content or "Analysis completed with research integration."
 
-
     def _execute_research_function(self, function_name: str, arguments: dict, requesting_model_name: str = None) -> str:
-        """Execute research function using proper OpenFloor HTTP protocol"""
+        """Execute research function using proper OpenFloor messaging"""
         
         query_param = arguments.get("query") or arguments.get("topic") or arguments.get("technology") or arguments.get("company")
         
-        # Phase 1: Show research STARTING
-        if query_param:
-            self.show_research_starting(function_name, query_param)
+        if not query_param:
+            return "No query parameter found in research request"
+        
+        # Show research starting
+        self.show_research_starting(function_name, query_param)
         
         try:
-            # Map function names to research agents
-            function_to_agent = {
-                "search_web": "web_search",
-                "search_wikipedia": "wikipedia", 
-                "search_academic": "arxiv",
-                "search_technology_trends": "github",
-                "search_financial_data": "sec_edgar"
-            }
+            # Use OpenFloor messaging for research
+            result = self.send_research_request_via_floor(
+                function_name, 
+                query_param, 
+                requesting_model_name or 'unknown'
+            )
             
-            result = ""
+            # Show research complete
+            self.show_research_complete(function_name, query_param, len(result), requesting_model_name)
             
-            if function_name in function_to_agent:
-                agent_name = function_to_agent[function_name]
-                
-                if agent_name not in self.agent_servers:
-                    return f"Research agent '{agent_name}' not available"
-                
-                agent_server = self.agent_servers[agent_name]
-                
-                self.update_research_progress(f"Sending HTTP request to OpenFloor agent...")
-                
-                # Create OpenFloor envelope
-                conversation = Conversation()
-                request_dialog = DialogEvent(
-                    speakerUri=f"tag:consilium.ai,2025:{requesting_model_name or 'expert'}",
-                    features={"text": TextFeature(values=[query_param])}
-                )
-                
-                request_envelope = Envelope(
-                    conversation=conversation,
-                    sender=Sender(speakerUri=f"tag:consilium.ai,2025:{requesting_model_name or 'expert'}"),
-                    events=[
-                        UtteranceEvent(
-                            dialogEvent=request_dialog,
-                            to=To(speakerUri=self.research_agents[agent_name].manifest.identification.speakerUri)
-                        )
-                    ]
-                )
-                
-                # Send HTTP POST request to OpenFloor agent service
-                response = self._send_openfloor_request(agent_server['url'], request_envelope)
-                
-                if response:
-                    result = self._extract_research_result_from_envelope(response)
-                    self.update_research_progress(f"OpenFloor HTTP response received - {len(result)} characters")
-                else:
-                    result = f"Failed to get response from {agent_name} OpenFloor service"
-                      
-            else:
-                result = f"Unknown research function: {function_name}"
-            
-            # Phase 3: Show research complete
-            if query_param:
-                self.show_research_complete(function_name, query_param, len(result), requesting_model_name)
-                
             return result
             
         except Exception as e:
             error_msg = str(e)
-            if query_param:
-                self.show_research_error(function_name, query_param, error_msg, requesting_model_name)
-            return f"OpenFloor HTTP research error: {error_msg}"
-    
-    def _send_openfloor_request(self, agent_url: str, envelope: Envelope) -> Optional[Envelope]:
-        """Send HTTP request to OpenFloor agent service"""
-        try:
-            import requests
-            
-            print(f"🔍 DEBUG: Sending request to {agent_url}")
-            
-            # Serialize envelope to JSON
-            envelope_json = json.loads(envelope.to_json())
-            print(f"🔍 DEBUG: Envelope serialized, size: {len(str(envelope_json))} chars")
-            
-            # Send HTTP POST request
-            response = requests.post(
-                agent_url,
-                json=envelope_json,
-                headers={'Content-Type': 'application/json'},
-                timeout=30
-            )
-            
-            print(f"🔍 DEBUG: Response status: {response.status_code}")
-            print(f"🔍 DEBUG: Response text: {response.text[:200]}...")
-            
-            if response.status_code == 200:
-                # Parse response back to OpenFloor envelope
-                response_data = response.json()
-                return Envelope.from_json(json.dumps(response_data))
-            else:
-                print(f"OpenFloor HTTP error: {response.status_code} - {response.text}")
-                return None
-                
-        except Exception as e:
-            print(f"🔍 DEBUG: Exception in _send_openfloor_request: {e}")
-            import traceback
-            traceback.print_exc()
-            return None
-    
-    def _extract_research_result_from_envelope(self, envelope: Envelope) -> str:
-        """Extract research result from OpenFloor response envelope"""
-        try:
-            for event in envelope.events:
-                if hasattr(event, 'eventType') and event.eventType == 'utterance':
-                    dialog_event = event.parameters.get('dialogEvent')
-                    if dialog_event and hasattr(dialog_event, 'features'):
-                        text_feature = dialog_event.features.get('text')
-                        if text_feature and hasattr(text_feature, 'tokens'):
-                            return ' '.join([token.get('value', '') for token in text_feature.tokens])
-            
-            return "No research result found in OpenFloor response"
-            
-        except Exception as e:
-            return f"Error extracting OpenFloor research result: {str(e)}"
+            self.show_research_error(function_name, query_param, error_msg, requesting_model_name)
+            return f"OpenFloor research error: {error_msg}"
     
     def show_research_starting(self, function: str, query: str):
         """Invite specific research agent to join conversation"""
@@ -1036,7 +1218,6 @@ class VisualConsensusEngine:
                 "showBubbles": existing_bubbles
             })
 
-
     def show_research_complete(self, function: str, query: str, result_length: int, requesting_model_name: str = None):
         """Show research complete and dismiss the specific agent"""
         function_to_agent = {
@@ -1077,17 +1258,6 @@ class VisualConsensusEngine:
             # Use the existing dismiss method
             self.dismiss_research_agent(agent_name, "current_conversation")
 
-    def estimate_research_time(self, function_name: str) -> str:
-        """Provide time estimates for different research functions"""
-        time_estimates = {
-            "search_web": "30-60 seconds",
-            "search_wikipedia": "15-30 seconds", 
-            "search_academic": "2-5 minutes",
-            "search_technology_trends": "1-2 minutes",
-            "search_financial_data": "1-3 minutes"
-        }
-        return time_estimates.get(function_name, "1-3 minutes")
-
     def show_research_error(self, function: str, query: str, error: str, requesting_model_name: str = None):
         """Show research error from the specific agent and dismiss it"""
         function_to_agent = {
@@ -1128,55 +1298,6 @@ class VisualConsensusEngine:
             # Dismiss the research agent since research failed
             self.dismiss_research_agent(agent_name, "current_conversation")
 
-    def update_research_progress(self, progress_text: str, function_name: str = None):
-        """Update research progress from the specific active research agent"""
-        
-        # Map function to agent to identify which agent is providing progress
-        function_to_agent = {
-            "search_web": "web_search",
-            "search_wikipedia": "wikipedia", 
-            "search_academic": "arxiv",
-            "search_technology_trends": "github",
-            "search_financial_data": "sec_edgar"
-        }
-        
-        # Determine which research agent is active
-        if function_name and function_name in function_to_agent:
-            agent_name = function_to_agent[function_name]
-            research_agent = self.research_agents[agent_name]
-            agent_display_name = research_agent.manifest.identification.conversationalName
-        else:
-            # Fallback to generic research agent if function not specified
-            agent_display_name = "Research Agent"
-        
-        session = get_or_create_session_state(self.session_id)
-        current_state = session["roundtable_state"]
-        all_messages = list(current_state.get("messages", []))
-        participants = current_state.get("participants", [])
-        
-        # Ensure the specific research agent is visible
-        existing_bubbles = list(current_state.get("showBubbles", []))
-        if agent_display_name not in existing_bubbles:
-            existing_bubbles.append(agent_display_name)
-        
-        # Add progress message from the specific agent
-        progress_message = {
-            "speaker": agent_display_name,
-            "text": f"🔄 {progress_text}",
-            "type": "research_progress"
-        }
-        all_messages.append(progress_message)
-        
-        # Keep the agent active and visible during progress
-        self.update_visual_state({
-            "participants": participants,
-            "messages": all_messages,
-            "currentSpeaker": agent_display_name,
-            "thinking": [],
-            "showBubbles": existing_bubbles
-        })
-        time.sleep(0.3)
-
     def invite_research_agent(self, agent_name: str, conversation_id: str, requesting_expert: str):
         """Invite a research agent to join the conversation visually"""
         
@@ -1483,6 +1604,32 @@ class VisualConsensusEngine:
         if not available_models:
             return "❌ No AI models available"
         
+        # Add AI experts to the conversation
+        for model in available_models:
+            expert_speaker_uri = f"tag:consilium.ai,2025:{model}"
+            if self.conversation_id in self.floor_manager.active_conversations:
+                conversation_state = self.floor_manager.active_conversations[self.conversation_id]
+                if expert_speaker_uri not in conversation_state['participants']:
+                    conversation_state['participants'].append(expert_speaker_uri)
+        
+        # Send conversation start event through floor
+        start_envelope = Envelope(
+            conversation=Conversation(id=self.conversation_id),
+            sender=Sender(speakerUri="tag:consilium.ai,2025:session-manager"),
+            events=[
+                ContextEvent(
+                    parameters={
+                        "session_start": True,
+                        "question": question,
+                        "protocol": decision_protocol,
+                        "participants": [self.models[model]['name'] for model in available_models]
+                    }
+                )
+            ]
+        )
+        
+        self.floor_manager.route_message(start_envelope)
+        
         model_roles = self.assign_roles(available_models, role_assignment)
         
         visual_participant_names = [self.models[model]['name'] for model in available_models]
@@ -2364,6 +2511,38 @@ with gr.Blocks(title="🎭 Consilium: Multi-AI Expert Consensus Platform - OFP (
         - Creates interesting chains of reasoning and idea evolution
         - Can lead to surprising consensus emergence
         - **Use when:** You want to see how ideas build and evolve
+        
+        ## 🏛️ **OpenFloor Protocol Integration**
+        
+        This implementation uses the [Open Floor Protocol (OFP)](https://github.com/open-voice-interoperability/openfloor-docs) for:
+        
+        ### 🔄 **Inter-Agent Communication**
+        - **Envelope Structure**: Standard JSON format for agent messaging
+        - **Event Types**: Utterance, Context, Invite, Bye events
+        - **Conversation Management**: Persistent conversation threads
+        - **Agent Discovery**: Manifest-based capability matching
+        
+        ### 🔍 **Research Agent Architecture**
+        - **Dedicated Services**: Each research tool runs as an independent OpenFloor agent
+        - **HTTP Endpoints**: `/openfloor/conversation` and `/openfloor/manifest`
+        - **Proper Invitation Flow**: Agents are invited to join conversations for specific research tasks
+        - **Context Events**: Research results are delivered via standardized context events
+        
+        ### 🏛️ **Floor Manager**
+        - **Central Coordination**: Routes messages between all agents
+        - **Conversation State**: Maintains participant lists and message history
+        - **Visual Integration**: Updates UI based on OpenFloor conversation events
+        - **Session Isolation**: Each user session has its own conversation context
+        
+        ### 📋 **Event Flow Example**
+        1. **AI Expert** needs research → generates function call
+        2. **Floor Manager** invites **Research Agent** to conversation
+        3. **Research Agent** joins and receives query via UtteranceEvent
+        4. **Research Agent** performs search and responds with ContextEvent
+        5. **Floor Manager** routes result back to requesting expert
+        6. **Research Agent** sends ByeEvent and leaves conversation
+        
+        This architecture ensures true OpenFloor compliance while maintaining the visual roundtable experience.
         """)
 
 # Launch configuration