Update app.py

app.py

@@ -14,6 +14,9 @@ import queue
 import uuid
 from gradio_consilium_roundtable import consilium_roundtable
 from research_tools.base_tool import BaseTool
+from openfloor.OpenFloorResearchAgent import OpenFloorResearchAgent
+from openfloor.OpenFloorAgentServer import OpenFloorAgentServer
+from openfloor.OpenFloorManager import OpenFloorManager
 from openfloor import *
 from openfloor.manifest import *
 from openfloor.envelope import *
@@ -43,601 +46,6 @@ avatar_images = {
     "Wikipedia Research Agent": "https://upload.wikimedia.org/wikipedia/commons/thumb/8/80/Wikipedia-logo-v2.svg/103px-Wikipedia-logo-v2.svg.png"
 }
 
-class OpenFloorResearchAgent:
-    """Wrap research tools as independent OpenFloor agents"""
-    
-    def __init__(self, tool: BaseTool, port: int = None):
-        self.tool = tool
-        self.port = port
-        self.manifest = self._create_manifest()
-        self.active_conversations = {}
-        
-    def _create_manifest(self) -> Manifest:
-        """Create OpenFloor manifest for this research agent"""
-        speaker_uri = f"tag:research.consilium,2025:{self.tool.name.lower().replace(' ', '-')}-agent"
-        
-        # Tool-specific keyphrases and capabilities
-        tool_configs = {
-            'Web Search': {
-                'keyphrases': ['web', 'search', 'current', 'news', 'latest', 'recent'],
-                'synopsis': 'Real-time web search for current information and trends'
-            },
-            'Wikipedia': {
-                'keyphrases': ['facts', 'encyclopedia', 'history', 'knowledge', 'definition'],
-                'synopsis': 'Authoritative encyclopedia research and factual verification'
-            },
-            'arXiv': {
-                'keyphrases': ['academic', 'research', 'papers', 'science', 'study'],
-                'synopsis': 'Academic research papers and scientific literature analysis'
-            },
-            'GitHub': {
-                'keyphrases': ['technology', 'code', 'development', 'programming', 'trends'],
-                'synopsis': 'Technology adoption trends and software development analysis'
-            },
-            'SEC EDGAR': {
-                'keyphrases': ['financial', 'company', 'earnings', 'sec', 'filings'],
-                'synopsis': 'Corporate financial data and SEC regulatory filings research'
-            }
-        }
-        
-        config = tool_configs.get(self.tool.name, {
-            'keyphrases': ['research', 'data'],
-            'synopsis': self.tool.description
-        })
-        
-        return Manifest(
-            identification=Identification(
-                speakerUri=speaker_uri,
-                serviceUrl=f"http://localhost:{self.port}/openfloor" if self.port else None,
-                conversationalName=f"{self.tool.name} Research Agent",
-                organization="Consilium Research Division",
-                role="Research Specialist",
-                synopsis=config['synopsis']
-            ),
-            capabilities=[
-                Capability(
-                    keyphrases=config['keyphrases'],
-                    descriptions=[self.tool.description],
-                    languages=["en-us"]
-                )
-            ]
-        )
-    
-    def handle_utterance_event(self, envelope: Envelope) -> Envelope:
-        """Handle research requests from AI experts"""
-        print(f"🔍 DEBUG: {self.tool.name} - Starting handle_utterance_event")
-        
-        # Extract the query from the utterance
-        for event in envelope.events:
-            if hasattr(event, 'eventType') and event.eventType == 'utterance':
-                dialog_event = event.parameters.get('dialogEvent')
-                
-                if dialog_event and isinstance(dialog_event, dict):
-                    # dialog_event is a dict, not an object - use dict access
-                    features = dialog_event.get('features')
-                    print(f"🔍 DEBUG: features: {features}")
-                    
-                    if features and 'text' in features:
-                        text_feature = features['text']
-                        print(f"🔍 DEBUG: text_feature: {text_feature}")
-                        
-                        if 'tokens' in text_feature:
-                            tokens = text_feature['tokens']
-                            query_text = ' '.join([token.get('value', '') for token in tokens])
-                            
-                            print(f"🔍 DEBUG: {self.tool.name} received query: '{query_text}'")
-                            
-                            # Perform the research
-                            import time
-                            start_time = time.time()
-                            research_result = self.tool.search(query_text)
-                            end_time = time.time()
-                            
-                            print(f"🔍 DEBUG: {self.tool.name} completed in {end_time - start_time:.2f}s")
-                            print(f"🔍 DEBUG: Result length: {len(research_result)} chars")
-                            print(f"🔍 DEBUG: Result preview: {research_result[:200]}...")
-                            
-                            # Create response envelope
-                            return self._create_response_envelope(envelope, research_result, query_text)
-        
-        return self._create_error_response(envelope, "Could not extract query from request")
-    
-    def _create_response_envelope(self, original_envelope: Envelope, research_result: str, query: str) -> Envelope:
-        """Create OpenFloor response envelope with research results"""
-        
-        # Create response dialog event
-        response_dialog = DialogEvent(
-            speakerUri=self.manifest.identification.speakerUri,
-            features={
-                "text": TextFeature(values=[research_result])
-            }
-        )
-        
-        # Create context with research metadata
-        research_context = ContextEvent(
-            parameters={
-                "research_tool": self.tool.name,
-                "query": query,
-                "source": self.tool.name.lower().replace(' ', '_'),
-                "confidence": self._assess_result_confidence(research_result),
-                "timestamp": datetime.now().isoformat()
-            }
-        )
-        
-        # Create response envelope
-        response_envelope = Envelope(
-            conversation=original_envelope.conversation,
-            sender=Sender(speakerUri=self.manifest.identification.speakerUri),
-            events=[
-                UtteranceEvent(dialogEvent=response_dialog),
-                research_context
-            ]
-        )
-        
-        return response_envelope
-    
-    def _assess_result_confidence(self, result: str) -> float:
-        """Assess confidence in research result quality"""
-        if not result or len(result) < 50:
-            return 0.3
-        
-        quality_indicators = [
-            (len(result) > 500, 0.2),  # Substantial content
-            (any(year in result for year in ['2024', '2025']), 0.2),  # Recent data
-            (result.count('\n') > 5, 0.1),  # Well-structured
-            ('error' not in result.lower(), 0.3),  # No errors
-            (any(indicator in result.lower() for indicator in ['data', 'study', 'research']), 0.2)  # Authoritative
-        ]
-        
-        confidence = 0.5  # Base confidence
-        for condition, boost in quality_indicators:
-            if condition:
-                confidence += boost
-        
-        return min(1.0, confidence)
-    
-    def _create_error_response(self, original_envelope: Envelope, error_msg: str) -> Envelope:
-        """Create error response envelope"""
-        error_dialog = DialogEvent(
-            speakerUri=self.manifest.identification.speakerUri,
-            features={
-                "text": TextFeature(values=[f"Research error: {error_msg}"])
-            }
-        )
-        
-        return Envelope(
-            conversation=original_envelope.conversation,
-            sender=Sender(speakerUri=self.manifest.identification.speakerUri),
-            events=[UtteranceEvent(dialogEvent=error_dialog)]
-        )
-    
-    def join_conversation(self, conversation_id: str) -> bool:
-        """Join a conversation as an active research agent"""
-        self.active_conversations[conversation_id] = {
-            'joined_at': datetime.now(),
-            'status': 'active'
-        }
-        return True
-    
-    def leave_conversation(self, conversation_id: str) -> bool:
-        """Leave a conversation"""
-        if conversation_id in self.active_conversations:
-            del self.active_conversations[conversation_id]
-        return True
-    
-    def get_manifest(self) -> Manifest:
-        """Return the OpenFloor manifest for this research agent"""
-        return self.manifest
-
-
-class OpenFloorAgentServer:
-    """Run a research agent as an actual OpenFloor service"""
-    
-    def __init__(self, research_agent: OpenFloorResearchAgent, port: int):
-        self.agent = research_agent
-        self.port = port
-        self.app = None
-        
-    def start_server(self):
-        """Start the OpenFloor agent server"""
-        from flask import Flask, request, jsonify
-        
-        app = Flask(f"research-agent-{self.port}")
-        
-        @app.route('/openfloor/conversation', methods=['POST'])
-        def handle_conversation():
-            try:
-                print(f"🔍 DEBUG: Flask route called for agent {self.agent.tool.name}")
-                
-                # Parse incoming OpenFloor envelope
-                envelope_data = request.get_json()
-                print(f"🔍 DEBUG: Received envelope data: {str(envelope_data)[:200]}...")
-                
-                envelope = Envelope.from_json(json.dumps(envelope_data))
-                print(f"🔍 DEBUG: Envelope parsed successfully")
-                
-                # Process the request
-                print(f"🔍 DEBUG: Calling handle_utterance_event...")
-                response_envelope = self.agent.handle_utterance_event(envelope)
-                print(f"🔍 DEBUG: handle_utterance_event completed")
-                
-                # Return OpenFloor response
-                response_json = json.loads(response_envelope.to_json())
-                print(f"🔍 DEBUG: Returning response: {str(response_json)[:200]}...")
-                return jsonify(response_json)
-                
-            except Exception as e:
-                print(f"🔍 DEBUG: Exception in Flask route: {e}")
-                import traceback
-                traceback.print_exc()
-                
-                error_response = self.agent._create_error_response(
-                    envelope if 'envelope' in locals() else None, 
-                    str(e)
-                )
-                return jsonify(json.loads(error_response.to_json())), 500
-        
-        @app.route('/openfloor/manifest', methods=['GET'])
-        def get_manifest():
-            """Return agent manifest"""
-            return jsonify(json.loads(self.agent.manifest.to_json()))
-        
-        # Start server in background thread
-        import threading
-        server_thread = threading.Thread(
-            target=lambda: app.run(host='localhost', port=self.port, debug=False)
-        )
-        server_thread.daemon = True
-        server_thread.start()
-        
-        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 - 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"""
-        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()}"
-        
-        # 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] = {
-            '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 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_state = self.active_conversations[conversation_id]
-        conversation = conversation_state['conversation']
-        target_agent = self.agent_registry[target_speaker_uri]
-        
-        # Create proper OpenFloor InviteEvent
-        invite_envelope = Envelope(
-            conversation=conversation,
-            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_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 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_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 and target_uri != sender_uri:
-                    target_agent = self.agent_registry[target_uri]
-                    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 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 routed_successfully
-    
-    def _send_to_agent(self, agent_url: str, envelope: Envelope) -> bool:
-        """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:
-            # Fix: Use proper OpenFloor endpoint
-            response = requests.post(
-                f"{agent_url}/openfloor/conversation",  # ✅ Fixed endpoint
-                json=json.loads(envelope.to_json()),
-                headers={'Content-Type': 'application/json'},
-                timeout=30
-            )
-            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}")
-                print(f"🏛️ Floor Manager: Response: {response.text}")
-            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 not self.visual_callback or conversation_id not in self.active_conversations:
-            return
-            
-        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
-            
-            # 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
-            
-            # 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_record['timestamp'].strftime('%H:%M:%S'),
-                                    'type': 'utterance'
-                                })
-                    
-                    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"""
-        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:
-                print(f"🏛️ Floor Manager: Error handling conversation: {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:
-                print(f"🏛️ Floor Manager: Error inviting agent: {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"""