Update app.py

app.py

@@ -202,6 +202,85 @@ class OpenFloorResearchAgent:
         """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:
+                # Parse incoming OpenFloor envelope
+                envelope_data = request.get_json()
+                envelope = Envelope.from_json(json.dumps(envelope_data))
+                
+                # Process the request
+                response_envelope = self.agent.handle_utterance_event(envelope)
+                
+                # Return OpenFloor response
+                return jsonify(json.loads(response_envelope.to_json()))
+                
+            except Exception as e:
+                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
+
+def start_openfloor_research_agents(self):
+    """Start all research agents as proper OpenFloor services"""
+    
+    agent_ports = {
+        'web_search': 8001,
+        'wikipedia': 8002,
+        'arxiv': 8003, 
+        'github': 8004,
+        'sec_edgar': 8005
+    }
+    
+    self.agent_servers = {}
+    
+    for agent_name, port in agent_ports.items():
+        agent = self.research_agents[agent_name]
+        server = OpenFloorAgentServer(agent, port)
+        
+        if server.start_server():
+            self.agent_servers[agent_name] = {
+                'server': server,
+                'port': port,
+                'url': f"http://localhost:{port}/openfloor/conversation",
+                'manifest_url': f"http://localhost:{port}/openfloor/manifest"
+            }
+        
+        # Small delay between starting servers
+        time.sleep(0.5)
+
 def get_session_id(request: gr.Request = None) -> str:
     """Generate or retrieve session ID"""
     if request and hasattr(request, 'session_hash'):
@@ -273,6 +352,8 @@ class VisualConsensusEngine:
             'sec_edgar': OpenFloorResearchAgent(SECSearchTool(), port=8005)
         }
         
+        self.start_openfloor_research_agents()
+        
         # Available research agents for discovery
         self.available_research_agents = list(self.research_agents.keys())
         
@@ -540,7 +621,7 @@ class VisualConsensusEngine:
 
 
     def _execute_research_function(self, function_name: str, arguments: dict, requesting_model_name: str = None) -> str:
-        """Execute research function using proper OpenFloor protocol messaging"""
+        """Execute research function using proper OpenFloor HTTP protocol"""
         
         query_param = arguments.get("query") or arguments.get("topic") or arguments.get("technology") or arguments.get("company")
         
@@ -562,56 +643,58 @@ class VisualConsensusEngine:
             
             if function_name in function_to_agent:
                 agent_name = function_to_agent[function_name]
-                research_agent = self.research_agents[agent_name]
                 
-                self.update_research_progress(f"Sending OpenFloor research request...")
+                if agent_name not in self.agent_servers:
+                    return f"Research agent '{agent_name}' not available"
                 
-                # Create OpenFloor conversation and envelope
-                conversation = Conversation()
+                agent_server = self.agent_servers[agent_name]
+                
+                self.update_research_progress(f"Sending HTTP request to OpenFloor agent...")
                 
-                # Create research request utterance
+                # 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])
-                    }
+                    features={"text": TextFeature(values=[query_param])}
                 )
                 
-                # Create request envelope using OpenFloor protocol
                 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=research_agent.manifest.identification.speakerUri)
+                            to=To(speakerUri=self.research_agents[agent_name].manifest.identification.speakerUri)
                         )
                     ]
                 )
                 
-                self.update_research_progress(f"Processing research via OpenFloor protocol...")
-                
-                # Send request to research agent using OpenFloor protocol
-                response_envelope = research_agent.handle_utterance_event(request_envelope)
-                
-                # Extract result from OpenFloor response
-                result = self._extract_research_result_from_envelope(response_envelope)
+                # Send HTTP POST request to OpenFloor agent service
+                response = self._send_openfloor_request(agent_server['url'], request_envelope)
                 
-                self.update_research_progress(f"OpenFloor research complete - found {len(result)} characters")
+                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"
                 
             elif function_name == "multi_source_research":
-                self.update_research_progress("Initializing multi-source OpenFloor research...")
+                self.update_research_progress("Starting multi-agent OpenFloor HTTP research...")
                 
-                # Use multiple research agents via OpenFloor protocol
+                # Use multiple agents via HTTP
                 results = []
                 agents_to_use = ["web_search", "wikipedia", "arxiv"]
                 
                 for i, agent_name in enumerate(agents_to_use, 1):
-                    self.update_research_progress(f"Phase {i}: OpenFloor request to {agent_name.replace('_', ' ').title()}...")
+                    if agent_name not in self.agent_servers:
+                        continue
+                        
+                    self.update_research_progress(f"Phase {i}: HTTP request to {agent_name.replace('_', ' ').title()}...")
+                    
                     try:
-                        research_agent = self.research_agents[agent_name]
+                        agent_server = self.agent_servers[agent_name]
                         
-                        # Create OpenFloor request for this agent
+                        # Create OpenFloor request
                         conversation = Conversation()
                         request_dialog = DialogEvent(
                             speakerUri=f"tag:consilium.ai,2025:{requesting_model_name or 'expert'}",
@@ -623,27 +706,28 @@ class VisualConsensusEngine:
                             sender=Sender(speakerUri=f"tag:consilium.ai,2025:{requesting_model_name or 'expert'}"),
                             events=[UtteranceEvent(
                                 dialogEvent=request_dialog,
-                                to=To(speakerUri=research_agent.manifest.identification.speakerUri)
+                                to=To(speakerUri=self.research_agents[agent_name].manifest.identification.speakerUri)
                             )]
                         )
                         
-                        # Get OpenFloor response
-                        response_envelope = research_agent.handle_utterance_event(request_envelope)
-                        agent_result = self._extract_research_result_from_envelope(response_envelope)
+                        # Send HTTP request
+                        response = self._send_openfloor_request(agent_server['url'], request_envelope)
                         
-                        if agent_result and len(agent_result) > 100:
-                            results.append(f"**{agent_name.replace('_', ' ').title()} Results:**\n{agent_result}")
-                            
+                        if response:
+                            agent_result = self._extract_research_result_from_envelope(response)
+                            if agent_result and len(agent_result) > 100:
+                                results.append(f"**{agent_name.replace('_', ' ').title()} Results:**\n{agent_result}")
+                                
                     except Exception as e:
-                        self.update_research_progress(f"Phase {i}: {agent_name} OpenFloor error - {str(e)[:50]}...")
+                        self.update_research_progress(f"Phase {i}: {agent_name} HTTP error - {str(e)[:50]}...")
                         continue
                 
                 # Combine results
                 if results:
-                    result = f"**Multi-Source OpenFloor Research for: {query_param}**\n\n" + "\n\n---\n\n".join(results)
-                    self.update_research_progress(f"Multi-source OpenFloor research complete - synthesized {len(result)} characters")
+                    result = f"**Multi-Source OpenFloor HTTP Research for: {query_param}**\n\n" + "\n\n---\n\n".join(results)
+                    self.update_research_progress(f"Multi-source HTTP research complete - {len(result)} characters")
                 else:
-                    result = f"Multi-source OpenFloor research for '{query_param}' encountered errors across all agents."
+                    result = f"Multi-source HTTP research failed for '{query_param}'"
                     
             else:
                 result = f"Unknown research function: {function_name}"
@@ -658,7 +742,35 @@ class VisualConsensusEngine:
             error_msg = str(e)
             if query_param:
                 self.show_research_error(function_name, query_param, error_msg, requesting_model_name)
-            return f"OpenFloor research error: {error_msg}"
+            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
+            
+            # Serialize envelope to JSON
+            envelope_json = json.loads(envelope.to_json())
+            
+            # Send HTTP POST request
+            response = requests.post(
+                agent_url,
+                json=envelope_json,
+                headers={'Content-Type': 'application/json'},
+                timeout=30
+            )
+            
+            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"Error sending OpenFloor HTTP request: {e}")
+            return None
     
     def _extract_research_result_from_envelope(self, envelope: Envelope) -> str:
         """Extract research result from OpenFloor response envelope"""